@chroxify/eunoe 1.2.2 → 1.3.0

package/dist/types/context/content.d.ts

@@ -0,0 +1,31 @@
+export type Block = {
+    type: string;
+    [key: string]: any;
+};
+export type Message = {
+    role: string;
+    content: string | Block[];
+};
+export type Body = {
+    model?: string;
+    system?: string | Block[];
+    messages: Message[];
+    tools?: unknown[];
+    metadata?: {
+        user_id?: string;
+    };
+    [key: string]: any;
+};
+export declare function contentBlocks(content: unknown): Block[];
+export declare function blocks(message: Message): Block[];
+export declare function textOf(message: Message): string;
+export declare function resultText(block: Block): string;
+export declare function withoutCacheControl(block: Block): Block;
+export declare function clean(message: Message): Message;
+export declare function sha256(text: string): string;
+export declare function shortHash(json: string, chars: number): string;
+export declare function quickHash(text: string): string;
+export declare function truncate(text: string, max: number): string;
+export declare function clip(value: unknown, max: number): string;
+export declare function wellFormed(_key: string, value: unknown): unknown;
+export declare function describeToolCall(block: Block): string;

package/dist/types/context/fold/evidence.d.ts

@@ -0,0 +1,20 @@
+import { type Block, type Message } from "../content.js";
+export interface EvidenceOptions {
+    linesPerCall?: number;
+    lineChars?: number;
+    turnChars?: number;
+    scanLines?: number;
+    minScore?: number;
+    allTools?: boolean;
+    ranked?: boolean;
+    labels?: boolean;
+    callFloor?: number;
+}
+export declare const REREADABLE_TOOLS: Set<string>;
+export declare function isSalient(line: string): boolean;
+export declare function salientLines(text: string, options?: EvidenceOptions): string[];
+export declare function toolPairs(turn: Message[]): Array<{
+    call: Block;
+    result: Block;
+}>;
+export declare function turnEvidence(turn: Message[], options?: EvidenceOptions): string | null;

package/dist/types/context/fold/index.d.ts

@@ -0,0 +1,11 @@
+import { type Message } from "../content.js";
+import { type RecallChunk } from "../recall/index.js";
+export interface FoldedTurn {
+    user: string;
+    evidence: string;
+    reply: string;
+}
+export declare const FOLD_CAP_CHARS = 400000;
+export declare function foldedTurns(messages: Message[]): FoldedTurn[];
+export declare function foldedView(messages: Message[], cap?: number): string;
+export declare function sourceChunks(messages: Message[], from: string, users?: boolean): RecallChunk[];

package/dist/types/context/fold/strategies.d.ts

@@ -0,0 +1,20 @@
+import { type Block, type Body, type Message } from "../content.js";
+import { type ReduceOptions } from "./turns.js";
+export interface CompactOptions extends ReduceOptions {
+    keepTurns: number;
+    capChars?: number;
+    guide: string | null;
+    omittedBefore?: number;
+    reduce?: (turn: Message[], options: ReduceOptions) => Message[];
+    pinned?: ReadonlySet<string>;
+}
+export declare const countPinned: (turns: Message[][], pinned: ReadonlySet<string>) => number;
+export declare function trimMessages(messages: Message[], options?: ReduceOptions): Message[];
+export declare const CARRIED_CHARS = 80000;
+export declare const foldsOpening: (opening: Message[], keptFrom: number) => boolean;
+export declare function compactMessages(messages: Message[], cutIndex: number, options: CompactOptions): Message[];
+export declare function capTurns(messages: Message[], options: CompactOptions): Message[];
+export declare function tailMessages(messages: Message[], from: number, guide: string | null): Message[];
+export declare function countToolResults(messages: Message[], from: number): number;
+export declare function clearToolResults(messages: Message[], from: number, count: number, placeholder: string): Message[];
+export declare function appendSystem(system: Body["system"], text: string): Block[];

package/dist/types/context/fold/turns.d.ts

