@kenkaiiii/ggcoder 5.16.0 → 5.18.0

package/dist/core/agent-session.js

@@ -1,4 +1,4 @@
-import { agentLoop, isAbortError } from "@kenkaiiii/gg-agent";
+import { agentLoop, isAbortError, } from "@kenkaiiii/gg-agent";
 import { ProviderError, } from "@kenkaiiii/gg-ai";
 import { EventBus } from "./event-bus.js";
 import { SlashCommandRegistry, createBuiltinCommands, } from "./slash-commands.js";
@@ -11,11 +11,12 @@ import { kimiCodingHeaders, isKimiCodingEndpoint } from "./oauth/kimi.js";
 import { SessionManager, KEN_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";
+import { getAuthStorageKeys, getContextWindow, getModel, getToolResultCharLimit, MODELS, } from "./model-registry.js";
 import { discoverSkills } from "./skills.js";
 import { ensureAppDirs } from "../config.js";
 import { buildSystemPrompt } from "../system-prompt.js";
 import { createTools, createWebSearchTool, } from "../tools/index.js";
+import { buildSubAgentCompletionFollowUp } from "./subagent-manager.js";
 import { applyAsyncSubagentPolicy } from "./subagent-policy.js";
 import { MCPClientManager, getAllMcpServers } from "./mcp/index.js";
 import { DeferredToolCatalog } from "./mcp/deferred-catalog.js";
@@ -23,16 +24,22 @@ import { createToolSearchTool } from "../tools/tool-search.js";
 import { log } from "./logger.js";
 import { setEstimatorModel } from "./compaction/token-estimator.js";
 import { discoverAgents } from "./agents.js";
-import { generateSessionTitle } from "../utils/session-title.js";
 import { enhancePrompt } from "../utils/prompt-enhancer.js";
 import { detectProjectStack } from "./language-detector.js";
-import { evaluateIdealReview, buildIdealReviewMessage, detectTestDrift, } from "./ideal-review.js";
+import { evaluateIdealReview, buildIdealReviewMessage, buildReviewCoverageMessage, detectTestDrift, ReviewCoverageTracker, } from "./ideal-review.js";
 import { evaluateLoopBreak, buildLoopBreakMessage, ToolCallProgressTracker, detectTextRepetition, } from "./loop-breaker.js";
 import { buildRegroundingMessage } from "./regrounding.js";
 import { wrapSteeringText, STEERING_PREFIX } from "./steering.js";
+import { findUserSessionPrompt, getUserSessionPrompt } from "./session-preview.js";
 import crypto from "node:crypto";
 import fs from "node:fs/promises";
 import path from "node:path";
+// ── Tool-result policy ─────────────────────────────────────
+/** Resolve the per-result cap passed to the agent loop for the active transport. */
+export function resolveSessionToolResultCharLimit(model, provider, accountId) {
+    return (getToolResultCharLimit(model, { provider, accountId }) ??
+        Math.floor(getContextWindow(model, { provider, accountId }) * 3.5 * 0.3));
+}
 // ── Agent Session ──────────────────────────────────────────
 export class AgentSession {
     eventBus = new EventBus();
@@ -59,6 +66,7 @@ export class AgentSession {
     // display only, persisted + reloaded so a resumed session shows the same
     // transcript rows the live run showed.
     appMarkers = [];
+    turnMetrics = [];
     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
@@ -84,7 +92,8 @@ export class AgentSession {
     hookProgressTracker = new ToolCallProgressTracker();
     hookFileEditCounts = new Map();
     hookToolCalls = new Map();
-    idealReviewInjected = false;
+    idealReviewPhase = "idle";
+    reviewCoverage;
     loopBreakInjected = false;
     regroundingInjected = false;
     compactionOccurred = false;
@@ -125,6 +134,10 @@ export class AgentSession {
      *  model emits step-completion markers the UI's plan-progress widget reads. */
     approvedPlanPath;
     sessionId = "";
+    /** Stable identity shared by compaction and approved-plan checkpoint files. */
+    conversationId = "";
+    /** Original user-authored prompt, retained when internal messages replace history. */
+    sessionPreview = "";
     /** Runtime conversation identity for provider transport headers. Transient
      *  children need one even though they intentionally have no persisted session. */
     transportSessionId = crypto.randomUUID();
@@ -138,6 +151,7 @@ export class AgentSession {
         this.provider = options.provider;
         this.model = options.model;
         this.cwd = options.cwd;
+        this.reviewCoverage = new ReviewCoverageTracker(this.cwd);
         this.baseUrl = options.baseUrl;
         this.maxTokens = this.resolveMaxTokens(options.model);
         this.thinkingLevel = options.thinkingLevel;
@@ -203,6 +217,12 @@ export class AgentSession {
             model: this.model,
             lspDiagnostics: this.settingsManager.get("lspDiagnostics"),
             authStorage: this.authStorage,
+            onFileRead: (filePath) => this.reviewCoverage.recordRead(filePath),
+            onFileMutated: (filePath) => {
+                const relative = path.relative(this.cwd, filePath) || path.basename(filePath);
+                this.hookFileEditCounts.set(relative, (this.hookFileEditCounts.get(relative) ?? 0) + 1);
+                this.reviewCoverage.recordChanged(filePath);
+            },
             // Lazy — sessionId/model/provider can change after createTools() runs, so
             // sub-agent spawns read the current parent state at execution time.
             getProvider: () => this.provider,
@@ -273,6 +293,8 @@ export class AgentSession {
         else {
             await this.createNewSession();
         }
+        if (this.sessionId)
+            await this.subAgentManager?.hydrate(this.sessionId);
         // GG Coder owns its command registry. Other agents start with an isolated
         // empty registry and can register their own commands in their own file.
         if (this.opts.coderSlashCommands !== false) {
@@ -567,7 +589,8 @@ export class AgentSession {
         this.hookProgressTracker.reset();
         this.hookFileEditCounts.clear();
         this.hookToolCalls.clear();
-        this.idealReviewInjected = false;
+        this.reviewCoverage.reset();
+        this.idealReviewPhase = "idle";
         this.loopBreakInjected = false;
         this.regroundingInjected = false;
         this.compactionOccurred = false;
@@ -578,7 +601,7 @@ export class AgentSession {
      * the same signals the TUI's useAgentLoop collects, so the loop-break and
      * ideal-review decisions match across the CLI and the app.
      */
-    trackHookEvent(event) {
+    async trackHookEvent(event) {
         switch (event.type) {
             case "text_delta":
                 this.hookText += event.text;
@@ -601,13 +624,6 @@ export class AgentSession {
                     this.hookStats.bashCalls += 1;
                 this.hookConsecutiveFailures = event.isError ? this.hookConsecutiveFailures + 1 : 0;
                 this.hookRepeatedNoProgressCalls = this.hookProgressTracker.record(name, args, event.result, event.isError);
-                if ((name === "edit" || name === "write") && args) {
-                    const filePath = args.file_path;
-                    if (typeof filePath === "string") {
-                        const fileNext = (this.hookFileEditCounts.get(filePath) ?? 0) + 1;
-                        this.hookFileEditCounts.set(filePath, fileNext);
-                    }
-                }
                 if (name === "edit" && !event.isError) {
                     const diff = event.details?.diff ?? event.result;
                     const added = (diff.match(/^\+[^+]/gm) ?? []).length;
@@ -618,6 +634,7 @@ export class AgentSession {
             }
             case "turn_end":
                 this.hookStats.turns = event.turn;
+                await this.persistTurnMetric(event);
                 break;
         }
     }
@@ -677,15 +694,35 @@ export class AgentSession {
         return null;
     }
     /**
-     * Pre-stop follow-up hook: runs the ideal review once, when the agent would
-     * otherwise finish and the change set is substantial enough to warrant it.
+     * Pre-stop Ideal review phase machine. Once review starts, completion is
+     * blocked until harness-owned post-injection reads cover every changed file.
      */
     getHookFollowUpMessages() {
+        const childCompletionFollowUp = buildSubAgentCompletionFollowUp(this.subAgentManager);
+        if (childCompletionFollowUp)
+            return childCompletionFollowUp;
         if (this.opts.selfCorrectionHooks === false)
             return null;
-        if (!this.settingsManager.get("idealReviewEnabled"))
+        if (this.idealReviewPhase === "reviewing") {
+            const coverage = this.reviewCoverage.evidence();
+            const lspEvidence = this.reviewLspEvidence(coverage.expected);
+            log("INFO", "ideal", "Ideal review coverage check", {
+                covered: coverage.covered,
+                missing: coverage.missing,
+                lspLowConfidence: lspEvidence.lowConfidence,
+                lspMissing: lspEvidence.missing,
+            });
+            if (coverage.missing.length > 0) {
+                return [
+                    this.withReviewLspEvidence(buildReviewCoverageMessage(coverage.missing), lspEvidence),
+                ];
+            }
+            this.idealReviewPhase = "complete";
+            return null;
+        }
+        if (this.idealReviewPhase === "complete")
             return null;
-        if (this.idealReviewInjected)
+        if (!this.settingsManager.get("idealReviewEnabled"))
             return null;
         const decision = evaluateIdealReview(this.hookStats);
         // Test drift fires the review even on a small change the score would skip:
@@ -693,9 +730,50 @@ export class AgentSession {
         const driftedFiles = detectTestDrift(this.hookFileEditCounts.keys(), this.cwd).slice(0, 5);
         if (!decision.shouldReview && driftedFiles.length === 0)
             return null;
-        this.idealReviewInjected = true;
-        this.eventBus.emit("hook", { kind: "ideal" });
-        return [buildIdealReviewMessage(decision.reasons, driftedFiles)];
+        this.reviewCoverage.start(this.hookFileEditCounts.keys());
+        this.idealReviewPhase = "reviewing";
+        const coverage = this.reviewCoverage.evidence();
+        const lspEvidence = this.reviewLspEvidence(coverage.expected);
+        this.eventBus.emit("hook", {
+            kind: "ideal",
+            coverageExpected: coverage.expected,
+            coverageMissing: coverage.missing,
+        });
+        log("INFO", "ideal", "Injecting ideal review before final response", {
+            coverageExpected: coverage.expected,
+            coverageMissing: coverage.missing,
+            lspLowConfidence: lspEvidence.lowConfidence,
+            lspMissing: lspEvidence.missing,
+        });
+        return [
+            this.withReviewLspEvidence(buildIdealReviewMessage(decision.reasons, driftedFiles), lspEvidence),
+        ];
+    }
+    reviewLspEvidence(files) {
+        const lowConfidence = [];
+        const missing = [];
+        for (const filePath of files) {
+            const outcome = this.lspManager?.getLatestOutcome(filePath);
+            if (outcome?.kind === "low_confidence")
+                lowConfidence.push(filePath);
+            else if (outcome?.kind !== "clean" && outcome?.kind !== "diagnostics")
+                missing.push(filePath);
+        }
+        return { lowConfidence, missing };
+    }
+    withReviewLspEvidence(message, evidence) {
+        if (evidence.lowConfidence.length === 0 && evidence.missing.length === 0)
+            return message;
+        const notes = [
+            ...(evidence.lowConfidence.length > 0
+                ? [`Diagnostics are low confidence while indexing: ${evidence.lowConfidence.join(", ")}.`]
+                : []),
+            ...(evidence.missing.length > 0
+                ? [`Diagnostics evidence is unavailable or missing: ${evidence.missing.join(", ")}.`]
+                : []),
+            "Do not describe those files as compiler-clean without other evidence.",
+        ];
+        return { role: "user", content: `${String(message.content)}\n\n${notes.join(" ")}` };
     }
     /** Auto-compact if needed, run agent loop with auth retry, and persist messages. */
     async runLoop() {
@@ -779,9 +857,9 @@ export class AgentSession {
                 supportsImages: modelInfo?.supportsImages,
                 supportsVideo: modelInfo?.supportsVideo,
                 userAgent,
-                // clearToolUses disabled — causes model to output unsolicited context summaries
-                // Single tool result shouldn't exceed 30% of context window (in chars)
-                maxToolResultChars: Math.floor(getContextWindow(this.model, { provider: this.provider, accountId }) * 3.5 * 0.3),
+                // Codex caps each tool output at 10K tokens. Other transports retain the
+                // generic 30%-of-context allowance used before this provider policy.
+                maxToolResultChars: resolveSessionToolResultCharLimit(this.model, this.provider, accountId),
                 // Self-correction hooks (same as the TUI): loop-break + re-grounding are
                 // polled mid-loop; the ideal review is polled when the agent would stop.
                 getSteeringMessages: () => this.getHookSteeringMessages(),
@@ -807,7 +885,7 @@ export class AgentSession {
                 },
             });
             for await (const event of generator) {
-                this.trackHookEvent(event);
+                await this.trackHookEvent(event);
                 this.eventBus.forwardAgentEvent(event);
             }
         };
@@ -967,9 +1045,14 @@ export class AgentSession {
         else {
             // Persist compacted messages to a new session file so `ggcoder continue`
             // picks up the compacted state instead of the full original history.
-            const session = await this.sessionManager.create(this.cwd, this.provider, this.model);
+            const session = await this.sessionManager.create(this.cwd, this.provider, this.model, {
+                conversationId: this.conversationId || undefined,
+                preview: this.sessionPreview || undefined,
+            });
             this.sessionId = session.id;
+            this.conversationId = session.header.conversationId ?? session.id;
             this.sessionPath = session.path;
+            await this.subAgentManager?.rebindParentSession(this.sessionId);
             // Write compacted messages (skip system — it's rebuilt on load)
             for (const msg of this.messages) {
                 if (msg.role === "system")
@@ -977,7 +1060,8 @@ export class AgentSession {
                 await this.persistMessage(msg);
             }
             this.lastPersistedIndex = this.messages.length;
-            // Carry Ken's advisory turns into the new file so they survive compaction.
+            // Carry evidence records into the new file so they survive compaction.
+            await this.rePersistTurnMetrics();
             await this.rePersistKenTurns();
             await this.rePersistAutopilotMarkers();
             await this.rePersistAppMarkers();
@@ -993,7 +1077,13 @@ export class AgentSession {
             newCount: result.result.newCount,
         });
     }
-    async newSession() {
+    async newSession(preserveConversation = false) {
+        // Approved-plan execution is a clean checkpoint of the same conversation;
+        // explicit new sessions reset the conversation identity.
+        if (!preserveConversation) {
+            this.conversationId = "";
+            this.sessionPreview = "";
+        }
         // A fresh session drops any in-flight plan state so its prompt is clean.
         this.planModeRef.current = false;
         this.approvedPlanPath = undefined;
@@ -1004,6 +1094,7 @@ export class AgentSession {
         this.kenTurns = [];
         this.autopilotMarkers = [];
         this.appMarkers = [];
+        this.turnMetrics = [];
         const basePrompt = this.customSystemPrompt ??
             (await buildSystemPrompt(this.cwd, this.skills, false, undefined, this.tools.map((tool) => tool.name), undefined, this.provider));
         this.baseSystemPrompt = basePrompt;
@@ -1018,16 +1109,21 @@ export class AgentSession {
         // polluted the project's session list.
         if (this.opts.transient) {
             this.sessionId = "";
+            this.conversationId = "";
+            this.sessionPreview = "";
             this.sessionPath = "";
             this.lastPersistedIndex = this.messages.length;
         }
         else {
             await this.createNewSession();
+            await this.subAgentManager?.resetParentSession(this.sessionId);
         }
         this.eventBus.emit("session_start", { sessionId: this.sessionId });
     }
     async loadSession(sessionPath) {
         await this.loadExistingSession(sessionPath);
+        if (this.sessionId)
+            await this.subAgentManager?.hydrate(this.sessionId);
         this.eventBus.emit("session_start", { sessionId: this.sessionId });
     }
     /**
@@ -1197,6 +1293,39 @@ export class AgentSession {
     getMessages() {
         return this.messages;
     }
+    getTurnMetrics() {
+        return this.turnMetrics.map((metric) => ({
+            ...metric,
+            usage: { ...metric.usage },
+            timing: { ...metric.timing },
+            cost: { ...metric.cost },
+        }));
+    }
+    async persistTurnMetric(event) {
+        const payload = {
+            version: 1,
+            turn: event.turn,
+            provider: this.provider,
+            model: this.model,
+            stopReason: event.stopReason,
+            usage: { ...event.usage },
+            timing: { ...event.timing },
+            cost: {
+                status: "unavailable",
+                reason: "No authoritative effective-dated provider pricing is available",
+            },
+        };
+        this.turnMetrics.push(payload);
+        if (this.sessionPath)
+            await this.sessionManager.appendTurnMetric(this.sessionPath, payload);
+    }
+    async rePersistTurnMetrics() {
+        if (!this.sessionPath)
+            return;
+        for (const metric of this.turnMetrics) {
+            await this.sessionManager.appendTurnMetric(this.sessionPath, metric);
+        }
+    }
     /** Ken Kai (mentor) turns recorded against this session, in record order. Used
      *  by the host to interleave Ken's advisory exchanges back into the transcript
      *  on resume. Never part of the LLM message history. */
@@ -1351,46 +1480,12 @@ export class AgentSession {
             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
-     * when there's no user message yet. Uses the cheapest model for the provider.
-     */
-    async generateTitle() {
-        const extractText = (content) => typeof content === "string"
-            ? content
-            : content
-                .map((c) => c.type === "text" && "text" in c && typeof c.text === "string" ? c.text : "")
-                .join(" ");
-        const userMsg = this.messages.find((m) => m.role === "user");
-        const assistantMsg = this.messages.find((m) => m.role === "assistant");
-        const userText = userMsg ? extractText(userMsg.content) : "";
-        if (!userText.trim())
-            return null;
-        try {
-            const creds = await this.authStorage.resolveCredentials(this.provider, {
-                storageKeys: this.currentAuthStorageKeys(),
-            });
-            const title = await generateSessionTitle({
-                provider: this.provider,
-                userMessage: userText,
-                assistantPreview: assistantMsg ? extractText(assistantMsg.content).slice(0, 200) : "",
-                apiKey: creds.accessToken,
-                baseUrl: this.baseUrl ?? creds.baseUrl,
-                accountId: creds.accountId,
-            });
-            return title || null;
-        }
-        catch {
-            return null;
-        }
-    }
     /**
      * 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
      * tools, no session mutation) — safe to run even mid-run. Returns the plain
      * enhanced text plus typed segments marking each corrected term. Errors throw
-     * so the caller can surface them (unlike best-effort title generation).
+     * so the caller can surface them.
      */
     async enhancePrompt(text) {
         if (!text.trim())
@@ -1488,8 +1583,12 @@ export class AgentSession {
     }
     // ── Private ────────────────────────────────────────────
     async createNewSession() {
-        const session = await this.sessionManager.create(this.cwd, this.provider, this.model);
+        const session = await this.sessionManager.create(this.cwd, this.provider, this.model, {
+            conversationId: this.conversationId || undefined,
+            preview: this.sessionPreview || undefined,
+        });
         this.sessionId = session.id;
+        this.conversationId = session.header.conversationId ?? session.id;
         this.sessionPath = session.path;
         this.lastPersistedIndex = this.messages.length;
     }
@@ -1497,6 +1596,15 @@ export class AgentSession {
         const loaded = await this.sessionManager.load(sessionPath);
         // Use the leaf from the header to walk the correct branch
         const loadedMessages = this.sessionManager.getMessages(loaded.entries, loaded.header.leafId);
+        this.conversationId = loaded.header.conversationId ?? loaded.header.id;
+        const legacyLabel = [...loaded.entries]
+            .reverse()
+            .find((entry) => entry.type === "label")
+            ?.label.replace(/\s+/g, " ")
+            .trim()
+            .slice(0, 80);
+        this.sessionPreview =
+            legacyLabel || loaded.header.preview || findUserSessionPrompt(loadedMessages);
         // Restore Ken's advisory turns (custom entries, not on the message branch) so
         // they reappear in the transcript and survive into the continuation file.
         this.kenTurns = this.sessionManager.getKenTurns(loaded.entries);
@@ -1504,6 +1612,7 @@ export class AgentSession {
         this.autopilotMarkers = this.sessionManager.getAutopilotMarkers(loaded.entries);
         // Restore app transcript markers (plan banner / task header / errors / hints).
         this.appMarkers = this.sessionManager.getAppMarkers(loaded.entries);
+        this.turnMetrics = this.sessionManager.getTurnMetrics(loaded.entries);
         // Track the current leaf for subsequent entries
         this.currentLeafId = loaded.header.leafId;
         // Rebuild messages: keep system, add loaded
@@ -1523,6 +1632,7 @@ export class AgentSession {
             accountId: creds.accountId,
         });
         if (shouldCompact(this.messages, contextWindow, 0.8, undefined, getCompactionReserveTokens(this.maxTokens))) {
+            await this.subAgentManager?.hydrate(loaded.header.id);
             log("INFO", "session", `Restored session exceeds context — auto-compacting`);
             const compacted = await compact(this.messages, {
                 provider: this.provider,
@@ -1543,9 +1653,14 @@ export class AgentSession {
             // what's in memory — fork a fresh session file for the compacted state
             // (mirrors compact()'s own persistence) so `ggcoder continue` picks up
             // the summary instead of the full original transcript.
-            const session = await this.sessionManager.create(this.cwd, this.provider, this.model);
+            const session = await this.sessionManager.create(this.cwd, this.provider, this.model, {
+                conversationId: this.conversationId || undefined,
+                preview: this.sessionPreview || undefined,
+            });
             this.sessionId = session.id;
+            this.conversationId = session.header.conversationId ?? session.id;
             this.sessionPath = session.path;
+            await this.subAgentManager?.rebindParentSession(this.sessionId);
             this.currentLeafId = null;
             // Re-persist (compacted) messages — skip system, it's rebuilt on load
             for (const msg of this.messages) {
@@ -1554,7 +1669,8 @@ export class AgentSession {
                 await this.persistMessage(msg);
             }
             this.lastPersistedIndex = this.messages.length;
-            // Carry Ken's restored turns into the continuation file.
+            // Carry restored evidence into the continuation file.
+            await this.rePersistTurnMetrics();
             await this.rePersistKenTurns();
             await this.rePersistAutopilotMarkers();
             await this.rePersistAppMarkers();
@@ -1578,6 +1694,9 @@ export class AgentSession {
         return this.messages;
     }
     async persistMessage(message) {
+        if (!this.sessionPreview && message.role === "user") {
+            this.sessionPreview = getUserSessionPrompt(message.content) ?? "";
+        }
         // Transient sessions (subagent spawns) have no session file — skip.
         if (!this.sessionPath)
             return;