@prestyj/cli 5.3.0 → 5.4.0

package/dist/core/agent-session.js

@@ -8,7 +8,7 @@ import { SettingsManager } from "./settings-manager.js";
 import { AuthStorage } from "./auth-storage.js";
 import { getClaudeCliUserAgent } from "./claude-code-version.js";
 import { kimiCodingHeaders, isKimiCodingEndpoint } from "./oauth/kimi.js";
-import { SessionManager, NOLAN_TURN_CUSTOM_KIND, } from "./session-manager.js";
+import { SessionManager, NOLAN_TURN_CUSTOM_KIND, AUTOPILOT_MARKER_CUSTOM_KIND, APP_MARKER_CUSTOM_KIND, } from "./session-manager.js";
 import { ExtensionLoader } from "./extensions/loader.js";
 import { shouldCompact, compact, getCompactionReserveTokens } from "./compaction/compactor.js";
 import { getAuthStorageKeys, getContextWindow, getModel, MODELS } from "./model-registry.js";
@@ -17,6 +17,8 @@ import { ensureAppDirs } from "../config.js";
 import { buildSystemPrompt } from "../system-prompt.js";
 import { createTools, createWebSearchTool, } from "../tools/index.js";
 import { MCPClientManager, getAllMcpServers } from "./mcp/index.js";
+import { DeferredToolCatalog } from "./mcp/deferred-catalog.js";
+import { createToolSearchTool } from "../tools/tool-search.js";
 import { log } from "./logger.js";
 import { setEstimatorModel } from "./compaction/token-estimator.js";
 import { discoverAgents } from "./agents.js";