@@ -0,0 +1,14 @@
+import { type Message } from "../content.js";
+export interface ReduceOptions {
+    evidence?: boolean;
+}
+export declare const isStaleNote: (text: unknown) => boolean;
+export declare function isPrompt(message: Message): boolean;
+export declare function splitTurns(messages: Message[]): {
+    preamble: Message[];
+    turns: Message[][];
+};
+export declare function turnFingerprint(turn: Message[]): string;
+export declare function isHarness(message: Message): boolean;
+export declare function hasContent(message: Message): boolean;
+export declare function reduceTurn(turn: Message[], options?: ReduceOptions): Message[];

package/dist/types/context/prompts.d.ts

@@ -0,0 +1,24 @@
+interface NoticeCounts {
+    omitted: number;
+    kept: number;
+    pinned?: number;
+    guide: string | null;
+}
+export declare const SYSTEM_PROMPT: string;
+export declare function handoffBlock(label: string, text: string): string;
+export declare function recalledContext(entries: string[], fromEarlierSessions: boolean): string;
+export declare function rerankQuestion(query: string): string;
+export declare function toolEvidence(entries: string[]): string;
+export declare function interruptedReply(lastWords: string | undefined, calls: string[]): string;
+export declare function clearedOutput(dir: string | null): string;
+export declare function clearedInput(kept: string, cleared: number): string;
+export declare function compactionNotice({ omitted, kept, pinned, guide }: NoticeCounts): string;
+export declare function truncationNotice({ omitted, kept, guide }: NoticeCounts): string;
+export declare function trimInstructions(guide: string | null): string;
+export declare function searchOnlyInstructions(guide: string): string;
+export declare function searchGuide(ref: {
+    mode: string;
+    jsonl: string;
+    dir: string;
+}): string;
+export {};

package/dist/types/context/recall/index.d.ts

@@ -0,0 +1,44 @@
+import { type Message } from "../content.js";
+export interface RecallChunk {
+    turn: number;
+    from?: string;
+    call: string;
+    lines: string[];
+    terms: string[];
+}
+export interface RecallOptions {
+    windowLines?: number;
+    perQuery?: number;
+    minTerms?: number;
+    maxChars?: number;
+    maxCharsMulti?: number;
+    narrative?: boolean;
+    callWeight?: number;
+    salientExcerpt?: boolean;
+    candidates?: number;
+}
+export interface RecallPick {
+    index: number;
+    query: Set<string>;
+}
+export type Reranker = (query: string, chunks: RecallChunk[], candidates: number[]) => Promise<number[]>;
+export declare function terms(text: string): string[];
+export declare function recallChunks(messages: Message[], keptIds: Map<string, string>, options?: RecallOptions): RecallChunk[];
+interface RankedChunk {
+    index: number;
+    score: number;
+    matched: number;
+}
+export declare function warmIndex(chunks: RecallChunk[], until: number): boolean;
+export declare function rank(query: string[], chunks: RecallChunk[], minTerms?: number): RankedChunk[];
+export declare const identityReranker: Reranker;
+export declare function pickRecallWith(prompt: string, chunks: RecallChunk[], rerank: Reranker, options?: RecallOptions): Promise<RecallPick[]>;
+export declare function renderRecall(prompt: string, chunks: RecallChunk[], picks: RecallPick[], options?: RecallOptions): string | null;
+export declare function recallFor(prompt: string, chunks: RecallChunk[], options?: RecallOptions): string | null;
+export declare function recallForWith(prompt: string, chunks: RecallChunk[], rerank: Reranker, options?: RecallOptions): Promise<string | null>;
+export declare function livePrompt(messages: Message[]): {
+    index: number;
+    text: string;
+} | null;
+export declare function withRecall(messages: Message[], fingerprint: (message: Message) => string, recalls: Record<string, string>): Message[];
+export {};

package/dist/types/context/recall/rerank.d.ts

@@ -0,0 +1,3 @@
+import type { Reranker } from "./index.js";
+export declare function orderByProbability(candidates: number[], probabilities: Record<string, number>): number[];
+export declare function jevReranker(model: string, key: string, endpoint?: string, onError?: (reason: string) => void): Reranker;

