@retaw106/mmc-oc 0.0.0-stage → 1.2.2

package/dist/hooks/magic-context/read-session-formatting.d.ts

@@ -0,0 +1,65 @@
+export interface SessionChunkLine {
+    ordinal: number;
+    messageId: string;
+}
+export interface ChunkBlock {
+    role: string;
+    startOrdinal: number;
+    endOrdinal: number;
+    parts: string[];
+    partMeta: Array<{
+        ordinal: number;
+        toolResultBodyTokens: number;
+    }>;
+    meta: SessionChunkLine[];
+    commitHashes: string[];
+    /**
+     * True when every part in this block came from tool-call summaries only
+     * (no textual narrative from the user or assistant). Historian often skips
+     * such blocks — that's safe as long as we know the skipped range is
+     * tool-only, so we mark the block here and let validation absorb the gap.
+     */
+    isToolOnly: boolean;
+}
+export declare function hasMeaningfulUserText(parts: unknown[]): boolean;
+export declare function extractTexts(parts: unknown[]): string[];
+/** Count omitted tool-result bodies so pathological splits prefer the largest result boundary. */
+export declare function extractToolResultBodyTokens(parts: unknown[]): number;
+/** Extract compact tool-call summaries from message parts.
+ *  Returns lines like "TC: Fix lint errors" or "TC: read(src/index.ts)". */
+export declare function extractToolCallSummaries(parts: unknown[]): string[];
+export interface TokenizerNativeMemoryStats {
+    loaded: boolean;
+    loadAttempted: boolean;
+    tableBytes: number | null;
+    tablePath: string | null;
+}
+/** Serialized vocabulary bytes are the only tokenizer size exposed by ai-tokenizer. */
+export declare function getTokenizerNativeMemoryStats(): TokenizerNativeMemoryStats;
+export declare function preloadTokenizer(): Promise<boolean>;
+/**
+ * Short identity of the estimator `estimateTokens` currently uses. Results that
+ * depend on token counts and outlive the process (such as where embedding
+ * windows were split) record it, so a process running a different estimator
+ * (the character heuristic after a failed tokenizer load, or a tokenizer that
+ * counts differently) recomputes them instead of trusting them. Reads the
+ * tokenizer directly so callers counting `estimateTokens` calls are unaffected.
+ */
+export declare function getTokenEstimatorFingerprint(): string;
+/** Admission must refuse rather than treating a heuristic fallback as an exact count. */
+export declare function hasTokenizerForFit(): boolean;
+export declare function estimateTokens(text: string): number;
+/** Exact-content, bounded counts; fallback invalidates counts from the previous tokenizer. */
+export declare function createTokenCountMemo(maxEntries: number, maxBytes: number): (text: string) => number;
+/** Count identical fixed historian prompts once, without borrowing counts after tokenizer fallback. */
+export declare function estimateFixedPromptTokens(text: string): number;
+export declare function normalizeText(text: string): string;
+export declare function compactRole(role: string): string;
+export declare function formatBlock(block: ChunkBlock): string;
+export declare function extractCommitHashes(text: string): string[];
+export declare function compactTextForSummary(text: string, role: string): {
+    text: string;
+    commitHashes: string[];
+};
+export declare function mergeCommitHashes(existing: string[], next: string[]): string[];
+//# sourceMappingURL=read-session-formatting.d.ts.map

package/dist/hooks/magic-context/read-session-formatting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-session-formatting.d.ts","sourceRoot":"","sources":["../../../src/hooks/magic-context/read-session-formatting.ts"],"names":[],"mappings":"AASA,MAAM,WAAW,gBAAgB;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,UAAU;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,QAAQ,EAAE,KAAK,CAAC;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,oBAAoB,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACnE,IAAI,EAAE,gBAAgB,EAAE,CAAC;IACzB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB;;;;;OAKG;IACH,UAAU,EAAE,OAAO,CAAC;CACvB;AAID,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,OAAO,CAiB/D;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,MAAM,EAAE,CAUvD;AAED,kGAAkG;AAClG,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,MAAM,CAcpE;AAED;4EAC4E;AAC5E,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,MAAM,EAAE,CA2BnE;AAiJD,MAAM,WAAW,0BAA0B;IACvC,MAAM,EAAE,OAAO,CAAC;IAChB,aAAa,EAAE,OAAO,CAAC;IACvB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B;AAgCD,uFAAuF;AACvF,wBAAgB,6BAA6B,IAAI,0BAA0B,CAY1E;AAYD,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,OAAO,CAAC,CAuBzD;AAwBD;;;;;;;GAOG;AACH,wBAAgB,4BAA4B,IAAI,MAAM,CAgBrD;AAED,yFAAyF;AACzF,wBAAgB,kBAAkB,IAAI,OAAO,CAE5C;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAiBnD;AAED,8FAA8F;AAC9F,wBAAgB,oBAAoB,CAChC,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,GACjB,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CA0B1B;AASD,uGAAuG;AACvG,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CA2B9D;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAElD;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAIhD;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAQrD;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAW1D;AAED,wBAAgB,qBAAqB,CACjC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GACb;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,EAAE,CAAA;CAAE,CAmB1C;AAED,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAS9E"}

package/dist/hooks/magic-context/read-session-raw.d.ts

