omp-fabric 0.85.0

package/dist/chunks/chunk-ZNAJDPT7.js

@@ -0,0 +1,2203 @@
+import {
+  withExclusiveFileLock,
+  withExclusiveFileLockAsync
+} from "./chunk-YWEXP724.js";
+import {
+  COMPILED_SURFACE_VERSION,
+  MAX_COMPILED_SURFACE_PROPOSALS,
+  applyCompiledSurface,
+  replaySuccessfulCalls,
+  replaySuccessfulCallsAsync,
+  schemaDigest
+} from "./chunk-4A4MVZQW.js";
+import {
+  sessionDirForCwd,
+  sessionsDirRoot
+} from "./chunk-7BIA5BJN.js";
+import {
+  stableJsonHash,
+  stableJsonHashArrayAsync
+} from "./chunk-7363CD5A.js";
+import {
+  writeJsonAtomic,
+  writeJsonAtomicAsync
+} from "./chunk-KAD7UWT2.js";
+import {
+  FABRIC_EXECUTION_TRACE_KIND,
+  readFabricExecutionTraceV1
+} from "./chunk-T5ZA5YRU.js";
+
+// src/entropy/types.ts
+var ENTROPY_METRIC_VERSION = 2;
+var ENTROPY_WEIGHTS = {
+  shape: 1,
+  failureStage: 1,
+  churn: 4,
+  navigation: 4,
+  flow: 1,
+  lexicon: 2,
+  staticFreedom: 0.25
+};
+var ENTROPY_INVOCATION_STAGES = ["resolve", "prepare", "validate"];
+
+// src/entropy/fingerprint.ts
+var SIGNATURE_MAX_KEYS = 32;
+var SIGNATURE_MAX_DEPTH = 3;
+var ENUM_SATURATION_BITS = 6;
+var isPlainRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var roundMetric = (value) => {
+  const rounded = Math.round(value * 1e6) / 1e6;
+  return rounded === 0 ? 0 : rounded;
+};
+var compareCodeUnits = (left, right) => left < right ? -1 : left > right ? 1 : 0;
+var typeTag = (value, depth) => {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "arr";
+  switch (typeof value) {
+    case "string":
+      return "str";
+    case "number":
+      return "num";
+    case "boolean":
+      return "bool";
+    case "object": {
+      if (depth >= SIGNATURE_MAX_DEPTH) return "obj";
+      try {
+        const record = value;
+        const keys = Object.keys(record).sort();
+        const head = keys.slice(0, SIGNATURE_MAX_KEYS).map((key) => `${key}:${typeTag(record[key], depth + 1)}`);
+        if (keys.length > SIGNATURE_MAX_KEYS) {
+          head.push(`\u2026+${keys.length - SIGNATURE_MAX_KEYS}`);
+        }
+        return `{${head.join(",")}}`;
+      } catch {
+        return "obj";
+      }
+    }
+    default:
+      return "other";
+  }
+};
+var shapeSignature = (args) => {
+  const keys = Object.keys(args).sort();
+  const head = keys.slice(0, SIGNATURE_MAX_KEYS).map((key) => `${key}:${typeTag(args[key], 1)}`);
+  if (keys.length > SIGNATURE_MAX_KEYS) {
+    head.push(`\u2026+${keys.length - SIGNATURE_MAX_KEYS}`);
+  }
+  return `(${head.join(",")})`;
+};
+var signatureDistance = (left, right) => {
+  if (left === right) return 0;
+  const bound = Math.max(left.length, right.length);
+  if (bound === 0) return 0;
+  let previous = [];
+  for (let index = 0; index <= right.length; index++) {
+    previous.push(index);
+  }
+  for (let index = 1; index <= left.length; index++) {
+    const current = [index];
+    for (let inner = 1; inner <= right.length; inner++) {
+      const substitution = previous[inner - 1] + (left[index - 1] === right[inner - 1] ? 0 : 1);
+      const insertion = current[inner - 1] + 1;
+      const deletion = previous[inner] + 1;
+      current.push(Math.min(substitution, insertion, deletion));
+    }
+    previous = current;
+  }
+  return roundMetric(previous[right.length] / bound);
+};
+var shannonEntropyBits = (counts) => {
+  const total = counts.reduce((sum, value) => sum + value, 0);
+  if (total <= 0) return 0;
+  let bits = 0;
+  for (const count of counts) {
+    if (count <= 0) continue;
+    const probability = count / total;
+    bits += probability * Math.log2(probability);
+  }
+  return roundMetric(-bits);
+};
+var schemaFreedom = (schema, depth) => {
+  if (depth > SIGNATURE_MAX_DEPTH) return 0.5;
+  if (!isPlainRecord(schema)) return 0.5;
+  const union = Array.isArray(schema.anyOf) ? schema.anyOf : Array.isArray(schema.oneOf) ? schema.oneOf : void 0;
+  if (union) {
+    const scores = union.map((branch) => schemaFreedom(branch, depth + 1));
+    const widest = scores.length > 0 ? Math.max(...scores) : 0;
+    return roundMetric(widest + 0.1 * Math.max(0, union.length - 1));
+  }
+  if (Array.isArray(schema.enum)) {
+    return roundMetric(
+      Math.min(1, Math.log2(Math.max(1, schema.enum.length)) / ENUM_SATURATION_BITS)
+    );
+  }
+  if ("const" in schema) return 0;
+  const type = schema.type;
+  if (typeof type !== "string") return 0.75;
+  if (type === "boolean") return 0.1;
+  if (type === "number" || type === "integer") return 0.5;
+  if (type === "string") return 1;
+  if (type === "array") return roundMetric(0.5 + 0.5 * schemaFreedom(schema.items, depth + 1));
+  if (type === "object") {
+    const properties = schema.properties;
+    if (!isPlainRecord(properties)) return 1;
+    const keys = Object.keys(properties).sort();
+    if (keys.length === 0) return 1;
+    const required = Array.isArray(schema.required) ? schema.required.filter((entry) => typeof entry === "string") : [];
+    let score = 0;
+    for (const key of keys) {
+      score += schemaFreedom(properties[key], depth + 1);
+      if (!required.includes(key)) score += 0.25;
+    }
+    if (schema.additionalProperties !== false) score += 0.5;
+    return roundMetric(score);
+  }
+  return 0.75;
+};
+var staticFreedomFromSchema = (schema) => schemaFreedom(schema, 0);
+var trendFromScores = (scores) => {
+  const count = scores.length;
+  const first = count > 0 ? scores[0] : void 0;
+  const last = count > 0 ? scores[count - 1] : void 0;
+  let slope = 0;
+  if (count >= 2) {
+    const meanX = (count - 1) / 2;
+    const meanY = scores.reduce((sum, value) => sum + value, 0) / count;
+    let numerator = 0;
+    let denominator = 0;
+    for (let index = 0; index < count; index++) {
+      numerator += (index - meanX) * (scores[index] - meanY);
+      denominator += (index - meanX) ** 2;
+    }
+    slope = denominator > 0 ? numerator / denominator : 0;
+  }
+  return {
+    count,
+    ...first !== void 0 ? { first: roundMetric(first) } : {},
+    ...last !== void 0 ? { last: roundMetric(last) } : {},
+    slopePerStep: roundMetric(slope)
+  };
+};
+
+// src/entropy/meter.ts
+var DISCOVERY_PREFIX = "fabric.discovery.";
+var WORKFLOW_PREFIX = "fabric.workflow.";
+var DEFAULT_TASK_KEY = "(none)";
+var TOP_SIGNATURES = 8;
+var createMeasureState = (input) => {
+  const surfaceByRef = /* @__PURE__ */ new Map();
+  if (input.surface) {
+    for (const action of input.surface.actions) surfaceByRef.set(action.ref, action.inputSchema);
+  }
+  const lexiconByRef = /* @__PURE__ */ new Map();
+  let lexiconRows = 0;
+  for (const row of input.repairs ?? []) {
+    lexiconByRef.set(row.ref, (lexiconByRef.get(row.ref) ?? 0) + 1);
+    lexiconRows += 1;
+  }
+  return {
+    surfaceByRef,
+    lexiconByRef,
+    lexiconRows,
+    totals: {
+      traces: input.traces.length,
+      operations: 0,
+      actionOperations: 0,
+      discoveryOperations: 0,
+      workflowOperations: 0,
+      succeeded: 0,
+      failed: 0,
+      aborted: 0,
+      timedOut: 0,
+      invocationRejections: 0,
+      invocationRejectionsPer1k: 0
+    },
+    refs: /* @__PURE__ */ new Map(),
+    taskSequences: /* @__PURE__ */ new Map(),
+    churnPairs: 0,
+    churnSum: 0
+  };
+};
+var accumulatorFor = (state, ref) => {
+  const existing = state.refs.get(ref);
+  if (existing) return existing;
+  const created = {
+    calls: 0,
+    succeeded: 0,
+    failed: 0,
+    signatures: /* @__PURE__ */ new Map(),
+    stages: /* @__PURE__ */ new Map(),
+    churnPairs: 0,
+    churnSum: 0
+  };
+  state.refs.set(ref, created);
+  return created;
+};
+var accumulateTrace = (state, sourceTrace) => {
+  const taskKey = sourceTrace.taskKey ?? DEFAULT_TASK_KEY;
+  const sequence = [];
+  const pendingFailed = /* @__PURE__ */ new Map();
+  for (const operation of sourceTrace.operations) {
+    state.totals.operations += 1;
+    if (operation.ref.startsWith(DISCOVERY_PREFIX)) {
+      state.totals.discoveryOperations += 1;
+      continue;
+    }
+    if (operation.ref.startsWith(WORKFLOW_PREFIX)) {
+      state.totals.workflowOperations += 1;
+      continue;
+    }
+    state.totals.actionOperations += 1;
+    sequence.push(operation.ref);
+    const acc = accumulatorFor(state, operation.ref);
+    acc.calls += 1;
+    if (operation.outcome === "succeeded") {
+      state.totals.succeeded += 1;
+      acc.succeeded += 1;
+    } else if (operation.outcome === "failed") {
+      state.totals.failed += 1;
+      acc.failed += 1;
+    } else if (operation.outcome === "aborted") {
+      state.totals.aborted += 1;
+    } else {
+      state.totals.timedOut += 1;
+    }
+    const signature = shapeSignature(operation.args);
+    acc.signatures.set(signature, (acc.signatures.get(signature) ?? 0) + 1);
+    if (operation.outcome === "failed") {
+      const stage = operation.failureStage ?? "unknown";
+      acc.stages.set(stage, (acc.stages.get(stage) ?? 0) + 1);
+      if (ENTROPY_INVOCATION_STAGES.includes(stage)) state.totals.invocationRejections += 1;
+    }
+    const pending = pendingFailed.get(operation.ref);
+    if (pending !== void 0) {
+      const distance = signatureDistance(pending, signature);
+      acc.churnPairs += 1;
+      acc.churnSum += distance;
+      state.churnPairs += 1;
+      state.churnSum += distance;
+      pendingFailed.delete(operation.ref);
+    }
+    if (operation.outcome === "failed") pendingFailed.set(operation.ref, signature);
+  }
+  if (sequence.length > 0) {
+    const key = sequence.join("\u2192");
+    const perTask = state.taskSequences.get(taskKey) ?? /* @__PURE__ */ new Map();
+    perTask.set(key, (perTask.get(key) ?? 0) + 1);
+    state.taskSequences.set(taskKey, perTask);
+  }
+};
+var finalizeMeasure = (input, state) => {
+  const refEntries = [...state.refs.entries()].sort(
+    ([left], [right]) => compareCodeUnits(left, right)
+  );
+  const refReports = [];
+  let staticFreedomTotal = 0;
+  let staticWeighted = 0;
+  let shapeWeighted = 0;
+  let failureStageWeighted = 0;
+  let scoreSum = 0;
+  for (const [ref, acc] of refEntries) {
+    const shapeEntropyBits = shannonEntropyBits([...acc.signatures.values()]);
+    const failureStageEntropyBits = shannonEntropyBits([...acc.stages.values()]);
+    const refChurnRate = acc.churnPairs > 0 ? roundMetric(acc.churnSum / acc.churnPairs) : 0;
+    const lexicon = state.lexiconByRef.get(ref) ?? 0;
+    const staticFreedom = state.surfaceByRef.has(ref) ? staticFreedomFromSchema(state.surfaceByRef.get(ref)) : 0;
+    staticFreedomTotal += staticFreedom;
+    staticWeighted += ENTROPY_WEIGHTS.staticFreedom * staticFreedom;
+    shapeWeighted += shapeEntropyBits * acc.calls;
+    failureStageWeighted += failureStageEntropyBits * acc.failed;
+    const score2 = roundMetric(
+      ENTROPY_WEIGHTS.shape * shapeEntropyBits + ENTROPY_WEIGHTS.failureStage * failureStageEntropyBits + ENTROPY_WEIGHTS.churn * refChurnRate + ENTROPY_WEIGHTS.lexicon * lexicon + ENTROPY_WEIGHTS.staticFreedom * staticFreedom
+    );
+    scoreSum += score2;
+    const shapeSignatures = [...acc.signatures.entries()].map(([signature, count]) => ({ signature, count })).sort(
+      (left, right) => right.count - left.count || compareCodeUnits(left.signature, right.signature)
+    ).slice(0, TOP_SIGNATURES);
+    refReports.push({
+      ref,
+      calls: acc.calls,
+      succeeded: acc.succeeded,
+      failed: acc.failed,
+      shapeSignatures,
+      shapeEntropyBits,
+      failureStageEntropyBits,
+      churnRate: refChurnRate,
+      lexiconRows: lexicon,
+      staticFreedom,
+      score: score2
+    });
+  }
+  const navigationRatio = state.totals.actionOperations > 0 ? roundMetric(state.totals.discoveryOperations / state.totals.actionOperations) : 0;
+  let flowWeighted = 0;
+  let flowOccurrences = 0;
+  for (const perTask of state.taskSequences.values()) {
+    const counts = [...perTask.values()];
+    const occurrences = counts.reduce((sum, value) => sum + value, 0);
+    flowWeighted += shannonEntropyBits(counts) * occurrences;
+    flowOccurrences += occurrences;
+  }
+  const flowEntropyBits = flowOccurrences > 0 ? roundMetric(flowWeighted / flowOccurrences) : 0;
+  state.totals.invocationRejectionsPer1k = state.totals.actionOperations > 0 ? roundMetric(state.totals.invocationRejections / state.totals.actionOperations * 1e3) : 0;
+  const score = roundMetric(
+    (scoreSum + ENTROPY_WEIGHTS.navigation * navigationRatio + ENTROPY_WEIGHTS.flow * flowEntropyBits) / Math.max(1, state.totals.succeeded)
+  );
+  const staticScore = roundMetric(staticWeighted / Math.max(1, state.totals.succeeded));
+  const behavioralScore = roundMetric(score - staticScore);
+  const sortedRefs = [...refReports].sort(
+    (left, right) => right.score - left.score || compareCodeUnits(left.ref, right.ref)
+  );
+  return {
+    metricVersion: ENTROPY_METRIC_VERSION,
+    catalogDigest: input.catalogDigest ?? "",
+    totals: state.totals,
+    shapeEntropyBits: state.totals.actionOperations > 0 ? roundMetric(shapeWeighted / state.totals.actionOperations) : 0,
+    failureStageEntropyBits: state.totals.failed > 0 ? roundMetric(failureStageWeighted / state.totals.failed) : 0,
+    churnRate: state.churnPairs > 0 ? roundMetric(state.churnSum / state.churnPairs) : 0,
+    navigationRatio,
+    flowEntropyBits,
+    lexiconRows: state.lexiconRows,
+    staticFreedom: roundMetric(staticFreedomTotal),
+    staticScore,
+    behavioralScore,
+    score,
+    refs: sortedRefs
+  };
+};
+var measureOnce = (input) => {
+  const state = createMeasureState(input);
+  for (const trace of input.traces) accumulateTrace(state, trace);
+  return finalizeMeasure(input, state);
+};
+var measureEntropy = (input) => {
+  const report = measureOnce(input);
+  const groups = /* @__PURE__ */ new Map();
+  for (const sourceTrace of input.traces) {
+    if (!sourceTrace.model) continue;
+    const group = groups.get(sourceTrace.model) ?? [];
+    group.push(sourceTrace);
+    groups.set(sourceTrace.model, group);
+  }
+  const byModel = [...groups.entries()].sort(([left], [right]) => compareCodeUnits(left, right)).map(([model, traces]) => {
+    const scoped = measureOnce({ ...input, traces });
+    return {
+      model,
+      operations: scoped.totals.operations,
+      actionOperations: scoped.totals.actionOperations,
+      succeeded: scoped.totals.succeeded,
+      invocationRejections: scoped.totals.invocationRejections,
+      invocationRejectionsPer1k: scoped.totals.invocationRejectionsPer1k,
+      behavioralScore: scoped.behavioralScore
+    };
+  });
+  return { ...report, byModel };
+};
+var yieldToLoop = () => new Promise((resolve) => setImmediate(resolve));
+var COOPERATIVE_TRACE_CHUNK = 64;
+var measureOnceAsync = async (input) => {
+  const state = createMeasureState(input);
+  await yieldToLoop();
+  for (let index = 0; index < input.traces.length; index += 1) {
+    accumulateTrace(state, input.traces[index]);
+    if ((index + 1) % COOPERATIVE_TRACE_CHUNK === 0) await yieldToLoop();
+  }
+  return finalizeMeasure(input, state);
+};
+var measureEntropyAsync = async (input) => {
+  const report = await measureOnceAsync(input);
+  const groups = /* @__PURE__ */ new Map();
+  for (const sourceTrace of input.traces) {
+    if (!sourceTrace.model) continue;
+    const group = groups.get(sourceTrace.model) ?? [];
+    group.push(sourceTrace);
+    groups.set(sourceTrace.model, group);
+  }
+  const byModel = [];
+  for (const [model, traces] of [...groups.entries()].sort(
+    ([left], [right]) => compareCodeUnits(left, right)
+  )) {
+    const scoped = await measureOnceAsync({ ...input, traces });
+    byModel.push({
+      model,
+      operations: scoped.totals.operations,
+      actionOperations: scoped.totals.actionOperations,
+      succeeded: scoped.totals.succeeded,
+      invocationRejections: scoped.totals.invocationRejections,
+      invocationRejectionsPer1k: scoped.totals.invocationRejectionsPer1k,
+      behavioralScore: scoped.behavioralScore
+    });
+  }
+  return { ...report, byModel };
+};
+
+// src/entropy/passes.ts
+var ENUM_MIN_OBSERVATIONS = 8;
+var ENUM_MAX_DISTINCT = 8;
+var ENUM_MIN_TOP_SHARE = 0.5;
+var SPLIT_MIN_SHAPE_ENTROPY_BITS = 1;
+var SPLIT_MIN_CLUSTER_CALLS = 2;
+var FUSE_MIN_SEQUENCE_LENGTH = 3;
+var FUSE_MAX_SEQUENCE_LENGTH = 6;
+var FUSE_MIN_OCCURRENCES = 3;
+var FUSE_MIN_EXECUTIONS = 3;
+var QUARANTINE_MIN_CALLS = 3;
+var QUARANTINE_MIN_STAGE_ENTROPY_BITS = 1;
+var MAX_PROPOSALS_PER_KIND = 8;
+var ENTROPY_ENUM_CANDIDATE_ANNOTATION = "x-fabric-enum-candidate";
+var isPlainRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var valueKey = (value) => `${typeof value}:${String(value)}`;
+var schemaProperties = (schema) => {
+  if (!isPlainRecord2(schema)) return void 0;
+  const properties = schema.properties;
+  return isPlainRecord2(properties) ? properties : void 0;
+};
+var enumKeys = (schema) => {
+  if (!isPlainRecord2(schema) || !Array.isArray(schema.enum)) return void 0;
+  const keys = /* @__PURE__ */ new Set();
+  for (const entry of schema.enum) {
+    if (typeof entry === "string" || typeof entry === "number" || typeof entry === "boolean") {
+      keys.add(valueKey(entry));
+    }
+  }
+  return keys;
+};
+var contains = (outer, inner) => {
+  if (outer.length < inner.length) return false;
+  for (let start = 0; start + inner.length <= outer.length; start++) {
+    let matches = true;
+    for (let index = 0; index < inner.length; index++) {
+      if (outer[start + index] !== inner[index]) {
+        matches = false;
+        break;
+      }
+    }
+    if (matches) return true;
+  }
+  return false;
+};
+var tightenBeneathDeclaredEnum = (candidate, declaredDomain) => {
+  const ranked = candidate.ranked.filter((item) => declaredDomain.has(valueKey(item.value)));
+  if (ranked.length === 0 || ranked.length === declaredDomain.size) return void 0;
+  return { ...candidate, ranked };
+};
+var proposeEntropyReductions = (input) => {
+  const calledRefs = /* @__PURE__ */ new Map();
+  for (const ref of input.report.refs) calledRefs.set(ref.ref, ref);
+  const surfaceByRef = /* @__PURE__ */ new Map();
+  const surfaceRefs = /* @__PURE__ */ new Set();
+  if (input.surface) {
+    for (const action of input.surface.actions) {
+      surfaceByRef.set(action.ref, action.inputSchema);
+      surfaceRefs.add(action.ref);
+    }
+  }
+  const proposals = [];
+  const observations = /* @__PURE__ */ new Map();
+  const observeValue = (ref, key, value, weight = 1) => {
+    const id = `${ref}\0${key}`;
+    const entry = observations.get(id) ?? {
+      ref,
+      key,
+      counts: /* @__PURE__ */ new Map(),
+      total: 0
+    };
+    const valueId = valueKey(value);
+    const existing = entry.counts.get(valueId);
+    entry.counts.set(valueId, { value, count: (existing?.count ?? 0) + weight });
+    entry.total += weight;
+    observations.set(id, entry);
+  };
+  if (input.valueObservations) {
+    for (const observation of input.valueObservations) {
+      observeValue(observation.ref, observation.key, observation.value, observation.count ?? 1);
+    }
+  } else {
+    for (const sourceTrace of input.traces) {
+      for (const operation of sourceTrace.operations) {
+        if (operation.ref.startsWith("fabric.")) continue;
+        for (const [key, value] of Object.entries(operation.args)) {
+          if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") {
+            continue;
+          }
+          observeValue(operation.ref, key, value);
+        }
+      }
+    }
+  }
+  const eligibleCandidates = [...observations.values()].filter((entry) => entry.total >= ENUM_MIN_OBSERVATIONS).filter((entry) => entry.counts.size >= 2 && entry.counts.size <= ENUM_MAX_DISTINCT).map((entry) => {
+    const ranked = [...entry.counts.values()].sort(
+      (left, right) => right.count - left.count || compareCodeUnits(valueKey(left.value), valueKey(right.value))
+    );
+    return { entry, ranked, topShare: roundMetric(ranked[0].count / entry.total) };
+  }).filter((candidate) => candidate.topShare >= ENUM_MIN_TOP_SHARE);
+  const closedCandidates = [];
+  const openCandidates = [];
+  for (const candidate of eligibleCandidates) {
+    const properties = input.surface ? schemaProperties(surfaceByRef.get(candidate.entry.ref)) : void 0;
+    const target = properties ? properties[candidate.entry.key] : void 0;
+    if (isPlainRecord2(target) && target.type === "boolean") continue;
+    const declaredDomain = target ? enumKeys(target) : void 0;
+    if (declaredDomain) {
+      const tightened = tightenBeneathDeclaredEnum(candidate, declaredDomain);
+      if (tightened) closedCandidates.push(tightened);
+    } else if (isPlainRecord2(target) && target[ENTROPY_ENUM_CANDIDATE_ANNOTATION] === true) {
+      openCandidates.push(candidate);
+    }
+  }
+  const byRefKey = (left, right) => compareCodeUnits(
+    `${left.entry.ref}\0${left.entry.key}`,
+    `${right.entry.ref}\0${right.entry.key}`
+  );
+  for (const candidate of closedCandidates.sort(byRefKey).slice(0, MAX_PROPOSALS_PER_KIND)) {
+    proposals.push({
+      kind: "enum-tighten",
+      ref: candidate.entry.ref,
+      key: candidate.entry.key,
+      values: candidate.ranked.map((item) => item.value),
+      calls: candidate.entry.total,
+      distinct: candidate.ranked.length,
+      topShare: candidate.topShare
+    });
+  }
+  for (const candidate of openCandidates.sort(byRefKey).slice(0, MAX_PROPOSALS_PER_KIND)) {
+    proposals.push({
+      kind: "declare-enum",
+      ref: candidate.entry.ref,
+      key: candidate.entry.key,
+      values: candidate.ranked.map((item) => item.value),
+      calls: candidate.entry.total,
+      distinct: candidate.entry.counts.size,
+      topShare: candidate.topShare
+    });
+  }
+  const overloadRefs = new Set(
+    input.report.refs.filter((ref) => ref.shapeEntropyBits >= SPLIT_MIN_SHAPE_ENTROPY_BITS).map((ref) => ref.ref)
+  );
+  if (overloadRefs.size > 0) {
+    const keySets = /* @__PURE__ */ new Map();
+    for (const sourceTrace of input.traces) {
+      for (const operation of sourceTrace.operations) {
+        if (!overloadRefs.has(operation.ref)) continue;
+        const keys = Object.keys(operation.args).sort();
+        const id = keys.join("\0");
+        const perRef = keySets.get(operation.ref) ?? /* @__PURE__ */ new Map();
+        const cluster = perRef.get(id) ?? { keys, calls: 0 };
+        cluster.calls += 1;
+        perRef.set(id, cluster);
+        keySets.set(operation.ref, perRef);
+      }
+    }
+    let overloadCount = 0;
+    for (const [ref, perRef] of [...keySets.entries()].sort(
+      ([left], [right]) => compareCodeUnits(left, right)
+    )) {
+      if (overloadCount >= MAX_PROPOSALS_PER_KIND) break;
+      const clusters = [...perRef.values()].filter((cluster) => cluster.calls >= SPLIT_MIN_CLUSTER_CALLS).sort(
+        (left, right) => right.calls - left.calls || compareCodeUnits(left.keys.join(","), right.keys.join(","))
+      );
+      const disjoint = [];
+      for (const cluster of clusters) {
+        const keys = new Set(cluster.keys);
+        if (disjoint.every((candidate) => candidate.keys.every((key) => !keys.has(key)))) {
+          disjoint.push(cluster);
+        }
+      }
+      if (disjoint.length >= 2) {
+        overloadCount += 1;
+        const report = calledRefs.get(ref);
+        proposals.push({
+          kind: "overload-split",
+          ref,
+          shapeEntropyBits: report?.shapeEntropyBits ?? 0,
+          clusters: disjoint.slice(0, MAX_PROPOSALS_PER_KIND).map((cluster) => ({
+            keys: cluster.keys,
+            calls: cluster.calls
+          }))
+        });
+      }
+    }
+  }
+  const sequenceCounts = /* @__PURE__ */ new Map();
+  const recordSequenceSegment = (refs, execution) => {
+    for (let length = FUSE_MIN_SEQUENCE_LENGTH; length <= Math.min(FUSE_MAX_SEQUENCE_LENGTH, refs.length); length++) {
+      for (let start = 0; start + length <= refs.length; start++) {
+        const sequence = refs.slice(start, start + length);
+        if (new Set(sequence).size !== sequence.length) continue;
+        const id = sequence.join("\u2192");
+        const entry = sequenceCounts.get(id) ?? {
+          sequence,
+          occurrences: 0,
+          executions: /* @__PURE__ */ new Set()
+        };
+        entry.occurrences += 1;
+        entry.executions.add(execution);
+        sequenceCounts.set(id, entry);
+      }
+    }
+  };
+  input.traces.forEach((sourceTrace, execution) => {
+    let segment = [];
+    const flush = () => {
+      recordSequenceSegment(segment, execution);
+      segment = [];
+    };
+    for (const operation of sourceTrace.operations) {
+      if (operation.outcome !== "succeeded" || operation.ref.startsWith("fabric.") || operation.ref.startsWith("omp.")) {
+        flush();
+      } else {
+        segment.push(operation.ref);
+      }
+    }
+    flush();
+  });
+  const fuseCandidates = [...sequenceCounts.values()].filter(
+    (entry) => entry.occurrences >= FUSE_MIN_OCCURRENCES && entry.executions.size >= FUSE_MIN_EXECUTIONS
+  ).sort(
+    (left, right) => right.sequence.length - left.sequence.length || right.occurrences - left.occurrences || compareCodeUnits(left.sequence.join("\u2192"), right.sequence.join("\u2192"))
+  );
+  const selected = [];
+  for (const candidate of fuseCandidates) {
+    if (selected.length >= MAX_PROPOSALS_PER_KIND) break;
+    const redundant = selected.some(
+      (chosen) => contains(candidate.sequence, chosen.sequence) || contains(chosen.sequence, candidate.sequence)
+    );
+    if (redundant) continue;
+    selected.push(candidate);
+  }
+  for (const candidate of selected) {
+    proposals.push({
+      kind: "sequence-fuse",
+      sequence: candidate.sequence,
+      occurrences: candidate.occurrences
+    });
+  }
+  const quarantineCandidates = input.report.refs.filter(
+    (ref) => ref.calls >= QUARANTINE_MIN_CALLS && ref.failed > ref.succeeded && ref.failureStageEntropyBits >= QUARANTINE_MIN_STAGE_ENTROPY_BITS
+  ).filter((ref) => !input.surface || surfaceRefs.has(ref.ref)).slice(0, MAX_PROPOSALS_PER_KIND);
+  for (const ref of quarantineCandidates) {
+    proposals.push({
+      kind: "noise-quarantine",
+      ref: ref.ref,
+      calls: ref.calls,
+      succeeded: ref.succeeded,
+      failed: ref.failed,
+      failureStageEntropyBits: ref.failureStageEntropyBits
+    });
+  }
+  return proposals;
+};
+var deepCloneJson = (value) => value === void 0 ? {} : JSON.parse(JSON.stringify(value));
+var applyProposalsToSurface = (surface, proposals) => {
+  const actions = surface.actions.map((action) => ({
+    ref: action.ref,
+    inputSchema: deepCloneJson(action.inputSchema)
+  }));
+  const quarantined = /* @__PURE__ */ new Set();
+  for (const proposal of proposals) {
+    if (proposal.kind === "noise-quarantine") {
+      quarantined.add(proposal.ref);
+      continue;
+    }
+    if (proposal.kind === "enum-tighten") {
+      const action = actions.find((candidate) => candidate.ref === proposal.ref);
+      if (!action || !isPlainRecord2(action.inputSchema)) continue;
+      const properties = schemaProperties(action.inputSchema);
+      if (!properties || !isPlainRecord2(properties[proposal.key])) continue;
+      properties[proposal.key] = {
+        ...properties[proposal.key],
+        enum: [...proposal.values]
+      };
+    }
+  }
+  const survivors = actions.filter((action) => !quarantined.has(action.ref)).sort((left, right) => compareCodeUnits(left.ref, right.ref));
+  return { version: 1, actions: survivors };
+};
+var evaluateGate = (before, after) => {
+  const reasons = [];
+  if (after.score > before.score) {
+    reasons.push(`score increased ${before.score} \u2192 ${after.score}`);
+  }
+  if (after.totals.succeeded < before.totals.succeeded) {
+    reasons.push(
+      `successful calls dropped ${before.totals.succeeded} \u2192 ${after.totals.succeeded}`
+    );
+  }
+  return {
+    passed: reasons.length === 0,
+    beforeScore: before.score,
+    afterScore: after.score,
+    delta: roundMetric(after.score - before.score),
+    reasons
+  };
+};
+
+// src/entropy/pool.ts
+import { createHash } from "node:crypto";
+var OBSERVATION_POOL_VERSION = 1;
+var POOL_TRACKED_VALUES = 16;
+var POOL_TRACKED_SESSIONS = 16;
+var POOL_BAKED_DIGESTS = 512;
+var SEPARATOR = "\0";
+var observationIdentity = (observation) => `${observation.ref}${SEPARATOR}${observation.key}${SEPARATOR}${typeof observation.value}:${String(observation.value)}`;
+var entryValueKey = (value) => `${typeof value}:${String(value)}`;
+var valueFromKey = (valueKey2) => {
+  const separator = valueKey2.indexOf(":");
+  const type = valueKey2.slice(0, separator);
+  const raw = valueKey2.slice(separator + 1);
+  if (type === "number") return Number(raw);
+  if (type === "boolean") return raw === "true";
+  return raw;
+};
+var parseIdentity = (identity) => {
+  const first = identity.indexOf(SEPARATOR);
+  const second = identity.indexOf(SEPARATOR, first + 1);
+  return {
+    ref: identity.slice(0, first),
+    key: identity.slice(first + 1, second),
+    valueKey: identity.slice(second + 1)
+  };
+};
+var digestFromIdentityCounts = (counts) => {
+  const hash = createHash("sha256");
+  hash.update("[");
+  let first = true;
+  for (const [identity, count] of Object.entries(counts).sort(
+    ([left], [right]) => compareCodeUnits(left, right)
+  )) {
+    const encoded = JSON.stringify(identity);
+    const repeated = Array.from({ length: count }, () => encoded).join(",");
+    hash.update(first ? repeated : `,${repeated}`);
+    first = false;
+  }
+  hash.update("]");
+  return hash.digest("hex");
+};
+var summarizeObservations = (observations) => {
+  const counts = {};
+  const digestCounts = {};
+  for (const observation of observations) {
+    const identity = observationIdentity(observation);
+    counts[identity] = (counts[identity] ?? 0) + (observation.count ?? 1);
+    digestCounts[identity] = (digestCounts[identity] ?? 0) + 1;
+  }
+  return { counts, digest: digestFromIdentityCounts(digestCounts) };
+};
+var observationWindowDigest = (observations) => summarizeObservations(observations).digest;
+var COOPERATIVE_OBSERVATION_CHUNK = 256;
+var COOPERATIVE_DIGEST_CHUNK = 512;
+var yieldToLoop2 = () => new Promise((resolve) => setImmediate(resolve));
+var digestFromIdentityCountsAsync = async (counts) => {
+  const hash = createHash("sha256");
+  hash.update("[");
+  let first = true;
+  let encodedBatch = [];
+  const flush = async () => {
+    if (encodedBatch.length === 0) return;
+    hash.update(`${first ? "" : ","}${encodedBatch.join(",")}`);
+    first = false;
+    encodedBatch = [];
+    await yieldToLoop2();
+  };
+  for (const [identity, count] of Object.entries(counts).sort(
+    ([left], [right]) => compareCodeUnits(left, right)
+  )) {
+    const encoded = JSON.stringify(identity);
+    for (let occurrence = 0; occurrence < count; occurrence += 1) {
+      encodedBatch.push(encoded);
+      if (encodedBatch.length >= COOPERATIVE_DIGEST_CHUNK) await flush();
+    }
+  }
+  if (encodedBatch.length > 0) {
+    hash.update(`${first ? "" : ","}${encodedBatch.join(",")}`);
+  }
+  hash.update("]");
+  return hash.digest("hex");
+};
+var summarizeObservationsAsync = async (observations) => {
+  const counts = {};
+  const digestCounts = {};
+  for (let index = 0; index < observations.length; index += 1) {
+    const observation = observations[index];
+    const identity = observationIdentity(observation);
+    counts[identity] = (counts[identity] ?? 0) + (observation.count ?? 1);
+    digestCounts[identity] = (digestCounts[identity] ?? 0) + 1;
+    if ((index + 1) % COOPERATIVE_OBSERVATION_CHUNK === 0) await yieldToLoop2();
+  }
+  return { counts, digest: await digestFromIdentityCountsAsync(digestCounts) };
+};
+var workingFromPool = (pool) => {
+  const working = /* @__PURE__ */ new Map();
+  if (!pool) return working;
+  for (const entry of pool.entries) {
+    const values = /* @__PURE__ */ new Map();
+    for (const item of entry.values) {
+      values.set(entryValueKey(item.value), { value: item.value, count: item.count });
+    }
+    working.set(`${entry.ref}${SEPARATOR}${entry.key}`, {
+      ref: entry.ref,
+      key: entry.key,
+      values,
+      total: entry.total
+    });
+  }
+  return working;
+};
+var applyEntryDelta = (working, identity, weight) => {
+  const { ref, key, valueKey: valueKey2 } = parseIdentity(identity);
+  const entryId = `${ref}${SEPARATOR}${key}`;
+  let entry = working.get(entryId);
+  if (!entry) {
+    entry = { ref, key, values: /* @__PURE__ */ new Map(), total: 0 };
+    working.set(entryId, entry);
+  }
+  const current = entry.values.get(valueKey2);
+  const nextCount = (current?.count ?? 0) + weight;
+  entry.total += weight;
+  if (nextCount > 0) {
+    entry.values.set(valueKey2, {
+      value: current?.value ?? valueFromKey(valueKey2),
+      count: nextCount
+    });
+  } else {
+    entry.values.delete(valueKey2);
+  }
+  if (entry.values.size === 0 && entry.total <= 0) working.delete(entryId);
+  return entryId;
+};
+var enforceValueCap = (entry) => {
+  while (entry.values.size > POOL_TRACKED_VALUES) {
+    let evictKey;
+    let evictCount = Number.POSITIVE_INFINITY;
+    for (const [valueKey2, item] of entry.values) {
+      if (evictKey === void 0 || item.count < evictCount || item.count === evictCount && compareCodeUnits(valueKey2, evictKey) > 0) {
+        evictKey = valueKey2;
+        evictCount = item.count;
+      }
+    }
+    if (evictKey === void 0) return;
+    entry.total -= entry.values.get(evictKey).count;
+    entry.values.delete(evictKey);
+  }
+};
+var serializePool = (working, tracked, baked) => ({
+  version: OBSERVATION_POOL_VERSION,
+  entries: [...working.values()].map((entry) => ({
+    ref: entry.ref,
+    key: entry.key,
+    total: entry.total,
+    values: [...entry.values.values()].map((item) => ({ value: item.value, count: item.count })).sort(
+      (left, right) => right.count - left.count || compareCodeUnits(entryValueKey(left.value), entryValueKey(right.value))
+    )
+  })).sort(
+    (left, right) => compareCodeUnits(
+      `${left.ref}${SEPARATOR}${left.key}`,
+      `${right.ref}${SEPARATOR}${right.key}`
+    )
+  ),
+  tracked,
+  baked
+});
+var mergeObservationSummaries = (pool, windows) => {
+  const working = workingFromPool(pool);
+  const tracked = [...pool?.tracked ?? []];
+  const baked = [...pool?.baked ?? []];
+  const bakedSet = new Set(baked);
+  const trackedDigests = new Set(tracked.map((session) => session.digest));
+  let mergedSessions = 0;
+  let skippedSessions = 0;
+  for (const window of windows) {
+    const { digest, counts: fresh } = window.summary;
+    if (bakedSet.has(digest) || trackedDigests.has(digest)) {
+      skippedSessions += 1;
+      continue;
+    }
+    const existingIndex = tracked.findIndex((session) => session.file === window.file);
+    const existing = existingIndex >= 0 ? tracked[existingIndex] : void 0;
+    const delta = { ...fresh };
+    if (existing) {
+      for (const [identity, count] of Object.entries(existing.counts)) {
+        delta[identity] = (delta[identity] ?? 0) - count;
+      }
+    }
+    const touched = /* @__PURE__ */ new Set();
+    for (const [identity, weight] of Object.entries(delta)) {
+      if (weight === 0) continue;
+      touched.add(applyEntryDelta(working, identity, weight));
+    }
+    for (const entryId of touched) {
+      const entry = working.get(entryId);
+      if (entry) enforceValueCap(entry);
+    }
+    const trackedSession = { file: window.file, digest, counts: fresh };
+    if (existing) {
+      tracked[existingIndex] = trackedSession;
+    } else {
+      tracked.push(trackedSession);
+      if (tracked.length > POOL_TRACKED_SESSIONS) {
+        const oldest = tracked.shift();
+        if (!bakedSet.has(oldest.digest)) {
+          baked.push(oldest.digest);
+          bakedSet.add(oldest.digest);
+          while (baked.length > POOL_BAKED_DIGESTS) {
+            bakedSet.delete(baked.shift());
+          }
+        }
+      }
+    }
+    trackedDigests.add(digest);
+    mergedSessions += 1;
+  }
+  return {
+    file: serializePool(working, tracked, baked),
+    mergedSessions,
+    skippedSessions
+  };
+};
+var mergeObservationWindow = (pool, windows) => mergeObservationSummaries(
+  pool,
+  windows.map((window) => ({
+    file: window.file,
+    summary: summarizeObservations(window.observations)
+  }))
+);
+var mergeObservationWindowAsync = async (pool, windows) => {
+  const summarized = [];
+  for (const window of windows) {
+    summarized.push({
+      file: window.file,
+      summary: await summarizeObservationsAsync(window.observations)
+    });
+  }
+  await yieldToLoop2();
+  return mergeObservationSummaries(pool, summarized);
+};
+var poolToValueObservations = (pool) => {
+  if (!pool) return [];
+  const observations = [];
+  for (const entry of pool.entries) {
+    for (const item of entry.values) {
+      observations.push({ ref: entry.ref, key: entry.key, value: item.value, count: item.count });
+    }
+  }
+  return observations;
+};
+
+// src/entropy/pool-store.ts
+import fs from "node:fs";
+import path from "node:path";
+var POOL_LOCK_ATTEMPTS = 50;
+var POOL_LOCK_DELAY_MS = 5;
+var POOL_STALE_LOCK_MS = 3e4;
+var POOL_MAX_ENTRIES = 8192;
+var POOL_MAX_VALUES_PER_ENTRY = 64;
+var POOL_MAX_TRACKED = 64;
+var POOL_MAX_BAKED = 2048;
+var observationPoolDirectory = (agentDir) => path.join(agentDir, "fabric", "entropy");
+var poolPath = (directory) => path.join(directory, "observation-pool.json");
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var errorCode = (error) => isRecord(error) && typeof error.code === "string" ? error.code : void 0;
+var errorText = (error) => (error instanceof Error ? error.message : String(error)).slice(0, 200);
+var isPrimitive = (value) => typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+var parseValueCount = (value) => {
+  if (!isRecord(value) || !isPrimitive(value.value)) return void 0;
+  if (!Number.isSafeInteger(value.count) || value.count < 1) return void 0;
+  return { value: value.value, count: value.count };
+};
+var parseEntry = (value) => {
+  if (!isRecord(value) || typeof value.ref !== "string" || !value.ref.trim()) return void 0;
+  if (typeof value.key !== "string" || !value.key.trim()) return void 0;
+  if (!Number.isSafeInteger(value.total) || value.total < 0) return void 0;
+  if (!Array.isArray(value.values) || value.values.length > POOL_MAX_VALUES_PER_ENTRY) {
+    return void 0;
+  }
+  const values = [];
+  for (const item of value.values) {
+    const parsed = parseValueCount(item);
+    if (!parsed) return void 0;
+    values.push(parsed);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of values) {
+    const key = `${typeof item.value}:${String(item.value)}`;
+    if (seen.has(key)) return void 0;
+    seen.add(key);
+  }
+  return { ref: value.ref.trim(), key: value.key.trim(), total: value.total, values };
+};
+var parseTrackedSession = (value) => {
+  if (!isRecord(value) || typeof value.file !== "string" || !value.file.trim()) return void 0;
+  if (typeof value.digest !== "string" || !value.digest.trim()) return void 0;
+  if (!isRecord(value.counts)) return void 0;
+  const counts = {};
+  for (const [identity, count] of Object.entries(value.counts)) {
+    if (!Number.isSafeInteger(count) || count < 1) return void 0;
+    counts[identity] = count;
+  }
+  return { file: value.file.trim(), digest: value.digest.trim(), counts };
+};
+var parsePoolFile = (value) => {
+  if (!isRecord(value) || value.version !== OBSERVATION_POOL_VERSION) return void 0;
+  if (!Array.isArray(value.entries) || value.entries.length > POOL_MAX_ENTRIES) return void 0;
+  if (!Array.isArray(value.tracked) || value.tracked.length > POOL_MAX_TRACKED) return void 0;
+  if (!Array.isArray(value.baked) || value.baked.length > POOL_MAX_BAKED) return void 0;
+  if (!value.baked.every((digest) => typeof digest === "string" && digest.trim())) {
+    return void 0;
+  }
+  const entries = [];
+  for (const entry of value.entries) {
+    const parsed = parseEntry(entry);
+    if (!parsed) return void 0;
+    entries.push(parsed);
+  }
+  const tracked = [];
+  const trackedFiles = /* @__PURE__ */ new Set();
+  for (const session of value.tracked) {
+    const parsed = parseTrackedSession(session);
+    if (!parsed) return void 0;
+    if (trackedFiles.has(parsed.file)) return void 0;
+    trackedFiles.add(parsed.file);
+    tracked.push(parsed);
+  }
+  const entrySeen = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    const id = `${entry.ref}\0${entry.key}`;
+    if (entrySeen.has(id)) return void 0;
+    entrySeen.add(id);
+  }
+  return {
+    version: OBSERVATION_POOL_VERSION,
+    entries,
+    tracked,
+    baked: value.baked.map((digest) => digest.trim())
+  };
+};
+var loadObservationPool = (agentDir) => {
+  const file = poolPath(observationPoolDirectory(agentDir));
+  let raw;
+  try {
+    raw = fs.readFileSync(file, "utf8");
+  } catch (error) {
+    if (errorCode(error) === "ENOENT") return {};
+    return { error: `observation pool is unreadable: ${errorText(error)}` };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return { error: "observation pool is malformed JSON" };
+  }
+  const parsedFile = parsePoolFile(parsed);
+  if (!parsedFile) return { error: "observation pool is invalid" };
+  return { file: parsedFile };
+};
+var loadObservationPoolAsync = async (agentDir) => {
+  const file = poolPath(observationPoolDirectory(agentDir));
+  let raw;
+  try {
+    raw = await fs.promises.readFile(file, "utf8");
+  } catch (error) {
+    if (errorCode(error) === "ENOENT") return {};
+    return { error: `observation pool is unreadable: ${errorText(error)}` };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return { error: "observation pool is malformed JSON" };
+  }
+  const parsedFile = parsePoolFile(parsed);
+  return parsedFile ? { file: parsedFile } : { error: "observation pool is invalid" };
+};
+var saveObservationPool = (agentDir, file) => withExclusiveFileLock(
+  {
+    directory: observationPoolDirectory(agentDir),
+    lockName: "observation-pool.lock",
+    timeoutMessage: "Timed out waiting for the observation pool lock",
+    attempts: POOL_LOCK_ATTEMPTS,
+    delayMs: POOL_LOCK_DELAY_MS,
+    staleMs: POOL_STALE_LOCK_MS
+  },
+  () => {
+    const loaded = loadObservationPool(agentDir);
+    if (loaded.error) throw new Error(loaded.error);
+    const target = poolPath(observationPoolDirectory(agentDir));
+    const serialized = `${JSON.stringify(file, null, 2)}
+`;
+    try {
+      if (fs.readFileSync(target, "utf8") === serialized) return { file, written: false };
+    } catch {
+    }
+    writeJsonAtomic(target, file, { space: 2, newline: true, mode: 384, dirMode: 448 });
+    return { file, written: true };
+  }
+);
+var saveObservationPoolAsync = async (agentDir, file) => withExclusiveFileLockAsync(
+  {
+    directory: observationPoolDirectory(agentDir),
+    lockName: "observation-pool.lock",
+    timeoutMessage: "Timed out waiting for the observation pool lock",
+    attempts: POOL_LOCK_ATTEMPTS,
+    delayMs: POOL_LOCK_DELAY_MS,
+    staleMs: POOL_STALE_LOCK_MS
+  },
+  async () => {
+    const loaded = await loadObservationPoolAsync(agentDir);
+    if (loaded.error) throw new Error(loaded.error);
+    const target = poolPath(observationPoolDirectory(agentDir));
+    const serialized = `${JSON.stringify(file, null, 2)}
+`;
+    try {
+      if (await fs.promises.readFile(target, "utf8") === serialized) {
+        return { file, written: false };
+      }
+    } catch {
+    }
+    await writeJsonAtomicAsync(target, file, {
+      space: 2,
+      newline: true,
+      mode: 384,
+      dirMode: 448
+    });
+    return { file, written: true };
+  }
+);
+
+// src/entropy/surface.ts
+var SURFACE_LIST_LIMIT = 1e3;
+var surfaceInvocationContext = (input) => ({
+  cwd: input.cwd,
+  signal: void 0,
+  parentToolCallId: "fabric-entropy-surface",
+  nestedToolCallId: "fabric-entropy-surface",
+  extensionContext: input.extensionContext,
+  update: () => {
+  }
+});
+var liveSurfaceSnapshot = async (input) => {
+  const actions = await input.registry.list(
+    { limit: SURFACE_LIST_LIMIT, declared: true },
+    surfaceInvocationContext(input)
+  );
+  return {
+    version: 1,
+    actions: actions.map((action) => ({ ref: action.ref, inputSchema: action.inputSchema })).sort((left, right) => compareCodeUnits(left.ref, right.ref))
+  };
+};
+var entropySurfaceHash = (surface) => stableJsonHash(surface);
+var surfaceFreedomReport = (surface) => {
+  const actions = surface.actions.map((action) => ({ ref: action.ref, freedom: staticFreedomFromSchema(action.inputSchema) })).sort((left, right) => right.freedom - left.freedom || compareCodeUnits(left.ref, right.ref));
+  const total = roundMetric(actions.reduce((sum, entry) => sum + entry.freedom, 0));
+  return {
+    actions,
+    total,
+    mean: actions.length > 0 ? roundMetric(total / actions.length) : 0
+  };
+};
+
+// src/entropy/compiler.ts
+var AUTO_APPLY_PROPOSAL_KINDS = ["enum-tighten", "noise-quarantine"];
+var entropyReviewSignals = (input) => proposeEntropyReductions(input).filter(
+  (proposal) => !AUTO_APPLY_PROPOSAL_KINDS.includes(proposal.kind)
+);
+var formatEntropyReviewSignal = (proposal) => {
+  if (proposal.kind === "declare-enum") {
+    const values = proposal.values.slice(0, 4).map((value) => String(value)).join(", ");
+    return `declare-enum ${proposal.ref}.${proposal.key} (${values}${proposal.values.length > 4 ? ", ..." : ""})`;
+  }
+  if (proposal.kind === "overload-split") {
+    return `overload-split ${proposal.ref} (${proposal.clusters.length} key-set clusters)`;
+  }
+  if (proposal.kind === "sequence-fuse") {
+    return `sequence-fuse ${proposal.sequence.join(" -> ")}`;
+  }
+  return `${proposal.kind} ${proposal.ref}`;
+};
+var proposalDetail = (proposal) => {
+  if (proposal.kind === "enum-tighten") {
+    return { ref: proposal.ref, detail: `${proposal.key}: ${proposal.values.length} observed values` };
+  }
+  if (proposal.kind === "noise-quarantine") {
+    return { ref: proposal.ref, detail: `${proposal.failed} failed vs ${proposal.succeeded} succeeded` };
+  }
+  return { ref: "n/a", detail: "review-only" };
+};
+var touchedRefs = (before, after) => {
+  const beforeByRef = new Map(before.actions.map((action) => [action.ref, action.inputSchema]));
+  const touched = /* @__PURE__ */ new Set();
+  for (const action of after.actions) {
+    if (stableJsonHash(beforeByRef.get(action.ref)) !== stableJsonHash(action.inputSchema)) {
+      touched.add(action.ref);
+    }
+  }
+  for (const ref of beforeByRef.keys()) {
+    if (!after.actions.some((action) => action.ref === ref)) touched.add(ref);
+  }
+  return touched;
+};
+var artifactFromCandidate = (live, candidate, proposals, gate, evidenceDigest, previous) => {
+  const liveByRef = new Map(live.actions.map((action) => [action.ref, action.inputSchema]));
+  const actions = candidate.actions.filter(
+    (action) => stableJsonHash(action.inputSchema) !== stableJsonHash(liveByRef.get(action.ref))
+  ).map((action) => ({
+    ref: action.ref,
+    inputSchema: action.inputSchema,
+    baseSchemaDigest: schemaDigest(liveByRef.get(action.ref))
+  }));
+  const candidateRefs = new Set(candidate.actions.map((action) => action.ref));
+  const quarantined = live.actions.filter((action) => !candidateRefs.has(action.ref)).map((action) => ({ ref: action.ref, baseSchemaDigest: schemaDigest(action.inputSchema) }));
+  const applied = [...previous?.applied ?? []];
+  const seen = new Set(applied.map((entry) => `${entry.kind}:${entry.ref}:${entry.detail}`));
+  for (const proposal of proposals) {
+    const { ref, detail } = proposalDetail(proposal);
+    const identity = `${proposal.kind}:${ref}:${detail}`;
+    if (seen.has(identity)) continue;
+    seen.add(identity);
+    applied.push({ kind: proposal.kind, ref, detail });
+  }
+  return {
+    version: COMPILED_SURFACE_VERSION,
+    metricVersion: ENTROPY_METRIC_VERSION,
+    actions,
+    quarantined,
+    applied: applied.slice(0, MAX_COMPILED_SURFACE_PROPOSALS),
+    gate,
+    evidenceDigest
+  };
+};
+var compileEntropySurface = (input) => {
+  const effective = applyCompiledSurface(input.surface, input.artifact);
+  const report = measureEntropy({
+    traces: input.traces,
+    surface: effective,
+    ...input.repairs ? { repairs: input.repairs } : {},
+    catalogDigest: input.catalogDigest ?? entropySurfaceHash(effective)
+  });
+  const proposals = proposeEntropyReductions({
+    report,
+    traces: input.traces,
+    surface: effective,
+    ...input.repairs ? { repairs: input.repairs } : {},
+    ...input.valueObservations ? { valueObservations: input.valueObservations } : {}
+  });
+  const auto = proposals.filter(
+    (proposal) => AUTO_APPLY_PROPOSAL_KINDS.includes(proposal.kind)
+  );
+  if (auto.length === 0) {
+    return {
+      status: "converged",
+      ...input.artifact ? { artifact: input.artifact } : {},
+      report,
+      proposals
+    };
+  }
+  const candidate = applyProposalsToSurface(effective, auto);
+  const after = measureEntropy({
+    traces: input.traces,
+    surface: candidate,
+    ...input.repairs ? { repairs: input.repairs } : {},
+    catalogDigest: entropySurfaceHash(candidate)
+  });
+  const scoreGate = evaluateGate(report, after);
+  const violations = replaySuccessfulCalls(
+    candidate,
+    effective,
+    input.traces,
+    touchedRefs(effective, candidate),
+    input.auditCalls
+  );
+  const reasons = [
+    ...scoreGate.reasons,
+    ...violations.map((violation) => `${violation.ref}: ${violation.reason}`)
+  ];
+  const gate = {
+    passed: scoreGate.passed && violations.length === 0,
+    beforeScore: report.score,
+    afterScore: after.score,
+    delta: scoreGate.delta,
+    reasons: scoreGate.passed && violations.length === 0 ? [] : reasons
+  };
+  if (gate.passed) {
+    const evidenceDigest = stableJsonHash({
+      traces: input.traces.length,
+      operations: report.totals.operations,
+      succeeded: report.totals.succeeded,
+      failed: report.totals.failed,
+      surface: entropySurfaceHash(effective),
+      repairs: input.repairs?.length ?? 0,
+      valueObservations: stableJsonHash(input.valueObservations ?? []),
+      auditCalls: stableJsonHash(input.auditCalls ?? [])
+    });
+    return {
+      status: "compiled",
+      artifact: artifactFromCandidate(
+        input.surface,
+        candidate,
+        auto,
+        { passed: true, beforeScore: report.score, afterScore: after.score, reasons: [] },
+        evidenceDigest,
+        input.artifact
+      ),
+      report,
+      after,
+      proposals,
+      gate
+    };
+  }
+  return {
+    status: "rejected",
+    ...input.artifact ? { artifact: input.artifact } : {},
+    report,
+    after,
+    proposals,
+    gate
+  };
+};
+var yieldToLoop3 = () => new Promise((resolve) => setImmediate(resolve));
+var compileEntropySurfaceAsync = async (input) => {
+  const effective = applyCompiledSurface(input.surface, input.artifact);
+  const report = await measureEntropyAsync({
+    traces: input.traces,
+    surface: effective,
+    ...input.repairs ? { repairs: input.repairs } : {},
+    catalogDigest: input.catalogDigest ?? entropySurfaceHash(effective)
+  });
+  await yieldToLoop3();
+  const proposals = proposeEntropyReductions({
+    report,
+    traces: input.traces,
+    surface: effective,
+    ...input.repairs ? { repairs: input.repairs } : {},
+    ...input.valueObservations ? { valueObservations: input.valueObservations } : {}
+  });
+  const auto = proposals.filter(
+    (proposal) => AUTO_APPLY_PROPOSAL_KINDS.includes(proposal.kind)
+  );
+  if (auto.length === 0) {
+    return {
+      status: "converged",
+      ...input.artifact ? { artifact: input.artifact } : {},
+      report,
+      proposals
+    };
+  }
+  await yieldToLoop3();
+  const candidate = applyProposalsToSurface(effective, auto);
+  const after = await measureEntropyAsync({
+    traces: input.traces,
+    surface: candidate,
+    ...input.repairs ? { repairs: input.repairs } : {},
+    catalogDigest: entropySurfaceHash(candidate)
+  });
+  const scoreGate = evaluateGate(report, after);
+  await yieldToLoop3();
+  const violations = await replaySuccessfulCallsAsync(
+    candidate,
+    effective,
+    input.traces,
+    touchedRefs(effective, candidate),
+    input.auditCalls
+  );
+  const reasons = [
+    ...scoreGate.reasons,
+    ...violations.map((violation) => `${violation.ref}: ${violation.reason}`)
+  ];
+  const gate = {
+    passed: scoreGate.passed && violations.length === 0,
+    beforeScore: report.score,
+    afterScore: after.score,
+    delta: scoreGate.delta,
+    reasons: scoreGate.passed && violations.length === 0 ? [] : reasons
+  };
+  if (gate.passed) {
+    const [valueObservationsDigest, auditCallsDigest] = await Promise.all([
+      stableJsonHashArrayAsync(input.valueObservations ?? []),
+      stableJsonHashArrayAsync(input.auditCalls ?? [])
+    ]);
+    const evidenceDigest = stableJsonHash({
+      traces: input.traces.length,
+      operations: report.totals.operations,
+      succeeded: report.totals.succeeded,
+      failed: report.totals.failed,
+      surface: entropySurfaceHash(effective),
+      repairs: input.repairs?.length ?? 0,
+      valueObservations: valueObservationsDigest,
+      auditCalls: auditCallsDigest
+    });
+    return {
+      status: "compiled",
+      artifact: artifactFromCandidate(
+        input.surface,
+        candidate,
+        auto,
+        { passed: true, beforeScore: report.score, afterScore: after.score, reasons: [] },
+        evidenceDigest,
+        input.artifact
+      ),
+      report,
+      after,
+      proposals,
+      gate
+    };
+  }
+  return {
+    status: "rejected",
+    ...input.artifact ? { artifact: input.artifact } : {},
+    report,
+    after,
+    proposals,
+    gate
+  };
+};
+
+// src/entropy/presentation.ts
+var METRIC_PRECISION = 6;
+var MAX_APPLIED_DETAILS = 3;
+var MAX_VALUE_LENGTH = 32;
+var ENTROPY_COMMAND_HINTS = [
+  {
+    label: "export",
+    command: "/fabric entropy export [path]",
+    comment: "snapshot the live surface (default <agent dir>/fabric/entropy/surface.json)"
+  },
+  {
+    label: "share",
+    command: "/fabric entropy export-artifact [path]",
+    comment: "write the compiled artifact (default <agent dir>/fabric/entropy/artifact.json)"
+  },
+  {
+    label: "merge",
+    command: "/fabric entropy import <path>",
+    comment: "merge a peer artifact (digest-proven entries only)"
+  }
+];
+var formatEntropyMetric = (value) => value.toFixed(METRIC_PRECISION);
+var formatEntropyCommandHints = () => {
+  const heads = ENTROPY_COMMAND_HINTS.map((hint) => `${hint.label}: ${hint.command}`);
+  const commentColumn = Math.max(...heads.map((head) => head.length)) + 2;
+  return ENTROPY_COMMAND_HINTS.map(
+    (hint, index) => `${heads[index].padEnd(commentColumn)}# ${hint.comment}`
+  );
+};
+var formatDuration = (elapsedMs) => elapsedMs >= 1e3 ? `${(elapsedMs / 1e3).toFixed(1)}s` : `${Math.max(1, Math.round(elapsedMs))}ms`;
+var formatValue = (value) => {
+  const rendered = typeof value === "string" ? value.replace(/\s+/gu, " ").trim() || '""' : String(value);
+  return rendered.length <= MAX_VALUE_LENGTH ? rendered : `${rendered.slice(0, MAX_VALUE_LENGTH - 1)}\u2026`;
+};
+var formatValues = (values) => `{${values.map(formatValue).join(", ")}}`;
+var autoProposal = (proposal) => proposal.kind === "enum-tighten" || proposal.kind === "noise-quarantine";
+var formatApplied = (proposal) => {
+  if (proposal.kind === "enum-tighten") {
+    return `tightened ${proposal.ref}.${proposal.key} to ${formatValues(proposal.values)}`;
+  }
+  if (proposal.kind === "noise-quarantine") {
+    return `hid ${proposal.ref} (${proposal.failed} failed, ${proposal.succeeded} succeeded)`;
+  }
+  return proposal.kind;
+};
+var scoreChange = (before, after) => {
+  if (before === after) {
+    return `entropy score unchanged at ${formatEntropyMetric(before)} (lower is better)`;
+  }
+  let precision = METRIC_PRECISION;
+  while (precision < 12 && before.toFixed(precision) === after.toFixed(precision)) precision += 1;
+  const delta = after - before;
+  const format = (value) => value.toFixed(precision);
+  const absoluteDelta = format(Math.abs(delta));
+  const renderedDelta = Number(absoluteDelta) === 0 ? Math.abs(delta).toExponential(2) : absoluteDelta;
+  return `entropy score ${delta < 0 ? "improved" : "changed"} ${format(before)} \u2192 ${format(after)} (${delta > 0 ? "+" : "\u2212"}${renderedDelta}; lower is better)`;
+};
+var entropyReviewKey = (proposals) => {
+  const identities = proposals.map((proposal) => {
+    if (proposal.kind === "declare-enum") {
+      return JSON.stringify([
+        proposal.kind,
+        proposal.ref,
+        proposal.key,
+        proposal.values.map((value) => [typeof value, value])
+      ]);
+    }
+    if (proposal.kind === "overload-split") {
+      return JSON.stringify([
+        proposal.kind,
+        proposal.ref,
+        proposal.clusters.map((cluster) => cluster.keys)
+      ]);
+    }
+    if (proposal.kind === "sequence-fuse") {
+      return JSON.stringify([proposal.kind, proposal.sequence]);
+    }
+    return JSON.stringify([proposal.kind, proposal.ref]);
+  });
+  identities.sort();
+  return JSON.stringify(identities);
+};
+var reviewLabel = (kind, count) => {
+  const noun = kind === "declare-enum" ? "enum declaration" : kind === "overload-split" ? "action split" : kind === "sequence-fuse" ? "sequence fusion" : kind;
+  return `${count} ${noun}${count === 1 ? "" : "s"}`;
+};
+var formatEntropyReviewNotice = (proposals) => {
+  const counts = /* @__PURE__ */ new Map();
+  for (const proposal of proposals) counts.set(proposal.kind, (counts.get(proposal.kind) ?? 0) + 1);
+  const summary = [...counts.entries()].map(([kind, count]) => reviewLabel(kind, count)).join(" \xB7 ");
+  return `entropy: ${proposals.length} suggestion${proposals.length === 1 ? "" : "s"} await review${summary ? ` \xB7 ${summary}` : ""} \xB7 inspect with /fabric entropy`;
+};
+var formatEntropyCompileNotice = (input) => {
+  const applied = input.proposals.filter(autoProposal);
+  const details = applied.slice(0, MAX_APPLIED_DETAILS).map(formatApplied);
+  if (applied.length > MAX_APPLIED_DETAILS) {
+    details.push(`+${applied.length - MAX_APPLIED_DETAILS} more`);
+  }
+  if (details.length === 0) details.push("surface updated");
+  const review = input.reviewCount ? ` \xB7 ${input.reviewCount} suggestion${input.reviewCount === 1 ? "" : "s"} await review (/fabric entropy)` : "";
+  return `entropy: background optimization complete (${formatDuration(input.elapsedMs)}) \xB7 ${details.join(" \xB7 ")} \xB7 ${scoreChange(input.beforeScore, input.afterScore)} \xB7 safety checks passed${review}`;
+};
+
+// src/entropy/corpus.ts
+var DEFAULT_TASK_KEY2 = "(none)";
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var entropyTraceFromFabricTrace = (trace, model) => ({
+  operations: trace.operations.map((operation) => ({
+    ref: operation.ref,
+    args: operation.args,
+    outcome: operation.outcome,
+    ...operation.failureStage !== void 0 ? { failureStage: operation.failureStage } : {}
+  })),
+  taskKey: trace.phases[0] ?? DEFAULT_TASK_KEY2,
+  ...model ? { model } : {}
+});
+var MODEL_CHANGE_FILTER = '"type":"model_change"';
+var ASSISTANT_FILTER = '"role":"assistant"';
+var modelFromRecord = (parsed) => {
+  if (parsed.type === "model_change") {
+    const provider2 = typeof parsed.provider === "string" ? parsed.provider : "";
+    const modelId2 = typeof parsed.modelId === "string" ? parsed.modelId : "";
+    return provider2 && modelId2 ? `${provider2}/${modelId2}` : void 0;
+  }
+  const message = isRecord2(parsed.message) ? parsed.message : void 0;
+  if (!message || message.role !== "assistant") return void 0;
+  const provider = typeof message.provider === "string" ? message.provider : "";
+  const modelId = typeof message.model === "string" ? message.model : "";
+  return provider && modelId ? `${provider}/${modelId}` : void 0;
+};
+var scanSessionLine = (line, state) => {
+  if (line === "") return void 0;
+  const traceLine = line.includes(FABRIC_EXECUTION_TRACE_KIND);
+  const modelLine = !traceLine && (line.includes(MODEL_CHANGE_FILTER) || line.includes(ASSISTANT_FILTER));
+  if (!traceLine && !modelLine) return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(line.trim());
+  } catch {
+    return void 0;
+  }
+  if (!isRecord2(parsed)) return void 0;
+  if (modelLine) {
+    const model = modelFromRecord(parsed);
+    if (model) state.currentModel = model;
+    return void 0;
+  }
+  const details = isRecord2(parsed.details) ? parsed.details : isRecord2(parsed.message) && isRecord2(parsed.message.details) ? parsed.message.details : void 0;
+  return isRecord2(details) ? { details, ...state.currentModel ? { model: state.currentModel } : {} } : void 0;
+};
+var emptySessionEvidence = () => ({
+  traces: [],
+  valueObservations: [],
+  auditCalls: []
+});
+var appendSessionRecord = (evidence, record) => {
+  const trace = readFabricExecutionTraceV1(record.details.trace);
+  if (trace) evidence.traces.push(entropyTraceFromFabricTrace(trace, record.model));
+  const audits = record.details.audits;
+  if (!Array.isArray(audits)) return;
+  for (const audit of audits) {
+    if (!isRecord2(audit)) continue;
+    const ref = typeof audit.ref === "string" ? audit.ref : void 0;
+    const args = isRecord2(audit.args) ? audit.args : void 0;
+    if (!ref || !args) continue;
+    evidence.auditCalls.push({ ref, args });
+    for (const [key, value] of Object.entries(args)) {
+      if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        evidence.valueObservations.push({ ref, key, value });
+      }
+    }
+  }
+};
+var entropySessionEvidenceFromJsonl = (lines) => {
+  const evidence = emptySessionEvidence();
+  const state = {};
+  for (const line of lines) {
+    const record = scanSessionLine(line, state);
+    if (record) appendSessionRecord(evidence, record);
+  }
+  return evidence;
+};
+var scanEntropySessionJsonlAsync = async (lines, initialModel) => {
+  const evidence = emptySessionEvidence();
+  const state = {
+    ...initialModel ? { currentModel: initialModel } : {}
+  };
+  for await (const line of lines) {
+    const record = scanSessionLine(line, state);
+    if (record) appendSessionRecord(evidence, record);
+  }
+  return {
+    evidence,
+    ...state.currentModel ? { currentModel: state.currentModel } : {}
+  };
+};
+var entropySessionEvidenceFromJsonlAsync = async (lines) => (await scanEntropySessionJsonlAsync(lines)).evidence;
+var entropyTracesFromSessionJsonl = (lines) => entropySessionEvidenceFromJsonl(lines).traces;
+var entropyValueObservationsFromSessionJsonl = (lines) => entropySessionEvidenceFromJsonl(lines).valueObservations;
+var entropyAuditCallsFromSessionJsonl = (lines) => entropySessionEvidenceFromJsonl(lines).auditCalls;
+var entropyRepairRows = (repairs) => repairs.map(
+  (repair) => repair.kind === "keyAlias" ? { kind: "keyAlias", ref: repair.ref, from: repair.from, to: repair.to } : {
+    kind: "actionAlias",
+    ref: `${repair.provider}.${repair.to}`,
+    from: repair.from,
+    to: repair.to
+  }
+);
+var entropyReportHash = (report) => stableJsonHash(report);
+
+// src/entropy/sessions.ts
+import fs2 from "node:fs";
+import path2 from "node:path";
+import { createInterface } from "node:readline";
+var DEFAULT_SESSION_WINDOW = 8;
+var SESSION_STAT_CONCURRENCY = 32;
+var SESSION_READ_CONCURRENCY = 4;
+var SESSION_EVIDENCE_CACHE_LIMIT = 16;
+var asyncEvidenceCache = /* @__PURE__ */ new Map();
+var mapConcurrent = async (items, limit, fn) => {
+  const results = new Array(items.length);
+  let cursor = 0;
+  const worker = async () => {
+    for (; ; ) {
+      const index = cursor++;
+      if (index >= items.length) return;
+      results[index] = await fn(items[index]);
+    }
+  };
+  await Promise.all(
+    Array.from({ length: Math.min(limit, items.length) }, () => worker())
+  );
+  return results;
+};
+var byNewestSession = (left, right) => right.mtime - left.mtime || (left.file < right.file ? -1 : left.file > right.file ? 1 : 0);
+var stampSessionFiles = async (files) => mapConcurrent(files, SESSION_STAT_CONCURRENCY, async (file) => {
+  let mtime = 0;
+  try {
+    mtime = (await fs2.promises.stat(file)).mtimeMs;
+  } catch {
+  }
+  return { file, mtime };
+});
+var projectSessionFiles = (agentDir, cwd, limit = DEFAULT_SESSION_WINDOW) => {
+  const dir = sessionDirForCwd(cwd, agentDir);
+  let entries = [];
+  try {
+    entries = fs2.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const stamped = entries.filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl")).map((entry) => {
+    const file = path2.join(dir, entry.name);
+    let mtime = 0;
+    try {
+      mtime = fs2.statSync(file).mtimeMs;
+    } catch {
+      mtime = 0;
+    }
+    return { file, mtime };
+  });
+  stamped.sort(
+    (left, right) => right.mtime - left.mtime || (left.file < right.file ? -1 : left.file > right.file ? 1 : 0)
+  );
+  return stamped.slice(0, Math.max(1, limit)).map((entry) => entry.file);
+};
+var machineSessionFiles = (agentDir, cwd, limit = DEFAULT_SESSION_WINDOW) => {
+  const root = sessionsDirRoot(agentDir);
+  let projectDirs = [];
+  try {
+    projectDirs = fs2.readdirSync(root, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const byNewest = (left, right) => right.mtime - left.mtime || (left.file < right.file ? -1 : left.file > right.file ? 1 : 0);
+  const stamped = [];
+  const directories = projectDirs.filter((entry) => entry.isDirectory()).sort((left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0);
+  for (const directory of directories) {
+    let entries = [];
+    try {
+      entries = fs2.readdirSync(path2.join(root, directory.name), { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries.filter(
+      (candidate) => candidate.isFile() && candidate.name.endsWith(".jsonl")
+    )) {
+      const file = path2.join(root, directory.name, entry.name);
+      let mtime = 0;
+      try {
+        mtime = fs2.statSync(file).mtimeMs;
+      } catch {
+        mtime = 0;
+      }
+      stamped.push({ file, mtime });
+    }
+  }
+  stamped.sort(byNewest);
+  const window = Math.max(1, limit);
+  let selected = stamped.slice(0, window);
+  if (cwd) {
+    const current = projectSessionFiles(agentDir, cwd, 1)[0];
+    if (current !== void 0 && !selected.some((entry) => entry.file === current)) {
+      const kept = [...selected];
+      if (kept.length >= window) kept.length = window - 1;
+      let mtime = 0;
+      try {
+        mtime = fs2.statSync(current).mtimeMs;
+      } catch {
+        mtime = 0;
+      }
+      kept.push({ file: current, mtime });
+      kept.sort(byNewest);
+      selected = kept;
+    }
+  }
+  return selected.map((entry) => entry.file);
+};
+var projectSessionFilesAsync = async (agentDir, cwd, limit = DEFAULT_SESSION_WINDOW) => {
+  const dir = sessionDirForCwd(cwd, agentDir);
+  let entries;
+  try {
+    entries = await fs2.promises.readdir(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const files = entries.filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl")).map((entry) => path2.join(dir, entry.name));
+  const stamped = await stampSessionFiles(files);
+  stamped.sort(byNewestSession);
+  return stamped.slice(0, Math.max(1, limit)).map((entry) => entry.file);
+};
+var machineSessionFilesAsync = async (agentDir, cwd, limit = DEFAULT_SESSION_WINDOW) => {
+  const root = sessionsDirRoot(agentDir);
+  let projectDirs;
+  try {
+    projectDirs = await fs2.promises.readdir(root, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const directories = projectDirs.filter((entry) => entry.isDirectory()).sort((left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0);
+  const filesByDirectory = await mapConcurrent(
+    directories,
+    SESSION_STAT_CONCURRENCY,
+    async (directory) => {
+      const dir = path2.join(root, directory.name);
+      try {
+        return (await fs2.promises.readdir(dir, { withFileTypes: true })).filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl")).map((entry) => path2.join(dir, entry.name));
+      } catch {
+        return [];
+      }
+    }
+  );
+  const stamped = await stampSessionFiles(filesByDirectory.flat());
+  stamped.sort(byNewestSession);
+  const window = Math.max(1, limit);
+  let selected = stamped.slice(0, window);
+  if (cwd) {
+    const current = (await projectSessionFilesAsync(agentDir, cwd, 1))[0];
+    if (current !== void 0 && !selected.some((entry) => entry.file === current)) {
+      const kept = [...selected];
+      if (kept.length >= window) kept.length = window - 1;
+      const [stampedCurrent] = await stampSessionFiles([current]);
+      if (stampedCurrent) kept.push(stampedCurrent);
+      kept.sort(byNewestSession);
+      selected = kept;
+    }
+  }
+  return selected.map((entry) => entry.file);
+};
+var finalizeSessionCorpus = (files, sessions) => {
+  const chronological = [...sessions].reverse();
+  const modelScores = /* @__PURE__ */ new Map();
+  for (const session of chronological) {
+    for (const model of session.report.byModel) {
+      const entry = modelScores.get(model.model) ?? { behavioral: [], latest: model };
+      entry.behavioral.push(model.behavioralScore);
+      entry.latest = model;
+      modelScores.set(model.model, entry);
+    }
+  }
+  const models = [...modelScores.entries()].sort(([left], [right]) => compareCodeUnits(left, right)).map(([model, entry]) => ({
+    model,
+    sessions: entry.behavioral.length,
+    latestBehavioralScore: entry.latest.behavioralScore,
+    slopePerSession: trendFromScores(entry.behavioral).slopePerStep,
+    latestRejectionsPer1k: entry.latest.invocationRejectionsPer1k
+  }));
+  return {
+    files,
+    sessions,
+    ...sessions.length > 0 ? { latest: sessions[0].report } : {},
+    trend: trendFromScores(chronological.map((session) => session.report.score)),
+    models
+  };
+};
+var measureSessionCorpus = (input) => {
+  const sessions = [];
+  for (const file of input.files) {
+    let text;
+    try {
+      text = fs2.readFileSync(file, "utf8");
+    } catch {
+      continue;
+    }
+    const traces = entropyTracesFromSessionJsonl(text.split("\n"));
+    if (traces.length === 0) continue;
+    const report = measureEntropy({
+      traces,
+      ...input.surface ? { surface: input.surface } : {},
+      ...input.catalogDigest !== void 0 ? { catalogDigest: input.catalogDigest } : {}
+    });
+    if (report.totals.operations === 0) continue;
+    sessions.push({ file, operations: report.totals.operations, report });
+  }
+  return finalizeSessionCorpus(input.files, sessions);
+};
+var sessionMetadata = async (file) => {
+  try {
+    const entry = await fs2.promises.stat(file);
+    return {
+      size: entry.size,
+      mtimeMs: entry.mtimeMs,
+      dev: entry.dev,
+      ino: entry.ino
+    };
+  } catch {
+    return void 0;
+  }
+};
+var endsAtLineBoundary = async (file, metadata) => {
+  if (metadata.size === 0) return true;
+  let handle;
+  try {
+    handle = await fs2.promises.open(file, "r");
+    const byte = Buffer.allocUnsafe(1);
+    const { bytesRead } = await handle.read(byte, 0, 1, metadata.size - 1);
+    return bytesRead === 1 && byte[0] === 10;
+  } catch {
+    return false;
+  } finally {
+    await handle?.close().catch(() => void 0);
+  }
+};
+var scanSessionRange = async (file, start, end, initialModel) => {
+  const input = fs2.createReadStream(file, { encoding: "utf8", start, end });
+  const lines = createInterface({ input, crlfDelay: Infinity });
+  try {
+    return await scanEntropySessionJsonlAsync(lines, initialModel);
+  } finally {
+    lines.close();
+    input.destroy();
+  }
+};
+var evidenceWindow = (file, evidence) => ({
+  traces: evidence.traces,
+  valueObservations: evidence.valueObservations,
+  auditCalls: evidence.auditCalls,
+  observationWindows: [{ file, observations: evidence.valueObservations }]
+});
+var cacheSessionEvidence = (file, cached) => {
+  asyncEvidenceCache.delete(file);
+  asyncEvidenceCache.set(file, cached);
+  while (asyncEvidenceCache.size > SESSION_EVIDENCE_CACHE_LIMIT) {
+    asyncEvidenceCache.delete(asyncEvidenceCache.keys().next().value);
+  }
+};
+var sameSessionFile = (cached, metadata) => cached.dev === metadata.dev && cached.ino === metadata.ino;
+var readSessionEvidenceAsync = async (file) => {
+  const metadata = await sessionMetadata(file);
+  if (!metadata) return void 0;
+  const cached = asyncEvidenceCache.get(file);
+  if (cached && sameSessionFile(cached, metadata) && cached.size === metadata.size && Math.abs(cached.mtimeMs - metadata.mtimeMs) <= 1e-6) {
+    cacheSessionEvidence(file, cached);
+    return evidenceWindow(file, cached.evidence);
+  }
+  const append = cached && sameSessionFile(cached, metadata) && metadata.size > cached.size ? cached : void 0;
+  const start = append ? append.size : 0;
+  let scan;
+  try {
+    scan = metadata.size === start ? {
+      evidence: { traces: [], valueObservations: [], auditCalls: [] },
+      ...append?.currentModel ? { currentModel: append.currentModel } : {}
+    } : await scanSessionRange(
+      file,
+      start,
+      metadata.size - 1,
+      append?.currentModel
+    );
+  } catch {
+    return void 0;
+  }
+  const evidence = append ? {
+    traces: [...append.evidence.traces, ...scan.evidence.traces],
+    valueObservations: [
+      ...append.evidence.valueObservations,
+      ...scan.evidence.valueObservations
+    ],
+    auditCalls: [...append.evidence.auditCalls, ...scan.evidence.auditCalls]
+  } : scan.evidence;
+  if (await endsAtLineBoundary(file, metadata)) {
+    cacheSessionEvidence(file, {
+      ...metadata,
+      ...scan.currentModel ? { currentModel: scan.currentModel } : {},
+      evidence
+    });
+  } else {
+    asyncEvidenceCache.delete(file);
+  }
+  return evidenceWindow(file, evidence);
+};
+var sessionWindowEvidenceAsync = async (files) => {
+  const windows = await mapConcurrent(files, SESSION_READ_CONCURRENCY, readSessionEvidenceAsync);
+  const traces = [];
+  const valueObservations = [];
+  const auditCalls = [];
+  const observationWindows = [];
+  for (const window of windows) {
+    if (!window) continue;
+    traces.push(...window.traces);
+    valueObservations.push(...window.valueObservations);
+    auditCalls.push(...window.auditCalls);
+    observationWindows.push(...window.observationWindows);
+  }
+  return { traces, valueObservations, auditCalls, observationWindows };
+};
+var measureSessionCorpusAsync = async (input) => {
+  const windows = await mapConcurrent(
+    input.files,
+    SESSION_READ_CONCURRENCY,
+    readSessionEvidenceAsync
+  );
+  const sessions = [];
+  for (let index = 0; index < input.files.length; index++) {
+    const window = windows[index];
+    const file = input.files[index];
+    if (!window || !file || window.traces.length === 0) continue;
+    const report = await measureEntropyAsync({
+      traces: window.traces,
+      ...input.surface ? { surface: input.surface } : {},
+      ...input.catalogDigest !== void 0 ? { catalogDigest: input.catalogDigest } : {}
+    });
+    if (report.totals.operations === 0) continue;
+    sessions.push({ file, operations: report.totals.operations, report });
+  }
+  return finalizeSessionCorpus(input.files, sessions);
+};
+var sessionWindowEvidence = (files) => {
+  const traces = [];
+  const valueObservations = [];
+  const auditCalls = [];
+  const observationWindows = [];
+  for (const file of files) {
+    let text;
+    try {
+      text = fs2.readFileSync(file, "utf8");
+    } catch {
+      continue;
+    }
+    const evidence = entropySessionEvidenceFromJsonl(text.split("\n"));
+    traces.push(...evidence.traces);
+    valueObservations.push(...evidence.valueObservations);
+    auditCalls.push(...evidence.auditCalls);
+    observationWindows.push({ file, observations: evidence.valueObservations });
+  }
+  return { traces, valueObservations, auditCalls, observationWindows };
+};
+
+// src/entropy/trial.ts
+import { isJsonSchemaValueValid } from "@oh-my-pi/pi-ai/utils/schema";
+var isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var accepts = (schema, args) => {
+  try {
+    return isRecord3(schema) && isJsonSchemaValueValid(schema, args);
+  } catch {
+    return false;
+  }
+};
+var trialClassFields = {
+  "both-accept": "bothAccept",
+  "both-reject": "bothReject",
+  "tightening-cost": "tighteningCost",
+  "typed-failure-win": "typedFailureWin",
+  "quarantine-win": "quarantineWin",
+  "quarantine-cost": "quarantineCost"
+};
+var trialClassField = (trialClass) => trialClassFields[trialClass];
+var classify = (operation, declaredAccepts, compiledAccepts, quarantined) => {
+  if (quarantined) {
+    if (!declaredAccepts) return "both-reject";
+    return operation.outcome === "succeeded" ? "quarantine-cost" : "quarantine-win";
+  }
+  if (!declaredAccepts) return "both-reject";
+  if (compiledAccepts) return "both-accept";
+  return operation.outcome === "succeeded" ? "tightening-cost" : "typed-failure-win";
+};
+var runEntropyTrial = (input) => {
+  const effective = applyCompiledSurface(input.live, input.artifact);
+  const declaredByRef = new Map(
+    input.live.actions.map((action) => [action.ref, action.inputSchema])
+  );
+  const effectiveByRef = new Map(
+    effective.actions.map((action) => [action.ref, action.inputSchema])
+  );
+  const declaredReport = measureEntropy({
+    traces: input.traces,
+    surface: input.live,
+    catalogDigest: entropySurfaceHash(input.live)
+  });
+  const effectiveReport = measureEntropy({
+    traces: input.traces,
+    surface: effective,
+    catalogDigest: entropySurfaceHash(effective)
+  });
+  const totals = {
+    operations: 0,
+    bothAccept: 0,
+    bothReject: 0,
+    tighteningCost: 0,
+    typedFailureWin: 0,
+    quarantineWin: 0,
+    quarantineCost: 0
+  };
+  const divergenceCounts = /* @__PURE__ */ new Map();
+  const auditedArgsByRef = /* @__PURE__ */ new Map();
+  if (input.auditCalls) {
+    for (const call of input.auditCalls) {
+      if (declaredByRef.get(call.ref) === void 0) continue;
+      const bucket = auditedArgsByRef.get(call.ref) ?? [];
+      bucket.push(call.args);
+      auditedArgsByRef.set(call.ref, bucket);
+    }
+  }
+  for (const trace of input.traces) {
+    for (const operation of trace.operations) {
+      if (operation.ref.startsWith("fabric.")) continue;
+      const declared = declaredByRef.get(operation.ref);
+      if (declared === void 0) continue;
+      if (auditedArgsByRef.has(operation.ref)) continue;
+      const compiled = effectiveByRef.get(operation.ref);
+      const quarantined = compiled === void 0;
+      const trialClass = classify(
+        operation,
+        accepts(declared, operation.args),
+        quarantined ? false : accepts(compiled, operation.args),
+        quarantined
+      );
+      totals.operations++;
+      totals[trialClassField(trialClass)]++;
+      if (trialClass !== "both-accept" && trialClass !== "both-reject") {
+        const key = `${operation.ref}\0${trialClass}`;
+        divergenceCounts.set(key, (divergenceCounts.get(key) ?? 0) + 1);
+      }
+    }
+  }
+  for (const ref of [...auditedArgsByRef.keys()].sort(compareCodeUnits)) {
+    const declared = declaredByRef.get(ref);
+    const compiled = effectiveByRef.get(ref);
+    const quarantined = compiled === void 0;
+    for (const args of auditedArgsByRef.get(ref)) {
+      const declaredAccepts = accepts(declared, args);
+      const trialClass = !declaredAccepts ? "both-reject" : quarantined ? "quarantine-cost" : accepts(compiled, args) ? "both-accept" : "tightening-cost";
+      totals.operations++;
+      totals[trialClassField(trialClass)]++;
+      if (trialClass !== "both-accept" && trialClass !== "both-reject") {
+        const key = `${ref}\0${trialClass}`;
+        divergenceCounts.set(key, (divergenceCounts.get(key) ?? 0) + 1);
+      }
+    }
+  }
+  const hasEntries = (input.artifact?.actions.length ?? 0) + (input.artifact?.quarantined.length ?? 0) > 0;
+  const costs = totals.tighteningCost + totals.quarantineCost;
+  const verdict = !hasEntries || totals.operations === 0 ? "no-evidence" : costs === 0 ? "clean" : "costly";
+  const divergences = [...divergenceCounts.entries()].map(([key, count]) => {
+    const [ref, trialClass] = key.split("\0");
+    return { ref, trialClass, count };
+  }).sort(
+    (left, right) => compareCodeUnits(left.ref, right.ref) || compareCodeUnits(left.trialClass, right.trialClass)
+  );
+  return {
+    verdict,
+    declaredScore: declaredReport.score,
+    effectiveScore: effectiveReport.score,
+    delta: effectiveReport.score - declaredReport.score,
+    totals,
+    divergences
+  };
+};
+
+export {
+  ENTROPY_METRIC_VERSION,
+  ENTROPY_WEIGHTS,
+  ENTROPY_INVOCATION_STAGES,
+  roundMetric,
+  compareCodeUnits,
+  shapeSignature,
+  signatureDistance,
+  shannonEntropyBits,
+  staticFreedomFromSchema,
+  trendFromScores,
+  liveSurfaceSnapshot,
+  entropySurfaceHash,
+  surfaceFreedomReport,
+  entropyTraceFromFabricTrace,
+  entropySessionEvidenceFromJsonl,
+  scanEntropySessionJsonlAsync,
+  entropySessionEvidenceFromJsonlAsync,
+  entropyTracesFromSessionJsonl,
+  entropyValueObservationsFromSessionJsonl,
+  entropyAuditCallsFromSessionJsonl,
+  entropyRepairRows,
+  entropyReportHash,
+  measureEntropy,
+  measureEntropyAsync,
+  projectSessionFiles,
+  machineSessionFiles,
+  projectSessionFilesAsync,
+  machineSessionFilesAsync,
+  measureSessionCorpus,
+  sessionWindowEvidenceAsync,
+  measureSessionCorpusAsync,
+  sessionWindowEvidence,
+  ENTROPY_ENUM_CANDIDATE_ANNOTATION,
+  proposeEntropyReductions,
+  applyProposalsToSurface,
+  evaluateGate,
+  AUTO_APPLY_PROPOSAL_KINDS,
+  entropyReviewSignals,
+  formatEntropyReviewSignal,
+  compileEntropySurface,
+  compileEntropySurfaceAsync,
+  OBSERVATION_POOL_VERSION,
+  POOL_TRACKED_VALUES,
+  POOL_TRACKED_SESSIONS,
+  POOL_BAKED_DIGESTS,
+  observationIdentity,
+  observationWindowDigest,
+  mergeObservationWindow,
+  mergeObservationWindowAsync,
+  poolToValueObservations,
+  observationPoolDirectory,
+  loadObservationPool,
+  loadObservationPoolAsync,
+  saveObservationPool,
+  saveObservationPoolAsync,
+  formatEntropyMetric,
+  formatEntropyCommandHints,
+  entropyReviewKey,
+  formatEntropyReviewNotice,
+  formatEntropyCompileNotice,
+  runEntropyTrial
+};
+//# sourceMappingURL=chunk-ZNAJDPT7.js.map