@caupulican/pi-adaptative 0.81.41 → 0.81.43

package/dist/core/context-pipeline.js

@@ -22,7 +22,7 @@
  * {@link ContextPipelineDeps.getMemoryManager} (never imports it), and MemoryController never imports
  * the pipeline — keeping the transform the one place the two subsystems meet.
  */
-import { createHash } from "node:crypto";
+import { addUsage, createEmptyUsage } from "@caupulican/pi-agent-core";
 import { calculateContextTokens, estimateTokens, getApplicableAssistantUsageInfo, getLatestCompactionEntry, TokenBudget, } from "@caupulican/pi-agent-core/node";
 import { BrainCurator, preDigestConversationText } from "./context/brain-curator.js";
 import { createFileArtifactStore } from "./context/context-artifacts.js";
@@ -30,64 +30,15 @@ import { runContextAudit, } from "./context/context-audit.js";
 import { enforcePromptPolicy } from "./context/context-prompt-enforcement.js";
 import { correlateWithContextGc, planPromptPolicy, } from "./context/context-prompt-policy.js";
 import { acquireContextStoreRetention, getContextStoreDir, migrateLegacyContextStores, } from "./context/context-store-retention.js";
+import { latestUserPromptText, textContentPrefix } from "./context/message-text.js";
 import { applyContextGc } from "./context-gc.js";
+import { runIsolatedTextCompletion } from "./isolated-text-completion.js";
 import { resolveCliModel } from "./model-resolver.js";
 import { evaluateSurfaceFitness } from "./model-router/fitness-gate.js";
 import { FitnessStore } from "./models/fitness-store.js";
 import { HF_TRANSFORMERS_PROVIDER, OLLAMA_PROVIDER } from "./models/local-registration.js";
