pi-mega-compact 0.21.3 → 0.21.5

package/dist/extensions/mega-runtime/runtime-instrumentation.js

@@ -0,0 +1,171 @@
+import { DEFAULT_SAVED_GOAL } from "../mega-config.js";
+/**
+ * DIAG counters for the "team run doesn't relieve context" investigation.
+ * Plain integers, incremented at the three compaction decision points. They
+ * let a headless test drive the real event handlers and assert the firing
+ * cadence without scraping log files. Inert in production (the live-trim and
+ * before-compact probes also emit logger.info, but these counters are always
+ * updated and cost nothing).
+ */
+export class RuntimeInstrumentation {
+    diagLiveTrimFires = 0; // context handler returned a trimmed view
+    diagLiveTrimReplays = 0; // v0.8.6: trim view returned via cached replay (skipped re-compact)
+    diagBeforeCompactFires = 0; // session_before_compact handler entered
+    diagBeforeCompactSupplied = 0; // session_before_compact supplied our trim
+    diagAgentEndIdle = 0; // agent_end with activeAgents===0
+    diagAgentEndDurable = 0; // agent_end fired ctx.compact() (mid-run durable trim)
+    diagAgentEndDurableSkipRecent = 0; // agent_end skipped ctx.compact() — compaction in last 10s (race guard)
+    // Per-skip-path counters for the team-run diagnosis.
+    diagCtxFastGate = 0; // returned at token fast-gate (below threshold)
+    diagCtxNoCompact = 0; // autoCompactCheck().shouldCompact === false
+    diagCtxDebounce = 0; // debounceUntil not yet elapsed
+    diagCtxRunSkipped = 0; // runCompact() returned skipped
+    diagCtxCutNull = 0; // computeLiveTrimCut returned null (anchor/boundary)
+    diagCtxThrown = 0; // live-trim try threw (caught)
+    diagCtxOutputErrorTrip = 0; // Phase H: output-error catch tripped a forced compaction
+    // Context health instrumentation (v0.12): rolling ring buffers for
+    // drift detection + cache poison Layer 1 hash baseline.
+    recentTurnEmbeddings = [];
+    recentErrorCategories = [];
+    lastPrefixHash = null;
+    lastErrorCategory = null;
+    // Sprint H (Finding 3): a SEPARATE internal-error ring fed by explicit
+    // `recordInternalError(category)` calls at each store/service-write failure
+    // emit site (Option A — NOT a central events.log filter). This captures
+    // internal store-write failures which the API-error `errorRate` ring never
+    // sees. The health-handler computes a distinct `storeErrorRate` 6th axis.
+    // Mirrors `recentErrorCategories` / `lastErrorCategory` exactly (cap = RING_MAX).
+    recentInternalErrors = [];
+    /**
+     * S26 capture instrumentation: the "model_snapshots empty → $0.00 cost card"
+     * bug was invisible because captureModel swallowed the DB write in a silent
+     * `catch {}`. These always-updated counters (zero cost) let a headless test or
+     * a live capture tell whether captureModel ran and whether the snapshot landed.
+     */
+    diagCaptureModelCalls = 0; // captureModel entered with a populated ctx.model
+    diagCaptureModelFails = 0; // recordModelSnapshot threw → model_snapshots stays empty
+    // ── Live display / cache-stability state (moved from runtime.ts shell) ────
+    // v0.8.6 cache-stability: the cached live-trim view for the current
+    // compaction epoch. Set after a fresh runCompact + computeLiveTrimCut, and
+    // replayed verbatim on subsequent gated context events in the SAME epoch
+    // (same checkpointId) so the provider KV-cache prefix stays stable instead
+    // of being invalidated by a freshly regenerated summary + sentinel every
+    // fire. Invalidated on session restart (resetRuntime) and on any native
+    // durable compaction (session_compact) that truncates the transcript.
+    trimCache = null;
+    debounceUntil = 0;
+    // S16: debounce for the agent_end resume nudge (avoid busy-loops).
+    resumeNudgeUntil = 0;
+    // Agent tracking for real-time widget updates
+    activeAgents = 0;
+    currentTurn = 0;
+    // S33: transient MEGA CACHE flare flag (armed by the turn_end scoring hook
+    // when cachePct > 100). Copied into widgetData.megaCacheFlare on the next
+    // snapshot() so the widget renders the oopsie gag, then reset (one cycle).
+    megaCacheFlare = false;
+    /** v0.8.3: ambient effect state for animated panel borders keyed off
+     *  status transitions (level-up, mega-cache overshoot, achievement unlock,
+     *  compaction start). Threaded into widgetData as `activeEffect`; the widget
+     *  computes the per-frame phase from startedAt vs Date.now() (non-expired).
+     *  Null when idle/expired. */
+    activeEffect = null;
+    megaCacheFlarePct = 0;
+    levelUpFlare = false;
+    lastLevel = 0;
+    // S35: transient achievement-unlock flare (armed by the scoring hooks after
+    // evaluateAndUnlockAchievements returns newly-unlocked titles). Copied into
+    // widgetData.achievementFlare on the next snapshot() so the widget renders the
+    // unlock toast, then reset (one cycle — mirrors megaCacheFlare/levelUpFlare).
+    achievementFlare = false;
+    achievementFlareTitles = [];
+    // S33: last cumulative dedup-collapsed count seen by the session_compact
+    // hook, so we only record the DELTA as the dedupe score (leaderboard sums).
+    lastDedupCollapsed = 0;
+    // Recall block produced by auto-inline (resume/branch) that the next
+    // before_agent_start should prepend to the system prompt. Unset after use.
+    pendingRecallBlock;
+    // S21: memory recall block, parallel to pendingRecallBlock. Same one-shot
+    // semantics; composed with the checkpoint block in before_agent_start.
+    pendingMemoryRecallBlock;
+    statusKey; // current status text for dashboard
+    // Active model/provider (for real cost estimation). Captured from ctx.model
+    // on model_select + session_start; persisted to SQL so cost + the dashboard
+    // can read it without a live ctx.
+    currentModel;
+    // Live "what it's doing right now" timestamp, used for the fresh-window.
+    lastActivityAt = 0;
+    // Live per-tier dedup trace (Phase 1): e.g. "L0 ✓ → L1 ✓ → L2 0.91 → stored".
+    // Built from the store's sync onTier callback during a compaction so the user
+    // watches each tier evaluate in real time. Cleared once the outcome settles.
+    tierTrace;
+    // Phase 3 — standout toolbar state.
+    // Recall/activity ticker: a small ring buffer (≤5) of recent compact/recall
+    // events so the widget shows a live history instead of a single last action.
+    ticker = [];
+    TICKER_MAX = 5;
+    // Pulsing status: set true while a compaction is in flight, cleared on result.
+    pulsing = false;
+    // S21.2: set by `applyMemoryOps` when a memory add/replace/remove lands in
+    // the current compaction. The pipeline reads this after a successful compact
+    // to decide whether to fire `consolidateMemories` (skip the work entirely
+    // when no memory rows changed).
+    memoriesTouchedThisCompaction = 0;
+    // Rolling "saved" goal for the progress bar — grows as we save more, so the
+    // bar always has a meaningful denominator (never sits at 100% forever).
+    // Seeded from the %-derived DEFAULT_SAVED_GOAL (low-tier fire point at the
+    // default context window); resetRuntime re-seeds from the live
+    // effectiveThreshold when the window is known. Display-only.
+    savedGoal = DEFAULT_SAVED_GOAL;
+    // Last explain-why line (dedup reason / anchor-kept / superseded), surfaced
+    // while fresh.
+    lastWhy = undefined;
+    // v0.8.8 Perf dashboard instrumentation: turn/provider start timestamps +
+    // the 5s cpu/mem interval handle (one per MegaRuntime, cleared in dispose()).
+    perfTurnStart = 0;
+    perfProviderStart = 0;
+    perfCpuInterval = null;
+    perfCpuBaseline;
+    // Context tracking for the dashboard (updated in the context handler).
+    lastCtxTokens = null;
+    lastCtxPercent = null;
+    lastCtxWindow = 0;
+    // Latest computed widget payload (recomputed per snapshot, rendered per frame).
+    widgetData = null;
+    // v0.8.5: material-change signature from the last full snapshot() body. When
+    // the next snapshot()'s signature matches, the expensive recompute (6 sync
+    // SQLite opens) + writeFileSync(dashboard.json) are skipped — only the
+    // (already-registered) widget factory is refreshed. Kills the per-event
+    // main-thread block during typing/idle streaming with no material change.
+    lastSnapshotSig = null;
+    lastHeartbeatAt = 0;
+    // v0.8.5: bumped whenever the cached game-state memo is evicted (bumpGameState
+    // for in-process /mega-game writes, the fs.watch callback for cross-process
+    // dashboard-server writes, and bindRepo on repo switch) so the snapshot gate
+    // invalidates and the widget re-reads theme/mode after the change.
+    gameStateBump = 0;
+    // Cached cross-repo drift status (recomputed at most every 30s — it opens the
+    // machine-wide registry DB, so we don't want to do it on every render frame).
+    driftCache = null;
+    // S31: cached game-mode state (game_mode_on/theme/tui_display_mode). Lazily
+    // read from the game_state SQLite row on the first widget render, then
+    // memoized until bumpGameState() evicts it (called by /mega-game after a
+    // write) so the widget picks up theme/mode/level changes live without
+    // re-querying the DB on every render frame.
+    cachedGameState;
+    // S32: fs.watch on the current repo's sqlite.db so cross-process writes
+    // (e.g. the dashboard server's PUT /api/game-state, which runs as a detached
+    // child with no MegaRuntime ref) evict the cached game-state memo. Without
+    // this, /mega-game's in-process bumpGameState() is the only eviction trigger
+    // and the widget would keep showing stale theme/mode/toggle after a dashboard
+    // edit until a restart. The watcher tracks currentStateDir — closed + re-opened
+    // by ensureGameStateWatcher() on every bindRepo repo switch. Non-fatal: any
+    // fs.watch failure (missing file / platform issue) is swallowed; the next
+    // getCachedGameState() snapshot re-queries the DB anyway.
+    gameStateWatcher;
+    gameStateWatchDir;
+    // P2: the last ExtensionContext handed to snapshot()/renderWidget(), stashed
+    // so the fs.watch game-state callback can force a widget re-render without
+    // a context event (cross-process dashboard edits while pi is idle). Cleared
+    // implicitly on construction (undefined → watcher skips until first snap).
+    lastWidgetCtx;
+}

