@retaw106/mmc-oc 0.0.0-stage → 1.2.2

package/dist/hooks/magic-context/apply-operations.d.ts.map

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

package/dist/hooks/magic-context/auto-search-deadline.d.ts

@@ -0,0 +1,10 @@
+export declare const AUTO_SEARCH_TIMEOUT_MS = 3000;
+/**
+ * Preparation and search share one deadline. Check elapsed time as well as
+ * the timer: a synchronous SQLite call can prevent an overdue timer from
+ * firing before the search promise resolves. Checkpoints after preparation or
+ * embedding abort expired work before its next synchronous database scan;
+ * overdue search results are discarded before hint persistence.
+ */
+export declare function withAutoSearchDeadline<T>(operation: (signal: AbortSignal, checkDeadline: () => boolean) => Promise<T>, startedAt?: number): Promise<T | null>;
+//# sourceMappingURL=auto-search-deadline.d.ts.map

package/dist/hooks/magic-context/auto-search-deadline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto-search-deadline.d.ts","sourceRoot":"","sources":["../../../src/hooks/magic-context/auto-search-deadline.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,sBAAsB,OAAQ,CAAC;AAE5C;;;;;;GAMG;AACH,wBAAsB,sBAAsB,CAAC,CAAC,EAC1C,SAAS,EAAE,CAAC,MAAM,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,OAAO,KAAK,OAAO,CAAC,CAAC,CAAC,EAC5E,SAAS,SAAoB,GAC9B,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CA+BnB"}

package/dist/hooks/magic-context/auto-search-hint.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Build a compact "you may recall something related" hint from unified search
+ * results, ready to append to a user message.
+ *
+ * The hint intentionally compresses fragments so they feel like vague recall
+ * rather than a drop-in answer — the goal is to nudge the agent to run
+ * mmc_search for full context, not to provide the answer itself.
+ *
+ * Compression strategy per source:
+ *   - memory → caveman-ultra via `cavemanCompress()` (token-dense)
+ *   - message → caveman-ultra, role tag
+ *
+ * Guardrails:
+ *   - Per-fragment token cap (~20 tokens, ~80 chars) with ellipsis truncation
+ *   - Skip fragments whose source is already present in visible session-history
+ *     (caller handles) — this module only knows about search results
+ *   - Hard-caps total output at ~200 tokens so misconfigured thresholds can't
+ *     balloon the user message
+ */
+import type { UnifiedSearchResult } from "../../features/magic-context/search";
+import { type CavemanWordRules } from "./caveman";
+export interface AutoSearchHintOptions {
+    maxFragments?: number;
+    fragmentCharCap?: number;
+    /** English word rules unless the user-level `language` is another language. */
+    wordRules?: CavemanWordRules;
+}
+/**
+ * Build the hint text. Returns null when `results` is empty, when no fragment
+ * has meaningful content after compression, or when limits zero out the budget.
+ *
+ * This function does NOT enforce score thresholds or message-length rules —
+ * callers (the transform-time auto-search wiring) apply those gates first.
+ */
+export declare function buildAutoSearchHint(results: UnifiedSearchResult[], options?: AutoSearchHintOptions): string | null;
+//# sourceMappingURL=auto-search-hint.d.ts.map

package/dist/hooks/magic-context/auto-search-hint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto-search-hint.d.ts","sourceRoot":"","sources":["../../../src/hooks/magic-context/auto-search-hint.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAC/E,OAAO,EAAE,KAAK,gBAAgB,EAA0C,MAAM,WAAW,CAAC;AAM1F,MAAM,WAAW,qBAAqB;IAClC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,+EAA+E;IAC/E,SAAS,CAAC,EAAE,gBAAgB,CAAC;CAChC;AAqDD;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAC/B,OAAO,EAAE,mBAAmB,EAAE,EAC9B,OAAO,GAAE,qBAA0B,GACpC,MAAM,GAAG,IAAI,CAgCf"}

package/dist/hooks/magic-context/auto-search-runner.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Transform-time auto-search hint runner.
+ *
+ * When a new user message arrives, optionally run mmc_search against the user's
+ * prompt and append a caveman-compressed "vague recall" fragment hint to that
+ * message. The hint nudges the agent to run mmc_search for full context rather
+ * than injecting the content directly.
+ *
+ * Cache safety:
+ *   - Attaches to the latest user message (the message that triggered the turn),
+ *     never to message[0] or to any assistant message. Appending to the current
+ *     user message happens BEFORE it reaches Anthropic's cache because this
+ *     transform runs on the prompt path — same property as note nudges.
+ *   - Idempotent via in-memory turn cache + `.includes()` guard in
+ *     appendReminderToUserMessageById. On defer passes we re-append the same
+ *     text; `.includes()` makes that a no-op.
+ *   - New user turn (different message id) → compute fresh hint, new append.
+ *   - Process restart → cache cleared; next pass will recompute but the user
+ *     message is a fresh turn anyway, no provider cache to preserve yet.
+ */
+import type { Database } from "../../shared/sqlite";
+import type { CavemanWordRules } from "./caveman";
+import type { MessageLike } from "./transform-operations";
+export type AutoSearchOutcome = {
+    ok: true;
+} | {
+    ok: false;
+    kind: "timeout" | "search-failure" | "cas-exhaustion";
+};
+export interface AutoSearchRunnerOptions {
+    enabled: boolean;
+    scoreThreshold: number;
+    minPromptChars: number;
+    directory?: string;
+    projectPath: string;
+    ensureProjectRegistered?: (directory: string, db: Database) => Promise<void>;
+    memoryEnabled?: boolean;
+    /** Memory ids already rendered in the injected <session-history> block —
+     *  skip fragments that just duplicate visible memories. */
+    visibleMemoryIds?: Set<number>;
+    /** English word rules unless the user-level `language` is another language. */
+    wordRules?: CavemanWordRules;
+}
+/**
+ * Entry point. Called from transform post-processing. No-op when disabled,
+ * when there is no meaningful user message, when prompt is too short, when
+ * search returns nothing strong enough, or when the hint has already been
+ * appended for this turn.
+ */
+export declare function runAutoSearchHint(args: {
+    sessionId: string;
+    db: Database;
+    messages: MessageLike[];
+    options: AutoSearchRunnerOptions;
+}): Promise<AutoSearchOutcome>;
+/** Test hook — wipe the per-turn cache. */
+export declare function _resetAutoSearchCache(): void;
+/** Session cleanup hook — call on session.deleted. */
+export declare function clearAutoSearchForSession(_sessionId: string): void;
+//# sourceMappingURL=auto-search-runner.d.ts.map

