@caupulican/pi-adaptative 0.81.38 → 0.81.40

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

@@ -1,8 +1,8 @@
 import type { Agent, AgentEvent, AgentLoopConfig, AgentMessage, AgentState, AgentTool, StreamIdleOptions, ThinkingLevel } from "@caupulican/pi-agent-core";
 import { type CustomMessage } from "@caupulican/pi-agent-core";
-import { type BranchSummaryEntry, type CompactionResult, type SessionManager } from "@caupulican/pi-agent-core/node";
-import type { CacheRetention, ImageContent, Message, Model, StopReason, TextContent, TextToolProtocolVariant, Usage } from "@caupulican/pi-ai";
-import type { CapabilityEnvelope, EvidenceBundle, LearningDecision, WorkerRequest, WorkerResult } from "./autonomy/contracts.ts";
+import type { BranchSummaryEntry, CompactionResult, SessionManager } from "@caupulican/pi-agent-core/node";
+import type { Api, CacheRetention, ImageContent, Message, Model, StopReason, TextContent, Usage } from "@caupulican/pi-ai";
+import type { CapabilityEnvelope, EvidenceBundle, LearningDecision, WorkerClaim, WorkerRequest } from "./autonomy/contracts.ts";
 import type { LaneRecord, LaneTerminalStatus } from "./autonomy/lane-tracker.ts";
 import type { AutonomyDiagnosticSnapshot, AutonomyStatusSnapshot, GateOutcomeHistoryEntry } from "./autonomy/status.ts";
 import type { BashResult } from "./bash-executor.ts";
@@ -18,21 +18,23 @@ import type { ContextGcReport } from "./context-gc.ts";
 import type { SessionCostSummary } from "./cost/cost-summary.ts";
 import type { DailyUsageTotals } from "./cost/daily-usage.ts";
 import { type CostGuardDecision } from "./cost-guard.ts";
+import type { WorkerDelegationRequest } from "./delegation/worker-delegation-request.ts";
 import type { WorkerRunOutcome } from "./delegation/worker-runner.ts";
 import type { ContextUsage, ExtensionCommandContextActions, ExtensionContext, ExtensionErrorListener, ExtensionRunner, ExtensionUIContext, InputSource, ReplacedSessionContext, SessionStartEvent, ShutdownHandler, ToolDefinition, ToolInfo } from "./extensions/index.ts";
 import { type ChannelProvider, GatewayRegistry, type JobSchedulerProvider } from "./gateways/channel-provider.ts";
 import type { GoalContinuationPrompt, GoalContinuationPromptLimits } from "./goals/goal-continuation-prompt.ts";
 import { type GoalRuntimeSnapshot, type GoalRuntimeSnapshotSettings } from "./goals/goal-runtime-snapshot.ts";
-import type { GoalState } from "./goals/goal-state.ts";
+import { type GoalState } from "./goals/goal-state.ts";
 import type { LearningAuditRecord } from "./learning/learning-audit.ts";
 import type { DemandSignals, ReflectionResult } from "./learning/reflection-engine.ts";
 import { type CurationProposals } from "./learning/skill-curator.ts";
 import type { MemoryProvider } from "./memory/memory-provider.ts";
-import { type ModelCapabilityProfile } from "./model-capability.ts";
+import { type LaneWorkerRefusal, type ModelCapabilityProfile } from "./model-capability.ts";
 import type { ModelRegistry } from "./model-registry.ts";
-import { type NativeToolProbeGrade } from "./models/adaptation-store.ts";
 import type { StoredFitnessReport } from "./models/fitness-store.ts";
+import type { PrismLlamaCppRuntime } from "./models/llamacpp-runtime.ts";
 import type { LocalRuntimeDeps, OllamaRuntime, TransformersRuntime } from "./models/local-runtime.ts";
+import type { OrchestrationProfile } from "./orchestration/contracts.ts";
 import { type PromptTemplate } from "./prompt-templates.ts";
 import type { ModelFitnessReport } from "./research/model-fitness.ts";
 import type { ResearchRunResult } from "./research/research-runner.ts";
@@ -41,6 +43,7 @@ import type { ResourceLoader } from "./resource-loader.ts";
 import { type ToolArgumentValidationStats } from "./session-analytics.ts";
 import type { ResourceProfileFilterSettings, SettingsManager } from "./settings-manager.ts";
 import { type TaskStepsState } from "./tasks/task-state.ts";
+import { type ToolProbeReport } from "./tool-protocol-controller.ts";
 import type { BashOperations } from "./tools/bash.ts";
 /**
  * Test hook: override the stream-idle bounds so a stall can be provoked in-suite without a
@@ -137,7 +140,7 @@ export interface AgentSessionConfig {
     agentDir?: string;
     /** Models to cycle through with Ctrl+P (from --models flag) */
     scopedModels?: Array<{
-        model: Model<any>;
+        model: Model<Api>;
         thinkingLevel?: ThinkingLevel;
     }>;
     /** Resource loader for skills, prompts, themes, context files, system prompt */
