@gkorepanov/ccodex 0.4.15 → 0.4.16

package/dist/claude/session/session.js

@@ -101,7 +101,7 @@ function commandLane(command) {
         return "control";
     if (["providerEventStarted", "providerEventFinished", "providerBoundary", "providerRetract",
         "conversationReset", "modelFallback", "fastModeStatus", "systemNotice", "runtimeNotification", "mainStream",
-        "accountUsage", "accountCost", "publishUsage", "lifecycle", "compactBoundary", "compactFailed",
+        "accountUsage", "accountCost", "publishUsage", "lifecycle", "autoCompactStarted", "compactBoundary", "compactFailed",
         "postCompact",
     ].includes(command.type))
         return "provider";
@@ -135,6 +135,7 @@ export class ClaudeSession {
     scopes = new Map();
     tasks = new Map();
     compaction;
+    automaticCompaction;
     compactionActions = [];
     lastPublishedUsage;
     lifecycle;
@@ -1342,6 +1343,13 @@ export class ClaudeSession {
             if (status === "requesting") {
                 await this.providerSubmitLifecycle(projection, runtimeGeneration, { type: "request", messageStarted: false });
             }
+            else if (status === "compacting") {
+                await this.submitProviderProjection(runtimeGeneration, {
+                    type: "autoCompactStarted",
+                    runtimeGeneration,
+                    source: this.providerFactSource(projection),
+                });
+            }
             return "stateOnly";
         }
         if (message.type === "system" && message.subtype === "session_state_changed") {
@@ -4499,10 +4507,15 @@ export class ClaudeSession {
                 if (command.runtimeGeneration !== this.runtimeGeneration)
                     return { admitted: false, hidden: false };
                 return {
-                    admitted: command.trigger === "auto" ? !this.compaction && Boolean(this.activeNormalTurn())
+                    admitted: command.trigger === "auto"
+                        ? !this.compaction && Boolean(this.automaticCompaction || this.activeNormalTurn())
                         : Boolean(this.compaction && !this.compaction.cancellation),
                     hidden: Boolean(this.compaction?.hidden),
                 };
+            case "autoCompactStarted":
+                if (command.runtimeGeneration !== this.runtimeGeneration)
+                    return undefined;
+                return this.startAutomaticCompaction(command.runtimeGeneration, command.source);
             case "compactBoundary":
                 if (command.runtimeGeneration !== this.runtimeGeneration)
                     return undefined;
@@ -4528,8 +4541,10 @@ export class ClaudeSession {
                     : this.compactionProjection();
             }
             case "compactFailed":
-                if (command.runtimeGeneration !== this.runtimeGeneration || !this.compaction)
+                if (command.runtimeGeneration !== this.runtimeGeneration)
                     return undefined;
+                if (!this.compaction)
+                    return this.completeAutomaticCompaction(command.source);
                 if (this.compaction.cancellation)
                     return this.compactionProjection();
                 return this.completeCompaction("failed", command.message, command.codexErrorInfo, command.source);
@@ -4869,21 +4884,77 @@ export class ClaudeSession {
         if (this.compaction)
             return this.compactionProjection();
         const record = this.requireRecord(true);
-        const turn = this.activeNormalTurn(record);
+        const automatic = this.automaticCompaction;
+        const turn = automatic
+            ? this.repository.readTurn(this.threadId, automatic.turnId)
+            : this.activeNormalTurn(record);
         if (!turn)
             return undefined;
+        const item = automatic
+            ? turn.items.find((candidate) => candidate.id === automatic.itemId)
+            : undefined;
         const updated = { ...record, lastClaudeMessageUuid: boundary };
-        this.commitState(updated, [{
+        this.commitState(updated, [
+            ...(item?.type === "contextCompaction" ? [{
+                    turnId: turn.id,
+                    method: "item/completed",
+                    params: { item, threadId: this.threadId, turnId: turn.id, completedAtMs: Date.now() },
+                    providerEventId: source.providerEventId,
+                    providerEventType: source.providerEventType,
+                }] : []),
+            {
                 turnId: turn.id,
                 method: "thread/compacted",
                 params: { threadId: this.threadId, turnId: turn.id },
                 providerEventId: source.providerEventId,
                 providerEventType: source.providerEventType,
-            }], turn, false, {
+            },
+        ], turn, false, {
             ownerThreadId: this.threadId,
             turnId: turn.id,
             messageUuid: boundary,
         });
+        if (automatic)
+            this.automaticCompaction = undefined;
+        return { turnId: turn.id, terminal: false };
+    }
+    startAutomaticCompaction(runtimeGeneration, source) {
+        if (this.compaction)
+            return this.compactionProjection();
+        const turn = this.activeNormalTurn();
+        if (!turn)
+            return undefined;
+        if (this.automaticCompaction?.turnId === turn.id) {
+            return { turnId: turn.id, terminal: false };
+        }
+        const item = {
+            type: "contextCompaction",
+            id: uuidv7(),
+        };
+        turn.items.push(item);
+        this.publishTurn(turn, "item/started", {
+            item, threadId: this.threadId, turnId: turn.id, startedAtMs: Date.now(),
+        }, source);
+        this.automaticCompaction = { turnId: turn.id, itemId: item.id, runtimeGeneration };
+        return { turnId: turn.id, terminal: false };
+    }
+    completeAutomaticCompaction(source) {
+        const automatic = this.automaticCompaction;
+        if (!automatic)
+            return undefined;
+        const record = this.requireRecord(false);
+        const turn = this.repository.readTurn(this.threadId, automatic.turnId);
+        const item = turn?.items.find((candidate) => candidate.id === automatic.itemId);
+        if (!turn || item?.type !== "contextCompaction")
+            return undefined;
+        this.commitState(record, [{
+                turnId: turn.id,
+                method: "item/completed",
+                params: { item, threadId: this.threadId, turnId: turn.id, completedAtMs: Date.now() },
+                providerEventId: source.providerEventId,
+                providerEventType: source.providerEventType,
+            }], turn);
+        this.automaticCompaction = undefined;
         return { turnId: turn.id, terminal: false };
     }
     completeCompaction(status, errorMessage, codexErrorInfo, source, boundary) {
@@ -4933,7 +5004,7 @@ export class ClaudeSession {
     }
     activeNormalTurn(record = this.requireRecord(true)) {
         return record.thread.turns.findLast((turn) => turn.status === "inProgress"
-            && !turn.items.some((item) => item.type === "contextCompaction"));
+            && turn.items.some((item) => item.type !== "contextCompaction"));
     }
     startTurn(items, threadPatch = {}, id = uuidv7(), emitEvents = true) {
         const record = this.requireRecord(false);
@@ -5103,7 +5174,21 @@ export class ClaudeSession {
                 updatedAt: turn.completedAt, recencyAt: turn.completedAt,
             },
         };
-        const events = [...terminalEvents.map((event) => ({
+        const automatic = this.automaticCompaction?.turnId === turn.id
+            ? this.automaticCompaction
+            : undefined;
+        const automaticItem = automatic
+            ? turn.items.find((item) => item.id === automatic.itemId)
+            : undefined;
+        const events = [
+            ...(automaticItem?.type === "contextCompaction" ? [{
+                    turnId: turn.id,
+                    method: "item/completed",
+                    params: { item: automaticItem, threadId: this.threadId, turnId: turn.id, completedAtMs: Date.now() },
+                    providerEventId: source.providerEventId,
+                    providerEventType: source.providerEventType,
+                }] : []),
+            ...terminalEvents.map((event) => ({
                 ...event,
                 providerEventId: event.providerEventId ?? source.providerEventId,
                 providerEventType: event.providerEventType ?? source.providerEventType,
@@ -5113,7 +5198,8 @@ export class ClaudeSession {
                 params: { threadId: this.threadId, status: updated.thread.status },
                 providerEventId: source.providerEventId,
                 providerEventType: source.providerEventType,
-            }];
+            }
+        ];
         if (turn.error && emitError)
             events.push({
                 turnId: turn.id,
@@ -5132,6 +5218,8 @@ export class ClaudeSession {
             providerEventType: source.providerEventType,
         });
         this.commitState(updated, events, turn, false, providerBoundary, emitEvents);
+        if (automatic)
+            this.automaticCompaction = undefined;
         return { record: updated, turn };
     }
     goalContext() {