@retaw106/mmc-oc 0.0.0-stage → 1.2.2

package/dist/features/magic-context/tool-owner-backfill.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-owner-backfill.d.ts","sourceRoot":"","sources":["../../../src/features/magic-context/tool-owner-backfill.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAKH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAiBpD,UAAU,gBAAgB;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B;AAED,UAAU,cAAc;IACpB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,qBAAqB,EAAE,MAAM,CAAC;IAC9B,wBAAwB,EAAE,MAAM,CAAC;IACjC,iBAAiB,EAAE,MAAM,CAAC;IAC1B,sBAAsB,EAAE,MAAM,CAAC;IAC/B,eAAe,EAAE,MAAM,CAAC;IACxB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;CACtB;AAqBD;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,QAAQ,GAAG,cAAc,CAgEjE;AAED;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CAAC,EAAE,EAAE,QAAQ,GAAG,OAAO,CAkB/D;AA4FD,oEAAoE;AACpE,wBAAgB,2BAA2B,CAAC,EAAE,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,CAEjF;AAiPD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI,CAO1F"}

package/dist/features/magic-context/transform-decision-log.d.ts

@@ -0,0 +1,110 @@
+import { Database } from "../../shared/sqlite";
+export type TransformDecisionHarness = "opencode" | "pi";
+export type TransformSchedulerDecision = "execute" | "defer" | "error" | "need_full_sync" | "parked" | "passthrough" | "unknown";
+/**
+ * Max transform_decisions rows kept per (session_id, harness). Pruned newest-first
+ * after every insert so a long session's cache-affecting passes never grow this
+ * telemetry table without bound (the dashboard loads all matching rows for cause
+ * attribution).
+ */
+export declare const TRANSFORM_DECISIONS_RETENTION = 2000;
+export type CanonicalMaterializeReason = "system_hash" | "model_change" | "ttl_idle" | "explicit_flush" | "max_mutation_id" | "first_render" | "pressure_refold" | "upgrade_state" | "cached_m1_missing" | "project_change" | "compartment_render_epoch" | "m1_delta" | "ttl_expiry" | "epoch_change" | "coverage_fold" | "profile_transition" | "host_compaction";
+export interface PendingTransformDecision {
+    tsMs: number;
+    decision: TransformSchedulerDecision;
+    materialized: boolean;
+    materializeReason: CanonicalMaterializeReason | null;
+    /**
+     * `transform_decisions.system_hash_prev`: cached operand from a system-hash
+     * comparison. NULL means this pass made no system-hash comparison; an empty
+     * string is a real compared cached value and must remain distinct from NULL.
+     */
+    systemHashPrev: string | null;
+    /**
+     * `transform_decisions.system_hash_new`: live operand from a system-hash
+     * comparison. NULL means this pass made no system-hash comparison.
+     */
+    systemHashNew: string | null;
+    /**
+     * `transform_decisions.m0_model_key_prev`: cached canonical model-key operand.
+     * NULL means this pass made no model-key comparison; an empty string is a real
+     * compared cached value and must remain distinct from NULL.
+     */
+    m0ModelKeyPrev: string | null;
+    /**
+     * `transform_decisions.m0_model_key_new`: live canonical model-key operand.
+     * NULL means this pass made no model-key comparison.
+     */
+    m0ModelKeyNew: string | null;
+    /**
+     * `transform_decisions.m0_tool_set_hash_prev`: cached tool-set operand from
+     * an observed comparison. NULL means this pass made no tool-set comparison;
+     * an empty string is a real compared cached value.
+     */
+    m0ToolSetHashPrev?: string | null;
+    /**
+     * `transform_decisions.m0_tool_set_hash_new`: live tool-set operand from an
+     * observed comparison. NULL means this pass made no tool-set comparison.
+     */
+    m0ToolSetHashNew?: string | null;
+    emergency: boolean;
+    /**
+     * Nonnegative estimate persisted as `transform_decisions.dropped_tokens` for
+     * diagnostics only. It does not drive budgeting or scheduler decisions.
+     */
+    droppedTokens: number;
+    droppedCount: number;
+    inputTokens: number;
+    bustedThisPass: boolean;
+}
+interface TransformDecisionRow extends PendingTransformDecision {
+    sessionId: string;
+    harness: TransformDecisionHarness;
+    messageId: string;
+}
+interface PendingPiTransformDecision extends PendingTransformDecision {
+    snapshotNewestAssistantEntryId: string | null;
+}
+type TransformDecisionWriter = (dbPath: string, row: TransformDecisionRow) => void;
+export declare function normalizeMaterializeReason(harness: TransformDecisionHarness, reason: string | null | undefined, rematerialized: boolean): CanonicalMaterializeReason | null;
+/**
+ * Stage one Rust pass for the assistant message that will receive its provider usage row.
+ * The transform runs before that assistant exists, so binding to the newest input message
+ * attributes a multi-step pass to the previous step. The ordinary OpenCode event path binds
+ * this pending record to the next completed assistant id.
+ */
+export declare function writeRustTransformDecision(args: {
+    sessionId: string;
+    decision: string;
+    materializeReason: string | null;
+    inputTokens: number;
+    tsMs?: number;
+}): void;
+export declare function clearOpenCodePendingTransformDecision(sessionId: string): void;
+export declare function clearTransformDecisionSession(sessionId: string): void;
+export declare function recordPendingTransformDecision(sessionId: string, decision: PendingTransformDecision): void;
+export declare function recordPendingPiTransformDecision(sessionId: string, decision: PendingTransformDecision, snapshotNewestAssistantEntryId: string | null): void;
+export declare function scheduleOpenCodeTransformDecisionWrite(args: {
+    db: Database;
+    sessionId: string;
+    messageId: string;
+    inputTokens: number;
+}): boolean;
+export declare function findNewestPiAssistantEntryId(entries: readonly unknown[] | null | undefined): string | null;
+export declare function schedulePiTransformDecisionResolve(args: {
+    db: Database;
+    sessionId: string;
+    branchEntries: readonly unknown[] | null;
+}): boolean;
+declare function findNewestPiAssistantEntryIdAfter(entries: readonly unknown[] | null, snapshotNewestAssistantEntryId: string | null): string | null;
+export declare const __test: {
+    getPending(sessionId: string): PendingTransformDecision | undefined;
+    getPendingPi(sessionId: string): PendingPiTransformDecision | undefined;
+    reset(): void;
+    setWriterForTests(writer: TransformDecisionWriter | null): void;
+    setRetentionForTests(cap: number | null): void;
+    writeRow(dbPath: string, row: TransformDecisionRow): void;
+    findNewestPiAssistantEntryIdAfter: typeof findNewestPiAssistantEntryIdAfter;
+};
+export {};
+//# sourceMappingURL=transform-decision-log.d.ts.map