package/dist/types/core/compaction.d.ts

@@ -0,0 +1,32 @@
+import { type Body, type Message } from "../context/content.js";
+import { type CompactOptions } from "../context/fold/strategies.js";
+import type { CoreConfig } from "./config.js";
+import { type Estimator } from "./estimate.js";
+import type { RewriteNote } from "./rewrite.js";
+import { type ThreadState } from "./state.js";
+export interface CompactInput {
+    body: Body;
+    config: CoreConfig;
+    state: ThreadState;
+    window: number | null;
+    guide: string | null;
+    transcriptDir?: string | null;
+    mayCompact: boolean;
+    omittedBefore?: number;
+    decorate?: (messages: Message[]) => Message[];
+    reduce?: CompactOptions["reduce"];
+}
+export interface CompactResult {
+    messages: Message[];
+    stateChanged: boolean;
+    note: RewriteNote;
+}
+export type StuckSizes = ReturnType<typeof stuckSizes>;
+declare function stuckSizes(messages: Message[], headEnd: number, liveFrom: number, size: Estimator): {
+    fixed: number;
+    head: number;
+    folded: number;
+    live: number;
+};
+export declare function compact({ body, config, state, window, guide, transcriptDir, mayCompact, omittedBefore, decorate, reduce }: CompactInput): CompactResult;
+export {};

package/dist/types/core/config.d.ts

@@ -0,0 +1,33 @@
+export type Mode = "off" | "compact" | "default";
+interface EvalConfig {
+    recallOptions?: {
+        maxChars?: number;
+        maxCharsMulti?: number;
+        perQuery?: number;
+    };
+    strategy?: "tail" | "guide" | "trim";
+    rolling?: {
+        keep: number;
+        budget: number;
+    };
+    forceCut?: boolean;
+    trustHeaders?: boolean;
+    evidence?: boolean;
+    recall?: boolean;
+    rerank?: {
+        model: string;
+        candidates?: number;
+        endpoint?: string;
+    };
+}
+export interface CoreConfig {
+    mode: Mode;
+    compactAt: number;
+    keepTurns: number | "all";
+    keep: number;
+    budget: number;
+    turnCap: number | "off";
+    eval?: EvalConfig;
+}
+export declare const CORE_DEFAULTS: CoreConfig;
+export {};

package/dist/types/core/estimate.d.ts

@@ -0,0 +1,9 @@
+import type { Body, Message } from "../context/content.js";
+export interface Estimator {
+    of: (messages: Message[]) => number;
+    fixed: number;
+}
+export declare const DEFAULT_RATIO: number;
+export declare function sizeOf(body: Pick<Body, "system" | "tools" | "messages">): number;
+export declare function estimator(body: Body, ratio: number): Estimator;
+export declare function targetSize(size: Estimator, window: number): number;

package/dist/types/core/fingerprint.d.ts

@@ -0,0 +1,10 @@
+import { type Body, type Message } from "../context/content.js";
+export interface ContextFingerprint {
+    system: string;
+    tools: string;
+    skills: string[];
+    given?: ContextFingerprint;
+}
+export declare const isInjected: (text: unknown) => boolean;
+export declare function messageFingerprint(message: Message): string;
+export declare function contextFingerprint(body: Body): ContextFingerprint;

package/dist/types/core/fold.d.ts

@@ -0,0 +1,18 @@
+import type { Message } from "../context/content.js";
+import { type ThreadStore } from "./state.js";
+export interface FoldTarget {
+    store: ThreadStore;
+    threadId: string;
+    messages: Message[];
+}
+export interface FoldOptions {
+    at?: number | "latest";
+    pin?: number[];
+}
+export interface Folded {
+    threadKey: string;
+    cutTurn: number | null;
+    pinned: number[];
+}
+export declare function foldThread(target: FoldTarget, { at, pin }?: FoldOptions): Folded;
+export declare function pinTurns(target: FoldTarget, indices: number[], pinned?: boolean): Folded;

