pi-fabric 0.92.18 → 0.92.20

package/dist/agents.js

@@ -1,10 +1,10 @@
-import {
-  validateAgentResult
-} from "./chunks/chunk-3QECYQGA.js";
 import {
   AGENTS_ACTION_DESCRIPTORS,
   normalizeAgentRunRequest
 } from "./chunks/chunk-2PZWDVJB.js";
+import {
+  validateAgentResult
+} from "./chunks/chunk-3QECYQGA.js";
 import {
   actionArgNormalizer
 } from "./chunks/chunk-NQOEHX62.js";

package/dist/chunks/chunk-EDL4JDW7.js

@@ -0,0 +1,184 @@
+import {
+  MemoryProvider
+} from "./chunk-UQ4LTUH4.js";
+
+// src/memory/worker-provider.ts
+import path from "node:path";
+import { Worker } from "node:worker_threads";
+var MAX_PENDING_REQUESTS = 64;
+var IDLE_TIMEOUT_MS = 3e4;
+var sameBranch = (left, right) => left.leafId === right.leafId && left.entries.length === right.entries.length && left.entries.every((entry, index) => entry.id === right.entries[index].id);
+var WorkerMemoryProvider = class extends MemoryProvider {
+  constructor(workerContext, workerUrl = new URL("../memory/file-worker.js", import.meta.url)) {
+    super(workerContext);
+    this.workerContext = workerContext;
+    this.workerUrl = workerUrl;
+  }
+  worker;
+  active;
+  pending = [];
+  idleTimer;
+  stopping;
+  closed = false;
+  nextId = 0;
+  async invoke(action, args, invocation) {
+    invocation.signal?.throwIfAborted();
+    if (this.closed) throw new Error("Memory provider is closed");
+    if (typeof args.source === "string" && args.source.length > 0 || !["recall", "expand", "sessions"].includes(action)) {
+      return super.invoke(action, args, invocation);
+    }
+    if (this.pending.length + (this.active ? 1 : 0) >= MAX_PENDING_REQUESTS) {
+      throw new Error(`Memory request queue is full (${MAX_PENDING_REQUESTS} requests); await outstanding calls`);
+    }
+    return new Promise((resolve, reject) => {
+      const request = {
+        id: ++this.nextId,
+        action,
+        args,
+        invocation,
+        resolve,
+        reject,
+        abort: () => {
+          if (this.active === request) {
+            this.active = void 0;
+            void this.retire();
+          } else {
+            const index = this.pending.indexOf(request);
+            if (index >= 0) this.pending.splice(index, 1);
+          }
+          this.finish(request, false, invocation.signal?.reason ?? new Error("Memory request aborted"));
+          this.pump();
+        }
+      };
+      invocation.signal?.addEventListener("abort", request.abort, { once: true });
+      this.pending.push(request);
+      this.pump();
+    });
+  }
+  snapshot(request) {
+    const context = this.workerContext;
+    if (request.args.branches === "all" || !context.sessionFile || !context.getLiveBranch) return void 0;
+    const selector = request.action === "expand" ? request.args.session : request.args.scope;
+    const target = typeof selector === "string" && selector.trim().startsWith("session:") ? selector.trim().slice("session:".length).trim() : request.action === "expand" && typeof selector === "string" ? selector.trim() : void 0;
+    if (target !== void 0 && target !== context.sessionId && target !== path.basename(context.sessionFile, ".jsonl") && path.resolve(target) !== path.resolve(context.sessionFile)) return void 0;
+    const branch = context.getLiveBranch();
+    return {
+      leafId: branch.leafId,
+      entries: branch.entries.map((entry) => {
+        const id = entry !== null && typeof entry === "object" ? entry.id : void 0;
+        return typeof id === "string" ? { id } : {};
+      })
+    };
+  }
+  start() {
+    const { agentDir, cwd, config, sessionId, sessionFile } = this.workerContext;
+    const worker = new Worker(this.workerUrl, {
+      workerData: { agentDir, cwd, config, sessionId, sessionFile },
+      // Eval/stdin-only flags are invalid when Node starts this compiled module file.
+      execArgv: process.execArgv.filter((value, index, args) => value !== "--input-type" && args[index - 1] !== "--input-type" && !value.startsWith("--input-type="))
+    });
+    this.worker = worker;
+    worker.on("message", (message) => {
+      const request = this.active;
+      if (this.worker !== worker || !request || message?.id !== request.id) return;
+      try {
+        if (message.type === "progress") {
+          request.invocation.update(message.text);
+          return;
+        }
+        if (message.type === "error") {
+          const error = new Error(message.message);
+          error.name = message.name;
+          this.active = void 0;
+          this.finish(request, false, error);
+        } else if (message.type === "result") {
+          const branch = this.snapshot(request);
+          if (request.branch && (!branch || !sameBranch(request.branch, branch))) {
+            throw new Error("Session branch changed during memory retrieval; retry the request");
+          }
+          this.active = void 0;
+          this.finish(request, true, message.value);
+        } else {
+          throw new Error("Invalid memory worker response");
+        }
+        this.pump();
+      } catch (error) {
+        this.failWorker(worker, error);
+      }
+    });
+    worker.once("error", (error) => this.failWorker(worker, error));
+    worker.once("exit", (code) => this.failWorker(worker, new Error(`Memory worker exited before completing its request (code ${code})`)));
+    return worker;
+  }
+  finish(request, success, value) {
+    request.invocation.signal?.removeEventListener("abort", request.abort);
+    if (success) request.resolve(value);
+    else request.reject(value);
+  }
+  failWorker(worker, error) {
+    if (this.worker !== worker) return;
+    const request = this.active;
+    this.active = void 0;
+    void this.retire();
+    if (request) this.finish(request, false, error);
+  }
+  pump() {
+    if (this.closed || this.active || this.stopping) return;
+    const request = this.pending.shift();
+    if (!request) {
+      this.worker?.unref();
+      if (this.worker && !this.idleTimer) {
+        this.idleTimer = setTimeout(() => {
+          void this.retire();
+        }, IDLE_TIMEOUT_MS);
+        this.idleTimer.unref();
+      }
+      return;
+    }
+    if (this.idleTimer) clearTimeout(this.idleTimer);
+    this.idleTimer = void 0;
+    this.active = request;
+    try {
+      request.invocation.signal?.throwIfAborted();
+      request.branch = this.snapshot(request);
+      const worker = this.worker ?? this.start();
+      worker.ref();
+      worker.postMessage({ id: request.id, action: request.action, args: request.args, branch: request.branch });
+    } catch (error) {
+      this.active = void 0;
+      void this.retire();
+      this.finish(request, false, error);
+      this.pump();
+    }
+  }
+  retire() {
+    if (this.idleTimer) clearTimeout(this.idleTimer);
+    this.idleTimer = void 0;
+    const worker = this.worker;
+    this.worker = void 0;
+    if (!worker) return this.stopping ?? Promise.resolve();
+    const stopping = worker.terminate().then(() => {
+    }, () => {
+    });
+    this.stopping = stopping;
+    void stopping.then(() => {
+      if (this.stopping === stopping) this.stopping = void 0;
+      this.pump();
+    });
+    return stopping;
+  }
+  async close() {
+    this.closed = true;
+    const active = this.active;
+    this.active = void 0;
+    const requests = this.pending.splice(0);
+    if (active) requests.unshift(active);
+    for (const request of requests) this.finish(request, false, new Error("Memory provider is closed"));
+    await this.retire();
+  }
+};
+
+export {
+  WorkerMemoryProvider
+};
+//# sourceMappingURL=chunk-EDL4JDW7.js.map