package/dist/hooks/magic-context/auto-search-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto-search-runner.d.ts","sourceRoot":"","sources":["../../../src/hooks/magic-context/auto-search-runner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAaH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAGpD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAGlD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAE1D,MAAM,MAAM,iBAAiB,GACvB;IAAE,EAAE,EAAE,IAAI,CAAA;CAAE,GACZ;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,IAAI,EAAE,SAAS,GAAG,gBAAgB,GAAG,gBAAgB,CAAA;CAAE,CAAC;AAI3E,MAAM,WAAW,uBAAuB;IACpC,OAAO,EAAE,OAAO,CAAC;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,uBAAuB,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,EAAE,EAAE,QAAQ,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7E,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;+DAC2D;IAC3D,gBAAgB,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC/B,+EAA+E;IAC/E,SAAS,CAAC,EAAE,gBAAgB,CAAC;CAChC;AAqID;;;;;GAKG;AACH,wBAAsB,iBAAiB,CAAC,IAAI,EAAE;IAC1C,SAAS,EAAE,MAAM,CAAC;IAClB,EAAE,EAAE,QAAQ,CAAC;IACb,QAAQ,EAAE,WAAW,EAAE,CAAC;IACxB,OAAO,EAAE,uBAAuB,CAAC;CACpC,GAAG,OAAO,CAAC,iBAAiB,CAAC,CA8I7B;AAED,2CAA2C;AAC3C,wBAAgB,qBAAqB,IAAI,IAAI,CAE5C;AAED,sDAAsD;AACtD,wBAAgB,yBAAyB,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAElE"}

package/dist/hooks/magic-context/cache-busting-signals.d.ts

@@ -0,0 +1,42 @@
+export interface DeferredConsumptionArgs {
+    schedulerDecision: "execute" | "defer";
+    contextPercentage: number;
+    /** True when this pass awaited a run that actually published new compartment state. */
+    justAwaitedPublication: boolean;
+    /** Legacy caller observation; published-work consumption does not depend on it. */
+    activeRunBlocksMaterialization: boolean;
+    forceMaterializationPercentage?: number;
+}
+export declare function canConsumeDeferredOnThisPass(args: DeferredConsumptionArgs): boolean;
+export interface MaterializationPassSignals {
+    /** True when this transform pass successfully wrote fresh cached m[0] bytes. */
+    m0RematerializedThisPass: boolean;
+    /** True when retry exhaustion forced fallback to a previous cached m[0]. */
+    materializationContentionRetryExhausted: boolean;
+    /** True when postprocess observed newer m0_mutation_log ids than cached m[0]. */
+    m0MutationDriftDetected: boolean;
+}
+/**
+ * The four signals that can independently authorize an automatic reduction to
+ * run: a hard fold, a forced reduction, an explicit flush, and freshly published
+ * history. Each is a cache bust the session is already paying for, so a
+ * reduction riding one adds no further prefix rewrite of its own.
+ */
+export interface ReclaimRideSignals {
+    hardFold: boolean;
+    force: boolean;
+    explicitFlush: boolean;
+    publishedHistory: boolean;
+}
+/** Automatic reductions ride independently priced work, never pressure alone. */
+export declare function hasReclaimRide(signals: ReclaimRideSignals): boolean;
+/**
+ * Names the ride signals that actually granted permission to mutate, for the
+ * logs that announce that permission. The permission is `hasReclaimRide`, so a
+ * log naming anything else sends whoever reads it to the wrong cause: a drain
+ * granted by freshly published history used to be reported as
+ * "reason=scheduler_execute", which is a different signal entirely and was not
+ * even true on the passes that printed it.
+ */
+export declare function reclaimRideLabel(signals: ReclaimRideSignals): string;
+//# sourceMappingURL=cache-busting-signals.d.ts.map

