@prestyj/cli 5.30.0 → 5.30.2

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

@@ -11,7 +11,7 @@ import { type ContextLimits } from "./context-limits.js";
 import { type ImportForeignTranscriptResult } from "./foreign-session-import.js";
 import { type CacheExpiryStatus } from "./cache-expiry.js";
 import { type EnhanceResult } from "../utils/prompt-enhancer.js";
-import { type VerificationEvidence } from "./verification-evidence.js";
+import type { VerificationEvidence } from "./verification-evidence.js";
 /** A chat attachment (image / video / other file) prepared for the model. The
  *  raw base64 `data` rides native blocks; `path` (when persisted to disk) lets
  *  the agent's tools open the file directly. */
@@ -193,18 +193,12 @@ export interface AgentSessionOptions {
     additionalTools?: AgentTool[];
     /** Mode-owned completion policy; absent in Coder/chat/worker sessions. */
     completionReview?: CompletionReview;
+    /** Remind the agent to submit its plan (exit_plan) when a run is about to
+     *  stop still in plan mode. Desktop only: an unsubmitted plan there leaves
+     *  nothing to review. See plan-submission-gate.ts. */
+    planSubmissionGate?: boolean;
 }
-/** Resolve the per-result cap passed to the agent loop for the active transport. */
-export declare function resolveSessionToolResultCharLimit(model: string, provider: Provider, accountId?: string): number;
-/**
- * Aggregate budget for ALL tool results produced in one assistant turn.
- * Individual results are already capped, but wide parallel fan-outs (GPT-5.6's
- * signature behavior) were observed injecting 100k+ uncached tokens in a single
- * turn. ~15% of the context window in chars (1 token ≈ 3.5 chars), floored at
- * 100KB so small windows still fit two full-size reads, ceilinged at 240KB so
- * 1M-context models don't waive the budget entirely.
- */
-export declare function resolveSessionTurnToolResultCharLimit(model: string, provider: Provider, accountId?: string): number;
+export { resolveSessionToolResultCharLimit, resolveSessionTurnToolResultCharLimit, } from "./agent-session/helpers.js";
 export interface AgentSessionState {
     provider: Provider;
     model: string;
@@ -226,10 +220,7 @@ export declare class AgentSession {
     private sessionManager;
     private extensionLoader;
     private messages;
-    private nolanTurns;
-    private autopilotMarkers;
-    private appMarkers;
-    private turnMetrics;
+    private readonly markers;
     private readonly cacheDiagnostics;
     /** Internal-only (EZ_INTERNAL): live per-session cost/reliability recorder.
      * Absent entirely in public builds — see core/internal-diagnostics.ts. */
@@ -245,25 +236,8 @@ export declare class AgentSession {
     private recordBashReads;
     private skills;
     private cacheKeyLogged;
-    private hookStats;
-    private hookText;
-    private hookConsecutiveFailures;
-    private hookRepeatedNoProgressCalls;
-    private hookProgressTracker;
-    private hookCycleDetector;
-    private hookCyclicPattern;
-    private hookFileEditCounts;
-    private hookToolCalls;
-    private backgroundVerification;
-    /** 0 = none; 1 = first nudge sent; 2 = final stop-and-report injected. */
-    private loopBreakInjected;
+    private readonly loopMonitor;
     private regroundingInjected;
-    /** Recent tool-call digests for the semantic loop judge — bounded ring. */
-    private hookRecentCalls;
-    /** LLM-judged loop detection state. `verdict` holds a LOOP verdict awaiting
-     *  injection at the next steering poll; judge failures fail open (no
-     *  injection) and still consume budget + cooldown. */
-    private semanticLoop;
     /**
      * The environment as the cached system prompt currently describes it.
      * Re-recorded on every prompt build, so a rebuild (e.g. `/add-dir`) needs no
@@ -274,10 +248,14 @@ export declare class AgentSession {
     private runStartedAt;
     /** Gate injections spent this run, capped by MAX_PROCESS_GATE_INJECTIONS. */
     private processGateInjected;
+    /** Plan-submission reminders spent this run (plan-submission-gate.ts). */
+    private planSubmissionNudges;
     /** Verification gate: code edited this run, nothing proved it since. Always
      *  tracks evidence for run status; the `verificationGateEnabled` setting
      *  decides whether an unverified stop is also continued once. */
     private readonly verificationGate;
+    /** Host-observed evidence (edited files, in-flight and background checks) feeding the gate. */
+    private readonly verificationTracker;
     /** Mirror of the last `hook_armed` value, so the event fires only on an edge. */
     private preFinalArmed;
     private compactionOccurred;
@@ -320,9 +298,8 @@ export declare class AgentSession {
     private readonly notifications;
     private managerAbortSignal?;
     private readonly managerAbortHandler;
-    private mcpManager?;
-    /** Deferred MCP tools awaiting discovery via tool_search. */
-    private mcpCatalog?;
+    /** MCP client, deferred tool_search catalog and cached-stub reconcile state. */
+    private readonly mcp;
     /** Resolved prompt-injection byte budgets (contextLimits setting). */
     private contextLimits;
     /**
@@ -331,11 +308,6 @@ export declare class AgentSession {
      * can discover and promote them; a promoted name drops out of this list.
      */
     private deferredBuiltinToolNames;
-    /** Live (connected) MCP tools by name — the reconcile target for cached stubs. */
-    private liveMcpTools;
-    /** Server name for each cached-only tool, so a stub knows what to wait on. */
-    private cachedMcpToolServers;
-    private readonly mcpCatalogCache;
     private provider;
     private model;
     private cwd;
@@ -444,43 +416,27 @@ export declare class AgentSession {
      * pushed eagerly when the user opted out.
      * Allow-listed sessions (Nolan) always get the eager path — their fixed tool
      * expectations predate the catalog, and tool_search isn't allow-listed.
-     * Promotion pushes onto the live `this.tools` array the running agent loop
-     * re-reads every turn, so promoted tools are callable on the next step.
      */
     private addMcpTools;
     /**
-     * Register `tool_search` once. Promotion of a cached-only entry waits for its
-     * server so the model is told immediately when that capability turns out to
-     * be unreachable, instead of promoting a tool that fails on first call.
-     *
-     * The catalog is created on demand rather than required up front: deferred
-     * built-in tools populate it with zero MCP servers connected, so gating
-     * registration on an existing catalog would leave those tools unreachable.
-     */
-    private ensureToolSearchTool;
-    /**
-     * `wait_agent` is deferred, yet nearly every `spawn_agent` is followed by it,
-     * so the model spent a whole turn on `tool_search` just to load it (bench 41:
-     * ~6 s per fan-out). Promote it as soon as a spawn succeeds instead: the tool
-     * list grows exactly as it would after that `tool_search`, one turn earlier,
-     * and sessions that never spawn keep the smaller prefix.
+     * Deferred follow-up tools whose need is certain once a trigger succeeds.
+     * `wait_agent` follows nearly every `spawn_agent`, and loading it through
+     * `tool_search` cost a whole turn (bench 41: ~6 s per fan-out). Likewise a
+     * background `bash` is always followed by `task_output` (and sometimes
+     * `task_send`/`task_stop`). Promote them as soon as the trigger succeeds: the
+     * tool list grows exactly as it would after that `tool_search`, one turn
+     * earlier, and sessions that never trigger keep the smaller prefix.
+     * Call before tier partitioning so a deferred trigger is wrapped too.
      */
-    private promoteWaitAgentAfterSpawn;
-    /** Append tools, replacing any same-named entry (cached stub → live tool). */
-    private replaceOrPushTools;
-    /** Swap already-promoted cached stubs for their live equivalents, in place. */
-    private replaceLivePromotedTools;
+    private promoteFollowUpTools;
+    /** Append a deferred built-in to the live tool list (append-only). */
+    private promoteDeferredBuiltin;
+    private wrapToPromote;
     /**
      * Publish cached tool definitions into the deferred catalog so `tool_search`
-     * answers correctly on turn 1. A cached stub carries the real name, one-line
-     * description and input schema; calling it waits for the live connection and
-     * then dispatches against the real client, or returns a clear error when that
-     * server ultimately failed. Live tools replace stubs on connect.
+     * answers correctly on turn 1 (see {@link McpToolRegistry.seedFromCache}).
      */
     private seedMcpCatalogFromCache;
-    /** Catalog-only registration for cached stubs — never marks them live. */
-    private addCachedMcpTools;
-    private buildCachedMcpTool;
     /**
      * Resolve a `/name [args]` input to the prompt template it expands into, or
      * null when it isn't a prompt-template command for THIS session (an ordinary
@@ -839,7 +795,6 @@ export declare class AgentSession {
     getMessages(): Message[];
     getTurnMetrics(): TurnMetricPayload[];
     private persistTurnMetric;
-    private rePersistTurnMetrics;
     /** Nolan Grout (mentor) turns recorded against this session, in record order. Used
      *  by the host to interleave Nolan's advisory exchanges back into the transcript
      *  on resume. Never part of the LLM message history. */
@@ -870,11 +825,6 @@ export declare class AgentSession {
      * appendEntry's own handling.
      */
     persistNolanTurn(question: string, reply: string): Promise<void>;
-    /** Re-append the in-memory Nolan turns to the current session file. Called after
-     *  a continuation/compaction file is created so Nolan's advisory history isn't
-     *  lost when the session is rewritten (those rewrites only re-persist
-     *  messages). Each turn keeps its original `afterMessageCount` anchor. */
-    private rePersistNolanTurns;
     /**
      * Record one autopilot verdict marker (prompted / done / human / capped)
      * against this build session. Kept in memory for the live transcript and
@@ -883,7 +833,6 @@ export declare class AgentSession {
      * instead of dropping the marker or falling back to a raw verdict string.
      * No-op persistence for transient sessions (kept in memory only).
      */
-    private recordFinishedBackgroundVerification;
     getVerificationEvidence(): VerificationEvidence[];
     /** Current request activity, separate from persistent workspace verification debt. */
     getRunVerificationActivity(): {
@@ -891,7 +840,6 @@ export declare class AgentSession {
         checked: boolean;
         evidence: VerificationEvidence[];
     };
-    private finishSnapshotVerification;
     getVerificationProblem(): string | null;
     private persistCompletionReviewState;
     private persistVerificationState;
@@ -899,10 +847,6 @@ export declare class AgentSession {
         reason?: string;
         body?: string;
     }): Promise<void>;
-    /** Re-append the in-memory autopilot markers to the current session file.
-     *  Mirrors `rePersistNolanTurns` — called after a continuation/compaction file
-     *  is created so the auto-review history survives the rewrite. */
-    private rePersistAutopilotMarkers;
     /** App transcript markers recorded against this session, in record order.
      *  Used by the host to interleave display-only rows (plan banner, task
      *  header, errors, user-bubble hints) back into the transcript on resume. */
@@ -927,10 +871,6 @@ export declare class AgentSession {
     persistRunStarted(generation: number): Promise<void>;
     /** Close the run journal. Its absence is what marks a run as crashed. */
     persistRunFinished(generation: number, outcome: RunOutcome): Promise<void>;
-    /** Re-append the in-memory app markers to the current session file. Mirrors
-     *  `rePersistNolanTurns` — called after a continuation/compaction file is
-     *  created so display-only rows survive the rewrite. */
-    private rePersistAppMarkers;
     /**
      * Rewrite a draft prompt into a tighter, terminology-correct version using
      * the ACTIVE provider/model. A stateless one-off LLM call (no agent loop, no