package/dist/extensions/mega-runtime/runtime.js

@@ -13,9 +13,10 @@
  */
 import { join } from "node:path";
 import { VectorStore } from "../../src/vectorStore.js";
-import { normalizeSessionId } from "../../src/store.js";
 import { Logger } from "../../src/log.js";
+export { RING_MAX } from "./internal-errors.js";
 import { Dashboard } from "../mega-dashboard.js";
+import { createSessionRuntime } from "./helpers.js";
 import { ensureGameStateWatcherImpl, getCachedGameStateImpl, refreshWidgetGameStateImpl, bumpGameStateImpl, disposeRuntimeImpl, } from "./game-state.js";
 import { setEffectImpl, armMegaCacheFlareImpl, armAchievementFlareImpl, makeTierCallbackImpl, pushTickerImpl, } from "./effects.js";
 import { ensurePerfIntervalImpl } from "./perf.js";
@@ -25,11 +26,13 @@ import { snapshotImpl } from "./runtime-snapshot.js";
 import { pressureImpl, effectiveThresholdImpl, pressureBandImpl, } from "./pressure-getters.js";
 import { resetRuntimeImpl } from "./reset-runtime.js";
 import { appendEventImpl } from "./append-event.js";
+import { recordInternalErrorImpl } from "./internal-errors.js";
+import { RuntimeInstrumentation } from "./runtime-instrumentation.js";
 import { getStateDirImpl } from "./get-state-dir.js";
 import { renderWidgetImpl } from "./render-widget.js";
 import { setStatusImpl } from "./status.js";
 import { engineViewImpl } from "./engine-view.js";
