@retaw106/mmc-oc 0.0.0-stage → 1.2.2

package/dist/hooks/magic-context/text-complete.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Persistence-boundary strip for assistant completions (`experimental.text.complete`).
+ *
+ * 1. **Leading well-formed runs** — `^(§N§\s*)+` removes canonical mimicked prefixes
+ *    at the start so persisted text stays clean; the transform layer re-injects the
+ *    authoritative `§N§ ` from DB tag state on the next pass.
+ *
+ * 2. **Global complete pairs** — `/§\d+§/g` removes whole cargo-cult `§N§` tokens
+ *    mid-text without leaving digit residue (unlike stripping `§` alone).
+ *
+ * 3. **Global malformed hybrids** — `§N">§…` shapes from compartment/XML confusion.
+ *
+ * 4. **Stray `§`** — any remaining section signs after pair removal.
+ *
+ * Transform-layer `stripTagPrefix` intentionally does NOT strip bare leading digits;
+ * only this persistence path performs global MC-notation cleanup.
+ *
+ * Cost: legitimate lone `§` (e.g. `§5.1` section refs) becomes `5.1` after step 4.
+ * Models adapt to alternatives (`Section 5.1`, `[5.1]`).
+ *
+ * Does not affect user message text (hook is assistant-only) or transform-injected
+ * sentinels like `[dropped §N§]`.
+ */
+export declare function createTextCompleteHandler(): (_input: {
+    sessionID: string;
+    messageID: string;
+    partID: string;
+}, output: {
+    text: string;
+}) => Promise<void>;
+//# sourceMappingURL=text-complete.d.ts.map

package/dist/hooks/magic-context/text-complete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-complete.d.ts","sourceRoot":"","sources":["../../../src/hooks/magic-context/text-complete.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,wBAAgB,yBAAyB,KAEjC,QAAQ;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,EAEhE,QAAQ;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,KACzB,OAAO,CAAC,IAAI,CAAC,CAGnB"}

package/dist/hooks/magic-context/todo-view.d.ts

@@ -0,0 +1,127 @@
+/**
+ * Todo state synthesis — synthetic todowrite injection.
+ *
+ * Instead of inventing a custom `<current-todos>` block (which agents would
+ * need to learn to parse), we synthesize a realistic `todowrite` tool part
+ * and inject it into the latest assistant message on cache-busting passes.
+ * The agent reads it through their existing todowrite-tracking mental model:
+ * the wire shape is identical to OpenCode's stored todowrite tool parts
+ * (`{type: "tool", callID, tool: "todowrite", state: {input, output, ...}}`).
+ *
+ * Cache safety:
+ *   - Snapshot capture (in hook-handlers.ts on tool.execute.after) writes DB
+ *     only — no message mutation.
+ *   - Injection happens in transform-postprocess-phase.ts AFTER tagging and
+ *     AFTER applyPendingOperations, so the synthetic part never gets tagged
+ *     and is invisible to mmc_reduce and heuristic cleanup.
+ *   - The synthetic callID is deterministic (sha256(stateJson)) so a stable
+ *     snapshot produces a stable wire shape across passes; on defer passes we
+ *     re-inject the same part at the same anchor, idempotent via callID match.
+ *
+ * Wire shape verified against:
+ *   - OpenCode source: ~/Work/OSS/opencode/packages/opencode/src/tool/todo.ts
+ *   - Production OpenCode DB sample: part where data LIKE '%"tool":"todowrite"%'
+ */
+export declare const TODO_STATUS_PENDING = "pending";
+export declare const TODO_STATUS_IN_PROGRESS = "in_progress";
+export declare const TODO_STATUS_COMPLETED = "completed";
+export declare const TODO_STATUS_CANCELLED = "cancelled";
+export declare const TODO_PRIORITY_HIGH = "high";
+export declare const TODO_PRIORITY_MEDIUM = "medium";
+export declare const TODO_PRIORITY_LOW = "low";
+export declare const TODO_STATUSES: readonly ["pending", "in_progress", "completed", "cancelled"];
+export declare const TODO_PRIORITIES: readonly ["high", "medium", "low"];
+export type TodoStatus = (typeof TODO_STATUSES)[number];
+export type TodoPriority = (typeof TODO_PRIORITIES)[number];
+export interface TodoItem {
+    content: string;
+    status: TodoStatus;
+    priority: TodoPriority;
+}
+export declare const TERMINAL_STATUSES: Set<"completed" | "pending" | "in_progress" | "cancelled">;
+/**
+ * The set of statuses real OpenCode `todowrite` excludes when computing the
+ * tool-part `title` (e.g. "3 todos"). OpenCode counts only `completed` as
+ * "done"; cancelled todos still appear in the title's active count.
+ *
+ * Source: ~/Work/OSS/opencode/packages/opencode/src/tool/todo.ts:47-52.
+ */
+export declare const TITLE_DONE_STATUSES: Set<"completed" | "pending" | "in_progress" | "cancelled">;
+/**
+ * Normalize a `todowrite` args.todos array into a stable JSON string.
+ * Returns `null` if the input is not a valid todo array.
+ *
+ * Some Pi users disable Magic Context's built-in `todowrite` and install a
+ * third-party tool with the same name. Capture stays interoperable when that
+ * tool emits Magic Context's exact todo shape, but it must fail closed for any
+ * other status or priority values so bad state never reaches synthetic replay.
+ *
+ * Used by the snapshot capture path (`hook-handlers.ts`) to produce a
+ * deterministic representation that survives JSON round-tripping with
+ * stable field order.
+ */
+export declare function normalizeTodoStateJson(todos: unknown): string | null;
+/**
+ * A synthetic OpenCode tool part matching the wire shape of a real
+ * `todowrite` tool result.
+ *
+ * NOTE — deliberate field omissions vs OpenCode `ToolPart`:
+ *   - `id`, `sessionID`, `messageID`: OpenCode generates these from
+ *     `Identifier.ascending(...)` for parts that originate from real tool
+ *     calls and persist to the OpenCode DB. The synthetic part is
+ *     transform-only (never persisted to OpenCode's DB), so these fields
+ *     would be meaningless. The OpenCode wire serializer
+ *     (`MessageV2.toModelMessagesEffect`) only reads `part.state.*`,
+ *     `part.callID`, `part.tool`, and `part.metadata` — none of the
+ *     omitted fields participate in wire serialization. Verified against
+ *     ~/Work/OSS/opencode/packages/opencode/src/session/message-v2.ts:851-884.
+ */
+export interface SyntheticTodoPart {
+    type: "tool";
+    callID: string;
+    tool: "todowrite";
+    state: {
+        status: "completed";
+        input: {
+            todos: TodoItem[];
+        };
+        output: string;
+        title: string;
+        metadata: {
+            todos: TodoItem[];
+            truncated: false;
+        };
+        time: {
+            start: number;
+            end: number;
+        };
+    };
+    /** Marker so other plugin code can detect synthetic parts and skip them. */
+    syntheticTodoMarker: true;
+}
+/**
+ * Build a synthetic todowrite tool part from a normalized state JSON.
+ * Returns `null` if the state is empty or all todos are terminal — in
+ * those cases the agent doesn't need a reminder.
+ */
+export declare function buildSyntheticTodoPart(stateJson: string): SyntheticTodoPart | null;
+/**
+ * Compute a deterministic call_id from the snapshot JSON. Stable for stable
+ * state; identical state across passes produces identical callID, which
+ * gives byte-identical wire shape on both cache-busting and defer passes.
+ *
+ * Format chosen to clearly distinguish from real provider-generated IDs:
+ *   - Anthropic: `toolu_<24 base62 chars>`
+ *   - OpenAI:    `call_<random>`
+ *   - Synthetic: `mc_synthetic_todo_<16 hex chars>`
+ *
+ * Providers do not validate callID format — they only require matching IDs
+ * between tool_use and tool_result.
+ */
+export declare function computeSyntheticCallId(stateJson: string): string;
+/**
+ * Detect whether a part is a synthetic todo part this module produced.
+ * Used to skip synthetic parts during tagging and other tool-walk passes.
+ */
+export declare function isSyntheticTodoPart(part: unknown): boolean;
+//# sourceMappingURL=todo-view.d.ts.map

