@kenkaiiii/ggcoder 5.16.0 → 5.18.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

@@ -18,10 +18,11 @@ import os from "node:os";
 import path from "node:path";
 import { randomUUID } from "node:crypto";
 import { parseArgs } from "node:util";
-import { formatError } from "@kenkaiiii/gg-ai";
+import { environmentSecrets, formatError, redactValue, } from "@kenkaiiii/gg-ai";
 import { runJsonMode } from "./modes/json-mode.js";
 import { runSubagentWorkerMode } from "./modes/subagent-worker-mode.js";
 import { AgentSession } from "./core/agent-session.js";
+import { RunLifecycle } from "./core/run-lifecycle.js";
 import { CHAT_AGENT_IDS, chatAgentSessionsDir, createChatAgent, parseChatAgentId, sessionsDirForChatAgent, switchChatAgent, } from "./chat-agents/index.js";
 import { buildJiwaTools, JiwaStore } from "./chat-agents/jiwa.js";
 import { buildMemoryTools, MemoryStore } from "./chat-agents/memory.js";
@@ -43,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";
@@ -929,7 +931,8 @@ async function createSession(deps, opts) {
     const clients = new Set();
     let clientSeq = 0;
     function broadcast(type, data) {
-        const frame = `data: ${JSON.stringify({ type, data })}\n\n`;
+        const safePayload = redactValue({ type, data }, { secrets: environmentSecrets(process.env) });
+        const frame = `data: ${JSON.stringify(safePayload)}\n\n`;
         for (const c of clients)
             c.res.write(frame);
     }
@@ -1033,7 +1036,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(() => { });
             },
@@ -1063,11 +1068,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 });
@@ -1079,6 +1090,7 @@ async function createSession(deps, opts) {
             contextWindow: currentContextWindow(),
             gitBranch,
             isGitRepo: gitIsRepo,
+            gitDirtyFileCount,
             tasks: session.listBackgroundProcesses(),
         };
     }
