@iowarp/clio-coder 0.3.3 → 0.3.6

package/dist/context-working-set-UX5KEP4J.js

@@ -0,0 +1,1553 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  DEFAULT_KEEP_RECENT_TOKENS,
+  buildEvictionFields,
+  estimateTokens,
+  findCutPoint,
+  isProtected,
+  planEviction,
+  projectWorkingSet,
+  resolveWorkingSetPolicy,
+  selectVisibleEntries,
+  tokensFreedByEviction
+} from "./chunk-WHJYKASB.js";
+import {
+  parseSessionEntries
+} from "./chunk-CJUB2JJ2.js";
+import "./chunk-HVDIIIQW.js";
+import {
+  EMPTY_WORKING_SET_VIEW,
+  buildPathIndex,
+  callPathsByToolCallId,
+  covers,
+  foldWorkingSet,
+  isTurnStart,
+  protectionCutoffIndex
+} from "./chunk-TZSKNMZG.js";
+import {
+  filterEntriesToActivePath
+} from "./chunk-W6GROXXM.js";
+import "./chunk-43AOLP7E.js";
+import "./chunk-MV3K5QF2.js";
+import "./chunk-UL3WSD3F.js";
+import "./chunk-ECH6PKUQ.js";
+import {
+  isSessionHeader
+} from "./chunk-GOXNB3AO.js";
+import "./chunk-HWUFFB6L.js";
+import "./chunk-OZNBF4L3.js";
+import "./chunk-CGKSTWHD.js";
+import "./chunk-XAKHZX5N.js";
+import "./chunk-33YXPOE3.js";
+import "./chunk-CFGTUFWB.js";
+import {
+  DEFAULT_WORKING_SET_SETTINGS
+} from "./chunk-LL4KHSZI.js";
+import "./chunk-GEYXPTRF.js";
+import "./chunk-FO5ZOVUY.js";
+import {
+  assertSafeId
+} from "./chunk-R346GLFC.js";
+import {
+  clioStatePath
+} from "./chunk-BNAZZHFG.js";
+import "./chunk-WEPFGWHJ.js";
+import "./chunk-G7MUEIGA.js";
+import "./chunk-7CR24IG7.js";
+import "./chunk-IWHMRKLL.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/cli/context-working-set.ts
+init_esm_shims();
+import { execFileSync } from "node:child_process";
+import { mkdir, readdir as readdir2, readFile as readFile2, stat as stat2, writeFile } from "node:fs/promises";
+import { basename as basename2, dirname as dirname2, join as join2, resolve as resolve2 } from "node:path";
+
+// src/domains/context/working-set/replay/controls.ts
+init_esm_shims();
+
+// src/domains/context/working-set/replay/trace.ts
+init_esm_shims();
+function countReplayTurns(entries) {
+  let count = 0;
+  for (const entry of entries) {
+    if (isTurnStart(entry)) count += 1;
+  }
+  return count;
+}
+
+// src/domains/context/working-set/replay/controls.ts
+function controlId(id) {
+  return id;
+}
+function eligibleToolResults(input) {
+  const cutoff = protectionCutoffIndex(input.entries, input.settings.protectLastTurns);
+  const index = buildPathIndex(input.entries, { cwd: input.cwd });
+  const out = [];
+  for (let entryIndex = cutoff - 1; entryIndex >= 0; entryIndex -= 1) {
+    const entry = input.entries[entryIndex];
+    if (entry?.kind !== "message" || entry.role !== "tool_result") continue;
+    if (input.view.evicted.has(entry.turnId)) continue;
+    if (isProtected(entry, { entryIndex, cutoffIndex: cutoff, input, index })) continue;
+    out.push(entry);
+  }
+  return out;
+}
+function takeToTarget(input, entries) {
+  let tokensNeeded = Math.max(0, input.pressure.tokens - input.pressure.target * input.pressure.contextWindow);
+  if (tokensNeeded <= 0) return [];
+  const selected = [];
+  const callPaths = callPathsByToolCallId(input.entries);
+  for (const entry of entries) {
+    const candidate = { ref: { entry: entry.turnId }, reason: "age_horizon" };
+    selected.push(candidate);
+    tokensNeeded -= tokensFreedByEviction(input.estimateTokens, entry, candidate, callPaths);
+    if (tokensNeeded <= 0) break;
+  }
+  return selected;
+}
+function makeOraclePolicy(graph) {
+  let lastInput = null;
+  let lastCandidateCount = 0;
+  const safeEntries = (input) => {
+    const currentTurn = countReplayTurns(input.entries) + 1;
+    return eligibleToolResults(input).filter((entry) => {
+      const futureTurns = graph.futureTurnsOf.get(entry.turnId) ?? [];
+      return futureTurns.every((turn) => turn < currentTurn);
+    });
+  };
+  return {
+    id: controlId("oracle"),
+    select(input) {
+      const safe = safeEntries(input);
+      lastInput = input;
+      lastCandidateCount = safe.length;
+      return takeToTarget(input, safe);
+    },
+    replayCandidateCount(input) {
+      return input === lastInput ? lastCandidateCount : safeEntries(input).length;
+    }
+  };
+}
+function mulberry32(seed) {
+  let value = seed >>> 0;
+  return () => {
+    value = value + 1831565813 >>> 0;
+    let next = value;
+    next = Math.imul(next ^ next >>> 15, next | 1);
+    next ^= next + Math.imul(next ^ next >>> 7, next | 61);
+    return ((next ^ next >>> 14) >>> 0) / 4294967296;
+  };
+}
+function makeRandomPolicy(seed) {
+  let lastInput = null;
+  let lastCandidateCount = 0;
+  return {
+    id: controlId("random"),
+    select(input) {
+      const entries = [...eligibleToolResults(input)];
+      lastInput = input;
+      lastCandidateCount = entries.length;
+      const random = mulberry32(seed);
+      for (let index = entries.length - 1; index > 0; index -= 1) {
+        const swap = Math.floor(random() * (index + 1));
+        const value = entries[index];
+        entries[index] = entries[swap];
+        entries[swap] = value;
+      }
+      return takeToTarget(input, entries);
+    },
+    replayCandidateCount(input) {
+      return input === lastInput ? lastCandidateCount : eligibleToolResults(input).length;
+    }
+  };
+}
+var nonePolicy = {
+  id: controlId("none"),
+  select: () => []
+};
+
+// src/domains/context/working-set/replay/load-clio.ts
+init_esm_shims();
+import { readdir, readFile, stat } from "node:fs/promises";
+import { basename, dirname, join, resolve } from "node:path";
+
+// src/domains/context/working-set/replay/reference-graph.ts
+init_esm_shims();
+var READ_CLASS_OPS = /* @__PURE__ */ new Set(["read", "grep", "find", "ls", "code_nav"]);
+var MUTATION_OPS = /* @__PURE__ */ new Set(["write", "edit"]);
+function isToolResult(entry) {
+  return entry?.kind === "message" && entry.role === "tool_result";
+}
+function isReadableObservation(observation) {
+  return !observation.isError && observation.path.length > 0 && READ_CLASS_OPS.has(observation.op);
+}
+function edgeKey(edge) {
+  return `${edge.from}\0${edge.toTurnIndex}\0${edge.kind}`;
+}
+function buildReferenceGraph(trace, index) {
+  const entryById = new Map(trace.entries.map((entry) => [entry.turnId, entry]));
+  const edges = [];
+  const seenEdges = /* @__PURE__ */ new Set();
+  const future = /* @__PURE__ */ new Map();
+  const add = (edge) => {
+    const key = edgeKey(edge);
+    if (seenEdges.has(key)) return;
+    seenEdges.add(key);
+    edges.push(edge);
+    if (edge.kind === "file_rewrite") return;
+    const turns = future.get(edge.from);
+    if (turns === void 0) future.set(edge.from, /* @__PURE__ */ new Set([edge.toTurnIndex]));
+    else turns.add(edge.toTurnIndex);
+  };
+  for (const earlier of index.observations) {
+    if (!isToolResult(entryById.get(earlier.ref.entry)) || !isReadableObservation(earlier)) continue;
+    const surfaced = new Set(earlier.surfaced);
+    for (const later of index.observations) {
+      if (later.entryIndex <= earlier.entryIndex) continue;
+      if (isReadableObservation(later) && later.path === earlier.path) {
+        add({ from: earlier.ref.entry, toTurnIndex: later.turnIndex, kind: "file_reread" });
+      }
+      if (isReadableObservation(later) && surfaced.has(later.path)) {
+        add({ from: earlier.ref.entry, toTurnIndex: later.turnIndex, kind: "file_discovery" });
+      }
+      if (later.path === earlier.path && MUTATION_OPS.has(later.op)) {
+        add({ from: earlier.ref.entry, toTurnIndex: later.turnIndex, kind: "file_rewrite" });
+      }
+    }
+  }
+  const futureTurnsOf = /* @__PURE__ */ new Map();
+  for (const [ref, turns] of future)
+    futureTurnsOf.set(
+      ref,
+      [...turns].sort((a, b) => a - b)
+    );
+  return { edges, futureTurnsOf };
+}
+
+// src/domains/context/working-set/replay/load-clio.ts
+var DEFAULT_FILTER = {
+  minTurns: 8,
+  minToolResults: 8,
+  requireFileReread: true
+};
+async function collectLedgerFiles(input, out) {
+  const path = resolve(input);
+  let facts;
+  try {
+    facts = await stat(path);
+  } catch {
+    return;
+  }
+  if (facts.isFile()) {
+    if (path.endsWith(".jsonl")) out.add(path);
+    return;
+  }
+  if (!facts.isDirectory()) return;
+  const direct = join(path, "current.jsonl");
+  try {
+    if ((await stat(direct)).isFile()) {
+      out.add(direct);
+      return;
+    }
+  } catch {
+  }
+  let children;
+  try {
+    children = await readdir(path, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const child of children.sort((a, b) => a.name.localeCompare(b.name))) {
+    if (!child.isDirectory()) continue;
+    await collectLedgerFiles(join(path, child.name), out);
+  }
+}
+function sessionFacts(raw, source) {
+  const fallback = { id: basename(dirname(source)), cwd: null };
+  for (const line of raw.split("\n")) {
+    if (line.trim().length === 0) continue;
+    try {
+      const value = JSON.parse(line);
+      if (isSessionHeader(value)) return { id: value.id, cwd: value.cwd.length > 0 ? value.cwd : null };
+    } catch {
+      return fallback;
+    }
+  }
+  return fallback;
+}
+async function pinnedLeafTurnId(source) {
+  try {
+    const raw = await readFile(join(dirname(source), "meta.json"), "utf8");
+    const value = JSON.parse(raw);
+    if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+    const pinned = value.pinnedLeafTurnId;
+    return typeof pinned === "string" && pinned.length > 0 ? pinned : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function cleanActiveEntries(entries, activeLeafTurnId) {
+  return filterEntriesToActivePath(entries, activeLeafTurnId).filter(
+    (entry) => entry.kind !== "contextEviction" && entry.kind !== "contextRecall"
+  );
+}
+function toolResultCount(entries) {
+  let count = 0;
+  for (const entry of entries) {
+    if (entry.kind === "message" && entry.role === "tool_result") count += 1;
+  }
+  return count;
+}
+async function loadClioTraces(paths, options = {}) {
+  const discovered = /* @__PURE__ */ new Set();
+  let missingInputs = 0;
+  for (const path of paths) {
+    const before = discovered.size;
+    await collectLedgerFiles(path, discovered);
+    if (discovered.size === before) {
+      try {
+        await stat(resolve(path));
+      } catch {
+        missingInputs += 1;
+      }
+    }
+  }
+  const filtered = {
+    turns_lt_8: 0,
+    tool_results_lt_8: 0,
+    no_file_reread: 0
+  };
+  const cascade = {
+    found: discovered.size,
+    unreadable: missingInputs,
+    filtered,
+    kept: 0
+  };
+  const traces = [];
+  const filter = options.filter === false ? null : {
+    minTurns: options.filter?.minTurns ?? DEFAULT_FILTER.minTurns,
+    minToolResults: options.filter?.minToolResults ?? DEFAULT_FILTER.minToolResults,
+    requireFileReread: options.filter?.requireFileReread ?? DEFAULT_FILTER.requireFileReread
+  };
+  for (const source of [...discovered].sort((a, b) => a.localeCompare(b))) {
+    let raw;
+    try {
+      raw = await readFile(source, "utf8");
+    } catch {
+      cascade.unreadable += 1;
+      continue;
+    }
+    const parsed = parseSessionEntries(raw, source);
+    if (parsed.errors.length > 0) {
+      cascade.unreadable += 1;
+      continue;
+    }
+    const entries = cleanActiveEntries(parsed.entries, await pinnedLeafTurnId(source));
+    const facts = sessionFacts(raw, source);
+    const trace = {
+      id: facts.id,
+      source,
+      cwd: facts.cwd,
+      entries,
+      turnCount: countReplayTurns(entries)
+    };
+    if (filter !== null) {
+      if (trace.turnCount < filter.minTurns) {
+        filtered.turns_lt_8 = (filtered.turns_lt_8 ?? 0) + 1;
+        continue;
+      }
+      if (toolResultCount(entries) < filter.minToolResults) {
+        filtered.tool_results_lt_8 = (filtered.tool_results_lt_8 ?? 0) + 1;
+        continue;
+      }
+      if (filter.requireFileReread) {
+        const graph = buildReferenceGraph(trace, buildPathIndex(entries, { cwd: trace.cwd }));
+        if (!graph.edges.some((edge) => edge.kind === "file_reread")) {
+          filtered.no_file_reread = (filtered.no_file_reread ?? 0) + 1;
+          continue;
+        }
+      }
+    }
+    traces.push(trace);
+  }
+  cascade.kept = traces.length;
+  return { traces, cascade };
+}
+
+// src/domains/context/working-set/replay/metrics.ts
+init_esm_shims();
+function safeFraction(numerator, denominator, empty) {
+  return denominator === 0 ? empty : numerator / denominator;
+}
+function survivesThrough(observation, referenceTurn, evictedAtTurn) {
+  const evictedAt = evictedAtTurn.get(observation.ref.entry);
+  return evictedAt === void 0 || evictedAt > referenceTurn;
+}
+function hasSurvivingCoveringRead(input, ref, referenceTurn) {
+  const original = input.index.byRef.get(ref);
+  if (original?.op !== "read" || original.path.length === 0) return false;
+  return (input.index.byPath.get(original.path) ?? []).some(
+    (later) => later.op === "read" && !later.isError && later.entryIndex > original.entryIndex && later.turnIndex < referenceTurn && covers(later.range, original.range) && survivesThrough(later, referenceTurn, input.replay.evictedAtTurn)
+  );
+}
+function measure(input) {
+  let pairs = 0;
+  let retainedPairs = 0;
+  let coveredRetainedPairs = 0;
+  let pairsAt10 = 0;
+  let retainedPairsAt10 = 0;
+  for (const [ref, futureTurns] of input.graph.futureTurnsOf) {
+    const observationTurn = input.index.byRef.get(ref)?.turnIndex;
+    const evictedAt = input.replay.evictedAtTurn.get(ref);
+    for (const referenceTurn of futureTurns) {
+      pairs += 1;
+      const retained = evictedAt === void 0 || evictedAt > referenceTurn;
+      if (retained) retainedPairs += 1;
+      if (retained || hasSurvivingCoveringRead(input, ref, referenceTurn)) coveredRetainedPairs += 1;
+      if (observationTurn !== void 0 && referenceTurn - observationTurn <= 10) {
+        pairsAt10 += 1;
+        if (retained) retainedPairsAt10 += 1;
+      }
+    }
+  }
+  let evictedItems = 0;
+  let safelyEvictedItems = 0;
+  let tokensEvicted = 0;
+  let recallTokens = 0;
+  let coldPrefixTokens2 = 0;
+  let saturatedEventCount = 0;
+  for (const event of input.replay.events) {
+    if (event.saturated) saturatedEventCount += 1;
+    coldPrefixTokens2 += event.coldPrefixTokens;
+    for (const item of event.items) {
+      evictedItems += 1;
+      tokensEvicted += item.tokensFreed;
+      const future = input.graph.futureTurnsOf.get(item.ref.entry) ?? [];
+      if (!future.some((turn) => turn > event.turnIndex)) safelyEvictedItems += 1;
+      else recallTokens += item.tokensFreed;
+    }
+  }
+  return {
+    metrics: {
+      traces: 1,
+      retention: safeFraction(retainedPairs, pairs, 1),
+      retentionCovered: safeFraction(coveredRetainedPairs, pairs, 1),
+      retentionAt10: safeFraction(retainedPairsAt10, pairsAt10, 1),
+      evictionPrecision: safeFraction(safelyEvictedItems, evictedItems, 1),
+      tokensEvicted,
+      recallTokens,
+      coldPrefixTokens: coldPrefixTokens2,
+      evictionEvents: input.replay.events.length,
+      saturatedEvents: safeFraction(saturatedEventCount, input.replay.events.length, 0),
+      turnsToFirstSummary: input.replay.turnsToFirstSummary,
+      summaries: input.replay.summaries
+    },
+    pairs,
+    retainedPairs,
+    coveredRetainedPairs,
+    pairsAt10,
+    retainedPairsAt10,
+    saturatedEventCount
+  };
+}
+function mean(values) {
+  return values.length === 0 ? 0 : values.reduce((sum, value) => sum + value, 0) / values.length;
+}
+function aggregateReplayMetrics(inputs) {
+  const measured = inputs.map(measure);
+  const firstSummaries = measured.map((entry) => entry.metrics.turnsToFirstSummary).filter((value) => value !== null);
+  const sum = (field) => measured.reduce((total, entry) => total + entry[field], 0);
+  const totalEvents = measured.reduce((total, entry) => total + entry.metrics.evictionEvents, 0);
+  const saturatedEvents = measured.reduce((total, entry) => total + entry.saturatedEventCount, 0);
+  return {
+    mean: {
+      traces: measured.length,
+      retention: measured.length === 0 ? 1 : mean(measured.map((entry) => entry.metrics.retention)),
+      retentionCovered: measured.length === 0 ? 1 : mean(measured.map((entry) => entry.metrics.retentionCovered)),
+      retentionAt10: measured.length === 0 ? 1 : mean(measured.map((entry) => entry.metrics.retentionAt10)),
+      evictionPrecision: measured.length === 0 ? 1 : mean(measured.map((entry) => entry.metrics.evictionPrecision)),
+      tokensEvicted: mean(measured.map((entry) => entry.metrics.tokensEvicted)),
+      recallTokens: mean(measured.map((entry) => entry.metrics.recallTokens)),
+      coldPrefixTokens: mean(measured.map((entry) => entry.metrics.coldPrefixTokens)),
+      evictionEvents: mean(measured.map((entry) => entry.metrics.evictionEvents)),
+      // Event-pooled: zero-event traces must not dilute the saturation rate.
+      saturatedEvents: safeFraction(saturatedEvents, totalEvents, 0),
+      turnsToFirstSummary: firstSummaries.length === 0 ? null : mean(firstSummaries),
+      summaries: mean(measured.map((entry) => entry.metrics.summaries))
+    },
+    turnsToFirstSummaryCount: firstSummaries.length,
+    pooledRetention: safeFraction(sum("retainedPairs"), sum("pairs"), 1),
+    pooledRetentionCovered: safeFraction(sum("coveredRetainedPairs"), sum("pairs"), 1),
+    pooledRetentionAt10: safeFraction(sum("retainedPairsAt10"), sum("pairsAt10"), 1)
+  };
+}
+
+// src/domains/context/working-set/replay/report.ts
+init_esm_shims();
+function metricObject(metrics, turnsToFirstSummaryCount) {
+  return {
+    traces: metrics.traces,
+    retention: metrics.retention,
+    retentionCovered: metrics.retentionCovered,
+    retentionAt10: metrics.retentionAt10,
+    evictionPrecision: metrics.evictionPrecision,
+    tokensEvicted: metrics.tokensEvicted,
+    recallTokens: metrics.recallTokens,
+    coldPrefixTokens: metrics.coldPrefixTokens,
+    evictionEvents: metrics.evictionEvents,
+    saturatedEvents: metrics.saturatedEvents,
+    turnsToFirstSummary: metrics.turnsToFirstSummary,
+    turnsToFirstSummaryCount,
+    summaries: metrics.summaries
+  };
+}
+function renderReplayJson(input) {
+  const filtered = Object.fromEntries(Object.entries(input.cascade.filtered).sort(([a], [b]) => a.localeCompare(b)));
+  const artifact = {
+    schema: "clio-context-replay-v2",
+    config: {
+      policies: [...input.config.policies],
+      budgets: [...input.config.budgets],
+      threshold: input.config.threshold,
+      target: input.config.target,
+      seed: input.config.seed,
+      corpus: [...input.config.corpus],
+      filter: input.config.filter,
+      settings: {
+        enabled: input.config.settings.enabled,
+        policy: input.config.settings.policy,
+        target: input.config.settings.target,
+        protectLastTurns: input.config.settings.protectLastTurns,
+        minEvictableTokens: input.config.settings.minEvictableTokens
+      }
+    },
+    provenance: {
+      gitSha: input.gitSha,
+      commandLine: [...input.commandLine]
+    },
+    cascade: {
+      found: input.cascade.found,
+      unreadable: input.cascade.unreadable,
+      filtered,
+      kept: input.cascade.kept
+    },
+    results: input.results.map((result) => ({
+      budgetTokens: result.budgetTokens,
+      policyId: result.policyId,
+      metrics: {
+        mean: metricObject(result.metrics.mean, result.metrics.turnsToFirstSummaryCount),
+        pooledRetention: result.metrics.pooledRetention,
+        pooledRetentionCovered: result.metrics.pooledRetentionCovered,
+        pooledRetentionAt10: result.metrics.pooledRetentionAt10
+      }
+    }))
+  };
+  return `${JSON.stringify(artifact, null, "	")}
+`;
+}
+function ratio(value) {
+  return value.toFixed(3);
+}
+function quantity(value) {
+  return Number.isInteger(value) ? String(value) : value.toFixed(1);
+}
+function cascadeRows(cascade) {
+  return [
+    `| found | ${cascade.found} |`,
+    `| unreadable | ${cascade.unreadable} |`,
+    ...Object.entries(cascade.filtered).map(([stage, count]) => `| ${stage} | ${count} |`),
+    `| kept | ${cascade.kept} |`
+  ];
+}
+function renderReplayMarkdown(input) {
+  const lines = [
+    "# Clio working-set replay",
+    "",
+    "## Inclusion cascade",
+    "",
+    "| stage | traces |",
+    "| --- | ---: |",
+    ...cascadeRows(input.cascade)
+  ];
+  for (const budget of input.config.budgets) {
+    lines.push(
+      "",
+      `## Budget ${budget}`,
+      "",
+      "| policy | n | retention (mean) | retention (pooled) | retention covered (mean) | retention covered (pooled) | retention@10 (mean) | eviction precision (mean) | tokens evicted (mean) | recall tokens (mean) | cold prefix tokens (mean) | eviction events (mean) | saturated events | turns to first summary (mean) | summaries (mean) |",
+      "| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |"
+    );
+    for (const policy of input.config.policies) {
+      const result = input.results.find((entry) => entry.budgetTokens === budget && entry.policyId === policy);
+      if (result === void 0) continue;
+      const metrics = result.metrics.mean;
+      lines.push(
+        `| ${policy} | ${metrics.traces} | ${ratio(metrics.retention)} | ${ratio(result.metrics.pooledRetention)} | ${ratio(metrics.retentionCovered)} | ${ratio(result.metrics.pooledRetentionCovered)} | ${ratio(metrics.retentionAt10)} | ${ratio(metrics.evictionPrecision)} | ${quantity(metrics.tokensEvicted)} | ${quantity(metrics.recallTokens)} | ${quantity(metrics.coldPrefixTokens)} | ${quantity(metrics.evictionEvents)} | ${ratio(metrics.saturatedEvents)} | ${metrics.turnsToFirstSummary === null ? "\u2014" : quantity(metrics.turnsToFirstSummary)} (n=${result.metrics.turnsToFirstSummaryCount}) | ${quantity(metrics.summaries)} |`
+      );
+    }
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/domains/context/working-set/replay/runner.ts
+init_esm_shims();
+function sumTokens(entries) {
+  let tokens = 0;
+  for (const entry of entries) tokens += estimateTokens(entry);
+  return tokens;
+}
+function hasCandidatePool(policy) {
+  return "replayCandidateCount" in policy && typeof policy.replayCandidateCount === "function";
+}
+function latestCompactionIndex(entries) {
+  for (let index = entries.length - 1; index >= 0; index -= 1) {
+    if (entries[index]?.kind === "compactionSummary") return index;
+  }
+  return -1;
+}
+function eventSaturated(policy, input, plan) {
+  if (policy.id === "age-horizon") return true;
+  const targetTokens = input.pressure.target * input.pressure.contextWindow;
+  if (policy.id === "structural-v1") {
+    const thresholdTokens = input.pressure.threshold * input.pressure.contextWindow;
+    const usedAgeRung = plan.items.some((item) => item.reason === "age_horizon");
+    return plan.tokensAfter > targetTokens && (plan.tokensAfter > thresholdTokens || usedAgeRung);
+  }
+  if (hasCandidatePool(policy)) return plan.items.length === policy.replayCandidateCount(input);
+  return plan.tokensAfter > targetTokens;
+}
+function rebuildProjection(soFar, leaf, view) {
+  const raw = selectVisibleEntries(soFar, leaf ?? void 0);
+  const projected = projectWorkingSet(raw, view);
+  return {
+    raw,
+    projected,
+    indexByTurnId: new Map(raw.map((entry, index) => [entry.turnId, index])),
+    tokens: sumTokens(projected)
+  };
+}
+function projectAppendedEntry(entry, state, view) {
+  if (view.evictionEvents === 0) return entry;
+  const lastEventId = view.lastEvictionTurnId;
+  if (lastEventId !== null && state.indexByTurnId.has(lastEventId)) {
+    return entry;
+  }
+  return projectWorkingSet([entry], view)[0] ?? entry;
+}
+function appendVisibleEntry(entry, state, view) {
+  const projected = projectAppendedEntry(entry, state, view);
+  state.indexByTurnId.set(entry.turnId, state.raw.length);
+  state.raw.push(entry);
+  state.projected.push(projected);
+  state.tokens += estimateTokens(projected);
+}
+function applyEvictionProjection(state, synthetic, view, items) {
+  const affected = /* @__PURE__ */ new Set();
+  for (const item of items) {
+    const index = state.indexByTurnId.get(item.ref.entry);
+    if (index !== void 0) affected.add(index);
+  }
+  for (let index = 0; index < state.raw.length - 1; index += 1) {
+    const entry = state.raw[index];
+    if (entry?.kind === "message" && entry.role === "assistant") affected.add(index);
+  }
+  for (const index of affected) {
+    const source = state.raw[index];
+    const before = state.projected[index];
+    if (source === void 0 || before === void 0) continue;
+    const after = projectWorkingSet([source, synthetic], view)[0] ?? source;
+    state.projected[index] = after;
+    state.tokens += estimateTokens(after) - estimateTokens(before);
+  }
+}
+function coldPrefixTokens(state, items) {
+  let cut = state.projected.length;
+  for (const item of items) {
+    const index = state.indexByTurnId.get(item.ref.entry);
+    if (index !== void 0 && index < cut) cut = index;
+  }
+  let tokens = 0;
+  for (let index = cut; index < state.projected.length; index += 1) {
+    const entry = state.projected[index];
+    if (entry !== void 0) tokens += estimateTokens(entry);
+  }
+  return tokens;
+}
+function replayTrace(trace, policy, config) {
+  const soFar = [];
+  const events = [];
+  const evictedAtTurn = /* @__PURE__ */ new Map();
+  const toolResults = new Set(
+    trace.entries.filter((entry) => entry.kind === "message" && entry.role === "tool_result").map((entry) => entry.turnId)
+  );
+  let evictionSequence = 0;
+  let summaries = 0;
+  let turnIndex = 0;
+  let turnsToFirstSummary = null;
+  let lastMessageTurnId = null;
+  let view = EMPTY_WORKING_SET_VIEW;
+  let visible = { raw: [], projected: [], indexByTurnId: /* @__PURE__ */ new Map(), tokens: 0 };
+  const pressureLimit = config.threshold * config.budgetTokens;
+  for (const entry of trace.entries) {
+    if (isTurnStart(entry)) {
+      turnIndex += 1;
+      const leaf = lastMessageTurnId;
+      const tokens = visible.tokens;
+      if (tokens > pressureLimit) {
+        const input = {
+          entries: visible.raw,
+          view,
+          cwd: trace.cwd,
+          settings: config.settings,
+          pressure: {
+            tokens,
+            contextWindow: config.budgetTokens,
+            threshold: config.threshold,
+            target: config.target
+          },
+          estimateTokens
+        };
+        const plan = planEviction(policy, input);
+        if (plan !== null) {
+          const saturated = eventSaturated(policy, input, plan);
+          evictionSequence += 1;
+          const previous = soFar[soFar.length - 1];
+          const synthetic = {
+            ...buildEvictionFields(plan, {
+              trigger: "pressure",
+              pressureBefore: tokens / config.budgetTokens,
+              snapshotIdBefore: null
+            }),
+            turnId: `replay-evict-${evictionSequence}`,
+            parentTurnId: leaf,
+            timestamp: previous?.timestamp ?? entry.timestamp
+          };
+          soFar.push(synthetic);
+          appendVisibleEntry(synthetic, visible, view);
+          view = foldWorkingSet(soFar, leaf ?? void 0);
+          applyEvictionProjection(visible, synthetic, view, plan.items);
+          events.push({
+            turnIndex,
+            items: plan.items,
+            tokensBefore: plan.tokensBefore,
+            tokensAfter: plan.tokensAfter,
+            saturated,
+            coldPrefixTokens: coldPrefixTokens(visible, plan.items)
+          });
+          for (const item of plan.items) {
+            if (toolResults.has(item.ref.entry) && !evictedAtTurn.has(item.ref.entry)) {
+              evictedAtTurn.set(item.ref.entry, turnIndex);
+            }
+          }
+        }
+        if (visible.tokens > pressureLimit) {
+          if (turnsToFirstSummary === null) turnsToFirstSummary = turnIndex;
+          const previousCompactionIndex = latestCompactionIndex(soFar);
+          const boundaryStart = previousCompactionIndex + 1;
+          const cut = config.summaries === void 0 ? boundaryStart : findCutPoint(soFar, config.summaries.keepRecentTokens, { startIndex: boundaryStart }).firstKeptEntryIndex;
+          if (config.summaries !== void 0 && cut > boundaryStart) {
+            summaries += 1;
+            const visibleBefore = new Set(visible.raw.map((candidate) => candidate.turnId));
+            const previous = soFar[soFar.length - 1];
+            const firstKeptTurnId = soFar[cut]?.turnId ?? "";
+            const synthetic = {
+              kind: "compactionSummary",
+              turnId: `replay-summary-${summaries}`,
+              parentTurnId: firstKeptTurnId || null,
+              timestamp: previous?.timestamp ?? entry.timestamp,
+              summary: "#".repeat(config.summaries.summaryTokens * 4),
+              tokensBefore: visible.tokens,
+              firstKeptTurnId
+            };
+            soFar.push(synthetic);
+            visible = rebuildProjection(soFar, lastMessageTurnId, view);
+            const visibleAfter = new Set(visible.raw.map((candidate) => candidate.turnId));
+            for (const removed of visibleBefore) {
+              if (toolResults.has(removed) && !visibleAfter.has(removed) && !evictedAtTurn.has(removed)) {
+                evictedAtTurn.set(removed, turnIndex);
+              }
+            }
+          }
+        }
+      }
+    }
+    soFar.push(entry);
+    if (entry.kind === "compactionSummary") visible = rebuildProjection(soFar, lastMessageTurnId, view);
+    else appendVisibleEntry(entry, visible, view);
+    if (entry.kind === "message") lastMessageTurnId = entry.turnId;
+  }
+  return {
+    traceId: trace.id,
+    policyId: config.policyId,
+    budgetTokens: config.budgetTokens,
+    turnCount: trace.turnCount,
+    events,
+    evictedAtTurn,
+    turnsToFirstSummary,
+    summaries,
+    entries: soFar
+  };
+}
+
+// src/domains/context/working-set/replay/synthetic.ts
+init_esm_shims();
+var SYNTHETIC_CORPORA = [
+  {
+    id: "science-long",
+    seed: 7,
+    traces: 8,
+    turns: 300,
+    files: 48,
+    returnProbability: 0.3,
+    zipfExponent: 1,
+    scripts: { explore: 1, implement: 3, validate: 2, analyze: 2 },
+    fileLines: [12, 96],
+    simulationLines: [100, 2400],
+    offloadAfterLines: 200
+  },
+  {
+    id: "refactor",
+    seed: 11,
+    traces: 8,
+    turns: 200,
+    files: 64,
+    returnProbability: 0.4,
+    zipfExponent: 1,
+    scripts: { explore: 1, implement: 5, validate: 2, analyze: 0 },
+    fileLines: [16, 110],
+    simulationLines: [100, 400],
+    offloadAfterLines: 200
+  },
+  {
+    id: "exploration",
+    seed: 13,
+    traces: 8,
+    turns: 200,
+    files: 120,
+    returnProbability: 0.15,
+    zipfExponent: 1,
+    scripts: { explore: 4, implement: 1, validate: 1, analyze: 1 },
+    fileLines: [10, 64],
+    simulationLines: [100, 800],
+    offloadAfterLines: 200
+  }
+];
+function syntheticCorpus(id) {
+  return SYNTHETIC_CORPORA.find((spec) => spec.id === id);
+}
+function mulberry322(seed) {
+  let value = seed >>> 0;
+  return () => {
+    value = value + 1831565813 >>> 0;
+    let next = value;
+    next = Math.imul(next ^ next >>> 15, next | 1);
+    next ^= next + Math.imul(next ^ next >>> 7, next | 61);
+    return ((next ^ next >>> 14) >>> 0) / 4294967296;
+  };
+}
+function powerLawRank(size, exponent, draw) {
+  const upper = size + 1;
+  const sample = exponent === 1 ? upper ** draw : (1 + draw * (upper ** (1 - exponent) - 1)) ** (1 / (1 - exponent));
+  return Math.min(size - 1, Math.max(0, Math.floor(sample) - 1));
+}
+var DIRECTORIES = ["src/sim", "src/io", "src/analysis", "src/mesh", "tests", "scripts", "configs"];
+var STEMS = ["solver", "reader", "writer", "grid", "field", "boundary", "stepper", "metrics", "plot", "checkpoint"];
+var EXTENSIONS = ["py", "py", "py", "c", "h", "yaml", "toml"];
+var CONSUMED_LISTING_READ_LIMIT = 48;
+var CONSUMED_LISTING_SAMPLE_LINES = 20;
+var Ledger = class {
+  constructor(cwd) {
+    this.cwd = cwd;
+  }
+  cwd;
+  entries = [];
+  parent = null;
+  sequence = 0;
+  calls = 0;
+  next(kind) {
+    this.sequence += 1;
+    const turnId = `${kind}-${String(this.sequence).padStart(5, "0")}`;
+    const stamp = {
+      turnId,
+      parentTurnId: this.parent,
+      timestamp: new Date(1787e9 + this.sequence * 1e3).toISOString()
+    };
+    this.parent = turnId;
+    return stamp;
+  }
+  user(text) {
+    this.entries.push({ kind: "message", ...this.next("user"), role: "user", payload: { text } });
+  }
+  assistant(thinking, text) {
+    this.entries.push({
+      kind: "message",
+      ...this.next("assistant"),
+      role: "assistant",
+      payload: {
+        content: [
+          { type: "thinking", thinking },
+          { type: "text", text }
+        ]
+      }
+    });
+  }
+  call(name, args, text, options = {}) {
+    this.calls += 1;
+    const toolCallId = `call-${String(this.calls).padStart(5, "0")}`;
+    this.entries.push({ kind: "message", ...this.next("call"), role: "tool_call", payload: { toolCallId, name, args } });
+    const details = options.offload === true ? { resultDisposition: { offloadPath: `${this.cwd}/.clio-state/scratch/${toolCallId}.txt` } } : void 0;
+    this.entries.push({
+      kind: "message",
+      ...this.next("result"),
+      role: "tool_result",
+      payload: {
+        toolCallId,
+        toolName: name,
+        result: { content: [{ type: "text", text }], ...details === void 0 ? {} : { details } },
+        isError: options.isError === true
+      }
+    });
+  }
+};
+function fileBody(file, offset = 0, limit = null) {
+  const end = limit === null ? file.lines : Math.min(file.lines, offset + limit);
+  const lines = [];
+  for (let line = offset + 1; line <= end; line += 1) {
+    lines.push(`${String(line).padStart(4, " ")}  ${file.path}@v${file.version}: x[${line}] = f(x[${line - 1}]) + eps`);
+  }
+  return lines.join("\n");
+}
+function simulationOutput(lines, seed) {
+  const rnd = mulberry322(seed);
+  const out = [];
+  for (let step = 0; step < lines; step += 1) {
+    out.push(
+      `step ${String(step).padStart(5, "0")} t=${(step * 0.01).toFixed(2)} e=${(1 - rnd() * 1e-3).toFixed(6)} r=${(rnd() * 1e-6).toExponential(2)}`
+    );
+  }
+  return out.join("\n");
+}
+function testOutput(files, failing) {
+  const out = [
+    "============================= test session starts =============================",
+    `collected ${files.length * 4} items`,
+    ""
+  ];
+  for (const file of files) {
+    for (let case_ = 1; case_ <= 4; case_ += 1) {
+      out.push(
+        `${file.path}::test_${file.path.replace(/\W/g, "_")}_${case_} ${file === failing && case_ === 3 ? "FAILED" : "PASSED"} [${String(Math.round(100 * case_ / 4)).padStart(3, " ")}%]`
+      );
+    }
+  }
+  if (failing !== null) {
+    const line = Math.max(1, Math.floor(failing.lines / 2));
+    out.push(
+      "",
+      "=================================== FAILURES ===================================",
+      `____________________ test_${failing.path.replace(/\W/g, "_")}_3 ____________________`,
+      ""
+    );
+    for (let frame = 0; frame < 12; frame += 1) {
+      out.push(
+        `  File "${failing.path}", line ${line + frame}, in step_${frame}`,
+        `    residual = advance(state, dt)  # frame ${frame}`
+      );
+    }
+    out.push(
+      "",
+      "AssertionError: residual 3.2e-4 exceeds tolerance 1e-6",
+      `FAILED ${failing.path}::test_${failing.path.replace(/\W/g, "_")}_3`
+    );
+  }
+  out.push(
+    "",
+    `${failing === null ? files.length * 4 : files.length * 4 - 1} passed, ${failing === null ? 0 : 1} failed`
+  );
+  return out.join("\n");
+}
+function generateSyntheticTrace(spec, index) {
+  const rnd = mulberry322(spec.seed * 1e3 + index);
+  const between = (low, high) => low + Math.floor(rnd() * (high - low + 1));
+  const pick = (items) => items[Math.floor(rnd() * items.length)];
+  const cwd = `/synthetic/${spec.id}-${index}`;
+  const ledger = new Ledger(cwd);
+  const repo = [];
+  for (let file = 0; file < spec.files; file += 1) {
+    const dir = DIRECTORIES[file % DIRECTORIES.length];
+    const stem = STEMS[Math.floor(file / DIRECTORIES.length) % STEMS.length];
+    const ext = EXTENSIONS[file % EXTENSIONS.length];
+    repo.push({
+      path: `${dir}/${stem}${Math.floor(file / (DIRECTORIES.length * STEMS.length)) || ""}.${ext}`,
+      lines: between(spec.fileLines[0], spec.fileLines[1]),
+      version: 1
+    });
+  }
+  const zipf = () => repo[powerLawRank(repo.length, spec.zipfExponent, rnd())];
+  const scriptNames = Object.keys(spec.scripts).flatMap(
+    (name) => Array.from({ length: spec.scripts[name] }, () => name)
+  );
+  const history = [];
+  let treeListings = 0;
+  const readWhole = (file) => ledger.call("read", { path: file.path }, fileBody(file));
+  const readListingPath = (file) => ledger.call(
+    "read",
+    { path: file.path, offset: 1, limit: CONSUMED_LISTING_SAMPLE_LINES },
+    fileBody(file, 0, CONSUMED_LISTING_SAMPLE_LINES)
+  );
+  const readRange = (file) => {
+    const limit = between(20, 80);
+    const offset = between(1, Math.max(1, file.lines - limit));
+    ledger.call("read", { path: file.path, offset, limit }, fileBody(file, offset - 1, limit));
+  };
+  const edit = (file) => {
+    file.version += 1;
+    ledger.call(
+      "edit",
+      { path: file.path, edits: [{ oldText: `v${file.version - 1}`, newText: `v${file.version}` }] },
+      `Applied 1 edit to ${file.path}`
+    );
+  };
+  const runTests = (focus, failing) => ledger.call(
+    "bash",
+    { command: `pytest ${focus.map((file) => file.path).join(" ")} -q` },
+    testOutput(focus, failing),
+    { isError: failing !== null }
+  );
+  for (let turn = 0; turn < spec.turns; turn += 1) {
+    const script = pick(scriptNames);
+    const returning = history.length > 0 && rnd() < spec.returnProbability;
+    const focus = returning ? pick(history) : Array.from({ length: between(1, 3) }, zipf);
+    if (!returning) history.push(focus);
+    const names = focus.map((file) => file.path).join(", ");
+    ledger.user(`Episode ${turn + 1}: ${script} ${names}`);
+    ledger.assistant(`Plan for ${script}: start from ${names} and keep the residual bounded.`, `Working on ${names}.`);
+    switch (script) {
+      case "explore": {
+        const dir = pick(DIRECTORIES);
+        const tree = rnd() < 0.6;
+        const discovered = tree ? repo.slice(0, between(24, repo.length)) : repo.filter((file) => file.path.startsWith(`${dir}/`));
+        const consumeListing = tree && treeListings % 7 === 0;
+        if (tree) treeListings += 1;
+        const listed = consumeListing ? repo.slice(0, CONSUMED_LISTING_READ_LIMIT) : discovered;
+        const root = tree ? "." : dir;
+        ledger.call(
+          rnd() < 0.5 ? "find" : "ls",
+          { path: root },
+          listed.map((file) => tree ? file.path : file.path.slice(dir.length + 1)).join("\n")
+        );
+        const term = pick(["residual", "checkpoint", "boundary", "tolerance"]);
+        const matches = repo.filter(() => rnd() < 0.15).slice(0, 20);
+        ledger.call(
+          "grep",
+          { pattern: term, path: "src" },
+          matches.map(
+            (file) => `${file.path}:${between(1, file.lines)}: ${term} = compute_${term}(state, dt, tol=1e-6)  # ${file.path}`
+          ).join("\n")
+        );
+        const walk = consumeListing ? listed : listed.slice(0, between(2, 4));
+        for (const file of walk) (consumeListing ? readListingPath : readWhole)(file);
+        for (const file of matches.slice(0, between(0, 2))) readWhole(file);
+        break;
+      }
+      case "implement": {
+        for (const file of focus) {
+          readWhole(file);
+          edit(file);
+          if (rnd() < 0.7) readRange(file);
+        }
+        break;
+      }
+      case "validate": {
+        const culprit = pick(focus);
+        readWhole(culprit);
+        runTests(focus, culprit);
+        edit(culprit);
+        runTests(focus, null);
+        break;
+      }
+      case "analyze": {
+        const lines = between(spec.simulationLines[0], spec.simulationLines[1]);
+        const text = simulationOutput(lines, spec.seed + turn);
+        const offload = lines > spec.offloadAfterLines;
+        ledger.call(
+          "bash",
+          { command: `python scripts/run_sim.py --config configs/run.yaml --steps ${lines}` },
+          offload ? `${text.split("\n").slice(0, spec.offloadAfterLines).join("\n")}
+[tool result truncated]` : text,
+          { offload }
+        );
+        const results = pick(focus);
+        readRange(results);
+        if (rnd() < 0.5)
+          ledger.call(
+            "grep",
+            { pattern: "energy", path: results.path },
+            `${results.path}:${between(1, results.lines)}: energy = 0.999`
+          );
+        break;
+      }
+    }
+    ledger.assistant(`Checked ${names}; residual acceptable for this episode.`, `Done with episode ${turn + 1}.`);
+  }
+  const entries = ledger.entries;
+  return {
+    id: `${spec.id}-${String(index).padStart(2, "0")}`,
+    source: `synthetic:${spec.id}#${index}`,
+    cwd,
+    entries,
+    turnCount: countReplayTurns(entries)
+  };
+}
+function generateSyntheticCorpora(ids) {
+  const traces = [];
+  for (const id of ids) {
+    const spec = syntheticCorpus(id);
+    if (spec === void 0) throw new Error(`unknown synthetic corpus: ${id}`);
+    for (let index = 0; index < spec.traces; index += 1) traces.push(generateSyntheticTrace(spec, index));
+  }
+  return { traces, cascade: { found: traces.length, unreadable: 0, filtered: {}, kept: traces.length } };
+}
+
+// src/cli/context-working-set.ts
+var REPLAY_HELP = `Usage:
+  clio-coder context replay (--sessions <path>... | --synthetic <corpus>...) [options]
+
+Options:
+  --sessions <path>... Clio session directories, sessions roots, or ledger JSONL files
+  --synthetic <ids>   comma-separated procedural corpora: ${SYNTHETIC_CORPORA.map((spec) => spec.id).join(",")}
+  --policies <ids>    comma-separated none,random,age-horizon,structural-v1,oracle
+  --budgets <tokens>  comma-separated budgets (default: 16000,32000,64000)
+  --threshold <ratio> pressure threshold (default: 0.8)
+  --target <ratio>    post-eviction pressure target (default: 0.6)
+  --protect-last-turns <n>
+                      protected recent turns (default: ${DEFAULT_WORKING_SET_SETTINGS.protectLastTurns})
+  --min-evictable-tokens <n>
+                      minimum tool-result body tokens (default: ${DEFAULT_WORKING_SET_SETTINGS.minEvictableTokens})
+  --seed <integer>    deterministic random-policy seed (default: 0)
+  --no-filter         include every readable transcript
+  --json <path>       write the stable JSON report
+  --md <path>         write Markdown instead of printing it
+`;
+var WORKING_SET_HELP = `Usage:
+  clio-coder context working-set --session <id|path>
+
+Print the durable working-set fold and path-index summary for one Clio session.
+`;
+var REPLAY_SUMMARY_TOKENS = 1500;
+var POLICY_IDS = ["none", "random", "age-horizon", "structural-v1", "oracle"];
+var CliUsageError = class extends Error {
+};
+function commaValues(value, flag) {
+  const values = value.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+  if (values.length === 0) throw new CliUsageError(`${flag} requires at least one value`);
+  return [...new Set(values)];
+}
+function numberValue(value, flag) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) throw new CliUsageError(`${flag} requires a finite number`);
+  return parsed;
+}
+function requiredValue(args, index, flag) {
+  const value = args[index + 1];
+  if (value === void 0 || value.startsWith("--")) throw new CliUsageError(`${flag} requires a value`);
+  return value;
+}
+function policyResolves(id) {
+  if (id === "none" || id === "random" || id === "oracle") return true;
+  try {
+    resolveWorkingSetPolicy(id);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function defaultPolicies() {
+  return POLICY_IDS.filter(policyResolves);
+}
+function parseReplayArgs(args) {
+  const parsed = {
+    sessions: [],
+    policies: defaultPolicies(),
+    budgets: [16e3, 32e3, 64e3],
+    threshold: 0.8,
+    target: 0.6,
+    protectLastTurns: DEFAULT_WORKING_SET_SETTINGS.protectLastTurns,
+    minEvictableTokens: DEFAULT_WORKING_SET_SETTINGS.minEvictableTokens,
+    seed: 0,
+    synthetic: [],
+    noFilter: false
+  };
+  let policiesExplicit = false;
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--no-filter") {
+      parsed.noFilter = true;
+      continue;
+    }
+    if (arg === "--sessions") {
+      let consumed = 0;
+      while (index + 1 < args.length && !args[index + 1]?.startsWith("--")) {
+        parsed.sessions.push(args[index + 1]);
+        index += 1;
+        consumed += 1;
+      }
+      if (consumed === 0) throw new CliUsageError("--sessions requires at least one path");
+      continue;
+    }
+    if (arg === "--policies" || arg === "--budgets" || arg === "--synthetic" || arg === "--threshold" || arg === "--target" || arg === "--protect-last-turns" || arg === "--min-evictable-tokens" || arg === "--seed") {
+      const value = requiredValue(args, index, arg);
+      index += 1;
+      if (arg === "--policies") {
+        const values = commaValues(value, arg);
+        const unknown = values.filter((entry) => !POLICY_IDS.includes(entry));
+        if (unknown.length > 0) throw new CliUsageError(`unknown replay policy: ${unknown.join(", ")}`);
+        parsed.policies = values;
+        policiesExplicit = true;
+      } else if (arg === "--budgets") {
+        parsed.budgets = commaValues(value, arg).map((entry) => {
+          const budget = numberValue(entry, arg);
+          if (!Number.isInteger(budget) || budget <= 0) {
+            throw new CliUsageError("--budgets values must be positive integers");
+          }
+          return budget;
+        });
+      } else if (arg === "--synthetic") {
+        const values = commaValues(value, arg);
+        const known = SYNTHETIC_CORPORA.map((spec) => spec.id);
+        const unknown = values.filter((entry) => !known.includes(entry));
+        if (unknown.length > 0) throw new CliUsageError(`unknown synthetic corpus: ${unknown.join(", ")}`);
+        parsed.synthetic = values;
+      } else if (arg === "--threshold") {
+        parsed.threshold = numberValue(value, arg);
+        if (parsed.threshold <= 0 || parsed.threshold > 1) {
+          throw new CliUsageError("--threshold must be greater than 0 and at most 1");
+        }
+      } else if (arg === "--target") {
+        parsed.target = numberValue(value, arg);
+        if (parsed.target <= 0 || parsed.target >= 1) {
+          throw new CliUsageError("--target must be greater than 0 and less than 1");
+        }
+      } else if (arg === "--protect-last-turns") {
+        parsed.protectLastTurns = numberValue(value, arg);
+        if (!Number.isInteger(parsed.protectLastTurns) || parsed.protectLastTurns < 1) {
+          throw new CliUsageError("--protect-last-turns must be an integer at least 1");
+        }
+      } else if (arg === "--min-evictable-tokens") {
+        parsed.minEvictableTokens = numberValue(value, arg);
+        if (!Number.isInteger(parsed.minEvictableTokens) || parsed.minEvictableTokens < 0) {
+          throw new CliUsageError("--min-evictable-tokens must be a non-negative integer");
+        }
+      } else {
+        parsed.seed = numberValue(value, arg);
+        if (!Number.isInteger(parsed.seed)) throw new CliUsageError("--seed must be an integer");
+      }
+      continue;
+    }
+    if (arg === "--json" || arg === "--md") {
+      const value = requiredValue(args, index, arg);
+      index += 1;
+      if (arg === "--json") parsed.jsonPath = value;
+      else parsed.markdownPath = value;
+      continue;
+    }
+    throw new CliUsageError(`unknown flag ${arg}`);
+  }
+  if (parsed.sessions.length === 0 && parsed.synthetic.length === 0) {
+    throw new CliUsageError("--sessions or --synthetic is required");
+  }
+  if (parsed.target >= parsed.threshold) throw new CliUsageError("--target must be less than --threshold");
+  if (policiesExplicit) {
+    const unavailable = parsed.policies.filter((id) => !policyResolves(id));
+    if (unavailable.length > 0) {
+      throw new CliUsageError(`replay policy is not available in this build: ${unavailable.join(", ")}`);
+    }
+  }
+  return parsed;
+}
+function policyForTrace(id, graph, seed) {
+  if (id === "none") return nonePolicy;
+  if (id === "random") return makeRandomPolicy(seed);
+  if (id === "oracle") return makeOraclePolicy(graph);
+  return resolveWorkingSetPolicy(id);
+}
+function gitSha() {
+  try {
+    return execFileSync("git", ["rev-parse", "HEAD"], {
+      cwd: process.cwd(),
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+function exactCommandLine() {
+  return [process.execPath, ...process.execArgv, ...process.argv.slice(1)];
+}
+async function writeOutput(path, contents) {
+  const output = resolve2(path);
+  await mkdir(dirname2(output), { recursive: true });
+  await writeFile(output, contents, "utf8");
+  return output;
+}
+function cascadeLine(cascade) {
+  const filtered = Object.entries(cascade.filtered).map(([stage, count]) => `${stage}=${count}`).join(" ");
+  return `cascade found=${cascade.found} unreadable=${cascade.unreadable} ${filtered} kept=${cascade.kept}`;
+}
+async function runContextReplayCommand(args) {
+  if (args.includes("--help") || args.includes("-h")) {
+    process.stdout.write(REPLAY_HELP);
+    return 0;
+  }
+  let parsed;
+  try {
+    parsed = parseReplayArgs(args);
+  } catch (error) {
+    process.stderr.write(
+      `clio-coder context replay: ${error instanceof Error ? error.message : String(error)}
+${REPLAY_HELP}`
+    );
+    return 2;
+  }
+  try {
+    const ledgers = await loadClioTraces(parsed.sessions, { filter: parsed.noFilter ? false : {} });
+    const synthetic = generateSyntheticCorpora(parsed.synthetic);
+    const loaded = {
+      traces: [...ledgers.traces, ...synthetic.traces],
+      cascade: {
+        found: ledgers.cascade.found + synthetic.cascade.found,
+        unreadable: ledgers.cascade.unreadable,
+        filtered: ledgers.cascade.filtered,
+        kept: ledgers.cascade.kept + synthetic.cascade.kept
+      }
+    };
+    if (loaded.traces.length === 0) {
+      process.stderr.write(`clio-coder context replay: no traces to replay (${cascadeLine(loaded.cascade)})
+`);
+      return 1;
+    }
+    const indexed = loaded.traces.map((trace) => {
+      const index = buildPathIndex(trace.entries, { cwd: trace.cwd });
+      return { trace, index, graph: buildReferenceGraph(trace, index) };
+    });
+    const settings = {
+      ...DEFAULT_WORKING_SET_SETTINGS,
+      target: parsed.target,
+      protectLastTurns: parsed.protectLastTurns,
+      minEvictableTokens: parsed.minEvictableTokens
+    };
+    const results = [];
+    for (const budgetTokens of parsed.budgets) {
+      for (const policyId of parsed.policies) {
+        const measurements = indexed.map(({ trace, index, graph }) => ({
+          trace,
+          index,
+          graph,
+          replay: replayTrace(trace, policyForTrace(policyId, graph, parsed.seed), {
+            policyId,
+            budgetTokens,
+            threshold: parsed.threshold,
+            target: parsed.target,
+            settings,
+            seed: parsed.seed,
+            summaries: { keepRecentTokens: DEFAULT_KEEP_RECENT_TOKENS, summaryTokens: REPLAY_SUMMARY_TOKENS }
+          })
+        }));
+        results.push({ budgetTokens, policyId, metrics: aggregateReplayMetrics(measurements) });
+      }
+    }
+    const report = {
+      config: {
+        policies: parsed.policies,
+        budgets: parsed.budgets,
+        threshold: parsed.threshold,
+        target: parsed.target,
+        seed: parsed.seed,
+        corpus: [...parsed.sessions.length > 0 ? ["ledgers"] : [], ...parsed.synthetic],
+        filter: parsed.noFilter ? "none" : "default",
+        settings
+      },
+      cascade: loaded.cascade,
+      results,
+      gitSha: gitSha(),
+      commandLine: exactCommandLine()
+    };
+    const markdown = renderReplayMarkdown(report);
+    if (parsed.markdownPath === void 0) process.stdout.write(markdown);
+    else {
+      const path = await writeOutput(parsed.markdownPath, markdown);
+      process.stdout.write(`${cascadeLine(loaded.cascade)}
+markdown ${path}
+`);
+    }
+    if (parsed.jsonPath !== void 0) {
+      const path = await writeOutput(parsed.jsonPath, renderReplayJson(report));
+      process.stdout.write(`json ${path}
+`);
+    }
+    return 0;
+  } catch (error) {
+    process.stderr.write(`clio-coder context replay failed: ${error instanceof Error ? error.message : String(error)}
+`);
+    return 1;
+  }
+}
+async function sessionPath(value) {
+  const candidate = resolve2(value);
+  try {
+    const facts = await stat2(candidate);
+    if (facts.isDirectory()) return join2(candidate, "current.jsonl");
+    if (facts.isFile()) return candidate;
+  } catch {
+  }
+  try {
+    assertSafeId(value, "session");
+  } catch (error) {
+    throw new CliUsageError(error instanceof Error ? error.message : String(error));
+  }
+  const sessionsRoot = join2(clioStatePath(), "sessions");
+  let cwdHashes;
+  try {
+    cwdHashes = await readdir2(sessionsRoot);
+  } catch {
+    throw new Error(`session not found: ${value}`);
+  }
+  for (const cwdHash of cwdHashes.sort()) {
+    const current = join2(sessionsRoot, cwdHash, value, "current.jsonl");
+    try {
+      if ((await stat2(current)).isFile()) return current;
+    } catch {
+    }
+  }
+  throw new Error(`session not found: ${value}`);
+}
+async function pinnedLeafForSession(source) {
+  try {
+    const raw = await readFile2(join2(dirname2(source), "meta.json"), "utf8");
+    const value = JSON.parse(raw);
+    if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+    const pinned = value.pinnedLeafTurnId;
+    return typeof pinned === "string" && pinned.length > 0 ? pinned : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function sessionCwdForSession(source) {
+  try {
+    const raw = await readFile2(join2(dirname2(source), "meta.json"), "utf8");
+    const value = JSON.parse(raw);
+    if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+    const cwd = value.cwd;
+    return typeof cwd === "string" && cwd.length > 0 ? cwd : null;
+  } catch {
+    return null;
+  }
+}
+function formatWorkingSet(trace) {
+  const view = foldWorkingSet(trace.entries);
+  const index = buildPathIndex(trace.entries, { cwd: trace.cwd });
+  const graph = buildReferenceGraph(trace, index);
+  const evictedTokens = [...view.evicted.values()].reduce((sum, state) => sum + state.tokensFreed, 0);
+  const churn = view.itemsEvicted === 0 ? "n/a" : (view.recalls / view.itemsEvicted).toFixed(3);
+  const opCounts = /* @__PURE__ */ new Map();
+  for (const observation of index.observations) {
+    opCounts.set(observation.op, (opCounts.get(observation.op) ?? 0) + 1);
+  }
+  const rewrittenPaths = /* @__PURE__ */ new Set();
+  for (const edge of graph.edges) {
+    if (edge.kind !== "file_rewrite") continue;
+    const path = index.byRef.get(edge.from)?.path;
+    if (path) rewrittenPaths.add(path);
+  }
+  const lines = [
+    `session: ${trace.id}`,
+    `source: ${trace.source}`,
+    "working set:",
+    `  policy: ${view.lastPolicyId ?? "none"}`,
+    `  eviction events: ${view.evictionEvents}`,
+    `  evicted refs: ${view.evicted.size}`,
+    `  items evicted: ${view.itemsEvicted}`,
+    `  evicted tokens: ${evictedTokens}`,
+    `  recalls: ${view.recalls}`,
+    `  churn: ${churn}`,
+    "  refs:",
+    ...[...view.evicted.entries()].length === 0 ? ["    none"] : [...view.evicted.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([ref, state]) => `    ${ref} reason=${state.reason} by=${state.by ?? "-"} tokens=${state.tokensFreed}`),
+    "path index:",
+    `  observations: ${index.observations.length}`,
+    `  ops: ${[...opCounts.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([op, count]) => `${op}=${count}`).join(", ") || "none"}`,
+    `  paths with rewrites: ${rewrittenPaths.size}`,
+    ...[...rewrittenPaths].sort().map((path) => `    ${path}`),
+    ""
+  ];
+  return lines.join("\n");
+}
+async function runContextWorkingSetCommand(args) {
+  if (args.includes("--help") || args.includes("-h")) {
+    process.stdout.write(WORKING_SET_HELP);
+    return 0;
+  }
+  let session;
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--session") {
+      try {
+        session = requiredValue(args, index, arg);
+      } catch (error) {
+        process.stderr.write(
+          `clio-coder context working-set: ${error instanceof Error ? error.message : String(error)}
+${WORKING_SET_HELP}`
+        );
+        return 2;
+      }
+      index += 1;
+      continue;
+    }
+    process.stderr.write(`clio-coder context working-set: unknown flag ${arg}
+${WORKING_SET_HELP}`);
+    return 2;
+  }
+  if (session === void 0) {
+    process.stderr.write(`clio-coder context working-set: --session is required
+${WORKING_SET_HELP}`);
+    return 2;
+  }
+  try {
+    const source = await sessionPath(session);
+    const raw = await readFile2(source, "utf8");
+    const parsed = parseSessionEntries(raw, source);
+    if (parsed.errors.length > 0) throw new Error(parsed.errors.join("; "));
+    const entries = filterEntriesToActivePath(parsed.entries, await pinnedLeafForSession(source));
+    const cwd = await sessionCwdForSession(source);
+    process.stdout.write(
+      formatWorkingSet({
+        id: basename2(dirname2(source)),
+        source,
+        cwd,
+        entries,
+        turnCount: buildPathIndex(entries, { cwd }).turnCount
+      })
+    );
+    return 0;
+  } catch (error) {
+    if (error instanceof CliUsageError) {
+      process.stderr.write(`clio-coder context working-set: ${error.message}
+${WORKING_SET_HELP}`);
+      return 2;
+    }
+    process.stderr.write(
+      `clio-coder context working-set failed: ${error instanceof Error ? error.message : String(error)}
+`
+    );
+    return 1;
+  }
+}
+export {
+  runContextReplayCommand,
+  runContextWorkingSetCommand
+};
+//# sourceMappingURL=context-working-set-UX5KEP4J.js.map