pi-fabric 0.92.18 → 0.92.19

package/dist/chunks/{chunk-RNOPHITP.js → chunk-H6DDV6E2.js}

@@ -220,6 +220,82 @@ var finalizeMeasure = (input, state) => {
     refs: sortedRefs
   };
 };
+var mergeCounts = (target, source) => {
+  for (const [key, count] of source) target.set(key, (target.get(key) ?? 0) + count);
+};
+var mergeMeasureState = (target, source) => {
+  for (const key of Object.keys(source.totals)) {
+    target.totals[key] += source.totals[key];
+  }
+  target.churnPairs += source.churnPairs;
+  target.churnSum += source.churnSum;
+  for (const [ref, acc] of source.refs) {
+    const into = accumulatorFor(target, ref);
+    for (const key of ["calls", "succeeded", "failed", "churnPairs", "churnSum"]) into[key] += acc[key];
+    mergeCounts(into.signatures, acc.signatures);
+    mergeCounts(into.stages, acc.stages);
+  }
+  for (const [task, sequences] of source.taskSequences) {
+    let into = target.taskSequences.get(task);
+    if (!into) target.taskSequences.set(task, into = /* @__PURE__ */ new Map());
+    mergeCounts(into, sequences);
+  }
+};
+var SessionEntropyMeter = class {
+  #windows = /* @__PURE__ */ new Map();
+  async measure(windows, input) {
+    const reportInput = { ...input, traces: [] };
+    const combined = createMeasureState(reportInput);
+    const models = /* @__PURE__ */ new Map();
+    for (const window of windows) {
+      let cached = this.#windows.get(window.file);
+      if (cached?.traces !== window.traces) {
+        const append = cached && cached.traces.length <= window.traces.length && cached.traces.every((trace, index) => trace === window.traces[index]);
+        if (!append) cached = { traces: [], state: createMeasureState({ traces: [] }), models: /* @__PURE__ */ new Map() };
+        const entry2 = cached;
+        this.#windows.delete(window.file);
+        for (let index = entry2.traces.length; index < window.traces.length; index++) {
+          const trace = window.traces[index];
+          accumulateTrace(entry2.state, trace);
+          entry2.state.totals.traces++;
+          if (trace.model) {
+            let model = entry2.models.get(trace.model);
+            if (!model) entry2.models.set(trace.model, model = createMeasureState({ traces: [] }));
+            accumulateTrace(model, trace);
+            model.totals.traces++;
+          }
+          if ((index + 1) % COOPERATIVE_TRACE_CHUNK === 0) await yieldToLoop();
+        }
+        entry2.traces = window.traces;
+      }
+      const entry = cached;
+      this.#windows.delete(window.file);
+      this.#windows.set(window.file, entry);
+      while (this.#windows.size > 16) this.#windows.delete(this.#windows.keys().next().value);
+      mergeMeasureState(combined, entry.state);
+      for (const [name, source] of entry.models) {
+        let model = models.get(name);
+        if (!model) models.set(name, model = createMeasureState(reportInput));
+        mergeMeasureState(model, source);
+      }
+      await yieldToLoop();
+    }
+    const report = finalizeMeasure(reportInput, combined);
+    const byModel = [...models.entries()].sort(([a], [b]) => compareCodeUnits(a, b)).map(([model, state]) => {
+      const scoped = finalizeMeasure(reportInput, state);
+      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 measureOnce = (input) => {
   const state = createMeasureState(input);
   for (const trace of input.traces) accumulateTrace(state, trace);
@@ -569,26 +645,24 @@ 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();
-  };
+  let processed = 0;
   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();
+    const batchSize = Math.max(1, Math.floor(32768 / (encoded.length + 1)));
+    for (let remaining = count; remaining > 0; ) {
+      const size = Math.min(remaining, batchSize, COOPERATIVE_DIGEST_CHUNK - processed);
+      hash.update(`${first ? "" : ","}${encoded}${`,${encoded}`.repeat(size - 1)}`);
+      first = false;
+      remaining -= size;
+      processed += size;
+      if (processed >= COOPERATIVE_DIGEST_CHUNK) {
+        processed = 0;
+        await yieldToLoop2();
+      }
     }
   }
-  if (encodedBatch.length > 0) {
-    hash.update(`${first ? "" : ","}${encodedBatch.join(",")}`);
-  }
   hash.update("]");
   return hash.digest("hex");
 };
@@ -707,7 +781,7 @@ var mergeObservationSummaries = (pool, windows) => {
       const entry = working.get(entryId);
       if (entry) enforceValueCap(entry);
     }
-    const trackedSession = { file: window.file, digest, counts: fresh };
+    const trackedSession = { file: window.file, digest, counts: { ...fresh } };
     if (existing) {
       tracked[existingIndex] = trackedSession;
     } else {
@@ -739,6 +813,36 @@ var mergeObservationWindow = (pool, windows) => mergeObservationSummaries(
     summary: summarizeObservations(window.observations)
   }))
 );
+var SessionObservationCache = class {
+  #windows = /* @__PURE__ */ new Map();
+  async merge(pool, windows) {
+    const summarized = [];
+    for (const window of windows) {
+      let cached = this.#windows.get(window.file);
+      if (cached?.observations !== window.observations) {
+        const append = cached && cached.observations.length <= window.observations.length && cached.observations.every((observation, index) => observation === window.observations[index]);
+        const counts = append ? { ...cached.counts } : {};
+        const digestCounts = append ? { ...cached.digestCounts } : {};
+        const start = append ? cached.observations.length : 0;
+        for (let index = start; index < window.observations.length; index++) {
+          const observation = window.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();
+        }
+        const digest = append && start === window.observations.length ? cached.summary.digest : await digestFromIdentityCountsAsync(digestCounts);
+        cached = { observations: window.observations, counts, digestCounts, summary: { counts, digest } };
+      }
+      this.#windows.delete(window.file);
+      this.#windows.set(window.file, cached);
+      while (this.#windows.size > 16) this.#windows.delete(this.#windows.keys().next().value);
+      summarized.push({ file: window.file, summary: cached.summary });
+      await yieldToLoop2();
+    }
+    return mergeObservationSummaries(pool, summarized);
+  }
+};
 var mergeObservationWindowAsync = async (pool, windows) => {
   const summarized = [];
   for (const window of windows) {
@@ -986,8 +1090,8 @@ var formatEntropyReviewSignal = (proposal) => {
   return `${proposal.kind} ${proposal.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 });
+var finishCompile = (input, report, plans, reviewSignals = true) => {
+  const review = reviewSignals ? 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) {
@@ -1009,6 +1113,30 @@ var finishCompile = (input, report, plans) => {
   };
   return { status: "compiled", artifact, report, after: report, proposals: [...proposals, ...review], gate };
 };
+var BackgroundEntropyCompiler = class {
+  #meter = new SessionEntropyMeter();
+  #plans;
+  async compile(input) {
+    const digest = entropySurfaceHash(input.surface);
+    if (this.#plans?.digest !== digest) {
+      const plans2 = [];
+      let processed = 0;
+      for (const action of sortedActions(input.surface)) {
+        const plan = deriveNormalFormPlan(action.ref, action.inputSchema);
+        if (plan && plans2.length < MAX_NORMAL_FORM_PLANS) plans2.push(plan);
+        if (++processed % 32 === 0) await new Promise((resolve) => setImmediate(resolve));
+      }
+      this.#plans = { digest, plans: plans2 };
+    }
+    const plans = this.#plans.plans;
+    const report = await this.#meter.measure(input.windows, {
+      surface: input.surface,
+      ...input.repairs ? { repairs: input.repairs } : {},
+      catalogDigest: input.catalogDigest ?? digest
+    });
+    return finishCompile({ ...input, traces: [] }, report, structuredClone(plans), false);
+  }
+};
 var compileEntropySurface = (input) => {
   const report = measureEntropy({ ...input, catalogDigest: input.catalogDigest ?? entropySurfaceHash(input.surface) });
   const plans = [];
@@ -1422,6 +1550,23 @@ var measureSessionCorpus = (input) => {
   }
   return finalizeSessionCorpus(input.files, sessions);
 };
+var BackgroundSessionSelector = class {
+  constructor(scan = machineSessionFilesAsync) {
+    this.scan = scan;
+  }
+  #cached;
+  async select(agentDir, cwd, currentFile) {
+    const cached = this.#cached;
+    let files;
+    if (cached && cached.agentDir === agentDir && cached.cwd === cwd && Date.now() < cached.until) {
+      files = cached.files;
+    } else {
+      files = await this.scan(agentDir, cwd);
+      this.#cached = files.length > 0 ? { agentDir, cwd, files, until: Date.now() + 3e4 } : void 0;
+    }
+    return currentFile ? [currentFile, ...files.filter((file) => file !== currentFile)].slice(0, DEFAULT_SESSION_WINDOW) : [...files];
+  }
+};
 var sessionMetadata = async (file) => {
   try {
     const entry = await fs2.promises.stat(file);
@@ -1460,6 +1605,7 @@ var scanSessionRange = async (file, start, end, initialModel) => {
   }
 };
 var evidenceWindow = (file, evidence) => ({
+  traceWindows: [{ file, traces: evidence.traces }],
   traces: evidence.traces,
   valueObservations: evidence.valueObservations,
   auditCalls: evidence.auditCalls,
@@ -1516,20 +1662,24 @@ var readSessionEvidenceAsync = async (file) => {
   }
   return evidenceWindow(file, evidence);
 };
-var sessionWindowEvidenceAsync = async (files) => {
+var sessionWindowEvidenceAsync = async (files, options = {}) => {
   const windows = await mapConcurrent(files, SESSION_READ_CONCURRENCY, readSessionEvidenceAsync);
   const traces = [];
   const valueObservations = [];
   const auditCalls = [];
   const observationWindows = [];
+  const traceWindows = [];
   for (const window of windows) {
     if (!window) continue;
-    traces.push(...window.traces);
-    valueObservations.push(...window.valueObservations);
-    auditCalls.push(...window.auditCalls);
+    if (!options.windowsOnly) {
+      for (const trace of window.traces) traces.push(trace);
+      for (const observation of window.valueObservations) valueObservations.push(observation);
+      for (const call of window.auditCalls) auditCalls.push(call);
+    }
     observationWindows.push(...window.observationWindows);
+    traceWindows.push(...window.traceWindows);
   }
-  return { traces, valueObservations, auditCalls, observationWindows };
+  return { traces, valueObservations, auditCalls, observationWindows, traceWindows };
 };
 var measureSessionCorpusAsync = async (input) => {
   const windows = await mapConcurrent(
@@ -1557,6 +1707,7 @@ var sessionWindowEvidence = (files) => {
   const valueObservations = [];
   const auditCalls = [];
   const observationWindows = [];
+  const traceWindows = [];
   for (const file of files) {
     let text;
     try {
@@ -1569,8 +1720,9 @@ var sessionWindowEvidence = (files) => {
     valueObservations.push(...evidence.valueObservations);
     auditCalls.push(...evidence.auditCalls);
     observationWindows.push({ file, observations: evidence.valueObservations });
+    traceWindows.push({ file, traces: evidence.traces });
   }
-  return { traces, valueObservations, auditCalls, observationWindows };
+  return { traces, valueObservations, auditCalls, observationWindows, traceWindows };
 };
 
 // src/entropy/trial.ts
@@ -1677,6 +1829,7 @@ export {
   entropyAuditCallsFromSessionJsonl,
   entropyRepairRows,
   entropyReportHash,
+  SessionEntropyMeter,
   measureEntropy,
   measureEntropyAsync,
   projectSessionFiles,
@@ -1684,6 +1837,7 @@ export {
   projectSessionFilesAsync,
   machineSessionFilesAsync,
   measureSessionCorpus,
+  BackgroundSessionSelector,
   sessionWindowEvidenceAsync,
   measureSessionCorpusAsync,
   sessionWindowEvidence,
@@ -1694,6 +1848,7 @@ export {
   AUTO_APPLY_PROPOSAL_KINDS,
   entropyReviewSignals,
   formatEntropyReviewSignal,
+  BackgroundEntropyCompiler,
   compileEntropySurface,
   compileEntropySurfaceAsync,
   OBSERVATION_POOL_VERSION,
@@ -1703,6 +1858,7 @@ export {
   observationIdentity,
   observationWindowDigest,
   mergeObservationWindow,
+  SessionObservationCache,
   mergeObservationWindowAsync,
   poolToValueObservations,
   observationPoolDirectory,
@@ -1717,4 +1873,4 @@ export {
   formatEntropyCompileNotice,
   runEntropyTrial
 };
-//# sourceMappingURL=chunk-RNOPHITP.js.map
+//# sourceMappingURL=chunk-H6DDV6E2.js.map