package/dist/hooks/magic-context/todo-view.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"todo-view.d.ts","sourceRoot":"","sources":["../../../src/hooks/magic-context/todo-view.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAIH,eAAO,MAAM,mBAAmB,YAAY,CAAC;AAC7C,eAAO,MAAM,uBAAuB,gBAAgB,CAAC;AACrD,eAAO,MAAM,qBAAqB,cAAc,CAAC;AACjD,eAAO,MAAM,qBAAqB,cAAc,CAAC;AAEjD,eAAO,MAAM,kBAAkB,SAAS,CAAC;AACzC,eAAO,MAAM,oBAAoB,WAAW,CAAC;AAC7C,eAAO,MAAM,iBAAiB,QAAQ,CAAC;AAEvC,eAAO,MAAM,aAAa,+DAKhB,CAAC;AAEX,eAAO,MAAM,eAAe,oCAIlB,CAAC;AAEX,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,CAAC,CAAC;AACxD,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,CAAC,CAAC;AAQ5D,MAAM,WAAW,QAAQ;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,UAAU,CAAC;IACnB,QAAQ,EAAE,YAAY,CAAC;CAC1B;AAKD,eAAO,MAAM,iBAAiB,4DAG5B,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,4DAA+C,CAAC;AAIhF;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAcpE;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,iBAAiB;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,WAAW,CAAC;IAClB,KAAK,EAAE;QACH,MAAM,EAAE,WAAW,CAAC;QACpB,KAAK,EAAE;YAAE,KAAK,EAAE,QAAQ,EAAE,CAAA;SAAE,CAAC;QAC7B,MAAM,EAAE,MAAM,CAAC;QACf,KAAK,EAAE,MAAM,CAAC;QACd,QAAQ,EAAE;YAAE,KAAK,EAAE,QAAQ,EAAE,CAAC;YAAC,SAAS,EAAE,KAAK,CAAA;SAAE,CAAC;QAClD,IAAI,EAAE;YAAE,KAAK,EAAE,MAAM,CAAC;YAAC,GAAG,EAAE,MAAM,CAAA;SAAE,CAAC;KACxC,CAAC;IACF,4EAA4E;IAC5E,mBAAmB,EAAE,IAAI,CAAC;CAC7B;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,iBAAiB,GAAG,IAAI,CAkClF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAGhE;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAmB1D"}

