@pikiloom/kernel 0.3.12 → 0.3.14

package/dist/contracts/driver.d.ts

@@ -55,6 +55,10 @@ export type DriverEvent = {
 } | {
     type: 'activity';
     line: string;
+} | {
+    type: 'compaction';
+    trigger: 'auto' | 'manual';
+    atTokens?: number | null;
 };
 export type SteerFn = (prompt: string, attachments?: string[]) => Promise<boolean>;
 export interface DriverContext {

package/dist/drivers/claude.js

@@ -468,6 +468,15 @@ export function handleClaudeEvent(ev, s, emit) {
         }
         s.model = ev.model ?? s.model;
         s.contextWindow = claudeEffectiveContextWindow(claudeContextWindowFromModel(s.model)) ?? s.contextWindow;
+        // Claude compacted the running context (subtype `compact_boundary`): `trigger` is
+        // `auto` (the context filled up) or `manual` (a `/compact` command). Surface it live
+        // so a terminal can show a "compacting" affordance; the compacted summary itself lands
+        // in the native transcript and settles into a divider separately.
+        if (ev.subtype === 'compact_boundary') {
+            const meta = (ev.compact_metadata ?? {});
+            emit({ type: 'compaction', trigger: meta.trigger === 'manual' ? 'manual' : 'auto', atTokens: typeof meta.pre_tokens === 'number' ? meta.pre_tokens : null });
+            return;
+        }
         // Live thinking progress (system/thinking_tokens, ~every 1.4s of sustained thinking): during
         // extended thinking a subscription account streams no plaintext (signature_delta only) and no
         // usage until the message settles, so without projecting these the terminal shows a dead

package/dist/drivers/codex.js

@@ -320,6 +320,9 @@ export class CodexDriver {
                 state.sessionId = threadId;
                 ctx.emit({ type: 'session', sessionId: threadId });
             }
+            // Codex emits no explicit compaction event, so track peak occupancy: a sharp
+            // mid-turn drop is an auto-compaction, surfaced as a live `compaction` signal.
+            let compactPeakTokens = 0;
             srv.onNotification((method, params) => {
                 if (params?.threadId && params.threadId !== state.sessionId && method !== 'turn/started')
                     return;
@@ -444,6 +447,21 @@ export class CodexDriver {
                     case 'thread/tokenUsage/updated': {
                         applyCodexTokenUsage(state, params?.tokenUsage || params?.usage);
                         ctx.emit({ type: 'usage', usage: codexUsageOf(state) });
+                        // No explicit boundary event: a sharp drop from a high peak IS a compaction.
+                        // Conservative thresholds (peak ≥ 50% of window, drop ≥ 25% of window) so
+                        // ordinary turn churn never trips it; re-baseline so it fires once per drop.
+                        {
+                            const cw = state.contextWindow ?? 0;
+                            const used = state.contextUsed ?? 0;
+                            if (cw > 0 && used >= 0) {
+                                if (used > compactPeakTokens)
+                                    compactPeakTokens = used;
+                                else if (compactPeakTokens / cw >= 0.5 && (compactPeakTokens - used) / cw >= 0.25) {
+                                    ctx.emit({ type: 'compaction', trigger: 'auto', atTokens: compactPeakTokens });
+                                    compactPeakTokens = used;
+                                }
+                            }
+                        }
                         break;
                     }
                     case 'turn/completed': {

package/dist/protocol/index.d.ts

@@ -86,6 +86,14 @@ export interface UniversalSnapshot {
     toolCalls?: UniversalToolCall[];
     subAgents?: UniversalSubAgent[];
     usage?: UniversalUsage | null;
+    /** Set when the CLI compacted the context mid-turn (its `compact_boundary`
+     *  event). `trigger` separates an automatic (context-full) compaction from a
+     *  manual `/compact`. Drives a live "compacting" affordance; because a runner
+     *  owns one turn, it naturally clears on the next turn. */
+    compaction?: {
+        trigger: 'auto' | 'manual';
+        atTokens?: number | null;
+    } | null;
     artifacts?: UniversalArtifact[];
     interactions?: UniversalInteraction[];
     queued?: UniversalQueuedTask[];

package/dist/runtime/session-runner.js

@@ -96,6 +96,9 @@ export class SessionRunner {
             case 'usage':
                 this.snapshot.usage = mergeUsage(this.snapshot.usage, e.usage);
                 break;
+            case 'compaction':
+                this.snapshot.compaction = { trigger: e.trigger, atTokens: e.atTokens ?? null };
+                break;
             // toolCalls is the structured SSOT; activity is its derived human-readable view.
             // A driver that streams explicit `activity` lines (e.g. echo) owns activity directly;
             // any driver that emits structured tool/subagent events gets the projection for free.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikiloom/kernel",
-  "version": "0.3.12",
+  "version": "0.3.14",
   "description": "Heterogeneous coding agents (Claude / Codex / Gemini / ACP) -> an interaction-friendly, accumulating session snapshot + control handle, over pluggable surfaces (IM, Web, tunnel, TUI). The reusable core pikiloom itself is built on.",
   "type": "module",
   "license": "MIT",