-export class MegaRuntime {
+export class MegaRuntime extends RuntimeInstrumentation {
     config;
     // Store/dashboard/logger are rebound per-repo by bindRepo() so each git repo
     // gets its own isolated state dir. They start bound to the global default.
@@ -39,197 +42,13 @@ export class MegaRuntime {
     activeRepoRoot = null;
     currentStateDir;
     // The only mutable per-session state. Reset on session_start / session_tree.
-    rt = {
-        sessionId: normalizeSessionId(undefined),
-        persistedThisSession: false,
-        lastCheckpointId: undefined,
-        lastCompactedFrom: 0,
-        lastCompactedTokens: 0,
-        dedupSkips: 0,
-        dedupAttempts: 0,
-        tokensSaved: 0,
-        lastCompactAt: null,
-        lastRecallAt: null,
-        lastInjectAt: null,
-        _prevCacheHitPct: null,
-        _lastCacheHealthScore: undefined,
-        lastNativeCompactAt: null,
-        compactCount: 0,
-        recallInjections: 0,
-        cacheHitTokens: 0,
-        lengthStopPending: false,
-        errorRetryCount: 0,
-        errorRetryUntil: 0,
-        consecutiveErrors: 0,
-        lastErrorRetryAt: 0,
-        retryNudgePending: false,
-        errorRetrySessionCount: 0,
-        lastErrorText: undefined,
-        errorTextRepeatCount: 0,
-        poisonedAdviseSent: false,
-        providerOutageAdvised: false,
-        poisonedCompactSignatures: new Set(),
-        // S53: tracks whether withRecallTail injected this turn (consumed at turn_end).
-        recallInjectedThisTurn: false,
-        poisonedCount: 0,
-        extensionInitiatedTurn: false,
-    };
-    // v0.8.6 cache-stability: the cached live-trim view for the current
-    // compaction epoch. Set after a fresh runCompact + computeLiveTrimCut, and
-    // replayed verbatim on subsequent gated context events in the SAME epoch
-    // (same checkpointId) so the provider KV-cache prefix stays stable instead
-    // of being invalidated by a freshly regenerated summary + sentinel every
-    // fire. Invalidated on session restart (resetRuntime) and on any native
-    // durable compaction (session_compact) that truncates the transcript.
-    trimCache = null;
-    debounceUntil = 0;
-    // S16: debounce for the agent_end resume nudge (avoid busy-loops).
-    resumeNudgeUntil = 0;
-    // Agent tracking for real-time widget updates
-    activeAgents = 0;
-    currentTurn = 0;
-    // S33: transient MEGA CACHE flare flag (armed by the turn_end scoring hook
-    // when cachePct > 100). Copied into widgetData.megaCacheFlare on the next
-    // snapshot() so the widget renders the oopsie gag, then reset (one cycle).
-    megaCacheFlare = false;
-    /** v0.8.3: ambient effect state for animated panel borders keyed off
-     *  status transitions (level-up, mega-cache overshoot, achievement unlock,
-     *  compaction start). Threaded into widgetData as `activeEffect`; the widget
-     *  computes the per-frame phase from startedAt vs Date.now() (non-expired).
-     *  Null when idle/expired. */
-    activeEffect = null;
-    megaCacheFlarePct = 0;
-    levelUpFlare = false;
-    lastLevel = 0;
-    // S35: transient achievement-unlock flare (armed by the scoring hooks after
-    // evaluateAndUnlockAchievements returns newly-unlocked titles). Copied into
-    // widgetData.achievementFlare on the next snapshot() so the widget renders the
-    // unlock toast, then reset (one cycle — mirrors megaCacheFlare/levelUpFlare).
-    achievementFlare = false;
-    achievementFlareTitles = [];
-    // S33: last cumulative dedup-collapsed count seen by the session_compact
-    // hook, so we only record the DELTA as the dedupe score (leaderboard sums).
-    lastDedupCollapsed = 0;
-    // Recall block produced by auto-inline (resume/branch) that the next
-    // before_agent_start should prepend to the system prompt. Unset after use.
-    pendingRecallBlock;
-    // S21: memory recall block, parallel to pendingRecallBlock. Same one-shot
-    // semantics; composed with the checkpoint block in before_agent_start.
-    pendingMemoryRecallBlock;
-    statusKey; // current status text for dashboard
-    // Active model/provider (for real cost estimation). Captured from ctx.model
-    // on model_select + session_start; persisted to SQL so cost + the dashboard
-    // can read it without a live ctx.
-    currentModel;
-    // Live "what it's doing right now" timestamp, used for the fresh-window.
-    lastActivityAt = 0;
-    // Live per-tier dedup trace (Phase 1): e.g. "L0 ✓ → L1 ✓ → L2 0.91 → stored".
-    // Built from the store's sync onTier callback during a compaction so the user
-    // watches each tier evaluate in real time. Cleared once the outcome settles.
-    tierTrace;
-    // Phase 3 — standout toolbar state.
-    // Recall/activity ticker: a small ring buffer (≤5) of recent compact/recall
-    // events so the widget shows a live history instead of a single last action.
-    ticker = [];
-    TICKER_MAX = 5;
-    // Pulsing status: set true while a compaction is in flight, cleared on result.
-    pulsing = false;
-    // S21.2: set by `applyMemoryOps` when a memory add/replace/remove lands in
-    // the current compaction. The pipeline reads this after a successful compact
-    // to decide whether to fire `consolidateMemories` (skip the work entirely
-    // when no memory rows changed).
-    memoriesTouchedThisCompaction = 0;
-    // Rolling "saved" goal for the progress bar — grows as we save more, so the
-    // bar always has a meaningful denominator (never sits at 100% forever).
-    savedGoal = 50_000;
-    // Last explain-why line (dedup reason / anchor-kept / superseded), surfaced
-    // while fresh.
-    lastWhy = undefined;
-    // v0.8.8 Perf dashboard instrumentation: turn/provider start timestamps +
-    // the 5s cpu/mem interval handle (one per MegaRuntime, cleared in dispose()).
-    perfTurnStart = 0;
-    perfProviderStart = 0;
-    perfCpuInterval = null;
-    perfCpuBaseline;
-    // Context tracking for the dashboard (updated in the context handler).
-    lastCtxTokens = null;
-    lastCtxPercent = null;
-    lastCtxWindow = 0;
-    // Latest computed widget payload (recomputed per snapshot, rendered per frame).
-    widgetData = null;
-    // v0.8.5: material-change signature from the last full snapshot() body. When
-    // the next snapshot()'s signature matches, the expensive recompute (6 sync
-    // SQLite opens) + writeFileSync(dashboard.json) are skipped — only the
-    // (already-registered) widget factory is refreshed. Kills the per-event
-    // main-thread block during typing/idle streaming with no material change.
-    lastSnapshotSig = null;
-    lastHeartbeatAt = 0;
-    // v0.8.5: bumped whenever the cached game-state memo is evicted (bumpGameState
-    // for in-process /mega-game writes, the fs.watch callback for cross-process
-    // dashboard-server writes, and bindRepo on repo switch) so the snapshot gate
-    // invalidates and the widget re-reads theme/mode after the change.
-    gameStateBump = 0;
-    // Cached cross-repo drift status (recomputed at most every 30s — it opens the
-    // machine-wide registry DB, so we don't want to do it on every render frame).
-    driftCache = null;
-    // S31: cached game-mode state (game_mode_on/theme/tui_display_mode). Lazily
-    // read from the game_state SQLite row on the first widget render, then
-    // memoized until bumpGameState() evicts it (called by /mega-game after a
-    // write) so the widget picks up theme/mode/level changes live without
-    // re-querying the DB on every render frame.
-    cachedGameState;
-    // S32: fs.watch on the current repo's sqlite.db so cross-process writes
-    // (e.g. the dashboard server's PUT /api/game-state, which runs as a detached
-    // child with no MegaRuntime ref) evict the cached game-state memo. Without
-    // this, /mega-game's in-process bumpGameState() is the only eviction trigger
-    // and the widget would keep showing stale theme/mode/toggle after a dashboard
-    // edit until a restart. The watcher tracks currentStateDir — closed + re-opened
-    // by ensureGameStateWatcher() on every bindRepo repo switch. Non-fatal: any
-    // fs.watch failure (missing file / platform issue) is swallowed; the next
-    // getCachedGameState() snapshot re-queries the DB anyway.
-    gameStateWatcher;
-    gameStateWatchDir;
-    // P2: the last ExtensionContext handed to snapshot()/renderWidget(), stashed
-    // so the fs.watch game-state callback can force a widget re-render without
-    // a context event (cross-process dashboard edits while pi is idle). Cleared
-    // implicitly on construction (undefined → watcher skips until first snap).
-    lastWidgetCtx;
-    /**
-     * DIAG counters for the "team run doesn't relieve context" investigation.
-     * Plain integers, incremented at the three compaction decision points. They
-     * let a headless test drive the real event handlers and assert the firing
-     * cadence without scraping log files. Inert in production (the live-trim and
-     * before-compact probes also emit logger.info, but these counters are always
-     * updated and cost nothing).
-     */
-    diagLiveTrimFires = 0; // context handler returned a trimmed view
-    diagLiveTrimReplays = 0; // v0.8.6: trim view returned via cached replay (skipped re-compact)
-    diagBeforeCompactFires = 0; // session_before_compact handler entered
-    diagBeforeCompactSupplied = 0; // session_before_compact supplied our trim
-    diagAgentEndIdle = 0; // agent_end with activeAgents===0
-    diagAgentEndDurable = 0; // agent_end fired ctx.compact() (mid-run durable trim)
-    diagAgentEndDurableSkipRecent = 0; // agent_end skipped ctx.compact() — compaction in last 10s (race guard)
-    // Per-skip-path counters for the team-run diagnosis.
-    diagCtxFastGate = 0; // returned at token fast-gate (below threshold)
-    diagCtxNoCompact = 0; // autoCompactCheck().shouldCompact === false
-    diagCtxDebounce = 0; // debounceUntil not yet elapsed
-    diagCtxRunSkipped = 0; // runCompact() returned skipped
-    diagCtxCutNull = 0; // computeLiveTrimCut returned null (anchor/boundary)
-    diagCtxThrown = 0; // live-trim try threw (caught)
-    // Context health instrumentation (v0.12): rolling ring buffers for
-    // drift detection + cache poison Layer 1 hash baseline.
-    recentTurnEmbeddings = [];
-    recentErrorCategories = [];
-    lastPrefixHash = null;
-    lastErrorCategory = null;
-    /**
-     * S26 capture instrumentation: the "model_snapshots empty → $0.00 cost card"
-     * bug was invisible because captureModel swallowed the DB write in a silent
-     * `catch {}`. These always-updated counters (zero cost) let a headless test or
-     * a live capture tell whether captureModel ran and whether the snapshot landed.
-     */
-    diagCaptureModelCalls = 0; // captureModel entered with a populated ctx.model
-    diagCaptureModelFails = 0; // recordModelSnapshot threw → model_snapshots stays empty
+    // Initialized via createSessionRuntime() (helpers.ts delegate-shell split).
+    rt = createSessionRuntime();
+    // All other field declarations (instrumentation counters, context-health
+    // rings, the Sprint-H internal-error ring, live display / cache-stability
+    // state) live on the RuntimeInstrumentation base class — see
+    // runtime-instrumentation.ts. Field names are unchanged (this.diagXxx,
+    // this.trimCache, this.recentInternalErrors, etc).
     // ---- pressure accessors (bodies in pressure-getters.ts) -------------------
     /** Live 0–1 pressure — see `pressureImpl` in pressure-getters.ts for the
      *  dual-basis (percent vs token) reconciliation notes. Thin delegate. */
@@ -247,6 +66,7 @@ export class MegaRuntime {
         return pressureBandImpl(this);
     }
     constructor(config) {
+        super();
         this.config = config;
         this.store = new VectorStore({
             dedupSim: config.dedupSim,
@@ -299,6 +119,20 @@ export class MegaRuntime {
     appendEvent(event, fields) {
         appendEventImpl(this, event, fields);
     }
+    /**
+     * Sprint H (Finding 3 / Option A): record an internal store/service-write
+     * failure category into the `recentInternalErrors` ring. Called AT each
+     * failure emit site (see the §2.3a audit in
+     * docs/specs/c2-resume-and-health-fixes.md) — never by a central log filter.
+     * Mirrors `recentErrorCategories` (cap = RING_MAX, shift when over).
+     *
+     * NOTE (process boundary): the ring is per-runtime / in-memory. A child
+     * subprocess's failures do NOT reach the parent's ring; the parent-side
+     * dashboard already aggregates events.log cross-process, so nothing is lost.
+     */
+    recordInternalError(category) {
+        recordInternalErrorImpl(this, category);
+    }
     /** S21: state dir of the currently bound repo (where memories live) — thin
      *  delegate to `getStateDirImpl` (get-state-dir.ts). */
     getStateDir() {

package/dist/extensions/mega-runtime/state.js

@@ -5,4 +5,4 @@
  * every existing `import { MegaRuntime } from "./state.js"` continues to
  * resolve without changes.
  */
-export { MegaRuntime } from "./runtime.js";
+export { MegaRuntime, RING_MAX } from "./runtime.js";

package/dist/extensions/mega-runtime/widget.js

@@ -85,7 +85,7 @@ export function buildWidgetLines(wd, width, activeAgents) {
         `${C.gray}all-time${C.reset} ${fmtTokens(wd.repoIn)}→${fmtTokens(wd.repoKept)} kept ${C.blue}(${wd.rTxt}% freed)${C.reset}`,
         `${wd.repoChk} chk/${wd.repoSess} sess`,
         `${C.gray}mem${C.reset} ${wd.embedderName} · ${wd.chk} chunks · ${C.blue}comp ${wd.compStr}${C.reset}`,
-        `${C.gray}drift${C.reset} ${wd.driftStatus === "ok" ? C.green : C.amber}${wd.driftStatus}${C.reset}`,
+        `${C.gray}comp lag${C.reset} ${wd.driftStatus === "ok" ? C.green : C.amber}${wd.driftStatus}${C.reset}`,
         `${C.gray}compact${C.reset} ${sinceCompactStr(wd.sinceCompact)}`,
         ...(wd.perTurnCacheHitPct != null
             ? [

package/dist/extensions/mega-turn-store.js

@@ -24,6 +24,10 @@ function storeFor(stateDir) {
     }
     return s;
 }
+/** Read-only view of the turn store for a state dir (e.g. nextTurnIndexFor). */
+export function turnReaderFor(stateDir) {
+    return storeFor(stateDir).asReader();
+}
 /** Map a legacy RecallSource onto the contract `TurnRecallEntry.source` enum. */
 function mapSource(s) {
     switch (s) {
@@ -52,6 +56,7 @@ export function recordTurnWrite(config, input, stateDir) {
         conversationId: input.conversationId,
         sessionId: input.sessionId,
         turnIndex: input.turnIndex,
+        sessionTurnIndex: input.sessionTurnIndex,
         role: input.role,
         endedAt: input.endedAt ?? input.startedAt ?? Date.now(),
         ctxTokens: input.ctxTokens,

package/dist/src/bridge/factory.js

@@ -136,6 +136,10 @@ export function createMegaBridge(opts) {
                 if (e instanceof ForkError) {
                     return { error: e.code };
                 }
+                // The bridge is pi-agnostic (no runtime handle) — the host-side adapter
+                // (ithacus) owns the internal-error ring for fork failures, so this
+                // re-thrown non-ForkError is recorded there, not here.
+                // guardrails-allow INTERNAL-ERR: bridge is pi-agnostic; no runtime handle — host adapter records fork failures
                 throw e;
             }
         },
@@ -155,16 +159,26 @@ export function createMegaBridge(opts) {
             }, null, stateDir);
         },
         recordTurn(input) {
+            // S49R: child turns get the conversation-monotonic index (MAX+1) so a
+            // re-dispatched child (same conversation, restarted session counter) never
+            // collides with UNIQUE(conversation_id, turn_index). Carry the child's
+            // session counter as sessionTurnIndex for the raw_transcript join.
+            const turnIndex = getTurnStore().asReader().nextTurnIndexFor(input.conversationId);
             const turn = {
                 conversationId: input.conversationId,
                 sessionId: input.sessionId,
-                turnIndex: input.turnIndex,
+                turnIndex,
+                sessionTurnIndex: input.turnIndex,
                 role: input.role ?? "assistant",
                 endedAt: input.endedAt ?? Date.now(),
                 ctxTokens: input.ctxTokens,
                 ctxPercent: input.ctxPercent,
                 model: input.model,
             };
+            // The bridge is pi-agnostic (no runtime handle); the host-side adapter
+            // (ithacus) owns the internal-error ring for appendTurn failures. The
+            // recordTurn child-path twin of Finding 2 is recorded there, not here.
+            // guardrails-allow INTERNAL-ERR: bridge is pi-agnostic; no runtime handle — host adapter records appendTurn failures
             getTurnStore().asWriter().appendTurn(turn);
         },
         close() {

package/dist/src/compact-summary.js

@@ -0,0 +1,99 @@
+function truncate(s, max) {
+    return s.length <= max ? s : `${s.slice(0, max)}…`;
+}
+function summarizeBlock(m) {
+    if (m.role === "tool")
+        return `tool_result ${m.toolName ?? "?"}: ${truncate(m.output ?? m.text, 160)}`;
+    if (m.toolName)
+        return `tool_use ${m.toolName}(${truncate(m.input ?? "", 160)})`;
+    return truncate(m.text, 160);
+}
+function stripTag(block, tag) {
+    const start = `<${tag}>`;
+    const end = `</${tag}>`;
+    const s = block.indexOf(start);
+    const e = block.indexOf(end);
+    if (s === -1 || e === -1)
+        return block;
+    return block.slice(0, s) + block.slice(e + end.length);
+}
+function extractTag(block, tag) {
+    const s = block.indexOf(`<${tag}>`);
+    const e = block.indexOf(`</${tag}>`);
+    if (s === -1 || e === -1)
+        return undefined;
+    return block.slice(s + `<${tag}>`.length, e);
+}
+/** Normalize a raw summary into user-facing "Summary: ..." text. */
+export function formatCompactSummary(summary) {
+    const withoutAnalysis = stripTag(summary, "analysis");
+    let formatted = withoutAnalysis;
+    const content = extractTag(withoutAnalysis, "summary");
+    if (content !== undefined) {
+        formatted = withoutAnalysis.replace(`<summary>${content}</summary>`, `Summary:\n${content.trim()}`);
+    }
+    return formatted.replace(/\n{3,}/g, "\n\n").trim();
+}
+/** Extract the prior "highlights" + "timeline" sections from an existing summary. */
+export function extractSummaryHighlights(summary) {
+    const lines = formatCompactSummary(summary).split("\n");
+    const out = [];
+    let inTimeline = false;
+    for (const line of lines) {
+        const t = line.trimEnd();
+        if (!t || t === "Summary:" || t === "Conversation summary:")
+            continue;
+        if (t === "- Key timeline:") {
+            inTimeline = true;
+            continue;
+        }
+        if (inTimeline)
+            continue;
+        out.push(t);
+    }
+    return out;
+}
+export function extractSummaryTimeline(summary) {
+    const lines = formatCompactSummary(summary).split("\n");
+    const out = [];
+    let inTimeline = false;
+    for (const line of lines) {
+        const t = line.trimEnd();
+        if (t === "- Key timeline:") {
+            inTimeline = true;
+            continue;
+        }
+        if (!inTimeline)
+            continue;
+        if (!t)
+            break;
+        out.push(t);
+    }
+    return out;
+}
+/** Merge an existing compact summary with a new one (accumulate, don't overwrite). */
+export function mergeCompactSummaries(existing, newSummary) {
+    if (!existing)
+        return newSummary;
+    const prevHighlights = extractSummaryHighlights(existing);
+    const newHighlights = extractSummaryHighlights(formatCompactSummary(newSummary));
+    const newTimeline = extractSummaryTimeline(formatCompactSummary(newSummary));
+    const lines = ["<summary>", "Conversation summary:"];
+    if (prevHighlights.length) {
+        lines.push("- Previously compacted context:");
+        prevHighlights.forEach((l) => lines.push(`  ${l}`));
+    }
+    if (newHighlights.length) {
+        lines.push("- Newly compacted context:");
+        newHighlights.forEach((l) => lines.push(`  ${l}`));
+    }
+    if (newTimeline.length) {
+        lines.push("- Key timeline:");
+        newTimeline.forEach((l) => lines.push(`  ${l}`));
+    }
+    lines.push("</summary>");
+    return lines.join("\n");
+}
+// Private helpers re-exported for the shell's summarizeMessages (which stays
+// in compact.ts because it depends on the inference helpers there).
+export { truncate, summarizeBlock };