@caupulican/pi-adaptative 0.81.39 → 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,6 +18,7 @@ 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";
@@ -30,10 +31,10 @@ import { type CurationProposals } from "./learning/skill-curator.ts";
 import type { MemoryProvider } from "./memory/memory-provider.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";
@@ -42,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
@@ -138,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 */
@@ -183,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).
@@ -215,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;
@@ -327,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. */
@@ -380,7 +381,7 @@ export declare const DEFAULT_ISOLATED_LANE_KIND = "isolated";
  * 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<any> | undefined, systemPrompt: string): string;
+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;
@@ -439,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;
@@ -466,31 +466,16 @@ export declare class AgentSession {
     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;
-    /** Total text-protocol parse-failure events observed this session, backing the
-     * {@link TEXT_TOOL_PROTOCOL_STEER_INTERVAL} throttle on {@link _maybeInjectTextProtocolCorrectiveSteer}. */
-    private _textProtocolCorrectiveSteerCount;
-    /** Monotonic counter backing tool-probe/text-protocol-calibration spawned-usage reportIds
-     * (see {@link _nextProbeUsageReportId}); guarantees each probe/calibration completion in the
-     * session lands in the cost ledger exactly once, even across repeated /toolprobe invocations. */
-    private _toolProbeUsageReportSeq;
-    /** Anti-loop: modelKeys the evidence-gated auto-probe has already fired for THIS session (see
-     * {@link _maybeAutoProbeOnValidationEscalation}), so a burst of validation-escalation events for
-     * the same still-failing model never re-fires the probe more than once per session. */
-    private readonly _autoProbedModels;
-    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;
     /** 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;
@@ -499,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. */
@@ -528,12 +514,13 @@ export declare class AgentSession {
      * 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. */
@@ -600,7 +587,8 @@ export declare class AgentSession {
      * 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 at the top of `_promptUnserialized` ({@link _costGuardTurnBaselineUsd}) — so a
+     * 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.
@@ -630,67 +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;
-    /** Builds a reportId that uniquely identifies one probe/calibration completion within the
-     * session: the model, a caller-supplied `kind` (e.g. "read-task", "echo", or
-     * "text-protocol:<variant>"), and a monotonic sequence number. The sequence number (not
-     * wall-clock time or randomness) is what guarantees no collision even when the same model+kind
-     * is probed again later in the session (e.g. a repeated /toolprobe run), so genuine repeat spend
-     * is never silently deduped away. */
-    private _nextProbeUsageReportId;
-    private _resolveProbeStreamCountingUsage;
-    private _textProtocolCalibrationContext;
-    private _messageHasToolCallWithStringArgument;
-    private _nativeToolProbeSystemPrompt;
-    private _runNativeReadTaskProbeTrial;
-    private _runNativeEchoToolProbeTrial;
-    private _gradeNativeToolCallingForModel;
-    private _runTextProtocolTrial;
-    private _calibrateTextToolProtocolForModel;
-    private _ensureTextToolProtocolForActiveModel;
-    private _modelRef;
-    /** The persisted `/toolprobe` verdict on record for this model, if any (undefined = unprobed). */
-    private _toolProbeVerdict;
-    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>;
-    /**
-     * The text-protocol circuit breaker. Every parse failure (from either the
-     * live per-completion {@link Agent.onTextToolProtocolParse} callback or the post-hoc detection in
-     * {@link _recordTextToolProtocolParseOutcomeFromLastAssistant}) gets a throttled one-line
-     * corrective steer for the next turn. On the 3rd consecutive SAME-SIGNATURE failure — graded
-     * evidence a model genuinely cannot speak this dialect, not a single bad turn — the breaker also
-     * demotes the persisted tool-probe verdict to "none" so {@link _textProtocolFlag} reads false next
-     * turn and native is attempted instead of thrashing on a protocol this model has proven it can't
-     * follow.
-     */
-    private _handleTextToolProtocolParse;
-    /**
-     * A phone model whose envelope fails to parse gets no corrective guidance today —
-     * the runaway-loop backstop only trips on repeated PARSED tool-call signatures (agent-loop.ts), so
-     * an every-turn unparseable-prose model never trips it. Inject a one-line reminder of the envelope
-     * shape as a nextTurn message, reusing {@link formatVariantEnvelope} so the reminder can never
-     * drift from the grammar the primer actually teaches. Throttled to the first failure this session
-     * and then every {@link TEXT_TOOL_PROTOCOL_STEER_INTERVAL}th after — the breaker above is what
-     * actually demotes a genuinely-failing model at the 3rd same-signature failure; this is guidance,
-     * not a second counter.
-     */
-    private _maybeInjectTextProtocolCorrectiveSteer;
-    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.
@@ -779,12 +714,6 @@ 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
@@ -793,11 +722,6 @@ export declare class AgentSession {
      * warning through the same event the context-window/compaction backstops use.
      */
     private _handleRunawayStop;
-    /** Anti-loop: true when this model's persisted tool-probe verdict was written within the
-     * auto-probe freshness window ({@link AUTO_TOOL_PROBE_FRESHNESS_MS}) — covers a very recent
-     * explicit `/toolprobe` run or a fresh circuit-breaker demote from an EARLIER session, complementing
-     * the in-session {@link _autoProbedModels} latch. */
-    private _hasFreshToolProbeVerdict;
     /**
      * Evidence-gated native→phone auto-probe for a LOCAL/MANAGED model (never cloud — see
      * {@link isLocalOrManagedRouterModel}) that just crossed the tool-argument-validation escalation
@@ -808,7 +732,7 @@ export declare class AgentSession {
      * "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 ({@link _hasFreshToolProbeVerdict}) — otherwise a model that keeps
+     * 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;
@@ -839,7 +763,6 @@ export declare class AgentSession {
     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
@@ -891,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 */
@@ -929,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
@@ -956,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 */
@@ -976,6 +901,16 @@ export declare class AgentSession {
      */
     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.
@@ -1105,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. */
@@ -1156,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.
@@ -1202,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.
      */
@@ -1301,9 +1239,10 @@ 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[];
@@ -1311,8 +1250,8 @@ export declare class AgentSession {
     private _recordGateOutcome;
     /** 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[];
     /**
@@ -1347,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.
@@ -1393,7 +1328,7 @@ export declare class AgentSession {
     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. */