pi-fabric 0.91.0 → 0.92.0

package/dist/chunks/{chunk-UVUWHPAO.js → chunk-LLJXPPTA.js}

@@ -1,183 +1,39 @@
-import {
-  withExclusiveFileLock,
-  withExclusiveFileLockAsync
-} from "./chunk-H6FEQL2D.js";
 import {
   COMPILED_SURFACE_VERSION,
+  ENTROPY_INVOCATION_STAGES,
+  ENTROPY_METRIC_VERSION,
+  ENTROPY_WEIGHTS,
   MAX_COMPILED_SURFACE_PROPOSALS,
-  applyCompiledSurface,
-  replaySuccessfulCalls,
-  replaySuccessfulCallsAsync,
-  schemaDigest
-} from "./chunk-FMLK3ZA7.js";
+  emptyCompiledSurface,
+  withExclusiveFileLock,
+  withExclusiveFileLockAsync
+} from "./chunk-5MDFFHOO.js";
 import {
   sessionDirForCwd,
   sessionsDirRoot
-} from "./chunk-TDCMU5L4.js";
+} from "./chunk-KNBPIZF7.js";
 import {
   writeJsonAtomic,
   writeJsonAtomicAsync
 } from "./chunk-KAD7UWT2.js";
 import {
   FABRIC_EXECUTION_TRACE_KIND,
-  readFabricExecutionTraceV1
-} from "./chunk-KAWR7MS5.js";
+  MAX_NORMAL_FORM_PLANS,
+  applyNormalFormPlan,
+  compareCodeUnits,
+  deriveNormalFormPlan,
+  provesNormalFormPlan,
+  readFabricExecutionTraceV1,
+  roundMetric,
+  shannonEntropyBits,
+  shapeSignature,
+  signatureDistance,
+  staticFreedomFromSchema,
+  trendFromScores
+} from "./chunk-T3UYWHLT.js";
 import {
-  stableJsonHash,
-  stableJsonHashArrayAsync
-} from "./chunk-7363CD5A.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)
-  };
-};
+  stableJsonHash
+} from "./chunk-3YZUQESG.js";
 
 // src/entropy/meter.ts
 var DISCOVERY_PREFIX = "fabric.discovery.";
@@ -296,7 +152,6 @@ var finalizeMeasure = (input, state) => {
   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()]);
@@ -304,13 +159,14 @@ var finalizeMeasure = (input, state) => {
     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;
+    staticWeighted += ENTROPY_WEIGHTS.staticFreedom * staticFreedom * acc.calls;
     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
+    const invocationRejections = ENTROPY_INVOCATION_STAGES.reduce(
+      (sum, stage) => sum + (acc.stages.get(stage) ?? 0),
+      0
     );
-    scoreSum += score2;
+    const score2 = roundMetric(invocationRejections / acc.calls);
     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);
@@ -339,11 +195,9 @@ var finalizeMeasure = (input, state) => {
   }
   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 score = state.totals.actionOperations > 0 ? roundMetric(state.totals.invocationRejections / state.totals.actionOperations) : 0;
+  const staticScore = state.totals.actionOperations > 0 ? roundMetric(staticWeighted / state.totals.actionOperations) : 0;
+  const behavioralScore = score;
   const sortedRefs = [...refReports].sort(
     (left, right) => right.score - left.score || compareCodeUnits(left.ref, right.ref)
   );