package/dist/hooks/magic-context/tokenizer-calibration.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Per-model tokenizer calibration ratios.
+ *
+ * ai-tokenizer's `claude` / `o200k_base` / `cl100k_base` / `p50k_base` encodings
+ * approximate provider tokenizers but drift from the API's actual count by
+ * model-specific amounts. Empirically measured ratios from
+ * `scripts/calibrate-tokenizer/` (sweep against real production system prompt
+ * + 39 MCP-style tools + minimal conversation, comparing local count vs each
+ * provider's own usage.input_tokens).
+ *
+ * `system_ratio = api_tokens / local_raw_tokens` for plain-text system prompts
+ * `tools_ratio  = api_tokens / local_raw_tokens` for the tools array
+ *
+ * Multiplying the local count by these ratios yields the API's count.
+ *
+ * Pattern matching: longest prefix wins. Unknown models fall back to 1.0 / 1.0
+ * (no calibration). Re-run the harness when adding new models or after a
+ * provider tokenizer change.
+ */
+export interface ModelCalibration {
+    systemRatio: number;
+    toolsRatio: number;
+    /** Table prefix the ratios were inherited from when the model itself is unmeasured. */
+    derivedFrom?: string;
+    /** A provider without measurements matched the model id against another provider's seeds. */
+    matchedByModelId?: boolean;
+    proseRatio: number;
+}
+/** Version of the static measurements and family-inheritance rules, independent of session usage samples. */
+export declare const CALIBRATION_TABLE_REVISION = "2026-09-30-sol-tokenizer-seeds-v3";
+export declare const UNKNOWN_FIT_RATIO: number;
+/** Whether the resolver found a measured or family-inherited seed, including neutral measurements. */
+export declare function hasModelCalibration(providerId: string | undefined, modelId: string | undefined): boolean;
+/**
+ * Look up calibration ratios for a given `providerID/modelID` key. Performs
+ * longest-prefix match (case-insensitive), then same-family inheritance.
+ * Unknown models retain neutral decision ratios; fit callers must instead use UNKNOWN_FIT_RATIO.
+ */
+export declare function resolveModelCalibration(providerId: string | undefined, modelId: string | undefined): ModelCalibration;
+/**
+ * Apply calibration to local raw counts and absorb the residual into the
+ * unknown-drift buckets so all categories sum to exactly inputTokens.
+ *
+ * Bucket policy by stability:
+ *   1. **Calibrated** (System, Tool Defs) — local count × measured per-model
+ *      ratio. We have empirically derived ratios from `scripts/calibrate-tokenizer/`,
+ *      so these match the API to within ~5%.
+ *   2. **Calibrated prose** (Compartments, Facts, Memories, Profile) —
+ *      local count × measured prose ratio (1.0 when unmeasured). Display-only:
+ *      transform budgets and served bytes continue to use raw local counts.
+ *   3. **Residual absorbers** (Conversation, Tool Calls) — proportionally
+ *      scaled to absorb whatever's left after (1) and (2). These have the
+ *      most genuine drift (mixed user/assistant text + tool I/O) and the
+ *      least fixed structure, so attributing the unknown remainder here is
+ *      the most honest mapping.
+ *
+ * Behavior at the edges:
+ *   - inputTokens === 0 → returns all zeros.
+ *   - residual local sum === 0 (no conversation or tool calls yet) →
+ *     conversation absorbs the full remainder so the bar still adds up.
+ *   - non-residual buckets together exceed inputTokens (rare clamp case) →
+ *     residuals = 0; calibrated system/tools + prose are scaled down proportionally so
+ *     the sum never exceeds inputTokens.
+ *   - rounding: residual ±1 token from rounding lands in the larger residual
+ *     bucket so exact equality is preserved.
+ */
+export interface CalibratedBuckets {
+    systemTokens: number;
+    toolDefinitionTokens: number;
+    compartmentTokens: number;
+    factTokens: number;
+    memoryTokens: number;
+    conversationTokens: number;
+    toolCallTokens: number;
+}
+export interface CalibrationInput {
+    inputTokens: number;
+    /** Local raw count (ai-tokenizer) for the system prompt. */
+    systemLocal: number;
+    /** Local raw count (ai-tokenizer) for the tool definitions. */
+    toolDefsLocal: number;
+    /** Raw first-message (m0) prose counts, calibrated for display only; budgets remain local. */
+    compartmentsLocal: number;
+    factsLocal: number;
+    memoriesLocal: number;
+    /** Residual absorbers — proportionally scaled to absorb the remainder. */
+    conversationLocal: number;
+    toolCallsLocal: number;
+    calibration: ModelCalibration;
+}
+export declare function calibrateBuckets(input: CalibrationInput): CalibratedBuckets;
+//# sourceMappingURL=tokenizer-calibration.d.ts.map

package/dist/hooks/magic-context/tokenizer-calibration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokenizer-calibration.d.ts","sourceRoot":"","sources":["../../../src/hooks/magic-context/tokenizer-calibration.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,MAAM,WAAW,gBAAgB;IAC7B,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,uFAAuF;IACvF,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,6FAA6F;IAC7F,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,UAAU,EAAE,MAAM,CAAC;CACtB;AAaD,6GAA6G;AAC7G,eAAO,MAAM,0BAA0B,sCAAsC,CAAC;AAE9E,eAAO,MAAM,iBAAiB,QAO7B,CAAC;AAEF,sGAAsG;AACtG,wBAAgB,mBAAmB,CAC/B,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,OAAO,EAAE,MAAM,GAAG,SAAS,GAC5B,OAAO,CAET;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CACnC,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,OAAO,EAAE,MAAM,GAAG,SAAS,GAC5B,gBAAgB,CA0ClB;AAwHD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,WAAW,iBAAiB;IAC9B,YAAY,EAAE,MAAM,CAAC;IACrB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,cAAc,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,gBAAgB;IAC7B,WAAW,EAAE,MAAM,CAAC;IACpB,4DAA4D;IAC5D,WAAW,EAAE,MAAM,CAAC;IACpB,+DAA+D;IAC/D,aAAa,EAAE,MAAM,CAAC;IACtB,8FAA8F;IAC9F,iBAAiB,EAAE,MAAM,CAAC;IAC1B,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;IACtB,0EAA0E;IAC1E,iBAAiB,EAAE,MAAM,CAAC;IAC1B,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,gBAAgB,CAAC;CACjC;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,gBAAgB,GAAG,iBAAiB,CA8H3E"}

package/dist/hooks/magic-context/tool-drop-target.d.ts

@@ -0,0 +1,144 @@
+import type { MessageLike, ThinkingLikePart } from "./tag-messages";
+export type ToolDropResult = "removed" | "truncated" | "absent" | "incomplete";
+interface ToolCallObservation {
+    callId: string;
+    kind: "invocation" | "result";
+}
+export interface IndexedOccurrence {
+    message: MessageLike;
+    part: unknown;
+    kind: "invocation" | "result";
+    /**
+     * The rewritten clone currently standing in for `part` in the message's
+     * parts array, when a clamp swapped one in this pass. `part` itself stays
+     * the untouched host object, so a later rewrite in the same pass (a legacy
+     * skeleton converted on a HARD fold) still starts from the real input and
+     * knows which array entry to replace or remove.
+     */
+    served?: unknown;
+}
+export interface ToolCallIndexEntry {
+    occurrences: IndexedOccurrence[];
+    hasResult: boolean;
+}
+export type ToolCallIndex = Map<string, ToolCallIndexEntry>;
+export declare function hasMeaningfulPart(part: unknown): boolean;
+/**
+ * True when a tool part carries a COMPLETED result — i.e. the arc is closed and
+ * OpenCode will not read its input again. This is the selection gate that keeps
+ * open arcs (an invocation with no result yet) out of every drop/clamp selector.
+ *
+ * OpenCode's single-part `{ type: "tool" }` representation is classified as a
+ * "result" observation by its TYPE even while the call is still pending/running
+ * (no output written yet). The arc is closed in either of two arms: a completed
+ * result (`state.output` is a string) OR an errored call (`state.status ===
+ * "error"`, carrying `state.error`). OpenCode serializes an errored part as an
+ * `output-error` block built from `state.error` and never reads its input again
+ * (opencode message-v2.ts error arm), so it is just as safe to reclaim as a
+ * completed one — excluding it would leak bulky inputs (e.g. a failed write with
+ * a large content arg). Pending/running parts have neither an output nor an
+ * error status and stay excluded. Anthropic's separate `tool_result` part only
+ * exists after the call finished, so it always counts. Invocation-shaped parts
+ * (`tool-invocation` / `tool_use`) never carry a result and are excluded here.
+ */
+export declare function partHasCompletedResult(part: unknown): boolean;
+export declare function extractToolCallObservation(part: unknown): ToolCallObservation | null;
+/**
+ * The two arrays a pre-adoption pass could serve, offered to a variant
+ * resolver before either one is applied. `legacy` is what the original
+ * session-wide sweep would serve (every row left without a meaningful part is
+ * removed, including rows this pass never touched); `scoped` is what the
+ * narrow sweep would serve (only the tool-drop owners this pass emptied).
+ */
+export interface ToolSweepCandidates {
+    legacy: MessageLike[];
+    scoped: MessageLike[];
+}
+/** Choose the sweep variant for this pass; `true` selects the scoped sweep. */
+export type ToolSweepVariantResolver = (candidates: ToolSweepCandidates) => boolean;
+export declare class ToolMutationBatch {
+    private readonly scopedSweep;
+    private readonly servedMessages?;
+    private partsToRemove;
+    private affectedMessages;
+    private messages;
+    private resolvedScopedSweep;
+    /**
+     * `servedMessages` is the array that actually goes to the provider when it
+     * is not the array being tagged (see `pruneServedRows`). Leave it undefined
+     * whenever tagging and serving share one array.
+     */
+    constructor(messages: MessageLike[], scopedSweep?: boolean | ToolSweepVariantResolver, servedMessages?: MessageLike[] | undefined);
+    markForRemoval(occurrence: IndexedOccurrence): void;
+    /**
+     * Would removing `occurrences` (on top of everything already marked in this
+     * batch) leave the provider request ending on an assistant turn?
+     *
+     * The request ends with the newest message that has any content (a blank
+     * pending assistant shell after it does not count). When that message is an
+     * assistant, its tool results are what the provider sees as the closing user
+     * turn, so at least one must survive. Any other role must keep some content,
+     * or the sweep removes it and an earlier assistant becomes the end. Models
+     * without assistant prefill support reject an assistant-terminated request.
+     */
+    wouldStrandConversationEnd(occurrences: readonly IndexedOccurrence[]): boolean;
+    finalize(): void;
+    /** Ask the resolver once per batch so every finalize in a pass sweeps alike. */
+    private resolveScopedSweep;
+    /**
+     * The array being tagged is not always the array that reaches the provider:
+     * on a pass that trims a compaction prefix, tagging runs over the pre-trim
+     * copy so persisted drops still find rows the trim removed. Splicing only
+     * that copy left the served array holding a message whose parts had all
+     * been removed, and the next pass — which sweeps the served array directly
+     * — removed it, so two passes over the same history served different
+     * arrays. Remove the same rows from both.
+     */
+    private pruneServedRows;
+}
+/**
+ * Build a TagTarget for a single tool composite key
+ * (`<ownerMsgId>\x00<callId>`).
+ *
+ * v3.3.1 Layer C: pre-fix this took a bare `callId`. Two assistant turns
+ * reusing the same callId produced two TagTargets that both pointed at
+ * the same `index.get(callId)` entry — last-write-wins on `targets.set`
+ * silently merged them into one drop target, and a queued drop on the
+ * older tag would mutate the newer turn's content. Composite keys
+ * guarantee one TagTarget per (owner, callId) pair, so each turn's tag
+ * gets its own independent drop scope.
+ *
+ * The `index` map is keyed by composite key as well — see
+ * `tag-messages.ts` for the matching producer.
+ */
+export declare function createToolDropTarget(compositeKey: string, thinkingParts: ThinkingLikePart[], index: ToolCallIndex, batch: ToolMutationBatch, tagId: number): {
+    setContent: (content: string) => boolean;
+    drop: () => ToolDropResult;
+    truncate: () => ToolDropResult;
+    skeletonReal: () => ToolDropResult;
+    editMarker: () => ToolDropResult;
+    editMarkerStripped: () => ToolDropResult;
+    skeletonStripped: () => ToolDropResult;
+    hasAttachments: () => boolean;
+    inputStringBytes: () => number | null;
+    wouldStrandConversationEnd: () => boolean;
+    /**
+     * Non-mutating predicate: would drop()/truncate() actually remove bytes?
+     * False for an absent (compacted-away) or incomplete (invocation present,
+     * no result part) entry — both return early without reclaiming anything.
+     * The tiered emergency planner must filter on this, not on the mere
+     * presence of a drop() function: counting a no-reclaim tag as droppable
+     * makes the plan stop early and under-evict below the ceiling.
+     */
+    canDrop: () => boolean;
+    requiresToolArcSkeleton: boolean;
+    readInput: () => Record<string, unknown> | null;
+    measureReclaim: (skeleton: boolean) => {
+        beforeTools: number;
+        afterTools: number;
+        beforeProse: number;
+        afterProse: number;
+    };
+};
+export {};
+//# sourceMappingURL=tool-drop-target.d.ts.map

package/dist/hooks/magic-context/tool-drop-target.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-drop-target.d.ts","sourceRoot":"","sources":["../../../src/hooks/magic-context/tool-drop-target.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAGpE,MAAM,MAAM,cAAc,GAAG,SAAS,GAAG,WAAW,GAAG,QAAQ,GAAG,YAAY,CAAC;AAE/E,UAAU,mBAAmB;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,YAAY,GAAG,QAAQ,CAAC;CACjC;AAED,MAAM,WAAW,iBAAiB;IAC9B,OAAO,EAAE,WAAW,CAAC;IACrB,IAAI,EAAE,OAAO,CAAC;IACd,IAAI,EAAE,YAAY,GAAG,QAAQ,CAAC;IAC9B;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,kBAAkB;IAC/B,WAAW,EAAE,iBAAiB,EAAE,CAAC;IACjC,SAAS,EAAE,OAAO,CAAC;CACtB;AAED,MAAM,MAAM,aAAa,GAAG,GAAG,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;AA0M5D,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAUxD;AAkBD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAO7D;AAED,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,OAAO,GAAG,mBAAmB,GAAG,IAAI,CAepF;AAMD;;;;;;GAMG;AACH,MAAM,WAAW,mBAAmB;IAChC,MAAM,EAAE,WAAW,EAAE,CAAC;IACtB,MAAM,EAAE,WAAW,EAAE,CAAC;CACzB;AAED,+EAA+E;AAC/E,MAAM,MAAM,wBAAwB,GAAG,CAAC,UAAU,EAAE,mBAAmB,KAAK,OAAO,CAAC;AAEpF,qBAAa,iBAAiB;IAatB,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAC;IAbpC,OAAO,CAAC,aAAa,CAAsB;IAC3C,OAAO,CAAC,gBAAgB,CAA0B;IAClD,OAAO,CAAC,QAAQ,CAAgB;IAChC,OAAO,CAAC,mBAAmB,CAAsB;IAEjD;;;;OAIG;gBAEC,QAAQ,EAAE,WAAW,EAAE,EACN,WAAW,GAAE,OAAO,GAAG,wBAAgC,EACvD,cAAc,CAAC,EAAE,WAAW,EAAE,YAAA;IAKnD,cAAc,CAAC,UAAU,EAAE,iBAAiB,GAAG,IAAI;IAKnD;;;;;;;;;;OAUG;IACH,0BAA0B,CAAC,WAAW,EAAE,SAAS,iBAAiB,EAAE,GAAG,OAAO;IAc9E,QAAQ,IAAI,IAAI;IA8BhB,gFAAgF;IAChF,OAAO,CAAC,kBAAkB;IAe1B;;;;;;;;OAQG;IACH,OAAO,CAAC,eAAe;CAO1B;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,oBAAoB,CAChC,YAAY,EAAE,MAAM,EACpB,aAAa,EAAE,gBAAgB,EAAE,EACjC,KAAK,EAAE,aAAa,EACpB,KAAK,EAAE,iBAAiB,EACxB,KAAK,EAAE,MAAM,GACd;IACC,UAAU,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC;IACzC,IAAI,EAAE,MAAM,cAAc,CAAC;IAC3B,QAAQ,EAAE,MAAM,cAAc,CAAC;IAC/B,YAAY,EAAE,MAAM,cAAc,CAAC;IACnC,UAAU,EAAE,MAAM,cAAc,CAAC;IACjC,kBAAkB,EAAE,MAAM,cAAc,CAAC;IACzC,gBAAgB,EAAE,MAAM,cAAc,CAAC;IACvC,cAAc,EAAE,MAAM,OAAO,CAAC;IAC9B,gBAAgB,EAAE,MAAM,MAAM,GAAG,IAAI,CAAC;IACtC,0BAA0B,EAAE,MAAM,OAAO,CAAC;IAC1C;;;;;;;OAOG;IACH,OAAO,EAAE,MAAM,OAAO,CAAC;IACvB,uBAAuB,EAAE,OAAO,CAAC;IACjC,SAAS,EAAE,MAAM,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAChD,cAAc,EAAE,CAAC,QAAQ,EAAE,OAAO,KAAK;QACnC,WAAW,EAAE,MAAM,CAAC;QACpB,UAAU,EAAE,MAAM,CAAC;QACnB,WAAW,EAAE,MAAM,CAAC;QACpB,UAAU,EAAE,MAAM,CAAC;KACtB,CAAC;CACL,CA8LA"}

package/dist/hooks/magic-context/tool-input-size.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Size rule for a dropped tool call inside the newest-call window.
+ *
+ * A dropped call's arguments are either served exactly as the host gave them
+ * or the whole call is removed. Every synthetic value ever placed in the
+ * argument position (5-character clamps ending in `...[truncated]`, then the
+ * `{"dropped": "[dropped §N§]"}` marker) was copied back by models into new
+ * calls, which either ran with garbage arguments or looped on the refusal.
+ * Small inputs therefore keep their real arguments; large ones are removed.
+ *
+ * The size is the total UTF-8 byte length of every string value, recursively
+ * through objects and arrays. Keys, numbers, booleans and nulls do not count.
+ * It is defined on string leaves so the OpenCode, Pi and Rust lanes compute the
+ * same number from the same input regardless of how each serializes JSON; the
+ * shared fixture `tests/fixtures/tool-input-string-bytes.json` pins it.
+ */
+export declare const SKELETON_REAL_INPUT_MAX_BYTES = 1024;
+export declare function toolInputStringBytes(value: unknown): number;
+/** True when a dropped call with this input keeps its real arguments. */
+export declare function isSmallToolInput(value: unknown): boolean;
+//# sourceMappingURL=tool-input-size.d.ts.map

package/dist/hooks/magic-context/tool-input-size.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-input-size.d.ts","sourceRoot":"","sources":["../../../src/hooks/magic-context/tool-input-size.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,6BAA6B,OAAO,CAAC;AAIlD,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAe3D;AAED,yEAAyE;AACzE,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAExD"}

package/dist/hooks/magic-context/tool-reclaim.d.ts

@@ -0,0 +1,12 @@
+import { type ContextDatabase } from "../../features/magic-context/storage";
+import type { PendingOp } from "../../features/magic-context/types";
+import type { TagTarget } from "./tag-messages";
+export declare function buildSyntheticToolReclaimOps(input: {
+    db: ContextDatabase;
+    sessionId: string;
+    targets: Map<number, TagTarget>;
+    watermark: number;
+    pendingOps?: readonly PendingOp[];
+}): PendingOp[];
+export declare function advanceToolReclaimWatermarkToCurrentMax(db: ContextDatabase, sessionId: string): number;
+//# sourceMappingURL=tool-reclaim.d.ts.map

package/dist/hooks/magic-context/tool-reclaim.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-reclaim.d.ts","sourceRoot":"","sources":["../../../src/hooks/magic-context/tool-reclaim.ts"],"names":[],"mappings":"AAAA,OAAO,EAGH,KAAK,eAAe,EAGvB,MAAM,sCAAsC,CAAC;AAC9C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oCAAoC,CAAC;AACpE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEhD,wBAAgB,4BAA4B,CAAC,KAAK,EAAE;IAChD,EAAE,EAAE,eAAe,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,SAAS,SAAS,EAAE,CAAC;CACrC,GAAG,SAAS,EAAE,CAmCd;AAED,wBAAgB,uCAAuC,CACnD,EAAE,EAAE,eAAe,EACnB,SAAS,EAAE,MAAM,GAClB,MAAM,CAIR"}

package/dist/hooks/magic-context/tool-sweep-policy.d.ts

@@ -0,0 +1,50 @@
+import type { Database } from "../../shared/sqlite";
+import type { MessageLike } from "./tag-messages";
+import type { ToolSweepCandidates, ToolSweepVariantResolver } from "./tool-drop-target";
+export declare const TOOL_SWEEP_SCOPED_MARKER = "@tool-sweep-scoped";
+/**
+ * Ledger entries that are session-wide control flags rather than message ids.
+ * The reasoning replay ledger is a plain set of strings, so every consumer that
+ * filters it by message identity (session clone, in particular) has to copy
+ * these through verbatim instead of discarding them as undecodable ids.
+ */
+export declare const RESERVED_LEDGER_CONTROL_ENTRIES: readonly string[];
+export declare function isReservedLedgerControlEntry(entry: string): boolean;
+/** Restore unrelated reasoning-only messages only when a cache-busting pass permits byte changes. */
+export declare function useScopedToolSweep(db: Database, sessionId: string, canAdopt: boolean): boolean;
+/**
+ * What the durable last-served snapshot says about a pre-adoption pass:
+ *
+ * - `lkg_absent`   nothing durable was recorded, so no bytes are known to have
+ *                  been served under either sweep.
+ * - `matched_old`  the last served rows are reproduced by the legacy sweep.
+ *                  Also reported when both candidates reproduce them, because
+ *                  then the snapshot is no evidence for changing behavior.
+ * - `matched_scoped` only the scoped sweep reproduces the last served rows.
+ * - `matched_neither` neither candidate reproduces them (history moved since).
+ */
+export type ToolSweepLkgCondition = "lkg_absent" | "matched_old" | "matched_scoped" | "matched_neither";
+export interface ToolSweepVariantDecision {
+    condition: ToolSweepLkgCondition;
+    /** True when this pass should serve — and therefore adopt — the scoped sweep. */
+    scoped: boolean;
+    legacyDivergence: number;
+    scopedDivergence: number;
+    lastServedRows: number;
+}
+export declare function classifyToolSweepCandidates(lastServed: readonly MessageLike[] | null, candidates: ToolSweepCandidates): ToolSweepVariantDecision;
+/**
+ * Pick the sweep variant for a pass that may NOT change bytes and has not
+ * adopted the scoped sweep yet.
+ *
+ * A session upgraded from a build that only ever ran the legacy sweep may have
+ * been served either array, depending on which code path last priced it, so a
+ * fixed default is wrong for one of the two populations. Instead compare both
+ * candidates against the last array this session actually served and serve the
+ * one that reproduces it. Reproducing the scoped array is adoption evidence —
+ * it re-serves bytes the session already paid for — so the marker is written on
+ * that pass. Every outcome is logged under one stable key so the populations
+ * can be counted.
+ */
+export declare function createPreAdoptionToolSweepResolver(db: Database, sessionId: string): ToolSweepVariantResolver;
+//# sourceMappingURL=tool-sweep-policy.d.ts.map

package/dist/hooks/magic-context/tool-sweep-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-sweep-policy.d.ts","sourceRoot":"","sources":["../../../src/hooks/magic-context/tool-sweep-policy.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAGpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,KAAK,EAAE,mBAAmB,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAC;AAIxF,eAAO,MAAM,wBAAwB,uBAAuB,CAAC;AAE7D;;;;;GAKG;AACH,eAAO,MAAM,+BAA+B,EAAE,SAAS,MAAM,EAG5D,CAAC;AAEF,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAEnE;AAED,qGAAqG;AACrG,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,GAAG,OAAO,CAI9F;AAED;;;;;;;;;;GAUG;AACH,MAAM,MAAM,qBAAqB,GAC3B,YAAY,GACZ,aAAa,GACb,gBAAgB,GAChB,iBAAiB,CAAC;AAExB,MAAM,WAAW,wBAAwB;IACrC,SAAS,EAAE,qBAAqB,CAAC;IACjC,iFAAiF;IACjF,MAAM,EAAE,OAAO,CAAC;IAChB,gBAAgB,EAAE,MAAM,CAAC;IACzB,gBAAgB,EAAE,MAAM,CAAC;IACzB,cAAc,EAAE,MAAM,CAAC;CAC1B;AAiDD,wBAAgB,2BAA2B,CACvC,UAAU,EAAE,SAAS,WAAW,EAAE,GAAG,IAAI,EACzC,UAAU,EAAE,mBAAmB,GAChC,wBAAwB,CA+B1B;AAaD;;;;;;;;;;;;GAYG;AACH,wBAAgB,kCAAkC,CAC9C,EAAE,EAAE,QAAQ,EACZ,SAAS,EAAE,MAAM,GAClB,wBAAwB,CAoB1B"}

package/dist/hooks/magic-context/transform-compartment-phase.d.ts

@@ -0,0 +1,133 @@
+import { type ContextDatabase } from "../../features/magic-context/storage";
+import type { ContextUsage } from "../../features/magic-context/types";
+import type { PluginContext } from "../../plugin/types";
+import type { ModelInput } from "../../shared/model-resolution";
+import type { HiddenCompartmentRunnerDeps, HiddenCompletionExecutor } from "./compartment-runner-types";
+import { type PreparedCompartmentInjection } from "./inject-compartments";
+import { type ProtectedTailBoundarySnapshot } from "./protected-tail-boundary";
+import type { MessageLike } from "./transform-operations";
+/**
+ * A transform blocks the user's turn before provider dispatch, so it may join a historian for at
+ * most one minute. The historian keeps running after this foreground budget and can publish for a
+ * later pass; the provider-sized historian timeout must never become a silent TUI wait.
+ */
+export declare const HISTORIAN_INLINE_JOIN_BUDGET_MS = 60000;
+export declare function resolveHistorianInlineJoinBudget(configuredTimeoutMs?: number): number;
+export declare function historianJoinFailClosedMessage(input: {
+    timedOut: boolean;
+    budgetMs: number | null;
+    finalWireEstimate?: {
+        tokens: number;
+        trusted: boolean;
+    };
+    contextLimitTokens: number;
+    lastHistorianError?: string | null;
+}): string | null;
+interface RunCompartmentPhaseArgs {
+    hiddenCompletionExecutor?: HiddenCompletionExecutor;
+    compactionMarkerStrategy?: HiddenCompartmentRunnerDeps["compactionMarkerStrategy"];
+    canRunCompartments: boolean;
+    fullFeatureMode: boolean;
+    /** Compaction-off mode (issue #266): no historian start, no 95% block,
+     *  no boundary resolution — the phase degrades to a stale-flag cleanup. */
+    compactionOff?: boolean;
+    /** False when historian.disable=true, blocking historian-backed child agents. */
+    historianRunnable?: boolean;
+    sessionMeta: {
+        compartmentInProgress: boolean;
+    };
+    contextUsage: {
+        percentage: number;
+    };
+    boundaryContextLimit: number;
+    boundaryExecuteThresholdPercentage: number;
+    boundaryUsage: ContextUsage;
+    boundaryUsageSource: "live" | "persisted" | "provisional-zero" | "manual-none";
+    client?: PluginContext["client"];
+    db: ContextDatabase;
+    sessionId: string;
+    resolvedSessionId: string;
+    historianChunkTokens: number;
+    historyBudgetTokens?: number;
+    historianTimeoutMs?: number;
+    historianModel?: ModelInput;
+    historianContextLimit?: number;
+    historianMaxOutputTokens?: number;
+    fallbackModels?: readonly ModelInput[];
+    compartmentDirectory: string;
+    messages: MessageLike[];
+    pendingCompartmentInjection: PreparedCompartmentInjection | null;
+    fallbackModelId?: string;
+    ensureProjectRegistered?: (directory: string, db: ContextDatabase) => Promise<void>;
+    projectPath?: string;
+    injectionBudgetTokens?: number;
+    getNotificationParams?: () => import("./send-session-notification").NotificationParams;
+    /** True when this pass is already safe for background compression to run. */
+    safeForBackgroundCompression?: boolean;
+    deferredHistoryRefreshSessions: Set<string>;
+    /** Compatibility-only input retained for older callers; urgent pressure always joins before refusal. */
+    skipAwaitForThisPass?: boolean;
+    /** When true, inject wall-clock dates on compartments in <session-history>. */
+    experimentalTemporalAwareness?: boolean;
+    /** When true, run a second editor pass after historian to clean U: lines. */
+    historianTwoPass?: boolean;
+    historianExpandTools?: Record<string, string | false>;
+    /** Cross-session memory feature gate (`memory.enabled`). Issue #44. */
+    memoryEnabled?: boolean;
+    /** Auto-promotion gate (`memory.auto_promote`). Issue #44. */
+    autoPromote?: boolean;
+    /** Forwarded to compartment runner — see CompartmentRunnerDeps.onCompartmentStatePublished. */
+    onCompartmentStatePublished?: (sessionId: string) => void;
+    /**
+     * Boundary snapshot already resolved by THIS pass's trigger decision
+     * (transform-located trigger). When present and runnable, the phase uses it
+     * instead of re-resolving — one boundary resolution per pass, and the
+     * historian starts from exactly the snapshot the fire decision saw. The
+     * ≥80% emergency re-scale fallback below still re-resolves when this
+     * snapshot has no runnable window.
+     */
+    preResolvedBoundarySnapshot?: ProtectedTailBoundarySnapshot;
+}
+/**
+ * Prime the raw-message cache for the WHOLE compartment phase, then run it.
+ *
+ * The phase's boundary resolution (`getRawHistoryEligibility` +
+ * `resolveOpenCodeProtectedTailBoundary`) AND the historian runner's
+ * `readSessionChunk` all read raw OpenCode history. On a large session an
+ * un-primed read is O(session) (multi-second each) and runs on the transform
+ * thread — OpenCode awaits `messages.transform` before the LLM call, so a
+ * historian-FIRE pass froze ~9.6s at "Thinking". The compartment TRIGGER primes
+ * its own scope (`withRawSessionMessageCache` inside `getUnsummarizedTailInfo`),
+ * but that scope ends when the trigger returns, so the phase read un-primed.
+ *
+ * Prime from the TAIL-ONLY DB read (`primeTailRawMessageCache`), NOT the
+ * in-memory `args.messages` tail: `extractInMemoryMessageViews` aliases the live
+ * `parts` objects, which the transform MUTATES between the trigger and this phase
+ * (§N§ prefixes, `[dropped]` sentinels, stripped reasoning). The historian must
+ * read RAW content; the DB read is unmutated and O(tail).
+ *
+ * Scope/await correctness: every raw read happens in the phase's SYNCHRONOUS
+ * prefix — `runCompartmentPhaseImpl` is `async` but reaches its first `await`
+ * only on the ≥95% blocking path (`awaitCompartmentRun`), and the runner's
+ * `readSessionChunk` runs in the runner's own synchronous prefix (before its
+ * first `await` at `client.session.get`). `withRawSessionMessageCache`'s
+ * try/finally clears the cache the moment the wrapped fn RETURNS its promise
+ * (i.e. after the synchronous body suspends at the first await), so the cache
+ * covers all raw reads; the only post-await work (`prepareCompartmentInjection`)
+ * reads context.db, never raw history. Priming once under `resolvedSessionId`
+ * covers the runner too — it reads under `args.sessionId`, which equals
+ * `resolvedSessionId` (transform.ts).
+ */
+export declare function runCompartmentPhase(args: RunCompartmentPhaseArgs): ReturnType<typeof runCompartmentPhaseImpl>;
+declare function runCompartmentPhaseImpl(args: RunCompartmentPhaseArgs): Promise<{
+    pendingCompartmentInjection: PreparedCompartmentInjection | null;
+    awaitedCompartmentRun: boolean;
+    compartmentInProgress: boolean;
+    published: boolean;
+    justAwaitedPublication: boolean;
+    rebuiltHistoryThisPass: boolean;
+    historianJoinTimedOut: boolean;
+    historianJoinBudgetMs: number | null;
+}>;
+export {};
+//# sourceMappingURL=transform-compartment-phase.d.ts.map