@prestyj/cli 5.27.0 → 5.28.1

package/dist/core/agent-session.js

@@ -1,6 +1,7 @@
 import { agentLoop, isAbortError, isUsageLimitError, } from "@prestyj/agent";
 import { ProviderError, stream, } from "@prestyj/ai";
 import { EventBus } from "./event-bus.js";
+import { COMPLETION_REVIEW_STATE_KIND, } from "./completion-review.js";
 import { SlashCommandRegistry, createBuiltinCommands, } from "./slash-commands.js";
 import { PROMPT_COMMANDS, getPromptCommand } from "./prompt-commands.js";
 import { loadCustomCommands } from "./custom-commands.js";
@@ -28,7 +29,7 @@ import { applyAsyncSubagentPolicy } from "./subagent-policy.js";
 import { z } from "zod";
 import { MCPClientManager, getAllMcpServers } from "./mcp/index.js";
 import { clampMcpToolDescription, DeferredToolCatalog } from "./mcp/deferred-catalog.js";
-import { CONTEXT_LIMITS, resolveContextLimits } from "./context-limits.js";
+import { CONTEXT_LIMITS, resolveSessionContextLimits, } from "./context-limits.js";
 import { McpCatalogCache } from "./mcp/catalog-cache.js";
 import { describeDropped, importForeignSession, } from "./foreign-session-import.js";
 import { createToolSearchTool } from "../tools/tool-search.js";