package/dist/hooks/magic-context/cache-busting-signals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-busting-signals.d.ts","sourceRoot":"","sources":["../../../src/hooks/magic-context/cache-busting-signals.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,uBAAuB;IACpC,iBAAiB,EAAE,SAAS,GAAG,OAAO,CAAC;IACvC,iBAAiB,EAAE,MAAM,CAAC;IAC1B,uFAAuF;IACvF,sBAAsB,EAAE,OAAO,CAAC;IAChC,mFAAmF;IACnF,8BAA8B,EAAE,OAAO,CAAC;IACxC,8BAA8B,CAAC,EAAE,MAAM,CAAC;CAC3C;AAED,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,uBAAuB,GAAG,OAAO,CAWnF;AAED,MAAM,WAAW,0BAA0B;IACvC,gFAAgF;IAChF,wBAAwB,EAAE,OAAO,CAAC;IAClC,4EAA4E;IAC5E,uCAAuC,EAAE,OAAO,CAAC;IACjD,iFAAiF;IACjF,uBAAuB,EAAE,OAAO,CAAC;CACpC;AAED;;;;;GAKG;AACH,MAAM,WAAW,kBAAkB;IAC/B,QAAQ,EAAE,OAAO,CAAC;IAClB,KAAK,EAAE,OAAO,CAAC;IACf,aAAa,EAAE,OAAO,CAAC;IACvB,gBAAgB,EAAE,OAAO,CAAC;CAC7B;AAED,iFAAiF;AACjF,wBAAgB,cAAc,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAEnE;AAID;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,kBAAkB,GAAG,MAAM,CAGpE"}

package/dist/hooks/magic-context/caveman-cleanup.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Age-tier caveman text compression for long user/assistant text parts.
+ *
+ * Two entry points:
+ *
+ * 1. `applyCavemanCleanup` — runs ONLY on cache-busting heuristic passes
+ *    (execute / flush / force-materialize) and is the only path that may
+ *    INCREASE `tags.caveman_depth`. Computes age tiers (20/20/20/40),
+ *    persists the new depth, and applies the compressed text in place.
+ *
+ * 2. `replayCavemanCompression` — runs on EVERY transform pass (defer too)
+ *    and re-applies the persisted depth to message text without ever
+ *    increasing it. This exists because `tagMessages` restores
+ *    `textPart.text = source_contents.content` (the pristine original) on
+ *    every pass; without a replay step the compressed text would oscillate
+ *    between compressed (post-execute) and original (defer), which would
+ *    bust the provider prompt cache on every turn.
+ *
+ * Partitioning: eligible tags (message-type, active, byte_size >= threshold,
+ * tag_number <= protected cutoff) are sorted by tag_number ascending, then
+ * bucketed 20/20/20/40:
+ *  - oldest 20%  → ultra
+ *  - next 20%    → full
+ *  - next 20%    → lite
+ *  - newest 40%  → untouched
+ *
+ * Source-of-truth invariant: compression is ALWAYS computed from the
+ * pristine original (`source_contents.content`), never from an already-
+ * cavemaned intermediate. So repeated tier shifts converge identically to
+ * direct compression at the target depth, and the replay path can produce
+ * the exact same output as the original execute pass.
+ *
+ * Persisted state:
+ *  - tags.caveman_depth records the applied depth
+ *  - source_contents.content is unchanged (remains the pristine original)
+ *  - message-part text holds the cavemaned result visible to the agent,
+ *    behind the same `§N§ ` prefix as every other tagged text, so the agent
+ *    can still reference and reduce it
+ *  - the replay document records which rule set the session is served with
+ *    (storage-caveman-rules.ts)
+ */
+import type { ContextDatabase } from "../../features/magic-context/storage";
+import type { TagEntry } from "../../features/magic-context/types";
+import { type CavemanWordRules } from "./caveman";
+import type { TagTarget } from "./tag-messages";
+export interface CavemanCleanupConfig {
+    enabled: boolean;
+    minChars: number;
+    /** From the user-level `language` setting (`cavemanWordRulesForLanguage`); English when absent. */
+    wordRules?: CavemanWordRules;
+}
+export interface CavemanCleanupResult {
+    compressedToLite: number;
+    compressedToFull: number;
+    compressedToUltra: number;
+    mutatedTextTags: number;
+    textReductions: Array<{
+        tagNumber: number;
+        removedCharacters: number;
+    }>;
+}
+/**
+ * Compute target caveman depth for a tag by its position in the sorted
+ * eligible list. Visible for testing.
+ */
+export declare function computeTargetDepth(positionIndex: number, totalEligible: number): number;
+/**
+ * Apply age-tier caveman compression to eligible message tags.
+ *
+ * Preconditions: caller has already acquired the DB transaction context for
+ * this heuristic pass (or this function opens its own). Caller is expected
+ * to gate on primary sessions and `config.enabled === true`.
+ */
+export declare function applyCavemanCleanup(sessionId: string, db: ContextDatabase, targets: Map<number, TagTarget>, tags: TagEntry[], config: CavemanCleanupConfig & {
+    protectedCutoff: number | null;
+}): CavemanCleanupResult;
+/**
+ * Re-apply persisted caveman compression on every transform pass (defer
+ * included). This is the cache-stability counterpart to applyCavemanCleanup.
+ *
+ * Why this exists: tagMessages restores `textPart.text = source_contents.content`
+ * (the pristine original) for every existing tag on every pass. Without this
+ * replay step, a tag compressed during an execute pass would revert to its
+ * original text on the next defer pass. Anthropic's prompt cache hashes the
+ * full message prefix, so an oscillating tag would bust cache on every turn
+ * after compression first runs.
+ *
+ * Mirrors the pattern used by replayClearedReasoning / replayStrippedInline
+ * for typed reasoning. Pure read \u2014 never increases caveman_depth, never
+ * mutates the database. Only execute/flush passes (via applyCavemanCleanup)
+ * can deepen the depth.
+ *
+ * Idempotent: cavemanCompress is deterministic over (originalText, level),
+ * so calling this on every pass produces the exact same text the original
+ * execute pass produced.
+ */
+export declare function replayCavemanCompression(sessionId: string, db: ContextDatabase, targets: Map<number, TagTarget>, tags: TagEntry[]): number;
+//# sourceMappingURL=caveman-cleanup.d.ts.map

