@kenkaiiii/ggcoder 5.17.0 → 5.19.0

package/README.md

@@ -71,7 +71,7 @@ Switch mid-conversation with `/model`. Not locked to anyone.
 |---|---|---|
 | **Anthropic** | Claude Opus 4.8, Sonnet 5, Haiku 4.5 | OAuth |
 | **OpenAI** | GPT-5.5, GPT-5.5 Pro, GPT-5.4, GPT-5.3 Codex | OAuth |
-| **Moonshot** | Kimi K2.7 | API key |
+| **Moonshot** | Kimi K3, Kimi K2.7 Code | OAuth or API key |
 | **Z.AI (GLM)** | GLM-5.1, GLM-4.7, GLM-4.7 Flash | API key |
 | **MiniMax** | MiniMax M3 (image + video) | API key |
 | **Xiaomi (MiMo)** | MiMo-V2.5-Pro, MiMo-V2.5-Pro-UltraSpeed, MiMo-V2.5 (image + video) | API key |
@@ -80,7 +80,7 @@ Switch mid-conversation with `/model`. Not locked to anyone.
 
 The same conversation, the same tools, the same project context — only the model changes. Use a strong reasoning model when you need it, swap to a fast cheap one for grunt work, never restart your session.
 
-**Attachments.** Drag, paste, or type a path to attach images and video in the chat input. Video is sent natively to models that support it (Gemini 3.x, Kimi K2.7, MiniMax M3, MiMo-V2.5); for other models the video is saved to a temp file and the model is told to inspect it with ffmpeg or its own tools.
+**Attachments.** Drag, paste, or type a path to attach images and video in the chat input. Video is sent natively to models that support it (Gemini 3.x, Kimi K3/K2.7 Code, MiniMax M3, MiMo-V2.5); for other models the video is saved to a temp file and the model is told to inspect it with ffmpeg or its own tools.
 
 ---
 

package/dist/app-sidecar.js

@@ -44,7 +44,8 @@ import { ensureAppDirs, loadSavedSettings } from "./config.js";
 import { SettingsManager } from "./core/settings-manager.js";
 import { getModel, getMaxThinkingLevel, getContextWindow, MODELS } from "./core/model-registry.js";
 import { resolveStartOrFallback } from "./core/resolve-start.js";
-import { getGitBranch, isGitRepo } from "./utils/git.js";
+import { getGitBranch, getGitDirtyFileCount, isGitRepo } from "./utils/git.js";
+import { extractPlanSteps } from "./utils/plan-steps.js";
 import { getNextThinkingLevel, getSupportedThinkingLevels, isThinkingLevelSupported, } from "./core/thinking-level.js";
 import { PROMPT_COMMANDS } from "./core/prompt-commands.js";
 import { loadCustomCommands } from "./core/custom-commands.js";
@@ -63,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");
@@ -535,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))) {
@@ -543,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;
             }
@@ -558,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,
@@ -586,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;
         }
@@ -1011,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") {
@@ -1035,7 +1066,9 @@ async function createSession(deps, opts) {
             ...baseSessionOptions,
             // Plan mode belongs only to the coding agent.
             onEnterPlan: async (reason) => {
+                deactivateApprovedPlan();
                 await session.setPlanMode(true);
+                broadcast("plan_progress", { total: 0, completed: [] });
                 broadcast("plan_enter", { reason: reason ?? "" });
                 void session.persistAppMarker("plan", { reason: reason ?? "" }).catch(() => { });
             },
@@ -1065,11 +1098,17 @@ async function createSession(deps, opts) {
         }
     }
     log("INFO", "app-sidecar", "session ready", { provider, model, mode, chatAgent, cwd });
-    // Footer extras (context window, git branch, background tasks). The git
-    // branch is resolved once at startup and refreshed lazily; the context
+    // Workspace extras (context window, git status, background tasks). Git state
+    // is resolved once at startup and refreshed after every run; the context
     // window follows the active model.
-    let gitBranch = await getGitBranch(cwd).catch(() => null);
-    let gitIsRepo = await isGitRepo(cwd).catch(() => false);
+    const [initialGitBranch, initialGitIsRepo, initialDirtyFileCount] = await Promise.all([
+        getGitBranch(cwd).catch(() => null),
+        isGitRepo(cwd).catch(() => false),
+        getGitDirtyFileCount(cwd).catch(() => 0),
+    ]);
+    let gitBranch = initialGitBranch;
+    let gitIsRepo = initialGitIsRepo;
+    let gitDirtyFileCount = initialDirtyFileCount;
     function currentContextWindow() {
         const st = session.getState();
         return getContextWindow(st.model, { provider: st.provider, accountId: st.accountId });
@@ -1081,6 +1120,7 @@ async function createSession(deps, opts) {
             contextWindow: currentContextWindow(),
             gitBranch,
             isGitRepo: gitIsRepo,
+            gitDirtyFileCount,
             tasks: session.listBackgroundProcesses(),
         };
     }
