@kenkaiiii/ggcoder 5.7.0 → 5.8.1

package/dist/app-sidecar.js

@@ -22,11 +22,12 @@ 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";
 import { validateKenModelPref, effectiveKenModel } from "./core/ken-model.js";
+import { normalizeAutopilotMarkersForHistory, normalizeAppMarkersForHistory, normalizeKenTurnsForHistory, restoreUserRow, restoreAssistantTexts, autopilotMarkerCopySeed, } from "./core/session-history.js";
 import { AuthStorage } from "./core/auth-storage.js";
 import { MOONSHOT_OAUTH_KEY, XIAOMI_CREDITS_KEY } from "@kenkaiiii/gg-core";
 import { loginAnthropic } from "./core/oauth/anthropic.js";
@@ -811,6 +812,16 @@ async function createSession(deps, opts) {
             ...(f.statusCode != null ? { statusCode: f.statusCode } : {}),
             ...(f.resetsAt != null ? { resetsAt: f.resetsAt } : {}),
         });
+        // Persist the error row (display-only marker) so a resumed session shows
+        // the same headline/message/guidance the live run did. Best-effort.
+        void session
+            .persistAppMarker("error", {
+            scope: type,
+            headline: f.headline,
+            ...(f.message ? { message: f.message } : {}),
+            guidance: f.guidance,
+        })
+            .catch(() => { });
     }
     // The session file path to resume (passed by the daemon's POST /session);
     // empty/unset starts a fresh session.
