@iowarp/clio-coder 0.4.6 → 0.4.8

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

@@ -1,1556 +0,0 @@
-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,
-  tokensFreedByEviction
-} from "./chunk-UUQ5G6EZ.js";
-import {
-  EMPTY_WORKING_SET_VIEW,
-  buildPathIndex,
-  callPathsByToolCallId,
-  covers,
-  foldWorkingSet,
-  isTurnStart,
-  protectionCutoffIndex,
-  selectVisibleEntries
-} from "./chunk-DBREN25X.js";
-import {
-  parseSessionEntries
-} from "./chunk-DXLUVUD4.js";
-import {
-  filterEntriesToActivePath
-} from "./chunk-O5F25NIE.js";
-import "./chunk-QH3ZTUOA.js";
-import "./chunk-DNHVRBH4.js";
-import "./chunk-YPRSNUTC.js";
-import "./chunk-KECNXMDE.js";
-import {
-  isSessionHeader
-} from "./chunk-KAFMW7WM.js";
-import "./chunk-MCJKEGHO.js";
-import "./chunk-77CZRFTE.js";
-import "./chunk-M6TAYK66.js";
-import "./chunk-KQ6IDQIB.js";
-import "./chunk-NTTS3O53.js";
-import "./chunk-M4KFUXS7.js";
-import "./chunk-EM2WNQS2.js";
-import "./chunk-FQOOGXBH.js";
-import {
-  assertSafeId
-} from "./chunk-UHW5V7HC.js";
-import "./chunk-EHOSNVVM.js";
-import "./chunk-KMF54VH3.js";
-import "./chunk-HL26ADLH.js";
-import "./chunk-CVDAFGPW.js";
-import "./chunk-PPEZJWUG.js";
-import "./chunk-WDV62RKY.js";
-import "./chunk-E3LEPLQ2.js";
-import {
-  DEFAULT_WORKING_SET_SETTINGS
-} from "./chunk-U2MSJ57E.js";
-import "./chunk-ZZFWWYLX.js";
-import {
-  clioStatePath
-} from "./chunk-CTTI7G3T.js";
-import {
-  init_esm_shims
-} from "./chunk-ECBHH7LU.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-coder-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-ZUW3EGLS.js.map