package/dist/chunks/chunk-EDL4JDW7.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/memory/worker-provider.ts"],
+  "sourcesContent": ["import path from \"node:path\";\nimport { Worker } from \"node:worker_threads\";\nimport type { FabricInvocationContext } from \"../protocol.js\";\nimport { MemoryProvider, type MemoryProviderContext } from \"../providers/memory-provider.js\";\nimport type { LiveSessionBranch } from \"./lineage.js\";\nimport type { MemoryWorkerReply } from \"./file-worker.js\";\n\nconst MAX_PENDING_REQUESTS = 64;\nconst IDLE_TIMEOUT_MS = 30_000;\n\ninterface Request {\n  id: number;\n  action: string;\n  args: Record<string, unknown>;\n  invocation: FabricInvocationContext;\n  branch?: LiveSessionBranch | undefined;\n  abort(): void;\n  resolve(value: unknown): void;\n  reject(error: unknown): void;\n}\n\nconst sameBranch = (left: LiveSessionBranch, right: LiveSessionBranch): boolean =>\n  left.leafId === right.leafId && left.entries.length === right.entries.length &&\n  left.entries.every((entry, index) =>\n    (entry as { id?: string }).id === (right.entries[index] as { id?: string }).id);\n\n/** Pi-facing file memory: one lazy worker, bounded FIFO, no transcript work on the UI thread. */\nexport class WorkerMemoryProvider extends MemoryProvider {\n  private worker: Worker | undefined;\n  private active: Request | undefined;\n  private readonly pending: Request[] = [];\n  private idleTimer: NodeJS.Timeout | undefined;\n  private stopping: Promise<void> | undefined;\n  private closed = false;\n  private nextId = 0;\n\n  constructor(\n    private readonly workerContext: MemoryProviderContext,\n    private readonly workerUrl = new URL(\"../memory/file-worker.js\", import.meta.url),\n  ) {\n    super(workerContext);\n  }\n\n  override async invoke(action: string, args: Record<string, unknown>, invocation: FabricInvocationContext): Promise<unknown> {\n    invocation.signal?.throwIfAborted();\n    if (this.closed) throw new Error(\"Memory provider is closed\");\n    // Authorized host adapters contain callbacks and must stay in their owning host.\n    if ((typeof args.source === \"string\" && args.source.length > 0) ||\n        ![\"recall\", \"expand\", \"sessions\"].includes(action)) {\n      return super.invoke(action, args, invocation);\n    }\n    if (this.pending.length + (this.active ? 1 : 0) >= MAX_PENDING_REQUESTS) {\n      throw new Error(`Memory request queue is full (${MAX_PENDING_REQUESTS} requests); await outstanding calls`);\n    }\n    return new Promise((resolve, reject) => {\n      const request: Request = {\n        id: ++this.nextId, action, args, invocation, resolve, reject,\n        abort: () => {\n          if (this.active === request) {\n            this.active = undefined;\n            void this.retire();\n          } else {\n            const index = this.pending.indexOf(request);\n            if (index >= 0) this.pending.splice(index, 1);\n          }\n          this.finish(request, false, invocation.signal?.reason ?? new Error(\"Memory request aborted\"));\n          this.pump();\n        },\n      };\n      invocation.signal?.addEventListener(\"abort\", request.abort, { once: true });\n      this.pending.push(request);\n      this.pump();\n    });\n  }\n\n  private snapshot(request: Request): LiveSessionBranch | undefined {\n    const context = this.workerContext;\n    if (request.args.branches === \"all\" || !context.sessionFile || !context.getLiveBranch) return undefined;\n    const selector = request.action === \"expand\" ? request.args.session : request.args.scope;\n    const target = typeof selector === \"string\" && selector.trim().startsWith(\"session:\")\n      ? selector.trim().slice(\"session:\".length).trim()\n      : request.action === \"expand\" && typeof selector === \"string\" ? selector.trim() : undefined;\n    if (target !== undefined && target !== context.sessionId &&\n        target !== path.basename(context.sessionFile, \".jsonl\") &&\n        path.resolve(target) !== path.resolve(context.sessionFile)) return undefined;\n    const branch = context.getLiveBranch();\n    // Lineage needs IDs only. Never clone tool output, images, or the full transcript to the worker.\n    return {\n      leafId: branch.leafId,\n      entries: branch.entries.map(entry => {\n        const id = entry !== null && typeof entry === \"object\" ? (entry as { id?: unknown }).id : undefined;\n        return typeof id === \"string\" ? { id } : {};\n      }),\n    };\n  }\n\n  private start(): Worker {\n    const { agentDir, cwd, config, sessionId, sessionFile } = this.workerContext;\n    const worker = new Worker(this.workerUrl, {\n      workerData: { agentDir, cwd, config, sessionId, sessionFile },\n      // Eval/stdin-only flags are invalid when Node starts this compiled module file.\n      execArgv: process.execArgv.filter((value, index, args) =>\n        value !== \"--input-type\" && args[index - 1] !== \"--input-type\" && !value.startsWith(\"--input-type=\")),\n    });\n    this.worker = worker;\n    worker.on(\"message\", (message: MemoryWorkerReply) => {\n      const request = this.active;\n      if (this.worker !== worker || !request || message?.id !== request.id) return;\n      try {\n        if (message.type === \"progress\") {\n          request.invocation.update(message.text);\n          return;\n        }\n        if (message.type === \"error\") {\n          const error = new Error(message.message);\n          error.name = message.name;\n          this.active = undefined;\n          this.finish(request, false, error);\n        } else if (message.type === \"result\") {\n          const branch = this.snapshot(request);\n          if (request.branch && (!branch || !sameBranch(request.branch, branch))) {\n            throw new Error(\"Session branch changed during memory retrieval; retry the request\");\n          }\n          this.active = undefined;\n          this.finish(request, true, message.value);\n        } else {\n          throw new Error(\"Invalid memory worker response\");\n        }\n        this.pump();\n      } catch (error) {\n        this.failWorker(worker, error);\n      }\n    });\n    worker.once(\"error\", error => this.failWorker(worker, error));\n    worker.once(\"exit\", code => this.failWorker(worker, new Error(`Memory worker exited before completing its request (code ${code})`)));\n    return worker;\n  }\n\n  private finish(request: Request, success: boolean, value: unknown): void {\n    request.invocation.signal?.removeEventListener(\"abort\", request.abort);\n    if (success) request.resolve(value);\n    else request.reject(value);\n  }\n\n  private failWorker(worker: Worker, error: unknown): void {\n    if (this.worker !== worker) return;\n    const request = this.active;\n    this.active = undefined;\n    void this.retire();\n    if (request) this.finish(request, false, error);\n  }\n\n  private pump(): void {\n    if (this.closed || this.active || this.stopping) return;\n    const request = this.pending.shift();\n    if (!request) {\n      this.worker?.unref();\n      if (this.worker && !this.idleTimer) {\n        this.idleTimer = setTimeout(() => { void this.retire(); }, IDLE_TIMEOUT_MS);\n        this.idleTimer.unref();\n      }\n      return;\n    }\n    if (this.idleTimer) clearTimeout(this.idleTimer);\n    this.idleTimer = undefined;\n    this.active = request;\n    try {\n      request.invocation.signal?.throwIfAborted();\n      request.branch = this.snapshot(request);\n      const worker = this.worker ?? this.start();\n      worker.ref();\n      worker.postMessage({ id: request.id, action: request.action, args: request.args, branch: request.branch });\n    } catch (error) {\n      this.active = undefined;\n      void this.retire();\n      this.finish(request, false, error);\n      this.pump();\n    }\n  }\n\n  private retire(): Promise<void> {\n    if (this.idleTimer) clearTimeout(this.idleTimer);\n    this.idleTimer = undefined;\n    const worker = this.worker;\n    this.worker = undefined;\n    if (!worker) return this.stopping ?? Promise.resolve();\n    const stopping = worker.terminate().then(() => {}, () => {});\n    this.stopping = stopping;\n    void stopping.then(() => {\n      if (this.stopping === stopping) this.stopping = undefined;\n      this.pump();\n    });\n    return stopping;\n  }\n\n  async close(): Promise<void> {\n    this.closed = true;\n    const active = this.active;\n    this.active = undefined;\n    const requests = this.pending.splice(0);\n    if (active) requests.unshift(active);\n    for (const request of requests) this.finish(request, false, new Error(\"Memory provider is closed\"));\n    await this.retire();\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/chunks/{chunk-3KOK4CPR.js → chunk-EFHCXJTV.js}

@@ -9,7 +9,7 @@ import {
   agentParticipantRecords,
   loadModelUsage,
   useBudgetLedger
-} from "./chunk-4U5NR5VF.js";
+} from "./chunk-KI4VAMHK.js";
 import {
   RESIDENT_HOST_FORMAT,
   residentDeliveryPrefix,
@@ -689,4 +689,4 @@ if (isMain) {
 export {
   runResidentHostFromConfigPath
 };
-//# sourceMappingURL=chunk-3KOK4CPR.js.map
+//# sourceMappingURL=chunk-EFHCXJTV.js.map

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