@caupulican/pi-adaptative 0.80.58 → 0.80.60

package/CHANGELOG.md

@@ -1,3 +1,21 @@
+## [0.80.60] - 2026-06-27
+
+### Fixed
+
+- Resource profiles are now the final authority everywhere: a profile-blocked skill, prompt, theme, or extension can no longer be selected or invoked by the user or the agent — including after a runtime profile switch. Skills/prompts/themes load fully (so the profile editor can show them) but are filtered at every use surface; extensions stay load-gated (a blocked extension is never loaded or allowed to run).
+- The profile resource editor can now be cancelled/aborted (Ctrl+Q / Esc / interrupt) without saving; the footer advertises it.
+
+### Added
+
+- The system prompt now lists the agent's loaded capabilities — active skills, tools, and extensions (with names and descriptions) — so the agent can answer "list your capabilities" accurately. Extensions show a real name/description instead of `index.ts`.
+
+## [0.80.59] - 2026-06-27
+
+### Added
+
+- Native reflection engine: when auto-learn is enabled, pi now learns in-process at the end of a turn (demand-gated, cheap model) and writes durable lessons via the `memory` tool, replacing the external continuous-learning subprocess. Set `PI_NATIVE_REFLECTION=0` to fall back to the legacy path.
+- `AgentSession.runIsolatedCompletion(...)`: a one-shot LLM call fully isolated from the session (no history/log/tool mutation, no prompt-cache churn) — the primitive the reflection engine runs on.
+
 ## [0.80.58] - 2026-06-27
 
 ### Added

package/dist/core/agent-session.d.ts

@@ -13,11 +13,12 @@
  * Modes use this class and add their own I/O layer on top.
  */
 import type { Agent, AgentEvent, AgentMessage, AgentState, AgentTool, ThinkingLevel } from "@caupulican/pi-agent-core";
-import type { ImageContent, Model, TextContent, Usage } from "@caupulican/pi-ai";
+import type { ImageContent, Message, Model, StopReason, TextContent, Usage } from "@caupulican/pi-ai";
 import { type BashResult } from "./bash-executor.ts";
 import { type CompactionResult } from "./compaction/index.ts";
 import { type ContextGcReport } from "./context-gc.ts";
 import { type ContextUsage, type ExtensionCommandContextActions, type ExtensionContext, type ExtensionErrorListener, ExtensionRunner, type ExtensionUIContext, type InputSource, type ReplacedSessionContext, type SessionStartEvent, type ShutdownHandler, type ToolDefinition, type ToolInfo } from "./extensions/index.ts";
+import { type DemandSignals, type ReflectionResult } from "./learning/reflection-engine.ts";
 import type { MemoryProvider } from "./memory/memory-provider.ts";
 import type { CustomMessage } from "./messages.ts";
 import type { ModelRegistry } from "./model-registry.ts";
@@ -206,6 +207,30 @@ export interface SpawnedUsageTotals {
     /** Number of distinct reports recorded. */
     reports: number;
 }
+/**
+ * Options for {@link AgentSession.runIsolatedCompletion} — a one-shot LLM call fully isolated from
+ * the main session (used by the native reflection engine, R2). See the adaptive-agent design §6c/§7.
+ */
+export interface IsolatedCompletionOptions {
+    /** System prompt for the isolated call. */
+    systemPrompt: string;
+    /** The isolated conversation (e.g. the reflection prompt). NOT the main session history. */
+    messages: Message[];
+    /** Model to use. Defaults to the session model; callers should pass a cheap model. */
+    model?: Model<any>;
+    /** Thinking level. Defaults to "off" to keep the call cheap. */
+    thinkingLevel?: ThinkingLevel;
+    /** Output token cap. */
+    maxTokens?: number;
+    /** Abort signal. */
+    signal?: AbortSignal;
+}
+/** Result of an isolated completion: the text, the usage spent, and the stop reason. */
+export interface IsolatedCompletionResult {
+    text: string;
+    usage: Usage;
+    stopReason: StopReason;
+}
 export declare class AgentSession {
     readonly agent: Agent;
     readonly sessionManager: SessionManager;
@@ -732,6 +757,38 @@ export declare class AgentSession {
     }): string | undefined;
     /** Aggregate all recorded spawned-usage reports (see {@link addSpawnedUsage}). */
     getSpawnedUsage(): SpawnedUsageTotals;
+    /**
+     * Run a one-shot LLM completion fully ISOLATED from the main session — the load-bearing
+     * primitive for the native reflection engine (adaptive-agent design §6c/§7).
+     *
+     * Isolation invariants (audited by codex): builds a fresh {@link Context} (no main history), runs
+     * with `tools: []`, sets `cacheRetention: "none"`, and passes **no `sessionId`** — so it cannot
+     * mutate `agent.state.messages`, cannot append session entries, cannot touch the tool registry,
+     * and cannot churn the main session's prompt cache. Mirrors `generateSummary()`'s mechanics.
+     *
+     * Returns the result even on an error/aborted stop reason (callers — e.g. a background reflection
+     * microtask — decide whether to act); it does not throw on a model-level error.
+     */
+    runIsolatedCompletion(opts: IsolatedCompletionOptions): Promise<IsolatedCompletionResult>;
+    /**
+     * Native end-of-loop reflection pass (R2). Demand-gates (zero-I/O), and when warranted runs the
+     * {@link ReflectionEngine} via an isolated completion ({@link runIsolatedCompletion}), applies the
+     * resulting memory writes through the bundled `memory` tool, and accounts the reflection's token
+     * cost via the cost-aggregation surface so it stays visible and net-negative-auditable.
+     *
+     * Returns `null` when the gate skips (or in a child session, which must not learn). The whole pass
+     * is best-effort: a model/parse error yields no writes, never throws into the caller.
+     */
+    runReflectionPass(input: {
+        signals: DemandSignals;
+        recentTurnText: string;
+        model?: Model<any>;
+        thinkingLevel?: ThinkingLevel;
+        signal?: AbortSignal;
+        /** Stable id so a duplicate scheduling/retry of the same pass can't double-count its cost. */
+        reportId?: string;
+    }): Promise<ReflectionResult | null>;
+    private _applyReflectionWrite;
     getContextUsage(): ContextUsage | undefined;
     /**
      * Export session to HTML.