@@ -182,6 +185,8 @@ export interface AgentSessionConfig {
      * defaults to the real, best-effort collector.
      */
     collectWorkspaceSources?: typeof collectWorkspaceSources;
+    /** Immutable owner-authored orchestration policy; dispatch cannot mutate it. */
+    orchestrationProfile?: OrchestrationProfile;
     /**
      * Injected fetch/spawn/exists for the local (Ollama) runtime health-check + boot used by the
      * model router before a turn routed to a local model (see LocalRuntimeController.ensureLocalModelReady).
@@ -214,30 +219,27 @@ export interface PromptOptions {
     /** Whether an idle active goal should auto-inject bounded continuation prompts after this prompt settles. Default: true. */
     autoContinueGoal?: boolean;
 }
-export type ToolProbeVerdict = "native" | "text-protocol" | "none";
-export interface ToolProbeResult {
-    model: string;
-    verdict: ToolProbeVerdict;
-    variant?: TextToolProtocolVariant;
-    nativeGrade?: NativeToolProbeGrade;
-    diagnostic?: string;
-}
-export interface ToolProbeReport {
-    results: ToolProbeResult[];
-    table: string;
-}
+export type { ToolProbeReport, ToolProbeResult, ToolProbeVerdict } from "./tool-protocol-controller.ts";
 /** Result from cycleModel() */
 export interface ModelCycleResult {
-    model: Model<any>;
+    model: Model<Api>;
     thinkingLevel: ThinkingLevel;
     /** Whether cycling through scoped models (--models flag) or all available */
     isScoped: boolean;
 }
 /** Session statistics for /session command */
