@ponythewhite/base-context 1.0.14 → 1.0.16

package/dist/core/session-manager.js

@@ -39,7 +39,8 @@ const COMPACTION_BOOKKEEPING_ENTRY_TYPES = new Set([
 ]);
 function isCompactionBookkeeping(entry) {
     return (COMPACTION_BOOKKEEPING_ENTRY_TYPES.has(entry.type) ||
-        (entry.type === "custom_message" && entry.customType === COMPACTION_OUTCOME_CUSTOM_TYPE));
+        (entry.type === "custom_message" && entry.customType === COMPACTION_OUTCOME_CUSTOM_TYPE) ||
+        (entry.type === "custom" && entry.customType === "job_watch_state"));
 }
 // Entry types that can represent user intent (vs. daemon bookkeeping like
 // session_state/agent_status/git_state/child_usage_attributed). Used by
@@ -1932,6 +1933,13 @@ export class SessionManager {
             this.sessionFile === sessionFile &&
             state.branchSelectionRevision === selectionRevision;
     }
+    /** Capture content ownership, ignoring bookkeeping and allowing the caller's known ACKed content appends. */
+    captureCompactionContentOwner() {
+        const sourceIsCurrent = this.captureCompactionSourceOwner();
+        const state = this.writeState;
+        const revision = state.compactionRevision;
+        return (ownAppends = 0) => sourceIsCurrent() && state.compactionRevision === revision + ownAppends;
+    }
     bindCompactionSink(limits = DEFAULT_MANAGER_HISTORY_LIMITS) {
         const state = this.writeState;
         const owner = state.owner;
@@ -2012,6 +2020,10 @@ export class SessionManager {
             isCurrent: () => isCurrent(currentRevision),
             readHistory: (read) => sink.readHistory((history) => read(history.branchContext)),
             [readCopiedEpochSource]: (read) => sink.readHistory(read),
+            readCompactionEntries: (entryIds) => {
+                const ids = [...new Set(entryIds)];
+                return sink.readHistory((history) => this._readCompactionEntriesAt(history, ids, capturedLimits));
+            },
             readBranch: async () => {
                 if (indexed)
                     return sink.readHistory(async (history) => (await this._readBranchesAt(history, [history.source.leafId], capturedLimits)).branches[0]);
@@ -2893,6 +2905,59 @@ export class SessionManager {
             return entries;
         });
     }
+    async _readCompactionEntriesAt(history, entryIds, limits) {
+        const { maxEntries, maxSourceBytes } = limits;
+        if (!Number.isSafeInteger(maxEntries) ||
+            maxEntries <= 0 ||
+            !Number.isSafeInteger(maxSourceBytes) ||
+            maxSourceBytes <= 0)
+            throw new Error("Invalid compaction source limits");
+        if (entryIds.length > maxEntries)
+            throw new Error("Compaction entry budget exceeded");
+        const selected = new Set(entryIds);
+        const references = [];
+        for (const id of entryIds) {
+            const reference = await history.branchContext.get(id);
+            if (!reference)
+                throw new Error("Compaction entry is outside its captured branch");
+            references.push(reference);
+        }
+        references.sort((a, b) => a.sequence - b.sequence);
+        // Pinned older views cannot cross an omitted message to become a chronological cut.
+        // Walk metadata only: excluded lifetime payloads must not consume the hydration budget.
+        const suffixAnchors = new Set();
+        const visited = new Set();
+        let current = history.source.leafId;
+        let leafKind;
+        while (current !== null) {
+            if (visited.has(current))
+                throw new Error("Compaction parent path is unresolved");
+            visited.add(current);
+            const reference = await history.branchContext.get(current);
+            if (!reference)
+                throw new Error("Compaction parent path is unresolved");
+            leafKind ??= reference.kind;
+            if (["message", "custom_message", "branch_summary"].includes(reference.kind)) {
+                if (!selected.has(reference.id))
+                    break;
+                suffixAnchors.add(reference.id);
+            }
+            current = reference.parentId;
+        }
+        const entries = [];
+        let sourceBytes = 0;
+        for (const reference of references) {
+            const remaining = maxSourceBytes - sourceBytes;
+            sourceBytes += reference.locator.length;
+            if (sourceBytes > maxSourceBytes)
+                throw new Error("Compaction source byte budget exceeded");
+            const value = await history.hydrateEntry(reference.id, remaining);
+            if (!value)
+                throw new Error("Compaction entry source is unavailable");
+            entries.push(withEntryRetention(value.entry, value.source.retention, value.source.qualification));
+        }
+        return { entries, suffixAnchors, leafKind };
+    }
     async _readBranchesAt(history, leafIds, limits) {
         const { maxEntries, maxSourceBytes } = limits;
         if (!Number.isSafeInteger(maxEntries) ||