@@ -45,6 +47,17 @@ export class AgentSession {
     // transcript. Each carries the non-system message count at record time so the
     // webview can interleave them chronologically.
     nolanTurns = [];
+    // Autopilot Nolan (auto-reviewer) markers recorded against this build session:
+    // the review verdict shown in the transcript (prompted / done / human /
+    // capped). Same not-on-the-DAG treatment as nolanTurns — advisory only,
+    // persisted + reloaded so a resumed session shows the identical Nolan bubble
+    // the live run showed instead of dropping it or replaying a raw verdict.
+    autopilotMarkers = [];
+    // Generic app transcript markers (plan-mode banner, task header, error rows,
+    // user-bubble display hints). Same not-on-the-DAG treatment as nolanTurns —
+    // display only, persisted + reloaded so a resumed session shows the same
+    // transcript rows the live run showed.
+    appMarkers = [];
     tools = [];
     /** Rebuilds the read tool for a new model (video byte cap is baked in at
      *  creation). Called from switchModel so video-capable models get the
@@ -87,6 +100,8 @@ export class AgentSession {
     processManager;
     lspManager;
     mcpManager;
+    /** Deferred MCP tools awaiting discovery via tool_search (bench A win). */
+    mcpCatalog;
     provider;
     model;
     cwd;
@@ -352,7 +367,7 @@ export class AgentSession {
             const mcpTools = this.opts.allowedTools
                 ? connected.filter((t) => this.isToolAllowed(t.name))
                 : connected;
-            this.tools.push(...mcpTools);
+            this.addMcpTools(mcpTools);
             // Background connect resolves AFTER initialize() has already built the
             // system prompt (the default path awaits this before buildSystemPrompt,
             // so its prompt already lists the tools). Refresh messages[0] so the
@@ -369,6 +384,31 @@ export class AgentSession {
             log("WARN", "mcp", `MCP initialization failed: ${err instanceof Error ? err.message : String(err)}`);
         }
     }
+    /**
+     * Route freshly connected MCP tools: deferred into the tool_search catalog
+     * (default — keeps ~8k tokens of schema out of every cache-miss turn, see
+     * bench/RESULTS.md bench A) or 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.
+     */
+    addMcpTools(mcpTools) {
+        if (mcpTools.length === 0)
+            return;
+        const defer = !this.opts.allowedTools && this.settingsManager.get("deferredMcpTools");
+        if (!defer) {
+            this.tools.push(...mcpTools);
+            return;
+        }
+        this.mcpCatalog ??= new DeferredToolCatalog();
+        this.mcpCatalog.add(mcpTools);
+        if (!this.tools.some((t) => t.name === "tool_search")) {
+            this.tools.push(createToolSearchTool(this.mcpCatalog, (promoted) => {
+                this.tools.push(...promoted);
+            }));
+        }
+    }
     /**
      * Process user input. Handles slash commands or runs agent loop.
      */
@@ -579,22 +619,23 @@ export class AgentSession {
         // agent sees them mid-loop instead of after it stops.
         if (this.userQueue.length > 0) {
             const queued = this.userQueue.splice(0);
-            // Frame the queued text as concurrent steering — without this wrapper the
-            // model treats a mid-run message as a fresh request that supersedes the
-            // original task and silently drops it.
-            // Plain-text-only queue: keep the simple merged-string message.
-            if (queued.every((m) => m.attachments.length === 0)) {
-                const merged = queued.map((m) => m.text).join("\n\n");
-                return [{ role: "user", content: wrapSteeringText(merged) }];
-            }
-            // Any queued attachments → deliver one user message with text + media
-            // blocks built the same way as a non-queued attachment prompt.
-            const parts = [
-                { type: "text", text: STEERING_PREFIX },
-            ];
-            for (const m of queued)
-                parts.push(...this.buildAttachmentParts(m.text, m.attachments));
-            return [{ role: "user", content: parts }];
+            // Frame each queued item as concurrent steering — without this wrapper
+            // the model treats a mid-run message as a fresh request that supersedes
+            // the original task and silently drops it. ONE message per queued item
+            // (not merged): each persists as its own user message, so a resumed
+            // session shows the same number of bubbles the live run did.
+            return queued.map((m) => {
+                if (m.attachments.length === 0) {
+                    return { role: "user", content: wrapSteeringText(m.text) };
+                }
+                // Queued attachments ride the same native-block path as a non-queued
+                // attachment prompt, prefixed with the steering framing.
+                const parts = [
+                    { type: "text", text: STEERING_PREFIX },
+                    ...this.buildAttachmentParts(m.text, m.attachments),
+                ];
+                return { role: "user", content: parts };
+            });
         }
         if (!this.settingsManager.get("idealReviewEnabled"))
             return null;
@@ -723,6 +764,25 @@ export class AgentSession {
                 // polled mid-loop; the ideal review is polled when the agent would stop.
                 getSteeringMessages: () => this.getHookSteeringMessages(),
                 getFollowUpMessages: () => this.getHookFollowUpMessages(),
+                // Overflow recovery: the loop calls this with { force: true } when the
+                // provider rejects a turn as too large (request_too_large / context
+                // overflow). Force-compact the in-flight history and hand it back so the
+                // loop retries with a smaller request, instead of surfacing the error.
+                // Without this the desktop app (which drives the loop through
+                // AgentSession, not the TUI's useContextCompaction hook) had NO auto
+                // recovery on 413 — the error went straight to the user. The non-force
+                // pre-call invocations pass through untouched: pre-turn compaction is
+                // already handled above, so we only act on the overflow force path.
+                // `loopMessages === this.messages` (prepareDynamicContext returns it by
+                // reference) and the post-loop `this.messages = loopMessages` re-sync
+                // keeps persistence correct after compact() swaps the array.
+                transformContext: async (messages, transformOpts) => {
+                    if (!transformOpts?.force)
+                        return messages;
+                    await this.compact();
+                    this.compactionOccurred = true;
+                    return this.messages;
+                },
             });
             for await (const event of generator) {
                 this.trackHookEvent(event);
@@ -840,7 +900,11 @@ export class AgentSession {
                     // Use getAllMcpServers so user-configured servers survive the reconnect.
                     const servers = await getAllMcpServers(this.provider, apiKey, this.cwd);
                     const mcpTools = await this.mcpManager.connectAll(servers);
-                    this.tools.push(...mcpTools);
+                    // Drop stale MCP tools from both the live set and deferred catalog before
+                    // re-adding. Some tools may already have been promoted out of the catalog.
+                    this.tools = this.tools.filter((t) => !t.name.startsWith("mcp__"));
+                    this.mcpCatalog?.removeWhere((name) => name.startsWith("mcp__"));
+                    this.addMcpTools(mcpTools);
                 }
                 catch (err) {
                     log("WARN", "mcp", `MCP reconnection failed: ${err instanceof Error ? err.message : String(err)}`);
@@ -869,20 +933,39 @@ export class AgentSession {
             signal: this.opts.signal,
         });
         this.messages = result.messages;
-        // Persist compacted messages to a new session file so `ezcoder continue`
-        // picks up the compacted state instead of the full original history.
-        const session = await this.sessionManager.create(this.cwd, this.provider, this.model);
-        this.sessionId = session.id;
-        this.sessionPath = session.path;
-        // Write compacted messages (skip system — it's rebuilt on load)
-        for (const msg of this.messages) {
-            if (msg.role === "system")
-                continue;
-            await this.persistMessage(msg);
+        // Transient sessions (Nolan chat/autopilot, subagent spawns) must NEVER touch
+        // the session store: without this guard, the first auto-compaction called
+        // sessionManager.create() and assigned a real sessionPath, silently turning
+        // the "in-memory only" session into a persisted one — every later turn (and
+        // every further compaction) then leaked a Nolan transcript file into the
+        // project's session list. Compact in memory only and keep sessionPath empty.
+        if (this.opts.transient) {
+            this.lastPersistedIndex = this.messages.length;
+        }
+        else {
+            // Persist compacted messages to a new session file so `ezcoder continue`
+            // picks up the compacted state instead of the full original history.
+            const session = await this.sessionManager.create(this.cwd, this.provider, this.model);
+            this.sessionId = session.id;
+            this.sessionPath = session.path;
+            // Write compacted messages (skip system — it's rebuilt on load)
+            for (const msg of this.messages) {
+                if (msg.role === "system")
+                    continue;
+                await this.persistMessage(msg);
+            }
+            this.lastPersistedIndex = this.messages.length;
+            // Carry Nolan's advisory turns into the new file so they survive compaction.
+            await this.rePersistNolanTurns();
+            await this.rePersistAutopilotMarkers();
+            await this.rePersistAppMarkers();
+            // Persist the compaction counts so a resumed session's quiet notice can
+            // show the same "N → M messages" summary the live run did.
+            await this.persistAppMarker("compaction", {
+                originalCount: result.result.originalCount,
+                newCount: result.result.newCount,
+            });
         }
-        this.lastPersistedIndex = this.messages.length;
-        // Carry Nolan's advisory turns into the new file so they survive compaction.
-        await this.rePersistNolanTurns();
         this.eventBus.emit("compaction_end", {
             originalCount: result.result.originalCount,
             newCount: result.result.newCount,
@@ -892,10 +975,31 @@ export class AgentSession {
         // A fresh session drops any in-flight plan state so its prompt is clean.
         this.planModeRef.current = false;
         this.approvedPlanPath = undefined;
+        // Display-only history belongs to the OLD session. Without this, stale Nolan
+        // turns / autopilot verdicts / app markers linger in memory, show up in the
+        // new session's /history, and get re-persisted into the new file by the
+        // next compaction — the cross-session duplicate-marker propagation bug.
+        this.nolanTurns = [];
+        this.autopilotMarkers = [];
+        this.appMarkers = [];
         const basePrompt = this.customSystemPrompt ??
             (await buildSystemPrompt(this.cwd, this.skills, false, undefined, this.tools.map((tool) => tool.name), undefined, this.provider));
         this.messages = [{ role: "system", content: basePrompt }];
-        await this.createNewSession();
+        // Fresh conversation — new entries must not chain onto the old DAG's leaf.
+        this.currentLeafId = null;
+        // Transient sessions (Nolan chat/autopilot, subagent spawns) never touch the
+        // session store. Without this guard, autopilot's per-cycle resetReviewer
+        // (nolanAutoSession.newSession()) created a real session file EVERY review
+        // cycle — the stream of 3-line "## Who you are … Nolan Grout" sessions that
+        // polluted the project's session list.
+        if (this.opts.transient) {
+            this.sessionId = "";
+            this.sessionPath = "";
+            this.lastPersistedIndex = this.messages.length;
+        }
+        else {
+            await this.createNewSession();
+        }
         this.eventBus.emit("session_start", { sessionId: this.sessionId });
     }
     async loadSession(sessionPath) {
@@ -1040,6 +1144,12 @@ export class AgentSession {
     getNolanTurns() {
         return this.nolanTurns;
     }
+    /** Autopilot verdict markers recorded against this session, in record order.
+     *  Used by the host to interleave the auto-review loop's markers back into
+     *  the transcript on resume, mirroring `getNolanTurns`. */
+    getAutopilotMarkers() {
+        return this.autopilotMarkers;
+    }
     /**
      * Record one Nolan Grout (mentor agent) turn against this build session: the
      * user's question + Nolan's reply. Kept in memory for the live transcript and
@@ -1085,6 +1195,103 @@ export class AgentSession {
             await this.sessionManager.appendEntry(this.sessionPath, entry);
         }
     }
+    /**
+     * Record one autopilot verdict marker (prompted / done / human / capped)
+     * against this build session. Kept in memory for the live transcript and
+     * persisted as a `custom` entry (parentId null, same as Nolan turns) so a
+     * resumed session renders the exact same Nolan bubble the live run showed
+     * instead of dropping the marker or falling back to a raw verdict string.
+     * No-op persistence for transient sessions (kept in memory only).
+     */
+    async persistAutopilotMarker(phase, extra) {
+        const afterMessageCount = this.messages.filter((m) => m.role !== "system").length;
+        const payload = {
+            version: 1,
+            phase,
+            afterMessageCount,
+            ...(extra?.reason !== undefined ? { reason: extra.reason } : {}),
+            ...(extra?.body !== undefined ? { body: extra.body } : {}),
+        };
+        this.autopilotMarkers.push(payload);
+        if (!this.sessionPath)
+            return;
+        const entry = {
+            type: "custom",
+            kind: AUTOPILOT_MARKER_CUSTOM_KIND,
+            id: crypto.randomUUID(),
+            parentId: null,
+            timestamp: new Date().toISOString(),
+            data: payload,
+        };
+        await this.sessionManager.appendEntry(this.sessionPath, entry);
+    }
+    /** 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. */
+    async rePersistAutopilotMarkers() {
+        if (!this.sessionPath)
+            return;
+        for (const payload of this.autopilotMarkers) {
+            const entry = {
+                type: "custom",
+                kind: AUTOPILOT_MARKER_CUSTOM_KIND,
+                id: crypto.randomUUID(),
+                parentId: null,
+                timestamp: new Date().toISOString(),
+                data: payload,
+            };
+            await this.sessionManager.appendEntry(this.sessionPath, entry);
+        }
+    }
+    /** 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. */
+    getAppMarkers() {
+        return this.appMarkers;
+    }
+    /**
+     * Record one app transcript marker (display-only row) against this session.
+     * Same treatment as autopilot markers: kept in memory for the live
+     * transcript, persisted as a `custom` entry (parentId null, never on the
+     * message DAG) so a resumed session shows the identical row. `anchorOffset`
+     * shifts the recorded `afterMessageCount` — pass +1 for a marker that should
+     * attach to the user message about to be pushed by the imminent prompt.
+     * No-op persistence for transient sessions.
+     */
+    async persistAppMarker(kind, data, anchorOffset = 0) {
+        const afterMessageCount = this.messages.filter((m) => m.role !== "system").length + anchorOffset;
+        const payload = { version: 1, kind, afterMessageCount, data };
+        this.appMarkers.push(payload);
+        if (!this.sessionPath)
+            return;
+        const entry = {
+            type: "custom",
+            kind: APP_MARKER_CUSTOM_KIND,
+            id: crypto.randomUUID(),
+            parentId: null,
+            timestamp: new Date().toISOString(),
+            data: payload,
+        };
+        await this.sessionManager.appendEntry(this.sessionPath, entry);
+    }
+    /** 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. */
+    async rePersistAppMarkers() {
+        if (!this.sessionPath)
+            return;
+        for (const payload of this.appMarkers) {
+            const entry = {
+                type: "custom",
+                kind: APP_MARKER_CUSTOM_KIND,
+                id: crypto.randomUUID(),
+                parentId: null,
+                timestamp: new Date().toISOString(),
+                data: payload,
+            };
+            await this.sessionManager.appendEntry(this.sessionPath, entry);
+        }
+    }
     /**
      * Generate a short LLM session title from the conversation so far (first user
      * message + first assistant reply). Best-effort; returns null on failure or
@@ -1165,9 +1372,11 @@ export class AgentSession {
     setSignal(signal) {
         this.opts = { ...this.opts, signal };
     }
-    /** True when speedProfile is "optimized" (1-h cache TTL + pre-warm). */
+    /** True when speedProfile is "optimized" (1-h cache TTL + pre-warm), or the
+     *  session was constructed with `forceLongCacheRetention` (Nolan sessions). */
     isSpeedOptimized() {
-        return this.settingsManager?.get("speedProfile") === "optimized";
+        return (this.opts.forceLongCacheRetention === true ||
+            this.settingsManager?.get("speedProfile") === "optimized");
     }
     /**
      * Ordered auth-storage keys the current (provider, model) pair tries, first
@@ -1247,6 +1456,10 @@ export class AgentSession {
         // Restore Nolan's advisory turns (custom entries, not on the message branch) so
         // they reappear in the transcript and survive into the continuation file.
         this.nolanTurns = this.sessionManager.getNolanTurns(loaded.entries);
+        // Restore autopilot verdict markers the same way (not on the message DAG).
+        this.autopilotMarkers = this.sessionManager.getAutopilotMarkers(loaded.entries);
+        // Restore app transcript markers (plan banner / task header / errors / hints).
+        this.appMarkers = this.sessionManager.getAppMarkers(loaded.entries);
         // Track the current leaf for subsequent entries
         this.currentLeafId = loaded.header.leafId;
         // Rebuild messages: keep system, add loaded
@@ -1282,20 +1495,40 @@ export class AgentSession {
                 before: String(compacted.result.originalCount),
                 after: String(compacted.result.newCount),
             });
+            // Compaction rewrote history, so the on-disk file no longer reflects
+            // what's in memory — fork a fresh session file for the compacted state
+            // (mirrors compact()'s own persistence) so `ezcoder continue` picks up
+            // the summary instead of the full original transcript.
+            const session = await this.sessionManager.create(this.cwd, this.provider, this.model);
+            this.sessionId = session.id;
+            this.sessionPath = session.path;
+            this.currentLeafId = null;
+            // Re-persist (compacted) messages — skip system, it's rebuilt on load
+            for (const msg of this.messages) {
+                if (msg.role === "system")
+                    continue;
+                await this.persistMessage(msg);
+            }
+            this.lastPersistedIndex = this.messages.length;
+            // Carry Nolan's restored turns into the continuation file.
+            await this.rePersistNolanTurns();
+            await this.rePersistAutopilotMarkers();
+            await this.rePersistAppMarkers();
+            // Record this load-time auto-compaction's counts for the resumed notice.
+            await this.persistAppMarker("compaction", {
+                originalCount: compacted.result.originalCount,
+                newCount: compacted.result.newCount,
+            });
+            return;
         }
-        // Create new session file for continuation
-        const session = await this.sessionManager.create(this.cwd, this.provider, this.model);
-        this.sessionId = session.id;
-        this.sessionPath = session.path;
-        // Re-persist (compacted) messages — skip system, it's rebuilt on load
-        for (const msg of this.messages) {
-            if (msg.role === "system")
-                continue;
-            await this.persistMessage(msg);
-        }
+        // Plain resume (no compaction needed): keep using the original session
+        // file/id and append future turns to it in place. Forking a new file here
+        // unconditionally used to create a byte-identical duplicate every time a
+        // session was merely reopened (e.g. app/window restart) with zero new
+        // messages in between — the duplicate entries seen in the session list.
+        this.sessionId = loaded.header.id;
+        this.sessionPath = sessionPath;
         this.lastPersistedIndex = this.messages.length;
-        // Carry Nolan's restored turns into the continuation file.
-        await this.rePersistNolanTurns();
     }
     async prepareDynamicContext(_latestUserPrompt) {
         return this.messages;