package/dist/types/core/forward.d.ts

@@ -0,0 +1,24 @@
+import { type Body } from "../context/content.js";
+import type { Reranker } from "../context/recall/index.js";
+import { type CoreConfig } from "./config.js";
+import { type Rewrite, type RewriteNote, type ThreadSources } from "./rewrite.js";
+import type { ThreadStore } from "./state.js";
+import { type WindowLookup } from "./window.js";
+export type ForwardNote = RewriteNote | Record<string, unknown>;
+export type Prepared = Omit<Rewrite, "note"> & {
+    note: ForwardNote;
+};
+export interface ForwarderOptions {
+    store: ThreadStore;
+    upstream?: string;
+    config?: CoreConfig;
+    window?: number | null | WindowLookup;
+    threadIdOf?: (request: Request, body: Body) => string | null;
+    sources?: (threadId: string, request: Request, body: Body) => ThreadSources | undefined;
+    reranker?: Reranker;
+    prepare?: (request: Request, body: Body, mayCompact: boolean) => Promise<Prepared>;
+    record?: (entry: Record<string, unknown>) => void;
+    countTokensTimeoutMs?: number;
+}
+export declare function claudeCodeSessionId(headers: Headers, body: Body): string | null;
+export declare function createForwarder(options: ForwarderOptions): (request: Request) => Promise<Response>;

package/dist/types/core/handoff.d.ts

@@ -0,0 +1,10 @@
+import { type Message } from "../context/content.js";
+import type { RecallChunk } from "../context/recall/index.js";
+import type { ThreadSources } from "./rewrite.js";
+import type { Handoff, ThreadState } from "./state.js";
+export declare const continueToken: (id: string) => string;
+export declare function continueIdOf(message: Message): string | null;
+export declare function activeHandoffs(handoffs?: Record<string, Handoff | null>): Record<string, Handoff>;
+export declare function attachHandoffs(messages: Message[], sources: ThreadSources, state: ThreadState): boolean;
+export declare function withHandoffs(messages: Message[], handoffs: Record<string, Handoff>): Message[];
+export declare function handoffChunks(handoffs: Record<string, Handoff>, sources: ThreadSources): RecallChunk[];

package/dist/types/core/index.d.ts

@@ -0,0 +1,14 @@
+export type { Block, Body, Message } from "../context/content.js";
+export type { RecallChunk, Reranker } from "../context/recall/index.js";
+export { jevReranker } from "../context/recall/rerank.js";
+export type { StuckSizes } from "./compaction.js";
+export { CORE_DEFAULTS, type CoreConfig, type Mode } from "./config.js";
+export { type Folded, type FoldOptions, type FoldTarget, foldThread, pinTurns } from "./fold.js";
+export { claudeCodeSessionId, createForwarder, type ForwarderOptions, type ForwardNote, type Prepared } from "./forward.js";
+export { continueToken } from "./handoff.js";
+export { type Rewrite, type RewriteInput, type RewriteNote, rewrite, rewriteAsync, type ThreadSources, threadKeyOf } from "./rewrite.js";
+export { memoryStore, type ThreadState, type ThreadStore } from "./state.js";
+export { listSubagentRecall, type Subagent } from "./subagents.js";
+export { renderTranscriptFiles, type TranscriptOptions, transcriptGuide } from "./transcript.js";
+export { inputTokens, recordOverflow, recordUsage, type Usage, watchUsage } from "./usage.js";
+export { createWindowLookup, type WindowLookup } from "./window.js";

package/dist/types/core/recall.d.ts

@@ -0,0 +1,8 @@
+import { type Reranker } from "../context/recall/index.js";
+import type { Rewrite, RewriteInput } from "./rewrite.js";
+export declare const wantsRecall: (input: RewriteInput) => boolean;
+export declare const activeRecalls: (recalls?: Record<string, string>) => {
+    [k: string]: string;
+};
+export declare function applyRecall(input: RewriteInput, result: Rewrite): Rewrite;
+export declare function prefetchFor(input: RewriteInput, result: Rewrite, rerank: Reranker): Promise<number | null>;