@@ -0,0 +1,164 @@
+import type { Database } from "../../shared/sqlite";
+export interface RawMessageParts {
+    id: string;
+    role: string;
+    parts: unknown[];
+    createdAt?: number | null;
+    version?: string | number | null;
+    /** Native store row type when the host exposes one; intentionally absent on v1. */
+    storeType?: string;
+}
+export interface RawMessage extends RawMessageParts {
+    ordinal: number;
+}
+/** Strictly classify rows that carry no user/assistant narrative and may fill a range gap. */
+export declare function isStrictGapHealingMessage(message: RawMessage): boolean;
+export interface RawMessageOrdinalAnchor {
+    timeCreated: number;
+    id: string;
+}
+export interface RawMessageOrdinalEntry extends RawMessageOrdinalAnchor {
+    contributesOrdinal: boolean;
+    hasValidInfo: boolean;
+}
+/**
+ * OpenCode message IDs are global primary keys and `part.message_id` references
+ * that key. Unary `+` keeps the cross-session correctness filter but prevents
+ * SQLite from choosing the session-only index instead of the bounded message-id
+ * lookup. Keep the likelihood hint for planner versions that honor it.
+ */
+export declare const RAW_MESSAGE_PARTS_BY_ID_SQL = "SELECT message_id, data, time_updated FROM part WHERE +session_id = ? AND likelihood(message_id = ?, 0.000001) ORDER BY time_created ASC, id ASC";
+export declare function isRawCompactionSummaryInfo(info: unknown): boolean;
+export declare function readRawSessionMessagesFromDb(db: Database, sessionId: string): RawMessage[];
+/**
+ * Read one bounded page from the canonical raw-message ordinal space. Message
+ * and part JSON parsing is limited to the requested page so background FTS work
+ * cannot monopolize the event loop by hydrating an entire long session.
+ */
+export declare function readRawSessionMessagePageFromDb(db: Database, sessionId: string, afterOrdinal: number, limit: number, finalWatermark?: number, after?: RawMessageOrdinalAnchor): RawMessage[];
+/** Longest text a summary page keeps from one text part or one tool key argument. */
+export declare const RAW_SUMMARY_TEXT_MAX_CHARS = 8192;
+/**
+ * Read one bounded page in the same ordinal space as
+ * {@link readRawSessionMessagePageFromDb}, keeping only text and tool parts in
+ * their summary projection. For callers that render `U:` / `TC:` lines and
+ * never need tool outputs, reasoning, or file payloads: peak memory is one page
+ * of small projected parts, whatever the session or tool-output size.
+ */
+export declare function readRawSessionMessageSummaryPageFromDb(db: Database, sessionId: string, afterOrdinal: number, limit: number, finalWatermark?: number, after?: RawMessageOrdinalAnchor): RawMessage[];
+export declare function countRawSessionMessageOrdinalsFromDb(db: Database, sessionId: string): number;
+/**
+ * Read the canonical raw-message ordinal space without loading or parsing part rows.
+ * Keep the ordering, summary predicate, and malformed-message behavior identical to
+ * `readRawSessionMessagesFromDb`; consumers compare these ordinals across passes.
+ */
+export declare function readRawSessionMessageIdOrdinalsFromDb(db: Database, sessionId: string): Map<string, number>;
+/** Hydrate only the requested range; malformed rows consume ordinals but have no id entry. */
+export declare function readRawSessionMessageIdOrdinalsForRangeFromDb(db: Database, sessionId: string, fromOrdinal: number, toOrdinal: number): Map<string, number>;
+/** Read a keyset page used to incrementally maintain shadow message ordinals. */
+export declare function readRawSessionMessageOrdinalPageFromDb(db: Database, sessionId: string, after: RawMessageOrdinalAnchor | null, limit: number): RawMessageOrdinalEntry[];
+/** Count stored rows without inspecting message JSON, allowing the session-id index to answer it. */
+export declare function countStoredRawSessionMessagesFromDb(db: Database, sessionId: string): number;
+/**
+ * Read ONLY the eligible tail — messages at/after the last compartment boundary
+ * — assigning them their correct ABSOLUTE ordinals (continuing from
+ * `baseOrdinal`), and return the absolute session message count alongside.
+ *
+ * This is the O(tail) read: it never touches the ~63k pre-boundary rows that the
+ * full reader scans just to recover the tail's ordinal base — a number the
+ * compaction marker already stores (`end_message` ordinal + `end_message_id`
+ * anchor). On a months-long session the full read is O(session) and grows
+ * unbounded; this stays flat at the tail size.
+ *
+ * Anchor semantics: reads rows with `(time_created, id) >= anchor` (INCLUSIVE of
+ * the boundary message), in the same sort order as the full reader, filters
+ * compaction-summary rows identically, and numbers the kept messages
+ * `baseOrdinal, baseOrdinal+1, …`. Including the anchor keeps
+ * `messageIdAtOrdinal(baseOrdinal)` real (the full reader has it too) so
+ * boundary-edge message ids match.
+ *
+ * Returns null when the anchor message id isn't found (deleted / legacy
+ * compartment without `end_message_id`); the caller then falls back to the full
+ * read. `absoluteMessageCount` = `baseOrdinal + (keptTail - 1)` = the exact
+ * count the full reader would produce, so every absolute-ordinal consumer lines
+ * up.
+ */
+export declare function readRawSessionTailFromDb(db: Database, sessionId: string, baseOrdinal: number, anchorMessageId: string): {
+    messages: RawMessage[];
+    absoluteMessageCount: number;
+} | null;
+/**
+ * Minimal structural view of an in-memory transform message, extracted from
+ * OpenCode's `MessageLike` by the caller. Kept dependency-free so this module
+ * doesn't import the transform/tagging layer.
+ */
+export interface InMemoryMessageView {
+    id: string;
+    role: string;
+    parts: unknown[];
+    /** From the message `info` if present; used to mirror the DB summary filter. */
+    summary?: boolean;
+    finish?: string;
+}
+export interface InMemoryTailResult {
+    messages: RawMessage[];
+    absoluteMessageCount: number;
+    /** True when the compaction anchor id was located within the array. */
+    anchorFound: boolean;
+}
+/**
+ * Extract the minimal structural view from OpenCode transform messages
+ * (`args.messages`, MessageLike-shaped: `{ info, parts }`). Tolerates missing
+ * fields — a message without a string id becomes an empty-id view, which
+ * `buildInMemoryTailRawMessages` treats as a malformed row (ordinal slot kept,
+ * no element), mirroring the DB reader.
+ */
+export declare function extractInMemoryMessageViews(messages: readonly {
+    info?: unknown;
+    parts?: unknown;
+}[]): InMemoryMessageView[];
+/**
+ * Build an absolute-ordinal `RawMessage[]` tail from the in-memory transform
+ * messages (`args.messages`), mirroring {@link readRawSessionTailFromDb} so the
+ * boundary resolver produces an identical result without any opencode.db read.
+ *
+ * OpenCode hands the transform the post-compaction-marker tail, i.e. the eligible
+ * window, already parsed. Ordinals are anchored at the last compartment boundary:
+ *
+ * - If `anchorMessageId` is found at index k, that message IS the boundary
+ *   (ordinal `lastCompartmentEnd`); messages k, k+1, … get ordinals
+ *   `lastCompartmentEnd, lastCompartmentEnd+1, …`. Messages before k (compaction
+ *   marker lag — already compartmentalized) are dropped, matching the DB tail
+ *   which starts AT the anchor.
+ * - If the anchor isn't present (it was a summary row OpenCode already filtered,
+ *   or marker is ahead), the array is assumed to start at `lastCompartmentEnd+1`
+ *   and ordinals run `lastCompartmentEnd+1, …`. `anchorFound=false` flags this so
+ *   callers can choose the DB fallback if they don't trust the assumption.
+ * - No compartments yet (#132): pass `lastCompartmentEnd=0`,
+ *   `anchorMessageId=null` → ordinals from 1 over the whole array.
+ *
+ * Mirrors the DB reader's contracts: compaction-summary rows
+ * (`summary===true && finish==='stop'`) are filtered BEFORE ordinal assignment;
+ * a malformed message (no string id) keeps its ordinal slot but yields no element;
+ * `absoluteMessageCount` equals what the DB reader would report for the same tail.
+ *
+ * Returns null when there are no usable messages.
+ */
+export declare function buildInMemoryTailRawMessages(args: {
+    messages: readonly InMemoryMessageView[];
+    lastCompartmentEnd: number;
+    anchorMessageId: string | null;
+}): InMemoryTailResult | null;
+export declare function readRawSessionMessagePartsByIdFromDb(db: Database, sessionId: string, messageId: string, onQuery?: () => void): RawMessageParts | null;
+/**
+ * Resolve one message ID in the canonical raw-message ordinal space. Synthetic
+ * compaction summaries are excluded so this count matches every module wire
+ * ordinal and does not depend on the stored compartment basis.
+ */
+export declare function readRawSessionMessageOrdinalByIdFromDb(db: Database, sessionId: string, messageId: string): number | null;
+export declare function readRawSessionMessageByIdFromDb(db: Database, sessionId: string, messageId: string): RawMessage | null;
+/** Existence does not require a canonical ordinal or any part payloads. */
+export declare function hasRawSessionMessageByIdFromDb(db: Database, sessionId: string, messageId: string): boolean;
+/** Read the canonical servable tail and its parts in one query, including its boundary row. */
+export declare function readRawSeedTailFromDb(db: Database, sessionId: string, boundaryId: string | null): Map<string, RawMessage>;
+//# sourceMappingURL=read-session-raw.d.ts.map