package/dist/hooks/magic-context/caveman-cleanup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"caveman-cleanup.d.ts","sourceRoot":"","sources":["../../../src/hooks/magic-context/caveman-cleanup.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sCAAsC,CAAC;AAO5E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oCAAoC,CAAC;AAEnE,OAAO,EAGH,KAAK,gBAAgB,EAGxB,MAAM,WAAW,CAAC;AACnB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAahD,MAAM,WAAW,oBAAoB;IACjC,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,mGAAmG;IACnG,SAAS,CAAC,EAAE,gBAAgB,CAAC;CAChC;AAED,MAAM,WAAW,oBAAoB;IACjC,gBAAgB,EAAE,MAAM,CAAC;IACzB,gBAAgB,EAAE,MAAM,CAAC;IACzB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,eAAe,EAAE,MAAM,CAAC;IACxB,cAAc,EAAE,KAAK,CAAC;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,iBAAiB,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAC3E;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,aAAa,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,MAAM,CAOvF;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAC/B,SAAS,EAAE,MAAM,EACjB,EAAE,EAAE,eAAe,EACnB,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,EAC/B,IAAI,EAAE,QAAQ,EAAE,EAChB,MAAM,EAAE,oBAAoB,GAAG;IAAE,eAAe,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,GAClE,oBAAoB,CA4KtB;AAgDD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,wBAAwB,CACpC,SAAS,EAAE,MAAM,EACjB,EAAE,EAAE,eAAe,EACnB,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,EAC/B,IAAI,EAAE,QAAQ,EAAE,GACjB,MAAM,CAoCR"}