package/dist/types/core/rewrite.d.ts

@@ -0,0 +1,63 @@
+import type { Body, Message } from "../context/content.js";
+import { type RecallChunk, type Reranker } from "../context/recall/index.js";
+import { type StuckSizes } from "./compaction.js";
+import type { CoreConfig } from "./config.js";
+import type { ThreadStore } from "./state.js";
+export interface ThreadSources {
+    guide?: string | null;
+    transcriptDir?: string | null;
+    readHistory?: () => Message[];
+    listSubagentChunks?: () => RecallChunk[];
+    findHandoff?: (id: string) => {
+        label: string;
+        source: string;
+    } | null;
+    readHandoff?: (source: string) => Message[];
+}
+export interface RewriteInput {
+    body: Body;
+    threadId: string | null;
+    config: CoreConfig;
+    store: ThreadStore;
+    sources?: ThreadSources;
+    window: number | null;
+    mayCompact: boolean;
+    omittedBefore?: number;
+}
+export type RewriteNote = {
+    action: "pass" | "full" | "compact" | "guide" | "trim" | "tail";
+    compacted?: boolean;
+    actions?: string[];
+    cutTurn?: number | null;
+    omitted?: number;
+    folded?: number;
+    pinned?: number;
+    host?: boolean;
+    keep?: number;
+    cleared?: number;
+    stuck?: StuckSizes;
+    turns?: number;
+    keptTurns?: number;
+    messagesIn?: number;
+    messagesOut?: number;
+    estimate?: number;
+    window?: number | null;
+    fit?: "recut" | "bare" | "over";
+    fitEstimate?: number;
+    recalled?: number;
+    handoff?: number;
+    handoffFrom?: string;
+};
+export interface Rewrite {
+    body: Body;
+    threadKey: string | null;
+    note: RewriteNote;
+}
+export declare function threadKeyOf(threadId: string, messages: Message[]): string | null;
+export declare function rewrite(input: RewriteInput, before?: Rewrite): Rewrite;
+export declare function prefetchRecall(input: RewriteInput, rerank: Reranker): Promise<{
+    reranked: boolean;
+    rerankError: null;
+    recalled: number;
+} | null>;
+export declare function rewriteAsync(input: RewriteInput, rerank?: Reranker): Promise<Rewrite>;

package/dist/types/core/state.d.ts

@@ -0,0 +1,22 @@
+export interface Handoff {
+    label: string;
+    source: string;
+    text: string;
+}
+export interface ThreadState {
+    handoffs?: Record<string, Handoff | null>;
+    cut?: string;
+    keep?: number;
+    cleared?: number;
+    stuck?: number;
+    host?: boolean;
+    pins?: string[];
+    ratio?: number;
+    recalls?: Record<string, string>;
+}
+export interface ThreadStore {
+    read: (key: string) => ThreadState;
+    save: (key: string, state: ThreadState) => void;
+}
+export declare function memoryStore(initial?: Record<string, ThreadState>): ThreadStore;
+export declare function resetCut(state: ThreadState): void;

package/dist/types/core/subagents.d.ts

@@ -0,0 +1,10 @@
+import { type Message } from "../context/content.js";
+import { type RecallChunk } from "../context/recall/index.js";
+export interface Subagent {
+    description: string;
+    messages: Message[];
+    toolUseId?: string;
+}
+export declare function launchTurnOf(parentMessages: Message[], toolUseId: string | undefined): number;
+export declare function subagentRecall(messages: Message[], description: string, parentTurn: number): RecallChunk[];
+export declare function listSubagentRecall(parentMessages: Message[], subagents: Subagent[]): RecallChunk[];

package/dist/types/core/transcript.d.ts