package/dist/hooks/magic-context/read-session-raw.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-session-raw.d.ts","sourceRoot":"","sources":["../../../src/hooks/magic-context/read-session-raw.ts"],"names":[],"mappings":"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"}

package/dist/hooks/magic-context/read-session-true-raw-tokens.d.ts

@@ -0,0 +1,82 @@
+import type { RawMessage } from "./read-session-raw";
+export interface TrueRawTokenBreakdown {
+    text: number;
+    reasoning: number;
+    toolInput: number;
+    toolOutput: number;
+    image: number;
+    other: number;
+    total: number;
+}
+export interface TrueRawEstimateOptions {
+    providerShapeVersion: "opencode-v1" | "pi-folded-v1";
+    imageTokenHeuristic?: (part: unknown) => number;
+}
+export interface TrueRawTokenIndex {
+    readonly sessionId: string;
+    readonly providerShapeVersion: string;
+    readonly rawMessageCount: number;
+    tokenForOrdinal(ordinal: number): number;
+    messageIdAtOrdinal(ordinal: number): string | null;
+    suffixTokensFromOrdinal(ordinal: number): number;
+    rangeTokens(startInclusive: number, endExclusive: number): number;
+    findSuffixStartForTokens(tokens: number): number;
+    findHeadEndForCap(startInclusive: number, endExclusive: number, capTokens: number): number;
+}
+export interface ToolArc {
+    callId: string;
+    invOrdinal: number;
+    resOrdinal: number | null;
+}
+/** True when a tail beginning at `boundary` would retain a completed result without its call. */
+export declare function completedToolArcCrossesBoundary(invOrdinal: number, resOrdinal: number, boundary: number): boolean;
+export interface TrueRawTokenIndexBuildOptions extends TrueRawEstimateOptions {
+    cacheNamespace: string;
+    /** Stored totals must already use these same ratios; tokenizer caches remain raw. */
+    calibration?: {
+        proseRatio: number;
+        toolsRatio: number;
+        systemRatio: number;
+    };
+    /**
+     * Durable per-message token source. When provided and it returns a non-null
+     * value for a message, that value is used as the message's total instead of
+     * live-tokenizing its parts — this is how the protected-tail boundary reads
+     * the precomputed `tags.token_count` store (restart-durable) rather than
+     * re-tokenizing the whole raw session every cold pass. Returning null falls
+     * back to live tokenization for that message (untagged / legacy-NULL rows),
+     * which converges to the stored path once the tagger backfills.
+     */
+    storedTotalForMessage?: (message: RawMessage) => number | null;
+    /**
+     * Absolute total message count for the session, when `messages` is a
+     * TAIL-ONLY slice carrying absolute ordinals (e.g. only messages after the
+     * last compartment boundary). The prefix/suffix machinery is sized to this
+     * count and ordinals outside the supplied slice contribute zero tokens —
+     * which is exactly correct for every offset-forward query the protected-tail
+     * boundary makes (its candidate, suffix, range, and head-cap reads never
+     * cross below the eligible offset). Lets the boundary resolve from only the
+     * eligible tail instead of reading the whole session every pass.
+     *
+     * Omitted for whole-session callers: defaults to `messages.length`, and with
+     * contiguous 1..N ordinals the result is byte-identical to the prior
+     * index-positional fill.
+     */
+    absoluteMessageCount?: number;
+}
+export declare function estimateTrueRawMessageTokens(message: RawMessage, options: TrueRawEstimateOptions): TrueRawTokenBreakdown;
+export declare function buildToolArcs(messages: readonly RawMessage[]): ToolArc[];
+export declare function fenceBoundaryForCompletedToolArcs(candidate: number, arcs: readonly ToolArc[], publicationFloorOrdinal: number, observeComponent?: (arcs: ReadonlyArray<{
+    invocation: number;
+    result: number;
+}>) => void): number;
+export declare function fenceBoundaryForToolArcs(candidate: number, arcs: readonly ToolArc[], lastCompartmentEndOrdinal: number, recentOpenArcCutoff: number): number;
+export declare function buildTrueRawTokenIndex(sessionId: string, messages: readonly RawMessage[], options: TrueRawTokenIndexBuildOptions): TrueRawTokenIndex;
+export declare function computeRawRangeFingerprint(messages: readonly RawMessage[], startInclusive: number, endExclusive: number): string;
+export declare function invalidateTrueRawTokenCache(args: {
+    sessionId?: string;
+    messageId?: string;
+    reason: "message.updated" | "message.removed" | "session.compacted" | "session.deleted" | "pi.branch.changed" | "pi.stable-id-scheme.changed" | "provider.unregistered" | "schema.migration";
+}): void;
+export declare function buildTrueRawTokenIndexFromTokenCountsForTest(sessionId: string, tokens: readonly number[]): TrueRawTokenIndex;
+//# sourceMappingURL=read-session-true-raw-tokens.d.ts.map

