@kenkaiiii/ggcoder 5.6.3 → 5.8.0

package/dist/app-sidecar.js

@@ -13,6 +13,7 @@
  */
 import http from "node:http";
 import fs from "node:fs/promises";
+import { watch as fsWatch } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { randomUUID } from "node:crypto";
@@ -21,7 +22,7 @@ import { formatError } from "@kenkaiiii/gg-ai";
 import { runJsonMode } from "./modes/json-mode.js";
 import { AgentSession } from "./core/agent-session.js";
 import { buildKenSystemPrompt, buildKenAutopilotSystemPrompt } from "./core/ken-prompt.js";
-import { buildKenDigest, buildKenAutopilotContext } from "./core/ken-context.js";
+import { buildKenDigest, buildKenAutopilotContext, buildKenAutopilotPlanContext, } from "./core/ken-context.js";
 import { parseAutopilotVerdict } from "./core/autopilot-verdict.js";
 import { isWorkflowCommandText, countAssistantMessages, shouldStartAutopilotCycle, extractTurnToolCalls, isMechanicalOnlyTurn, } from "./core/autopilot-gate.js";
 import { driveAutopilotCycle } from "./core/autopilot-cycle.js";
@@ -50,6 +51,11 @@ import { downscaleForPreview, validateVisionImage } from "./utils/image.js";
 import { startServeMode } from "./modes/serve-mode.js";
 import { loadTelegramConfig, saveTelegramConfig, verifyBotToken } from "./core/telegram-config.js";
 import { loadServers, addServer, removeServer, getServer, parseMcpAddCommand, MCPClientManager, McpOAuthStore, } from "./core/mcp/index.js";