package/dist/hooks/magic-context/caveman.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Deterministic rule-based text compression in the style of caveman-speak.
+ *
+ * Inspired by the caveman Claude Code skill (JuliusBrussee/caveman, 40k stars)
+ * which validated telegraph-style compression as the right LLM-friendly
+ * compression style — backed by research showing brevity constraints can
+ * actually improve LLM accuracy (arxiv 2604.00025, March 2026).
+ *
+ * This module is pure and stateless. It takes text, applies progressively
+ * aggressive rule-based transformations by level, and returns the compressed
+ * output. It is used by the compressor to post-process historian output at
+ * depths 2-4, enforcing style consistency without relying on LLM compliance.
+ *
+ * Preservation guarantees (all levels):
+ *  - Code blocks (` and ``` fenced)
+ *  - URLs (http://, https://)
+ *  - File paths (contain / or start with ./ or ../)
+ *  - Commit hashes (7-40 hex chars at word boundaries)
+ *  - Compartment markers (§N§, U: lines, msg_*, ses_*, toolu_*)
+ *  - Lines starting with "U: " (user quotes — irreplaceable phrasing)
+ *
+ * Compression by level:
+ *  - lite   (depth 2): drops filler words and hedging
+ *  - full   (depth 3): lite + drops articles and most auxiliaries, allows fragments
+ *  - ultra  (depth 4): full + symbol connectives and common-term abbreviation
+ *
+ * Two rule sets exist (see `CavemanRules`): the current Unicode-aware one, and
+ * the original ASCII one, kept so a session already served under it replays the
+ * same bytes until a cache-rebuilding pass switches it.
+ */
+export type CavemanLevel = "lite" | "full" | "ultra";
+/**
+ * Find the matches of `/(?:\.{1,2}\/)?(?:[\w.-]+\/)+[\w.-]+\.\w{1,6}/g` in
+ * linear time, as `[start, end)` pairs in order.
+ *
+ * Running that regex directly is quadratic: from every position inside a long
+ * run of `[\w.-]` characters with no `/`, the engine scans to the end of the
+ * run before failing, and the transform replays compression on every pass.
+ *
+ * The matches are the same as the regex's. Since `.` is itself a segment
+ * character, the optional `./` or `../` prefix never changes a match. A match
+ * is a chain of segments joined by single slashes, starting at the first
+ * segment, and ends in the file-name tail of the LAST segment (after the
+ * first) that has one, because the regex takes as many `segment/` repetitions
+ * as it can and backtracks from there. A start inside a segment sees the same
+ * chain and the same tails as the segment's start, so once a chain has been
+ * decided no later start inside it can match, and scanning resumes after it.
+ */
+export declare function findFilePathMatches(text: string): Array<[number, number]>;
+/**
+ * Which rule set compresses the text. Replay recomputes compressed text from the
+ * original on every transform pass, so a session keeps the rules it was served
+ * until a pass that already rebuilds the provider cache switches it (see
+ * caveman-cleanup.ts); changing the rules in place would rewrite served bytes
+ * on a pass that must replay them.
+ *
+ *  - "ascii-v1": ASCII word boundaries; phrase, auxiliary and article drops may
+ *    consume a line break; whitespace is normalized after the protected regions
+ *    are restored, which collapses indentation inside fenced code.
+ *  - "unicode-v2": letters, marks and numbers of any script are word characters;
+ *    no rule consumes a line break; protected regions keep their whitespace.
+ *    This is the only rule set of the Rust port (crates/mc-module/src/caveman.rs).
+ */
+export type CavemanRules = "ascii-v1" | "unicode-v2";
+export declare const CURRENT_CAVEMAN_RULES: CavemanRules;
+/**
+ * Whether the current rules may use their English word lists (articles,
+ * auxiliaries, fillers, hedges, pleasantries, phrase shortenings, connectives
+ * and abbreviations). On other languages those lists rewrite real words
+ * ("quite" is Spanish for "remove", "a" is a Spanish preposition), so with
+ * "none" only the language-neutral passes run, the same at every level:
+ * region protection, whitespace normalization and trimming. The original
+ * ASCII rules always use the English lists.
+ */
+export type CavemanWordRules = "english" | "none";
+/**
+ * The word rules for the user-level `language` setting: English when it is
+ * unset, "en", "en-*", or not a valid code (the same values that produce no
+ * language directive); none for any other language. The Rust twin is
+ * `caveman_word_rules_for_language` in crates/mc-module/src/transform.rs.
+ */
+export declare function cavemanWordRulesForLanguage(language: string | undefined): CavemanWordRules;
+/** Compress `text` using caveman-style rules at the given `level`.
+ *
+ *  Preserved regions (code, URLs, paths, hashes, tag markers, U: lines) are
+ *  never modified. Only surrounding prose is transformed.
+ *
+ *  The function is pure: same input always produces the same output. */
+export declare function cavemanCompress(text: string, level: CavemanLevel, rules?: CavemanRules, wordRules?: CavemanWordRules): string;
+//# sourceMappingURL=caveman.d.ts.map

package/dist/hooks/magic-context/caveman.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"caveman.d.ts","sourceRoot":"","sources":["../../../src/hooks/magic-context/caveman.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAIH,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AAgErD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAqCzE;AA8eD;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,YAAY,GAAG,UAAU,GAAG,YAAY,CAAC;AACrD,eAAO,MAAM,qBAAqB,EAAE,YAA2B,CAAC;AAEhE;;;;;;;;GAQG;AACH,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,MAAM,CAAC;AAElD;;;;;GAKG;AACH,wBAAgB,2BAA2B,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,GAAG,gBAAgB,CAI1F;AAED;;;;;wEAKwE;AACxE,wBAAgB,eAAe,CAC3B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,YAAY,EACnB,KAAK,GAAE,YAAoC,EAC3C,SAAS,GAAE,gBAA4B,GACxC,MAAM,CAiCR"}

package/dist/hooks/magic-context/channel2-cycle.d.ts

@@ -0,0 +1,16 @@
+import type { Database } from "../../shared/sqlite";
+import { type Channel2PredicateBaseline } from "./ctx-reduce-nudge";
+export declare function rearmChannel2AfterCoverageAdvancingHardFold(input: {
+    db: Database;
+    sessionId: string;
+    foldExecuted: boolean;
+    compactionOff: boolean;
+    previousCoverage: number | null;
+    currentCoverage: number | null;
+}): boolean;
+export declare function rearmChannel2AfterMeasuredCollapse(input: {
+    db: Database;
+    sessionId: string;
+    baseline: Channel2PredicateBaseline;
+}): boolean;
+//# sourceMappingURL=channel2-cycle.d.ts.map

package/dist/hooks/magic-context/channel2-cycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"channel2-cycle.d.ts","sourceRoot":"","sources":["../../../src/hooks/magic-context/channel2-cycle.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAyB,KAAK,yBAAyB,EAAE,MAAM,oBAAoB,CAAC;AAG3F,wBAAgB,2CAA2C,CAAC,KAAK,EAAE;IAC/D,EAAE,EAAE,QAAQ,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,OAAO,CAAC;IACtB,aAAa,EAAE,OAAO,CAAC;IACvB,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;CAClC,GAAG,OAAO,CAWV;AAED,wBAAgB,kCAAkC,CAAC,KAAK,EAAE;IACtD,EAAE,EAAE,QAAQ,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,yBAAyB,CAAC;CACvC,GAAG,OAAO,CAIV"}

package/dist/hooks/magic-context/channel2-delivery.d.ts

@@ -0,0 +1,32 @@
+import type { Database } from "../../shared/sqlite";
+import { type Channel1State, type Channel2PredicateBaseline, type ToolReclaimHint } from "./ctx-reduce-nudge";
+export interface Channel2DeliveryDeps {
+    db: Database;
+    /**
+     * The in-process client OpenCode hands the plugin (`input.client`). Channel 2
+     * delivers the synthetic-user ceiling nudge through `client.session.promptAsync`.
+     * No-op when absent (e.g. a context with no client wired).
+     */
+    client?: unknown;
+    /** Persisted reclaimable/total tail tokens, typed deltas, and generation validity. */
+    baseline?: Channel2PredicateBaseline & Partial<Pick<Channel1State, "baselineParts">>;
+    oldestReclaimableToolTags?: readonly ToolReclaimHint[];
+    /** Module-owned directives are already predicate-validated; preserve their text verbatim. */
+    directiveText?: string;
+}
+export interface SyntheticUserDeliveryDeps {
+    client: unknown;
+    text: string;
+    /** Re-check lease ownership immediately before the host call. */
+    beforeSend?: () => boolean;
+}
+/** Deliver an agent-directed synthetic user message through OpenCode's live run loop. */
+export declare function deliverSyntheticUserMessage(sessionId: string, deps: SyntheticUserDeliveryDeps): Promise<boolean>;
+/**
+ * Attempt to deliver a pending Channel 2 ceiling nudge for `sessionId`. Safe to
+ * call on every step-boundary `message.updated`: it no-ops unless a `pending`
+ * intent exists and a client is wired. Returns true only when a delivery was
+ * confirmed (intent moved to `delivered`).
+ */
+export declare function maybeDeliverChannel2(sessionId: string, deps: Channel2DeliveryDeps): Promise<boolean>;
+//# sourceMappingURL=channel2-delivery.d.ts.map

package/dist/hooks/magic-context/channel2-delivery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"channel2-delivery.d.ts","sourceRoot":"","sources":["../../../src/hooks/magic-context/channel2-delivery.ts"],"names":[],"mappings":"AAgDA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAEH,KAAK,aAAa,EAClB,KAAK,yBAAyB,EAI9B,KAAK,eAAe,EACvB,MAAM,oBAAoB,CAAC;AAG5B,MAAM,WAAW,oBAAoB;IACjC,EAAE,EAAE,QAAQ,CAAC;IACb;;;;OAIG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,sFAAsF;IACtF,QAAQ,CAAC,EAAE,yBAAyB,GAAG,OAAO,CAAC,IAAI,CAAC,aAAa,EAAE,eAAe,CAAC,CAAC,CAAC;IACrF,yBAAyB,CAAC,EAAE,SAAS,eAAe,EAAE,CAAC;IACvD,6FAA6F;IAC7F,aAAa,CAAC,EAAE,MAAM,CAAC;CAC1B;AA0DD,MAAM,WAAW,yBAAyB;IACtC,MAAM,EAAE,OAAO,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,iEAAiE;IACjE,UAAU,CAAC,EAAE,MAAM,OAAO,CAAC;CAC9B;AAED,yFAAyF;AACzF,wBAAsB,2BAA2B,CAC7C,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,yBAAyB,GAChC,OAAO,CAAC,OAAO,CAAC,CA4BlB;AAED;;;;;GAKG;AACH,wBAAsB,oBAAoB,CACtC,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,oBAAoB,GAC3B,OAAO,CAAC,OAAO,CAAC,CAoJlB"}