package/dist/hooks/magic-context/read-session-true-raw-tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-session-true-raw-tokens.d.ts","sourceRoot":"","sources":["../../../src/hooks/magic-context/read-session-true-raw-tokens.ts"],"names":[],"mappings":"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"}

package/dist/hooks/magic-context/reasoning-removal.d.ts

@@ -0,0 +1,60 @@
+import type { MessageLike } from "./tag-messages";
+/**
+ * Pick assistant message ids whose reasoning should be removed on this
+ * rebuilding pass. Pure; the caller persists the result before applying it.
+ *
+ * A message qualifies when its tag is at most `maxTag - clearReasoningAge`, it
+ * carries a reasoning part (or one a drop neutralized), it is not the newest
+ * assistant (nor the newest one with replayable content), it keeps wire
+ * content after removal, and removal actually takes its reasoning payload off
+ * the wire on this route.
+ *
+ * Prefix-bound models (`prefixBound`: Fable 5.1, Opus 5.5, Sonnet 5.5, on any
+ * route) select only a contiguous oldest prefix. Anthropic's preserved-thinking
+ * page ("What counts as an edit") lists "Remove `thinking` blocks from the
+ * start of the history, from the end, or all of them" as valid, but "Remove a
+ * `thinking` block from the middle of the history and keep later ones" as
+ * invalid for every later thinking block. The walk therefore goes oldest
+ * first, passes over messages whose reasoning is already gone (`alreadyRemoved`
+ * or `alsoGone`), and stops at the first reasoning-bearing message it may not
+ * remove, so the removed set never has a gap.
+ */
+export declare function selectReasoningRemovals(args: {
+    messages: MessageLike[];
+    messageTagNumbers: Map<MessageLike, number>;
+    clearReasoningAge: number;
+    alreadyRemoved: ReadonlySet<string>;
+    prefixBound: boolean;
+    /**
+     * Assistants whose reasoning another lane already took off the wire for
+     * good (the binding-mismatch strip set). Only the prefix walk reads it.
+     */
+    alsoGone?: ReadonlySet<string>;
+}): string[];
+/**
+ * Splice every reasoning part (including drop-neutralized ones) out of the
+ * assistant messages named in `ids`, on every pass. The newest assistant with
+ * replayable content is skipped, matching Rust's exempt-message rule; a
+ * removed message can only become that message if newer history disappears,
+ * which already rewrites the cache. On OpenRouter the message's
+ * `reasoning_details` copies leave with it. When an earlier drop has already
+ * emptied a message, a whole-message placeholder keeps it from being sent
+ * empty.
+ */
+export declare function removeReasoningParts(messages: MessageLike[], ids: ReadonlySet<string>, providerID: string | undefined): number;
+/**
+ * How reasoning neutralized by a drop is served on a route other than
+ * canonical Anthropic (which keeps the empty sentinel its adapter drops):
+ *
+ * - `restore`: put the original part back. A drop leaves reasoning to the age
+ *   lane, as Pi and Rust do. The tag lane links a tool to the reasoning of
+ *   the step before it, so removing that reasoning would take an unrelated
+ *   block off the wire.
+ * - `legacy`: put the original part back with `[cleared]` written into its
+ *   text, exactly the bytes served before this lane existed. Used only until a
+ *   session's first rebuilding pass after upgrade, and when the provider is
+ *   unresolved, so the change first lands on a pass that already rebuilds.
+ */
+export type DroppedReasoningMode = "restore" | "legacy";
+export declare function settleDroppedReasoningParts(messages: MessageLike[], mode: DroppedReasoningMode): number;
+//# sourceMappingURL=reasoning-removal.d.ts.map