@@ -1088,8 +1100,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);
@@ -1106,6 +1203,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
@@ -1123,7 +1225,13 @@ async function createSession(deps, opts) {
     session.eventBus.on("compaction_start", (d) => broadcast("compaction_start", d));
     session.eventBus.on("compaction_end", (d) => broadcast("compaction_end", d));
     let running = false;
-    let titleGenerated = false;
+    const runLifecycle = new RunLifecycle((runState) => {
+        running = runState !== "idle";
+        if (runState === "cancelling")
+            broadcast("run_cancelling", { runState });
+    });
+    const cancelledRunEndGenerations = new Set();
+    let pendingCancelDrain = null;
     // Bumped by /cancel — a run whose cancel generation changed mid-flight was
     // canceled and earns no XP.
     let cancelGeneration = 0;
@@ -1145,6 +1253,7 @@ async function createSession(deps, opts) {
     let autopilotCancelled = false;
     // Hard cap on review→prompt→review rounds per user turn (loop safety).
     const MAX_AUTOPILOT_ROUNDS = 3;
+    const CANCEL_TIMEOUT_MS = 5_000;
     // Prompt bodies Autopilot Ken injected into the BUILD session this
     // conversation. Passed into every Ken digest so injected prompts render as
     // "Ken autopilot (injected)" instead of `**User:**` — otherwise multi-round
@@ -1337,74 +1446,114 @@ 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();
+        // Stop a run-all sweep and every async child through AgentSession's signal.
+        taskRunAll = false;
+        autopilotCancelled = true;
+        kenAutoAbort.abort();
+    }
+    function installFreshRunControllers() {
+        abort = new AbortController();
+        session.setSignal(abort.signal);
+        kenAutoAbort = new AbortController();
+        kenAutoSession?.setSignal(kenAutoAbort.signal);
     }
-    // Core run lifecycle shared by /prompt and the task runner: flips `running`,
-    // brackets the run with run_start/run_end, refreshes the footer extras, and
-    // generates the session title once. `label` is the text shown live with the
-    // run_start frame.
+    function finishOwnedGeneration(generation, emitCancelledFallback) {
+        const cancelled = runLifecycle.isCancellationRequested(generation);
+        const settlement = runLifecycle.settle(generation);
+        if (!settlement.settled)
+            return cancelled;
+        // A replacement signal is safe only after the provider-backed owner settled.
+        installFreshRunControllers();
+        if (cancelled && emitCancelledFallback && !cancelledRunEndGenerations.has(generation)) {
+            cancelledRunEndGenerations.add(generation);
+            broadcast("run_end", { cancelled: true, runState: runLifecycle.state });
+        }
+        return cancelled;
+    }
+    // Core provider-run bracket. Standalone runs own a lifecycle generation;
+    // injected autopilot runs share the cycle's outer generation.
     async function runAgent(label, run) {
-        running = true;
+        const ownsGeneration = !runLifecycle.running;
+        const generation = ownsGeneration
+            ? runLifecycle.begin(abortOwnedWork).generation
+            : runLifecycle.generation;
+        if (ownsGeneration)
+            pendingCancelDrain = null;
         // 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 });
+        broadcast("run_start", { text: label, runState: runLifecycle.state });
         try {
-            await run();
+            if (!runLifecycle.isCancellationRequested(generation))
+                await run();
             runSucceeded = true;
         }
         catch (err) {
-            broadcastError("error", "run failed", err);
+            if (!runLifecycle.isCancellationRequested(generation)) {
+                broadcastError("error", "run failed", err);
+            }
         }
         finally {
-            running = false;
+            const cancelled = runLifecycle.isCancellationRequested(generation);
             if (runSucceeded &&
+                !cancelled &&
                 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);
-            gitIsRepo = await isGitRepo(cwd).catch(() => gitIsRepo);
-            broadcast("run_end", {});
+            // 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
+            // cycle; its outer finalizer emits the one terminal cancelled run_end.
+            if (!(cancelled && !ownsGeneration)) {
+                if (cancelled)
+                    cancelledRunEndGenerations.add(generation);
+                broadcast("run_end", {
+                    ...(cancelled ? { cancelled: true } : {}),
+                    runState: runLifecycle.state,
+                });
+            }
             // Autopilot's review loop is driven explicitly from POST /prompt (see
-            // runAutopilotCycle), NOT from this shared finally — that keeps the
-            // injected GG Coder runs this cycle triggers from recursively re-entering
-            // the loop through the same bracket.
-            // The agent may have marked project tasks done during the run — prune the
-            // completed ones so they drop out of the Tasks modal automatically (users
-            // never have to delete finished tasks by hand).
+            // runAutopilotCycle), NOT from this shared finally — that keeps injected
+            // runs from recursively entering the same review loop.
             broadcast("tasks_list", { tasks: pruneDoneTasksSync(cwd) });
-            // Queue drains into the run as steering, so it's empty by run_end —
-            // sync the webview indicator.
             broadcast("queued", { count: session.getQueuedCount() });
             broadcast("extras", footerExtras());
-            // Generate a session title once, after the first run, for the title bar
-            // (best-effort, async — don't block the response).
-            if (!titleGenerated) {
-                titleGenerated = true;
-                void session.generateTitle().then((title) => {
-                    if (title)
-                        broadcast("session_title", { title });
-                });
-            }
         }
     }
     // ── Autopilot orchestration ─────────────────────────────────
@@ -1430,7 +1579,8 @@ async function createSession(deps, opts) {
             return parseAutopilotVerdict(lastAssistantText(ken.getMessages()));
         }
         catch (err) {
-            broadcastError("autopilot_error", "autopilot review failed", err);
+            if (!autopilotCancelled)
+                broadcastError("autopilot_error", "autopilot review failed", err);
             return null;
         }
         finally {
@@ -1505,6 +1655,8 @@ async function createSession(deps, opts) {
     async function runAutopilotCycle(originalRequest) {
         if (!autopilot || autopilotCancelled)
             return;
+        const generation = runLifecycle.begin(abortOwnedWork).generation;
+        pendingCancelDrain = null;
         autopilotActive = true;
         // Generation captured by the last plan review; acceptPlan re-checks it so
         // a user Accept/Reject landing mid-review always wins.
@@ -1532,22 +1684,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;
@@ -1619,6 +1771,8 @@ async function createSession(deps, opts) {
         }
         finally {
             autopilotActive = false;
+            finishOwnedGeneration(generation, true);
+            queueMicrotask(() => void runStrandedQueue());
         }
     }
     // ── Stranded-queue drain ───────────────────────────────
@@ -1703,9 +1857,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) });
@@ -1786,6 +1940,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 = [];
@@ -1795,7 +1973,7 @@ async function createSession(deps, opts) {
         });
     }
     function json(res, status, body) {
-        const payload = JSON.stringify(body);
+        const payload = JSON.stringify(redactValue(body, { secrets: environmentSecrets(process.env) }));
         res.writeHead(status, {
             "content-type": "application/json",
             "access-control-allow-origin": "*",
@@ -1811,6 +1989,7 @@ async function createSession(deps, opts) {
                 mode,
                 chatAgent,
                 running,
+                runState: runLifecycle.state,
                 ready: true,
                 thinkingLevel: session.getThinkingLevel() ?? null,
                 supportedThinkingLevels: getSupportedThinkingLevels(st.provider, st.model),
@@ -1883,6 +2062,7 @@ async function createSession(deps, opts) {
                     mode,
                     chatAgent,
                     running,
+                    runState: runLifecycle.state,
                     thinkingLevel: session.getThinkingLevel() ?? null,
                     supportedThinkingLevels: getSupportedThinkingLevels(st.provider, st.model),
                     supportsVideo: getModel(st.model)?.supportsVideo ?? false,
@@ -2378,6 +2558,13 @@ async function createSession(deps, opts) {
                     json(res, 400, { error: "empty prompt" });
                     return;
                 }
+                if (runLifecycle.running && runLifecycle.isCancellationRequested(runLifecycle.generation)) {
+                    json(res, 409, {
+                        error: runLifecycle.state === "cancelling" ? "run_cancelling" : "cancel_failed",
+                        runState: runLifecycle.state,
+                    });
+                    return;
+                }
                 if (running || autopilotActive) {
                     // Queue prompts as mid-run steering (mirrors the CLI). Also queue while
                     // an autopilot cycle is active but between injected runs (build idle,
@@ -2866,26 +3053,50 @@ async function createSession(deps, opts) {
             return;
         }
         if (method === "POST" && url === "/cancel") {
-            cancelGeneration++;
-            abort.abort();
-            abort = new AbortController();
-            session.setSignal(abort.signal);
-            running = false;
-            // Stop a run-all sweep so the next pending task isn't auto-started.
-            taskRunAll = false;
-            // Stop any in-flight autopilot cycle: flag it so the loop bails between
-            // steps, and abort a review that's mid-prompt on the kenAuto session.
-            autopilotCancelled = true;
-            kenAutoAbort.abort();
-            kenAutoAbort = new AbortController();
-            kenAutoSession?.setSignal(kenAutoAbort.signal);
-            autopilotReviewing = false;
-            // Drop any queued steering and return it so the webview can restore it to
-            // the composer.
-            const drained = session.drainQueue();
-            broadcast("run_end", { cancelled: true });
-            broadcast("queued", { count: 0 });
-            json(res, 200, { cancelled: true, drained });
+            void (async () => {
+                // Even between task runs, cancellation stops the sweep. Active provider
+                // ownership invokes the full abort hook exactly once through lifecycle.
+                taskRunAll = false;
+                autopilotCancelled = true;
+                if (!runLifecycle.running) {
+                    kenAutoAbort.abort();
+                    kenAutoAbort = new AbortController();
+                    kenAutoSession?.setSignal(kenAutoAbort.signal);
+                }
+                const generation = runLifecycle.generation;
+                if (!pendingCancelDrain || pendingCancelDrain.generation !== generation) {
+                    pendingCancelDrain = { generation, text: session.drainQueue() };
+                    broadcast("queued", { count: 0 });
+                }
+                const result = await runLifecycle.cancel(CANCEL_TIMEOUT_MS);
+                const drained = pendingCancelDrain.text;
+                if (result.status === "failed") {
+                    broadcast("cancel_failed", {
+                        error: "cancel_failed",
+                        reason: result.reason,
+                        runState: runLifecycle.state,
+                    });
+                    json(res, 504, {
+                        error: "cancel_failed",
+                        reason: result.reason,
+                        runState: runLifecycle.state,
+                        drained,
+                    });
+                    return;
+                }
+                json(res, 200, {
+                    cancelled: result.status === "cancelled",
+                    runState: runLifecycle.state,
+                    drained,
+                });
+            })().catch((error) => {
+                broadcast("cancel_failed", { error: "cancel_failed", runState: runLifecycle.state });
+                json(res, 500, {
+                    error: "cancel_failed",
+                    message: error instanceof Error ? error.message : String(error),
+                    runState: runLifecycle.state,
+                });
+            });
             return;
         }
         if (method === "POST" && url === "/new-session") {
@@ -2899,6 +3110,7 @@ async function createSession(deps, opts) {
                 if (mode === "chat") {
                     await session.persistAppMarker("agent_handoff", { chatAgent });
                 }
+                deactivateApprovedPlan();
                 injectedAutopilotPrompts = [];
                 clearPendingPlan();
                 broadcast("session_reset", {});
@@ -2951,12 +3163,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) });
@@ -3384,6 +3596,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(() => { });