@@ -1090,8 +1130,93 @@ async function createSession(deps, opts) {
     // failures (e.g. repeated invalid-argument errors) instead of leaving the
     // fatal-abort path with no forensic trail.
     const toolCallNames = new Map();
+    // Approved-plan progress belongs beside the plan file, not in the webview.
+    // The implementation can rewrite/expand that file mid-run, so a step count
+    // frozen at approval time becomes dishonest (the exact stale-total bug the
+    // CLI already fixed). Re-read the live file after tools/markers, retain the
+    // last valid step section during transient edits, and send one authoritative
+    // snapshot to the app.
+    let approvedPlanPath = null;
+    let approvedPlanTotal = 0;
+    let approvedPlanMarkers = new Set();
+    let approvedPlanGeneration = 0;
+    let planMarkerTail = "";
+    let planProgressSync = Promise.resolve(false);
+    function planProgressPayload() {
+        const completed = [...approvedPlanMarkers]
+            .filter((step) => step >= 1 && step <= approvedPlanTotal)
+            .sort((a, b) => a - b);
+        return { total: approvedPlanTotal, completed };
+    }
+    async function syncApprovedPlanProgress(generation) {
+        const planPath = approvedPlanPath;
+        if (planPath === null || generation !== approvedPlanGeneration)
+            return false;
+        const content = await fs.readFile(planPath, "utf-8").catch(() => null);
+        if (approvedPlanPath !== planPath || generation !== approvedPlanGeneration)
+            return false;
+        if (content !== null) {
+            const freshTotal = extractPlanSteps(content).length;
+            // During an in-place rewrite the step section can briefly disappear.
+            // Keep the last real total instead of flashing 0 or declaring completion.
+            if (freshTotal > 0 || approvedPlanTotal === 0)
+                approvedPlanTotal = freshTotal;
+        }
+        broadcast("plan_progress", planProgressPayload());
+        return (approvedPlanTotal > 0 &&
+            Array.from({ length: approvedPlanTotal }, (_, index) => index + 1).every((step) => approvedPlanMarkers.has(step)));
+    }
+    function queueApprovedPlanProgressSync() {
+        const generation = approvedPlanGeneration;
+        planProgressSync = planProgressSync
+            .catch(() => false)
+            .then(() => syncApprovedPlanProgress(generation))
+            .catch((error) => {
+            log("WARN", "app-sidecar", "plan progress refresh failed", {
+                message: error instanceof Error ? error.message : String(error),
+            });
+            return false;
+        });
+        return planProgressSync;
+    }
+    async function activateApprovedPlan(planPath) {
+        deactivateApprovedPlan();
+        await session.setApprovedPlan(planPath);
+        if (!planPath)
+            return 0;
+        approvedPlanPath = planPath;
+        await queueApprovedPlanProgressSync();
+        return approvedPlanTotal;
+    }
+    function deactivateApprovedPlan() {
+        approvedPlanGeneration++;
+        approvedPlanPath = null;
+        approvedPlanTotal = 0;
+        approvedPlanMarkers = new Set();
+        planMarkerTail = "";
+        planProgressSync = Promise.resolve(false);
+    }
+    function recordApprovedPlanMarkers(text) {
+        if (approvedPlanPath === null || !text)
+            return;
+        const candidate = planMarkerTail + text;
+        let changed = false;
+        for (const match of candidate.matchAll(/\[DONE:(\d+)\]/gi)) {
+            const step = Number.parseInt(match[1], 10);
+            if (step >= 1 && !approvedPlanMarkers.has(step)) {
+                approvedPlanMarkers.add(step);
+                changed = true;
+            }
+        }
+        planMarkerTail = candidate.slice(-32);
+        if (changed)
+            void queueApprovedPlanProgressSync();
+    }
     // Forward every relevant bus event to the webview.
-    session.eventBus.on("text_delta", (d) => broadcast("text_delta", d));
+    session.eventBus.on("text_delta", (d) => {
+        broadcast("text_delta", d);
+        recordApprovedPlanMarkers(d.text);
+    });
     session.eventBus.on("thinking_delta", (d) => broadcast("thinking_delta", d));
     session.eventBus.on("tool_call_start", (d) => {
         toolCallNames.set(d.toolCallId, d.name);
@@ -1108,6 +1233,11 @@ async function createSession(deps, opts) {
             ...(d.isError ? { result: d.result.slice(0, 500) } : {}),
         });
         broadcast("tool_call_end", d);
+        // Any tool can mutate the approved plan (including bash), so refresh after
+        // every completed call while tracking is active. The file is tiny and this
+        // keeps the displayed total aligned before the next completion marker.
+        if (approvedPlanPath !== null)
+            void queueApprovedPlanProgressSync();
     });
     // Native server tools (e.g. Anthropic web_search) do NOT end the turn — text
     // streams before and after them in the SAME turn. The webview must reset its
