@caupulican/pi-adaptative 0.80.88 → 0.80.90

package/dist/core/agent-session.js

@@ -27,8 +27,11 @@ import { appendLaneRecordSnapshot, getLaneRecordSnapshots } from "./autonomy/ses
 import { composeSubagentSystemPrompt } from "./autonomy/subagent-prompt.js";
 import { executeBashWithOperations } from "./bash-executor.js";
 import { calculateContextTokens, collectEntriesForBranchSummary, compact, estimateContextTokens, generateBranchSummary, prepareCompaction, shouldCompact, } from "./compaction/index.js";
+// (module-scope helper for curation goal extraction defined below the imports)
+import { BrainCurator } from "./context/brain-curator.js";
 import { createFileArtifactStore } from "./context/context-artifacts.js";
 import { runContextAudit } from "./context/context-audit.js";
+import { buildContextCompositionReport, formatContextCompositionDashboard, } from "./context/context-composition.js";
 import { enforcePromptPolicy } from "./context/context-prompt-enforcement.js";
 import { correlateWithContextGc, planPromptPolicy, } from "./context/context-prompt-policy.js";
 import { defaultMemoryPromptInclusionReport, sanitizeMemoryRetrievalReportForDiagnostics, } from "./context/memory-diagnostics.js";
@@ -107,6 +110,23 @@ export function parseSkillBlock(text) {
 }
 /** customType for spawned-usage roll-up entries (Cost Aggregation, Model A). */
 export const SPAWNED_USAGE_CUSTOM_TYPE = "spawned_usage";
+/** Latest user prompt text in the provider-visible array (curation goal line; bounded by caller). */
+function latestUserPromptText(messages) {
+    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;
+        const text = message.content
+            .filter((part) => part.type === "text")
+            .map((part) => part.text)
+            .join("\n");
+        if (text.length > 0)
+            return text;
+    }
+    return "";
+}
 // ============================================================================
 // Constants
 // ============================================================================
