pi-fabric 0.78.0 → 0.79.0

package/dist/chunks/chunk-5IFANSBG.js

@@ -0,0 +1,1046 @@
+import {
+  COMPILED_SURFACE_VERSION,
+  MAX_COMPILED_SURFACE_PROPOSALS,
+  applyCompiledSurface,
+  replaySuccessfulCalls,
+  schemaDigest
+} from "./chunk-OTB7OOQS.js";
+import {
+  sessionDirForCwd
+} from "./chunk-6GRNSFDJ.js";
+import {
+  stableJsonHash
+} from "./chunk-CIJPRYAP.js";
+import {
+  FABRIC_EXECUTION_TRACE_KIND,
+  readFabricExecutionTraceV1
+} from "./chunk-IDTQ2B5W.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 measureOnce = (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;
+  }
+  const 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
+  };
+  const refs = /* @__PURE__ */ new Map();
+  const taskSequences = /* @__PURE__ */ new Map();
+  let churnPairs = 0;
+  let churnSum = 0;
+  const accumulator = (ref) => {
+    const existing = 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
+    };
+    refs.set(ref, created);
+    return created;
+  };
+  for (const sourceTrace of input.traces) {
+    const taskKey = sourceTrace.taskKey ?? DEFAULT_TASK_KEY;
+    const sequence = [];
+    const pendingFailed = /* @__PURE__ */ new Map();
+    for (const operation of sourceTrace.operations) {
+      totals.operations += 1;
+      if (operation.ref.startsWith(DISCOVERY_PREFIX)) {
+        totals.discoveryOperations += 1;
+        continue;
+      }
+      if (operation.ref.startsWith(WORKFLOW_PREFIX)) {
+        totals.workflowOperations += 1;
+        continue;
+      }
+      totals.actionOperations += 1;
+      sequence.push(operation.ref);
+      const acc = accumulator(operation.ref);
+      acc.calls += 1;
+      if (operation.outcome === "succeeded") {
+        totals.succeeded += 1;
+        acc.succeeded += 1;
+      } else if (operation.outcome === "failed") {
+        totals.failed += 1;
+        acc.failed += 1;
+      } else if (operation.outcome === "aborted") {
+        totals.aborted += 1;
+      } else {
+        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)) totals.invocationRejections += 1;
+      }
+      const pending = pendingFailed.get(operation.ref);
+      if (pending !== void 0) {
+        const distance = signatureDistance(pending, signature);
+        acc.churnPairs += 1;
+        acc.churnSum += distance;
+        churnPairs += 1;
+        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 = taskSequences.get(taskKey) ?? /* @__PURE__ */ new Map();
+      perTask.set(key, (perTask.get(key) ?? 0) + 1);
+      taskSequences.set(taskKey, perTask);
+    }
+  }
+  const refEntries = [...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 = lexiconByRef.get(ref) ?? 0;
+    const staticFreedom = surfaceByRef.has(ref) ? staticFreedomFromSchema(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 = totals.actionOperations > 0 ? roundMetric(totals.discoveryOperations / totals.actionOperations) : 0;
+  let flowWeighted = 0;
+  let flowOccurrences = 0;
+  for (const perTask of 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;
+  totals.invocationRejectionsPer1k = totals.actionOperations > 0 ? roundMetric(totals.invocationRejections / totals.actionOperations * 1e3) : 0;
+  const score = roundMetric(
+    (scoreSum + ENTROPY_WEIGHTS.navigation * navigationRatio + ENTROPY_WEIGHTS.flow * flowEntropyBits) / Math.max(1, totals.succeeded)
+  );
+  const staticScore = roundMetric(staticWeighted / Math.max(1, 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,
+    shapeEntropyBits: totals.actionOperations > 0 ? roundMetric(shapeWeighted / totals.actionOperations) : 0,
+    failureStageEntropyBits: totals.failed > 0 ? roundMetric(failureStageWeighted / totals.failed) : 0,
+    churnRate: churnPairs > 0 ? roundMetric(churnSum / churnPairs) : 0,
+    navigationRatio,
+    flowEntropyBits,
+    lexiconRows,
+    staticFreedom: roundMetric(staticFreedomTotal),
+    staticScore,
+    behavioralScore,
+    score,
+    refs: sortedRefs
+  };
+};
+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 };
+};
+
+// 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 = 2;
+var QUARANTINE_MIN_CALLS = 3;
+var QUARANTINE_MIN_STAGE_ENTROPY_BITS = 1;
+var MAX_PROPOSALS_PER_KIND = 8;
+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 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) => {
+    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) + 1 });
+    entry.total += 1;
+    observations.set(id, entry);
+  };
+  if (input.valueObservations) {
+    for (const observation of input.valueObservations) {
+      observeValue(observation.ref, observation.key, observation.value);
+    }
+  } 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 enumCandidates = [...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).filter((candidate) => {
+    if (!input.surface) return true;
+    const properties = schemaProperties(surfaceByRef.get(candidate.entry.ref));
+    const target = properties ? properties[candidate.entry.key] : void 0;
+    const existing = enumKeys(target);
+    if (!existing) return true;
+    return [...candidate.entry.counts.keys()].some((observed) => !existing.has(observed));
+  }).sort(
+    (left, right) => compareCodeUnits(`${left.entry.ref}\0${left.entry.key}`, `${right.entry.ref}\0${right.entry.key}`)
+  ).slice(0, MAX_PROPOSALS_PER_KIND);
+  for (const candidate of enumCandidates) {
+    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.entry.counts.size,
+      topShare: candidate.topShare
+    });
+  }
+  const repairRows = [...input.repairs ?? []].sort(
+    (left, right) => compareCodeUnits(left.ref, right.ref) || compareCodeUnits(left.from, right.from) || compareCodeUnits(left.to, right.to)
+  );
+  for (const row of repairRows) {
+    if (!calledRefs.has(row.ref)) continue;
+    if (input.surface) {
+      if (row.kind === "keyAlias") {
+        const properties = schemaProperties(surfaceByRef.get(row.ref));
+        if (properties && row.from in properties) continue;
+      } else {
+        const provider = row.ref.split(".")[0] ?? row.ref;
+        if (surfaceRefs.has(`${provider}.${row.from}`)) continue;
+      }
+    }
+    proposals.push({
+      kind: "modal-rename",
+      level: row.kind === "keyAlias" ? "key" : "action",
+      ref: row.ref,
+      from: row.from,
+      to: row.to,
+      note: row.kind === "keyAlias" ? "the spilled spelling dominates observed calls; rename the declared key and retire the repair row" : "the spilled action name dominates observed calls; rename the declared action and retire the repair row"
+    });
+  }
+  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();
+  for (const sourceTrace of input.traces) {
+    const refs = sourceTrace.operations.filter((operation) => !operation.ref.startsWith("fabric.")).map((operation) => operation.ref);
+    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 < 2) continue;
+        const id = sequence.join("\u2192");
+        const entry = sequenceCounts.get(id) ?? { sequence, occurrences: 0 };
+        entry.occurrences += 1;
+        sequenceCounts.set(id, entry);
+      }
+    }
+  }
+  const fuseCandidates = [...sequenceCounts.values()].filter((entry) => entry.occurrences >= FUSE_MIN_OCCURRENCES).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 === "modal-rename" && proposal.level === "action") {
+      const provider = proposal.ref.split(".")[0] ?? proposal.ref;
+      const renamed = `${provider}.${proposal.from}`;
+      for (const action of actions) {
+        if (action.ref === proposal.ref) action.ref = renamed;
+      }
+      continue;
+    }
+    if (proposal.kind === "enum-tighten" || proposal.kind === "modal-rename" && proposal.level === "key") {
+      const action = actions.find((candidate) => candidate.ref === proposal.ref);
+      if (!action || !isPlainRecord2(action.inputSchema)) continue;
+      const schema = action.inputSchema;
+      const properties = schemaProperties(schema);
+      if (!properties) continue;
+      if (proposal.kind === "enum-tighten") {
+        if (!isPlainRecord2(properties[proposal.key])) continue;
+        properties[proposal.key] = {
+          ...properties[proposal.key],
+          enum: [...proposal.values]
+        };
+        continue;
+      }
+      if (!(proposal.to in properties) || proposal.from in properties) continue;
+      properties[proposal.from] = properties[proposal.to];
+      delete properties[proposal.to];
+      if (Array.isArray(schema.required)) {
+        schema.required = schema.required.map((key) => key === proposal.to ? proposal.from : key);
+      }
+    }
+  }
+  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/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 },
+    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 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,
+    input.traces,
+    touchedRefs(effective, candidate)
+  );
+  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
+    });
+    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/corpus.ts
+var DEFAULT_TASK_KEY2 = "(none)";
+var isRecord = (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 = isRecord(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 sessionRecords = (lines) => {
+  const records = [];
+  let currentModel;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed === "") continue;
+    const traceLine = trimmed.includes(FABRIC_EXECUTION_TRACE_KIND);
+    const modelLine = !traceLine && (trimmed.includes(MODEL_CHANGE_FILTER) || trimmed.includes(ASSISTANT_FILTER));
+    if (!traceLine && !modelLine) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    if (!isRecord(parsed)) continue;
+    if (modelLine) {
+      const model = modelFromRecord(parsed);
+      if (model) currentModel = model;
+      continue;
+    }
+    const details = isRecord(parsed.details) ? parsed.details : isRecord(parsed.message) && isRecord(parsed.message.details) ? parsed.message.details : void 0;
+    if (isRecord(details)) {
+      records.push({ details, ...currentModel ? { model: currentModel } : {} });
+    }
+  }
+  return records;
+};
+var entropyTracesFromSessionJsonl = (lines) => {
+  const traces = [];
+  for (const record of sessionRecords(lines)) {
+    const trace = readFabricExecutionTraceV1(record.details.trace);
+    if (trace) traces.push(entropyTraceFromFabricTrace(trace, record.model));
+  }
+  return traces;
+};
+var entropyValueObservationsFromSessionJsonl = (lines) => {
+  const observations = [];
+  for (const record of sessionRecords(lines)) {
+    const details = record.details;
+    if (!Array.isArray(details.audits)) continue;
+    for (const audit of details.audits) {
+      if (!isRecord(audit)) continue;
+      const ref = typeof audit.ref === "string" ? audit.ref : void 0;
+      const args = isRecord(audit.args) ? audit.args : void 0;
+      if (!ref || !args) continue;
+      for (const [key, value] of Object.entries(args)) {
+        if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+          observations.push({ ref, key, value });
+        }
+      }
+    }
+  }
+  return observations;
+};
+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 fs from "node:fs";
+import path from "node:path";
+var DEFAULT_SESSION_WINDOW = 8;
+var projectSessionFiles = (agentDir, cwd, limit = DEFAULT_SESSION_WINDOW) => {
+  const dir = sessionDirForCwd(cwd, agentDir);
+  let entries = [];
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const stamped = entries.filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl")).map((entry) => {
+    const file = path.join(dir, entry.name);
+    let mtime = 0;
+    try {
+      mtime = fs.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 measureSessionCorpus = (input) => {
+  const sessions = [];
+  for (const file of input.files) {
+    let text;
+    try {
+      text = fs.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 });
+  }
+  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: input.files,
+    sessions,
+    ...sessions.length > 0 ? { latest: sessions[0].report } : {},
+    trend: trendFromScores(chronological.map((session) => session.report.score)),
+    models
+  };
+};
+var sessionWindowEvidence = (files) => {
+  const traces = [];
+  const valueObservations = [];
+  for (const file of files) {
+    let text;
+    try {
+      text = fs.readFileSync(file, "utf8");
+    } catch {
+      continue;
+    }
+    const lines = text.split("\n");
+    traces.push(...entropyTracesFromSessionJsonl(lines));
+    valueObservations.push(...entropyValueObservationsFromSessionJsonl(lines));
+  }
+  return { traces, valueObservations };
+};
+
+export {
+  ENTROPY_METRIC_VERSION,
+  ENTROPY_WEIGHTS,
+  ENTROPY_INVOCATION_STAGES,
+  roundMetric,
+  compareCodeUnits,
+  shapeSignature,
+  signatureDistance,
+  shannonEntropyBits,
+  staticFreedomFromSchema,
+  trendFromScores,
+  liveSurfaceSnapshot,
+  entropySurfaceHash,
+  surfaceFreedomReport,
+  entropyTraceFromFabricTrace,
+  entropyTracesFromSessionJsonl,
+  entropyValueObservationsFromSessionJsonl,
+  entropyRepairRows,
+  entropyReportHash,
+  measureEntropy,
+  projectSessionFiles,
+  measureSessionCorpus,
+  sessionWindowEvidence,
+  proposeEntropyReductions,
+  applyProposalsToSurface,
+  evaluateGate,
+  AUTO_APPLY_PROPOSAL_KINDS,
+  compileEntropySurface
+};
+//# sourceMappingURL=chunk-5IFANSBG.js.map