-/**
- * Deterministic `addSpawnedUsage` reportId: `kind` + session id + a content hash of `identity`
- * (never `Date.now`/random). Same identity on a retry of the same logical work unit yields the same
- * id, so the ledger's `seenSubagentReportIds` dedupe catches a duplicate report instead of
- * double-counting spend.
- */
-function deriveSpawnedUsageReportId(kind, sessionId, identity) {
-    const digest = createHash("sha256").update(identity).digest("hex").slice(0, 16);
-    return `${kind}:${sessionId}:${digest}`;
-}
-function joinTextPrefix(content, maxChars = Number.POSITIVE_INFINITY) {
-    let found = false;
-    let text = "";
-    for (const part of content) {
-        if (typeof part !== "object" || part === null || part.type !== "text")
-            continue;
-        const blockText = part.text;
-        if (typeof blockText !== "string")
-            continue;
-        if (!found) {
-            found = true;
-            if (blockText.length >= maxChars)
-                return blockText.slice(0, maxChars);
-            text = blockText;
-            continue;
-        }
-        const available = maxChars - text.length;
-        if (available <= 0)
-            return text;
-        if (available === 1)
-            return `${text}\n`;
-        const remaining = available - 1;
-        text += `\n${blockText.slice(0, remaining)}`;
-        if (blockText.length >= remaining)
-            return text;
-    }
-    return text;
-}
-/** Latest user prompt text in the provider-visible array. */
-export function latestUserPromptText(messages, maxChars = Number.POSITIVE_INFINITY) {
-    for (let index = messages.length - 1; index >= 0; index--) {
-        const message = messages[index];
-        if (!message || message.role !== "user")
-            continue;
-        if (typeof message.content === "string") {
-            return message.content.length > maxChars ? message.content.slice(0, maxChars) : message.content;
-        }
-        const text = joinTextPrefix(message.content, maxChars);
-        if (text.length > 0)
-            return text;
-    }
-    return "";
-}
+import { resolveSessionEntryIndex } from "./session-entry-index.js";
+import { reportSpawnedUsage } from "./spawned-usage.js";
 /** Read a packed artifact-producing tool result's `details.artifactId`, if present, without `any`. */
 function extractArtifactId(message) {
     if (!message || message.role !== "toolResult")
@@ -139,35 +90,33 @@ function estimateContextTokensMemoized(messages, memo) {
     return result;
 }
 export class ContextPipeline {
-    _latestContextGcReport = undefined;
-    /** Brain-curation sidecar (design: brain-context-curation-design.md). Inert unless the
-     * contextPolicy.curation setting is enabled AND the model passes the digest fitness gate. */
-    _brainCurator = new BrainCurator();
-    _lastCurationSkipReason = undefined;
-    _lastPreDigestSkipReason = undefined;
-    _toolArtifactStore = undefined;
-    _contextStoreRetentionLease;
-    _latestContextAuditReport = undefined;
-    _latestPromptPolicyReport = undefined;
-    _latestPromptPolicyGcCorrelation = undefined;
-    _latestPromptEnforcementReport = undefined;
-    _tokenBudget = new TokenBudget();
-    _hasTokenBudgetAnchor = false;
-    _tokenBudgetAnchorCompactionId = undefined;
-    _lastTokenBudgetAnchorKey = undefined;
-    /** Incremental current-branch lookup used by the per-turn audit. It retains only tool calls
-     * still present in the provider-visible context, so compaction also bounds this cache. */
-    _sessionEntryLookupCache = undefined;
-    /** Incremental memo for the hot-path audit's expensive per-message work, keyed by
-     * message object identity -- see {@link ContextAuditMemo}'s doc for the invalidation
-     * contract. Rebuilt fresh (stale entries dropped) by `runContextAudit` every pass. */
-    _auditMemo = new Map();
-    /** Incremental memo for the per-message token estimate `estimateContextTokensMemoized`
-     * relies on -- same object-identity-keyed, fresh-rebuild-per-pass contract as `_auditMemo`,
-     * just for a plain `estimateTokens(message)` number instead of a built ContextItem. */
-    _tokenMemo = new Map();
-    deps;
     constructor(deps) {
+        this._latestContextGcReport = undefined;
+        /** Brain-curation sidecar (design: brain-context-curation-design.md). Inert unless the
+         * contextPolicy.curation setting is enabled AND the model passes the digest fitness gate. */
+        this._brainCurator = new BrainCurator();
+        this._lastCurationSkipReason = undefined;
+        this._lastPreDigestSkipReason = undefined;
+        this._toolArtifactStore = undefined;
+        this._latestContextAuditReport = undefined;
+        this._latestPromptPolicyReport = undefined;
+        this._latestPromptPolicyGcCorrelation = undefined;
+        this._latestPromptEnforcementReport = undefined;
+        this._tokenBudget = new TokenBudget();
+        this._hasTokenBudgetAnchor = false;
+        this._tokenBudgetAnchorCompactionId = undefined;
+        this._lastTokenBudgetAnchorKey = undefined;
+        /** Incremental current-branch lookup used by the per-turn audit. It retains only tool calls
+         * still present in the provider-visible context, so compaction also bounds this cache. */
+        this._sessionEntryLookupCache = undefined;
+        /** Incremental memo for the hot-path audit's expensive per-message work, keyed by
+         * message object identity -- see {@link ContextAuditMemo}'s doc for the invalidation
+         * contract. Rebuilt fresh (stale entries dropped) by `runContextAudit` every pass. */
+        this._auditMemo = new Map();
+        /** Incremental memo for the per-message token estimate `estimateContextTokensMemoized`
+         * relies on -- same object-identity-keyed, fresh-rebuild-per-pass contract as `_auditMemo`,
+         * just for a plain `estimateTokens(message)` number instead of a built ContextItem. */
+        this._tokenMemo = new Map();
         this.deps = deps;
     }
     _ensureContextStoreRetention() {
@@ -224,14 +173,11 @@ export class ContextPipeline {
      */
     _getLatestCompactionEntry() {
         const sessionManager = this.deps.getSessionManager();
-        const indexedSessionManager = sessionManager;
-        const getLeafId = indexedSessionManager.getLeafId?.bind(sessionManager);
-        const getEntry = indexedSessionManager.getEntry?.bind(sessionManager);
-        const leafId = getLeafId?.();
-        if (getLeafId && getEntry && leafId !== undefined) {
-            let currentId = leafId;
+        const index = resolveSessionEntryIndex(sessionManager);
+        if (index) {
+            let currentId = index.leafId;
             while (currentId !== null) {
-                const entry = getEntry(currentId);
+                const entry = index.getEntry(currentId);
                 if (!entry)
                     break;
                 if (entry.type === "compaction")
@@ -244,10 +190,8 @@ export class ContextPipeline {
     }
     _buildSessionEntryIdLookup(wantedToolCallIds) {
         const sessionManager = this.deps.getSessionManager();
-        const indexedSessionManager = sessionManager;
-        const getLeafId = indexedSessionManager.getLeafId?.bind(sessionManager);
-        const getEntry = indexedSessionManager.getEntry?.bind(sessionManager);
-        const leafId = getLeafId?.();
+        const index = resolveSessionEntryIndex(sessionManager);
+        const leafId = index?.leafId;
         const cached = this._sessionEntryLookupCache;
         if (cached) {
             for (const toolCallId of cached.byToolCallId.keys()) {
@@ -255,7 +199,7 @@ export class ContextPipeline {
                     cached.byToolCallId.delete(toolCallId);
             }
         }
-        if (getLeafId && getEntry && leafId !== undefined) {
+        if (index && leafId !== undefined) {
             if (cached?.leafId === leafId) {
                 return (toolCallId) => cached.byToolCallId.get(toolCallId);
             }
@@ -263,7 +207,7 @@ export class ContextPipeline {
                 const appendedEntries = [];
                 let cursor = leafId;
                 while (cursor !== null && cursor !== cached.leafId) {
-                    const entry = getEntry(cursor);
+                    const entry = index.getEntry(cursor);
                     if (!entry)
                         break;
                     appendedEntries.push(entry);
@@ -456,7 +400,7 @@ export class ContextPipeline {
                 const details = message.details;
                 if (details?.contextGc?.packed === true || details?.promptPolicy?.enforced === true)
                     continue;
-                const text = joinTextPrefix(message.content, 4000);
+                const text = textContentPrefix(message.content, 4000);
                 if (text.length === 0)
                     continue;
                 this._brainCurator.enqueue({ kind: "relevance", key: item.itemId, content: text, goal });
@@ -562,25 +506,18 @@ export class ContextPipeline {
                     text,
                     signal,
                     chunkChars,
-                    complete: async ({ systemPrompt, userPrompt, signal: chunkSignal }) => {
-                        const completion = await this.deps.runIsolatedCompletion({
-                            systemPrompt,
-                            messages: [{ role: "user", content: [{ type: "text", text: userPrompt }], timestamp: Date.now() }],
-                            model,
-                            thinkingLevel: "off",
-                            maxTokens: 512,
-                            signal: chunkSignal,
-                            cacheRetention: "short",
-                            // Stable per-lane synthetic affinity key so repeat pre-digest chunk
-                            // calls hit the same cache-warm backend.
-                            laneKind: "curation",
-                        });
-                        return {
-                            text: completion.text,
-                            costUsd: completion.usage.cost.total,
-                            stopReason: String(completion.stopReason),
-                        };
-                    },
+                    complete: ({ systemPrompt, userPrompt, signal: chunkSignal }) => runIsolatedTextCompletion(this.deps, {
+                        systemPrompt,
+                        userPrompt,
+                        model,
+                        thinkingLevel: "off",
+                        maxTokens: 512,
+                        signal: chunkSignal,
+                        cacheRetention: "short",
+                        // Stable per-lane synthetic affinity key so repeat pre-digest chunk
+                        // calls hit the same cache-warm backend.
+                        laneKind: "curation",
+                    }),
                 });
                 if (!this.deps.isDisposed() && result.totalChunks > 0) {
                     this.deps.getSessionManager().appendCustomEntry("brain-curation-predigest", {
@@ -603,13 +540,13 @@ export class ContextPipeline {
         try {
             // ACCUMULATE across all drained jobs (the drain runs the completer once PER job) —
             // keeping only the last job's usage would under-report every multi-job drain.
-            let spentUsage;
+            const spentUsage = createEmptyUsage();
             const results = await this._brainCurator.drain({
                 maxJobs,
                 complete: async ({ systemPrompt, userPrompt, signal }) => {
-                    const completion = await this.deps.runIsolatedCompletion({
+                    const completion = await runIsolatedTextCompletion(this.deps, {
                         systemPrompt,
-                        messages: [{ role: "user", content: [{ type: "text", text: userPrompt }], timestamp: Date.now() }],
+                        userPrompt,
                         model,
                         thinkingLevel: "off",
                         maxTokens: 256,
@@ -620,36 +557,18 @@ export class ContextPipeline {
                         // same cache-warm backend.
                         laneKind: "curation",
                     });
-                    const usage = completion.usage;
-                    if (!spentUsage) {
-                        spentUsage = structuredClone(usage);
-                    }
-                    else {
-                        spentUsage.input += usage.input;
-                        spentUsage.output += usage.output;
-                        spentUsage.cacheRead += usage.cacheRead;
-                        spentUsage.cacheWrite += usage.cacheWrite;
-                        spentUsage.totalTokens += usage.totalTokens;
-                        spentUsage.cost.input += usage.cost.input;
-                        spentUsage.cost.output += usage.cost.output;
-                        spentUsage.cost.cacheRead += usage.cost.cacheRead;
-                        spentUsage.cost.cacheWrite += usage.cost.cacheWrite;
-                        spentUsage.cost.total += usage.cost.total;
-                    }
-                    return {
-                        text: completion.text,
-                        costUsd: completion.usage.cost.total,
-                        stopReason: String(completion.stopReason),
-                    };
+                    addUsage(spentUsage, completion.usage);
+                    return completion;
                 },
             });
             // Honest accounting even for free local models: token visibility is the contract.
-            if (spentUsage && (spentUsage.cost.total > 0 || spentUsage.totalTokens > 0)) {
-                // `reportId` keyed on the drained jobs' own idempotency keys — stable across a
-                // retry of the same drain batch, distinct across genuinely different batches.
-                const reportId = deriveSpawnedUsageReportId("context-curator", this.deps.getSessionManager().getSessionId(), results.map((result) => result.key).join(" "));
-                this.deps.addSpawnedUsage(spentUsage, { label: "context-curator", reportId });
-            }
+            reportSpawnedUsage(this.deps, spentUsage, {
+                kind: "context-curator",
+                label: "context-curator",
+                sessionId: this.deps.getSessionManager().getSessionId(),
+                // Preserve the previous space-joined report identity without allocating it.
+                identity: results.map((result) => result.key),
+            });
             if (this.deps.isDisposed() || results.length === 0)
                 return;
             this.deps.getSessionManager().appendCustomEntry("brain-curation", {