package/dist/hooks/magic-context/reasoning-removal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reasoning-removal.d.ts","sourceRoot":"","sources":["../../../src/hooks/magic-context/reasoning-removal.ts"],"names":[],"mappings":"AA2BA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAyFlD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE;IAC1C,QAAQ,EAAE,WAAW,EAAE,CAAC;IACxB,iBAAiB,EAAE,GAAG,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC;IAC5C,iBAAiB,EAAE,MAAM,CAAC;IAC1B,cAAc,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACpC,WAAW,EAAE,OAAO,CAAC;IACrB;;;OAGG;IACH,QAAQ,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CAClC,GAAG,MAAM,EAAE,CAoCX;AAED;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAChC,QAAQ,EAAE,WAAW,EAAE,EACvB,GAAG,EAAE,WAAW,CAAC,MAAM,CAAC,EACxB,UAAU,EAAE,MAAM,GAAG,SAAS,GAC/B,MAAM,CAqBR;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,oBAAoB,GAAG,SAAS,GAAG,QAAQ,CAAC;AAExD,wBAAgB,2BAA2B,CACvC,QAAQ,EAAE,WAAW,EAAE,EACvB,IAAI,EAAE,oBAAoB,GAC3B,MAAM,CAUR"}

package/dist/hooks/magic-context/recomp-orchestrator.d.ts