package/dist/hooks/magic-context/child-session-spawn.d.ts

@@ -0,0 +1,27 @@
+import { type ChildSpawnFenceFailure } from "../../features/magic-context/schema-fence-probe";
+import type { Database } from "../../shared/sqlite";
+import type { NotificationParams } from "./send-session-notification";
+export declare const STALE_PLUGIN_RESTART_NOTICE = "Magic Context: plugin build is older than its database \u2014 restart OpenCode";
+export declare const SCHEMA_PROBE_FAILURE_NOTICE = "Magic Context: unable to verify the database schema before spawning a child \u2014 run npx @retaw106/mmc-oc@latest doctor";
+interface ChildSessionClient {
+    session: {
+        create(input: never): unknown | Promise<unknown>;
+    };
+}
+interface ChildSessionSpawnArgs {
+    client: ChildSessionClient;
+    db: Database | null;
+    parentSessionId?: string;
+    title: string;
+    directory?: string;
+    notificationParams?: NotificationParams;
+    /** Test seam for the one-shot, N-consecutive failure surface. */
+    onFenceLatched?: (failure: ChildSpawnFenceFailure) => void | Promise<void>;
+}
+/**
+ * Shared OpenCode child-session choke point. Every historian/recomp
+ * child must pass this probe before asking OpenCode to create it.
+ */
+export declare function createChildSessionWithFence(args: ChildSessionSpawnArgs): Promise<unknown | null>;
+export {};
+//# sourceMappingURL=child-session-spawn.d.ts.map

package/dist/hooks/magic-context/child-session-spawn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"child-session-spawn.d.ts","sourceRoot":"","sources":["../../../src/hooks/magic-context/child-session-spawn.ts"],"names":[],"mappings":"AACA,OAAO,EACH,KAAK,sBAAsB,EAE9B,MAAM,iDAAiD,CAAC;AAIzD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AAEtE,eAAO,MAAM,2BAA2B,mFACuC,CAAC;AAChF,eAAO,MAAM,2BAA2B,8HAAoH,CAAC;AAE7J,UAAU,kBAAkB;IACxB,OAAO,EAAE;QAAE,MAAM,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;KAAE,CAAC;CACjE;AAED,UAAU,qBAAqB;IAC3B,MAAM,EAAE,kBAAkB,CAAC;IAC3B,EAAE,EAAE,QAAQ,GAAG,IAAI,CAAC;IACpB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,kBAAkB,CAAC,EAAE,kBAAkB,CAAC;IACxC,iEAAiE;IACjE,cAAc,CAAC,EAAE,CAAC,OAAO,EAAE,sBAAsB,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9E;AA2CD;;;GAGG;AACH,wBAAsB,2BAA2B,CAC7C,IAAI,EAAE,qBAAqB,GAC5B,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC,CAuBzB"}