@@ -47,7 +48,7 @@ import { evaluateIdealReview, buildIdealReviewMessage, buildReviewCoverageEscala
 import { evaluateLoopBreak, buildLoopBreakMessage, CycleDetector, ToolCallProgressTracker, detectTextRepetition, } from "./loop-breaker.js";
 import { buildRegroundingMessage, requestTextForRegrounding } from "./regrounding.js";
 import { buildSemanticLoopJudgePrompt, buildSemanticLoopMessage, MAX_SEMANTIC_LOOP_CALLS, parseSemanticLoopVerdict, shouldRunSemanticLoopCheck, SEMANTIC_LOOP_JUDGE_TIMEOUT_MS, withJudgeTimeout, } from "./semantic-loop-check.js";
-import { buildIndependentReviewMessage, buildReviewerTask, INDEPENDENT_REVIEW_SCORE_THRESHOLD, parseReviewerFindings, REVIEWER_TOOLS, REVIEWER_WAIT_MS, } from "./ideal-review-subagent.js";
+import { buildIndependentReviewMessage, buildReviewerTask, INDEPENDENT_REVIEW_SCORE_THRESHOLD, parseReviewerFindings, REVIEWER_TOOLS, REVIEWER_TURN_TIMEOUT_MS, REVIEWER_WAIT_MS, } from "./ideal-review-subagent.js";
 import { buildEnvDeltaMessage } from "./env-delta.js";
 import { wrapSteeringText, buildNotificationSteeringText, STEERING_PREFIX } from "./steering.js";
 import { AgentNotificationQueue } from "./agent-notifications.js";
@@ -137,6 +138,9 @@ export class AgentSession {
      *  creation). Called from switchModel so video-capable models get the
      *  read-tool's native-video path after a mid-session model change. */
     rebuildReadTool;
+    /** Forgets every file read; called whenever the conversation is replaced or
+     *  rewound, so the model must re-read a file before changing it. */
+    clearReadTracker;
     skills = [];
     cacheKeyLogged = false;
     // ── Self-correction hook state (mirrors the TUI's useAgentLoop refs) ──
@@ -363,7 +367,7 @@ export class AgentSession {
         // Load settings & auth
         this.settingsManager = new SettingsManager(paths.settingsFile);
         await this.settingsManager.load();
-        this.contextLimits = resolveContextLimits(this.settingsManager.get("contextLimits"));
+        this.contextLimits = resolveSessionContextLimits(this.opts.contextLimits, this.settingsManager.get("contextLimits"));
         this.authStorage = new AuthStorage(paths.authFile);
         await this.authStorage.load();
         // Session manager. Agent-specific roots keep chat and coder histories isolated.
@@ -375,6 +379,11 @@ export class AgentSession {
             await fs.mkdir(path.join(localEzDir, "skills"), { recursive: true });
             await fs.mkdir(path.join(localEzDir, "commands"), { recursive: true });
             await fs.mkdir(path.join(localEzDir, "agents"), { recursive: true });
+        }
+        if (this.opts.skills) {
+            this.skills = [...this.opts.skills];
+        }
+        else if (projectCustomization) {
             this.skills = await discoverSkills({
                 globalSkillsDir: paths.skillsDir,
                 projectDir: this.cwd,
@@ -393,7 +402,7 @@ export class AgentSession {
             : this.opts.globalSubagents
                 ? await discoverAgents({ globalAgentsDir: paths.agentsDir })
                 : [];
-        const { tools: builtInTools, processManager, rebuildReadTool, lspManager, subAgentManager, } = await createTools(this.cwd, {
+        const { tools: builtInTools, processManager, rebuildReadTool, clearReadTracker, lspManager, subAgentManager, } = await createTools(this.cwd, {
             agents,
             skills: this.skills,
             contextLimits: this.contextLimits,
@@ -483,6 +492,7 @@ export class AgentSession {
             }
         }
         this.rebuildReadTool = rebuildReadTool;
+        this.clearReadTracker = clearReadTracker;
         this.processManager = processManager;
         this.lspManager = lspManager;
         this.subAgentManager = subAgentManager;
@@ -899,6 +909,8 @@ export class AgentSession {
     }
     /**
      * Process user input. Handles slash commands or runs agent loop.
+     * `capThinking` holds reasoning effort at the plan-mode ceiling for this
+     * prompt — for turns that must answer quickly from what is already known.
      */
     async prompt(content, provenance = {
         source: "human",
@@ -1036,6 +1048,7 @@ export class AgentSession {
      * is the verbatim user ask, pinned for post-compaction re-grounding.
      */
     resetHookState(originalRequest) {
+        this.opts.completionReview?.begin(originalRequest);
         this.lspManager?.clearPendingDiagnostics();
         this.hookStats = {
             changedLines: 0,
@@ -1096,20 +1109,32 @@ export class AgentSession {
      * ideal-review decisions match across the CLI and the app.
      */
     async trackHookEvent(event) {
+        if (this.opts.completionReview) {
+            await this.opts.completionReview.track(event);
+            if (event.type === "checkpoint")
+                await this.persistCompletionReviewState();
+        }
         switch (event.type) {
             case "text_delta":
                 this.hookText += event.text;
                 break;
-            case "tool_call_start":
+            case "tool_call_start": {
                 this.hookToolCalls.set(event.toolCallId, {
                     name: event.name,
                     args: event.args ?? {},
                     revision: this.verificationGate.revision,
                 });
-                if (event.name === "bash" &&
+                const startClassification = event.name === "bash" && typeof event.args?.command === "string"
+                    ? classifyVerificationCommand(event.args.command)
+                    : null;
+                if (startClassification &&
                     typeof event.args?.command === "string" &&
                     (isVerificationCommand(event.args.command) ||
-                        classifyVerificationCommand(event.args.command).accepted)) {
+                        startClassification.accepted ||
+                        // Must match the tool_call_end predicate: a snapshot-eligible
+                        // command that never captured a "before" snapshot is misread at
+                        // the end as an uncomparable workspace and re-arms the gate.
+                        startClassification.snapshotEligible === true)) {
                     // A check that can rewrite files (--fix, build scripts, emitters)
                     // invalidates earlier in-flight evidence AND marks the run as
                     // touched. A check that is merely UNRECOGNIZED (`make test`, `deno
@@ -1117,7 +1142,7 @@ export class AgentSession {
                     // it poisoned the gate on green output and re-armed the hook into
                     // every later question turn.
                     this.verificationGate.recordVerificationAttempt();
-                    const classification = classifyVerificationCommand(event.args.command);
+                    const classification = startClassification;
                     if (classification.snapshotEligible && event.args.persist !== true) {
                         const call = this.hookToolCalls.get(event.toolCallId);
                         call.sourceSnapshot = await captureVerificationSnapshot(this.opts.cwd, [
@@ -1126,12 +1151,20 @@ export class AgentSession {
                         if (call.sourceSnapshot === null)
                             this.verificationGate.requireFreshVerification(true, event.args.command);
                     }
-                    else {
+                    else if ((classification.accepted && event.args.persist !== true) ||
+                        (!classification.accepted && classification.mayMutate)) {
+                        // Flag the workspace unknown only when tool_call_end can resolve
+                        // it: a bounded check records pass/fail, a file-rewriting command
+                        // bumps the revision. An unrecognized read-only check (`biome ci`)
+                        // or a persistent-shell run records nothing at the end, so
+                        // flagging it left verified work Unverified forever — and
+                        // autopilot silently refused every later turn.
                         this.verificationGate.requireFreshVerification(!classification.accepted && classification.mayMutate, event.args.command);
                     }
                     await this.persistVerificationState();
                 }
                 break;
+            }
             case "tool_call_end": {
                 const call = this.hookToolCalls.get(event.toolCallId);
                 const name = call?.name ?? "";
@@ -1504,6 +1537,59 @@ export class AgentSession {
             }
         })();
     }
+    /** Fresh image-only critique context, using the active transport and auth routing. */
+    async callCompletionReviewer(request, signal) {
+        const model = this.model;
+        const provider = this.provider;
+        const thinking = this.thinkingLevel;
+        const configuredBaseUrl = this.baseUrl;
+        if (getModel(model)?.supportsImages !== true)
+            throw new Error("Active model has no confirmed image support");
+        signal.throwIfAborted();
+        try {
+            const creds = await this.authStorage.resolveCredentials(provider, {
+                storageKeys: this.currentAuthStorageKeys(),
+            });
+            const baseUrl = configuredBaseUrl ?? creds.baseUrl;
+            const result = stream({
+                provider,
+                model,
+                messages: [
+                    { role: "system", content: request.instruction },
+                    { role: "user", content: [{ type: "text", text: request.context }, ...request.images] },
+                ],
+                maxTokens: 4000,
+                thinking,
+                apiKey: creds.accessToken,
+                accountId: creds.accountId,
+                projectId: creds.projectId,
+                baseUrl,
+                signal,
+                transportSessionId: this.sessionId || this.transportSessionId,
+                defaultHeaders: provider === "moonshot" && isKimiCodingEndpoint(baseUrl)
+                    ? kimiCodingHeaders()
+                    : undefined,
+                userAgent: provider === "anthropic" ? await getClaudeCliUserAgent() : undefined,
+                supportsImages: true,
+            });
+            const response = await result.response;
+            const content = response.message.content;
+            const text = typeof content === "string"
+                ? content
+                : content
+                    .filter((part) => part.type === "text")
+                    .map((part) => part.text)
+                    .join("\n");
+            if (text.length > 32_768)
+                throw new Error("Review response exceeded its limit");
+            return { text, model, provider, thinking };
+        }
+        catch {
+            // Provider errors may contain transport details; never copy them to tools/artifacts.
+            signal.throwIfAborted();
+            throw new Error("Active model review unavailable or invalid; no verdict recorded");
+        }
+    }
     /** One-shot judge call on the session's ACTIVE model — deliberately not a
      *  cheaper routing: judging a model's own failure patterns with a weaker
      *  model swaps false negatives for false positives. */
@@ -1566,9 +1652,12 @@ export class AgentSession {
                 triggerReasons: decision.reasons,
             });
             // Active model forced at spawn time — never routed to a fast/review model.
+            // The reviewer's own time limit ends it with a verdict on what it read;
+            // the wait below is only a backstop against a hung child.
             const snapshot = await this.subAgentManager.spawn(taskName, task, undefined, {
                 model: this.model,
                 tools: REVIEWER_TOOLS,
+                turnTimeoutMs: REVIEWER_TURN_TIMEOUT_MS,
             });
             agentId = snapshot.agent_id;
             const waited = await this.subAgentManager.wait([agentId], "all", REVIEWER_WAIT_MS);
@@ -1584,7 +1673,11 @@ export class AgentSession {
             }
             const findings = parseReviewerFindings(agent.output ?? "");
             if (!findings) {
-                log("WARN", "ideal", "Independent reviewer output unparseable; falling back", { agentId });
+                log("WARN", "ideal", "Independent reviewer output unparseable; falling back", {
+                    agentId,
+                    state: agent.state,
+                    ...(agent.error ? { error: agent.error } : {}),
+                });
                 return [];
             }
             if (findings.clean) {
@@ -1654,6 +1747,8 @@ export class AgentSession {
      * the flash, so this errs toward arming.
      */
     wouldInjectIdealReview() {
+        if (this.opts.completionReview?.armed)
+            return true;
         if (this.opts.selfCorrectionHooks === false || this.idealReviewSuppressed)
             return false;
         // Mid-review a stop still injects: the coverage follow-up while files are
@@ -1801,6 +1896,22 @@ export class AgentSession {
         // verification demand above instead of manufacturing a separate hook.
         if (diagnosticMessages.length > 0)
             return diagnosticMessages;
+        if (this.opts.completionReview) {
+            const followUp = await this.opts.completionReview.followUp((request, signal) => this.callCompletionReviewer(request, signal), this.opts.signal);
+            await this.persistCompletionReviewState();
+            if (followUp) {
+                this.eventBus.emit("hook", { kind: "ideal" });
+                this.refreshHookArming();
+                return [
+                    {
+                        role: "user",
+                        content: followUp,
+                        provenance: { source: "runtime", kind: "notification", visibility: "hidden" },
+                    },
+                ];
+            }
+            this.refreshHookArming();
+        }
         if (this.opts.selfCorrectionHooks === false || this.idealReviewSuppressed)
             return null;
         if (this.idealReviewPhase === "reviewing") {
@@ -2039,8 +2150,9 @@ export class AgentSession {
                 // Plan mode caps effort at medium (Codex `plan_mode_reasoning_effort`
                 // preset): read-only exploration doesn't need xhigh/max reasoning, and
                 // deep-reasoning models left at the ceiling burn enormous thinking
-                // budgets re-deriving context they cannot act on.
-                thinking: this.planModeRef.current
+                // budgets re-deriving context they cannot act on. A capped prompt
+                // (a sub-agent's timed answer) gets the same ceiling for the same reason.
+                thinking: this.planModeRef.current || options.capThinking
                     ? clampThinkingForPlanMode(this.thinkingLevel)
                     : this.thinkingLevel,
                 apiKey,
@@ -2798,6 +2910,7 @@ export class AgentSession {
         const basePrompt = await this.buildBasePrompt(false, undefined);
         this.baseSystemPrompt = basePrompt;
         this.messages = [{ role: "system", content: this.withSystemPromptTail(basePrompt) }];
+        this.clearReadTracker?.();
         // 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
@@ -2852,6 +2965,8 @@ export class AgentSession {
         const systemMsg = this.messages[0];
         this.messages = [systemMsg, ...branchMessages];
         this.lastPersistedIndex = this.messages.length;
+        // Reads made in the dropped messages are no longer in the model's context.
+        this.clearReadTracker?.();
         this.eventBus.emit("branch_created", {
             leafId: this.currentLeafId,
             messagesKept: branchMessages.length,
@@ -3126,6 +3241,7 @@ export class AgentSession {
                 toolNames,
                 deferredToolNames,
                 context: this.opts.agentContext,
+                role: this.opts.agentRole,
                 environment: this.recordRenderedEnvironment(),
                 contextLimits: this.contextLimits,
             });
@@ -3412,7 +3528,21 @@ export class AgentSession {
                 ? "Unverified: a background check is still running or its result has not been confirmed."
                 : null));
     }
+    async persistCompletionReviewState() {
+        if (!this.sessionPath || !this.opts.completionReview)
+            return;
+        await this.sessionManager.appendEntry(this.sessionPath, {
+            type: "custom",
+            kind: COMPLETION_REVIEW_STATE_KIND,
+            id: crypto.randomUUID(),
+            parentId: null,
+            timestamp: new Date().toISOString(),
+            data: this.opts.completionReview.snapshot(),
+        });
+    }
     async persistVerificationState() {
+        if (this.opts.completionReview)
+            await this.persistCompletionReviewState();
         if (!this.sessionPath)
             return;
         const entry = {
@@ -3683,6 +3813,10 @@ export class AgentSession {
         const loaded = await this.sessionManager.load(canonicalPath);
         // Use the leaf from the header to walk the correct branch
         const loadedMessages = this.sessionManager.getMessages(loaded.entries, loaded.header.leafId);
+        const savedCompletionReview = [...loaded.entries]
+            .reverse()
+            .find((entry) => entry.type === "custom" && entry.kind === COMPLETION_REVIEW_STATE_KIND);
+        this.opts.completionReview?.restore(savedCompletionReview?.type === "custom" ? savedCompletionReview.data : null);
         this.backgroundVerification.clear();
         const savedVerification = [...loaded.entries]
             .reverse()
@@ -3730,6 +3864,8 @@ export class AgentSession {
         // not fail when Anthropic's stricter many-image limit activates later.
         const systemMsg = this.messages[0]; // Already built
         this.messages = [systemMsg, ...loadedMessages];
+        // Reads recorded for the previous conversation don't carry over.
+        this.clearReadTracker?.();
         const normalizedImageCount = await normalizeMessageImages(this.messages);
         if (normalizedImageCount > 0) {
             log("INFO", "session", `Resized ${normalizedImageCount} restored session image(s)`);