@@ -0,0 +1,93 @@
+import type { PluginContext } from "../../plugin/types";
+import type { ModelInput } from "../../shared/model-resolution";
+import type { Database } from "../../shared/sqlite";
+import { type PartialRecompRange } from "./compartment-runner";
+import type { CompartmentRunnerDeps, HiddenCompletionExecutor } from "./compartment-runner-types";
+import type { LiveSessionState } from "./live-session-state";
+import type { NotificationParams } from "./send-session-notification";
+/**
+ * Single source of truth for recomp orchestration.
+ *
+ * Before this module there were diverged implementations — the RPC `recomp`
+ * handler and the hook-side `executeRecomp` closure (used by `/mmc-recomp`).
+ * They drifted: the RPC handler had live progress but no model fallback, while
+ * the hook path had fallback but no progress, so the same request behaved
+ * differently depending on which surface started it.
+ *
+ * `runManagedRecomp` gives EVERY caller the full set: fallback resilience
+ * (config chain + live-session-model last resort), live progress (sidebar /
+ * status), and consistent terminal-state + messaging.
+ */
+/** Config-shape-agnostic context. Callers resolve config values and pass them
+ *  in, so this module never couples to the loose RPC config record vs the typed
+ *  hook config. */
+export interface ManagedRecompContext {
+    client: PluginContext["client"];
+    /** Optional executor for hosts that cannot issue hidden completions through the v1 SDK. */
+    hiddenCompletionExecutor?: HiddenCompletionExecutor;
+    db: Database;
+    liveSessionState: LiveSessionState;
+    /** Plugin-startup directory — last-resort fallback for session-dir resolution. */
+    directory: string;
+    historianChunkTokens: number;
+    historianTimeoutMs: number;
+    memoryEnabled: boolean;
+    autoPromote: boolean;
+    /** Active OpenCode historian entry, including its outbound request variant. */
+    historianModel?: ModelInput;
+    historianContextLimit?: number;
+    historianMaxOutputTokens?: number;
+    /** Resolved historian fallback chain (config `fallback_models` → builtin). */
+    fallbackModels: readonly ModelInput[];
+    language?: string;
+    /** Pre-resolved last-resort model key (the live session model). When omitted,
+     *  the orchestrator resolves it from `liveModelBySession`. The hook path passes
+     *  this explicitly so it can include its OpenCode-DB fallback (the live map can
+     *  be empty when `/mmc-recomp` runs before the first transform pass). */
+    fallbackModelId?: string;
+    /** Two-pass historian (editor cleanup) — config `historian.two_pass`. */
+    historianTwoPass?: boolean;
+    historianExpandTools?: Record<string, string | false>;
+    getNotificationParams: (sessionId: string) => NotificationParams;
+    ensureProjectRegistered?: (directory: string, db: Database) => Promise<void>;
+}
+/** The runner's outcome messages are headed "## Magic Recomp — <Status>".
+ *  Failed/Skipped wrote nothing. */
+export declare function isRecompFailure(message: string): boolean;
+/** A SKIP (vs a true failure): the run no-op'd because the compartment-state
+ *  lease was busy (incremental historian comparting the tail, or another process
+ *  mutating state). Transient — retrying in a moment succeeds. Matches the
+ *  "— Skipped" heading AND the suffix-less lease/already-running no-op text. */
+export declare function isRecompSkip(message: string): boolean;
+/** Strip markdown headings + blank lines from a runner outcome message, leaving
+ *  the human reason for compact sidebar/status display. Fixes the dogfood
+ *  2026-05-30 cosmetic bug where a raw "## Magic Recomp — Failed" heading leaked
+ *  into the sidebar line. */
+export declare function extractRecompReason(raw: string): string;
+/** Emit an IMMEDIATE "recomp" progress entry the instant an upgrade/recomp is
+ *  requested — before any async work (session-dir resolution, child-session
+ *  creation, the first slow historian attempt + fallback). Without this the
+ *  sidebar stays blank until the first per-pass emit, which can be 60-90s into a
+ *  fallback-heavy run (dogfood 2026-05-30). `totalMessages: 0` renders an
+ *  indeterminate "Starting…" state until the loop knows the real range. */
+export declare function setRecompStarting(liveSessionState: LiveSessionState, sessionId: string, note: string, kind?: "recomp" | "upgrade" | "wrapup"): void;
+/** Update only the transient `note` on the active recomp progress entry (e.g.
+ *  "trying fallback sonnet-4.6…") without disturbing the bar's counters. No-op
+ *  if there's no active non-terminal entry. */
+export declare function setRecompNote(liveSessionState: LiveSessionState, sessionId: string, note: string): void;
+/** Record a terminal recomp/upgrade phase ("done"/"failed") so the TUI shows the
+ *  OUTCOME (not a missed toast). "done" auto-clears after a grace period; "failed"
+ *  persists until the next run so the reason stays visible. */
+export declare function setRecompTerminal(liveSessionState: LiveSessionState, sessionId: string, phase: "done" | "failed" | "skipped", message: string): void;
+/** Build the common executeContextRecomp deps shared by recomp + upgrade:
+ *  fallback resilience + live progress + cache-bust signalling. */
+export declare function buildRecompDeps(ctx: ManagedRecompContext, sessionId: string): CompartmentRunnerDeps;
+/**
+ * Run a recomp (full or partial), with fallback + live progress + terminal state.
+ * Returns the runner's outcome message; the CALLER delivers it (so it can choose
+ * force-persist vs toast). Used by `/mmc-recomp` and the RPC `recomp` handler.
+ */
+export declare function runManagedRecomp(ctx: ManagedRecompContext, sessionId: string, options?: {
+    range?: PartialRecompRange;
+}): Promise<string>;
+//# sourceMappingURL=recomp-orchestrator.d.ts.map

package/dist/hooks/magic-context/recomp-orchestrator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recomp-orchestrator.d.ts","sourceRoot":"","sources":["../../../src/hooks/magic-context/recomp-orchestrator.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAExD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAChE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAEpD,OAAO,EAAwB,KAAK,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AACrF,OAAO,KAAK,EACR,qBAAqB,EACrB,wBAAwB,EAE3B,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAE7D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AAYtE;;;;;;;;;;;;GAYG;AAEH;;mBAEmB;AACnB,MAAM,WAAW,oBAAoB;IACjC,MAAM,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAC;IAChC,2FAA2F;IAC3F,wBAAwB,CAAC,EAAE,wBAAwB,CAAC;IACpD,EAAE,EAAE,QAAQ,CAAC;IACb,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,kFAAkF;IAClF,SAAS,EAAE,MAAM,CAAC;IAClB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,kBAAkB,EAAE,MAAM,CAAC;IAC3B,aAAa,EAAE,OAAO,CAAC;IACvB,WAAW,EAAE,OAAO,CAAC;IACrB,+EAA+E;IAC/E,cAAc,CAAC,EAAE,UAAU,CAAC;IAC5B,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,wBAAwB,CAAC,EAAE,MAAM,CAAC;IAClC,8EAA8E;IAC9E,cAAc,EAAE,SAAS,UAAU,EAAE,CAAC;IACtC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;6EAGyE;IACzE,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,yEAAyE;IACzE,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,oBAAoB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,KAAK,CAAC,CAAC;IACtD,qBAAqB,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,kBAAkB,CAAC;IACjE,uBAAuB,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,EAAE,EAAE,QAAQ,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CAChF;AAED;oCACoC;AACpC,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAExD;AAED;;;gFAGgF;AAChF,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAErD;AAED;;;6BAG6B;AAC7B,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAMvD;AAID;;;;;2EAK2E;AAC3E,wBAAgB,iBAAiB,CAC7B,gBAAgB,EAAE,gBAAgB,EAClC,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,EACZ,IAAI,GAAE,QAAQ,GAAG,SAAS,GAAG,QAAmB,GACjD,IAAI,CAcN;AAED;;+CAE+C;AAC/C,wBAAgB,aAAa,CACzB,gBAAgB,EAAE,gBAAgB,EAClC,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,GACb,IAAI,CAQN;AAED;;+DAE+D;AAC/D,wBAAgB,iBAAiB,CAC7B,gBAAgB,EAAE,gBAAgB,EAClC,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS,EACpC,OAAO,EAAE,MAAM,GAChB,IAAI,CAyBN;AAED;mEACmE;AACnE,wBAAgB,eAAe,CAC3B,GAAG,EAAE,oBAAoB,EACzB,SAAS,EAAE,MAAM,GAClB,qBAAqB,CA+CvB;AAED;;;;GAIG;AACH,wBAAsB,gBAAgB,CAClC,GAAG,EAAE,oBAAoB,EACzB,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE;IAAE,KAAK,CAAC,EAAE,kBAAkB,CAAA;CAAE,GACzC,OAAO,CAAC,MAAM,CAAC,CA0CjB"}

