@kenkaiiii/ggcoder 5.18.0 → 5.19.1

package/dist/app-sidecar.js

@@ -64,16 +64,20 @@ import { awardPrompt, awardCommits } from "./core/progress/engine.js";
 import { detectNewCommits, repoKey } from "./core/progress/git-xp.js";
 import { rebuildFromSessions } from "./core/progress/rebuild.js";
 const ALL_PROVIDERS = [
+    // US
     "anthropic",
-    "xiaomi",
     "openai",
     "gemini",
-    "glm",
+    "xai",
+    // China
     "moonshot",
+    "glm",
     "minimax",
+    "xiaomi",
     "deepseek",
-    "openrouter",
+    // Japan, then provider-agnostic gateway last
     "sakana",
+    "openrouter",
 ];
 function appSettingsFile() {
     return path.join(os.homedir(), ".gg", "gg-app.json");
@@ -536,6 +540,11 @@ async function main() {
     });
     const usageCache = new Map();
     const usageRequests = new Map();
+    // 429 backoff: when the provider rate-limits the usage endpoint, hold the
+    // error result until this timestamp instead of re-polling (and re-logging a
+    // WARN) every 60s — the old cadence hammered a limited endpoint for hours.
+    const usageRateLimitedUntil = new Map();
+    const USAGE_RATE_LIMIT_BACKOFF_MS = 5 * 60_000;
     async function fetchUsageProvider(provider) {
         const displayName = provider === "anthropic" ? "Anthropic" : "Codex";
         if (!(await auth.hasProviderAuth(provider))) {
@@ -544,14 +553,24 @@ async function main() {
         try {
             let credentials = await auth.resolveCredentials(provider);
             try {
-                return { ...(await fetchSubscriptionUsage(provider, credentials)), connected: true };
+                const snapshot = {
+                    ...(await fetchSubscriptionUsage(provider, credentials)),
+                    connected: true,
+                };
+                usageRateLimitedUntil.delete(provider);
+                return snapshot;
             }
             catch (error) {
                 // A provider can revoke an access token before its stored expiry. Refresh
                 // once on 401, matching inference auth recovery, then retry the usage call.
                 if (error instanceof SubscriptionUsageError && error.status === 401) {
                     credentials = await auth.resolveCredentials(provider, { forceRefresh: true });
-                    return { ...(await fetchSubscriptionUsage(provider, credentials)), connected: true };
+                    const snapshot = {
+                        ...(await fetchSubscriptionUsage(provider, credentials)),
+                        connected: true,
+                    };
+                    usageRateLimitedUntil.delete(provider);
+                    return snapshot;
                 }
                 throw error;
             }
@@ -559,6 +578,9 @@ async function main() {
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
             log("WARN", "app-sidecar", "subscription usage fetch failed", { provider, message });
+            if (error instanceof SubscriptionUsageError && error.status === 429) {
+                usageRateLimitedUntil.set(provider, Date.now() + USAGE_RATE_LIMIT_BACKOFF_MS);
+            }
             const connected = await auth.hasProviderAuth(provider);
             return {
                 provider,
@@ -587,9 +609,12 @@ async function main() {
             const missingReset = result.connected &&
                 result.windows.length > 0 &&
                 result.windows.some((window) => window.resetsAt === undefined);
+            const rateLimitedUntil = usageRateLimitedUntil.get(provider) ?? 0;
             usageCache.set(provider, {
                 result,
-                expiresAt: Date.now() + (missingReset ? 10_000 : 60_000),
+                expiresAt: rateLimitedUntil > Date.now()
+                    ? rateLimitedUntil
+                    : Date.now() + (missingReset ? 10_000 : 60_000),
             });
             return result;
         }
@@ -1012,6 +1037,11 @@ async function createSession(deps, opts) {
         signal: abort.signal,
         // Keep MCP startup off the readiness path in both modes.
         backgroundMcpConnect: true,
+        // Keep restore-time auto-compaction off the readiness path too: its summary
+        // LLM call (30s timeout) used to freeze waitForReady — and with it the whole
+        // window (project picker, session list) — whenever a resumed session was
+        // over the context threshold. First prompt compacts instead, with UI events.
+        deferLoadCompaction: true,
     };
     let session;
     if (mode === "chat") {
@@ -1238,8 +1268,10 @@ async function createSession(deps, opts) {
     // Autopilot (auto-review) toggle for THIS window's project. Loaded from
     // gg-app.json on boot; flipped via POST /autopilot. When on, POST /prompt runs
     // runAutopilotCycle after the user's turn settles — Ken auto-reviews the work
-    // and drives the review→prompt→review loop.
+    // and drives the review→prompt→review loop. Ken is the sole verification
+    // owner in this mode, so suppress the build session's redundant Ideal hook.
     let autopilot = mode === "code" && (await loadAutopilot(cwd));
+    session.setIdealReviewSuppressed(autopilot);
     // True while an autopilot review is in flight (used to defer kenAuto model
     // switches, like kenRunning does for chat Ken, and to drive the spinner).
     let autopilotReviewing = false;
@@ -1436,6 +1468,9 @@ async function createSession(deps, opts) {
             // (often >5 min) regardless of the user's global speedProfile pick.
             forceLongCacheRetention: true,
         });
+        // Ken is already the independent autopilot reviewer; recursively running
+        // his own Ideal self-review adds latency and can corrupt the verdict shape.
+        ken.setIdealReviewSuppressed(true);
         await ken.initialize();
         // Deliberately no bus bridge: the review is silent. Errors surface via the
         // runAutopilotReview try/catch as autopilot_error frames.
@@ -1658,6 +1693,7 @@ async function createSession(deps, opts) {
         const generation = runLifecycle.begin(abortOwnedWork).generation;
         pendingCancelDrain = null;
         autopilotActive = true;
+        session.setIdealReviewSuppressed(true);
         // Generation captured by the last plan review; acceptPlan re-checks it so
         // a user Accept/Reject landing mid-review always wins.
         let planGenAtReview = -1;
@@ -1771,6 +1807,7 @@ async function createSession(deps, opts) {
         }
         finally {
             autopilotActive = false;
+            session.setIdealReviewSuppressed(autopilot);
             finishOwnedGeneration(generation, true);
             queueMicrotask(() => void runStrandedQueue());
         }
@@ -2237,6 +2274,20 @@ async function createSession(deps, opts) {
             void (async () => {
                 const commandCandidates = [...PROMPT_COMMANDS, ...(await loadCustomCommands(cwd))];
                 const messages = session.getMessages();
+                // An Ideal hook is injected immediately after the assistant's candidate
+                // no-tool response. That response is review scratch, not a user-visible
+                // final answer. Live SSE drops it when the hook event arrives; mark the
+                // same assistant message here so resumed history stays identical.
+                const hiddenIdealDrafts = new Set();
+                for (let i = 0; i < messages.length - 1; i++) {
+                    const draft = messages[i];
+                    const hookPrompt = messages[i + 1];
+                    if (draft?.role !== "assistant" || hookPrompt?.role !== "user")
+                        continue;
+                    const restored = restoreUserRow(hookPrompt.content);
+                    if (detectHookKind(restored.text) === "ideal")
+                        hiddenIdealDrafts.add(draft);
+                }
                 // Pre-index tool results by toolCallId so we can pair tool calls with
                 // their results (for sub-agent status + image extraction).
                 const toolResultMap = new Map();
@@ -2454,10 +2505,11 @@ async function createSession(deps, opts) {
                             }
                         }
                     }
-                    else {
+                    else if (!hiddenIdealDrafts.has(msg)) {
                         // Assistant: one wire row per persisted text block — live streaming
                         // splits bubbles at server_tool_call boundaries, and the persisted
-                        // content keeps those blocks separate.
+                        // content keeps those blocks separate. Ideal-review candidate drafts
+                        // are intentionally omitted to match the live pre-final hook flow.
                         for (const blockText of restoreAssistantTexts(msg.content)) {
                             history.push({
                                 role: "assistant",
@@ -2736,6 +2788,9 @@ async function createSession(deps, opts) {
                     return;
                 }
                 autopilot = enabled;
+                // A toggle-off during an active cycle takes effect after Ken finishes;
+                // until then, injected build runs must not re-enable Ideal self-review.
+                session.setIdealReviewSuppressed(enabled || autopilotActive);
                 await saveAutopilot(cwd, enabled);
                 log("INFO", "app-sidecar", "autopilot toggled", { enabled: String(enabled) });
                 broadcast("autopilot", { autopilot: enabled });