@prestyj/cli 5.26.0 → 5.28.0

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";
@@ -42,10 +43,10 @@ import { clampThinkingForPlanMode } from "./thinking-level.js";
 import { pruneStaleToolResults } from "./compaction/tool-result-pruner.js";
 import { discoverAgents } from "./agents.js";
 import { enhancePrompt } from "../utils/prompt-enhancer.js";
-import { detectProjectStack } from "./language-detector.js";
+import { detectLanguages, detectProjectStack } from "./language-detector.js";
 import { evaluateIdealReview, buildIdealReviewMessage, buildReviewCoverageEscalationMessage, buildReviewCoverageMessage, MAX_REVIEW_COVERAGE_INJECTIONS, withReviewCoverageRequirements, detectTestDrift, ReviewCoverageTracker, } from "./ideal-review.js";
 import { evaluateLoopBreak, buildLoopBreakMessage, CycleDetector, ToolCallProgressTracker, detectTextRepetition, } from "./loop-breaker.js";
-import { buildRegroundingMessage } from "./regrounding.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 { buildEnvDeltaMessage } from "./env-delta.js";
@@ -273,6 +274,13 @@ export class AgentSession {
     agentPrompt;
     /** Stable prompt prefix retained separately from the volatile uncached tail. */
     baseSystemPrompt = "";
+    /**
+     * Project languages whose style packs and verify commands are in the
+     * standard prompt. Only ever grows within a session (same policy as the
+     * terminal UI): a pack disappearing mid-task would rewrite the cached prefix
+     * for no benefit.
+     */
+    activeLanguages = new Set();
     /** Shared with the tool layer so plan-mode restrictions read live state. */
     planModeRef = { current: false };
     /** Path of the approved plan currently being implemented, or undefined. When
@@ -356,7 +364,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.
@@ -368,6 +376,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,
@@ -1029,6 +1042,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,
@@ -1089,20 +1103,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
@@ -1110,7 +1136,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, [
@@ -1125,6 +1151,7 @@ export class AgentSession {
                     await this.persistVerificationState();
                 }
                 break;
+            }
             case "tool_call_end": {
                 const call = this.hookToolCalls.get(event.toolCallId);
                 const name = call?.name ?? "";
@@ -1497,6 +1524,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. */
@@ -1647,6 +1727,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
@@ -1794,6 +1876,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") {
@@ -1913,6 +2011,11 @@ export class AgentSession {
     }
     /** Auto-compact if needed, run agent loop with auth retry, and persist messages. */
     async runLoop(options = {}) {
+        // Languages are re-detected at each task boundary so a project scaffolded
+        // during the previous turn gets its packs; the prompt is rebuilt only when
+        // the set grows, keeping the cached prefix stable otherwise.
+        if (this.refreshActiveLanguages())
+            await this.rebuildSystemPromptInPlace();
         this.refreshSystemPromptTail();
         // One-shot cache-key marker per session so turn_end cacheRead numbers
         // in the log can be traced back to a specific routing namespace —
@@ -1929,8 +2032,7 @@ export class AgentSession {
         // Reset self-correction hook state for this run; pin the latest user message
         // as the verbatim original request for post-compaction re-grounding.
         const lastUser = [...this.messages].reverse().find((m) => m.role === "user");
-        const originalRequest = typeof lastUser?.content === "string" ? lastUser.content : "";
-        this.resetHookState(originalRequest);
+        this.resetHookState(requestTextForRegrounding(lastUser));
         // Resolve OAuth credentials and run agent loop.
         // On 401, force-refresh the token and retry once — the provider may have
         // revoked the token server-side before the stored expiry (e.g. after a restart).
@@ -3115,11 +3217,40 @@ export class AgentSession {
                 toolNames,
                 deferredToolNames,
                 context: this.opts.agentContext,
+                role: this.opts.agentRole,
                 environment: this.recordRenderedEnvironment(),
                 contextLimits: this.contextLimits,
             });
         }
-        return buildSystemPrompt(this.cwd, this.skills, planMode, approvedPlanPath, toolNames, undefined, this.provider, this.recordRenderedEnvironment(), deferredToolNames, this.contextLimits);
+        return buildSystemPrompt(this.cwd, this.skills, planMode, approvedPlanPath, toolNames, this.activeLanguages, this.provider, this.recordRenderedEnvironment(), deferredToolNames, this.contextLimits);
+    }
+    /**
+     * Add newly detected project languages. Returns true when the set grew and
+     * the standard prompt therefore needs a rebuild. Custom and sub-agent
+     * prompts never render packs, so detection is skipped for them.
+     */
+    refreshActiveLanguages() {
+        if (this.customSystemPrompt || this.agentPrompt !== undefined)
+            return false;
+        let grew = false;
+        try {
+            for (const id of detectLanguages(this.cwd)) {
+                if (this.activeLanguages.has(id))
+                    continue;
+                this.activeLanguages.add(id);
+                grew = true;
+            }
+        }
+        catch (err) {
+            log("WARN", "language", `Language detection failed: ${err.message}`);
+            return false;
+        }
+        if (grew) {
+            log("INFO", "language", "Style packs active", {
+                active: [...this.activeLanguages].join(","),
+            });
+        }
+        return grew;
     }
     /** Rebuild messages[0] from current plan-mode + approved-plan state. */
     async rebuildSystemPromptInPlace() {
@@ -3373,7 +3504,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 = {
@@ -3644,6 +3789,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()