@@ -440,26 +294,14 @@ 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 isPlainRecord = (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;
+  if (!isPlainRecord(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;
+  return isPlainRecord(properties) ? properties : void 0;
 };
 var contains = (outer, inner) => {
   if (outer.length < inner.length) return false;
@@ -475,23 +317,20 @@ var contains = (outer, inner) => {
   }
   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 = [];
+  for (const action of [...input.surface?.actions ?? []].sort((a, b) => compareCodeUnits(a.ref, b.ref)).slice(0, MAX_NORMAL_FORM_PLANS)) {
+    const plan = deriveNormalFormPlan(action.ref, action.inputSchema);
+    if (plan) proposals.push({ kind: "normal-form", ref: plan.ref, baseSchemaDigest: plan.baseSchemaDigest, rules: plan.rules });
+  }
   const observations = /* @__PURE__ */ new Map();
   const observeValue = (ref, key, value, weight = 1) => {
     const id = `${ref}\0${key}`;
@@ -530,35 +369,11 @@ var proposeEntropyReductions = (input) => {
     );
     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
-    });
-  }
+  const openCandidates = eligibleCandidates.filter((candidate) => {
+    const target = schemaProperties(surfaceByRef.get(candidate.entry.ref))?.[candidate.entry.key];
+    return isPlainRecord(target) && target.type !== "boolean" && !Array.isArray(target.enum) && target[ENTROPY_ENUM_CANDIDATE_ANNOTATION] === true;
+  });
+  const byRefKey = (left, right) => compareCodeUnits(`${left.entry.ref}\0${left.entry.key}`, `${right.entry.ref}\0${right.entry.key}`);
   for (const candidate of openCandidates.sort(byRefKey).slice(0, MAX_PROPOSALS_PER_KIND)) {
     proposals.push({
       kind: "declare-enum",
@@ -671,47 +486,9 @@ var proposeEntropyReductions = (input) => {
       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 applyProposalsToSurface = (surface, _proposals) => surface;
 var evaluateGate = (before, after) => {
   const reasons = [];
   if (after.score > before.score) {
@@ -1195,258 +972,60 @@ var surfaceFreedomReport = (surface) => {
 };
 
 // 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 AUTO_APPLY_PROPOSAL_KINDS = ["normal-form"];
+var entropyReviewSignals = (input) => proposeEntropyReductions(input).filter((proposal) => ["declare-enum", "overload-split", "sequence-fuse"].includes(proposal.kind));
 var formatEntropyReviewSignal = (proposal) => {
   if (proposal.kind === "declare-enum") {
-    const values = proposal.values.slice(0, 4).map((value) => String(value)).join(", ");
+    const values = proposal.values.slice(0, 4).map(String).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(" -> ")}`;
-  }
+  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))
+var sortedActions = (surface) => [...surface.actions].sort((a, b) => a.ref < b.ref ? -1 : a.ref > b.ref ? 1 : 0);
+var finishCompile = (input, report, plans) => {
+  const review = entropyReviewSignals({ ...input, report });
+  const previous = input.artifact;
+  const current = previous?.version === COMPILED_SURFACE_VERSION && previous.actions.length === 0 && previous.quarantined.length === 0 && stableJsonHash(previous.normalizations ?? []) === stableJsonHash(plans);
+  if (current || !previous && plans.length === 0) {
+    return { status: "converged", ...previous ? { artifact: previous } : {}, report, proposals: review };
+  }
+  const proposals = plans.map((plan) => ({
+    kind: "normal-form",
+    ref: plan.ref,
+    baseSchemaDigest: plan.baseSchemaDigest,
+    rules: plan.rules
   }));
-  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
+  const gate = { passed: true, beforeScore: report.score, afterScore: report.score, delta: 0, reasons: [] };
+  const artifact = {
+    ...emptyCompiledSurface(),
+    normalizations: plans,
+    applied: plans.slice(0, MAX_COMPILED_SURFACE_PROPOSALS).map((plan) => ({ kind: "normal-form", ref: plan.ref, detail: `${plan.rules.length} proven rules` })),
+    gate: { passed: true, beforeScore: report.score, afterScore: report.score, reasons: [] },
+    evidenceDigest: stableJsonHash({ surface: entropySurfaceHash(input.surface), plans })
   };
+  return { status: "compiled", artifact, report, after: report, proposals: [...proposals, ...review], gate };
 };
 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 report = measureEntropy({ ...input, catalogDigest: input.catalogDigest ?? entropySurfaceHash(input.surface) });
+  const plans = [];
+  for (const action of sortedActions(input.surface)) {
+    const plan = deriveNormalFormPlan(action.ref, action.inputSchema);
+    if (plan && plans.length < MAX_NORMAL_FORM_PLANS) plans.push(plan);
   }
-  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
-  };
+  return finishCompile(input, report, plans);
 };
-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
-    };
+  const report = await measureEntropyAsync({ ...input, catalogDigest: input.catalogDigest ?? entropySurfaceHash(input.surface) });
+  const plans = [];
+  let processed = 0;
+  for (const action of sortedActions(input.surface)) {
+    const plan = deriveNormalFormPlan(action.ref, action.inputSchema);
+    if (plan && plans.length < MAX_NORMAL_FORM_PLANS) plans.push(plan);
+    if (++processed % 32 === 0) await new Promise((resolve) => setImmediate(resolve));
   }
-  return {
-    status: "rejected",
-    ...input.artifact ? { artifact: input.artifact } : {},
-    report,
-    after,
-    proposals,
-    gate
-  };
+  return finishCompile(input, report, plans);
 };
 
 // src/entropy/presentation.ts
@@ -1525,7 +1104,7 @@ var formatEntropyReviewNotice = (proposals) => {
 };
 var formatEntropyCompileNotice = (input) => {
   const review = input.reviewCount ? ` \xB7 ${input.reviewCount} suggestion${input.reviewCount === 1 ? "" : "s"} await review (/fabric entropy)` : "";
-  return `entropy: background optimization complete \xB7 ${scoreChange(input.beforeScore, input.afterScore)} \xB7 safety checks passed${review}`;
+  return `entropy: background optimization complete \xB7 ${input.normalizations ?? 0} normal-form plans \xB7 canonical capabilities preserved \xB7 ${scoreChange(input.beforeScore, input.afterScore)} \xB7 safety checks passed${review}`;
 };
 
 // src/entropy/corpus.ts
@@ -1536,7 +1115,8 @@ var entropyTraceFromFabricTrace = (trace, model) => ({
     ref: operation.ref,
     args: operation.args,
     outcome: operation.outcome,
-    ...operation.failureStage !== void 0 ? { failureStage: operation.failureStage } : {}
+    ...operation.failureStage !== void 0 ? { failureStage: operation.failureStage } : {},
+    ...operation.normalization ? { normalization: operation.normalization } : {}
   })),
   taskKey: trace.phases[0] ?? DEFAULT_TASK_KEY2,
   ...model ? { model } : {}
@@ -1993,136 +1573,96 @@ var sessionWindowEvidence = (files) => {
 
 // src/entropy/trial.ts
 import { Value } from "typebox/value";
-var isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var accepts = (schema, args) => {
   try {
-    return isRecord3(schema) && Value.Check(schema, args);
+    return typeof schema === "object" && schema !== null && Value.Check(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 schemas = new Map(input.live.actions.map((action) => [action.ref, action.inputSchema]));
+  const plans = /* @__PURE__ */ new Map();
+  if (input.artifact?.version === COMPILED_SURFACE_VERSION) {
+    for (const plan of input.artifact.normalizations ?? []) {
+      if (provesNormalFormPlan(plan, schemas.get(plan.ref))) plans.set(plan.ref, plan);
+    }
+  }
+  const report = measureEntropy({ traces: input.traces, surface: input.live, catalogDigest: entropySurfaceHash(input.live) });
   const totals = {
     operations: 0,
     bothAccept: 0,
     bothReject: 0,
+    normalizationWin: 0,
+    canonicalIdentityChecks: 0,
+    canonicalIdentityCost: 0,
+    idempotenceCost: 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);
+  const divergences = /* @__PURE__ */ new Map();
+  let plannedOperations = 0;
+  const record = (ref, args) => {
+    if (ref.startsWith("fabric.discovery.") || ref.startsWith("fabric.workflow.")) return;
+    const schema = schemas.get(ref);
+    if (schema === void 0) return;
+    const plan = plans.get(ref);
+    if (plan) plannedOperations++;
+    const before = accepts(schema, args);
+    const normalized = applyNormalFormPlan(ref, schema, args, plan);
+    const after = accepts(schema, normalized.args);
+    totals.operations++;
+    if (before) {
+      totals.canonicalIdentityChecks++;
+      if (normalized.args !== args || normalized.witness) totals.canonicalIdentityCost++;
+    }
+    const twice = applyNormalFormPlan(ref, schema, normalized.args, plan);
+    if (twice.args !== normalized.args || twice.witness) totals.idempotenceCost++;
+    let trialClass;
+    if (before && !after) {
+      totals.tighteningCost++;
+      trialClass = "tightening-cost";
+    } else if (before) {
+      totals.bothAccept++;
+      trialClass = "both-accept";
+    } else if (after && normalized.witness) {
+      totals.normalizationWin++;
+      trialClass = "normalization-win";
+    } else {
+      totals.bothReject++;
+      trialClass = "both-reject";
+    }
+    if (trialClass !== "both-accept" && trialClass !== "both-reject") {
+      const key = JSON.stringify([ref, trialClass]);
+      const entry = divergences.get(key) ?? { ref, trialClass, count: 0 };
+      entry.count++;
+      divergences.set(key, entry);
     }
+  };
+  const auditedRefs = /* @__PURE__ */ new Set();
+  for (const call of input.auditCalls ?? []) {
+    auditedRefs.add(call.ref);
+    record(call.ref, call.args);
   }
   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);
-      }
+      if (!auditedRefs.has(operation.ref)) record(operation.ref, operation.args);
     }
   }
-  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)
-  );
+  const costs = totals.tighteningCost + totals.canonicalIdentityCost + totals.idempotenceCost;
   return {
-    verdict,
-    declaredScore: declaredReport.score,
-    effectiveScore: effectiveReport.score,
-    delta: effectiveReport.score - declaredReport.score,
+    verdict: costs > 0 ? "costly" : plannedOperations === 0 ? "no-evidence" : "clean",
+    declaredScore: report.score,
+    effectiveScore: report.score,
+    delta: 0,
     totals,
-    divergences
+    divergences: [...divergences.values()].sort((a, b) => compareCodeUnits(a.ref, b.ref) || compareCodeUnits(a.trialClass, b.trialClass))
   };
 };
 
 export {
-  ENTROPY_METRIC_VERSION,
-  ENTROPY_WEIGHTS,
-  ENTROPY_INVOCATION_STAGES,
-  roundMetric,
-  compareCodeUnits,
-  shapeSignature,
-  signatureDistance,
-  shannonEntropyBits,
-  staticFreedomFromSchema,
-  trendFromScores,
   liveSurfaceSnapshot,
   entropySurfaceHash,
   surfaceFreedomReport,
@@ -2175,4 +1715,4 @@ export {
   formatEntropyCompileNotice,
   runEntropyTrial
 };
-//# sourceMappingURL=chunk-UVUWHPAO.js.map
+//# sourceMappingURL=chunk-LLJXPPTA.js.map