@@ -835,6 +846,8 @@ async function createSession(deps, opts) {
         onEnterPlan: async (reason) => {
             await session.setPlanMode(true);
             broadcast("plan_enter", { reason: reason ?? "" });
+            // Persist the plan-mode banner so a resumed session still shows it.
+            void session.persistAppMarker("plan", { reason: reason ?? "" }).catch(() => { });
         },
         onExitPlan: async (planPath) => {
             await session.setPlanMode(false);
@@ -847,6 +860,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.";
         },
@@ -940,6 +959,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
@@ -1209,6 +1250,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
@@ -1219,14 +1314,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.
@@ -1240,20 +1374,34 @@ 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 });
                 },
                 runPrompt: (body) => runAgent(body, () => session.prompt(body)),
                 emit: (event) => {
-                    broadcast(event.type, event.data);
                     // Persist the terminal verdict marker so a resumed session renders the
                     // same Ken bubble the live run showed instead of dropping it or
                     // falling back to the raw verdict text (e.g. ALL_CLEAR).
                     if (event.type === "autopilot_done") {
+                        // Broadcast the SAME copySeed the persisted marker will produce on
+                        // resume, so the live all-clear wording matches the resumed one
+                        // (computed before persist — same synchronous message count).
+                        const seed = autopilotMarkerCopySeed({
+                            version: 1,
+                            phase: "done",
+                            afterMessageCount: session.getMessages().filter((m) => m.role !== "system").length,
+                        });
+                        broadcast(event.type, { ...event.data, copySeed: seed });
                         void session.persistAutopilotMarker("done");
+                        return;
                     }
-                    else if (event.type === "autopilot_human") {
+                    broadcast(event.type, event.data);
+                    if (event.type === "autopilot_human") {
                         void session.persistAutopilotMarker("human", { reason: event.data.reason });
                     }
                     else if (event.type === "autopilot_capped") {
@@ -1291,6 +1439,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());
@@ -1307,6 +1458,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
@@ -1316,6 +1470,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) {
@@ -1341,11 +1498,14 @@ 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);
         broadcast("tasks_list", { tasks: loadTasksSync(cwd) });
         broadcast("task_start", { id: task.id, title: task.title });
+        // Persist the task header so a resumed task session shows what ran.
+        void session.persistAppMarker("task", { title: task.title }).catch(() => { });
         const shortId = task.id.slice(0, 8);
         const completionHint = `\n\n---\nWhen you have fully completed this task, call the tasks tool to mark it done:\n` +
             `tasks({ action: "done", id: "${shortId}" })`;
@@ -1636,8 +1796,11 @@ async function createSession(deps, opts) {
                 // they were recorded after, so each lands right after that message. A
                 // turn becomes two wire rows: the `@Ken` question (user) + Ken's reply
                 // (assistant), both flagged `ken` so the webview tints them.
+                // Deduped; stale anchors are clamped to the last message (Ken turns
+                // carry real conversation, so they render at the end instead of
+                // vanishing).
                 const kenByCount = new Map();
-                for (const turn of session.getKenTurns()) {
+                for (const turn of normalizeKenTurnsForHistory(session.getKenTurns(), messages.filter((m) => m.role !== "system").length)) {
                     const list = kenByCount.get(turn.afterMessageCount) ?? [];
                     list.push(turn);
                     kenByCount.set(turn.afterMessageCount, list);
@@ -1655,8 +1818,12 @@ async function createSession(deps, opts) {
                 // Autopilot verdict markers to interleave, same anchor scheme as Ken
                 // turns — each becomes a single assistant row the webview renders
                 // exactly like the live `autopilot` item (never a raw verdict string).
+                // Compact/continuation rewrites can carry old markers whose original
+                // afterMessageCount is beyond the restored message list; dropping those
+                // prevents stale all-clear bubbles from bunching at the bottom on resume.
+                const restoredMessageCount = messages.filter((m) => m.role !== "system").length;
                 const autopilotByCount = new Map();
-                for (const marker of session.getAutopilotMarkers()) {
+                for (const marker of normalizeAutopilotMarkersForHistory(session.getAutopilotMarkers(), restoredMessageCount)) {
                     const list = autopilotByCount.get(marker.afterMessageCount) ?? [];
                     list.push(marker);
                     autopilotByCount.set(marker.afterMessageCount, list);
@@ -1674,15 +1841,77 @@ async function createSession(deps, opts) {
                                 phase: marker.phase,
                                 ...(marker.reason !== undefined ? { reason: marker.reason } : {}),
                                 ...(marker.body !== undefined ? { body: marker.body } : {}),
+                                copySeed: marker.copySeed,
                             },
                         });
                     }
                 };
+                // App transcript markers (plan banner / task header / error rows /
+                // user-bubble hints), same anchor scheme. user_hint markers don't
+                // become rows — they decorate the user row at their anchor instead.
+                const appMarkersByCount = new Map();
+                const userHintByCount = new Map();
+                // Compaction-count markers pair with compacted summary rows in file
+                // order (FIFO), not by anchor — the summary user message is what
+                // positions the notice.
+                const compactionCounts = [];
+                for (const marker of normalizeAppMarkersForHistory(session.getAppMarkers(), restoredMessageCount)) {
+                    if (marker.kind === "user_hint") {
+                        userHintByCount.set(marker.afterMessageCount, marker.data);
+                        continue;
+                    }
+                    if (marker.kind === "compaction") {
+                        const d = marker.data;
+                        if (typeof d.originalCount === "number" && typeof d.newCount === "number") {
+                            compactionCounts.push({ originalCount: d.originalCount, newCount: d.newCount });
+                        }
+                        continue;
+                    }
+                    const list = appMarkersByCount.get(marker.afterMessageCount) ?? [];
+                    list.push(marker);
+                    appMarkersByCount.set(marker.afterMessageCount, list);
+                }
+                const flushAppMarkers = (count) => {
+                    const markers = appMarkersByCount.get(count);
+                    if (!markers)
+                        return;
+                    appMarkersByCount.delete(count);
+                    for (const marker of markers) {
+                        const d = marker.data;
+                        if (marker.kind === "plan") {
+                            history.push({
+                                role: "assistant",
+                                text: "",
+                                plan: { reason: typeof d.reason === "string" ? d.reason : "" },
+                            });
+                        }
+                        else if (marker.kind === "task") {
+                            history.push({
+                                role: "assistant",
+                                text: "",
+                                task: { title: typeof d.title === "string" ? d.title : "" },
+                            });
+                        }
+                        else if (marker.kind === "error" && typeof d.headline === "string") {
+                            history.push({
+                                role: "assistant",
+                                text: "",
+                                error: {
+                                    scope: typeof d.scope === "string" ? d.scope : "error",
+                                    headline: d.headline,
+                                    ...(typeof d.message === "string" ? { message: d.message } : {}),
+                                    ...(typeof d.guidance === "string" ? { guidance: d.guidance } : {}),
+                                },
+                            });
+                        }
+                    }
+                };
                 let nonSystemCount = 0;
                 // Turns/markers recorded before any build message (anchor 0) render at
                 // the top.
                 flushKen(0);
                 flushAutopilot(0);
+                flushAppMarkers(0);
                 for (const msg of messages) {
                     if (msg.role === "system")
                         continue;
@@ -1732,30 +1961,54 @@ async function createSession(deps, opts) {
                         }
                         continue;
                     }
-                    // User or assistant message — existing text/hook/command/compacted
-                    // extraction, plus sub-agent group detection for assistant tool_calls.
-                    const text = typeof msg.content === "string"
-                        ? msg.content
-                        : msg.content
-                            .map((c) => c.type === "text" && "text" in c && typeof c.text === "string" ? c.text : "")
-                            .join("");
-                    const images = typeof msg.content === "string"
-                        ? []
-                        : msg.content.flatMap((c) => c.type === "image" ? [`data:${c.mediaType};base64,${c.data}`] : []);
-                    const hook = msg.role === "user" ? detectHookKind(text) : null;
-                    const compacted = msg.role === "user" && !hook && text.startsWith("[Previous conversation summary]");
-                    const command = msg.role === "user" && !hook && !compacted
-                        ? detectPromptCommand(text, commandCandidates)
-                        : null;
-                    if (text.trim() || images.length > 0) {
-                        history.push({
-                            role: msg.role,
-                            text: command ?? text,
-                            images,
-                            hook,
-                            command: command !== null,
-                            compacted,
-                        });
+                    // User or assistant message — text/hook/command/compacted extraction,
+                    // plus sub-agent group detection for assistant tool_calls.
+                    if (msg.role === "user") {
+                        // Rebuild the live bubble: strip the steering wrapper, drop
+                        // attachment/file notes the model saw but the bubble never showed.
+                        const restored = restoreUserRow(msg.content);
+                        const text = restored.text;
+                        const hook = detectHookKind(text);
+                        const compacted = !hook && text.startsWith("[Previous conversation summary]");
+                        const command = !hook && !compacted ? detectPromptCommand(text, commandCandidates) : null;
+                        if (text.trim() || restored.images.length > 0) {
+                            const hint = userHintByCount.get(nonSystemCount);
+                            history.push({
+                                role: "user",
+                                text: command ?? text,
+                                images: restored.images,
+                                hook,
+                                command: command !== null,
+                                compacted,
+                                // Markers accumulate across continuation files (each rewrite
+                                // re-persists prior ones) but only the LATEST summary row
+                                // survives compaction — so consume from the newest end.
+                                ...(compacted && compactionCounts.length > 0
+                                    ? { compactionCounts: compactionCounts.pop() }
+                                    : {}),
+                                ...(hint?.kenSent === true ? { kenSent: true } : {}),
+                                ...(Array.isArray(hint?.enhancements) ? { enhancements: hint.enhancements } : {}),
+                            });
+                            // Live showed the video-capability warning right after the bubble.
+                            if (restored.videoWarning) {
+                                history.push({ role: "assistant", text: "", infoKind: "video_warning" });
+                            }
+                        }
+                    }
+                    else {
+                        // 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.
+                        for (const blockText of restoreAssistantTexts(msg.content)) {
+                            history.push({
+                                role: "assistant",
+                                text: blockText,
+                                images: [],
+                                hook: null,
+                                command: false,
+                                compacted: false,
+                            });
+                        }
                     }
                     // Assistant tool_call blocks: detect sub-agent delegations.
                     if (msg.role === "assistant" && typeof msg.content !== "string") {
@@ -1776,19 +2029,21 @@ async function createSession(deps, opts) {
                             });
                         }
                     }
-                    // Interleave any Ken turns / autopilot markers recorded right after
-                    // this message.
+                    // Interleave any Ken turns / autopilot / app markers recorded right
+                    // after this message.
                     flushKen(nonSystemCount);
                     flushAutopilot(nonSystemCount);
+                    flushAppMarkers(nonSystemCount);
                 }
-                // Flush remaining Ken turns / autopilot markers whose anchor is at/after
-                // the message count (e.g. recorded before any build message, or anchors
-                // beyond the current count after compaction shrank the history) so none
-                // are dropped.
+                // Flush remaining Ken turns whose anchor is at/after the message count so
+                // none are dropped. Autopilot/app markers beyond the restored message
+                // count were already filtered above; any remaining marker here is valid.
                 for (const count of [...kenByCount.keys()].sort((a, b) => a - b))
                     flushKen(count);
                 for (const count of [...autopilotByCount.keys()].sort((a, b) => a - b))
                     flushAutopilot(count);
+                for (const count of [...appMarkersByCount.keys()].sort((a, b) => a - b))
+                    flushAppMarkers(count);
                 json(res, 200, { history });
             })();
             return;