@@ -204,6 +224,10 @@ export class AgentSession {
     _autoCompactionAbortController = undefined;
     _overflowRecoveryAttempted = false;
     _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;
     _toolArtifactStore = undefined;
     _latestContextAuditReport = undefined;
     _latestPromptPolicyReport = undefined;
@@ -424,6 +448,9 @@ export class AgentSession {
             const gcResult = this._applyContextGc(finalMessages, true);
             this._correlatePromptPolicyWithContextGc(gcResult.report);
             const enforcementResult = this._runPromptEnforcement(gcResult.messages, shadowReport);
+            this._enqueueRelevanceCuration(gcResult.messages, shadowReport);
+            // Fire-and-forget: the local curator overlaps the frontier call; it never blocks a turn.
+            this._maybeDrainBrainCuration();
             // Appended LAST, after gc and enforcement, so the bounded evidence block is
             // never packed/stubbed/reshaped by either pass and always reflects this turn's
             // fresh retrieval. Because nothing downstream trims it, memory-prompt-block.ts's
@@ -685,6 +712,7 @@ export class AgentSession {
     _runPromptEnforcement(messages, shadowReport) {
         try {
             const persistedSettings = this.settingsManager.getContextPromptEnforcementSettings();
+            const curationEnabled = this.settingsManager.getContextCurationSettings().enabled;
             const settings = {
                 ...persistedSettings,
                 // Runtime fact, never assumed: artifact_retrieve is a companion affordance
@@ -692,6 +720,7 @@ export class AgentSession {
                 // tools can differ turn to turn -- see context-prompt-enforcement.ts's doc
                 // comment on why this is checked separately from hasAvailableRetrievalPath.
                 retrievalToolAvailable: this.getActiveToolNames().includes("artifact_retrieve"),
+                brainRelevance: curationEnabled ? (itemId) => this._brainCurator.getRelevance(itemId) : undefined,
             };
             const result = enforcePromptPolicy(messages, shadowReport, settings);
             this._latestPromptEnforcementReport = result.report;
@@ -703,6 +732,222 @@ export class AgentSession {
             return { messages, report };
         }
     }
+    /**
+     * Enqueue relevance-scoring jobs for stale, artifact-backed tool outputs the enforcement
+     * pilot could act on. Pure queueing — the verdicts only ever take effect through the
+     * asymmetric advisory lever inside enforcePromptPolicy. Never throws into a turn.
+     */
+    _enqueueRelevanceCuration(messages, shadowReport) {
+        try {
+            const settings = this.settingsManager.getContextCurationSettings();
+            if (!settings.enabled)
+                return;
+            const goal = latestUserPromptText(messages).slice(0, 400);
+            for (const item of shadowReport.items) {
+                if (!item.hasAvailableRetrievalPath)
+                    continue;
+                const message = messages[item.messageIndex];
+                if (!message || message.role !== "toolResult" || message.toolCallId !== item.toolCallId)
+                    continue;
+                if (message.isError)
+                    continue;
+                const details = message.details;
+                if (details?.contextGc?.packed === true || details?.promptPolicy?.enforced === true)
+                    continue;
+                const text = message.content
+                    .filter((part) => part.type === "text")
+                    .map((part) => part.text)
+                    .join("\n");
+                if (text.length === 0)
+                    continue;
+                this._brainCurator.enqueue({ kind: "relevance", key: item.itemId, content: text.slice(0, 4000), goal });
+            }
+        }
+        catch {
+            // curation is a sidecar; it must never disrupt a turn
+        }
+    }
+    /**
+     * Drain gate: settings on, model configured+authed, and the model has PASSED the digest
+     * fitness probe on THIS host (design: unfit or unprobed models are refused with a visible
+     * reason, never silently degraded). Fire-and-forget; never throws into a turn.
+     */
+    _maybeDrainBrainCuration() {
+        try {
+            const settings = this.settingsManager.getContextCurationSettings();
+            if (!settings.enabled) {
+                // Never surface a stale refusal reason for a feature the user has since disabled.
+                this._lastCurationSkipReason = undefined;
+                return;
+            }
+            if (!this._brainCurator.hasWork() || this._brainCurator.isDraining)
+                return;
+            if (!settings.model) {
+                this._lastCurationSkipReason = "curation_model_unset";
+                return;
+            }
+            const resolved = resolveCliModel({ cliModel: settings.model, modelRegistry: this._modelRegistry });
+            if (!resolved.model || !this._modelRegistry.hasConfiguredAuth(resolved.model)) {
+                this._lastCurationSkipReason = "curation_model_unresolved";
+                return;
+            }
+            // Match on the CANONICAL "provider/id" ref — runModelFitness stores reports under it,
+            // while settings.model may be a bare id or pattern; comparing raw strings would refuse
+            // forever with curation_model_unprobed even after a successful probe.
+            const canonicalRef = `${resolved.model.provider}/${resolved.model.id}`;
+            const fitness = FitnessStore.forAgentDir(this._agentDir)
+                .getForHost()
+                .find((entry) => entry.model === canonicalRef);
+            const digestScore = fitness?.report.digest;
+            if (!digestScore) {
+                this._lastCurationSkipReason = "curation_model_unprobed";
+                return;
+            }
+            if (digestScore.succeeded < Math.ceil(digestScore.total * (2 / 3))) {
+                this._lastCurationSkipReason = "curation_model_digest_unfit";
+                return;
+            }
+            this._lastCurationSkipReason = undefined;
+            void this._drainBrainCuration(resolved.model, settings.maxJobsPerTurn);
+        }
+        catch {
+            // curation is a sidecar; it must never disrupt a turn
+        }
+    }
+    async _drainBrainCuration(model, maxJobs) {
+        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 results = await this._brainCurator.drain({
+                maxJobs,
+                complete: async ({ systemPrompt, userPrompt, signal }) => {
+                    const completion = await this.runIsolatedCompletion({
+                        systemPrompt,
+                        messages: [{ role: "user", content: [{ type: "text", text: userPrompt }], timestamp: Date.now() }],
+                        model,
+                        thinkingLevel: "off",
+                        maxTokens: 256,
+                        signal,
+                        // Both curation system prompts are static — the provider can cache the prefix.
+                        cacheRetention: "short",
+                    });
+                    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),
+                    };
+                },
+            });
+            // Honest accounting even for free local models: token visibility is the contract.
+            if (spentUsage && (spentUsage.cost.total > 0 || spentUsage.totalTokens > 0)) {
+                this.addSpawnedUsage(spentUsage, { label: "context-curator" });
+            }
+            if (this._disposed || results.length === 0)
+                return;
+            this.sessionManager.appendCustomEntry("brain-curation", {
+                version: 1,
+                results: results.map((result) => ({
+                    key: result.key,
+                    kind: result.kind,
+                    ok: result.ok,
+                    ms: result.ms,
+                    ...(result.digest !== undefined ? { digest: result.digest } : {}),
+                    ...(result.relevant !== undefined ? { relevant: result.relevant, confidence: result.confidence } : {}),
+                })),
+                telemetry: this._brainCurator.telemetry(),
+            });
+        }
+        catch {
+            // curation is a sidecar; it must never disrupt a turn
+        }
+    }
+    /**
+     * Context composition dashboard data: decomposes the per-request payload (system prompt, tool
+     * schemas, extension contributions, message classes incl. GC/policy stubs and recall pages)
+     * plus background spend, so users can see exactly what their integrations cost per request.
+     * Read-only: uses the GC report path (writePayloads=false), never mutates anything.
+     */
+    getContextCompositionReport() {
+        const rawMessages = this.agent.state.messages.slice();
+        const gcResult = this._applyContextGc(rawMessages, false);
+        const activeNames = new Set(this.getActiveToolNames());
+        const extensions = this._resourceLoader.getExtensions().extensions;
+        const extensionToolNames = new Set(extensions.flatMap((extension) => [...extension.tools.keys()]));
+        const usage = this.getContextUsage();
+        const enforcementItems = this.getPromptEnforcementReport().items;
+        const curationStatus = this.getContextCurationStatus();
+        const spawned = this.getSpawnedUsage();
+        const promptInclusion = this.getMemoryPromptInclusionReport();
+        const memoryEvidenceTokens = promptInclusion.status === "included" ? Math.ceil(promptInclusion.blockChars / 4) : 0;
+        // Enforcement stubs are applied at SEND time (not persisted), so the message view here
+        // still holds raw text for them; subtract what stubbing reclaims per request.
+        const enforcementSavedTokens = enforcementItems
+            .filter((item) => item.enforced && typeof item.originalChars === "number")
+            .reduce((sum, item) => sum + Math.max(0, Math.ceil((item.originalChars ?? 0) / 4) - 50), 0);
+        return buildContextCompositionReport({
+            systemPrompt: this.systemPrompt ?? "",
+            tools: this.getAllTools()
+                .filter((tool) => activeNames.has(tool.name))
+                .map((tool) => ({
+                name: tool.name,
+                description: tool.description,
+                parameters: tool.parameters,
+                source: extensionToolNames.has(tool.name) ? "extension" : "built-in",
+            })),
+            extensions: extensions.map((extension) => ({
+                name: basename(extension.path),
+                path: extension.path,
+                toolNames: [...extension.tools.keys()],
+                commandCount: extension.commands.size,
+            })),
+            messages: gcResult.messages,
+            providerReportedTokens: usage?.tokens ?? null,
+            contextWindow: usage?.contextWindow ?? this.model?.contextWindow ?? null,
+            gc: { packedCount: gcResult.report.packedCount, savedTokens: gcResult.report.savedTokens },
+            enforcement: {
+                enforcedCount: enforcementItems.filter((item) => item.enforced).length,
+                advisoryEvictions: enforcementItems.filter((item) => item.advisory === "brain_irrelevant").length,
+            },
+            curation: {
+                enabled: curationStatus.enabled,
+                telemetry: curationStatus.telemetry,
+                lastSkipReason: curationStatus.lastSkipReason,
+            },
+            spawned: { cost: spawned.cost, reports: spawned.reports },
+            adjustments: { memoryEvidenceTokens, enforcementSavedTokens },
+        });
+    }
+    /** Bounded plain-text rendering of {@link getContextCompositionReport} for the /context command. */
+    formatContextCompositionDashboard() {
+        return formatContextCompositionDashboard(this.getContextCompositionReport());
+    }
+    /** Curation status for diagnostics/dashboard: settings, live telemetry, last refusal reason. */
+    getContextCurationStatus() {
+        const settings = this.settingsManager.getContextCurationSettings();
+        return {
+            enabled: settings.enabled,
+            model: settings.model,
+            telemetry: this._brainCurator.telemetry(),
+            lastSkipReason: this._lastCurationSkipReason,
+        };
+    }
     /** Read-only inspection of the latest prompt-enforcement report, for tests/debugging. */
     getPromptEnforcementReport() {
         return this._latestPromptEnforcementReport ?? { turnIndex: this._turnIndex, items: [] };
@@ -877,6 +1122,7 @@ export class AgentSession {
             // default provider actually emits are never recognized as semantic-memory pages and
             // accumulate raw for the life of the session — the exact growth Bug #7 GC exists to stop.
             const providerMarkers = this._memoryManager.getContextMarkers();
+            const curationSettings = this.settingsManager.getContextCurationSettings();
             const result = applyContextGc(messages, {
                 ...settings,
                 semanticMemory: {
@@ -886,6 +1132,22 @@ export class AgentSession {
                 cwd: this._cwd,
                 storageDir: this._contextGcStorageDir(),
                 writePayloads,
+                curation: curationSettings.enabled
+                    ? {
+                        resolveDigest: (digestKey) => this._brainCurator.getDigest(digestKey),
+                        // Only the real per-turn pass enqueues work; the read-only report path
+                        // (writePayloads=false) stays side-effect free.
+                        onPacked: writePayloads
+                            ? (record, originalText) => {
+                                this._brainCurator.enqueue({
+                                    kind: "stub_digest",
+                                    key: record.key ?? record.toolCallId,
+                                    content: originalText,
+                                });
+                            }
+                            : undefined,
+                    }
+                    : undefined,
             });
             this._latestContextGcReport = result.report;
             // Only release/reclaim on the real per-turn pass (writePayloads=true), never on
@@ -3597,6 +3859,23 @@ export class AgentSession {
                 }
             }
         }
+        // Strict UAC: the active profile is the COMPLETE grant, so a tool the profile names
+        // explicitly is itself a request for that tool — it must ACTIVATE from the registry even
+        // if the session never requested it. Without this, activation is only ever the requested
+        // defaults ∩ allow-list, and a profile granting non-default tools (a search-only profile's
+        // grep/find) yields an empty or truncated tool set on load and /reload. A blanket "*"
+        // stays grant-only: activation then still derives from the request/defaults above.
+        const explicitAllowPatterns = toolProfileFilter?.allow.filter((pattern) => pattern !== "*") ?? [];
+        if (explicitAllowPatterns.length > 0) {
+            for (const toolName of this._toolRegistry.keys()) {
+                if (!isAllowedTool(toolName))
+                    continue;
+                if (matchesResourceProfilePattern(toolName, explicitAllowPatterns)) {
+                    nextActiveToolNames.push(toolName);
+                    autoActivated.push(toolName);
+                }
+            }
+        }
         // artifact_retrieve companion auto-activation is enforced inside
         // setActiveToolsByName() itself (not duplicated here), so every activation path --
         // including the public, extension-exposed setActiveTools() -- gets the same