package/dist/features/magic-context/transform-decision-log.d.ts.map

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

package/dist/features/magic-context/types.d.ts

@@ -0,0 +1,133 @@
+export interface TagEntry {
+    tagNumber: number;
+    messageId: string;
+    type: "message" | "tool" | "file";
+    status: "active" | "dropped" | "compacted";
+    /**
+     * How a dropped tool tag is rendered on every replay pass (frozen at drop
+     * time, re-derived deterministically from the original wire part each pass):
+     *  - "full": the whole tool call is removed from the transcript.
+     *  - "skeleton_real": keep the tool_use call with its REAL arguments,
+     *    output -> [dropped N]. Used for small inputs dropped inside the
+     *    newest-call window and for the call whose result ends the request.
+     *  - "truncated": legacy skeleton; keep the tool_use call, output ->
+     *    [dropped N], arguments replaced by the `{"dropped": …}` marker. No
+     *    longer written by new drops; existing tags replay it until a HARD fold
+     *    converts them to "skeleton_real" or "full".
+     *  - "edit_marker": like "truncated" but for an edit/write superseded by a
+     *    later edit to the same file; keep the filePath verbatim and a short
+     *    region-hint prefix of the diff, so the agent still sees WHICH file and
+     *    region it edited. Only produced when the smart_drops config is on.
+     */
+    dropMode: "full" | "truncated" | "skeleton_real" | "skeleton_stripped" | "edit_marker" | "edit_marker_stripped";
+    toolName: string | null;
+    inputByteSize: number;
+    byteSize: number;
+    reasoningByteSize: number;
+    sessionId: string;
+    /**
+     * Caveman compression depth applied to this tag's text part. 0 = none,
+     * 1 = lite, 2 = full, 3 = ultra. Only meaningful for `type: "message"`;
+     * tool/file tags stay at 0. Used by experimental age-tier caveman
+     * heuristic to avoid re-compressing text that already matches the
+     * target depth for its age band.
+     */
+    cavemanDepth: number;
+    /**
+     * For `type: "tool"` tags: the assistant message id where the
+     * underlying tool call was invoked. Identity for a tool tag is the
+     * triple `(sessionId, messageId/callID, toolOwnerMessageId)` —
+     * including this field disambiguates collisions when OpenCode's
+     * per-turn callID counter produces the same id across turns.
+     *
+     * NULL on:
+     *   - all `type: "message"` and `type: "file"` tags (not applicable)
+     *   - legacy tool tags written before plugin v0.16.x (the
+     *     tag-owner-fix migration v10). The runtime lazily adopts these
+     *     orphan rows on first observation; backfill populates them at
+     *     plugin startup against the OpenCode DB.
+     *
+     * See plan v3.3.1 in `.alfonso/plans/tag-owner-fix-plan.md`.
+     */
+    toolOwnerMessageId: string | null;
+}
+export interface PendingOp {
+    id: number;
+    sessionId: string;
+    tagId: number;
+    operation: "drop";
+    queuedAt: number;
+}
+export interface SessionMeta {
+    sessionId: string;
+    lastResponseTime: number;
+    cacheTtl: string;
+    counter: number;
+    lastNudgeTokens: number;
+    lastNudgeBand: "far" | "near" | "urgent" | "critical" | null;
+    lastTransformError: string | null;
+    isSubagent: boolean;
+    lastContextPercentage: number;
+    lastInputTokens: number;
+    observedSafeInputTokens: number;
+    cacheAlertSent: boolean;
+    timesExecuteThresholdReached: number;
+    compartmentInProgress: boolean;
+    systemPromptHash: string;
+    systemPromptTokens: number;
+    conversationTokens: number;
+    toolCallTokens: number;
+    clearedReasoningThroughTag: number;
+    toolReclaimWatermark: number;
+    lastTodoState: string;
+    cachedM0Bytes: Buffer | null;
+    /** Frozen image payload paired atomically with cachedM0Bytes. */
+    cachedM0MuralDataUrl: string | null;
+    cachedM0MuralHash: string | null;
+    cachedM1Bytes: Buffer | null;
+    cachedM0ProjectMemoryEpoch: number | null;
+    cachedM0WorkspaceFingerprint: string | null;
+    cachedM0ProjectUserProfileVersion: number | null;
+    cachedM0MaxCompartmentSeq: number | null;
+    cachedM0MaxMemoryId: number | null;
+    /**
+     * Pi message stable-id scheme version (Pi-only; OpenCode ignores it).
+     * NULL/0 = legacy index-based `pi-msg-*` ids; >=1 = real-SessionEntry-id
+     * scheme. Drives the one-time forced execute+materialize cutover when a
+     * session's stored scheme is below PI_STABLE_ID_SCHEME.
+     */
+    piStableIdScheme: number | null;
+    cachedM0MaxMutationId: number | null;
+    cachedM0MaxMemoryMutationId: number | null;
+    cachedM0ProjectDocsHash: string | null;
+    cachedM0MaterializedAt: number | null;
+    cachedM0SessionFactsVersion: number | null;
+    cachedM0UpgradeState: string | null;
+    /** HARD-bust markers: provider-side cache-eviction signals (system/tools/model). */
+    cachedM0SystemHash: string | null;
+    cachedM0ToolSetHash: string | null;
+    cachedM0ModelKey: string | null;
+    /** Pi-only HARD marker: project identity captured in the cached m[0] baseline. */
+    cachedM0ProjectIdentity: string | null;
+    lastObservedModelKey: string | null;
+    lastUsageContextLimit: number;
+    priorBoundaryOrdinal: number;
+    protectedTailPolicyVersion: number;
+    protectedTailDrainWindowStartedAt: number;
+    protectedTailDrainTokens: number;
+    recoveryNoEligibleHeadCount: number;
+    forceEmergencyBypassWindowStart: number;
+    forceEmergencyBypassUsed: number;
+    /** Set only after an explicit OpenCode dialog choice; keeps the fresh dialog dismissed. */
+    upgradeRemindedAt: number | null;
+    /** Most recent push reminder delivery, used for the bounded re-notification cooldown. */
+    upgradeReminderLastSentAt: number | null;
+    /** Total delivered upgrade reminders; the hard cap prevents an endless nag loop. */
+    upgradeReminderCount: number;
+}
+export type SchedulerDecision = "execute" | "defer";
+export interface ContextUsage {
+    percentage: number;
+    inputTokens: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/features/magic-context/types.d.ts.map

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

package/dist/features/magic-context/window-report-ledger.d.ts

@@ -0,0 +1,70 @@
+import type { ContextLimitProvenance } from "../../shared/context-limit-provenance";
+export declare const WINDOW_REPORTS_ROTATION_BYTES: number;
+/**
+ * Fusiform's full-catalog dual-detector admit sweep (pm_d3e23fcd, 2026-08-13:
+ * 125 providers / 5,680 models whose catalogs carry other vendors' models).
+ * An ADMIT list, not a classification — membership warrants
+ * `path_may_forward: true` at capture; absence clears nobody (a provider
+ * using an id convention neither detector knows is silently missing here),
+ * which is why the emitter never writes `false`: the report schema pins
+ * absent = unknown routing (refuses promotion, same as true), while an
+ * explicit false would PERMIT promotion — a claim this set structurally
+ * cannot support.
+ *
+ * `ollama-cloud` is deliberately EXCLUDED: the detectors admit it (it
+ * carries glm/deepseek/kimi weights) but it imposes its OWN wall from its
+ * own serving stack — and this field marks whose-wall-might-fire, not
+ * who-carries-whose-models. Other own-wall gateways may hide in this list;
+ * only per-cell evidence distinguishes them, and Fusiform's adjudicator
+ * refuses promotion for every admitted provider regardless, so a wrong
+ * `true` here degrades toward refusal, never toward a wrong mint.
+ */
+export declare const FORWARDING_PROVIDER_IDS: ReadonlySet<string>;
+export interface WindowReport {
+    provider_id?: string;
+    model_id?: string;
+    access_path: "api";
+    status?: number;
+    matched_pattern?: string;
+    extracted_limit?: number;
+    extracted_limit_units?: "provider";
+    attempted_tokens?: number;
+    attempted_tokens_units?: "estimate";
+    geometry: "prompt_only" | "combined" | "unknown";
+    observed_at_ms: number;
+    largest_success?: number;
+    largest_success_units?: "estimate";
+    /**
+     * Emitted ONLY as `true` (provider is a known forwarder) or omitted
+     * (unknown routing — refuses promotion by the schema's absent rule).
+     * Never `false`: this reporter has no evidence basis for asserting a
+     * path cannot forward, and explicit false is the one value that would
+     * permit promoting a measured report at a forwarded key.
+     */
+    path_may_forward?: true;
+    /** Observed routing evidence only; never inferred from provider configuration. */
+    served_by_hint?: string;
+}
+export interface AppendWindowReportInput {
+    db: import("../../shared/sqlite").Database;
+    providerID?: string;
+    modelID?: string;
+    matchedPattern?: string;
+    reportedLimit?: number;
+    reportedLimitProvenance?: ContextLimitProvenance;
+    attemptedTokens?: number;
+    error?: unknown;
+    observedAtMs?: number;
+    sessionID?: string;
+}
+export interface WindowReportLedgerDiagnostics {
+    swallowedWriteCount: number;
+    lastErrorMessage: string | null;
+}
+export declare function getWindowReportsPath(): string;
+export declare function getWindowReportLedgerDiagnostics(): WindowReportLedgerDiagnostics;
+export declare function __resetWindowReportLedgerDiagnosticsForTests(): void;
+export declare function buildWindowReport(input: AppendWindowReportInput): WindowReport;
+export declare function appendWindowReport(report: WindowReport): void;
+export declare function captureWindowReport(input: AppendWindowReportInput): void;
+//# sourceMappingURL=window-report-ledger.d.ts.map

package/dist/features/magic-context/window-report-ledger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"window-report-ledger.d.ts","sourceRoot":"","sources":["../../../src/features/magic-context/window-report-ledger.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,uCAAuC,CAAC;AASpF,eAAO,MAAM,6BAA6B,QAAmB,CAAC;AAE9D;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,uBAAuB,EAAE,WAAW,CAAC,MAAM,CA6HtD,CAAC;AAEH,MAAM,WAAW,YAAY;IACzB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,KAAK,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,qBAAqB,CAAC,EAAE,UAAU,CAAC;IACnC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,sBAAsB,CAAC,EAAE,UAAU,CAAC;IACpC,QAAQ,EAAE,aAAa,GAAG,UAAU,GAAG,SAAS,CAAC;IACjD,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,qBAAqB,CAAC,EAAE,UAAU,CAAC;IACnC;;;;;;OAMG;IACH,gBAAgB,CAAC,EAAE,IAAI,CAAC;IACxB,kFAAkF;IAClF,cAAc,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,uBAAuB;IACpC,EAAE,EAAE,OAAO,qBAAqB,EAAE,QAAQ,CAAC;IAC3C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,uBAAuB,CAAC,EAAE,sBAAsB,CAAC;IACjD,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,6BAA6B;IAC1C,mBAAmB,EAAE,MAAM,CAAC;IAC5B,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;CACnC;AAKD,wBAAgB,oBAAoB,IAAI,MAAM,CAE7C;AAYD,wBAAgB,gCAAgC,IAAI,6BAA6B,CAEhF;AAED,wBAAgB,4CAA4C,IAAI,IAAI,CAGnE;AA2ED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,uBAAuB,GAAG,YAAY,CAqC9E;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI,CAmB7D;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,uBAAuB,GAAG,IAAI,CAMxE"}

package/dist/features/magic-context/work-metrics.d.ts

@@ -0,0 +1,79 @@
+import type { Database } from "../../shared/sqlite";
+export interface WorkMetrics {
+    newWorkTokens: number;
+    totalInputTokens: number;
+}
+export interface PiSessionEntry {
+    role?: unknown;
+    usage?: unknown;
+    message?: unknown;
+}
+export declare function computeOpenCodeWorkMetrics(openCodeDb: Database, sessionId: string): WorkMetrics;
+/** A single assistant row's usage, as folded by `foldWorkMetricsRows`. */
+export interface AssistantUsageRow {
+    /** json_extract(data,'$.agent'); null when absent (its own partition). */
+    agent: string | null;
+    timeCreated: number;
+    id: string;
+    /** input + cache.read + cache.write. */
+    prompt: number;
+    output: number;
+}
+interface AgentCarry {
+    prevPrompt: number;
+    phaseId: number;
+    /** Max qualifying prompt in the current (open) phase. */
+    phasePeak: number;
+    /** Whether the current phase has at least one qualifying row. */
+    phaseHasQualifying: boolean;
+    /** Summed peaks of already-closed qualifying phases. */
+    closedPhaseSum: number;
+    lastOutput: number;
+    seen: boolean;
+}
+/** Resumable accumulator: fold new rows into this to extend the metric. */
+export interface WorkMetricsCarry {
+    perAgent: Map<string, AgentCarry>;
+    /** Σ max(0, prompt - prevPrompt) across every folded row (metric A body). */
+    newWorkSum: number;
+    /** Watermark: last folded row's ordering key. */
+    lastTimeCreated: number;
+    lastId: string;
+}
+export declare function emptyWorkMetricsCarry(): WorkMetricsCarry;
+/**
+ * Fold rows (which MUST be in (timeCreated, id) ascending order and strictly
+ * newer than `carry`'s watermark) into the carry, mutating and returning it.
+ *
+ * Mirrors OPEN_CODE_WORK_METRICS_SQL:
+ *  - delta per row = max(0, prompt - LAG(prompt) per agent), default LAG 0.
+ *  - phase_id = cumulative count of (prompt < prevPrompt) per agent; a dropping
+ *    row starts (and belongs to) the new phase.
+ *  - phase peak counts only QUALIFYING rows (prevPrompt > 0 OR phase_id == 0).
+ *  - metric A = Σ deltas + Σ (last output per agent); metric B = Σ phase peaks.
+ */
+export declare function foldWorkMetricsRows(rows: AssistantUsageRow[], carry: WorkMetricsCarry): WorkMetricsCarry;
+/** Current metric value implied by the carry (cheap; no DB access). */
+export declare function metricsFromCarry(carry: WorkMetricsCarry): WorkMetrics;
+/** Read assistant usage rows strictly newer than the carry watermark. */
+export declare function readAssistantUsageRowsAfter(openCodeDb: Database, sessionId: string, afterTimeCreated: number, afterId: string): AssistantUsageRow[];
+/**
+ * Extend `carry` with assistant rows newer than its watermark and return the
+ * up-to-date metrics. On a fresh carry this folds the whole session once (cold
+ * start); subsequent calls fold only new rows (≈0 when idle).
+ *
+ * The single most-recent assistant row is NEVER committed into the durable
+ * carry — OpenCode writes the row at stream start and finalizes `data.tokens`
+ * at completion, so a poll mid-stream would otherwise freeze that row at a
+ * partial/zero value. Instead the watermark is advanced only through the
+ * second-to-last row; the last row is re-read every poll and folded into a
+ * throwaway clone for the returned value, so the result always matches a full
+ * re-scan even while the latest turn is still streaming.
+ */
+export declare function computeOpenCodeWorkMetricsIncremental(openCodeDb: Database, sessionId: string, carry: WorkMetricsCarry): {
+    carry: WorkMetricsCarry;
+    metrics: WorkMetrics;
+};
+export declare function computePiWorkMetrics(sessionEntries: PiSessionEntry[] | unknown[]): WorkMetrics;
+export {};
+//# sourceMappingURL=work-metrics.d.ts.map

package/dist/features/magic-context/work-metrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"work-metrics.d.ts","sourceRoot":"","sources":["../../../src/features/magic-context/work-metrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAEpD,MAAM,WAAW,WAAW;IACxB,aAAa,EAAE,MAAM,CAAC;IACtB,gBAAgB,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,cAAc;IAC3B,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,OAAO,CAAC,EAAE,OAAO,CAAC;CACrB;AAwFD,wBAAgB,0BAA0B,CAAC,UAAU,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,GAAG,WAAW,CAQ/F;AAaD,0EAA0E;AAC1E,MAAM,WAAW,iBAAiB;IAC9B,0EAA0E;IAC1E,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,EAAE,EAAE,MAAM,CAAC;IACX,wCAAwC;IACxC,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAClB;AAED,UAAU,UAAU;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,yDAAyD;IACzD,SAAS,EAAE,MAAM,CAAC;IAClB,iEAAiE;IACjE,kBAAkB,EAAE,OAAO,CAAC;IAC5B,wDAAwD;IACxD,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,OAAO,CAAC;CACjB;AAED,2EAA2E;AAC3E,MAAM,WAAW,gBAAgB;IAC7B,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IAClC,6EAA6E;IAC7E,UAAU,EAAE,MAAM,CAAC;IACnB,iDAAiD;IACjD,eAAe,EAAE,MAAM,CAAC;IACxB,MAAM,EAAE,MAAM,CAAC;CAClB;AAID,wBAAgB,qBAAqB,IAAI,gBAAgB,CAExD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAC/B,IAAI,EAAE,iBAAiB,EAAE,EACzB,KAAK,EAAE,gBAAgB,GACxB,gBAAgB,CA2ClB;AAaD,uEAAuE;AACvE,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,gBAAgB,GAAG,WAAW,CAWrE;AA0BD,yEAAyE;AACzE,wBAAgB,2BAA2B,CACvC,UAAU,EAAE,QAAQ,EACpB,SAAS,EAAE,MAAM,EACjB,gBAAgB,EAAE,MAAM,EACxB,OAAO,EAAE,MAAM,GAChB,iBAAiB,EAAE,CAWrB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,qCAAqC,CACjD,UAAU,EAAE,QAAQ,EACpB,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,gBAAgB,GACxB;IAAE,KAAK,EAAE,gBAAgB,CAAC;IAAC,OAAO,EAAE,WAAW,CAAA;CAAE,CAiBnD;AAED,wBAAgB,oBAAoB,CAAC,cAAc,EAAE,cAAc,EAAE,GAAG,OAAO,EAAE,GAAG,WAAW,CA8B9F"}

package/dist/features/magic-context/workspaces.d.ts

@@ -0,0 +1,28 @@
+import type { Database } from "../../shared/sqlite";
+export interface WorkspaceIdentitySet {
+    identities: string[];
+    namesByIdentity: Map<string, string>;
+}
+export interface ExpandedWorkspaceIdentitySet {
+    expandedIdentities: string[];
+    canonicalIdentityByStoredPath: Map<string, string>;
+}
+/**
+ * Resolve the categories this workspace shares from foreign member projects.
+ *
+ * Return null when the project is not in a workspace. For workspace members,
+ * always return a list: [] means no foreign categories are shared, malformed
+ * JSON falls back to [], and older rows with missing or NULL share_categories
+ * default to CONSTRAINTS only.
+ */
+export declare function resolveWorkspaceShareCategories(db: Database, projectIdentity: string): string[] | null;
+export declare function resolveWorkspaceIdentitySet(db: Database, projectIdentity: string): WorkspaceIdentitySet;
+export declare function expandWorkspaceIdentitySet(db: Database, identities: readonly string[]): string[];
+export declare function expandWorkspaceIdentitySetWithAliases(db: Database, identities: readonly string[]): ExpandedWorkspaceIdentitySet;
+export declare function resolveStoredPathWorkspaceIdentity(storedProjectPath: string, memberIdentities: readonly string[], canonicalIdentityByStoredPath: ReadonlyMap<string, string>): string | null;
+export declare function storedPathBelongsToWorkspace(storedProjectPath: string, memberIdentities: readonly string[], expandedIdentities: readonly string[], canonicalIdentityByStoredPath: ReadonlyMap<string, string>): boolean;
+export declare function sourceNameForMemory(storedProjectPath: string, ownIdentity: string, memberIdentities: readonly string[], namesByIdentity: ReadonlyMap<string, string>, canonicalIdentityByStoredPath: ReadonlyMap<string, string>): string | undefined;
+export declare function computeWorkspaceEpochFingerprint(db: Database, identities: readonly string[]): string;
+export declare function bumpEpochsForWorkspaceMembers(db: Database, identity: string, now?: number): void;
+export declare function bumpEpochsForWorkspaceMemberSet(db: Database, identities: readonly string[], now?: number): void;
+//# sourceMappingURL=workspaces.d.ts.map

package/dist/features/magic-context/workspaces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspaces.d.ts","sourceRoot":"","sources":["../../../src/features/magic-context/workspaces.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAKpD,MAAM,WAAW,oBAAoB;IACjC,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,eAAe,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACxC;AAED,MAAM,WAAW,4BAA4B;IACzC,kBAAkB,EAAE,MAAM,EAAE,CAAC;IAC7B,6BAA6B,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACtD;AAqID;;;;;;;GAOG;AACH,wBAAgB,+BAA+B,CAC3C,EAAE,EAAE,QAAQ,EACZ,eAAe,EAAE,MAAM,GACxB,MAAM,EAAE,GAAG,IAAI,CAEjB;AAED,wBAAgB,2BAA2B,CACvC,EAAE,EAAE,QAAQ,EACZ,eAAe,EAAE,MAAM,GACxB,oBAAoB,CAiCtB;AAED,wBAAgB,0BAA0B,CAAC,EAAE,EAAE,QAAQ,EAAE,UAAU,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,EAAE,CAEhG;AAED,wBAAgB,qCAAqC,CACjD,EAAE,EAAE,QAAQ,EACZ,UAAU,EAAE,SAAS,MAAM,EAAE,GAC9B,4BAA4B,CA+B9B;AAED,wBAAgB,kCAAkC,CAC9C,iBAAiB,EAAE,MAAM,EACzB,gBAAgB,EAAE,SAAS,MAAM,EAAE,EACnC,6BAA6B,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GAC3D,MAAM,GAAG,IAAI,CAef;AAED,wBAAgB,4BAA4B,CACxC,iBAAiB,EAAE,MAAM,EACzB,gBAAgB,EAAE,SAAS,MAAM,EAAE,EACnC,kBAAkB,EAAE,SAAS,MAAM,EAAE,EACrC,6BAA6B,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GAC3D,OAAO,CAST;AAED,wBAAgB,mBAAmB,CAC/B,iBAAiB,EAAE,MAAM,EACzB,WAAW,EAAE,MAAM,EACnB,gBAAgB,EAAE,SAAS,MAAM,EAAE,EACnC,eAAe,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,EAC5C,6BAA6B,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GAC3D,MAAM,GAAG,SAAS,CAQpB;AAmBD,wBAAgB,gCAAgC,CAC5C,EAAE,EAAE,QAAQ,EACZ,UAAU,EAAE,SAAS,MAAM,EAAE,GAC9B,MAAM,CAmBR;AAsCD,wBAAgB,6BAA6B,CACzC,EAAE,EAAE,QAAQ,EACZ,QAAQ,EAAE,MAAM,EAChB,GAAG,SAAa,GACjB,IAAI,CAoBN;AAED,wBAAgB,+BAA+B,CAC3C,EAAE,EAAE,QAAQ,EACZ,UAAU,EAAE,SAAS,MAAM,EAAE,EAC7B,GAAG,SAAa,GACjB,IAAI,CAoBN"}

package/dist/hooks/auto-update-checker/semver.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Strict semver validator for the auto-update path.
+ *
+ * The plugin version string flows from the npm registry / dist-tags into
+ * package.json's dependency spec before `npm install`. A malformed or crafted
+ * value (`npm:@evil/pkg@1.0.0`, `file:/tmp/x`, `git+ssh://...`) must never be
+ * written there — this is the arbitrary-package-install / SSRF guard.
+ *
+ * Lives in its own leaf module (no imports beyond this) so both `cache.ts` and
+ * `checker.ts` can use it without creating a circular import between them
+ * (`cache.ts` imports `checker.ts` for the runtime package.json path; if
+ * `checker.ts` also imported this from `cache.ts`, the cycle breaks static
+ * export resolution on a cold module graph — CI / fresh installs — even though
+ * a warm bun cache tolerates it).
+ */
+export declare function isValidSemver(version: string): boolean;
+/**
+ * Compare two semver core versions (major.minor.patch). Returns >0 if `a` is
+ * newer than `b`, <0 if older, 0 if equal. Pre-release / build metadata is
+ * IGNORED (only the numeric core is compared) — sufficient for the announcement
+ * "show only on a forward version change" gate, which never needs to order two
+ * pre-releases of the same core. Returns null if either string isn't valid
+ * semver, so callers can treat anomalous input conservatively.
+ */
+export declare function compareSemverCore(a: string, b: string): number | null;
+//# sourceMappingURL=semver.d.ts.map

package/dist/hooks/auto-update-checker/semver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"semver.d.ts","sourceRoot":"","sources":["../../../src/hooks/auto-update-checker/semver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEtD;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAUrE"}

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

@@ -0,0 +1,158 @@
+import type { ContextDatabase } from "../../features/magic-context/storage";
+import { getPendingOps } from "../../features/magic-context/storage";
+import type { PendingOp, TagEntry } from "../../features/magic-context/types";
+import type { DroppedTokenReduction } from "./dropped-token-estimate";
+import type { TagTarget } from "./tag-messages";
+import type { ToolDropResult } from "./tool-drop-target";
+/**
+ * Agent-initiated (mmc_reduce) and emergency drops of a tool call within the
+ * newest N tool calls keep a structural skeleton when the call's input is
+ * small: the tool_use/tool_result pair survives with its REAL arguments and
+ * the canonical `[dropped §N§]` placeholder as its output (`skeleton_real`).
+ * A large input is removed outright, like a drop outside the window.
+ *
+ * WHY a skeleton: when every recent tool call vanishes from the wire, models
+ * (especially smaller ones) lose the anchors showing what they actually did
+ * and start writing fake tool calls as plain text. Keeping skeletons in the
+ * recent band prevents that. Older drops still remove the full structure.
+ *
+ * WHY real arguments: every synthetic value previously put in the argument
+ * position (5-character clamps, then a `{"dropped": "[dropped §N§]"}` marker)
+ * was copied by models into new calls, which then ran with garbage arguments
+ * or looped on the dropped-input guard's refusal. A dropped call's arguments
+ * are therefore either the real ones or absent. The size rule lives in
+ * tool-input-size.ts.
+ *
+ * CACHE SAFETY: the mode is decided once, at drop time (always a
+ * cache-busting pass), persisted in `tags.drop_mode`, and replayed
+ * byte-identically by `applyFlushedStatuses` on every later pass. A skeleton
+ * is NEVER demoted to a full drop afterwards — that second mutation would be
+ * a mid-prefix rewrite on some later pass (the volatile-boundary bust class).
+ * Emergency drops use the same newest-window skeleton rule as agent drops;
+ * heuristic dedup stays full-drop because dedup keeps the newest duplicate's
+ * full content as the nearby anchor.
+ */
+export declare const RECENT_TOOL_SKELETON_WINDOW = 20;
+export declare function buildReplacementContent(tagId: number): string;
+export interface NewToolDropOutcome {
+    result: ToolDropResult;
+    /** The drop mode to persist so every later pass replays the same bytes. */
+    mode: "skeleton_real" | "skeleton_stripped" | "full";
+}
+/**
+ * Apply a NEW drop of a tool call under the real-or-absent rule and report
+ * the mode to persist:
+ *  1. inside the newest-call window with a small input: keep the call with its
+ *     real arguments, output -> `[dropped §N§]` (`skeleton_real`);
+ *  2. otherwise remove the call and its result (`full`);
+ *  3. except when the call cannot be removed: its result ends the request
+ *     (drop() then keeps it, see ToolMutationBatch.wouldStrandConversationEnd),
+ *     the host adapter cannot remove it structurally, or the caller requires a
+ *     paired skeleton (`keepSkeleton`, e.g. beside native reasoning). Those keep
+ *     the REAL arguments too; nothing is ever written into the argument position.
+ */
+export declare function applyNewToolDrop(target: TagTarget | undefined, options: {
+    inWindow: boolean;
+    keepSkeleton?: boolean;
+}): NewToolDropOutcome;
+/** True when a drop of this call inside the newest-call window keeps real arguments. */
+export declare function hasSmallToolInput(target: TagTarget | undefined): boolean;
+export type ConvertedToolDropMode = "skeleton_real" | "full";
+/**
+ * HARD fold reasons whose trigger already loses the provider's cached prefix
+ * whatever bytes Magic Context serves: a different model has its own cache, a
+ * changed system prompt precedes every message, an idle TTL expiry means the
+ * cache was evicted, and a native host compaction replaced the conversation
+ * after the prefix. Other reasons only bust when the fold changes the served
+ * bytes (see foldChangesServedPrefix).
+ */
+export declare const CACHE_LOSING_FOLD_REASONS: ReadonlySet<string>;
+/**
+ * The cached m[0]/m[1] bytes a pass serves ahead of the conversation tail.
+ * (fork divergence: the upstream mural image field is deleted — this fork
+ * removed the mural feature; see UPSTREAM.md divergence log.)
+ */
+export interface ServedPrefixBytes {
+    m0Bytes: Uint8Array | null;
+    m1Bytes: Uint8Array | null;
+}
+/**
+ * Does a HARD fold change the prefix bytes served ahead of every tool call?
+ * Any difference counts: m[0] or m[1] text. A fold that re-renders both
+ * byte-identically keeps the provider's cached prefix.
+ */
+export declare function foldChangesServedPrefix(before: ServedPrefixBytes, after: ServedPrefixBytes): boolean;
+/**
+ * The single bust permission an executed HARD fold grants. True when the fold
+ * loses the provider's cached prefix anyway: its trigger evicts the cache
+ * (CACHE_LOSING_FOLD_REASONS) or it changes the m[0]/m[1] bytes served
+ * ahead of the tail. A fold that re-renders the prefix byte-identically, such
+ * as a memory epoch bump, an upgrade marker or a mutation-log entry with no
+ * rendered-content change, keeps the provider cache alive, and any lane riding
+ * it would make itself the pass's only bust. Every lane that rides a fold
+ * consults this one decision: legacy skeleton conversion, pending-op drains,
+ * heuristic cleanup, synthetic todo and sentinel first-application. OpenCode
+ * and Pi both call it.
+ */
+export declare function foldBustsServedPrefix(reason: string | null | undefined, before: ServedPrefixBytes, after: ServedPrefixBytes): boolean;
+/**
+ * Convert every dropped tool call that still serves the legacy
+ * `{"dropped": "[dropped §N§]"}` argument marker to the real-or-absent rule,
+ * persisting the new mode, and return the conversions so the caller can render
+ * them on this pass's wire.
+ *
+ * Call this ONLY inside the transaction that records an executing HARD fold.
+ * That pass rebuilds the whole prefix anyway, so the changed bytes ride the
+ * same cache bust; on every other pass the legacy tags keep replaying their
+ * marker byte-identically. Deciding here and persisting the mode means later
+ * passes never re-decide (never demote, never restore).
+ *
+ * Legacy tags are `drop_mode = 'truncated'`, plus `full` tags whose host
+ * adapter cannot remove the call and so replays a marker instead (Pi). Each is
+ * re-decided from its real input: small -> `skeleton_real`; large -> `full`,
+ * unless the call cannot be removed (it ends the request, the adapter cannot
+ * remove it, or it sits beside native reasoning), which keeps real arguments.
+ * The legacy marker was only ever written inside the newest-call window or for
+ * a call that could not be removed, so every legacy tag is re-decided as an
+ * in-window drop. Tags not on this pass's wire stay as they are.
+ *
+ * `keepFullDrop` lets a host exempt `full` tags whose removal it has already
+ * recorded. Pi records the first structural removal of each arc; such a call
+ * was removed, not served as a marker, and it may only look unremovable on this
+ * pass (a model that needs tool pairs beside its reasoning). Converting it
+ * would keep the call on every later pass, including ones that can remove it.
+ */
+export declare function convertLegacyToolSkeletons(db: ContextDatabase, sessionId: string, targets: ReadonlyMap<number, TagTarget>, options?: {
+    keepFullDrop?: (callId: string | null) => boolean;
+}): Map<number, ConvertedToolDropMode>;
+/** Render conversions from convertLegacyToolSkeletons on this pass's wire. */
+export declare function renderConvertedToolSkeletons(targets: ReadonlyMap<number, TagTarget>, converted: ReadonlyMap<number, ConvertedToolDropMode>): boolean;
+export interface PendingOperationBatchDiagnostics {
+    source: "pending" | "synthetic" | "mixed";
+    total: number;
+    mutated: number;
+    persistedWithoutMutation: number;
+    reasons: Record<string, number>;
+}
+export declare function applyPendingOperations(sessionId: string, db: ContextDatabase, targets: Map<number, TagTarget>, 
+/**
+ * Union projection form: protectedTagIds (set form).
+ * Coordinate space: tag-number space (Set<number> of member tool tag numbers).
+ * Empty-window behavior: an empty set means zero tool tags are protected by the window;
+ * non-tool (message/file) tags never become reclaim targets through any window form,
+ * their eligibility remaining decided solely by the independent protections.
+ */
+protectedTagIds: ReadonlySet<number>, preloadedTags?: TagEntry[], preloadedPendingOps?: ReturnType<typeof getPendingOps>, syntheticPendingOps?: PendingOp[], 
+/**
+ * Smart-drops: tag ids to compress as an edit_marker (an edit/write
+ * superseded by a later edit to the same file) instead of a full/skeleton
+ * drop. Synthetic-only: these are selected for the current apply pass;
+ * replay reads the frozen drop_mode, not this set.
+ */
+editMarkerTagIds?: ReadonlySet<number>, 
+/** Reports only reductions that changed the live message representation. */
+onTagReduced?: (reduction: DroppedTokenReduction) => void, 
+/** Reports why selected operations did or did not change the visible payload. */
+onBatchComplete?: (diagnostics: PendingOperationBatchDiagnostics) => void): boolean;
+export declare function applyFlushedStatuses(sessionId: string, db: ContextDatabase, targets: Map<number, TagTarget>, preloadedTags?: TagEntry[]): boolean;
+//# sourceMappingURL=apply-operations.d.ts.map