@ponythewhite/base-context 1.0.10 → 1.0.12

package/dist/bundle/{chunk-UHLGPYMI.js → chunk-IAKHCQA2.js}

@@ -116,6 +116,7 @@ import {
   acquireDaemonSocketPathLease,
   acquireSessionLease,
   addAssistantUsage,
+  addRequestUsageTotals,
   agentFamilyRelationship,
   assertAgentFamilyReach,
   assertAgentSessionNameAvailable,
@@ -173,6 +174,7 @@ import {
   durableDaemonWorkerDescriptor,
   emitSessionShutdownEvent,
   emptyGoalState,
+  emptyRequestUsageTotals,
   emptyUsage,
   encodeJournalFrame,
   encodeJournalFrameJson,
@@ -296,7 +298,7 @@ import {
   readSessionBootstrap,
   readSessionInfo,
   readSessionJournalHeader,
-  readUserMessagesForForking,
+  readVisibleUserMessagesForForking,
   renderDiff,
   renderDiffSeparator,
   renderRichDiff,
@@ -349,7 +351,7 @@ import {
   watchWithErrorHandler,
   workerRosterEntryFromSummary,
   wrapTextWithAnsi
-} from "./chunk-CDXQNS5P.js";
+} from "./chunk-YGV3Y4AD.js";
 import {
   array,
   boolean,
@@ -368,7 +370,7 @@ import {
 import {
   installFileLogSink,
   setLogContext
-} from "./chunk-QKIFBA7N.js";
+} from "./chunk-Q6UAHLII.js";
 import {
   APP_NAME,
   APP_TITLE,
@@ -414,7 +416,7 @@ import {
   shouldUseWindowsShell,
   signalProcessGroupOrProcess,
   typebox_exports
-} from "./chunk-2IPDSTDR.js";
+} from "./chunk-AEMRBMI2.js";
 import {
   PRODUCT,
   PRODUCT_ENV
@@ -436,7 +438,7 @@ import {
   getProviders,
   modelsAreEqual,
   supportsFastMode
-} from "./chunk-D3KOF57W.js";
+} from "./chunk-25VYRAC6.js";
 import {
   __commonJS,
   __export,
@@ -6360,10 +6362,15 @@ var SettingsManager = class _SettingsManager {
     return model === void 0 ? void 0 : structuredClone(model);
   }
   getCompactionSettings() {
+    const targetTokens = this.settings.compaction?.targetTokens;
+    if (targetTokens !== void 0 && targetTokens !== "model-limit" && (!Number.isSafeInteger(targetTokens) || targetTokens <= 0)) {
+      throw new Error('compaction.targetTokens must be a positive safe integer or "model-limit"');
+    }
     return {
       enabled: this.getCompactionEnabled(),
       reserveTokens: this.getCompactionReserveTokens(),
-      keepRecentTokens: this.getCompactionKeepRecentTokens()
+      keepRecentTokens: this.getCompactionKeepRecentTokens(),
+      ...targetTokens === void 0 ? {} : { targetTokens }
     };
   }
   /** Detached explicit configuration; the request path resolves and validates its model/effort. */
@@ -31875,6 +31882,67 @@ function buildSessionTreeFromFlatNodes(flatNodes) {
   }
   return roots;
 }
+function applyTreeUsageOverlays(entries2) {
+  const assistants = new Map(entries2.filter((entry) => entry.type === "message" && entry.message.role === "assistant").map((entry) => [entry.id, entry]));
+  for (const entry of entries2) {
+    if (entry.type !== "child_usage_attributed")
+      continue;
+    const target = assistants.get(entry.targetId);
+    if (target?.type === "message" && target.message.role === "assistant")
+      target.message.usage = cloneUsage(entry.aggregateUsage);
+  }
+}
+async function readVisibleSessionTreeFlatNodes(manager, limits = DEFAULT_SESSION_TREE_LIMITS) {
+  const { maxEntries, maxSourceBytes } = limits;
+  if (!Number.isSafeInteger(maxEntries) || maxEntries <= 0 || !Number.isSafeInteger(maxSourceBytes) || maxSourceBytes <= 0)
+    throw new Error("Invalid history materialization limits");
+  if (!manager.supportsCapturedHistoryReads())
+    return readSessionTreeFlatNodes(manager, { maxEntries, maxSourceBytes });
+  return manager.readSourceHistory(async (history) => {
+    const entries2 = [];
+    const visibleIds = /* @__PURE__ */ new Set();
+    let sourceBytes = 0;
+    let after = 0;
+    for (; ; ) {
+      const page = await history.page(after);
+      if (page.indexedThrough < history.source.sourceSequence)
+        throw new Error("Captured history has incomplete index coverage");
+      for (const ref of page.events) {
+        if (ref.kind === "request" || ref.kind === "tool_intent")
+          continue;
+        if (entries2.length >= maxEntries)
+          throw new Error("History entry budget exceeded");
+        if (sourceBytes + ref.locator.length > maxSourceBytes)
+          throw new Error("History source byte budget exceeded");
+        const hydrated = await history.hydrateEntry(ref.id, maxSourceBytes - sourceBytes);
+        if (!hydrated)
+          throw new Error("Session tree entry source is unavailable");
+        sourceBytes += ref.locator.length;
+        let parentId = ref.parentId;
+        while (parentId !== null && !visibleIds.has(parentId)) {
+          const parent = await history.get(parentId);
+          if (!parent || parent.kind !== "request" && parent.kind !== "tool_intent")
+            break;
+          parentId = parent.parentId;
+        }
+        hydrated.entry.parentId = parentId;
+        entries2.push(hydrated.entry);
+        visibleIds.add(ref.id);
+      }
+      if (page.nextAfter === null)
+        break;
+      after = page.nextAfter;
+    }
+    applyTreeUsageOverlays(entries2);
+    const result = { flatNodes: buildSessionTreeFlatNodes(entries2), leafId: history.source.leafId };
+    stringifyBoundedJson(result, maxSourceBytes);
+    return result;
+  });
+}
+async function readVisibleSessionTree(manager, limits = DEFAULT_SESSION_TREE_LIMITS) {
+  const { flatNodes, leafId } = await readVisibleSessionTreeFlatNodes(manager, limits);
+  return { tree: buildSessionTreeFromFlatNodes(flatNodes), leafId };
+}
 async function readSessionTreeFlatNodes(manager, limits = DEFAULT_SESSION_TREE_LIMITS) {
   const capturedLimits = { ...limits };
   let entries2;
@@ -31883,14 +31951,7 @@ async function readSessionTreeFlatNodes(manager, limits = DEFAULT_SESSION_TREE_L
     const history = await manager.materializeSourceHistory(capturedLimits);
     entries2 = history.entries.map(({ entry }) => entry);
     leafId = history.source.leafId;
-    const assistants = new Map(entries2.filter((entry) => entry.type === "message" && entry.message.role === "assistant").map((entry) => [entry.id, entry]));
-    for (const entry of entries2) {
-      if (entry.type !== "child_usage_attributed")
-        continue;
-      const target = assistants.get(entry.targetId);
-      if (target?.type === "message" && target.message.role === "assistant")
-        target.message.usage = cloneUsage(entry.aggregateUsage);
-    }
+    applyTreeUsageOverlays(entries2);
   } else {
     const history = manager.materializeResidentHistory(capturedLimits);
     entries2 = history.entries;
@@ -31898,10 +31959,6 @@ async function readSessionTreeFlatNodes(manager, limits = DEFAULT_SESSION_TREE_L
   }
   return { flatNodes: buildSessionTreeFlatNodes(entries2), leafId };
 }
-async function readSessionTree(manager, limits = DEFAULT_SESSION_TREE_LIMITS) {
-  const { flatNodes, leafId } = await readSessionTreeFlatNodes(manager, limits);
-  return { tree: buildSessionTreeFromFlatNodes(flatNodes), leafId };
-}
 
 // dist/core/side-question.js
 var SIDE_QUESTION_INSTRUCTION = "Answer this side question using only the conversation context above. Do not use tools. The user may send follow-up side questions; none of this side conversation is added to the main session.";
@@ -32405,7 +32462,7 @@ var InProcessAgentConnection = class {
     return this.session.buildSessionContext();
   }
   async getSessionTree() {
-    return readSessionTree(this.session.sessionManager);
+    return readVisibleSessionTree(this.session.sessionManager);
   }
   async listSavedSessions(scope, callbacks) {
     const sessionDir = this.session.sessionManager.getSessionDir() || void 0;
@@ -32490,7 +32547,7 @@ var InProcessAgentConnection = class {
     throw new Error("Agent messaging requires daemon mode");
   }
   async getUserMessagesForForking() {
-    return readUserMessagesForForking(this.session.sessionManager);
+    return readVisibleUserMessagesForForking(this.session.sessionManager);
   }
   async getLastAssistantText() {
     return this.session.getLastAssistantText();
@@ -34559,10 +34616,17 @@ var DaemonAgentConnection = class _DaemonAgentConnection {
     });
   }
   async getContextTree() {
-    return this.requestData({
+    const tree = await this.requestData({
       type: "get_context_tree",
       activeSessionId: this.activeSessionId
     });
+    if (this.client.supportsServerCapability("context_request_usage"))
+      return tree;
+    const legacy = (node) => {
+      const { ownRequestUsage: _ignored, ...rest } = node;
+      return { ...rest, children: node.children.map(legacy) };
+    };
+    return legacy(tree);
   }
   async getSessionContext() {
     if (this.latestSnapshotIsFresh && this.latestSnapshot?.sessionContext) {
@@ -40763,8 +40827,50 @@ function sumOwnUsage(root) {
   walk(root);
   return total;
 }
+var GOAL_SCOPE = "Goal budget: root successful main uncached input + output only; excludes cache, children and auxiliary requests";
+function formatReceiptContextTree(root, width) {
+  const rows = flattenContextTree(root);
+  const total = emptyRequestUsageTotals();
+  const seen = /* @__PURE__ */ new Set();
+  let missingNodes = 0;
+  const lines = [theme.bold("Context"), "", "Generation receipts: captured sources, known usage only", ""];
+  for (const { node, prefix } of rows) {
+    const usage = node.ownRequestUsage;
+    const label = truncateToWidth(`${prefix}${node.label}`, Math.max(16, width - 45), "...");
+    if (!usage) {
+      missingNodes++;
+      lines.push(`${statusIcon(node.status)} ${label}: request usage unknown`);
+    } else if (seen.has(usage.sessionId)) {
+      lines.push(`${statusIcon(node.status)} ${label}: shared source (counted once)`);
+    } else {
+      seen.add(usage.sessionId);
+      addRequestUsageTotals(total, usage.total);
+      lines.push(`${statusIcon(node.status)} ${label}: ${formatTokenCount2(usage.total.processedTokens)} tokens \xB7 ${formatCost(usage.total.catalogEstimateUsd)} est.`);
+      for (const [purpose, bucket] of Object.entries(usage.byPurpose)) {
+        lines.push(`  ${purpose}: ${bucket.processedTokens.toLocaleString()} tokens \xB7 $${bucket.catalogEstimateUsd.toFixed(4)} est. \xB7 ${bucket.settledAttempts} settled`);
+      }
+    }
+    if (node.contextUsage)
+      lines.push(`  Context: ${formatContextColumn(node.contextUsage, node.id === "root")}`);
+  }
+  lines.push("", theme.bold("Captured family \u2014 known generation usage"));
+  lines.push(`Sessions with receipts: ${seen.size}; request usage unavailable: ${missingNodes}`);
+  lines.push(`Uncached input: ${total.input.toLocaleString()}`);
+  lines.push(`Input total (including cache): ${total.inputTotal.toLocaleString()}`);
+  lines.push(`Cache read: ${total.cacheRead.toLocaleString()}; cache write: ${total.cacheWrite.toLocaleString()}`);
+  lines.push(`Output: ${total.output.toLocaleString()}`);
+  lines.push(`Processed total: ${total.processedTokens.toLocaleString()}`);
+  lines.push(`Catalog estimate (unvalidated rates, not an invoice): $${total.catalogEstimateUsd.toFixed(4)}`);
+  lines.push(`Unknown usage: ${total.missingUsageAttempts} missing, ${total.partialUsageAttempts} partial, ${total.unsettledAttempts} unsettled attempts; ${total.unpricedAttempts} settled attempts unpriced`);
+  lines.push("Missing fields are not zero. Totals exclude unavailable sessions and non-generation token-count requests.");
+  lines.push("Captured sources are not a guarantee of complete historical family usage.");
+  lines.push("", GOAL_SCOPE);
+  return lines.join("\n");
+}
 function formatContextTree(root, width) {
   const rows = flattenContextTree(root);
+  if (rows.some(({ node }) => node.ownRequestUsage))
+    return formatReceiptContextTree(root, width);
   const tokenCells = rows.map((row) => formatTokenCount2(spentTokens(row.node.ownUsage)));
   const costCells = rows.map((row) => formatCost(row.node.ownUsage.cost.total));
   const tokenHeader = "tokens";
@@ -40776,6 +40882,9 @@ function formatContextTree(root, width) {
   const lines = [];
   lines.push(theme.bold("Context"));
   lines.push("");
+  lines.push("Legacy conversation projection \u2014 request receipts unavailable; auxiliary usage may be missing");
+  lines.push("Costs below are catalog estimates, not invoices");
+  lines.push("");
   if (root.model) {
     lines.push(`${theme.fg("dim", "Model:")} ${root.model.provider}/${root.model.id}`);
     lines.push("");
@@ -40821,6 +40930,7 @@ function formatContextTree(root, width) {
       lines.push(`${theme.fg("dim", "Current:")} ${rootContext.tokens.toLocaleString()} / ${rootContext.contextWindow.toLocaleString()} (${percent})`);
     }
   }
+  lines.push("", GOAL_SCOPE);
   return lines.join("\n");
 }
 
@@ -59587,6 +59697,7 @@ var DaemonRlmCapacityClient = class {
 // dist/modes/daemon/daemon-session-summarizer.js
 var SWEEP_INTERVAL_MS = 25e3;
 var SETTLE_DEBOUNCE_MS = 2e3;
+var MIN_REFRESH_INTERVAL_MS = 6e4;
 var SUMMARY_CONTEXT_MESSAGES = 8;
 var SUMMARY_MAX_CHARS_PER_MESSAGE = 600;
 var SUMMARY_MAX_TOKENS = 400;
@@ -59620,7 +59731,7 @@ function messageText(content) {
     const type = block.type;
     if (type === "text" && typeof block.text === "string") {
       parts.push(block.text);
-    } else if (type === "tool_use" || type === "toolUse") {
+    } else if (type === "toolCall" || type === "tool_use" || type === "toolUse") {
       const name = block.name;
       if (typeof name === "string") {
         tools.push(name);
@@ -59684,7 +59795,7 @@ function parseAgentStatusResponse(text, isWorking) {
   return { summary, taskState };
 }
 async function generateAgentStatus(params) {
-  const { registry, messages, isWorking, signal, requests, model: selectedModel } = params;
+  const { registry, messages, isWorking, sessionId, signal, requests, model: selectedModel } = params;
   if (messages.length === 0) {
     return void 0;
   }
@@ -59708,7 +59819,13 @@ async function generateAgentStatus(params) {
           timestamp
         }
       ]
-    }, { maxTokens: SUMMARY_MAX_TOKENS, apiKey: auth.apiKey, headers: auth.headers, signal }, { purpose: "native-control", purposeDetail: "daemon-status" });
+    }, {
+      maxTokens: SUMMARY_MAX_TOKENS,
+      apiKey: auth.apiKey,
+      headers: auth.headers,
+      signal,
+      sessionId: sessionId ? `daemon-status:${sessionId}` : void 0
+    }, { purpose: "native-control", purposeDetail: "daemon-status" });
     if (response.stopReason === "error") {
       return void 0;
     }
@@ -59744,6 +59861,7 @@ var DaemonSessionSummarizer = class {
   debounceTimers = /* @__PURE__ */ new Map();
   // Controller per in-flight summary so a closing session can abort its write.
   inFlight = /* @__PURE__ */ new Map();
+  refreshes = /* @__PURE__ */ new Map();
   tasks = /* @__PURE__ */ new Map();
   forgotten = /* @__PURE__ */ new Set();
   stopped = false;
@@ -59793,6 +59911,7 @@ var DaemonSessionSummarizer = class {
       this.debounceTimers.delete(activeSessionId);
     }
     this.inFlight.get(activeSessionId)?.abort();
+    this.refreshes.delete(activeSessionId);
     this.rerunRequested.delete(activeSessionId);
     await this.tasks.get(activeSessionId);
   }
@@ -59809,6 +59928,9 @@ var DaemonSessionSummarizer = class {
   }
   /** Called when a session finishes a turn; debounce until the agent settles. */
   notifyActivity(state) {
+    this.schedule(state, SETTLE_DEBOUNCE_MS);
+  }
+  schedule(state, delay8) {
     const id = state.activeSessionId;
     if (this.stopped || this.forgotten.has(id))
       return;
@@ -59819,7 +59941,7 @@ var DaemonSessionSummarizer = class {
     const timer = setTimeout(() => {
       this.debounceTimers.delete(id);
       this.summarize(state);
-    }, SETTLE_DEBOUNCE_MS);
+    }, delay8);
     timer.unref?.();
     this.debounceTimers.set(id, timer);
   }
@@ -59853,33 +59975,54 @@ var DaemonSessionSummarizer = class {
     const messageCount = messages.length;
     const isWorking = isSessionWorking(state);
     const previous = state.summaryState;
-    const contentUnchanged = previous?.basedOnMessageCount === messageCount;
     const owesIdleVerdict = !isWorking && previous?.taskState === void 0;
     const owesSummary = !isWorking && !previous?.summary;
     const turnError = !isWorking ? terminalTurnError(messages) : void 0;
-    const owesErrorVerdict = turnError !== void 0 && (previous?.taskState !== "needs_input" || previous?.summary !== turnError);
-    if (contentUnchanged && !isWorking && !owesIdleVerdict && !owesSummary && !owesErrorVerdict) {
-      return;
+    const contextMessages = () => {
+      const streaming = isWorking ? session.state.streamingMessage : void 0;
+      return streaming ? [...session.messages, streaming] : session.messages;
+    };
+    const input = buildStatusContext(contextMessages(), isWorking);
+    const model = session.model;
+    const isCurrentSource = () => state.runtime.session === session && session.sessionManager === sessionManager && sessionManager.getSessionId() === sessionId && sessionManager.getSessionFile() === sessionFile && session.model === model;
+    let refresh = this.refreshes.get(id);
+    if (!refresh?.isCurrentSource()) {
+      refresh = { isCurrentSource };
+      this.refreshes.set(id, refresh);
+    }
+    const finalTransition = !isWorking && refresh.wasWorking === true;
+    refresh.wasWorking = isWorking;
+    const reuse = turnError === void 0 && refresh.input === input && previous?.summary ? previous : void 0;
+    if ((reuse || turnError !== void 0 && previous?.summary === turnError && previous.taskState === "needs_input") && previous?.basedOnMessageCount === messageCount) {
+      return;
+    }
+    if (!reuse && turnError === void 0) {
+      const remaining = MIN_REFRESH_INTERVAL_MS - (Date.now() - (refresh.attemptedAt ?? -Infinity));
+      if (!finalTransition && remaining > 0) {
+        this.schedule(state, remaining);
+        return;
+      }
+      refresh.attemptedAt = Date.now();
     }
-    const streaming = isWorking ? session.state.streamingMessage : void 0;
-    const contextMessages = streaming ? [...messages, streaming] : messages;
     const controller = new AbortController();
-    const isCurrent = () => !controller.signal.aborted && state.runtime.session === session && session.sessionManager === sessionManager && sessionManager.getSessionId() === sessionId && sessionManager.getSessionFile() === sessionFile && isSessionWorking(state) === isWorking && session.messages.length === messageCount;
+    const isCurrent = () => !controller.signal.aborted && isCurrentSource() && isSessionWorking(state) === isWorking && session.messages.length === messageCount && buildStatusContext(contextMessages(), isWorking) === input && (isWorking || terminalTurnError(session.messages) === turnError);
     this.inFlight.set(id, controller);
     let requests;
     let status;
+    let completedInput;
     let changed = false;
     try {
-      if (turnError === void 0)
+      if (!reuse && turnError === void 0)
         requests = this.getRequests?.(session);
-      const generated = turnError !== void 0 ? { summary: turnError, taskState: "needs_input" } : await this.generate({
+      const generated = reuse ?? (turnError !== void 0 ? { summary: turnError, taskState: "needs_input" } : await this.generate({
         registry: session.modelRegistry,
-        model: session.model,
-        messages: contextMessages,
+        model,
+        messages: contextMessages(),
         isWorking,
+        sessionId,
         signal: controller.signal,
         requests
-      });
+      }));
       await requests?.dispose();
       const result = generated ?? (!isWorking && (owesIdleVerdict || owesSummary) ? { summary: previous?.summary ?? "", taskState: "needs_input" } : void 0);
       if (!result) {
@@ -59888,6 +60031,8 @@ var DaemonSessionSummarizer = class {
       if (!isCurrent()) {
         return;
       }
+      if (generated && turnError === void 0)
+        completedInput = input;
       const taskState = result.taskState ?? (previous?.basedOnMessageCount === messageCount ? previous?.taskState : void 0);
       status = {
         summary: result.summary,
@@ -59908,6 +60053,7 @@ var DaemonSessionSummarizer = class {
       }
     }
     if (status && isCurrent()) {
+      refresh.input = completedInput;
       state.summaryState = status;
       if (changed)
         this.onStatusChanged?.(state);
@@ -64383,12 +64529,12 @@ var AgentDaemon = class {
       }
       case "get_session_tree": {
         const state = this.getSessionState(command.activeSessionId);
-        return success(command.id, "get_session_tree", await readSessionTreeFlatNodes(state.runtime.session.sessionManager));
+        return success(command.id, "get_session_tree", await readVisibleSessionTreeFlatNodes(state.runtime.session.sessionManager));
       }
       case "get_user_messages_for_forking": {
         const state = this.getSessionState(command.activeSessionId);
         return success(command.id, "get_user_messages_for_forking", {
-          messages: await readUserMessagesForForking(state.runtime.session.sessionManager)
+          messages: await readVisibleUserMessagesForForking(state.runtime.session.sessionManager)
         });
       }
       case "get_last_assistant_text": {

package/dist/bundle/{chunk-KT2BNEPE.js → chunk-MUFZODP5.js}

@@ -14,7 +14,7 @@ import {
   calculateCost,
   classifyStreamFailure,
   withRequestBody
-} from "./chunk-D3KOF57W.js";
+} from "./chunk-25VYRAC6.js";
 
 // ../ai/src/providers/openai-responses-shared.ts
 function encodeTextSignatureV1(id, phase) {

package/dist/bundle/{chunk-QKIFBA7N.js → chunk-Q6UAHLII.js}

@@ -2,11 +2,11 @@ import { createRequire as __piBundleCreateRequire } from 'node:module'; const re
 import {
   appendRotatingLog,
   getAgentLogPath
-} from "./chunk-2IPDSTDR.js";
+} from "./chunk-AEMRBMI2.js";
 import {
   setLogSink,
   stringifyLogEntry
-} from "./chunk-D3KOF57W.js";
+} from "./chunk-25VYRAC6.js";
 
 // dist/core/logging.js
 var AGENT_LOG_MAX_BYTES = 20 * 1024 * 1024;