package/dist/hooks/magic-context/compaction-marker-manager.d.ts

@@ -0,0 +1,154 @@
+/**
+ * Compaction Marker Manager
+ *
+ * Coordinates compaction marker injection/update/removal with historian
+ * publication. Called after compartments are published. Always-on since
+ * v0.21.4 — the `compaction_markers` config knob was removed because the
+ * feature is required for sane transform performance on long sessions.
+ *
+ * The marker summary text is a static placeholder — the real <session-history>
+ * is injected by the transform pipeline via inject-compartments.ts. The marker
+ * exists solely to make OpenCode's filterCompacted stop at the boundary so the
+ * transform receives only the live tail.
+ */
+import { type PendingCompactionMarker } from "../../features/magic-context/storage-meta-persisted";
+import type { Database } from "../../shared/sqlite";
+/** Static placeholder. The real session-history comes from transform injection. */
+export declare const MARKER_SUMMARY_TEXT = "[Compacted by magic-context \u2014 session history is managed by the plugin]";
+/**
+ * Result of draining one persisted marker request.
+ *
+ * Applied, already-current, and stale requests can clear their pending blob.
+ * Retryable failures keep both the blob and deferred-history signal so the
+ * next consuming pass can repeat the deterministic mutation.
+ */
+export type MarkerUpdateOutcome = {
+    kind: "applied";
+    markerOrdinal: number;
+} | {
+    kind: "already-current";
+} | {
+    kind: "stale-skip";
+    reason: "compartment-removed" | "target-superseded";
+} | {
+    kind: "retryable-failure";
+    error: Error;
+};
+/**
+ * Apply a deferred compaction-marker mutation owned by a specific pending
+ * blob. Called from the transform postprocess drain — see
+ * `transform-postprocess-phase.ts` Plan v6 §1.
+ *
+ * Returns one of four outcomes; the drain interprets each:
+ *   - `applied`         → CAS-clear pending (we did the work)
+ *   - `already-current` → CAS-clear pending (boundary already at this ordinal)
+ *   - `stale-skip`      → CAS-clear pending (target gone or superseded)
+ *   - `retryable-failure` → KEEP pending (transient failure; next consuming
+ *                          pass will retry; another publish may overwrite
+ *                          blob and that publish's drain heals)
+ *
+ * Retrying the full sequence is safe. Removal is a no-op when rows are already
+ * absent, and injection uses deterministic IDs with exact-row upserts, so a
+ * committed marker whose context-state write failed is reused rather than duplicated.
+ */
+export interface TrustedMaterializedCompactionBoundary {
+    rowVersion: number;
+    ordinal: number;
+    endMessageId: string;
+}
+export declare function applyDeferredCompactionMarker(db: Database, sessionId: string, pending: PendingCompactionMarker, directory?: string, trustedBoundary?: TrustedMaterializedCompactionBoundary): MarkerUpdateOutcome;
+/**
+ * After historian publishes new compartments, inject or move the compaction marker.
+ * Only moves the boundary forward; summary text is a static placeholder.
+ *
+ * Plan v6: callers in incremental / recomp / partial-recomp paths invoke this
+ * directly only when they are NOT deferring (i.e.
+ * `preserveInjectionCacheUntilConsumed === false`). Deferred path uses
+ * `applyDeferredCompactionMarker` from postprocess drain.
+ */
+export declare function updateCompactionMarkerAfterPublication(db: Database, sessionId: string, lastCompartmentEnd: number, directory?: string): boolean;
+/**
+ * Remove the compaction marker for a session (e.g. on session.deleted).
+ */
+export declare function removeCompactionMarkerForSession(db: Database, sessionId: string): void;
+/**
+ * Result of a fork-orphan marker hygiene pass (#263).
+ *
+ * `removed` counts foreign markers deleted this pass. `failed` signals that at
+ * least one deletion was attempted but could not complete (e.g. SQLITE_BUSY);
+ * the caller treats that as "retry on the next degraded pass" and never as a
+ * fatal error.
+ */
+export interface OrphanMarkerReconcileResult {
+    removed: number;
+    failed: boolean;
+}
+/**
+ * Fork-orphan compaction-marker hygiene (#263).
+ *
+ * OpenCode's `/fork` copies the parent session's message rows into the fork —
+ * including the parent's magic-context compaction-marker rows — but does NOT
+ * inherit magic-context's durable state (PARITY.md gap #25: OpenCode re-mints
+ * message ids on fork, so entry-id-keyed migration is unsafe). The fork then
+ * injects its own fresh marker at its own (much older) historian boundary, and
+ * `filterCompacted` — which walks newest→oldest and stops at the FIRST marker
+ * it sees (opencode message-v2.ts `filterCompacted`) — honours the NEWER
+ * orphan instead of ours. The visible window is cut at the orphan, our boundary
+ * message falls below the cut, and inject-compartments degrades with no
+ * recovery path while context usage climbs.
+ *
+ * A marker row in opencode.db for this session that the durable state does not
+ * recognize as its own current marker is a fork-orphan. This pass scans for
+ * them and removes the ones that actively outrank ours:
+ *
+ *   - not owned: `part.id != persisted.compactionPartId`
+ *   - magic-context-shaped: carries one of OUR summary messages
+ *     (providerID="magic-context") — OpenCode-native /compact markers carry the
+ *     real provider id and are never touched
+ *   - newer than ours: its boundary message sorts AFTER ours in canonical
+ *     order, which is exactly the case where `filterCompacted` stops at the
+ *     orphan first. Older foreign markers are harmless (ours already wins) and
+ *     are left alone to keep the repair minimally invasive.
+ *
+ * Removal is idempotent (plain DELETEs) so concurrent processes racing on the
+ * same orphan converge on the same end state; the only guarded invariant is
+ * never deleting our own marker, re-checked against freshly-read persisted
+ * state below.
+ *
+ * Cost gate: callers invoke this only when degraded mode fires (never on every
+ * pass), so steady state pays nothing. Any failure is swallowed and reported
+ * via the result so the next degraded pass retries.
+ */
+export declare function reconcileForkOrphanedCompactionMarkers(db: Database, sessionId: string): OrphanMarkerReconcileResult;
+/**
+ * Close the writable OpenCode DB connection used for marker injection.
+ */
+export declare function closeCompactionMarkerConnection(): void;
+/**
+ * Startup consistency check for compaction markers.
+ *
+ * Magic Context persists marker state in context.db's `session_meta`, while the
+ * actual marker rows (compaction part + summary message + summary part) live in
+ * OpenCode's separate `opencode.db`. There is no cross-DB transaction between
+ * the two stores, so a crash between writes — or any external cleanup of
+ * OpenCode's DB — can leave the two in an inconsistent state:
+ *
+ * - Phantom state: persisted in context.db but the referenced rows no longer
+ *   exist in opencode.db. On next publication, the manager tries to remove a
+ *   marker that isn't there, ignores the failure, and re-injects, but the
+ *   stale persisted state can also confuse readers that trust it.
+ * - Orphaned rows: rows in opencode.db exist without matching context.db
+ *   state. Those can't be surfaced from here (we don't track them), but the
+ *   natural-healing path already handles them: the next historian publication
+ *   moves the boundary forward and the new injection replaces the orphans by
+ *   moving filterCompacted past them.
+ *
+ * This function only diagnoses missing rows. A discovered database path does
+ * not prove which store the server writes, and startup has no cache-busting
+ * permission. Retain state and surviving rows; the deferred publication drain
+ * performs replacement on a priced pass instead.
+ *
+ * Called once at plugin startup. Safe to call multiple times (idempotent).
+ */
+export declare function checkCompactionMarkerConsistency(db: Database): void;
+//# sourceMappingURL=compaction-marker-manager.d.ts.map