package/dist/hooks/magic-context/reference-retrieval.d.ts

@@ -0,0 +1,72 @@
+import { type ReferenceSeed } from "./reference-seeds.generated";
+/**
+ * Structural minimum a compartment must satisfy to render as a session
+ * reference. Both `Compartment` (stored rows, incremental runner) and
+ * `CandidateCompartment` (in-flight recomp staging) are assignable — they
+ * differ only in null/undefined widening on the tier/importance fields.
+ */
+export interface ReferenceCompartment {
+    startMessage: number;
+    endMessage: number;
+    title: string;
+    content: string;
+    p1?: string | null;
+    p2?: string | null;
+    p3?: string | null;
+    p4?: string | null;
+    importance?: number | null;
+    episodeType?: string | null;
+}
+/** Permanent seed floor — never drops, even when the session is mature. */
+export declare const SEED_FLOOR = 3;
+/** Recency window of this-session compartments shown for continuity/calibration. */
+export declare const SESSION_REF_WINDOW = 4;
+export declare const SESSION_REF_DIVERSE = 3;
+export declare const SESSION_REF_LIMIT: number;
+/**
+ * Select 3 seeds from distinct importance bands, deterministically rotating
+ * both band order and the picks within each band by (sessionId, chunkStart).
+ */
+export declare function selectSeeds(sessionId: string, chunkStart: number, count?: number): ReferenceSeed[];
+/** Render the cross-project calibration block. Empty string if no seeds. */
+export declare function renderSeedExamplesBlock(seeds: ReferenceSeed[]): string;
+/**
+ * Render one this-session compartment in its full stored form for the
+ * `<session_references>` block. v2 rows emit the stored tiers (p1/p4, with
+ * fossil p2/p3 when present); legacy rows (no tiers) fall back to flat
+ * `content`. Keep episode_type in both groups, but
+ * show importance only on diverse examples: newest scores cause anchoring.
+ */
+export declare function renderSessionRefCompartment(c: ReferenceCompartment, showImportance: boolean): string;
+/**
+ * Select older calibration examples against the bands of the seeds alone.
+ * Recent references carry no scores, so their bands do not count as anchors.
+ * Repeatedly pick the least-represented available band (uncovered bands first),
+ * breaking ties in the seed's rotating band order. Within a band, rotate by the
+ * same UTF-16 hash. Remove each pick so sparse histories never duplicate a row.
+ * Input is chronological; output is diverse chronological, then recent chronological.
+ */
+export declare function selectSessionReferences(allCompartments: ReferenceCompartment[], seeds: readonly ReferenceSeed[], sessionId: string, chunkStart: number): ReferenceCompartment[];
+/**
+ * Render already-selected references. Keeping a suffix drops diverse examples
+ * before recent examples, then drops the oldest recent first. Selection happens
+ * once, before fitting, so trimming cannot reshuffle calibration examples.
+ */
+export declare function renderSessionReferencesBlock(selected: ReferenceCompartment[], window?: number): string;
+export interface ReferenceBlocks {
+    /** `<compartment_examples_from_other_projects>` — always present (3-seed floor). */
+    seedExamples: string;
+    /** `<session_references>` — empty for a young session with no prior compartments. */
+    sessionReferences: string;
+}
+/**
+ * Build both reference blocks for a historian run. Pure + deterministic for a
+ * given (sessionId, chunkStart, compartments) — no embedding, no DB, no clock.
+ */
+export declare function buildReferenceBlocks(args: {
+    sessionId: string;
+    chunkStart: number;
+    /** Full ordered list of this session's persisted compartments (asc). */
+    sessionCompartments: ReferenceCompartment[];
+}): ReferenceBlocks;
+//# sourceMappingURL=reference-retrieval.d.ts.map

