@kenkaiiii/ggcoder 5.68.1 → 5.70.0

package/dist/core/agent-session.js

@@ -1,6 +1,7 @@
 import { agentLoop, isAbortError, isUsageLimitError, repairToolPairingAdjacent, } from "@kenkaiiii/gg-agent";
 import { ProviderError, stream, } from "@kenkaiiii/gg-ai";
 import { EventBus } from "./event-bus.js";
+import { flagUntrustedToolResult } from "./injection-detect.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";
@@ -23,6 +24,8 @@ import { ensureAppDirs } from "../config.js";
 import { buildSubAgentSystemPrompt, buildSystemPrompt, } from "../system-prompt.js";
 import { createTools, createWebSearchTool, } from "../tools/index.js";
 import { partitionToolsByTier } from "../tools/tool-tiers.js";
+import { formatImpactForVerification } from "./test-impact.js";
+import { autoBackgroundedId } from "../tools/bash.js";
 import { buildProcessCompletionFollowUp } from "./process-gate.js";
 import { buildSubAgentCompletionFollowUp, } from "./subagent-manager.js";
 import { applyAsyncSubagentPolicy } from "./subagent-policy.js";
@@ -37,6 +40,7 @@ import { createSessionStatsTool } from "../tools/session-stats.js";
 import { createDiagnoseCommand, isInternalDiagnosticsEnabled, SessionDiagnosticsRecorder, } from "./internal-diagnostics.js";
 import { log } from "./logger.js";
 import { CacheDiagnostics } from "./cache-diagnostics.js";
+import { assessCacheExpiry, resolveCacheTtl } from "./cache-expiry.js";
 import { setEstimatorModel, calibrateEstimatorFromUsage, estimateConversationTokens, } from "./compaction/token-estimator.js";
 import { calculateActiveContextTokens } from "./compaction/active-context.js";
 import { resolveCompactionPolicy } from "./compaction/policy.js";