package/dist/hooks/magic-context/compaction-marker-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compaction-marker-manager.d.ts","sourceRoot":"","sources":["../../../src/hooks/magic-context/compaction-marker-manager.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAgBH,OAAO,EAEH,KAAK,uBAAuB,EAG/B,MAAM,qDAAqD,CAAC;AAY7D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAKpD,mFAAmF;AACnF,eAAO,MAAM,mBAAmB,iFAC6C,CAAC;AAwB9E;;;;;;GAMG;AACH,MAAM,MAAM,mBAAmB,GACzB;IACI,IAAI,EAAE,SAAS,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;CACzB,GACD;IAAE,IAAI,EAAE,iBAAiB,CAAA;CAAE,GAC3B;IACI,IAAI,EAAE,YAAY,CAAC;IACnB,MAAM,EAAE,qBAAqB,GAAG,mBAAmB,CAAC;CACvD,GACD;IAAE,IAAI,EAAE,mBAAmB,CAAC;IAAC,KAAK,EAAE,KAAK,CAAA;CAAE,CAAC;AA6IlD;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,qCAAqC;IAClD,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;CACxB;AAED,wBAAgB,6BAA6B,CACzC,EAAE,EAAE,QAAQ,EACZ,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,uBAAuB,EAChC,SAAS,CAAC,EAAE,MAAM,EAClB,eAAe,CAAC,EAAE,qCAAqC,GACxD,mBAAmB,CA0GrB;AAED;;;;;;;;GAQG;AACH,wBAAgB,sCAAsC,CAClD,EAAE,EAAE,QAAQ,EACZ,SAAS,EAAE,MAAM,EACjB,kBAAkB,EAAE,MAAM,EAC1B,SAAS,CAAC,EAAE,MAAM,GACnB,OAAO,CAoFT;AAED;;GAEG;AACH,wBAAgB,gCAAgC,CAAC,EAAE,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,CAmBtF;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,2BAA2B;IACxC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,OAAO,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,sCAAsC,CAClD,EAAE,EAAE,QAAQ,EACZ,SAAS,EAAE,MAAM,GAClB,2BAA2B,CAoF7B;AAED;;GAEG;AACH,wBAAgB,+BAA+B,IAAI,IAAI,CAEtD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,gCAAgC,CAAC,EAAE,EAAE,QAAQ,GAAG,IAAI,CA6EnE"}