@iowarp/clio-coder 0.4.8 → 0.4.9

package/dist/{chunk-5C2OQHLR.js → chunk-H72DCH3E.js}

@@ -1,7 +1,8 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
-  compareCodepoints
-} from "./chunk-B6UM3OZC.js";
+  compareCodepoints,
+  normalizeNumericTolerance
+} from "./chunk-2KUBKL63.js";
 import {
   isProjectVerifierCheckId
 } from "./chunk-M4KFUXS7.js";
@@ -11,204 +12,12 @@ import {
 import {
   SAFE_EXEC_DEFAULT_TIMEOUT_MS,
   resolveSafeCwd
-} from "./chunk-GJ24ODAX.js";
+} from "./chunk-XTQ7MEJG.js";
 import {
   __toESM,
   init_esm_shims
 } from "./chunk-ECBHH7LU.js";
 
-// src/tools/verify/numeric.ts
-init_esm_shims();
-var NUMERIC_PAYLOAD_CAPS = Object.freeze({
-  keys: 4096,
-  elements: 1e6
-});
-function normalizeNumericTolerance(value) {
-  if (value === null || typeof value !== "object" || Array.isArray(value)) {
-    return new Error("tolerance must be an object with relative, absolute, or ulp");
-  }
-  const record = value;
-  const unknown = Object.keys(record).filter((key) => key !== "relative" && key !== "absolute" && key !== "ulp");
-  if (unknown.length > 0) return new Error(`tolerance has unknown field(s): ${unknown.sort().join(", ")}`);
-  const tolerance = {};
-  for (const kind of ["relative", "absolute"]) {
-    if (!Object.hasOwn(record, kind)) continue;
-    const bound = record[kind];
-    if (typeof bound !== "number" || !Number.isFinite(bound) || bound < 0) {
-      return new Error(`tolerance.${kind} must be a finite non-negative number`);
-    }
-    tolerance[kind] = bound;
-  }
-  if (Object.hasOwn(record, "ulp")) {
-    const bound = record.ulp;
-    if (typeof bound !== "number" || !Number.isInteger(bound) || bound < 0) {
-      return new Error("tolerance.ulp must be a non-negative integer");
-    }
-    tolerance.ulp = bound;
-  }
-  if (tolerance.relative === void 0 && tolerance.absolute === void 0 && tolerance.ulp === void 0) {
-    return new Error("tolerance must name at least one of relative, absolute, or ulp");
-  }
-  return tolerance;
-}
-var ORDERED_VIEW = new DataView(new ArrayBuffer(8));
-function orderedBits(value) {
-  ORDERED_VIEW.setFloat64(0, value);
-  const bits = ORDERED_VIEW.getBigInt64(0);
-  return bits < 0n ? -(bits & 0x7fffffffffffffffn) : bits;
-}
-function ulpDistance(actual, expected) {
-  if (!Number.isFinite(actual) || !Number.isFinite(expected)) return Number.POSITIVE_INFINITY;
-  const distance = orderedBits(actual) - orderedBits(expected);
-  const magnitude = distance < 0n ? -distance : distance;
-  return magnitude > BigInt(Number.MAX_SAFE_INTEGER) ? Number.POSITIVE_INFINITY : Number(magnitude);
-}
-function parseNumericPayload(text, label) {
-  let parsed;
-  try {
-    parsed = JSON.parse(text);
-  } catch (error) {
-    return new Error(`${label} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
-  }
-  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-    return new Error(`${label} must be a JSON object of string -> number | number[]`);
-  }
-  const record = parsed;
-  const keys = Object.keys(record);
-  if (keys.length > NUMERIC_PAYLOAD_CAPS.keys)
-    return new Error(`${label} exceeds the ${NUMERIC_PAYLOAD_CAPS.keys}-key cap`);
-  const entries = [];
-  let elements = 0;
-  for (const key of keys) {
-    const value = record[key];
-    if (typeof value === "number") {
-      entries.push([key, value]);
-      elements += 1;
-    } else if (Array.isArray(value) && value.every((entry) => typeof entry === "number")) {
-      entries.push([key, [...value]]);
-      elements += value.length;
-    } else {
-      return new Error(`${label}.${key} must be a number or an array of numbers`);
-    }
-    if (elements > NUMERIC_PAYLOAD_CAPS.elements) {
-      return new Error(`${label} exceeds the ${NUMERIC_PAYLOAD_CAPS.elements}-element cap`);
-    }
-  }
-  return Object.fromEntries(entries);
-}
-function deviation(actual, expected, index) {
-  const finite = Number.isFinite(actual) && Number.isFinite(expected);
-  const absolute = finite ? Math.abs(actual - expected) : Number.POSITIVE_INFINITY;
-  let relative = !finite ? null : expected === 0 ? absolute === 0 ? 0 : null : absolute / Math.abs(expected);
-  if (finite && !Number.isFinite(absolute)) {
-    relative = Math.abs(actual / expected - 1);
-  }
-  return {
-    ...index !== void 0 ? { index } : {},
-    actual,
-    expected,
-    absolute,
-    relative,
-    ulp: finite ? ulpDistance(actual, expected) : null
-  };
-}
-function violatedTolerances(item, tolerance) {
-  const failed = [];
-  if (tolerance.relative !== void 0 && (item.relative === null || item.relative > tolerance.relative)) {
-    failed.push("relative");
-  }
-  if (tolerance.absolute !== void 0 && item.absolute > tolerance.absolute) failed.push("absolute");
-  if (tolerance.ulp !== void 0 && (item.ulp === null || item.ulp > tolerance.ulp)) failed.push("ulp");
-  return failed;
-}
-function formatNumber(value) {
-  return Number.isFinite(value) ? value.toPrecision(6).replace(/\.?0+(e|$)/u, "$1") : String(value);
-}
-function describeDeviation(item) {
-  const where = item.index === void 0 ? "" : `[${item.index}]`;
-  const relative = item.relative === null ? "undefined" : formatNumber(item.relative);
-  const ulp = item.ulp === null ? "undefined" : String(item.ulp);
-  return `${where} actual=${formatNumber(item.actual)} expected=${formatNumber(item.expected)} abs=${formatNumber(item.absolute)} rel=${relative} ulp=${ulp}`;
-}
-function compareElements(key, actual, expected, tolerance) {
-  let worst;
-  let worstFailed = [];
-  for (let index = 0; index < expected.length; index += 1) {
-    const item = deviation(
-      actual[index],
-      expected[index],
-      expected.length === 1 && actual.length === 1 ? void 0 : index
-    );
-    const failed = !Number.isFinite(item.actual) || !Number.isFinite(item.expected) ? ["not-finite"] : violatedTolerances(item, tolerance);
-    const worse = worst === void 0 || failed.length > 0 && worstFailed.length === 0 || failed.length > 0 === worstFailed.length > 0 && item.absolute > worst.absolute;
-    if (worse) {
-      worst = item;
-      worstFailed = failed;
-    }
-  }
-  if (worst === void 0) return { key, passed: true, failed: [], detail: `${key}: empty array matches` };
-  const passed = worstFailed.length === 0;
-  return {
-    key,
-    passed,
-    failed: worstFailed,
-    worst,
-    detail: passed ? `${key}: within tolerance, worst${describeDeviation(worst)}` : `${key}: failed ${worstFailed.join(", ")} at worst${describeDeviation(worst)}`
-  };
-}
-function compareNumeric(actual, reference, tolerance) {
-  const keys = [.../* @__PURE__ */ new Set([...Object.keys(reference), ...Object.keys(actual)])].sort();
-  const reports = [];
-  for (const key of keys) {
-    const got = actual[key];
-    const want = reference[key];
-    if (got === void 0) {
-      reports.push({ key, passed: false, failed: ["missing-actual"], detail: `${key}: missing from the command output` });
-      continue;
-    }
-    if (want === void 0) {
-      reports.push({ key, passed: false, failed: ["missing-reference"], detail: `${key}: missing from the reference` });
-      continue;
-    }
-    if (Array.isArray(got) !== Array.isArray(want)) {
-      reports.push({
-        key,
-        passed: false,
-        failed: ["shape-mismatch"],
-        detail: `${key}: ${Array.isArray(got) ? "array" : "scalar"} in the command output but ${Array.isArray(want) ? "array" : "scalar"} in the reference`
-      });
-      continue;
-    }
-    const gotList = Array.isArray(got) ? got : [got];
-    const wantList = Array.isArray(want) ? want : [want];
-    if (gotList.length !== wantList.length) {
-      reports.push({
-        key,
-        passed: false,
-        failed: ["length-mismatch"],
-        detail: `${key}: ${gotList.length} element(s) in the command output but ${wantList.length} in the reference`
-      });
-      continue;
-    }
-    reports.push(compareElements(key, gotList, wantList, tolerance));
-  }
-  const failedKeys = reports.filter((report) => !report.passed).map((report) => report.key);
-  const passed = failedKeys.length === 0;
-  return {
-    kind: "numeric-compare",
-    passed,
-    tolerance: { ...tolerance },
-    keys: reports,
-    failedKeys,
-    summary: passed ? `numeric-compare passed: ${reports.length} key(s) within tolerance` : `numeric-compare failed: ${failedKeys.length} of ${reports.length} key(s) out of tolerance (${failedKeys.join(", ")})`
-  };
-}
-function renderNumericReport(report) {
-  const lines = [report.summary, `tolerance: ${JSON.stringify(report.tolerance)}`];
-  for (const key of report.keys) lines.push(`- ${key.detail}`);
-  return lines.join("\n");
-}
-
 // src/tools/verify/catalog.ts
 init_esm_shims();
 var import_yaml = __toESM(require_dist(), 1);
@@ -217,7 +26,18 @@ import path from "node:path";
 
 // src/tools/verify/perf.ts
 init_esm_shims();
-var PERF_BASELINE_VERSION = 1;
+import { arch, cpus, hostname, platform, totalmem } from "node:os";
+var PERF_ENVIRONMENT_FIELDS = [
+  "hostname",
+  "platform",
+  "arch",
+  "cpuModel",
+  "cpuCount",
+  "totalMemoryBytes",
+  "nodeVersion"
+];
+var PERF_BASELINE_VERSION = 2;
+var SUPPORTED_BASELINE_VERSIONS = [1, PERF_BASELINE_VERSION];
 function normalizePerfBudget(value) {
   if (value === null || typeof value !== "object" || Array.isArray(value)) {
     return new Error("budget must be an object with wallTimeMs");
@@ -249,6 +69,44 @@ function normalizePerfTolerance(value, location) {
   }
   return { relative: record.relative };
 }
+function capturePerfEnvironment() {
+  const processors = cpus();
+  return {
+    hostname: hostname(),
+    platform: platform(),
+    arch: arch(),
+    cpuModel: processors[0]?.model.trim() ?? "unknown",
+    cpuCount: processors.length,
+    totalMemoryBytes: totalmem(),
+    nodeVersion: process.version
+  };
+}
+function parsePerfEnvironment(value, label) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return new Error(`${label} must be an object describing the recording host`);
+  }
+  const record = value;
+  const unknown = Object.keys(record).filter((key) => !PERF_ENVIRONMENT_FIELDS.includes(key));
+  if (unknown.length > 0) return new Error(`${label} has unknown field(s): ${unknown.sort().join(", ")}`);
+  for (const field of ["hostname", "platform", "arch", "cpuModel", "nodeVersion"]) {
+    if (typeof record[field] !== "string") return new Error(`${label}.${field} must be a string`);
+  }
+  if (typeof record.cpuCount !== "number" || !Number.isInteger(record.cpuCount) || record.cpuCount < 0) {
+    return new Error(`${label}.cpuCount must be a non-negative integer`);
+  }
+  if (typeof record.totalMemoryBytes !== "number" || !Number.isFinite(record.totalMemoryBytes) || record.totalMemoryBytes < 0) {
+    return new Error(`${label}.totalMemoryBytes must be a non-negative number`);
+  }
+  return {
+    hostname: record.hostname,
+    platform: record.platform,
+    arch: record.arch,
+    cpuModel: record.cpuModel,
+    cpuCount: record.cpuCount,
+    totalMemoryBytes: record.totalMemoryBytes,
+    nodeVersion: record.nodeVersion
+  };
+}
 function parsePerfBaseline(text, label) {
   let parsed;
   try {
@@ -260,28 +118,58 @@ function parsePerfBaseline(text, label) {
     return new Error(`${label} must be a JSON object with wallTimeMs`);
   }
   const record = parsed;
+  if (Object.hasOwn(record, "version")) {
+    if (typeof record.version !== "number" || !SUPPORTED_BASELINE_VERSIONS.includes(record.version)) {
+      return new Error(`${label}.version must be one of ${SUPPORTED_BASELINE_VERSIONS.join(", ")}`);
+    }
+  }
   if (typeof record.wallTimeMs !== "number" || !Number.isFinite(record.wallTimeMs) || record.wallTimeMs <= 0) {
     return new Error(`${label}.wallTimeMs must be a positive number of milliseconds`);
   }
   const baseline = { wallTimeMs: record.wallTimeMs };
   if (typeof record.recordedAt === "string") baseline.recordedAt = record.recordedAt;
   if (typeof record.check === "string") baseline.check = record.check;
+  if (Object.hasOwn(record, "environment") && record.environment !== void 0) {
+    const environment = parsePerfEnvironment(record.environment, `${label}.environment`);
+    if (environment instanceof Error) return environment;
+    baseline.environment = environment;
+  }
   return baseline;
 }
 function renderPerfBaseline(input) {
   return `${JSON.stringify(
-    { version: PERF_BASELINE_VERSION, check: input.check, wallTimeMs: input.wallTimeMs, recordedAt: input.recordedAt },
+    {
+      version: PERF_BASELINE_VERSION,
+      check: input.check,
+      wallTimeMs: input.wallTimeMs,
+      recordedAt: input.recordedAt,
+      environment: {
+        hostname: input.environment.hostname,
+        platform: input.environment.platform,
+        arch: input.environment.arch,
+        cpuModel: input.environment.cpuModel,
+        cpuCount: input.environment.cpuCount,
+        totalMemoryBytes: input.environment.totalMemoryBytes,
+        nodeVersion: input.environment.nodeVersion
+      }
+    },
     null,
     2
   )}
 `;
 }
+function comparePerfEnvironments(baseline, current) {
+  if (baseline === void 0) return { baseline: null, current, differing: [] };
+  const differing = PERF_ENVIRONMENT_FIELDS.filter((field) => baseline[field] !== current[field]);
+  return { baseline, current, differing };
+}
 function evaluatePerfBudget(measuredMs, spec) {
   if (!Number.isFinite(measuredMs) || measuredMs < 0)
     return new Error("measured wall time must be a non-negative number");
   let source;
   let referenceMs;
   let relative;
+  let comparison;
   if (spec.budget !== void 0) {
     source = "budget";
     referenceMs = spec.budget.wallTimeMs;
@@ -290,6 +178,7 @@ function evaluatePerfBudget(measuredMs, spec) {
     source = "baseline";
     referenceMs = spec.baseline.wallTimeMs;
     relative = spec.relative ?? 0;
+    if (spec.environment !== void 0) comparison = comparePerfEnvironments(spec.baseline.environment, spec.environment);
   } else {
     return new Error("perf-budget needs a budget or a recorded baseline");
   }
@@ -297,6 +186,8 @@ function evaluatePerfBudget(measuredMs, spec) {
   const ratio = Math.round(measuredMs / budgetMs * 1e3) / 1e3;
   const passed = measuredMs <= budgetMs;
   const bound = `${Math.round(budgetMs)}ms (${source} ${Math.round(referenceMs)}ms${relative > 0 ? ` +${Math.round(relative * 100)}%` : ""})`;
+  const verdict = passed ? `perf-budget passed: measured ${Math.round(measuredMs)}ms within ${bound}, ratio ${ratio}` : `perf-budget failed: measured ${Math.round(measuredMs)}ms exceeds ${bound}, ratio ${ratio}`;
+  const environmentNote = comparison === void 0 ? "" : comparison.baseline === null ? "; baseline records no environment" : comparison.differing.length > 0 ? `; environment differs: ${comparison.differing.join(", ")}` : "";
   return {
     kind: "perf-budget",
     passed,
@@ -306,7 +197,8 @@ function evaluatePerfBudget(measuredMs, spec) {
     source,
     referenceMs,
     relative,
-    summary: passed ? `perf-budget passed: measured ${Math.round(measuredMs)}ms within ${bound}, ratio ${ratio}` : `perf-budget failed: measured ${Math.round(measuredMs)}ms exceeds ${bound}, ratio ${ratio}`
+    summary: `${verdict}${environmentNote}`,
+    ...comparison !== void 0 ? { environment: comparison } : {}
   };
 }
 
@@ -655,10 +547,7 @@ function packageDeclaredCheck(id, packagePath, cwd, tags) {
 }
 
 export {
-  normalizeNumericTolerance,
-  parseNumericPayload,
-  compareNumeric,
-  renderNumericReport,
+  capturePerfEnvironment,
   parsePerfBaseline,
   renderPerfBaseline,
   evaluatePerfBudget,
@@ -671,4 +560,4 @@ export {
   parseProjectVerifierCatalogText,
   packageDeclaredCheck
 };
-//# sourceMappingURL=chunk-5C2OQHLR.js.map
+//# sourceMappingURL=chunk-H72DCH3E.js.map

package/dist/{chunk-JYKUMHCQ.js → chunk-H7TXJR23.js}

@@ -2,49 +2,49 @@ import { createRequire as __clioCreateRequire } from "node:module"; const requir
 import {
   SchedulingDomainModule,
   createPromptsDomainModule
-} from "./chunk-F7Y6QTPL.js";
+} from "./chunk-NYDG4QP4.js";
 import {
   ConfigDomainModule,
   loadDomains
-} from "./chunk-2SXGG2IV.js";
+} from "./chunk-XJZEDCNT.js";
 import {
   createObservabilityDomainModule
-} from "./chunk-XTLJDC2X.js";
+} from "./chunk-2X2R3UTH.js";
+import {
+  AgentsDomainModule
+} from "./chunk-5RTEFNBP.js";
 import {
   ResourcesDomainModule
-} from "./chunk-H5DPSUBB.js";
+} from "./chunk-MTOZEQHL.js";
+import {
+  MiddlewareDomainModule
+} from "./chunk-VPWGADBG.js";
 import {
   DispatchDomainModule,
   fallbackBootstrapOutput
-} from "./chunk-5W4FRA5Q.js";
+} from "./chunk-F2YM3JY4.js";
 import {
   renderCodewikiDigest
-} from "./chunk-FB3KTE2J.js";
+} from "./chunk-IALZJE37.js";
 import {
   SessionDomainModule
-} from "./chunk-BIY22UUK.js";
+} from "./chunk-3SUDBGEI.js";
 import {
   SafetyDomainModule
-} from "./chunk-2ZWLMA3T.js";
-import {
-  AgentsDomainModule
-} from "./chunk-LZDLYSUN.js";
-import {
-  MiddlewareDomainModule
-} from "./chunk-PJ5H5B7A.js";
+} from "./chunk-GREYLTZ5.js";
 import {
   UnsupportedResponseSchemaError,
   isResponseSchemaRejection
-} from "./chunk-MWMW53WW.js";
-import {
-  declaredScopeIntent
-} from "./chunk-L4N3DWNW.js";
+} from "./chunk-4ATBOFRP.js";
 import {
   ProvidersDomainModule
-} from "./chunk-GVU4CXPJ.js";
+} from "./chunk-4HFJKRGZ.js";
 import {
   parseJsonObjectPayload
-} from "./chunk-ARRUMZ7X.js";
+} from "./chunk-I47EJPYL.js";
+import {
+  declaredScopeIntent
+} from "./chunk-L4N3DWNW.js";
 import {
   resolveGuardrail
 } from "./chunk-C27U2TYG.js";
@@ -702,4 +702,4 @@ export {
   validateInitOptions,
   bootstrapInputFromInitOptions
 };
-//# sourceMappingURL=chunk-JYKUMHCQ.js.map
+//# sourceMappingURL=chunk-H7TXJR23.js.map

package/dist/chunk-HBJQQTKM.js

@@ -0,0 +1,40 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  ToolNames
+} from "./chunk-V4XJWDHR.js";
+import {
+  StringEnum
+} from "./chunk-UIU7MGZ3.js";
+import {
+  typebox_exports
+} from "./chunk-GH5ZR6JP.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/tools/context/surface.ts
+init_esm_shims();
+var contextToolSurface = {
+  name: ToolNames.Context,
+  description: "Environment context: scope=workspace returns the git/project snapshot, scope=skills lists installed and marketplace skills or loads an installed one by name, scope=recall returns an exact persisted evicted or summarized tool result by ref; omit ref to discover historical results by query with bounded limit/offset pages. Clio's documentation and the recipe catalog are gateway capabilities (clio_docs, clio_library). For repository code and the repo's generated wiki use code_nav (mode=wiki).",
+  parameters: typebox_exports.Object({
+    scope: StringEnum(["workspace", "skills", "recall"], { description: "Context source." }),
+    query: typebox_exports.Optional(
+      typebox_exports.String({ description: "scope=recall without ref: path, tool, or ref terms; omit to list." })
+    ),
+    name: typebox_exports.Optional(typebox_exports.String({ description: "scope=skills: skill name to load; omit to list." })),
+    limit: typebox_exports.Optional(typebox_exports.Number({ description: "scope=recall: max refs (default 8, max 12)." })),
+    ref: typebox_exports.Optional(typebox_exports.String({ description: "scope=recall: exact persisted result ref; omit for discovery." })),
+    offset: typebox_exports.Optional(
+      typebox_exports.Number({ description: "scope=recall discovery: zero-based offset; follow nextOffset (default 0)." })
+    ),
+    include_tree: typebox_exports.Optional(typebox_exports.Boolean({ description: "scope=skills: list files under the skill base_dir." }))
+  }),
+  baseActionClass: "read",
+  executionMode: "parallel"
+};
+
+export {
+  contextToolSurface
+};
+//# sourceMappingURL=chunk-HBJQQTKM.js.map