@@ -0,0 +1,9 @@
+import { type Message } from "../context/content.js";
+import { type TranscriptFormat } from "../transcript/parse.js";
+import { type Subagent } from "./subagents.js";
+export interface TranscriptOptions {
+    format?: TranscriptFormat;
+    subagents?: Subagent[];
+}
+export declare function renderTranscriptFiles(messages: Message[], { format, subagents }?: TranscriptOptions): Record<string, string>;
+export declare const transcriptGuide: (dir: string, format?: TranscriptFormat) => string;

package/dist/types/core/usage.d.ts

@@ -0,0 +1,7 @@
+import type { Body } from "../context/content.js";
+import type { ThreadStore } from "./state.js";
+export type Usage = Record<string, number>;
+export declare function watchUsage(response: Response, onUsage: (usage: Usage) => void): Response;
+export declare function inputTokens(usage: Usage): number;
+export declare function recordUsage(store: ThreadStore, threadKey: string, sent: Body | number, usage: Usage): boolean;
+export declare function recordOverflow(store: ThreadStore, threadKey: string, sent: Body | number, errorText: string): number | null;

package/dist/types/core/window.d.ts

@@ -0,0 +1,5 @@
+export type WindowLookup = (model: unknown, requestHeaders: Headers, upstream?: string) => Promise<number | null>;
+export declare function createWindowLookup({ known, onLearn }?: {
+    known?: Map<string, number>;
+    onLearn?: (windows: Map<string, number>) => void;
+}): WindowLookup;

package/dist/types/transcript/format.d.ts

@@ -0,0 +1,16 @@
+import type { TranscriptFormat, Turn } from "./parse.js";
+export interface SubagentRecord {
+    run: {
+        description: string;
+    };
+    turns: Turn[];
+    parentTurn: number;
+    file: string;
+}
+export declare function turnFile(turn: Turn, format: TranscriptFormat): string;
+export declare function subagentFile(parentTurn: number, k: number, format: TranscriptFormat): string;
+export declare function renderMarkdown(turn: Turn): string;
+export declare function renderXml(turn: Turn): string;
+export declare function renderIndex(turns: Turn[], format: TranscriptFormat, records?: SubagentRecord[]): string;
+export declare function renderSubagentMarkdown(record: SubagentRecord): string;
+export declare function renderSubagentXml(record: SubagentRecord): string;

package/dist/types/transcript/parse.d.ts

@@ -0,0 +1,45 @@
+import { type Block, type Message } from "../context/content.js";
+export interface SessionEntry {
+    type?: string;
+    subtype?: string;
+    isSidechain?: boolean;
+    isMeta?: boolean;
+    isCompactSummary?: boolean;
+    agentId?: string;
+    timestamp?: string;
+    cwd?: string;
+    aiTitle?: string;
+    message?: {
+        role: string;
+        content: string | Block[];
+    };
+}
+export type TranscriptFormat = "markdown" | "xml";
+export interface ToolPart {
+    kind: "tool";
+    n: number;
+    id: string;
+    name: string;
+    prompt?: string;
+    record?: string;
+    call: string;
+    body: string;
+    output: string;
+    error: boolean;
+}
+type TurnPart = {
+    kind: "say";
+    text: string;
+} | ToolPart;
+export interface Turn {
+    number: number;
+    time: string;
+    prompt: string;
+    parts: TurnPart[];
+    final: string;
+    calls: number;
+}
+export declare function parseJsonl<T = SessionEntry>(text: string): T[];
+export declare function entryMessages(entries: SessionEntry[]): Message[];
+export declare function parseTurns(entries: SessionEntry[], sidechain?: boolean | "any"): Turn[];
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chroxify/eunoe",
-  "version": "1.2.2",
+  "version": "1.3.0",
   "description": "Context management for Claude Code that never forgets what matters.",
   "license": "MIT",
   "repository": {
@@ -18,12 +18,21 @@
     "proxy"
   ],
   "type": "module",
+  "exports": {
+    ".": {
+      "bun": "./src/core/index.ts",
+      "types": "./dist/types/core/index.d.ts",
+      "default": "./dist/core/index.js"
+    },
+    "./package.json": "./package.json"
+  },
   "bin": {
     "eunoe": "src/cli/main.ts",
     "ee": "src/cli/main.ts"
   },
   "files": [
     "src",
+    "dist",
     "README.md",
     "LICENSE"
   ],