@@ -256,8 +260,12 @@ export class AgentSession {
     // different message (or past the end) by the time the cancel arrives.
     userQueue = [];
     queueSeq = 0;
+    /** Instant interrupt: the running loop's preempt listeners, fired on queueMessage. */
+    steeringListeners = new Set();
     processManager;
     lspManager;
+    testImpact;
+    debugManager;
     subAgentManager;
     /**
      * Out-of-band push notifications (finished children, background-process
@@ -427,7 +435,7 @@ export class AgentSession {
             : this.opts.globalSubagents
                 ? await discoverAgents({ globalAgentsDir: paths.agentsDir })
                 : [];
-        const { tools: builtInTools, processManager, rebuildReadTool, clearReadTracker, lspManager, subAgentManager, } = await createTools(this.cwd, {
+        const { tools: builtInTools, processManager, rebuildReadTool, clearReadTracker, lspManager, testImpact, debugManager, subAgentManager, } = await createTools(this.cwd, {
             agents,
             skills: this.skills,
             contextLimits: this.contextLimits,
@@ -468,7 +476,6 @@ export class AgentSession {
             // sub-agent spawns read the current parent state at execution time.
             getProvider: () => this.provider,
             getModel: () => this.model,
-            getThinkingLevel: () => this.thinkingLevel,
             getBaseUrl: () => this.baseUrl,
             getCacheKey: () => this.getPromptCacheKey(),
             getMaxPerModel: () => this.settingsManager.get("subagentMaxPerModel"),
@@ -514,12 +521,15 @@ export class AgentSession {
                 this.mcpCatalog ??= new DeferredToolCatalog(this.contextLimits);
                 this.mcpCatalog.add(deferred);
                 this.ensureToolSearchTool();
+                this.promoteWaitAgentAfterSpawn();
             }
         }
         this.rebuildReadTool = rebuildReadTool;
         this.clearReadTracker = clearReadTracker;
         this.processManager = processManager;
         this.lspManager = lspManager;
+        this.testImpact = testImpact;
+        this.debugManager = debugManager;
         this.subAgentManager = subAgentManager;
         this.bindManagerCancellation(this.opts.signal);
         // Connect MCP servers. The connect attempt itself can block for up to the
@@ -808,6 +818,29 @@ export class AgentSession {
                 : { serverName, ok: false, error: outcome.error };
         }, this.contextLimits));
     }
+    /**
+     * `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.
+     */
+    promoteWaitAgentAfterSpawn() {
+        const index = this.tools.findIndex((t) => t.name === "spawn_agent");
+        const spawn = index >= 0 ? this.tools[index] : undefined;
+        if (!spawn)
+            return;
+        this.tools[index] = {
+            ...spawn,
+            execute: async (args, context) => {
+                const result = await spawn.execute(args, context);
+                if (!this.tools.some((t) => t.name === "wait_agent")) {
+                    this.tools.push(...(this.mcpCatalog?.promote(["wait_agent"]) ?? []));
+                }
+                return result;
+            },
+        };
+    }
     /** Append tools, replacing any same-named entry (cached stub → live tool). */
     replaceOrPushTools(tools) {
         for (const tool of tools) {
@@ -1255,8 +1288,13 @@ export class AgentSession {
                     const command = typeof args.command === "string" ? args.command : "";
                     const classification = classifyVerificationCommand(command);
                     if (classification.accepted || classification.snapshotEligible) {
-                        if (args.run_in_background === true && !event.isError && args.persist !== true) {
-                            const id = /^ID:\s*(\S+)/m.exec(event.result)?.[1];
+                        // A foreground check that outlived the default budget was moved to
+                        // the background, not failed: track it to its real exit the same way.
+                        const autoBackgroundId = event.isError ? undefined : autoBackgroundedId(event.result);
+                        if ((autoBackgroundId !== undefined || args.run_in_background === true) &&
+                            !event.isError &&
+                            args.persist !== true) {
+                            const id = autoBackgroundId ?? /^ID:\s*(\S+)/m.exec(event.result)?.[1];
                             // No parseable ID means the check cannot be tracked to a real exit
                             // code — no evidence either way. Recording a FAILURE here made
                             // every later green run of a different spelling look owed.
@@ -1907,8 +1945,23 @@ export class AgentSession {
             this.settingsManager.get("verificationGateEnabled") &&
             (!this.opts.allowedTools || this.opts.allowedTools.includes("bash"))) {
             const verificationReason = this.verificationGate.pendingReason();
+            const pendingFiles = this.verificationGate.pendingFiles();
             const verificationFollowUp = this.verificationGate.followUp();
             if (verificationFollowUp) {
+                // Name the tests that actually reach the unverified files, with the
+                // command that runs exactly those, so the check is targeted rather
+                // than guessed. Best-effort: no index or no runner leaves it unchanged.
+                if (this.testImpact &&
+                    (verificationReason === "initial" || verificationReason === "recheck")) {
+                    const impactLine = await this.testImpact
+                        .impactFor(pendingFiles)
+                        .then(formatImpactForVerification)
+                        .catch(() => "");
+                    const first = verificationFollowUp[0];
+                    if (impactLine && first?.role === "user" && typeof first.content === "string") {
+                        verificationFollowUp[0] = { ...first, content: first.content + impactLine };
+                    }
+                }
                 log("INFO", "verification-gate", "Injecting verification follow-up", {});
                 // Announce, THEN disarm: clients release held text on disarm, so the
                 // reverse order paints the draft and immediately deletes it — the exact
@@ -2262,9 +2315,15 @@ export class AgentSession {
                 maxToolResultChars: resolveSessionToolResultCharLimit(this.model, this.provider, accountId),
                 // Aggregate per-turn budget across parallel tool results (fan-out guard).
                 maxTurnToolResultChars: resolveSessionTurnToolResultCharLimit(this.model, this.provider, accountId),
+                // Warn when web/MCP output contains instruction-like text (see injection-detect.ts).
+                transformToolResult: flagUntrustedToolResult,
                 // 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(),
+                onSteeringAvailable: (listener) => {
+                    this.steeringListeners.add(listener);
+                    return () => this.steeringListeners.delete(listener);
+                },
                 getFollowUpMessages: () => this.getHookFollowUpMessages(),
                 onTurnBudgetExhausted: (ctx) => this.shouldExtendTurnBudget(ctx),
                 // Check authoritative provider usage before every model/tool step.
@@ -3201,6 +3260,31 @@ export class AgentSession {
             : undefined;
         return costUsd === undefined ? { used, size } : { used, size, costUsd };
     }
+    /**
+     * Whether the provider's prompt cache has likely lapsed since the last
+     * successful request, and how many tokens the next message would re-read at
+     * full price. Null when the route has no known TTL or the chat is empty.
+     */
+    getCacheExpiryStatus(now = Date.now()) {
+        const status = assessCacheExpiry({
+            current: {
+                provider: this.provider,
+                model: this.model,
+                policy: resolveCacheTtl({
+                    provider: this.provider,
+                    model: this.model,
+                    cacheRetention: this.isSpeedOptimized() ? "long" : "short",
+                    baseUrl: this.baseUrl,
+                    accountId: this.lastAccountId,
+                }),
+            },
+            lastTouch: this.cacheDiagnostics.lastCacheTouch(),
+            now,
+            prefixTokens: this.getContextUsage().used,
+            hasHistory: this.messages.some((m) => m.role === "user"),
+        });
+        return status && { ...status, sessionId: this.sessionId || this.transportSessionId };
+    }
     getPlanMode() {
         return this.planModeRef.current;
     }
@@ -3225,6 +3309,9 @@ export class AgentSession {
     queueMessage(text, attachments = []) {
         this.queueSeq += 1;
         this.userQueue.push({ id: `q${this.queueSeq}`, text, attachments });
+        // Instant interrupt: preempt running tools so the steer lands right away.
+        for (const listener of [...this.steeringListeners])
+            listener();
         return this.userQueue.length;
     }
     /** Pending queued messages (id + text), oldest first, for client display. */
@@ -3277,6 +3364,15 @@ export class AgentSession {
             return `No background process with id "${id}"`;
         return this.processManager.stop(id);
     }
+    /**
+     * Force-stop every background process tree, synchronously. Background
+     * commands run in their own process group, so the daemon's group kill on
+     * quit never reaches them: this is the only thing that does. Callers on a
+     * shutdown deadline run it before awaiting anything that can hang.
+     */
+    stopBackgroundProcesses() {
+        this.processManager?.shutdownAll();
+    }
     /** Replace a host-owned system prompt in place without resetting conversation history. */
     setCustomSystemPrompt(systemPrompt, promptCacheKeyPrefix) {
         this.customSystemPrompt = systemPrompt;
@@ -4026,6 +4122,21 @@ export class AgentSession {
                 return { ok: false, reason: "thinking_budget_incompatible" };
             }
             this.lastPrewarmAt = Date.now();
+            const warmedPolicy = resolveCacheTtl({
+                provider: this.provider,
+                model: this.model,
+                cacheRetention,
+                baseUrl: this.baseUrl ?? creds.baseUrl,
+                accountId: creds.accountId,
+            });
+            if (warmedPolicy) {
+                this.cacheDiagnostics.noteCacheTouch({
+                    at: started,
+                    provider: this.provider,
+                    model: this.model,
+                    policy: warmedPolicy,
+                });
+            }
             log("INFO", "prewarm", "Cache prewarm complete", {
                 tokens: String(tokens),
                 cacheRead: String(usage.cacheRead ?? 0),
@@ -4074,6 +4185,9 @@ export class AgentSession {
         return this.getPromptCacheKey();
     }
     async dispose() {
+        // First and synchronous: nothing below may delay this, or a hung teardown
+        // step leaves background commands running after the app has quit.
+        this.stopBackgroundProcesses();
         // Quiesce any in-flight post-turn compaction BEFORE tearing down state:
         // the background compact() snapshots and replaces `this.messages`, so
         // letting it run past this point would checkpoint a near-empty history
@@ -4083,8 +4197,10 @@ export class AgentSession {
         this.cacheDiagnostics.reset();
         this.diagnosticsRecorder?.finalize();
         this.managerAbortSignal?.removeEventListener("abort", this.managerAbortHandler);
-        this.processManager?.shutdownAll();
+        // Again, in case a turn racing teardown started one while we awaited.
+        this.stopBackgroundProcesses();
         this.lspManager?.shutdownAll();
+        this.debugManager?.shutdown();
         await Promise.all([this.subAgentManager?.shutdownAll(), this.mcpManager?.dispose()]);
         await this.extensionLoader.deactivateAll();
         this.setSessionPath("");