@@ -1132,7 +1262,6 @@ async function createSession(deps, opts) {
     });
     const cancelledRunEndGenerations = new Set();
     let pendingCancelDrain = null;
-    let titleGenerated = false;
     // Bumped by /cancel — a run whose cancel generation changed mid-flight was
     // canceled and earns no XP.
     let cancelGeneration = 0;
@@ -1347,20 +1476,6 @@ async function createSession(deps, opts) {
         });
         return ken;
     }
-    // Resumed session: if it already has a conversation, generate its title now so
-    // the title bar shows it immediately on load (not just after the next prompt).
-    {
-        const hasHistory = session
-            .getMessages()
-            .some((m) => m.role === "user" || m.role === "assistant");
-        if (hasHistory) {
-            titleGenerated = true;
-            void session.generateTitle().then((title) => {
-                if (title)
-                    broadcast("session_title", { title });
-            });
-        }
-    }
     function abortOwnedWork() {
         cancelGeneration++;
         abort.abort();
@@ -1423,10 +1538,34 @@ async function createSession(deps, opts) {
                 // Fire-and-forget — XP must never delay or break run teardown.
                 void progress.awardRun(cwd, runStartedAt, opts.id);
             }
-            // A run may have switched branches (git checkout) or spawned/finished
-            // background tasks — refresh the footer extras once it settles.
-            gitBranch = await getGitBranch(cwd).catch(() => gitBranch);
-            gitIsRepo = await isGitRepo(cwd).catch(() => gitIsRepo);
+            // A run may have switched branches, changed files, or spawned/finished
+            // background tasks. Refresh the workspace extras once it settles.
+            [gitBranch, gitIsRepo, gitDirtyFileCount] = await Promise.all([
+                getGitBranch(cwd).catch(() => gitBranch),
+                isGitRepo(cwd).catch(() => gitIsRepo),
+                getGitDirtyFileCount(cwd).catch(() => gitDirtyFileCount),
+            ]);
+            // Serialize behind any marker/tool-triggered refresh so the terminal
+            // progress snapshot uses the live plan file. Once every canonical step
+            // is complete, remove the approved plan from future system prompts and
+            // clear the widget before run_end paints the idle activity bar.
+            if (runSucceeded &&
+                !cancelled &&
+                approvedPlanPath !== null &&
+                (await queueApprovedPlanProgressSync())) {
+                try {
+                    await session.setApprovedPlan(undefined);
+                    deactivateApprovedPlan();
+                    broadcast("plan_progress", { total: 0, completed: [] });
+                }
+                catch (error) {
+                    // Keep tracking when prompt cleanup fails; hiding the widget here
+                    // would claim completion while the approved-plan contract remained.
+                    log("WARN", "app-sidecar", "completed plan cleanup failed", {
+                        message: error instanceof Error ? error.message : String(error),
+                    });
+                }
+            }
             if (ownsGeneration)
                 finishOwnedGeneration(generation, false);
             // A cancelled injected run is still owned by the surrounding autopilot
@@ -1445,13 +1584,6 @@ async function createSession(deps, opts) {
             broadcast("tasks_list", { tasks: pruneDoneTasksSync(cwd) });
             broadcast("queued", { count: session.getQueuedCount() });
             broadcast("extras", footerExtras());
-            if (!titleGenerated) {
-                titleGenerated = true;
-                void session.generateTitle().then((title) => {
-                    if (title)
-                        broadcast("session_title", { title });
-                });
-            }
         }
     }
     // ── Autopilot orchestration ─────────────────────────────────