@@ -1821,10 +2076,12 @@ async function createSession(deps, opts) {
             void readBody(req).then(async (raw) => {
                 let text;
                 let attachments;
+                let meta;
                 try {
                     const body = JSON.parse(raw);
                     text = body.text ?? "";
                     attachments = Array.isArray(body.attachments) ? body.attachments : [];
+                    meta = typeof body.meta === "object" && body.meta !== null ? body.meta : undefined;
                 }
                 catch {
                     json(res, 400, { error: "invalid JSON body" });
@@ -1848,9 +2105,25 @@ async function createSession(deps, opts) {
                     return;
                 }
                 json(res, 202, { accepted: true });
+                // Webview display hint for this prompt's user bubble (kenSent shimmer
+                // label / enhancer highlight segments). Anchored +1 so it attaches to
+                // the user message the prompt below is about to push. Queued prompts
+                // skip this (their position in the run is unpredictable).
+                if (meta && (meta.kenSent === true || Array.isArray(meta.enhancements))) {
+                    void session
+                        .persistAppMarker("user_hint", {
+                        ...(meta.kenSent === true ? { kenSent: true } : {}),
+                        ...(Array.isArray(meta.enhancements) ? { enhancements: meta.enhancements } : {}),
+                    }, 1)
+                        .catch(() => { });
+                }
                 // 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
@@ -1887,6 +2160,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
@@ -1896,6 +2172,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) {
@@ -2298,6 +2575,7 @@ async function createSession(deps, opts) {
                 .newSession()
                 .then(() => {
                 injectedAutopilotPrompts = [];
+                clearPendingPlan();
                 broadcast("session_reset", {});
                 json(res, 200, { ok: true });
             })
@@ -2329,6 +2607,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 = [];