@ponythewhite/base-context 1.0.14 → 1.0.15

package/dist/bundle/{chunk-SX7CAXWU.js → chunk-RQFC34FM.js}

@@ -27268,7 +27268,7 @@ function formatPathRelativeToCwdOrAbsolute(filePath, cwd) {
 }
 
 // dist/core/session-manager.js
-import { isDeepStrictEqual as isDeepStrictEqual2 } from "node:util";
+import { isDeepStrictEqual as isDeepStrictEqual3 } from "node:util";
 import { randomUUID as randomUUID7 } from "crypto";
 import { existsSync as existsSync8, readdirSync as readdirSync4, readFileSync as readFileSync6, realpathSync as realpathSync3, statSync as statSync5 } from "fs";
 import { opendir, open as openFile, stat } from "fs/promises";
@@ -27688,6 +27688,7 @@ function stringifyBoundedJson(value, maxBytes) {
 // dist/core/inference-coordinator.js
 import { randomUUID as randomUUID5 } from "node:crypto";
 import { setTimeout as delay2 } from "node:timers/promises";
+import { isDeepStrictEqual } from "node:util";
 
 // dist/core/resource-view.js
 var RESOURCE_VIEW_CUSTOM_TYPE = "native_resource_view";
@@ -33704,6 +33705,7 @@ var InferenceCoordinator = class _InferenceCoordinator {
       }) : void 0;
       let publicAccepted = false;
       let selectedContextEpoch;