package/dist/hooks/magic-context/reference-retrieval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reference-retrieval.d.ts","sourceRoot":"","sources":["../../../src/hooks/magic-context/reference-retrieval.ts"],"names":[],"mappings":"AAqBA,OAAO,EAAmB,KAAK,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAElF;;;;;GAKG;AACH,MAAM,WAAW,oBAAoB;IACjC,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACnB,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACnB,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACnB,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;AAED,2EAA2E;AAC3E,eAAO,MAAM,UAAU,IAAI,CAAC;AAC5B,oFAAoF;AACpF,eAAO,MAAM,kBAAkB,IAAI,CAAC;AACpC,eAAO,MAAM,mBAAmB,IAAI,CAAC;AACrC,eAAO,MAAM,iBAAiB,QAA2C,CAAC;AAkD1E;;;GAGG;AACH,wBAAgB,WAAW,CACvB,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,KAAK,SAAa,GACnB,aAAa,EAAE,CAmCjB;AAED,4EAA4E;AAC5E,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,aAAa,EAAE,GAAG,MAAM,CAItE;AAED;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CACvC,CAAC,EAAE,oBAAoB,EACvB,cAAc,EAAE,OAAO,GACxB,MAAM,CAgCR;AAED;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CACnC,eAAe,EAAE,oBAAoB,EAAE,EACvC,KAAK,EAAE,SAAS,aAAa,EAAE,EAC/B,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,GACnB,oBAAoB,EAAE,CA4BxB;AAED;;;;GAIG;AACH,wBAAgB,4BAA4B,CACxC,QAAQ,EAAE,oBAAoB,EAAE,EAChC,MAAM,GAAE,MAA0B,GACnC,MAAM,CAaR;AAED,MAAM,WAAW,eAAe;IAC5B,oFAAoF;IACpF,YAAY,EAAE,MAAM,CAAC;IACrB,qFAAqF;IACrF,iBAAiB,EAAE,MAAM,CAAC;CAC7B;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE;IACvC,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,wEAAwE;IACxE,mBAAmB,EAAE,oBAAoB,EAAE,CAAC;CAC/C,GAAG,eAAe,CAalB"}

package/dist/hooks/magic-context/reference-seeds.generated.d.ts

@@ -0,0 +1,8 @@
+export interface ReferenceSeed {
+    /** importance score parsed from the seed's <compartment importance="N"> attribute */
+    readonly importance: number;
+    /** full example XML unit (compartment + optional facts/events/user_observations) */
+    readonly block: string;
+}
+export declare const REFERENCE_SEEDS: ReadonlyArray<ReferenceSeed>;
+//# sourceMappingURL=reference-seeds.generated.d.ts.map

package/dist/hooks/magic-context/reference-seeds.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reference-seeds.generated.d.ts","sourceRoot":"","sources":["../../../src/hooks/magic-context/reference-seeds.generated.ts"],"names":[],"mappings":"AAQA,MAAM,WAAW,aAAa;IAC1B,qFAAqF;IACrF,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,oFAAoF;IACpF,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CAC1B;AAED,eAAO,MAAM,eAAe,EAAE,aAAa,CAAC,aAAa,CAiPxD,CAAC"}

package/dist/hooks/magic-context/send-session-notification.d.ts

@@ -0,0 +1,43 @@
+export interface NotificationParams {
+    agent?: string;
+    variant?: string;
+    providerId?: string;
+    modelId?: string;
+    /** TUI toast lifetime in milliseconds (default: 5000). */
+    toastDurationMs?: number;
+    /** Runs after this notification is delivered, including after a queued flush. */
+    onDelivered?: () => void;
+}
+export type NotificationDeliveryDisposition = "sent" | "queued" | "skipped" | "failed";
+/**
+ * Notifications are status lines, not user input. Keep only the newest entries
+ * while a real turn is active so a long background run cannot grow memory or
+ * manufacture a backlog of user rows at the next idle boundary.
+ */
+export declare const MAX_QUEUED_IGNORED_NOTIFICATIONS = 16;
+/** Test seams for the process-local queue; production uses tracked message events with a cold-start DB fallback. */
+export declare const __ignoredNotificationTest: {
+    pendingTexts(sessionId: string): string[];
+    reset(): void;
+    setHoldDetector(detector: (sessionId: string) => boolean): void;
+    setNoticeDeleter(deleter: (sessionId: string, messageId: string) => Promise<boolean>): void;
+    setDiagnosticObserver(observer: (message: string) => void): void;
+};
+/** OpenCode HTTP origin used to DELETE a notice row that lost the append race. */
+export declare function setNotificationServerUrl(url: string | undefined): void;
+export declare function sendCommandResult(client: unknown, sessionId: string, text: string, params: NotificationParams): Promise<NotificationDeliveryDisposition>;
+export declare function sendIgnoredMessage(client: unknown, sessionId: string, text: string, params: NotificationParams, forcePersist?: boolean): Promise<NotificationDeliveryDisposition>;
+/**
+ * Flush queued status lines only with an observed harness idle authorization.
+ * A terminal assistant message is not proof that OpenCode's run loop has exited.
+ */
+export declare function flushIgnoredMessages(sessionId: string): Promise<void>;
+export declare function clearIgnoredMessages(sessionId: string): void;
+/** Only session.idle authorizes user-row notices; activity revokes that authorization synchronously. */
+export declare function observeIgnoredNotificationEvent(event: {
+    type: string;
+    properties?: unknown;
+}): void;
+/** Publish passive status through RPC only: a noReply user row is still input to host run scheduling. */
+export declare function sendStatusNotification(_client: unknown, sessionId: string, text: string, params: NotificationParams): Promise<NotificationDeliveryDisposition>;
+//# sourceMappingURL=send-session-notification.d.ts.map