+export interface CompactionGateCheckStats {
+    failures: number;
+    minScore?: number;
+    maxScore?: number;
+    threshold?: number;
+    comparator?: "minimum" | "maximum";
+}
 export interface CompactionGateStats {
     gateFailures: number;
     deterministicGapFills: number;
     compactionsWithGateFailures: number;
+    checks: Record<string, CompactionGateCheckStats>;
 }
 export interface SessionStats {
     sessionFile: string | undefined;
@@ -261,6 +263,35 @@ export interface SessionStats {
 }
 /** customType for spawned-usage roll-up entries (Cost Aggregation, Model A). */
 export declare const SPAWNED_USAGE_CUSTOM_TYPE = "spawned_usage";
+/**
+ * customType for a persisted runaway-loop-backstop entry: the agent loop stopped a turn stuck
+ * repeating one identical tool-call signature. This is the session-log/telemetry sink for
+ * {@link Agent.onRunawayStop} — see `_installAgentToolHooks`.
+ */
+export declare const RUNAWAY_STOP_CUSTOM_TYPE = "runaway_stop";
+/** Payload persisted for a {@link RUNAWAY_STOP_CUSTOM_TYPE} entry. */
+export interface RunawayStopRecord {
+    signature: string;
+    repeats: number;
+    model?: string;
+    provider?: string;
+    at: string;
+}
+/**
+ * customType for a persisted tool-validation-escalation entry: the agent loop bounced the same
+ * tool-call validation failure enough times to escalate. This is the session-log/telemetry sink for
+ * {@link Agent.onToolValidationEscalation} — see `_installAgentToolHooks`.
+ */
+export declare const TOOL_VALIDATION_ESCALATION_CUSTOM_TYPE = "tool_validation_escalation";
+/** Payload persisted for a {@link TOOL_VALIDATION_ESCALATION_CUSTOM_TYPE} entry. */
+export interface ToolValidationEscalationRecord {
+    tool: string;
+    signature: string;
+    repeats: number;
+    model: string;
+    provider: string;
+    at: string;
+}
 /**
  * A single spawned/subagent usage report, persisted as a `CustomEntry`
  * (`customType: "spawned_usage"`). Persistence-only — does NOT enter LLM context.
@@ -297,7 +328,7 @@ export interface IsolatedCompletionOptions {
     /** 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>;
+    model?: Model<Api>;
     /** Thinking level. Defaults to "off" to keep the call cheap. */
     thinkingLevel?: ThinkingLevel;
     /** Output token cap. */
@@ -319,12 +350,38 @@ export interface IsolatedCompletionOptions {
     /** Abort signal. */
     signal?: AbortSignal;
     /**
-     * Prompt-cache retention for this isolated call. Defaults to `"none"` (no caching — preserves full
-     * isolation). Callers whose `systemPrompt` is STATIC across calls (e.g. reflection, #33) can pass
-     * `"short"`/`"long"` so the provider reuses the cached prefix and bills only the variable tail.
+     * Prompt-cache retention for this isolated call. REQUIRED — the provider-level default is
+     * `"short"`, the opposite of this primitive's old implicit default, so a caller that forgot to
+     * set it would silently pay full input price forever. Pass `"none"` explicitly to preserve full
+     * isolation (no caching); callers whose `systemPrompt` is STATIC across calls (e.g. reflection,
+     * #33) should pass `"short"`/`"long"` so the provider reuses the cached prefix and bills only the
+     * variable tail.
+     */
+    cacheRetention: CacheRetention;
+    /**
+     * Lane/caller kind (e.g. `"reflection"`, `"research"`, `"worker"`, `"fitness"`) used to derive this
+     * call's synthetic cache-affinity key (see {@link computeLaneAffinityKey}). Omitted callers fall
+     * back to {@link DEFAULT_ISOLATED_LANE_KIND} — still a stable, namespaced key, just not
+     * lane-differentiated. Never the real session id.
      */
-    cacheRetention?: CacheRetention;
+    laneKind?: string;
 }
+/** Fallback {@link IsolatedCompletionOptions.laneKind} for callers that do not tag their lane. */
+export declare const DEFAULT_ISOLATED_LANE_KIND = "isolated";
+/**
+ * Derive a STABLE synthetic cache-affinity key for an isolated completion lane. Isolated calls
+ * deliberately never carry the real session id (see reflection-controller.ts's isolation invariants —
+ * an isolated call must not entangle with the main session), which today also means every isolated
+ * call looks like a brand-new, uncorrelated session to providers with session-affinity headers /
+ * `prompt_cache_key` (anthropic.ts's `x-session-affinity`, openai-responses.ts /
+ * openai-completions.ts's `prompt_cache_key`), defeating their cache routing.
+ *
+ * This key is deterministic per `(laneKind, model, systemPrompt)` — the SAME lane calling the SAME
+ * model with the SAME (static) system prompt always gets the SAME key, so repeat calls route to the
+ * same cache-warm backend — while remaining fully synthetic: it is a salted hash, namespaced with a
+ * `lane:` prefix, and never derived from or equal to the real session id.
+ */
+export declare function computeLaneAffinityKey(laneKind: string, model: Model<Api> | undefined, systemPrompt: string): string;
 /** Result of an isolated completion: the text, the usage spent, and the stop reason. */
 export interface IsolatedCompletionResult {
     text: string;
@@ -356,7 +413,7 @@ export interface GoalContinuationOnceResult {
     snapshot: GoalRuntimeSnapshot;
     prompt?: GoalContinuationPrompt;
 }
-export type GoalContinuationLoopStopReason = "continuation_not_allowed" | "max_turns_reached" | "wall_clock_budget_reached" | "goal_state_not_advanced";
+export type GoalContinuationLoopStopReason = "continuation_not_allowed" | "max_turns_reached" | "wall_clock_budget_reached" | "goal_state_not_advanced" | "goal_budget_exhausted" | "already_continuing" | "session_disposed" | "goal_tool_unavailable" | "worker_in_flight";
 export interface GoalContinuationLoopOptions extends GoalContinuationOnceOptions {
     maxTurns: number;
     /** 0 or undefined disables wall-clock budget. */
@@ -383,17 +440,16 @@ export declare class AgentSession {
     private _queuedExtensionCommands;
     private _pendingNextTurnMessages;
     private _streamingPromptSubmissionTail;
+    /** Serializes owner-input overlays so concurrent worker terminals cannot replace each other. */
+    private _humanInputTail;
+    private _activeHumanInputRequestIds;
     /**
      * The last tool set requested via setActiveToolsByName BEFORE model-capability filtering, so
      * switching from a small-window model back to a large one restores the full requested set.
      */
     private _requestedActiveToolNames;
-    private _compactionAbortController;
-    private _autoCompactionAbortController;
-    private _overflowRecoveryAttempted;
     private _unboundToolGrantWarnings;
     private _branchSummaryAbortController;
-    private _retryController;
     private readonly _modelSelection;
     private readonly _bash;
     private readonly _profileFilter;
@@ -405,23 +461,21 @@ export declare class AgentSession {
     private _resourceLoader;
     private _customTools;
     private _cwd;
+    /** Per-agent persistent shell session identity: stable across runtime reloads, disposed with the session. */
+    private readonly _shellSessionKey;
     private _agentDir;
     private _collectWorkspaceSources;
     private readonly _localRuntimeController;
-    private readonly _modelAdaptationStore;
+    private readonly _toolProtocol;
     private _prefixWarmer;
     private readonly _completedPrefixWarms;
-    private readonly _repairModeSessionCounts;
-    private readonly _textProtocolParseFailures;
-    private _textProtocolParseObservedThisTurn;
-    private _textProtocolValidationOutcomeThisTurn;
     /** Assembles the session's base system prompt from live session state (see
      * system-prompt-builder.ts); owns the paired _baseSystemPromptOptions. */
     private readonly _systemPromptBuilder;
-    /** G3/G8 autonomy telemetry sink + status/diagnostic snapshots (see autonomy-telemetry.ts); owns
+    /** Autonomy telemetry sink + status/diagnostic snapshots (see autonomy-telemetry.ts); owns
      * the latest gate outcome and the bounded gate-outcome history. */
     private readonly _autonomyTelemetry;
-    /** Goal auto-continue + research lane + scout-worker delegation + model-fitness probe (see
+    /** Goal auto-continue + research lane + profile-bound worker delegation + model-fitness probe (see
      * background-lane-controller.ts); owns the lane timers/guards, the last research-lane skip
      * reason, the live LaneTracker, and the in-flight research/worker abort controllers. */
     private readonly _backgroundLanes;
@@ -430,6 +484,7 @@ export declare class AgentSession {
      * effectiveness tracker, and the extension-contributed pending providers. */
     private readonly _memory;
     private readonly _compactionSupport;
+    private readonly _compaction;
     /** Per-turn context-shaping subsystem (see context-pipeline.ts); owns the latest
      * audit/policy/correlation/enforcement/gc reports, the brain-curation sidecar + its skip reasons,
      * and the tool-output artifact store. Invoked stage-by-stage from the context transform. */
@@ -447,17 +502,25 @@ export declare class AgentSession {
     private readonly _analytics;
     private readonly _treeNavigator;
     private _lastCostGuardDecision?;
+    /**
+     * `getSpawnedUsage().cost` snapshotted at the start of the CURRENT foreground prompt cycle (see
+     * `_promptUnserialized`), so the cost guard can attribute only background/spawned spend since THIS
+     * turn began, not the session's entire lifetime spend. Reset on every new user prompt; every
+     * round-trip within the same turn (tool-call iterations) shares this one baseline.
+     */
+    private _costGuardTurnBaselineUsd;
     /** Per-turn model-router subsystem (see model-router-controller.ts); owns the transient route/intent,
      * the cheap-turn session buffer, the escalation/retry flags, and the sticky last-decision/skip-reason
      * used by the status report. Its parallel routed drive path delegates every turn back to
      * {@link _runAgentPrompt} so the drive loop stays host-side. */
     private readonly _modelRouter;
-    private readonly _billingFailover;
+    private readonly _foregroundRecovery;
     private readonly _failureCorpus;
     private readonly _toolRecoveryLogger;
     private readonly _toolRecoveryEventLogPath;
     private _skillCuratorInstance?;
     private _disposed;
+    private _disposeCompletion;
     private readonly _reflectionAbort;
     /** Native reflection engine + learning-apply/rollback path (see reflection-controller.ts); owns no
      * session state, applies durable writes through the bundled memory tool and the session log. */
@@ -520,6 +583,16 @@ export declare class AgentSession {
      * model, full system prompt, converted messages, and tool schemas are known. The guard is a
      * projection threshold rather than a hard output cap: warning mode never reduces capability, while
      * opt-in downgrade changes only this request's reasoning effort. Best-effort: never throws.
+     *
+     * The ceiling is turn-cumulative: the next foreground call's projection is folded together with
+     * background/research/worker/reflection spend recorded SINCE THIS TURN BEGAN — {@link getSpawnedUsage}'s
+     * already-recorded rollup (the same read-side-deduped total the footer's SUBAGENTS line uses) minus the
+     * baseline snapshotted before a new turn enters routing in `_promptUnserialized`
+     * ({@link _costGuardTurnBaselineUsd}) — so a
+     * turn that is cheap in the foreground but has spent heavily via background lanes THIS turn still trips
+     * the warning, while a prior turn's background spend does not keep every later turn's guard stuck
+     * "over". A background lane that finishes mid-turn is attributed to whichever turn it completes in.
+     * Per-lane dollar caps (research/worker `maxUsd`) are separate and untouched by this guard.
      */
     private _resolveCostGuardRequestReasoning;
     /** Latest cost-guard decision (for the host footer/UI to surface a warning). Undefined if disabled. */
@@ -545,36 +618,14 @@ export declare class AgentSession {
     restorePromotedSkill(name: string): boolean;
     private _installAgentTurnRefresh;
     private _createAgentContextSnapshot;
-    private _modelAdaptationKeyFor;
-    private _toolRepairSettings;
-    private _applyToolRepairLayerSettings;
-    private _getModelAdaptationRulesForPrompt;
-    private _textProtocolFlag;
-    private _streamForToolProbe;
-    private _textProtocolCalibrationContext;
-    private _messageHasToolCallWithStringArgument;
-    private _nativeToolProbeSystemPrompt;
-    private _runNativeReadTaskProbeTrial;
-    private _runNativeEchoToolProbeTrial;
-    private _gradeNativeToolCallingForModel;
-    private _runTextProtocolTrial;
-    private _calibrateTextToolProtocolForModel;
-    private _ensureTextToolProtocolForActiveModel;
-    private _modelRef;
-    private _formatToolProbeReport;
-    private _storeToolProbe;
+    /** Compatibility seam retained for focused auto-probe regressions. */
     private _probeToolCallingForModel;
-    private _resolveToolProbeModels;
+    /** Compatibility seam retained for focused protocol-selection doctrine regressions. */
+    private _resolveModelToolProtocol;
     probeToolCalling(target?: string): Promise<ToolProbeReport>;
-    private _handleTextToolProtocolParse;
-    private _handleTextToolProtocolValidationOutcome;
-    private _recordTextToolProtocolParseOutcomeFromLastAssistant;
-    private _looksLikeTextToolProtocolAttempt;
-    private _tagModelAdaptationRuleTeaching;
-    private _repairSessionCount;
-    private _handleModelAdaptationTelemetry;
     /** Tool-build call-site delegation to {@link ContextPipeline.getToolArtifactStore}. */
     private _getToolArtifactStore;
+    private _getSessionImageStore;
     /**
      * Context-transform hot-path delegation to {@link ContextPipeline.runContextAudit}. Kept as a
      * one-line method (not inlined) so the transform stays the single owner of the pass ordering.
@@ -663,18 +714,55 @@ export declare class AgentSession {
     private _applyContextGc;
     /** Read-only inspection of the latest context-gc report (delegates to {@link ContextPipeline.getContextGcReport}). */
     getContextGcReport(messages?: AgentMessage[]): ContextGcReport;
-    /**
-     * Context-transform hot-path delegation to {@link ContextPipeline.estimateCurrentContextTokens}. Kept
-     * as a one-line method (not inlined) so the transform stays the single owner of the pass ordering;
-     * also feeds the per-turn cost guard.
-     */
-    private _estimateCurrentContextTokens;
     private _installAgentToolHooks;
+    /**
+     * The runaway-loop backstop ({@link Agent.maxStallTurns}) stopped a turn stuck repeating one
+     * identical tool-call signature. Previously silent — this is the first host handler. Records a
+     * session-log/telemetry entry (see {@link RUNAWAY_STOP_CUSTOM_TYPE}) and surfaces a user-visible
+     * warning through the same event the context-window/compaction backstops use.
+     */
+    private _handleRunawayStop;
+    /**
+     * Evidence-gated native→phone auto-probe for a LOCAL/MANAGED model (never cloud — see
+     * {@link isLocalOrManagedRouterModel}) that just crossed the tool-argument-validation escalation
+     * threshold — repeated identical validation failures with no successful native call in between,
+     * which is exactly the graded evidence {@link Agent.onToolValidationEscalation} already requires
+     * before firing. Runs the SAME probe `/toolprobe` uses ({@link _probeToolCallingForModel}: native
+     * trials first, so a model that can actually tool-call natively still resolves to verdict
+     * "native" and is never phoned) entirely OFF the hot path — fired here but never awaited by the
+     * caller, so a slow or failing probe can never block or throw the user's in-flight turn.
+     * Anti-loop: skipped when this session already auto-probed this model, or a fresh persisted
+     * verdict already exists (enforced by {@link ToolProtocolController}) — otherwise a model that keeps
+     * failing validation every turn would re-fire the (multi-completion) probe every single turn.
+     */
+    private _maybeAutoProbeOnValidationEscalation;
+    /**
+     * A repeated identical tool-argument-validation failure crossed the escalation threshold
+     * ({@link Agent.toolValidationEscalationThreshold}) — the graded evidence the capability-gate
+     * spine acts on. Always records a session-log/telemetry entry (see {@link
+     * TOOL_VALIDATION_ESCALATION_CUSTOM_TYPE}), then branches on the failing model's class:
+     * - LOCAL/MANAGED ({@link isLocalOrManagedRouterModel}, never cloud): the failure is evidence the
+     *   model may lack native tool-calling, so it fires the evidence-gated native→phone auto-probe
+     *   off the hot path ({@link _maybeAutoProbeOnValidationEscalation}). Escalating a local model's
+     *   ROUTER TIER on a tool-call failure would not fix a capability problem, so this branch never
+     *   touches the model router.
+     * - CLOUD (known tool-capable): the failure is evidence the routed tier is too weak for this
+     *   request, so it escalates via {@link ModelRouterController.requestValidationFailureEscalation}
+     *   — de-conflated from the beforeToolCall mutation gate ({@link
+     *   ModelRouterController.maybeEscalateToolCall}/`shouldEscalateModelRouterTool`): repeated
+     *   validation failure is grounds to escalate REGARDLESS of the failing tool's mutation status,
+     *   so a read-only tool's repeated failure now escalates too (previously a no-op, since the old
+     *   code reused the mutation gate verbatim for this unrelated signal). Cloud models are never
+     *   probe-gated or phoned by this handler.
+     * If the registry can no longer resolve `event.model`/`event.provider` (e.g. the model was
+     * unregistered mid-session), falls back to the cloud/tier-escalation path — the previously
+     * existing behavior — rather than silently dropping the signal.
+     */
+    private _handleToolValidationEscalation;
     /** Emit an event to all listeners */
     private _emit;
     private _notifyWorkerTerminalHandoff;
     private _emitQueueUpdate;
-    private _lastAssistantMessage;
     /**
      * User messages already painted to the UI by an early, synthetic `message_start` fired from
      * `_promptUnserialized` — before the model-router judge's bounded LLM call — so the prompt
@@ -726,10 +814,12 @@ export declare class AgentSession {
      * Call this when completely done with the session.
      */
     dispose(): void;
+    /** Dispose synchronously-visible state, then await all session-owned asynchronous shutdowns. */
+    disposeAndWait(): Promise<void>;
     /** Full agent state */
     get state(): AgentState;
     /** Current model (may be undefined if not yet selected) */
-    get model(): Model<any> | undefined;
+    get model(): Model<Api> | undefined;
     /** Current thinking level */
     get thinkingLevel(): ThinkingLevel;
     /** Whether agent is currently streaming a response */
@@ -743,14 +833,14 @@ export declare class AgentSession {
      * Returns the names of tools currently set on the agent.
      */
     getActiveToolNames(): string[];
-    /** G7: build a foreground {@link CapabilityEnvelope} from the live session state (active tools, cwd, cost ceiling). */
+    /** Build a foreground {@link CapabilityEnvelope} from the live session state (active tools, cwd, cost ceiling). */
     private _buildForegroundEnvelopeFromState;
     /**
-     * G7: (re)build the foreground envelope for the current turn. Visibility only -- the foreground
+     * (Re)build the foreground envelope for the current turn. Visibility only -- the foreground
      * envelope is NOT enforced this round. Best-effort: never throws into the turn.
      */
     private _refreshForegroundEnvelope;
-    /** G7: the auto-constructed foreground envelope for the current/most-recent turn (visibility only). */
+    /** The auto-constructed foreground envelope for the current/most-recent turn (visibility only). */
     getForegroundEnvelope(): CapabilityEnvelope | undefined;
     /**
      * Get all configured tools with name, description, parameter schema, prompt guidelines, and source metadata.
@@ -764,7 +854,7 @@ export declare class AgentSession {
      * Changes take effect on the next agent turn.
      *
      * artifact_retrieve is auto-activated as a companion whenever an artifact-producing tool
-     * (grep, find, or run_toolkit_script) ends up in the resulting active set and artifact_retrieve
+     * (grep, find, run_toolkit_script, or ask_question) ends up in the resulting active set and artifact_retrieve
      * is registered (i.e. not excluded/
      * blocked/outside an allowlist -- the registry itself is built with that same filter,
      * so registry presence already tracks "allowed"). This is enforced here, not just in
@@ -791,12 +881,12 @@ export declare class AgentSession {
     get sessionName(): string | undefined;
     /** Scoped models for cycling (from --models flag) */
     get scopedModels(): ReadonlyArray<{
-        model: Model<any>;
+        model: Model<Api>;
         thinkingLevel?: ThinkingLevel;
     }>;
     /** Update scoped models for cycling */
     setScopedModels(scopedModels: Array<{
-        model: Model<any>;
+        model: Model<Api>;
         thinkingLevel?: ThinkingLevel;
     }>): void;
     /** File-based prompt templates */
@@ -807,10 +897,20 @@ export declare class AgentSession {
     private _refreshBaseSystemPrompt;
     /**
      * Build a system prompt for a specific tool surface WITHOUT touching the session's base prompt
-     * state (G4 router-swap; see {@link SystemPromptBuilder.buildSystemPromptForToolNames}).
+     * state (used by the router's model swap; see {@link SystemPromptBuilder.buildSystemPromptForToolNames}).
      */
     private _buildSystemPromptForToolNames;
     private _runAgentPrompt;
+    private _queueWorkerHumanInput;
+    private _schedulePendingWorkerHumanInputs;
+    private _scheduleWorkerHumanInput;
+    private _resolveWorkerHumanInput;
+    /**
+     * Re-enter an interrupted ask_question call from its durable request snapshot. Pending requests
+     * are presented again; already-checkpointed answers are replayed without asking twice. The
+     * original toolCallId is preserved so provider tool-call ordering remains valid on /resume.
+     */
+    resumePendingHumanInput(): Promise<boolean>;
     /**
      * Shared {@link OllamaRuntime} for a given server, lazily created and cached by baseUrl so every
      * caller — the router's readiness gate and any host UI's own model-lifecycle commands (e.g.
@@ -819,11 +919,25 @@ export declare class AgentSession {
      */
     getLocalRuntime(baseUrl?: string): OllamaRuntime;
     getTransformersRuntime(modelId: string, baseUrl?: string): TransformersRuntime;
+    /** Shared {@link PrismLlamaCppRuntime} for pi's own managed prism install — see
+     * {@link LocalRuntimeController.getPrismLlamaCppRuntime}. Delegates so `/models` and the
+     * readiness gate share the SAME cached instance, same contract as getLocalRuntime above. */
+    getPrismLlamaCppRuntime(): PrismLlamaCppRuntime;
     /** models.json registers a local model's baseUrl as `<server>/v1` (OpenAI-compat); the runtime's
      * own health/boot endpoints are on the Ollama-native server root. Delegates to
      * {@link LocalRuntimeController}; kept here for `_warnIfManualModelChoiceIsRisky`'s own use. */
     private _deriveOllamaServerUrl;
     private _ensureRouteModelReady;
+    /**
+     * Every local model the CURRENT (post-reload) configuration could still route a turn to —
+     * the foreground model plus any router tier (cheap/medium/expensive) that still resolves to a
+     * real, authed, non-exhausted model. Fed to {@link LocalRuntimeController.reconcile} via the
+     * `reconcileLocalRuntimes` hook above, ONLY after a reload generation has fully committed, so a
+     * local model dropped from the live configuration has its pi-spawned runtime stopped instead of
+     * leaking a child process, while one still referenced here is left untouched. Read-only — never
+     * used for routing itself.
+     */
+    private _collectEligibleLocalModelsForReconcile;
     getModelRouterStatus(formatLabel?: (label: string) => string): string;
     private _handlePostAgentRun;
     /**
@@ -926,7 +1040,7 @@ export declare class AgentSession {
      * Abort current operation and wait for agent to become idle.
      */
     abort(): Promise<void>;
-    setModel(model: Model<any>, options?: {
+    setModel(model: Model<Api>, options?: {
         persistSettings?: boolean;
     }): Promise<void>;
     /** Re-resolve startup profile model/thinking after allowed extension providers are bound. */
@@ -977,7 +1091,18 @@ export declare class AgentSession {
     private _checkContextWindowUsageWarning;
     private _checkCompaction;
     private _measureLiveContextTokensForCompaction;
+    /**
+     * Internal: Run auto-compaction with events.
+     */
     private _runAutoCompaction;
+    /**
+     * Run one compaction attempt, retrying retryable provider failures (stream stalls,
+     * 429/5xx, network drops) with the session's retry policy. The reliability kernel
+     * classifies a stall as retryable by design (see withStreamIdleWatchdog); without this
+     * loop a single transient killed the whole compaction while ordinary turns survived the
+     * same failure via auto-retry. Caller aborts are never retried; sleepAbortable rejects
+     * with the abort reason if the signal fires mid-backoff.
+     */
     private _compactWithRetry;
     /**
      * Toggle auto-compaction setting.
@@ -995,11 +1120,11 @@ export declare class AgentSession {
     /** Register a memory provider contributed by an extension; applied on the next memory (re)init. */
     registerMemoryProvider(provider: MemoryProvider): void;
     registerContextMemoryProvider(provider: ContextMemoryProvider): void;
-    /** R8: the gateway/scheduler registry. A deployment runner registers providers and drives start/stop. */
+    /** The gateway/scheduler registry. A deployment runner registers providers and drives start/stop. */
     get gateways(): GatewayRegistry;
-    /** R8: register a deployment-supplied transport channel (gateway). */
+    /** Register a deployment-supplied transport channel (gateway). */
     registerChannelProvider(provider: ChannelProvider): void;
-    /** R8: register a deployment-supplied job scheduler (cron). */
+    /** Register a deployment-supplied job scheduler (cron). */
     registerJobScheduler(provider: JobSchedulerProvider): void;
     private _refreshToolRegistry;
     reload(): Promise<void>;
@@ -1023,14 +1148,6 @@ export declare class AgentSession {
      * Falls back to full reload if any individual load/unload fails.
      */
     reconcileLoadedExtensions(): Promise<void>;
-    /**
-     * Check if an error is retryable (transient provider/network failures). Billing/quota and auth
-     * are terminal; context overflow is handled by compaction, not retry. The verdict comes from the
-     * reliability kernel's classifier, fed the host-computed context-overflow flag.
-     */
-    private _classifyAssistantError;
-    private _isRetryableError;
-    private _prepareRetry;
     /**
      * Cancel in-progress retry.
      */
@@ -1096,6 +1213,21 @@ export declare class AgentSession {
      * Retrieve the latest valid goal state snapshot from the session log.
      */
     getGoalStateSnapshot(): GoalState | undefined;
+    /**
+     * Persist one submitted continuation pass's turn/wall-clock/spend contribution onto the active
+     * goal's durable cumulative budget (see `GoalState.continuationTurnsUsed` et al.). This is the
+     * "persistence dep" `GoalLoopController` calls once per pass actually submitted — it, not the
+     * loop controller, is where USD gets attributed: it reads the session's OWN cumulative model
+     * spend (`getCostSummary().ownCost` — deliberately excludes worker/subagent spend, which is
+     * tracked and budgeted separately) and threads that single absolute reading into a
+     * `record_continuation_budget` event; the pure reducer in `goal-state.ts` derives the delta.
+     * A no-op when no goal state exists (defensive — in practice this is only ever called right
+     * after a pass the loop already confirmed was submitted against an active goal).
+     */
+    recordGoalContinuationPass(pass: {
+        turns: number;
+        wallClockMs: number;
+    }): void;
     /** Save native task-step state to the active session log. */
     saveTaskStepsStateSnapshot(state: TaskStepsState): string;
     /** Retrieve the latest valid native task-step state from the active session log. */
@@ -1107,26 +1239,43 @@ export declare class AgentSession {
      */
     saveEvidenceBundleSnapshot(bundle: EvidenceBundle): string;
     /**
-     * Retrieve the latest valid evidence bundle snapshot from the session log.
+     * Retrieve the latest valid evidence bundle snapshot from the active branch.
      */
     getEvidenceBundleSnapshot(): EvidenceBundle | undefined;
+    /** Retrieve all valid evidence bundle snapshots from the active branch. */
     getEvidenceBundleSnapshots(): EvidenceBundle[];
     /** Live lane records tracked by this process (running and terminal). */
     getLaneRecords(): LaneRecord[];
     private _emitAutonomyTelemetry;
     private _recordGateOutcome;
-    /** G8: copies of the bounded gate-outcome history, oldest first, latest last. */
+    /** Copies of the bounded gate-outcome history, oldest first, latest last. */
     getGateOutcomeHistory(): GateOutcomeHistoryEntry[];
-    saveWorkerResultSnapshot(result: WorkerResult, request?: WorkerRequest): string;
-    getWorkerResultSnapshots(): WorkerResult[];
+    saveWorkerClaimSnapshot(claim: WorkerClaim, request?: WorkerRequest): string;
+    getWorkerClaimSnapshots(): WorkerClaim[];
     saveLearningDecisionSnapshot(decision: LearningDecision): string;
     getLearningDecisionSnapshots(): LearningDecision[];
+    /**
+     * The single injection point that makes the goal-continuation snapshot lane-aware:
+     * `laneRecords` feeds BOTH `evaluateGoalContinuation`'s "waiting" branch (a worker dispatched
+     * against an open requirement) and the per-goal worker-spend overlay — read fresh here so BOTH the
+     * goal loop (`GoalLoopController`) and the idle scheduler (`BackgroundLaneController`) see the
+     * same live lane state, since both reach this same method.
+     */
     getGoalRuntimeSnapshot(settings: GoalRuntimeSnapshotSettings): GoalRuntimeSnapshot;
     /**
      * Capability profile derived from the CURRENT session model's own metadata (context window),
      * honoring the modelCapability.mode setting ("off" disables, a class name forces).
      */
     getModelCapabilityProfile(): ModelCapabilityProfile;
+    /**
+     * Whether the CURRENT session model may drive a worktree-sync lane worker (see
+     * `evaluateLaneWorkerRefusal` in model-capability.ts): full capability class, a DECLARED
+     * (registry) context window, an ADVERTISED native tool-call path (`Model.textToolCallProtocol`
+     * unset/false -- `true` means phone-only), and no graded `/toolprobe` demotion to
+     * "text-protocol"/"none" on record. An unprobed model (no verdict on record yet) is eligible on
+     * its advertised support alone. `undefined` means eligible.
+     */
+    getLaneWorkerRefusal(): LaneWorkerRefusal | undefined;
     /**
      * Run one bounded, read-only research pass and persist its results. Delegates to
      * {@link BackgroundLaneController}; see there for the full gating/budget/dedupe contract.
@@ -1137,14 +1286,10 @@ export declare class AgentSession {
         goalId?: string;
     }): Promise<ResearchLaneRunOutcome>;
     /**
-     * Run one bounded scout-worker delegation. Delegates to {@link BackgroundLaneController};
+     * Run one bounded profile-bound worker delegation. Delegates to {@link BackgroundLaneController};
      * consumed by the `delegate` tool.
      */
-    runWorkerDelegationOnce(request: {
-        instructions: string;
-        systemPrompt?: string;
-        memoryRead?: boolean;
-    }): Promise<WorkerDelegationRunOutcome>;
+    runWorkerDelegationOnce(request: WorkerDelegationRequest): Promise<WorkerDelegationRunOutcome>;
     /**
      * Probe a candidate model against the subagent contracts. Delegates to
      * {@link BackgroundLaneController}; probe spend is reported through spawned-usage accounting.
@@ -1163,6 +1308,13 @@ export declare class AgentSession {
     /** Fitness reports persisted for THIS host (measured evidence for architect/profile decisions). */
     getStoredFitnessReports(): StoredFitnessReport[];
     continueGoalOnce(options: GoalContinuationOnceOptions): Promise<GoalContinuationOnceResult>;
+    /**
+     * Public entry point for BOTH idle autosteer and manual (`/goal start`, `/goal-continue`)
+     * continuation. Delegates to {@link BackgroundLaneController.continueGoalLoopExclusive}, the
+     * single-flight guard that prevents two goal loops from racing to submit prompts through the
+     * same session (which throws "Agent is already processing" from the second submission). Do not
+     * call `this._goalContinuation.continueGoalLoop` directly from here — that bypasses the guard.
+     */
     continueGoalLoop(options: GoalContinuationLoopOptions): Promise<GoalContinuationLoopResult>;
     /**
      * Run a one-shot LLM completion fully ISOLATED from the main session — the load-bearing primitive
@@ -1170,13 +1322,13 @@ export declare class AgentSession {
      */
     runIsolatedCompletion(opts: IsolatedCompletionOptions): Promise<IsolatedCompletionResult>;
     /**
-     * Native end-of-loop reflection pass (R2). Delegates to {@link ReflectionController}; returns null
+     * Native end-of-loop reflection pass. Delegates to {@link ReflectionController}; returns null
      * when the demand gate skips or in a child session.
      */
     runReflectionPass(input: {
         signals: DemandSignals;
         recentTurnText: string;
-        model?: Model<any>;
+        model?: Model<Api>;
         thinkingLevel?: ThinkingLevel;
         signal?: AbortSignal;
         /** Stable id so a duplicate scheduling/retry of the same pass can't double-count its cost. */