@kenkaiiii/ggcoder 5.74.2 → 5.74.3

package/dist/app-sidecar.js

@@ -27,6 +27,7 @@ import { setStreamDiagnostic } from "@kenkaiiii/gg-agent";
 import { AgentSession } from "./core/agent-session.js";
 import { RunLifecycle } from "./core/run-lifecycle.js";
 import { RunClaim } from "./core/run-claim.js";
+import { shouldOfferPendingPlan } from "./core/plan-handoff.js";
 import { CHAT_AGENT_IDS, chatAgentSessionsDir, createChatAgent, parseChatAgentId, switchChatAgent, } from "./chat-agents/index.js";
 import { createMotionAgentSession } from "./motion-agent/motion-agent.js";
 import { buildJiwaTools, JiwaStore } from "./chat-agents/jiwa.js";
@@ -1435,6 +1436,8 @@ async function createSession(deps, opts) {
         session = new AgentSession({
             ...baseSessionOptions,
             additionalTools: [askUserTool],
+            // A run must not end mid-plan with nothing submitted: nobody could review it.
+            planSubmissionGate: true,
             // Plan mode belongs only to the coding agent.
             onEnterPlan: async (reason) => {
                 deactivateApprovedPlan();
@@ -2101,6 +2104,47 @@ async function createSession(deps, opts) {
         pendingPlanContent = "";
         planGeneration++;
     }
+    // Plan feedback (Ken's or the user's) is revised back in read-only plan
+    // mode. exit_plan leaves plan mode, so without this a "revise the plan" run
+    // had full write access and could start implementing before any approval.
+    async function reenterPlanModeForRevision() {
+        if (session.getPlanMode())
+            return;
+        deactivateApprovedPlan();
+        await session.setPlanMode(true);
+        broadcast("plan_mode", { active: true });
+        log("INFO", "app-sidecar", "plan mode re-entered for revision");
+    }
+    // Plan generation last handed to the human review box (-1: none yet).
+    let offeredPlanGeneration = -1;
+    // The plan the human review box should show right now, or null. Only once
+    // everything has settled — see shouldOfferPendingPlan.
+    function pendingPlanForHuman(offeredGeneration) {
+        const offer = shouldOfferPendingPlan({
+            planPath: pendingPlanPath,
+            generation: planGeneration,
+            offeredGeneration,
+            running,
+            starting: runClaim.active,
+            autopilotActive,
+            queued: session.getQueuedCount(),
+        });
+        return offer && pendingPlanPath !== null
+            ? { planPath: pendingPlanPath, content: pendingPlanContent }
+            : null;
+    }
+    // Open the Accept / Feedback / Reject box once nothing else will act on the
+    // submitted plan. Called at every settle point (turn end, queue drain, task
+    // run end). Without it, a plan Ken didn't approve — handed back, review
+    // failed, capped, cancelled, or skipped — sat pending with no way to act.
+    function offerPendingPlan() {
+        const plan = pendingPlanForHuman(offeredPlanGeneration);
+        if (!plan)
+            return;
+        offeredPlanGeneration = planGeneration;
+        log("INFO", "app-sidecar", "plan handed to user for review", { planPath: plan.planPath });
+        broadcast("plan_review", plan);
+    }
     // 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
@@ -2523,7 +2567,12 @@ async function createSession(deps, opts) {
     // control flow lives in driveAutopilotCycle (core/autopilot-cycle.ts) so
     // every exit path is unit-tested; this only wires the real dependencies.
     async function runAutopilotCycle(originalRequest) {
-        if (!autopilot || autopilotCancelled || session.getVerificationProblem())
+        if (!autopilot || autopilotCancelled)
+            return;
+        // Unverified work skips a work review silently. A pending plan still enters
+        // the cycle so driveAutopilotCycle says WHY Ken stepped aside
+        // (autopilot_human) before the plan is handed to the user.
+        if (pendingPlanPath === null && session.getVerificationProblem())
             return;
         const generation = runLifecycle.begin(abortOwnedWork).generation;
         pendingCancelDrain = null;
@@ -2611,7 +2660,11 @@ async function createSession(deps, opts) {
                 },
                 // Autopilot-injected run: GG Coder receives the framed prompt (no human
                 // is watching this turn) while run_start keeps the clean label.
-                runPrompt: (body) => runAgent(body, () => session.prompt(frameAutopilotInjection(body), AUTOMATION_PROVENANCE)),
+                runPrompt: (body, opts) => runAgent(body, async () => {
+                    if (opts?.planRevision)
+                        await reenterPlanModeForRevision();
+                    await session.prompt(frameAutopilotInjection(body), AUTOMATION_PROVENANCE);
+                }),
                 emit: (event) => {
                     // Persist the terminal verdict marker so a resumed session renders the
                     // same Ken bubble the live run showed instead of dropping it or
@@ -2677,8 +2730,10 @@ async function createSession(deps, opts) {
                 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.
+                // plan and clears a stale Stop, exactly like a direct POST /prompt
+                // turn — otherwise an earlier Stop silently disables Ken for this turn.
                 clearPendingPlan();
+                autopilotCancelled = false;
                 const workflowCommand = next.attachments.length === 0 &&
                     isWorkflowCommandText(next.text, await loadWorkflowCommandSpecs());
                 const assistantsBefore = countAssistantMessages(session.getMessages());
@@ -2722,6 +2777,7 @@ async function createSession(deps, opts) {
         }
         finally {
             drainingStrandedQueue = false;
+            offerPendingPlan();
         }
     }
     // ── Task runner (project task list → sessions) ──────────────
@@ -2768,6 +2824,9 @@ async function createSession(deps, opts) {
         }
         taskRunAll = false;
         broadcast("tasks_run_done", {});
+        // Task runs never start an autopilot cycle; a plan a task submitted goes
+        // straight to the user.
+        offerPendingPlan();
     }
     // ── Provider auth (login) bridge ───────────────────────────
     // OAuth login functions are interactive (open a URL, sometimes prompt for a
@@ -3003,6 +3062,9 @@ async function createSession(deps, opts) {
                     chatAgent,
                     running,
                     reviewPending: autopilotActive,
+                    // A reconnecting window (reload/reopen) re-opens the review box for
+                    // a plan still waiting on the user, regardless of earlier offers.
+                    pendingPlan: pendingPlanForHuman(-1),
                     runState: runLifecycle.state,
                     thinkingLevel: session.getThinkingLevel() ?? null,
                     supportedThinkingLevels: getSupportedThinkingLevels(st.provider, st.model),
@@ -3762,6 +3824,9 @@ async function createSession(deps, opts) {
                 const assistantsBefore = countAssistantMessages(session.getMessages());
                 const messagesBefore = session.getMessages().length;
                 await runAgent(text, async () => {
+                    // The review box's Feedback: revise read-only, like Ken's feedback.
+                    if (meta?.planRevision === true)
+                        await reenterPlanModeForRevision();
                     if (attachments.length > 0) {
                         // Persist each attachment under .gg/uploads so files are inspectable
                         // by the agent's tools, then prompt with the media as native blocks.
@@ -3816,6 +3881,8 @@ async function createSession(deps, opts) {
                 if (claimedStart) {
                     scheduledRunActive = false;
                     runClaim.release();
+                    // The claim held the plan back until the turn fully settled.
+                    offerPendingPlan();
                 }
             });
             return;
@@ -4469,7 +4536,7 @@ async function createSession(deps, opts) {
                     json(res, 400, { error: "invalid JSON body" });
                     return;
                 }
-                if (running) {
+                if (running || runClaim.active) {
                     json(res, 409, { error: "cannot accept a plan while the agent is running" });
                     return;
                 }