@iowarp/clio-coder 0.3.3 → 0.3.6

package/dist/chunk-WHJYKASB.js

@@ -0,0 +1,677 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  buildPathIndex,
+  callPathsByToolCallId,
+  covers,
+  hasLegacyCompactionMarker,
+  hasThinking,
+  isRecord,
+  offloadPathOf,
+  primaryPathOf,
+  protectionCutoffIndex,
+  refKey,
+  toolResultBodyTokens,
+  toolResultPayload,
+  toolResultText,
+  withoutThinkingBlocks
+} from "./chunk-TZSKNMZG.js";
+import {
+  filterEntriesToActivePath
+} from "./chunk-W6GROXXM.js";
+import {
+  formatSize
+} from "./chunk-OZNBF4L3.js";
+import {
+  ceilChars,
+  contentChars,
+  estimateAgentMessageTokens
+} from "./chunk-GEYXPTRF.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/session/compaction/tokens.ts
+init_esm_shims();
+function estimateMessage(entry) {
+  if (entry.role !== "assistant" || !entry.payload || typeof entry.payload !== "object") {
+    return estimateAgentMessageTokens(entry);
+  }
+  const payload = entry.payload;
+  if (!("contextUsageInvalidated" in payload)) return estimateAgentMessageTokens(entry);
+  const { contextUsageInvalidated: _stamp, ...promptPayload } = payload;
+  return estimateAgentMessageTokens({ ...entry, payload: promptPayload });
+}
+function estimateBashExecution(entry) {
+  return ceilChars(entry.command.length + entry.output.length);
+}
+function estimateCustom(entry) {
+  if (entry.data === void 0) return 0;
+  return ceilChars(contentChars(entry.data));
+}
+function estimateSummary(entry) {
+  return ceilChars(entry.summary.length);
+}
+function estimateTokens(entry) {
+  switch (entry.kind) {
+    case "message":
+      return estimateMessage(entry);
+    case "bashExecution":
+      return estimateBashExecution(entry);
+    case "custom":
+      return estimateCustom(entry);
+    case "skillActivation":
+      return ceilChars(JSON.stringify(entry.activation).length);
+    case "branchSummary":
+    case "compactionSummary":
+      return estimateSummary(entry);
+    case "modelChange":
+    case "thinkingLevelChange":
+    case "fileEntry":
+    case "sessionInfo":
+    case "label":
+    case "protectedArtifact":
+    case "taskLedger":
+    case "decisionLedger":
+    case "workerRun":
+    // Working-set bookkeeping: refs and markers, never bodies. The
+    // projection accounts for marker cost on the projected messages.
+    case "contextEviction":
+    case "contextRecall":
+      return 0;
+  }
+}
+function usageTotalTokens(usage) {
+  return usage.totalTokens || usage.input + usage.output + usage.cacheRead + usage.cacheWrite;
+}
+function extractUsage(payload) {
+  if (!payload || typeof payload !== "object") return void 0;
+  const p = payload;
+  if (p.contextUsageInvalidated === true) return void 0;
+  if (p.stopReason === "aborted" || p.stopReason === "error") return void 0;
+  const u = p.usage;
+  if (!u || typeof u !== "object") return void 0;
+  const usage = u;
+  if (typeof usage.input !== "number" || typeof usage.output !== "number") return void 0;
+  return usage;
+}
+function getLastAssistantUsage(entries) {
+  for (let i = entries.length - 1; i >= 0; i--) {
+    const entry = entries[i];
+    if (entry?.kind !== "message" || entry?.role !== "assistant") continue;
+    const usage = extractUsage(entry.payload);
+    if (usage) return usage;
+  }
+  return void 0;
+}
+function findLastAssistantUsageIndex(entries) {
+  for (let i = entries.length - 1; i >= 0; i--) {
+    const entry = entries[i];
+    if (entry?.kind !== "message" || entry?.role !== "assistant") continue;
+    if (extractUsage(entry.payload)) return i;
+  }
+  return -1;
+}
+function calculateContextTokens(entries, lastUsage) {
+  const usage = lastUsage ?? getLastAssistantUsage(entries);
+  if (usage) {
+    const anchorTokens = usageTotalTokens(usage);
+    const anchorIndex = findLastAssistantUsageIndex(entries);
+    let trailing = 0;
+    for (let i = anchorIndex + 1; i < entries.length; i++) {
+      const entry = entries[i];
+      if (entry) trailing += estimateTokens(entry);
+    }
+    return anchorTokens + trailing;
+  }
+  let total = 0;
+  for (const entry of entries) total += estimateTokens(entry);
+  return total;
+}
+
+// src/domains/session/compaction/defaults.ts
+init_esm_shims();
+var DEFAULT_RESERVE_TOKENS = 16384;
+var DEFAULT_KEEP_RECENT_TOKENS = 2e4;
+
+// src/domains/context/working-set/policies/index.ts
+init_esm_shims();
+
+// src/domains/context/working-set/policies/age-horizon.ts
+init_esm_shims();
+var ageHorizonPolicy = {
+  id: "age-horizon",
+  select(input) {
+    const { entries, view, settings } = input;
+    const cutoff = protectionCutoffIndex(entries, settings.protectLastTurns);
+    const candidates = [];
+    for (let i = cutoff - 1; i >= 0; i -= 1) {
+      const entry = entries[i];
+      if (entry === void 0 || entry.kind !== "message") continue;
+      if (view.evicted.has(entry.turnId)) continue;
+      if (entry.role === "tool_result") {
+        if (hasLegacyCompactionMarker(entry.payload)) continue;
+        if (toolResultBodyTokens(entry.payload) < settings.minEvictableTokens) continue;
+        candidates.push({ ref: { entry: entry.turnId }, reason: "age_horizon" });
+        continue;
+      }
+      if (entry.role === "assistant" && hasThinking(entry.payload)) {
+        candidates.push({ ref: { entry: entry.turnId }, reason: "thinking_turn_closed" });
+      }
+    }
+    return candidates;
+  }
+};
+
+// src/domains/context/working-set/policies/structural.ts
+init_esm_shims();
+
+// src/domains/context/working-set/engine.ts
+init_esm_shims();
+
+// src/domains/context/working-set/marker.ts
+init_esm_shims();
+var PREVIEW_LIMIT = 120;
+function lineCount(text) {
+  if (text.length === 0) return 0;
+  let count = 1;
+  for (let index = 0; index < text.length; index += 1) {
+    const code = text.charCodeAt(index);
+    if (code === 10 || code === 13 && text.charCodeAt(index + 1) !== 10) count += 1;
+  }
+  return count;
+}
+function preview(text) {
+  let out = "";
+  let pendingSpace = false;
+  for (const char of text) {
+    if (/\s/.test(char)) {
+      pendingSpace = out.length > 0;
+      continue;
+    }
+    if (pendingSpace) out += " ";
+    pendingSpace = false;
+    out += char;
+    if (out.length >= PREVIEW_LIMIT) break;
+  }
+  return out.slice(0, PREVIEW_LIMIT).replace(/"/g, '\\"');
+}
+function firstLine(text) {
+  const line = /[^\r\n]*\S[^\r\n]*/.exec(text)?.[0] ?? "";
+  return line.trim().slice(0, PREVIEW_LIMIT).replace(/"/g, '\\"');
+}
+function renderMarker(input) {
+  const ref = input.ref.entry;
+  const fields = [`ref=${ref}`, `reason=${input.reason}`];
+  if (input.by !== void 0) fields.push(`by=${input.by}`);
+  fields.push(`tool=${input.toolName}`);
+  if (input.path !== void 0) fields.push(`path=${input.path}`);
+  fields.push(`size=${lineCount(input.text)} lines/${formatSize(Buffer.byteLength(input.text, "utf8"))}`);
+  if (input.offloadPath !== void 0) fields.push(`offload=${input.offloadPath}`);
+  fields.push(`recall=context(scope="recall", ref="${ref}")`);
+  if (input.offloadPath === void 0) {
+    const failed = input.reason === "failure_resolved";
+    const tail = failed ? firstLine(input.text) : preview(input.text);
+    if (tail.length > 0) fields.push(`${failed ? "first_line" : "preview"}="${tail}"`);
+  }
+  return `[evicted ${fields.join(" ")}]`;
+}
+
+// src/domains/context/working-set/project.ts
+init_esm_shims();
+function projectToolResult(entry, state) {
+  const next = { ...entry };
+  const { obj, result } = toolResultPayload(next.payload);
+  const details = isRecord(result) && isRecord(result.details) ? result.details : {};
+  next.payload = {
+    ...obj,
+    result: {
+      content: [{ type: "text", text: state.marker }],
+      details: {
+        ...details,
+        workingSet: { evicted: true, reason: state.reason, ref: entry.turnId }
+      }
+    },
+    output: void 0,
+    out: void 0,
+    content: void 0
+  };
+  return next;
+}
+function projectAssistant(entry) {
+  const obj = isRecord(entry.payload) ? entry.payload : null;
+  if (obj === null || !hasThinking(obj)) return entry;
+  const content = withoutThinkingBlocks(obj.content);
+  if (!hasVisibleContent(obj, content)) return entry;
+  const next = { ...entry };
+  next.payload = {
+    ...obj,
+    ...content !== void 0 ? { content } : {},
+    thinking: void 0
+  };
+  return next;
+}
+function hasVisibleContent(obj, content) {
+  if (typeof obj.text === "string" && obj.text.length > 0) return true;
+  return content !== void 0 && content.length > 0;
+}
+function invalidateUsage(entry) {
+  if (entry.kind !== "message" || entry.role !== "assistant") return entry;
+  const obj = isRecord(entry.payload) ? entry.payload : null;
+  if (obj === null || obj.contextUsageInvalidated === true) return entry;
+  const next = { ...entry };
+  next.payload = { ...obj, contextUsageInvalidated: true };
+  return next;
+}
+function eventIndex(entries, lastEvictionTurnId) {
+  if (lastEvictionTurnId === null) return entries.length;
+  const index = entries.findIndex((entry) => entry.turnId === lastEvictionTurnId);
+  return index < 0 ? entries.length : index;
+}
+function projectWorkingSet(entries, view) {
+  if (view.evicted.size === 0 && view.evictionEvents === 0) return [...entries];
+  const cutoff = view.evictionEvents > 0 ? eventIndex(entries, view.lastEvictionTurnId) : -1;
+  const out = [];
+  for (let index = 0; index < entries.length; index += 1) {
+    const entry = entries[index];
+    if (entry === void 0) continue;
+    let next = entry;
+    if (entry.kind === "message") {
+      const state = view.evicted.get(entry.turnId);
+      if (state !== void 0) {
+        if (entry.role === "tool_result") next = projectToolResult(entry, state);
+        else if (entry.role === "assistant") next = projectAssistant(entry);
+      }
+    }
+    if (index < cutoff) next = invalidateUsage(next);
+    out.push(next);
+  }
+  return out;
+}
+
+// src/domains/context/working-set/engine.ts
+var NO_CALL_PATHS = /* @__PURE__ */ new Map();
+var PENDING_EVENT_TURN_ID = "";
+function markerFor(entry, candidate, callPaths) {
+  if (entry.kind !== "message") return null;
+  if (entry.role === "assistant") return hasThinking(entry.payload) ? "" : null;
+  if (entry.role !== "tool_result") return null;
+  const payload = toolResultPayload(entry.payload);
+  const toolCallId = typeof payload.obj.toolCallId === "string" ? payload.obj.toolCallId : void 0;
+  return renderMarker({
+    ref: candidate.ref,
+    reason: candidate.reason,
+    by: candidate.by,
+    toolName: payload.toolName,
+    text: toolResultText(payload.result),
+    offloadPath: offloadPathOf(payload),
+    path: primaryPathOf(payload) ?? (toolCallId === void 0 ? void 0 : callPaths.get(toolCallId))
+  });
+}
+function pendingState(candidate, marker, policyId) {
+  return {
+    reason: candidate.reason,
+    marker,
+    ...candidate.by === void 0 ? {} : { by: candidate.by },
+    tokensFreed: 0,
+    evictedAtTurnId: PENDING_EVENT_TURN_ID,
+    policyId
+  };
+}
+function soloView(key, state) {
+  return {
+    evicted: /* @__PURE__ */ new Map([[key, state]]),
+    // Zero events: pricing one body must not also stamp usage invalidation,
+    // which would put the cost of a different mechanism in this item's total.
+    evictionEvents: 0,
+    itemsEvicted: 1,
+    recalls: 0,
+    lastPolicyId: null,
+    lastEvictionTurnId: null
+  };
+}
+function viewWithItems(view, items, policyId) {
+  const evicted = new Map(view.evicted);
+  for (const item of items) {
+    evicted.set(refKey(item.ref), {
+      reason: item.reason,
+      marker: item.marker,
+      ...item.by === void 0 ? {} : { by: item.by },
+      tokensFreed: item.tokensFreed,
+      evictedAtTurnId: PENDING_EVENT_TURN_ID,
+      policyId
+    });
+  }
+  return { ...view, evicted, itemsEvicted: view.itemsEvicted + items.length };
+}
+function sumTokens(entries, estimate) {
+  let total = 0;
+  for (const entry of entries) total += estimate(entry);
+  return total;
+}
+function tokensFreedByEviction(estimateTokens2, entry, candidate, callPaths = NO_CALL_PATHS) {
+  const marker = markerFor(entry, candidate, callPaths);
+  if (marker === null) return 0;
+  const key = refKey(candidate.ref);
+  const projected = projectWorkingSet([entry], soloView(key, pendingState(candidate, marker, "")))[0] ?? entry;
+  return Math.max(0, estimateTokens2(entry) - estimateTokens2(projected));
+}
+function planEviction(policy, input) {
+  const candidates = policy.select(input);
+  if (candidates.length === 0) return null;
+  const byTurnId = /* @__PURE__ */ new Map();
+  for (const entry of input.entries) byTurnId.set(entry.turnId, entry);
+  const callPaths = callPathsByToolCallId(input.entries);
+  const items = [];
+  const claimed = /* @__PURE__ */ new Set();
+  for (const candidate of candidates) {
+    const key = refKey(candidate.ref);
+    if (input.view.evicted.has(key) || claimed.has(key)) continue;
+    const entry = byTurnId.get(key);
+    if (entry === void 0) continue;
+    const marker = markerFor(entry, candidate, callPaths);
+    if (marker === null) continue;
+    const tokensFreed = tokensFreedByEviction(input.estimateTokens, entry, candidate, callPaths);
+    if (tokensFreed <= 0) continue;
+    claimed.add(key);
+    items.push({
+      ref: candidate.ref,
+      reason: candidate.reason,
+      tokensFreed,
+      marker,
+      ...candidate.by === void 0 ? {} : { by: candidate.by }
+    });
+  }
+  if (items.length === 0) return null;
+  return {
+    policyId: policy.id,
+    items,
+    tokensBefore: sumTokens(projectWorkingSet(input.entries, input.view), input.estimateTokens),
+    tokensAfter: sumTokens(
+      projectWorkingSet(input.entries, viewWithItems(input.view, items, policy.id)),
+      input.estimateTokens
+    )
+  };
+}
+function buildEvictionFields(plan, meta) {
+  return {
+    kind: "contextEviction",
+    policyId: plan.policyId,
+    trigger: meta.trigger,
+    evicted: plan.items,
+    tokensBefore: plan.tokensBefore,
+    tokensAfter: plan.tokensAfter,
+    pressureBefore: meta.pressureBefore,
+    snapshotIdBefore: meta.snapshotIdBefore
+  };
+}
+
+// src/domains/context/working-set/protect.ts
+init_esm_shims();
+var PATH_IDENTIFIED_OPS = /* @__PURE__ */ new Set(["read", "grep", "find"]);
+function isBlockedResult(payload) {
+  if (!isRecord(payload)) return false;
+  return payload.outcome === "blocked" || typeof payload.blockReason === "string";
+}
+function isErrorResult(payload) {
+  if (!isRecord(payload)) return false;
+  return payload.isError === true || payload.error === true;
+}
+function findLaterSuccess(observation, index) {
+  for (const candidate of index.observations) {
+    if (candidate.entryIndex <= observation.entryIndex || candidate.isError || candidate.isBlocked) continue;
+    if (candidate.toolName === observation.toolName && observation.argsKey.length > 0) {
+      if (candidate.argsKey === observation.argsKey) return candidate;
+    }
+    if (PATH_IDENTIFIED_OPS.has(observation.op) && candidate.op === observation.op && observation.path.length > 0 && candidate.path === observation.path) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function isActiveTurnMutation(observation, index) {
+  if (observation.op !== "write" && observation.op !== "edit") return false;
+  return observation.turnIndex >= index.turnCount;
+}
+function isProtected(entry, ctx) {
+  if (entry.kind !== "message") return true;
+  if (entry.role !== "tool_result" && entry.role !== "assistant") return true;
+  if (ctx.entryIndex >= ctx.cutoffIndex) return true;
+  if (entry.role === "assistant") return false;
+  if (toolResultBodyTokens(entry.payload) < ctx.input.settings.minEvictableTokens) return true;
+  if (hasLegacyCompactionMarker(entry.payload)) return true;
+  if (isBlockedResult(entry.payload)) return true;
+  const observation = ctx.index.byRef.get(entry.turnId);
+  if (observation === void 0) return isErrorResult(entry.payload);
+  if (isActiveTurnMutation(observation, ctx.index)) return true;
+  if (observation.isError && findLaterSuccess(observation, ctx.index) === null) return true;
+  return false;
+}
+
+// src/domains/context/working-set/policies/structural.ts
+var READ_CLASS = /* @__PURE__ */ new Set(["read", "grep", "find", "ls", "code_nav"]);
+var MUTATING = /* @__PURE__ */ new Set(["write", "edit"]);
+function firstMutationAfter(observation, index) {
+  for (const other of index.byPath.get(observation.path) ?? []) {
+    if (other.entryIndex > observation.entryIndex && MUTATING.has(other.op) && !other.isError) return other;
+  }
+  return null;
+}
+function lastCoveringRead(observation, index) {
+  let found = null;
+  for (const other of index.byPath.get(observation.path) ?? []) {
+    if (other.entryIndex <= observation.entryIndex || other.op !== "read" || other.isError) continue;
+    if (covers(other.range, observation.range)) found = other;
+  }
+  return found;
+}
+function isListingConsumed(observation, index) {
+  if (observation.surfaced.length === 0) return false;
+  for (const path of observation.surfaced) {
+    const readLater = (index.byPath.get(path) ?? []).some(
+      (other) => other.op === "read" && !other.isError && other.entryIndex > observation.entryIndex
+    );
+    if (!readLater) return false;
+  }
+  return true;
+}
+var structuralPolicy = {
+  id: "structural-v1",
+  select(input) {
+    const { entries, view, settings, pressure, estimateTokens: estimateTokens2 } = input;
+    const index = buildPathIndex(entries, { cwd: input.cwd });
+    const callPaths = callPathsByToolCallId(entries);
+    const cutoffIndex = protectionCutoffIndex(entries, settings.protectLastTurns);
+    const candidates = [];
+    const claimed = /* @__PURE__ */ new Set();
+    let freed = 0;
+    const entryIndexOf = /* @__PURE__ */ new Map();
+    for (let i = 0; i < entries.length; i += 1) {
+      const entry = entries[i];
+      if (entry !== void 0) entryIndexOf.set(entry.turnId, i);
+    }
+    const emit = (turnId, reason, by) => {
+      if (claimed.has(turnId) || view.evicted.has(turnId)) return false;
+      const entryIndex = entryIndexOf.get(turnId);
+      if (entryIndex === void 0) return false;
+      const entry = entries[entryIndex];
+      if (entry === void 0) return false;
+      if (isProtected(entry, { entryIndex, cutoffIndex, input, index })) return false;
+      const candidate = { ref: { entry: turnId }, reason, ...by === void 0 ? {} : { by } };
+      claimed.add(turnId);
+      candidates.push(candidate);
+      freed += tokensFreedByEviction(estimateTokens2, entry, candidate, callPaths);
+      return true;
+    };
+    const newestFirst = [...index.observations].reverse();
+    for (const observation of newestFirst) {
+      if (!READ_CLASS.has(observation.op) || observation.path.length === 0) continue;
+      const mutation = firstMutationAfter(observation, index);
+      if (mutation !== null) emit(observation.ref.entry, "stale_after_mutation", mutation.ref.entry);
+    }
+    for (const observation of newestFirst) {
+      if (observation.op !== "read" || observation.path.length === 0) continue;
+      const superseding = lastCoveringRead(observation, index);
+      if (superseding !== null) emit(observation.ref.entry, "superseded_read", superseding.ref.entry);
+    }
+    for (const observation of newestFirst) {
+      if (!observation.isError) continue;
+      const success = findLaterSuccess(observation, index);
+      if (success !== null) emit(observation.ref.entry, "failure_resolved", success.ref.entry);
+    }
+    for (const observation of newestFirst) {
+      if (isListingConsumed(observation, index)) emit(observation.ref.entry, "listing_consumed");
+    }
+    for (let i = cutoffIndex - 1; i >= 0; i -= 1) {
+      const entry = entries[i];
+      if (entry?.kind !== "message" || entry.role !== "assistant") continue;
+      if (hasThinking(entry.payload)) emit(entry.turnId, "thinking_turn_closed");
+    }
+    const window = pressure.contextWindow;
+    if (window <= 0) return candidates;
+    let projected = pressure.tokens - freed;
+    if (projected <= pressure.threshold * window) return candidates;
+    const targetTokens = pressure.target * window;
+    for (let i = cutoffIndex - 1; i >= 0 && projected > targetTokens; i -= 1) {
+      const entry = entries[i];
+      if (entry?.kind !== "message" || entry.role !== "tool_result") continue;
+      const before = freed;
+      if (emit(entry.turnId, "age_horizon")) projected -= freed - before;
+    }
+    return candidates;
+  }
+};
+
+// src/domains/context/working-set/policies/index.ts
+function resolveWorkingSetPolicy(id) {
+  if (id === "age-horizon") return ageHorizonPolicy;
+  return structuralPolicy;
+}
+
+// src/domains/session/compaction/cut-point.ts
+init_esm_shims();
+function findTurnStartIndex(entries, entryIndex, startIndex = 0) {
+  for (let i = entryIndex; i >= startIndex; i--) {
+    const entry = entries[i];
+    if (!entry) continue;
+    if (entry.kind === "branchSummary") return i;
+    if (entry.kind === "bashExecution") return i;
+    if (entry.kind === "message" && entry.role === "user") return i;
+  }
+  return -1;
+}
+function isValidCutPoint(entry) {
+  switch (entry.kind) {
+    case "message":
+      return entry.role !== "tool_result";
+    case "bashExecution":
+    case "custom":
+    case "skillActivation":
+    case "branchSummary":
+    case "compactionSummary":
+      return true;
+    case "modelChange":
+    case "thinkingLevelChange":
+    case "fileEntry":
+    case "sessionInfo":
+    case "label":
+    case "protectedArtifact":
+    case "taskLedger":
+    case "decisionLedger":
+    case "workerRun":
+    case "contextEviction":
+    case "contextRecall":
+      return false;
+  }
+}
+function findValidCutPoints(entries, startIndex, endIndex) {
+  const cuts = [];
+  for (let i = startIndex; i < endIndex; i++) {
+    const entry = entries[i];
+    if (!entry) continue;
+    if (isValidCutPoint(entry)) cuts.push(i);
+  }
+  return cuts;
+}
+function findCutPoint(entries, keepRecentTokens, opts = {}) {
+  const startIndex = opts.startIndex ?? 0;
+  const endIndex = opts.endIndex ?? entries.length;
+  const cutPoints = findValidCutPoints(entries, startIndex, endIndex);
+  if (cutPoints.length === 0) {
+    return { firstKeptEntryIndex: startIndex, turnStartIndex: -1, isSplitTurn: false };
+  }
+  let accumulated = 0;
+  let cutIndex = -1;
+  for (let i = endIndex - 1; i >= startIndex; i--) {
+    const entry = entries[i];
+    if (!entry) continue;
+    accumulated += estimateTokens(entry);
+    if (accumulated >= keepRecentTokens) {
+      for (const candidate of cutPoints) {
+        if (candidate >= i) {
+          cutIndex = candidate;
+          break;
+        }
+      }
+      break;
+    }
+  }
+  if (cutIndex === -1) {
+    const lastTurnStart = findTurnStartIndex(entries, endIndex - 1, startIndex);
+    cutIndex = lastTurnStart !== -1 ? lastTurnStart : cutPoints[0] ?? startIndex;
+  }
+  while (cutIndex > startIndex) {
+    const prev = entries[cutIndex - 1];
+    if (!prev) break;
+    if (prev.kind === "compactionSummary") break;
+    if (prev.kind === "message" || prev.kind === "bashExecution" || prev.kind === "custom" || prev.kind === "skillActivation" || prev.kind === "branchSummary") {
+      break;
+    }
+    cutIndex--;
+  }
+  const cutEntry = entries[cutIndex];
+  const cutIsUserTurn = !!cutEntry && cutEntry.kind === "message" && cutEntry.role === "user";
+  const turnStartIndex = cutIsUserTurn ? -1 : findTurnStartIndex(entries, cutIndex, startIndex);
+  return {
+    firstKeptEntryIndex: cutIndex,
+    turnStartIndex,
+    isSplitTurn: !cutIsUserTurn && turnStartIndex !== -1
+  };
+}
+
+// src/domains/context/working-set/visible.ts
+init_esm_shims();
+function compactionCut(entries) {
+  let compactionIndex = -1;
+  for (let i = entries.length - 1; i >= 0; i -= 1) {
+    if (entries[i]?.kind === "compactionSummary") {
+      compactionIndex = i;
+      break;
+    }
+  }
+  const compaction = entries[compactionIndex];
+  if (compaction?.kind !== "compactionSummary") return { compactionIndex: -1, visible: [...entries] };
+  const firstKeptIndex = compaction.firstKeptTurnId.length > 0 ? entries.findIndex((entry) => entry.turnId === compaction.firstKeptTurnId) : -1;
+  const kept = firstKeptIndex >= 0 && firstKeptIndex < compactionIndex ? entries.slice(firstKeptIndex, compactionIndex) : [];
+  return { compactionIndex, visible: [...kept, ...entries.slice(compactionIndex + 1)] };
+}
+function selectVisibleEntries(entries, activeLeafTurnId) {
+  return compactionCut(filterEntriesToActivePath(entries, activeLeafTurnId)).visible;
+}
+
+export {
+  estimateTokens,
+  getLastAssistantUsage,
+  calculateContextTokens,
+  findCutPoint,
+  DEFAULT_RESERVE_TOKENS,
+  DEFAULT_KEEP_RECENT_TOKENS,
+  projectWorkingSet,
+  tokensFreedByEviction,
+  planEviction,
+  buildEvictionFields,
+  isProtected,
+  resolveWorkingSetPolicy,
+  compactionCut,
+  selectVisibleEntries
+};
+//# sourceMappingURL=chunk-WHJYKASB.js.map

package/dist/{chunk-ORBHGJC5.js → chunk-WR67VIZY.js}

@@ -3,10 +3,10 @@ import {
   readSettings,
   settingsPath,
   updateSettings
-} from "./chunk-A3CYT5EX.js";
+} from "./chunk-AD2SYQYC.js";
 import {
   DEFAULT_SETTINGS
-} from "./chunk-ZDOOVTXZ.js";
+} from "./chunk-4OC57DA6.js";
 import {
   require_dist
 } from "./chunk-APJ265NV.js";
@@ -552,4 +552,4 @@ export {
   importShareArchive,
   ShareDomainModule
 };
-//# sourceMappingURL=chunk-ORBHGJC5.js.map
+//# sourceMappingURL=chunk-WR67VIZY.js.map