+      let preparedRequest;
       const attempts = {
         ...responsesMessageIds ? { responsesMessageIds } : {},
         ...requiredPublic ? {
@@ -33715,6 +33717,9 @@ var InferenceCoordinator = class _InferenceCoordinator {
         ...budget || canSelect ? {
           prepareRequest: async (representation, projection, countInput) => {
             try {
+              if (!projection && preparedRequest && isDeepStrictEqual(representation, preparedRequest))
+                return;
+              preparedRequest = void 0;
               selectedContextEpoch = void 0;
               publicAccepted = false;
               if (JSON.parse(representation.body).model !== model.id)
@@ -33732,8 +33737,10 @@ var InferenceCoordinator = class _InferenceCoordinator {
                 if (budget && assessment)
                   budget.assert(assessment);
                 const accepted = await prepareFixedRequestView(boundary, representation, projection, assessment);
-                if (accepted)
+                if (accepted) {
                   selectedContextEpoch = Object.freeze({ ...accepted });
+                  preparedRequest = structuredClone(representation);
+                }
                 return;
               }
               return await selectRequestView({
@@ -33741,8 +33748,10 @@ var InferenceCoordinator = class _InferenceCoordinator {
                 ...responsesMessageIds ? { responseItemIdentity: this.work.responsesIdentity } : {},
                 commit: async (candidate) => {
                   const accepted = await boundary.commit(candidate);
-                  if (accepted)
+                  if (accepted) {
                     selectedContextEpoch = Object.freeze({ ...accepted });
+                    preparedRequest = structuredClone(candidate.request);
+                  }
                   publicAccepted = Boolean(accepted && candidate.publicMessages && candidate.projection.publicWindow && !candidate.projection.pendingPublicMessageGroups?.length);
                   return accepted || void 0;
                 }
@@ -34512,18 +34521,20 @@ ${previousSummary}
   const textContent = response.content.filter((c) => c.type === "text").map((c) => c.text).join("\n");
   return captureSummarySlice({ summary: textContent, usage: response.usage }, requests, completion, "history");
 }
-function prepareViewCompaction(messages, entryIds, pathEntries, settings, maxCutEntryId, allowShortSession = false, budgetPressure = false) {
+function prepareViewCompaction(messages, entryIds, pathEntries, settings, maxCutEntryId, allowShortSession = false, budgetPressure = false, capturedSuffixAnchors) {
   if (messages.length !== entryIds.length)
     throw new Error("Compaction views do not match their source anchors");
   const selectedIds = new Set(entryIds);
-  const suffixAnchors = /* @__PURE__ */ new Set();
-  for (let index = pathEntries.length - 1; index >= 0; index--) {
-    const entry = pathEntries[index];
-    if (!getMessageFromEntryForCompaction(entry))
-      continue;
-    if (!selectedIds.has(entry.id))
-      break;
-    suffixAnchors.add(entry.id);
+  const suffixAnchors = new Set(capturedSuffixAnchors);
+  if (!capturedSuffixAnchors) {
+    for (let index = pathEntries.length - 1; index >= 0; index--) {
+      const entry = pathEntries[index];
+      if (!getMessageFromEntryForCompaction(entry))
+        continue;
+      if (!selectedIds.has(entry.id))
+        break;
+      suffixAnchors.add(entry.id);
+    }
   }
   let cuts = messages.flatMap((message2, index) => entryIds[index] && suffixAnchors.has(entryIds[index]) && message2.role !== "toolResult" && message2.role !== "compactionSummary" ? [index] : []);
   let relaxRetention = false;
@@ -34794,7 +34805,7 @@ ${TURN_PREFIX_SUMMARIZATION_PROMPT}`;
 }
 
 // dist/core/context-epoch-copy.js
-import { isDeepStrictEqual } from "node:util";
+import { isDeepStrictEqual as isDeepStrictEqual2 } from "node:util";
 var readCopiedEpochSource = /* @__PURE__ */ Symbol("readCopiedEpochSource");
 function captureEpochCopyEntry(entry, source) {
   const updateTarget = entry.type === "message" ? entry.message.role === "assistant" ? { kind: "assistant-usage", targetId: entry.id } : entry.message.role === "toolResult" && entry.message.toolName === "ipython" ? { kind: "ipython-sent-message", toolCallId: entry.message.toolCallId } : void 0 : void 0;
@@ -34895,7 +34906,7 @@ async function rebuildCopiedContextEpoch(history, copied, limits, metadataMaxByt
   await prefix(checkpoint.source);
   const copyReference = async (pinned) => {
     const old = oldById.get(pinned.ref.entryId);
-    if (!old || old.revision !== pinned.ref.revision || old.sequence !== pinned.ref.sequence || old.kind !== pinned.ref.kind || !isDeepStrictEqual(old.locator, pinned.ref.locator))
+    if (!old || old.revision !== pinned.ref.revision || old.sequence !== pinned.ref.sequence || old.kind !== pinned.ref.kind || !isDeepStrictEqual2(old.locator, pinned.ref.locator))
       throw new Error("Copied epoch recipe does not match its captured source");
     const read2 = await prefix(pinned.source);
     const actual = await read2.get(old.id);
@@ -34918,7 +34929,7 @@ async function rebuildCopiedContextEpoch(history, copied, limits, metadataMaxByt
         throw new Error("Copied epoch frozen revisions are unavailable");
       const updates = old.updateTarget ? (await read2.contextUpdates(old.updateTarget)).refs : [];
       const expected = original.slice(1).map((revision) => oldByRevision.get(revision));
-      if (expected.some((source) => !source || source.sequence > pinned.source.sourceSequence) || !isDeepStrictEqual(expected.map((source) => source.id), updates.map((source) => source.entryId)))
+      if (expected.some((source) => !source || source.sequence > pinned.source.sourceSequence) || !isDeepStrictEqual2(expected.map((source) => source.id), updates.map((source) => source.entryId)))
         throw new Error("Copied epoch update sources were not preserved");
       sourceRevision = JSON.stringify([actual.revision, ...updates.map((update) => update.revision)]);
     } else if (pinned.sourceRevision !== old.revision || pinned.retainedMessageCount === void 0) {
@@ -37866,6 +37877,10 @@ var SessionManager = class _SessionManager {
       isCurrent: () => isCurrent(currentRevision),
       readHistory: (read2) => sink.readHistory((history) => read2(history.branchContext)),
       [readCopiedEpochSource]: (read2) => sink.readHistory(read2),
+      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]);
@@ -37972,7 +37987,7 @@ var SessionManager = class _SessionManager {
           throw new Error("Session journal requires explicit legacy migration");
         const snapshot = await source;
         const request = JSON.parse(stringifyBoundedJson(event, 1024 * 1024));
-        if (!isDeepStrictEqual2(request.source, snapshot))
+        if (!isDeepStrictEqual3(request.source, snapshot))
           throw new Error("Request event does not match its bound source");
         const id = `${request.attemptId}:${request.type}`;
         const entry = {
@@ -37985,7 +38000,7 @@ var SessionManager = class _SessionManager {
         const json = stringifyBoundedJson(entry, 1024 * 1024 - 1);
         if (indexed) {
           await this._appendIndexedEntry(state, entry, true, void 0, (existing) => {
-            if (existing.type !== "request" || !isDeepStrictEqual2(existing.request, request))
+            if (existing.type !== "request" || !isDeepStrictEqual3(existing.request, request))
               throw new Error(`Conflicting request event: ${id}`);
             return existing;
           }, false);
@@ -37994,7 +38009,7 @@ var SessionManager = class _SessionManager {
         await this._enqueue(state, Buffer.byteLength(json), async () => {
           const existing = byId.get(id);
           if (existing) {
-            if (existing.type !== "request" || !isDeepStrictEqual2(existing.request, request))
+            if (existing.type !== "request" || !isDeepStrictEqual3(existing.request, request))
               throw new Error(`Conflicting request event: ${id}`);
             return;
           }
@@ -38017,7 +38032,7 @@ var SessionManager = class _SessionManager {
     };
     if (persistent && indexed && writer?.format === "framed") {
       const capture = (association) => {
-        if (!outputSource || !ownsOutputSource() || !isDeepStrictEqual2(association.source, outputSource))
+        if (!outputSource || !ownsOutputSource() || !isDeepStrictEqual3(association.source, outputSource))
           return void 0;
         return structuredClone(association);
       };
@@ -38711,6 +38726,54 @@ var SessionManager = 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, b2) => a.sequence - b2.sequence);
+    const suffixAnchors = /* @__PURE__ */ new Set();
+    const visited = /* @__PURE__ */ 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) || maxEntries <= 0 || !Number.isSafeInteger(maxSourceBytes) || maxSourceBytes <= 0)
@@ -41585,7 +41648,7 @@ import { randomUUID as randomUUID12 } from "node:crypto";
 import { existsSync as existsSync24, mkdirSync as mkdirSync8, mkdtempSync as mkdtempSync2 } from "node:fs";
 import { tmpdir as tmpdir9 } from "node:os";
 import { basename as basename10, dirname as dirname18, join as join29, resolve as resolve13 } from "node:path";
-import { isDeepStrictEqual as isDeepStrictEqual4 } from "node:util";
+import { isDeepStrictEqual as isDeepStrictEqual5 } from "node:util";
 
 // dist/utils/sleep.js
 function sleep(ms, signal) {
@@ -46096,7 +46159,7 @@ async function loadExtensionModule(extensionPath) {
     // (file-path aliases would load a second, divergent copy of each package).
     // Also disable tryNative so jiti handles ALL imports (not just the entry point)
     // Node/dev must also share the native AI registry and implementation identities.
-    ...isBunBinary || isBundledCli ? { virtualModules: (await import("./bundled-modules-UODO7ZR7.js")).VIRTUAL_MODULES, tryNative: false } : {
+    ...isBunBinary || isBundledCli ? { virtualModules: (await import("./bundled-modules-O67MEO74.js")).VIRTUAL_MODULES, tryNative: false } : {
       alias: getAliases(),
       virtualModules: {
         "@ponythewhite/base-context-ai": src_exports,
@@ -47387,7 +47450,7 @@ import { randomUUID as randomUUID11 } from "node:crypto";
 import { closeSync as closeSync5, existsSync as existsSync18, fstatSync as fstatSync2, mkdirSync as mkdirSync6, openSync as openSync4, readSync as readSync3, renameSync as renameSync4, statSync as statSync9, unlinkSync as unlinkSync2, writeFileSync as writeFileSync6 } from "node:fs";
 import { appendFile, mkdir as mkdir2 } from "node:fs/promises";
 import { join as join25 } from "node:path";
-import { isDeepStrictEqual as isDeepStrictEqual3 } from "node:util";
+import { isDeepStrictEqual as isDeepStrictEqual4 } from "node:util";
 var REFINEMENT_CUSTOM_TYPE = "prime-agent.refinement";
 var REFINE_SKILL_NAME = "refine";
 var HARNESS_STATE_DIR_NAME = "harness";
@@ -48114,7 +48177,7 @@ function applyRefinementProposal(state, proposal, options) {
     rollbackOf: options.rollbackOf,
     scope: options.scope
   };
-  if (application && state === application.state && options.id === application.native.id && options.scope === application.scope && options.rollbackOf === void 0 && options.baselineState === application.native.baselineState && matchesNativePlannerPlan(application.plan, application.native) && matchesPlannerOptions(application.options, application.native.options) && isDeepStrictEqual3(proposal, application.projection)) {
+  if (application && state === application.state && options.id === application.native.id && options.scope === application.scope && options.rollbackOf === void 0 && options.baselineState === application.native.baselineState && matchesNativePlannerPlan(application.plan, application.native) && matchesPlannerOptions(application.options, application.native.options) && isDeepStrictEqual4(proposal, application.projection)) {
     nativePlannerResults.set(result, { native: application.native, scope: application.scope, edits: appliedEdits });
   }
   return result;
@@ -48162,7 +48225,7 @@ var nativePlannerPlans = /* @__PURE__ */ new WeakMap();
 var nativePlannerApplications = /* @__PURE__ */ new WeakMap();
 var nativePlannerResults = /* @__PURE__ */ new WeakMap();
 function matchesNativePlannerPlan(plan, native) {
-  return plan.proposal === native.proposal && plan.id === native.id && plan.rollbackOf === void 0 && plan.rollbackScope === void 0 && plan.baselineState === native.baselineState && isDeepStrictEqual3(plan.proposal, native.projection);
+  return plan.proposal === native.proposal && plan.id === native.id && plan.rollbackOf === void 0 && plan.rollbackScope === void 0 && plan.baselineState === native.baselineState && isDeepStrictEqual4(plan.proposal, native.projection);
 }
 function matchesPlannerOptions(options, captured) {
   return options.instructions === captured.instructions && options.global === captured.global && options.rollbackId === captured.rollbackId;
@@ -57244,6 +57307,11 @@ var ReplKernelManager = class {
         return;
       this.appendKernelDiagnostic(`kernel stdout error: ${errorMessage3(error)}`);
     });
+    child.stderr?.on("error", (error) => {
+      if (this.child !== child)
+        return;
+      this.appendKernelDiagnostic(`kernel stderr error: ${errorMessage3(error)}`);
+    });
     child.once("exit", () => {
       globalThis.setImmediate(() => child.stderr?.destroy());
     });
@@ -61692,7 +61760,7 @@ var AgentSession = class _AgentSession {
     const { state, snapshot: original, arrivalEpoch, cwd } = capture;
     const before = this._snapshotAutonomousRuntimeState(original);
     const candidate = structuredClone(original);
-    const current = () => this._isCompactionOwnerCurrent(owner) && this._autonomousState === state && isDeepStrictEqual4(state, original);
+    const current = () => this._isCompactionOwnerCurrent(owner) && this._autonomousState === state && isDeepStrictEqual5(state, original);
     if (!current())
       return void 0;
     let messageToQueue;
@@ -61802,7 +61870,7 @@ var AgentSession = class _AgentSession {
     const actions = new Set(current.map((continuation) => continuation.action));
     const cancelled = this._cancelSessionActions((action) => actions.has(action), new Error("Queued autonomous continuation was cleared before delivery."));
     if (options.restoreAutonomousState) {
-      const continuation = current.find((candidate) => this._isCompactionOwnerCurrent(candidate.owner) && cancelled.includes(candidate.action) && !primaryDeliveryRecord(candidate.action).durable && this._autonomousState === candidate.state && isDeepStrictEqual4(candidate.state, candidate.after));
+      const continuation = current.find((candidate) => this._isCompactionOwnerCurrent(candidate.owner) && cancelled.includes(candidate.action) && !primaryDeliveryRecord(candidate.action).durable && this._autonomousState === candidate.state && isDeepStrictEqual5(candidate.state, candidate.after));
       if (continuation)
         this._restoreAutonomousRuntimeSnapshot(continuation.before);
     }
@@ -61883,12 +61951,14 @@ var AgentSession = class _AgentSession {
         this._assertCompactionOwner(owner);
         const compaction = owner.manager.bindCompactionSink();
         const captured = owner.requests.capture(compaction);
-        let branch;
         let preparation;
+        let leafKind;
         try {
-          branch = await compaction.readBranch();
-          this._assertCompactionOwner(owner);
-          preparation = this.isStreaming ? (await this._prepareCapturedCompaction(branch, settings, captured, compaction, owner)).preparation : void 0;
+          if (this.isStreaming) {
+            const prepared = await this._prepareCapturedCompaction(settings, captured, compaction, owner);
+            preparation = prepared.preparation;
+            leafKind = prepared.leafKind;
+          }
         } catch (error) {
           try {
             await captured.dispose();
@@ -61907,10 +61977,9 @@ var AgentSession = class _AgentSession {
             reason: "no active turn; compaction can only be requested while a turn is running"
           };
         if (!preparation) {
-          const lastEntry = branch.at(-1);
           return {
             scheduled: false,
-            reason: lastEntry?.type === "compaction" ? "already compacted" : "session is too short to compact"
+            reason: leafKind === "compaction" ? "already compacted" : "session is too short to compact"
           };
         }
         this._assertContextOptimizationAllowed();
@@ -62237,7 +62306,7 @@ var AgentSession = class _AgentSession {
     const autonomousState = this._autonomousState;
     const autonomousSnapshot = structuredClone(autonomousState);
     const cwd = this._cwd;
-    const autonomousOwnerIsCurrent = () => this._autonomousState === autonomousState && isDeepStrictEqual4(autonomousState, autonomousSnapshot);
+    const autonomousOwnerIsCurrent = () => this._autonomousState === autonomousState && isDeepStrictEqual5(autonomousState, autonomousSnapshot);
     const goalOutcome = await this._getGoalContinuationMessages(context, signal, owner);
     if (!this._isGoalContinuationOwnerCurrent(owner))
       return this._stoppedContinuationOutcome(signal);
@@ -64828,8 +64897,9 @@ ${parsed.args}` : block;
             actionId: action.id,
             submittedText: input.submitted?.text
           };
+          const clearedGoal = Boolean(this._goalState.objective) && this._parseGoalSlashCommand(input.text)?.kind === "clear";
           await this._handleGoalSlashCommand(input.text, input.images, goalOrigin);
-          resultText = this._goalState.objective ? `Goal ${this._goalState.status}: ${this._goalState.objective}` : "No active goal.";
+          resultText = this._goalState.objective ? `Goal ${this._goalState.status}: ${this._goalState.objective}` : clearedGoal ? "Goal cleared." : "No active goal.";
           break;
         }
         case "autonomous":
@@ -66002,14 +66072,12 @@ ${parsed.args}` : block;
       const semanticEdges = owner.semanticEdges;
       compaction = owner.manager.bindCompactionSink();
       requests = owner.requests.capture(compaction);
-      const pathEntries = await compaction.readBranch();
       this._assertCompactionOwner(owner);
       const { apiKey, headers } = await this._getRequiredRequestAuth(model);
       this._assertCompactionOwner(owner);
       committed = await this._performCompaction({
         model,
         thinkingLevel,
-        pathEntries,
         settings,
         requests,
         compaction,
@@ -66093,30 +66161,46 @@ ${parsed.args}` : block;
     }
   }
   /** A private compiled context keeps extension summary edits separate from retained source recipes. */
-  async _prepareCapturedCompaction(pathEntries, settings, requests, compaction, owner = this._captureCompactionOwner(), allowShortSession = false, budgetPressure = false, capacity) {
+  async _prepareCapturedCompaction(settings, requests, compaction, owner = this._captureCompactionOwner(), allowShortSession = false, budgetPressure = false, capacity) {
     this._assertCompactionOwner(owner);
     const limits = this.settingsManager.getCanonicalContextLimits();
     const resource = this._captureKernelResource();
     const source = await compaction.source;
     this._assertCompactionOwner(owner);
-    if (!source.persistent)
+    if (!source.persistent) {
+      const pathEntries = await compaction.readBranch();
+      this._assertCompactionOwner(owner);
       return {
         preparation: prepareCompaction(pathEntries, settings, allowShortSession),
+        pathEntries,
+        leafKind: pathEntries.at(-1)?.type,
         maxSourceBytes: limits.maxSourceBytes
       };
+    }
     return requests.readHistory(async (view) => {
       const messages = await new CanonicalContextCompiler().compile(view, limits, void 0, {}, resource, this._initialContextMode, false, "read");
       this._assertCompactionOwner(owner);
       const context = getCanonicalEpochContext(messages);
-      if (context.checkpoint?.includeSummary && pathEntries.at(-1)?.type === "compaction")
-        return { preparation: void 0, maxSourceBytes: limits.maxSourceBytes };
+      const entryIds = context.references.map((ref) => ref?.ref.entryId);
+      const selected = await compaction.readCompactionEntries(entryIds.filter((id) => id !== void 0));
+      this._assertCompactionOwner(owner);
+      const pathEntries = selected.entries;
+      if (context.checkpoint?.includeSummary && selected.leafKind === "compaction")
+        return {
+          preparation: void 0,
+          pathEntries,
+          leafKind: selected.leafKind,
+          maxSourceBytes: limits.maxSourceBytes
+        };
       const authorization = getRecoveryCompactionAuthorization(capacity);
       const boundary = canonicalRecoveryBoundary(messages, authorization);
-      const preparation = budgetPressure || context.checkpoint || boundary ? prepareViewCompaction(messages, context.references.map((ref) => ref?.ref.entryId), pathEntries, settings, boundary, allowShortSession, budgetPressure) : prepareCompaction(pathEntries, settings, allowShortSession);
+      const preparation = prepareViewCompaction(messages, entryIds, pathEntries, settings, boundary, allowShortSession, budgetPressure, selected.suffixAnchors);
       if (preparation)
         prepareRecoveryCompaction(messages, preparation.firstKeptEntryId, limits.maxSourceBytes, authorization);
       return {
         preparation,
+        pathEntries,
+        leafKind: selected.leafKind,
         messages,
         resource: context.resourceRevision !== void 0 ? resource : void 0,
         maxSourceBytes: limits.maxSourceBytes
@@ -66129,15 +66213,15 @@ ${parsed.args}` : block;
    * Error("Compaction cancelled") on abort or extension cancel.
    */
   async _performCompaction(options) {
-    const { model, apiKey, headers, customInstructions, signal, thinkingLevel, requests, compaction, semanticEdges, pathEntries, settings, owner = this._captureCompactionOwner(), allowShortSession = false, budgetPressure = false } = options;
-    const prepared = await this._prepareCapturedCompaction(pathEntries, settings, requests, compaction, owner, allowShortSession, budgetPressure, options.capacity);
+    const { model, apiKey, headers, customInstructions, signal, thinkingLevel, requests, compaction, semanticEdges, settings, owner = this._captureCompactionOwner(), allowShortSession = false, budgetPressure = false } = options;
+    const prepared = await this._prepareCapturedCompaction(settings, requests, compaction, owner, allowShortSession, budgetPressure, options.capacity);
     this._assertCompactionOwner(owner);
     if (prepared.resource)
       assertResourceCurrent(prepared.resource);
     const preparation = prepared.preparation;
+    const pathEntries = prepared.pathEntries;
     if (!preparation) {
-      const lastEntry = pathEntries[pathEntries.length - 1];
-      if (lastEntry?.type === "compaction") {
+      if (prepared.leafKind === "compaction") {
         throw new CompactionSkippedError("Already compacted");
       }
       throw new CompactionSkippedError("Session is too short to compact \u2014 try again once it grows");
@@ -66799,7 +66883,7 @@ ${parsed.args}` : block;
     const harnessState = this._loadMergedHarnessState();
     const evidence = await this._autoRefineEvidence(harnessState);
     signal?.throwIfAborted();
-    if (isDeepStrictEqual4(evidence, this._lastAutoRefineEvidence))
+    if (isDeepStrictEqual5(evidence, this._lastAutoRefineEvidence))
       return { shouldRefine: false, rationale: "No new task evidence since the previous automatic review." };
     this._lastAutoRefineEvidence = evidence;
     if (this._autoRefineReviewer)
@@ -67376,7 +67460,6 @@ This compaction outcome could not be saved to session history: ${persistenceErro
       const semanticEdges = owner.semanticEdges;
       compaction = owner.manager.bindCompactionSink();
       requests = owner.requests.capture(compaction);
-      const pathEntries = await compaction.readBranch();
       this._assertCompactionOwner(owner);
       const authResult = model ? await this._modelRegistry.getApiKeyAndHeaders(model) : void 0;
       this._assertCompactionOwner(owner);
@@ -67391,7 +67474,6 @@ This compaction outcome could not be saved to session history: ${persistenceErro
       committed = await this._performCompaction({
         model,
         thinkingLevel,
-        pathEntries,
         settings,
         requests,
         compaction,
@@ -70929,7 +71011,7 @@ import { resolve as resolve15 } from "node:path";
 var BASE_CONTEXT_BUILD_ID_ENV = "BASE_CONTEXT_BUILD_ID";
 var BASE_CONTEXT_LAUNCHER_PATH_ENV = "BASE_CONTEXT_LAUNCHER_PATH";
 function bundledBuildId() {
-  return false ? void 0 : "v1.0.14";
+  return false ? void 0 : "v1.0.14-2-g7486ffe2b";
 }
 function getDaemonRuntimeIdentity(environment = process.env) {
   const entrypoint = process.argv[1];

package/dist/bundle/{cli-main-6GXXIMQQ.js → cli-main-2RER6PBE.js}

@@ -5,7 +5,7 @@ import {
   isOwnedSessionWorkerProcess,
   maybeRunOwnedSessionWorkerFrontend,
   maybeStartDaemonEarly
-} from "./chunk-SX7CAXWU.js";
+} from "./chunk-RQFC34FM.js";
 import {
   APP_NAME
 } from "./chunk-IEM74GZ5.js";
@@ -39,7 +39,7 @@ async function runCli() {
     }
     const [{ EnvHttpProxyAgent, setGlobalDispatcher }, { main }] = await Promise.all([
       import("undici"),
-      import("./main-HF64B4HM.js")
+      import("./main-YERLD3T4.js")
     ]);
     setGlobalDispatcher(new EnvHttpProxyAgent({ bodyTimeout: 0, headersTimeout: 0 }));
     try {

package/dist/bundle/cli.js

@@ -52,6 +52,6 @@ var supported = assertNodeVersion({
   exit: (code) => process.exit(code)
 });
 if (supported) {
-  const { runCli } = await import("./cli-main-6GXXIMQQ.js");
+  const { runCli } = await import("./cli-main-2RER6PBE.js");
   await runCli();
 }

package/dist/bundle/{main-HF64B4HM.js → main-YERLD3T4.js}

@@ -17,8 +17,8 @@ import {
   shouldUseDaemonClientRuntime,
   shouldUseDaemonInteractive,
   shouldUseEphemeralSessionManagerForDaemonInteractive
-} from "./chunk-NLRWERWA.js";
-import "./chunk-SX7CAXWU.js";
+} from "./chunk-DGO66I3L.js";
+import "./chunk-RQFC34FM.js";
 import "./chunk-CFNASUYO.js";
 import "./chunk-V6LOBH6X.js";
 import "./chunk-IEM74GZ5.js";