@@ -1582,22 +1714,22 @@ async function createSession(deps, opts) {
                     if (pendingPlanPath === null || planGeneration !== planGenAtReview)
                         return false;
                     const planPath = pendingPlanPath;
+                    let planTotal;
                     try {
-                        await session.newSession();
+                        await session.newSession(true);
                         injectedAutopilotPrompts = [];
-                        titleGenerated = false;
-                        await session.setApprovedPlan(planPath);
+                        planTotal = await activateApprovedPlan(planPath);
                     }
                     catch (err) {
                         broadcastError("autopilot_error", "autopilot plan accept failed", err);
                         return false;
                     }
                     clearPendingPlan();
-                    // Ordering is load-bearing: the webview reads its still-open plan
-                    // modal state (step count) on autopilot_plan_accepted, and
-                    // session_reset clears it — accepted must land first.
+                    // Keep the approval marker ahead of the reset, then seed the reset
+                    // with the sidecar's canonical count from the actual plan file.
                     broadcast("autopilot_plan_accepted", {});
-                    broadcast("session_reset", {});
+                    broadcast("session_reset", { planTotal });
+                    broadcast("plan_progress", planProgressPayload());
                     // Persisted into the NEW session so a resume shows the marker.
                     void session.persistAutopilotMarker("plan_approved");
                     return true;
@@ -1755,9 +1887,9 @@ async function createSession(deps, opts) {
             return false;
         // Fresh session per task so one task's context never bleeds into the next.
         await session.newSession();
+        deactivateApprovedPlan();
         injectedAutopilotPrompts = [];
         clearPendingPlan();
-        titleGenerated = false;
         broadcast("session_reset", {});
         markTaskInProgress(cwd, task.id);
         broadcast("tasks_list", { tasks: loadTasksSync(cwd) });
@@ -1838,6 +1970,30 @@ async function createSession(deps, opts) {
         tasksPoll.unref?.();
     };
     scheduleTasksPoll(1500);
+    // Files can change outside the agent (editor saves, terminal commits), so keep
+    // the dirty count current while idle. Branch/repo state already refreshes after
+    // agent runs; polling only the count avoids spawning three git processes per tick.
+    let gitPoll;
+    let gitPollStopped = false;
+    const scheduleGitPoll = (delay) => {
+        if (gitPollStopped)
+            return;
+        gitPoll = setTimeout(() => {
+            void getGitDirtyFileCount(cwd)
+                .catch(() => gitDirtyFileCount)
+                .then((nextDirtyFileCount) => {
+                if (gitPollStopped)
+                    return;
+                if (nextDirtyFileCount !== gitDirtyFileCount) {
+                    gitDirtyFileCount = nextDirtyFileCount;
+                    broadcast("extras", footerExtras());
+                }
+                scheduleGitPoll(5000);
+            });
+        }, delay);
+        gitPoll.unref?.();
+    };
+    scheduleGitPoll(5000);
     function readBody(req) {
         return new Promise((resolve, reject) => {
             const chunks = [];
@@ -2111,6 +2267,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();
@@ -2328,10 +2498,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",
@@ -2984,6 +3155,7 @@ async function createSession(deps, opts) {
                 if (mode === "chat") {
                     await session.persistAppMarker("agent_handoff", { chatAgent });
                 }
+                deactivateApprovedPlan();
                 injectedAutopilotPrompts = [];
                 clearPendingPlan();
                 broadcast("session_reset", {});
@@ -3036,12 +3208,12 @@ async function createSession(deps, opts) {
                     broadcast("autopilot_ignored", {});
                 }
                 try {
-                    await session.newSession();
+                    await session.newSession(true);
                     injectedAutopilotPrompts = [];
-                    titleGenerated = false;
-                    await session.setApprovedPlan(planPath);
-                    broadcast("session_reset", {});
-                    json(res, 200, { ok: true });
+                    const planTotal = await activateApprovedPlan(planPath);
+                    broadcast("session_reset", { planTotal });
+                    broadcast("plan_progress", planProgressPayload());
+                    json(res, 200, { ok: true, planTotal });
                 }
                 catch (err) {
                     json(res, 500, { error: err instanceof Error ? err.message : String(err) });
@@ -3469,6 +3641,9 @@ async function createSession(deps, opts) {
         tasksPollStopped = true;
         if (tasksPoll)
             clearTimeout(tasksPoll);
+        gitPollStopped = true;
+        if (gitPoll)
+            clearTimeout(gitPoll);
         // Stop the Telegram serve loop + dispose its per-chat sessions.
         if (serveController)
             await serveController.stop().catch(() => { });