+import { buildSnapshot, levelForXp, rankForLevel } from "./core/progress/ranks.js";
+import { loadProgress, peekProgress, updateProgress } from "./core/progress/store.js";
+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 = [
     "anthropic",
     "xiaomi",
@@ -495,6 +501,13 @@ async function main() {
     // request to its window's session via the `x-gg-session` header (and the
     // `?session=` query for the SSE /events stream).
     const sessions = new Map();
+    // XP/rank progress — loaded once per daemon; awards fan out to every window.
+    // Each frame is tagged `origin: true` only for the session that earned the
+    // XP, so that window alone plays sounds/chips while the rest just re-render.
+    const progress = await createProgressManager(paths.agentDir, (snapshot, originId) => {
+        for (const ctx of sessions.values())
+            ctx.broadcast("progress", { ...snapshot, origin: ctx.id === originId });
+    });
     /** Resolve the target session id: the `x-gg-session` header, else a
      *  `?session=` query param (used by the SSE /events connection). */
     function sessionIdFromReq(req, url) {
@@ -538,7 +551,7 @@ async function main() {
                 const sessionPath = typeof body.sessionPath === "string" && body.sessionPath ? body.sessionPath : undefined;
                 const id = randomUUID();
                 try {
-                    const ctx = await createSession({ auth, paths }, { id, cwd: sessionCwd, sessionPath });
+                    const ctx = await createSession({ auth, paths, progress }, { id, cwd: sessionCwd, sessionPath });
                     sessions.set(id, ctx);
                     log("INFO", "app-sidecar", "session created", { id, cwd: sessionCwd });
                     daemonJson(res, 200, { sessionId: id });
@@ -563,6 +576,12 @@ async function main() {
             daemonJson(res, 200, { ok: true });
             return;
         }
+        // Progress is daemon-level so the Home screen can paint before a project
+        // session exists; per-session callers still work through the same endpoint.
+        if (method === "GET" && url === "/progress") {
+            daemonJson(res, 200, progress.snapshot());
+            return;
+        }
         // ── Per-session delegation ───────────────────────────────────────────
         const id = sessionIdFromReq(req, url);
         const ctx = id ? sessions.get(id) : undefined;
@@ -641,6 +660,88 @@ function buildKenContext(buildSession, cwd, gitBranch, question, workflowCommand
         injectedPrompts,
     });
 }
+async function createProgressManager(agentDir, broadcastAll) {
+    // Boot: recovery chain main → backup → one-time session-history rebuild → empty.
+    let file = await loadProgress({ rebuild: () => rebuildFromSessions() });
+    // Don't re-celebrate an old levelUp event on boot.
+    let lastSeenNonce = file.lastEvent?.nonce ?? null;
+    log("INFO", "app-sidecar", "progress loaded", {
+        xp: String(file.xp),
+        level: String(levelForXp(file.xp)),
+    });
+    function snapshot() {
+        return buildSnapshot(file);
+    }
+    async function awardRun(cwd, runStartedAt, originId) {
+        try {
+            const now = Date.now();
+            const updated = await updateProgress(async (f) => {
+                const levelBefore = levelForXp(f.xp);
+                awardPrompt(f, now, cwd);
+                // Commit XP: probe repo root + HEAD, then score lastHead..HEAD bounded
+                // by the run window. First sight of a repo records HEAD, scores nothing.
+                const probe = await detectNewCommits(cwd, undefined, runStartedAt);
+                if (probe) {
+                    const key = repoKey(probe.repoRoot);
+                    const lastHead = f.repos[key]?.lastHead;
+                    if (lastHead && lastHead !== probe.head) {
+                        const detected = await detectNewCommits(cwd, lastHead, runStartedAt);
+                        if (detected && detected.commits.length > 0) {
+                            awardCommits(f, detected.commits, now, cwd);
+                        }
+                    }
+                    f.repos[key] = { lastHead: probe.head };
+                }
+                // One combined lastEvent per run so other windows celebrate exactly once.
+                const levelAfter = levelForXp(f.xp);
+                const levelUp = levelAfter > levelBefore
+                    ? { from: levelBefore, to: levelAfter, rankName: rankForLevel(levelAfter).name }
+                    : null;
+                f.lastEvent = { nonce: randomUUID(), levelUp };
+                return { file: f, levelledUp: levelUp !== null };
+            });
+            file = updated;
+            lastSeenNonce = updated.lastEvent?.nonce ?? null;
+            broadcastAll(buildSnapshot(updated), originId);
+        }
+        catch (err) {
+            log("DEBUG", "app-sidecar", "progress award failed", {
+                message: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    // Watch ~/.gg (dir watch survives the atomic tmp+rename) for progress.json
+    // writes from other daemon processes; debounce, reload read-only, dedupe by nonce.
+    let watchDebounce = null;
+    try {
+        const watcher = fsWatch(agentDir, (_event, filename) => {
+            if (filename !== "progress.json")
+                return;
+            if (watchDebounce)
+                clearTimeout(watchDebounce);
+            watchDebounce = setTimeout(() => {
+                void (async () => {
+                    const reloaded = await peekProgress();
+                    if (!reloaded)
+                        return;
+                    const nonce = reloaded.lastEvent?.nonce ?? null;
+                    if (nonce === lastSeenNonce)
+                        return;
+                    file = reloaded;
+                    lastSeenNonce = nonce;
+                    broadcastAll(buildSnapshot(reloaded));
+                })();
+            }, 150);
+        });
+        watcher.unref();
+    }
+    catch (err) {
+        log("DEBUG", "app-sidecar", "progress watch unavailable", {
+            message: err instanceof Error ? err.message : String(err),
+        });
+    }
+    return { snapshot, awardRun };
+}
 /**
  * Build one in-process agent session: its AgentSession, SSE client set, event
  * bridge, task runner, auth/login bridge, and the full HTTP route table exposed
@@ -649,7 +750,7 @@ function buildKenContext(buildSession, cwd, gitBranch, question, workflowCommand
  * logger, PATH, shared auth file, and radio live at the daemon level.
  */
 async function createSession(deps, opts) {
-    const { auth } = deps;
+    const { auth, progress } = deps;
     const paths = deps.paths;
     const cwd = opts.cwd;
     // Base host for parsing request-URL query params (value is irrelevant to
@@ -746,6 +847,12 @@ async function createSession(deps, opts) {
             catch {
                 content = "";
             }
+            // Record the submitted plan so the autopilot gate can route this turn
+            // into a PLAN review instead of a stale work review (plan mode is
+            // already false here, so the gate's planMode check alone never catches
+            // a submission). setPendingPlan bumps planGeneration, which invalidates
+            // any in-flight Ken plan review racing a user action.
+            setPendingPlan(planPath, content);
             broadcast("plan_exit", { planPath, content });
             return "Plan submitted for user review. Wait for the user to approve, reject, or dismiss it before implementing.";
         },
@@ -812,6 +919,9 @@ async function createSession(deps, opts) {
     session.eventBus.on("compaction_end", (d) => broadcast("compaction_end", d));
     let running = false;
     let titleGenerated = false;
+    // Bumped by /cancel — a run whose cancel generation changed mid-flight was
+    // canceled and earns no XP.
+    let cancelGeneration = 0;
     // 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
@@ -836,6 +946,28 @@ async function createSession(deps, opts) {
     // cycles drift into Ken reviewing against his own last prompt. Cleared
     // whenever the conversation resets (new session / plan accept / task run).
     let injectedAutopilotPrompts = [];
+    // The plan GG Coder submitted via exit_plan that still awaits a decision
+    // (Ken's auto-review in autopilot, or the user's modal). Path + the content
+    // read at submission time (fallback if the file becomes unreadable).
+    let pendingPlanPath = null;
+    let pendingPlanContent = "";
+    // Bumped on EVERY pending-plan set/clear. Ken's plan review captures it
+    // before reviewing and re-checks it before acting on the verdict, so a user
+    // Accept/Reject racing an in-flight review always wins — the stale verdict
+    // is discarded silently.
+    let planGeneration = 0;
+    function setPendingPlan(planPath, content) {
+        pendingPlanPath = planPath;
+        pendingPlanContent = content;
+        planGeneration++;
+    }
+    function clearPendingPlan() {
+        if (pendingPlanPath === null)
+            return;
+        pendingPlanPath = null;
+        pendingPlanContent = "";
+        planGeneration++;
+    }
     // Workflow (prompt-template) commands: built-in + the project's custom
     // `.gg/commands/*.md`. Used to gate autopilot off command turns and to label
     // expanded templates in Ken's digests. Loaded fresh so a newly added custom
@@ -1020,15 +1152,28 @@ async function createSession(deps, opts) {
     // run_start frame.
     async function runAgent(label, run) {
         running = true;
+        // Progress (Ranks): completed, non-canceled runs with ≥1 assistant turn earn
+        // XP — prompt + any commits authored during the run window.
+        const runStartedAt = Date.now();
+        const cancelGenAtStart = cancelGeneration;
+        const assistantsBeforeRun = countAssistantMessages(session.getMessages());
+        let runSucceeded = false;
         broadcast("run_start", { text: label });
         try {
             await run();
+            runSucceeded = true;
         }
         catch (err) {
             broadcastError("error", "run failed", err);
         }
         finally {
             running = false;
+            if (runSucceeded &&
+                cancelGeneration === cancelGenAtStart &&
+                countAssistantMessages(session.getMessages()) > assistantsBeforeRun) {
+                // 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);
@@ -1092,6 +1237,60 @@ async function createSession(deps, opts) {
                 await syncKenAutoModel(pending.provider, pending.model);
         }
     }
+    // One PLAN review: like runAutopilotReview but the digest carries the
+    // submitted plan's markdown (`## Plan under review`) and the plan-review
+    // instruction — Ken judges the plan itself, not finished work. Returns null
+    // on failure; a failure caused by the user's own action racing the review
+    // (cancel or a manual Accept/Reject that bumped planGeneration) stays
+    // SILENT — no autopilot_error — because the user's decision already won.
+    async function runAutopilotPlanReview(originalRequest) {
+        const planPath = pendingPlanPath;
+        if (planPath === null)
+            return null;
+        const genAtStart = planGeneration;
+        autopilotReviewing = true;
+        broadcast("autopilot_review_start", {});
+        try {
+            const ken = await ensureKenAutoSession();
+            // Re-read the plan file (the run may have revised it in place); fall
+            // back to the content captured at exit_plan time.
+            const planContent = await fs.readFile(planPath, "utf-8").catch(() => pendingPlanContent);
+            const digest = buildKenAutopilotPlanContext({
+                cwd,
+                gitBranch,
+                messages: session.getMessages(),
+                originalRequest,
+                injectedPrompts: [...injectedAutopilotPrompts],
+                workflowCommands: await loadWorkflowCommandSpecs(),
+                planContent,
+            });
+            await ken.prompt(digest);
+            if (autopilotCancelled || planGeneration !== genAtStart)
+                return null;
+            return parseAutopilotVerdict(lastAssistantText(ken.getMessages()));
+        }
+        catch (err) {
+            // User action mid-review (manual Accept aborts the kenAuto run): drop
+            // the review silently — the user's decision supersedes Ken's.
+            if (autopilotCancelled || planGeneration !== genAtStart)
+                return null;
+            broadcastError("autopilot_error", "autopilot plan review failed", err);
+            return null;
+        }
+        finally {
+            autopilotReviewing = false;
+            // Apply any model switch that landed mid-review.
+            const pending = pendingKenAutoModel;
+            pendingKenAutoModel = null;
+            if (pending)
+                await syncKenAutoModel(pending.provider, pending.model);
+        }
+    }
+    // The prompt fed to the fresh session after a plan is accepted — the SAME
+    // string the webview sends on a manual Accept (see PlanReviewModal's accept
+    // handler in gg-app/src/App.tsx). Keep the two in lockstep so auto- and
+    // manual approval produce identical implementation turns.
+    const IMPLEMENT_PLAN_PROMPT = "The plan has been approved. Implement it now, following each step in order.";
     // Drive the review→prompt→review loop for one finished user turn. Only ever
     // called after shouldStartAutopilotCycle approves the turn (POST /prompt or
     // the stranded-queue drain) — never from the task runner, resume, /ken, or
@@ -1102,14 +1301,53 @@ async function createSession(deps, opts) {
         if (!autopilot || autopilotCancelled)
             return;
         autopilotActive = 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;
         try {
             await driveAutopilotCycle({
-                maxRounds: MAX_AUTOPILOT_ROUNDS,
+                // A plan-pending cycle needs extra rounds: approve+implement and the
+                // post-implement work review each consume one, so +2 keeps a real fix
+                // round available.
+                maxRounds: pendingPlanPath !== null ? MAX_AUTOPILOT_ROUNDS + 2 : MAX_AUTOPILOT_ROUNDS,
                 isCancelled: () => autopilotCancelled,
-                // An injected run entering plan mode halts the cycle (autopilot_human
-                // with the plan-hold reason) — Ken never prompts into a read-only
-                // plan-mode session or answers the plan modal for the user.
+                // An injected run entering plan mode WITHOUT submitting (enter_plan,
+                // no exit_plan) halts the cycle — Ken never prompts into a read-only
+                // plan-mode session. A submitted plan takes the planPending branch.
                 isPlanMode: () => session.getPlanMode(),
+                planPending: () => pendingPlanPath !== null,
+                reviewPlan: async () => {
+                    planGenAtReview = planGeneration;
+                    return runAutopilotPlanReview(originalRequest);
+                },
+                // Auto-accept: the inlined POST /plan/accept body. Returns false when
+                // the plan generation moved since the review (user acted) — the cycle
+                // exits silently and the user's action stands.
+                acceptPlan: async () => {
+                    if (pendingPlanPath === null || planGeneration !== planGenAtReview)
+                        return false;
+                    const planPath = pendingPlanPath;
+                    try {
+                        await session.newSession();
+                        injectedAutopilotPrompts = [];
+                        titleGenerated = false;
+                        await session.setApprovedPlan(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.
+                    broadcast("autopilot_plan_accepted", {});
+                    broadcast("session_reset", {});
+                    // Persisted into the NEW session so a resume shows the marker.
+                    void session.persistAutopilotMarker("plan_approved");
+                    return true;
+                },
+                runImplement: () => runAgent(IMPLEMENT_PLAN_PROMPT, () => session.prompt(IMPLEMENT_PLAN_PROMPT)),
                 // Lean context per user turn: wipe prior review history so each new
                 // turn starts cheap, while within this cycle the few review messages
                 // persist so Ken remembers what he already asked GG Coder to fix.
@@ -1123,6 +1361,10 @@ async function createSession(deps, opts) {
                 // streams normally; the shared finally never re-triggers autopilot,
                 // so this can't recurse.
                 onInjected: (body, round) => {
+                    // A revision injection supersedes the pending plan — if the run
+                    // resubmits via exit_plan, onExitPlan re-sets it (no-op for work-
+                    // branch injections, where nothing is pending).
+                    clearPendingPlan();
                     injectedAutopilotPrompts.push(body);
                     broadcast("autopilot_prompted", { round, body });
                     void session.persistAutopilotMarker("prompted", { body });
@@ -1174,6 +1416,9 @@ async function createSession(deps, opts) {
                 broadcast("queued", { count: session.getQueuedCount() });
                 if (!next.text.trim() && next.attachments.length === 0)
                     continue;
+                // A queued message draining as a fresh turn supersedes any pending
+                // plan, exactly like a direct POST /prompt turn.
+                clearPendingPlan();
                 const workflowCommand = next.attachments.length === 0 &&
                     isWorkflowCommandText(next.text, await loadWorkflowCommandSpecs());
                 const assistantsBefore = countAssistantMessages(session.getMessages());
@@ -1190,6 +1435,9 @@ async function createSession(deps, opts) {
                     enabled: autopilot,
                     cancelled: autopilotCancelled,
                     planMode: session.getPlanMode(),
+                    // A submitted plan (exit_plan fired) routes into the PLAN review
+                    // branch — the cycle reviews the plan itself instead of skipping.
+                    planPending: pendingPlanPath !== null,
                     workflowCommand,
                     assistantMessagesAdded: countAssistantMessages(session.getMessages()) - assistantsBefore,
                     // Skip the review API call outright for turns that only started a
@@ -1199,6 +1447,9 @@ async function createSession(deps, opts) {
                     mechanicalOnly: isMechanicalOnlyTurn(extractTurnToolCalls(session.getMessages(), messagesBefore)),
                 });
                 if (decision.start) {
+                    log("INFO", "app-sidecar", "autopilot cycle starting (queued turn)", {
+                        kind: decision.kind,
+                    });
                     await runAutopilotCycle(next.text);
                 }
                 else if (autopilot) {
@@ -1224,6 +1475,7 @@ async function createSession(deps, opts) {
         // Fresh session per task so one task's context never bleeds into the next.
         await session.newSession();
         injectedAutopilotPrompts = [];
+        clearPendingPlan();
         titleGenerated = false;
         broadcast("session_reset", {});
         markTaskInProgress(cwd, task.id);
@@ -1336,6 +1588,10 @@ async function createSession(deps, opts) {
             });
             return;
         }
+        if (method === "GET" && url === "/progress") {
+            json(res, 200, progress.snapshot());
+            return;
+        }
         if (method === "GET" && (url === "/events" || url.startsWith("/events?"))) {
             res.writeHead(200, {
                 "content-type": "text/event-stream",
@@ -1730,6 +1986,10 @@ async function createSession(deps, opts) {
                 // Fresh user turn: clear any cancel flag left from a prior cycle so this
                 // turn's autopilot review can run.
                 autopilotCancelled = false;
+                // A typed message while a plan modal/review is pending (reject,
+                // feedback, anything) supersedes the pending plan — the bump also
+                // invalidates any in-flight Ken plan review.
+                clearPendingPlan();
                 // Gate inputs captured around the run: whether this turn is a workflow
                 // slash command (attachment prompts skip slash expansion entirely), and
                 // how many assistant messages the run actually adds. Computed even when
@@ -1766,6 +2026,9 @@ async function createSession(deps, opts) {
                     enabled: autopilot,
                     cancelled: autopilotCancelled,
                     planMode: session.getPlanMode(),
+                    // A submitted plan (exit_plan fired) routes into the PLAN review
+                    // branch — the cycle reviews the plan itself instead of skipping.
+                    planPending: pendingPlanPath !== null,
                     workflowCommand,
                     assistantMessagesAdded: countAssistantMessages(session.getMessages()) - assistantsBefore,
                     // Skip the review API call outright for turns that only started a
@@ -1775,6 +2038,7 @@ async function createSession(deps, opts) {
                     mechanicalOnly: isMechanicalOnlyTurn(extractTurnToolCalls(session.getMessages(), messagesBefore)),
                 });
                 if (decision.start) {
+                    log("INFO", "app-sidecar", "autopilot cycle starting", { kind: decision.kind });
                     await runAutopilotCycle(text);
                 }
                 else if (autopilot) {
@@ -2146,6 +2410,7 @@ async function createSession(deps, opts) {
             return;
         }
         if (method === "POST" && url === "/cancel") {
+            cancelGeneration++;
             abort.abort();
             abort = new AbortController();
             session.setSignal(abort.signal);
@@ -2176,6 +2441,7 @@ async function createSession(deps, opts) {
                 .newSession()
                 .then(() => {
                 injectedAutopilotPrompts = [];
+                clearPendingPlan();
                 broadcast("session_reset", {});
                 json(res, 200, { ok: true });
             })
@@ -2207,6 +2473,24 @@ async function createSession(deps, opts) {
                     json(res, 409, { error: "cannot accept a plan while the agent is running" });
                     return;
                 }
+                // Manual accept, possibly racing Ken's autopilot plan review: the user
+                // always wins. Bump the plan generation (invalidates any in-flight
+                // review's verdict), stop the cycle, abort a mid-prompt review on the
+                // kenAuto session, and clear the spinner — autopilot_ignored renders
+                // nothing, so no stale "approve or reject" bubble ever lands. The
+                // webview's follow-up "implement" /prompt arrives as a fresh turn
+                // (resetting autopilotCancelled), so the implementation still gets its
+                // normal post-run review; if it lands while the cycle is winding down
+                // it queues and runStrandedQueue drains it as a fresh turn.
+                clearPendingPlan();
+                autopilotCancelled = true;
+                kenAutoAbort.abort();
+                kenAutoAbort = new AbortController();
+                kenAutoSession?.setSignal(kenAutoAbort.signal);
+                if (autopilotReviewing) {
+                    autopilotReviewing = false;
+                    broadcast("autopilot_ignored", {});
+                }
                 try {
                     await session.newSession();
                     injectedAutopilotPrompts = [];