@@ -34,11 +43,14 @@
     "start": "bun src/cli/main.ts serve",
     "test": "bun test",
     "check-types": "tsc --noEmit -p .",
+    "build:core": "bun scripts/build-core.ts",
+    "smoke:workers": "bun run build:core && bun build examples/durable-object.ts --target=browser --format=esm --outfile dist/workers/durable-object.js && node test/workers-smoke.mjs",
     "lint": "biome check . && bun lint:conventions",
     "lint:conventions": "bun scripts/lint-conventions.ts",
     "format": "biome check .",
     "format:fix": "biome check . --write",
-    "prepare": "husky"
+    "prepare": "husky",
+    "prepublishOnly": "bun run build:core"
   },
   "devDependencies": {
     "@babel/parser": "7.27.0",
@@ -47,6 +59,7 @@
     "husky": "9.1.7",
     "knip": "6.41.0",
     "lint-staged": "16.4.0",
+    "miniflare": "4.20260730.0",
     "typescript": "^7.0.2"
   },
   "publishConfig": {

package/src/cli/commands/mode.ts

@@ -1,4 +1,5 @@
-import { compactionOwner, MODES, type Mode, readConfig, saveConfig } from "../../config"
+import { compactionOwner, MODES, readConfig, saveConfig } from "../../config"
+import type { Mode } from "../../core/config"
 import type { Command } from "../command"
 import { editSettings, withCompactionOwner } from "../proxy/claude-settings"
 import { routedDirs } from "../proxy/inspect"

package/src/cli/commands/status.ts

@@ -1,7 +1,7 @@
 import path from "node:path"
 import { type Config, modeFor, overrides, readConfig } from "../../config"
 import { paths } from "../../config/paths"
-import { rerankKey } from "../../context/recall/rerank"
+import { rerankKey } from "../../proxy/rewrite"
 import type { Health } from "../../proxy/server"
 import { seenSessions } from "../../proxy/sessions"
 import { VERSION } from "../../version"

package/src/cli/proxy/stats.ts

@@ -1,4 +1,4 @@
-import { DEFAULT_RATIO } from "../../proxy/estimate"
+import { DEFAULT_RATIO } from "../../core/estimate"
 import { NATIVE_SUMMARY_CHARS, REPLAY_NATIVE_COMPACT_AT } from "../replay"
 import type { RequestRecord } from "./inspect"
 

package/src/cli/replay/index.ts

@@ -1,9 +1,9 @@
 import type { Config } from "../../config"
 import type { Body, Message } from "../../context/content"
 import { isPrompt, type ReduceOptions, reduceTurn, splitTurns, turnFingerprint } from "../../context/fold/turns"
-import { compact } from "../../proxy/compaction"
-import { DEFAULT_RATIO, sizeOf } from "../../proxy/estimate"
-import type { ThreadState } from "../../proxy/state"
+import { compact } from "../../core/compaction"
+import { DEFAULT_RATIO, sizeOf } from "../../core/estimate"
+import type { ThreadState } from "../../core/state"
 
 export interface ReplayOptions {
   config: Config

package/src/cli/sessions/index.ts

@@ -2,8 +2,8 @@ import { spawnSync } from "node:child_process"
 import { claudeConfigDirs, readConfig } from "../../config"
 import { FOLD_CAP_CHARS, foldedView, sourceChunks } from "../../context/fold"
 import { recallFor } from "../../context/recall"
-import { DEFAULT_RATIO } from "../../proxy/estimate"
-import { continueToken } from "../../proxy/handoff"
+import { DEFAULT_RATIO } from "../../core/estimate"
+import { continueToken } from "../../core/handoff"
 import { seenSessions } from "../../proxy/sessions"
 import { isSessionId } from "../../transcript/locate"
 import { subagentChunks } from "../../transcript/subagents"