@kenkaiiii/ggcoder 5.79.3 → 5.80.0

package/dist/modes/acp-mode.js

@@ -25,18 +25,35 @@ import path from "node:path";
 import { readFileSync, statSync } from "node:fs";
 import { rm } from "node:fs/promises";
 import { isAbortError } from "@kenkaiiii/gg-agent";
-import { getAllModels, getMaxThinkingLevel, getModel } from "@kenkaiiii/gg-core";
+import { getAllModels, getAppPaths, getMaxThinkingLevel, getModel } from "@kenkaiiii/gg-core";
 import { AgentSession } from "../core/agent-session.js";
+import { createAskUserBridge, formatLateAnswer, } from "../core/ask-user.js";
+import { createAskUserTool } from "../tools/ask-user.js";
+import { deleteGoal, goalKickoffPrompt, goalNeedsKickoff, goalPhase, goalResumePrompt, goalSettingsNote, goalWasInterrupted, goalsRoot, isGoalDir, markGoalKickoff, readGoal, setGoalCritterModel, setGoalPaused, startGoalOnAnswer, updateGoal, } from "../core/goals-store.js";
+import { GOAL_RUNTIME_PROVENANCE } from "../core/goal-summary.js";
+import { createGoalsAgentSession, goalCritterPick, loadGoalBriefExtras, } from "../goals-agent/goals-agent.js";
+import { prepareAttachments } from "../app-sidecar/attachments.js";
+import { acpImageAttachments, createAcpGoal, goalWorkers, listAcpGoals } from "./acp-goals.js";
 import { PROMPT_COMMANDS } from "../core/prompt-commands.js";
 import { loadCustomCommands } from "../core/custom-commands.js";
 import { findSessionById, listAllSessions, listSessionSummaries, loadSessionCheckpointChain, } from "../session.js";
-import { getHistoryMessageVisibility, reconstructCheckpointHistory, restoreUserRow, } from "../core/session-history.js";
+import { getHistoryMessageVisibility, normalizeAutopilotMarkersForHistory, reconstructCheckpointHistory, restoreUserRow, } from "../core/session-history.js";
 import { findUserSessionPrompt } from "../core/session-preview.js";
 import { sessionGroupPaths } from "../core/session-storage.js";
 import { extractPlanSteps, findCompletedMarkers, markStepsCompleted, rebasePlanSteps, } from "../utils/plan-steps.js";
 import { formatUserError } from "../utils/error-handler.js";
 import { closeLogger } from "../core/logger.js";
 import { acpToolImages } from "./acp-images.js";
+import { buildUserPlanFeedbackPrompt, IMPLEMENT_PLAN_PROMPT, PLAN_SUBMITTED_FOR_REVIEW, shouldOfferPendingPlan, } from "../core/plan-handoff.js";
+import { readChecklistSnapshot } from "../core/checklist-snapshot.js";
+import { CHECKLIST_FILE } from "../core/checklist-items.js";
+import { loadAutopilot, saveAutopilot } from "../app-sidecar/app-settings.js";
+import { formatErrorForDisplay } from "@kenkaiiii/gg-ai";
+import { buildKenAutopilotContext, buildKenAutopilotPlanContext } from "../core/ken-context.js";
+import { parseAutopilotVerdict } from "../core/autopilot-verdict.js";
+import { countAssistantMessages, extractTurnToolCalls, isMechanicalOnlyTurn, isWorkflowCommandText, shouldStartAutopilotCycle, } from "../core/autopilot-gate.js";
+import { driveAutopilotCycle, frameAutopilotInjection, } from "../core/autopilot-cycle.js";
+import { createAcpKenReviewer } from "./acp-autopilot.js";
 /** The ACP major version this mode implements. Bumped only for breaking changes. */
 export const ACP_PROTOCOL_VERSION = 1;
 /** JSON-RPC 2.0 reserved codes. ACP adds no codes of its own. */
@@ -54,6 +71,14 @@ const RPC_INTERNAL_ERROR = -32603;
  */
 class InvalidParams extends Error {
 }
+/** Desktop MAX_AUTOPILOT_ROUNDS (app-sidecar.ts). */
+const MAX_AUTOPILOT_ROUNDS = 3;
+/** Autopilot-injected runs: hidden, as on the desktop (autopilot-runner.ts). */
+const AUTOMATION_PROVENANCE = {
+    source: "runtime",
+    kind: "automation",
+    visibility: "hidden",
+};
 // ── Tool mapping ───────────────────────────────────────────
 /**
  * ggcoder tool name → ACP `ToolKind`.
@@ -408,16 +433,57 @@ function messageText(content) {
  * the protocol needs of them.
  */
 export function historyUpdates(messages) {
-    const updates = [];
+    return historyFrames(messages, []).flatMap((f) => ("update" in f ? [f.update] : []));
+}
+/**
+ * {@link historyUpdates} with Ken's verdict markers interleaved at their
+ * `afterMessageCount` (non-system messages, as the desktop history route
+ * counts them). Marker phase `plan_approved` replays as ACP `plan_accepted`.
+ */
+export function historyFrames(messages, markers) {
+    const frames = [];
+    const updates = {
+        push: (update) => frames.push({ update }),
+    };
+    const byCount = new Map();
+    const nonSystem = messages.filter((m) => m.role !== "system").length;
+    for (const marker of normalizeAutopilotMarkersForHistory(markers, nonSystem)) {
+        const list = byCount.get(marker.afterMessageCount) ?? [];
+        list.push(marker);
+        byCount.set(marker.afterMessageCount, list);
+    }
+    const flush = (count) => {
+        for (const marker of byCount.get(count) ?? []) {
+            frames.push({
+                autopilot: {
+                    phase: marker.phase === "plan_approved" ? "plan_accepted" : marker.phase,
+                    ...(marker.reason !== undefined ? { reason: marker.reason } : {}),
+                    ...(marker.body !== undefined ? { body: marker.body } : {}),
+                    history: true,
+                },
+            });
+        }
+        byCount.delete(count);
+    };
     let replayed = 0;
+    let counted = 0;
     const nextMessageId = () => `hist-${++replayed}`;
+    flush(0);
     for (const message of messages) {
+        replayMessage(message);
+        if (message.role !== "system") {
+            counted += 1;
+            flush(counted);
+        }
+    }
+    return frames;
+    function replayMessage(message) {
         if (getHistoryMessageVisibility(message) === "hidden")
-            continue;
+            return;
         if (message.role === "user") {
             const restored = restoreUserRow(message.content, message.provenance);
             if (restored.autopilotInjected || restored.notification)
-                continue;
+                return;
             if (restored.text) {
                 updates.push({
                     sessionUpdate: "user_message_chunk",
@@ -425,7 +491,7 @@ export function historyUpdates(messages) {
                     content: { type: "text", text: restored.text },
                 });
             }
-            continue;
+            return;
         }
         if (message.role === "assistant") {
             const text = messageText(message.content);
@@ -455,7 +521,7 @@ export function historyUpdates(messages) {
                     });
                 }
             }
-            continue;
+            return;
         }
         for (const result of message.content) {
             const entry = result;
@@ -473,7 +539,6 @@ export function historyUpdates(messages) {
             });
         }
     }
-    return updates;
 }
 // ── Mode ───────────────────────────────────────────────────
 /**
@@ -529,6 +594,217 @@ export async function runAcpMode(options) {
     let turnText = "";
     /** Whether this session has already announced a title to the client. */
     let titleAnnounced = false;
+    // ── GG extensions (namespace `gg`) ──
+    const agentDir = options.agentDir ?? getAppPaths().agentDir;
+    /** The client answers `_gg/ask_user` (clientCapabilities._meta.gg.askUser). */
+    let clientAsksUser = false;
+    /** The client reviews plans (`clientCapabilities._meta.gg.planReview`). */
+    let clientPlanReview = false;
+    /** The client sent any `clientCapabilities._meta.gg` (reads `_gg/*` notifications). */
+    let clientSpeaksGg = false;
+    /** Whether the CURRENT session was built with plan review on. */
+    let sessionPlanReview = false;
+    /** Pending plan, reachable by the autopilot cycle. */
+    const pendingPlan = {
+        planPath: null,
+        content: "",
+        generation: 0,
+        offeredGeneration: -1,
+    };
+    /** Autopilot (Ken) state for the session's project; `reviewing` is set by the cycle. */
+    const autopilot = { enabled: false, reviewing: false };
+    /**
+     * The cycle in flight inside a `session/prompt`. `stop` is set by
+     * session/cancel ("cancelled") or a queued message during review ("ignored").
+     */
+    const cycle = {
+        active: false,
+        stop: null,
+    };
+    /** Ken's reviewer for the current session, built on first review. */
+    let kenReviewer = null;
+    /** The text of the user turn the cycle reviews (pinned in Ken's digest). */
+    let originalRequest = "";
+    /** Bodies Ken injected this conversation, framed (digest labelling). */
+    let injectedPrompts = [];
+    /** The active session's working directory: the goal folder for a goal session. */
+    let sessionCwd = options.cwd;
+    /** The goal the active session coordinates, kept current as it changes. */
+    let goal = null;
+    /** The queue as last reported, to tell which entries a `queue_drained` took. */
+    let knownQueue = [];
+    /** Trailing throttle for worker-driven `_gg/goal_state` (≤ 4/s). */
+    const GOAL_STATE_INTERVAL_MS = 250;
+    let goalStateTimer = null;
+    let lastGoalStateAt = 0;
+    function queueSnapshot() {
+        return session?.listQueuedMessages?.() ?? [];
+    }
+    /** `_gg/queue_update`: the current queue, plus what was drained or returned. */
+    function notifyQueue(extra) {
+        const queued = queueSnapshot();
+        knownQueue = queued;
+        write({
+            jsonrpc: "2.0",
+            method: "_gg/queue_update",
+            params: { sessionId, queued, ...extra },
+        });
+    }
+    /**
+     * Hand whatever is still queued back to the client instead of running it:
+     * on `session/cancel`, and at a turn end that never reached a steering
+     * boundary (`turnEnded`, so the client sends it as the next prompt).
+     */
+    function returnQueue(turnEnded) {
+        const left = queueSnapshot();
+        if (left.length === 0 || !session?.drainQueue)
+            return;
+        session.drainQueue();
+        notifyQueue({ returned: left, ...(turnEnded ? { turnEnded: true } : {}) });
+    }
+    function goalStatePayload() {
+        if (!goal || !session)
+            return null;
+        const { record } = goal;
+        return {
+            sessionId,
+            goalId: record.id,
+            phase: goalPhase(record),
+            paused: Boolean(record.pausedAt),
+            critterModel: goalCritterPick(record)?.model ?? null,
+            workers: goalWorkers(session.listSubAgents?.() ?? []),
+        };
+    }
+    /** `_gg/goal_state`, now: full state each time. */
+    function notifyGoalState() {
+        if (goalStateTimer) {
+            clearTimeout(goalStateTimer);
+            goalStateTimer = null;
+        }
+        const params = goalStatePayload();
+        if (!params)
+            return;
+        lastGoalStateAt = Date.now();
+        write({ jsonrpc: "2.0", method: "_gg/goal_state", params });
+    }
+    /** `_gg/goal_state` for worker churn, at most every 250ms (trailing). */
+    function notifyGoalStateSoon() {
+        if (goalStateTimer || !goal)
+            return;
+        const wait = Math.max(0, GOAL_STATE_INTERVAL_MS - (Date.now() - lastGoalStateAt));
+        goalStateTimer = setTimeout(() => {
+            goalStateTimer = null;
+            notifyGoalState();
+        }, wait);
+    }
+    /** `_meta.gg.goal` for session/new|load|resume responses on a goal session. */
+    function goalMeta(target) {
+        if (!goal)
+            return {};
+        const { record } = goal;
+        return {
+            _meta: {
+                gg: {
+                    goal: {
+                        id: record.id,
+                        phase: goalPhase(record),
+                        paused: Boolean(record.pausedAt),
+                        needsKickoff: goalNeedsKickoff(record, target.getMessages()),
+                    },
+                },
+            },
+        };
+    }
+    /**
+     * `_gg/ask_user`, on the desktop's ask bridge: the JSON-RPC id is the
+     * bridge's question id. Past the soft deadline the model is told "no answer
+     * yet" and proceeds, while the client's request stays OPEN; a late answer
+     * goes to {@link deliverLateAnswer}. A JSON-RPC error or malformed reply
+     * counts as cancel; `session/cancel`, close and disconnect cancel everything
+     * (including deferred questions, whose later replies are then ignored).
+     */
+    const asks = createAskUserBridge({
+        broadcast: (prompt) => write({
+            jsonrpc: "2.0",
+            id: prompt.id,
+            method: "_gg/ask_user",
+            params: { sessionId, questions: prompt.questions },
+        }),
+        ...(options.askUserDeadlineMs !== undefined ? { timeoutMs: options.askUserDeadlineMs } : {}),
+        onLateAnswer: (late) => void deliverLateAnswer(late),
+    });
+    /**
+     * A late answer reaches the agent the way the desktop delivers it: a goal
+     * start is recorded at once, then the "Late answer to:" text joins the queue.
+     * Mid-run it is steering (reported like any queued message). Idle, ggcoder
+     * never starts a turn itself, so it is handed back as `returned` with
+     * `turnEnded` and the client sends it as the next prompt.
+     */
+    async function deliverLateAnswer(late) {
+        const target = session;
+        await startGoalFrom({ action: "answer", answers: late.answers }, late.prompt.questions);
+        if (!target || target !== session)
+            return;
+        const text = formatLateAnswer(late);
+        if (running && target.queueMessage) {
+            target.queueMessage(text);
+            notifyQueue({});
+            return;
+        }
+        write({
+            jsonrpc: "2.0",
+            method: "_gg/queue_update",
+            params: {
+                sessionId,
+                queued: queueSnapshot(),
+                returned: [{ id: `late-${late.prompt.id}`, text }],
+                turnEnded: true,
+            },
+        });
+    }
+    function cancelPendingAsks() {
+        asks.cancelAll();
+    }
+    /** The client's answer to an outbound `_gg/ask_user`, validated. */
+    function settleAsk(id, frame) {
+        const result = frame.result;
+        if (frame.error === undefined &&
+            result?.action === "answer" &&
+            result.answers &&
+            typeof result.answers === "object" &&
+            !Array.isArray(result.answers)) {
+            const answers = {};
+            for (const [key, value] of Object.entries(result.answers)) {
+                if (typeof value === "string")
+                    answers[key] = value;
+                else if (Array.isArray(value)) {
+                    answers[key] = value.filter((v) => typeof v === "string");
+                }
+            }
+            asks.settle(id, { action: "answer", answers });
+            return;
+        }
+        asks.settle(id, { action: "cancel" });
+    }
+    /**
+     * A goal starts when the user picks "Start the goal now", exactly as the
+     * desktop sidecar does. Never throws: a failed write leaves it briefing.
+     */
+    async function startGoalFrom(result, questions) {
+        const current = goal;
+        if (!current)
+            return;
+        const started = await startGoalOnAnswer(current.dir, current.record, result, new Date(), questions).catch(() => null);
+        if (started && goal === current) {
+            goal = { dir: current.dir, record: started };
+            notifyGoalState();
+        }
+    }
+    const askUserTool = createAskUserTool(async (request) => {
+        const result = await asks.park(request);
+        await startGoalFrom(result, request.questions);
+        return result;
+    });
     function notifyUpdate(update) {
         write({
             jsonrpc: "2.0",
@@ -578,8 +854,402 @@ export async function runAcpMode(options) {
                 return;
             notifyUsage(target);
             notifySessionInfo(target);
+            notifyGoalState();
+            notifyPlanState();
+            notifyAutopilotState();
         }, 0);
     }
+    // ── GG extensions: plan review, autopilot state ──
+    function setPendingPlan(planFile, content) {
+        pendingPlan.planPath = planFile;
+        pendingPlan.content = content;
+        pendingPlan.generation++;
+    }
+    function clearPendingPlan() {
+        if (pendingPlan.planPath === null)
+            return;
+        pendingPlan.planPath = null;
+        pendingPlan.content = "";
+        pendingPlan.generation++;
+    }
+    /** `_gg/plan_state`: full state. `pending` only once offered to the human. */
+    function notifyPlanState() {
+        if (!sessionPlanReview || !session)
+            return;
+        const offered = pendingPlan.planPath !== null && pendingPlan.offeredGeneration === pendingPlan.generation;
+        write({
+            jsonrpc: "2.0",
+            method: "_gg/plan_state",
+            params: {
+                sessionId,
+                planMode: session.getPlanMode(),
+                pending: offered
+                    ? {
+                        planPath: pendingPlan.planPath,
+                        content: pendingPlan.content,
+                        generation: pendingPlan.generation,
+                    }
+                    : null,
+            },
+        });
+    }
+    /** Desktop offerPendingPlan: hand the plan over once everything settled. */
+    function offerPendingPlan() {
+        if (!sessionPlanReview || !session)
+            return;
+        const offer = shouldOfferPendingPlan({
+            planPath: pendingPlan.planPath,
+            generation: pendingPlan.generation,
+            offeredGeneration: pendingPlan.offeredGeneration,
+            running,
+            starting: false,
+            autopilotActive: autopilot.reviewing,
+            queued: session.listQueuedMessages?.().length ?? 0,
+        });
+        if (!offer)
+            return;
+        pendingPlan.offeredGeneration = pendingPlan.generation;
+        notifyPlanState();
+    }
+    /** `_gg/autopilot_state` for coding sessions of a client that speaks `_gg`. */
+    function notifyAutopilotState() {
+        if (!clientSpeaksGg || !session || goal)
+            return;
+        write({
+            jsonrpc: "2.0",
+            method: "_gg/autopilot_state",
+            params: { sessionId, enabled: autopilot.enabled, reviewing: autopilot.reviewing },
+        });
+    }
+    function setReviewing(on) {
+        if (autopilot.reviewing === on)
+            return;
+        autopilot.reviewing = on;
+        notifyAutopilotState();
+    }
+    /** `_gg/autopilot_event`, one per desktop `autopilot_*` frame. */
+    function notifyAutopilotEvent(params) {
+        write({ jsonrpc: "2.0", method: "_gg/autopilot_event", params: { sessionId, ...params } });
+    }
+    /** Desktop autopilot-runner's `persistAutopilotMarker`, same phases and moments. */
+    function persistMarker(target, phase, extra) {
+        void target.persistAutopilotMarker?.(phase, extra).catch(() => { });
+    }
+    function emitCycleFrame(event) {
+        switch (event.type) {
+            case "autopilot_done":
+                notifyAutopilotEvent({ phase: "done", ...event.data });
+                return;
+            case "autopilot_ignored":
+                notifyAutopilotEvent({ phase: "ignored" });
+                return;
+            case "autopilot_human":
+                notifyAutopilotEvent({ phase: "human", reason: event.data.reason });
+                return;
+            case "autopilot_capped":
+                notifyAutopilotEvent({ phase: "capped", round: event.data.rounds });
+                return;
+            case "autopilot_plan_accepted":
+                notifyAutopilotEvent({ phase: "plan_accepted" });
+                return;
+        }
+    }
+    async function workflowCommandSpecs() {
+        const custom = await loadCustomCommands(sessionCwd).catch(() => []);
+        return [
+            ...PROMPT_COMMANDS.map((c) => ({ name: c.name, aliases: c.aliases, prompt: c.prompt })),
+            ...custom.map((c) => ({ name: c.name, aliases: [], prompt: c.prompt })),
+        ];
+    }
+    function reviewer(target) {
+        kenReviewer ??= (options.createKenReviewer ?? defaultKenReviewer)(sessionCwd, () => {
+            const st = target.getState();
+            return { provider: st.provider, model: st.model };
+        });
+        return kenReviewer;
+    }
+    function defaultKenReviewer(cwd, buildModel) {
+        return createAcpKenReviewer({ cwd, buildModel });
+    }
+    /** One Ken review (work or plan); null on failure or when the cycle stopped. */
+    async function kenReview(target, plan) {
+        setReviewing(true);
+        notifyAutopilotEvent({ phase: "review_start" });
+        try {
+            const input = {
+                cwd: sessionCwd,
+                gitBranch: null,
+                messages: target.getMessages(),
+                verificationEvidence: target.getVerificationEvidence?.() ?? [],
+                verificationProblem: target.getVerificationProblem?.() ?? null,
+                originalRequest,
+                injectedPrompts: [...injectedPrompts],
+                workflowCommands: await workflowCommandSpecs(),
+            };
+            const digest = plan
+                ? buildKenAutopilotPlanContext({ ...input, planContent: plan.content })
+                : buildKenAutopilotContext(input);
+            const reply = await reviewer(target).review(digest);
+            if (cycle.stop || (plan && plan.generation !== pendingPlan.generation))
+                return null;
+            return parseAutopilotVerdict(reply);
+        }
+        catch (err) {
+            if (!cycle.stop)
+                notifyAutopilotEvent({ phase: "error", reason: formatErrorForDisplay(err) });
+            return null;
+        }
+        finally {
+            setReviewing(false);
+        }
+    }
+    /**
+     * AUTOPILOT HOOK — runs inside `session/prompt` after a non-cancelled build
+     * turn: desktop runAutopilotCycle over the shared driveAutopilotCycle. The
+     * prompt response waits for it; injected runs stream as normal turns.
+     * Returns the stop result the prompt answers with.
+     */
+    async function afterBuildTurn(target, result, turn) {
+        const messages = target.getMessages();
+        const gate = shouldStartAutopilotCycle({
+            enabled: autopilot.enabled && !goal,
+            cancelled: false,
+            planMode: target.getPlanMode(),
+            planPending: pendingPlan.planPath !== null,
+            workflowCommand: isWorkflowCommandText(turn.text, await workflowCommandSpecs()),
+            assistantMessagesAdded: countAssistantMessages(messages) - turn.assistantBefore,
+            mechanicalOnly: isMechanicalOnlyTurn(extractTurnToolCalls(messages, turn.messagesBefore)),
+        });
+        if (!gate.start)
+            return result;
+        originalRequest = turn.text;
+        cycle.active = true;
+        cycle.stop = null;
+        let last = result;
+        let planGenAtReview = -1;
+        const isStopped = () => cycle.stop !== null || target !== session;
+        const injectedRun = async (prompt, before) => {
+            last = await runTurn(async (t) => {
+                await before?.();
+                await t.prompt(prompt, AUTOMATION_PROVENANCE);
+            });
+            if (cancelled)
+                cycle.stop ??= "cancelled";
+        };
+        try {
+            await driveAutopilotCycle({
+                maxRounds: pendingPlan.planPath !== null ? MAX_AUTOPILOT_ROUNDS + 2 : MAX_AUTOPILOT_ROUNDS,
+                isCancelled: isStopped,
+                verificationProblem: () => target.getVerificationProblem?.() ?? null,
+                isPlanMode: () => target.getPlanMode(),
+                planPending: () => pendingPlan.planPath !== null,
+                resetReviewer: async () => {
+                    await kenReviewer?.reset();
+                },
+                review: () => kenReview(target, null),
+                reviewPlan: () => {
+                    planGenAtReview = pendingPlan.generation;
+                    return kenReview(target, {
+                        content: pendingPlan.planPath
+                            ? readPlanFile(pendingPlan.planPath) || pendingPlan.content
+                            : pendingPlan.content,
+                        generation: planGenAtReview,
+                    });
+                },
+                acceptPlan: async (reason) => {
+                    if (pendingPlan.planPath === null || pendingPlan.generation !== planGenAtReview) {
+                        return false;
+                    }
+                    notifyAutopilotEvent({ phase: "plan_accepted" });
+                    try {
+                        await acceptPendingPlan(target);
+                    }
+                    catch (err) {
+                        notifyAutopilotEvent({ phase: "error", reason: formatErrorForDisplay(err) });
+                        return false;
+                    }
+                    // Persisted into the NEW session (as the desktop does) so a reload
+                    // shows the marker.
+                    persistMarker(target, "plan_approved", { reason });
+                    injectedPrompts = [];
+                    return true;
+                },
+                runImplement: async () => {
+                    const framed = frameAutopilotInjection(IMPLEMENT_PLAN_PROMPT);
+                    injectedPrompts.push(framed);
+                    await injectedRun(framed);
+                },
+                onInjected: (body, round) => {
+                    clearPendingPlan();
+                    injectedPrompts.push(frameAutopilotInjection(body));
+                    notifyAutopilotEvent({ phase: "prompted", body, round });
+                    persistMarker(target, "prompted", { body });
+                },
+                runPrompt: (body, opts) => injectedRun(frameAutopilotInjection(body), opts?.planRevision ? () => reenterPlanModeForRevision(target) : undefined),
+                emit: (event) => {
+                    // plan_accepted is sent by acceptPlan, ahead of _gg/session_reset.
+                    if (event.type !== "autopilot_plan_accepted")
+                        emitCycleFrame(event);
+                    if (event.type === "autopilot_done")
+                        persistMarker(target, "done", event.data);
+                    else if (event.type === "autopilot_human") {
+                        persistMarker(target, "human", { reason: event.data.reason });
+                    }
+                    else if (event.type === "autopilot_capped")
+                        persistMarker(target, "capped");
+                },
+            });
+        }
+        finally {
+            const stop = cycle.stop;
+            cycle.active = false;
+            cycle.stop = null;
+            setReviewing(false);
+            // A queued message ended the cycle: hand it back as the next prompt.
+            if (stop === "ignored") {
+                notifyAutopilotEvent({ phase: "ignored" });
+                if (target === session)
+                    returnQueue(true);
+            }
+            if (stop === "cancelled")
+                last = { stopReason: "cancelled" };
+        }
+        return last;
+    }
+    /** mtime of the project's checklist file, or null when absent. */
+    function checklistStamp() {
+        try {
+            return statSync(path.join(sessionCwd, CHECKLIST_FILE)).mtimeMs;
+        }
+        catch {
+            return null;
+        }
+    }
+    /** A build turn plus the settle steps (autopilot hook, plan offer, checklist). */
+    async function runBuildTurn(text, work) {
+        const target = session;
+        const before = checklistStamp();
+        const messagesBefore = target?.getMessages() ?? [];
+        const turn = {
+            messagesBefore: messagesBefore.length,
+            assistantBefore: countAssistantMessages(messagesBefore),
+            text,
+        };
+        let result = await runTurn(work);
+        if (target && target === session) {
+            if (!cancelled)
+                result = await afterBuildTurn(target, result, turn);
+            offerPendingPlan();
+            if (checklistStamp() !== before) {
+                write({ jsonrpc: "2.0", method: "_gg/checklist_changed", params: { sessionId } });
+            }
+        }
+        return result;
+    }
+    /** `_meta.gg.planDecision` on a `session/prompt`. */
+    function planDecisionOf(params) {
+        const raw = params?._meta?.gg
+            ?.planDecision;
+        if (!raw || typeof raw !== "object")
+            return null;
+        const { action, feedback, generation } = raw;
+        if (action !== "accept" && action !== "feedback" && action !== "reject") {
+            throw new InvalidParams("planDecision.action must be accept, feedback or reject.");
+        }
+        if (typeof generation !== "number") {
+            throw new InvalidParams("planDecision.generation must be a number.");
+        }
+        return { action, feedback: typeof feedback === "string" ? feedback : "", generation };
+    }
+    /**
+     * Desktop /plan/accept: fresh context with the plan baked in, ACP sessionId
+     * kept stable, `_gg/session_reset` then the ACP `plan`. A session without
+     * `newSession` keeps its context and sends no reset.
+     */
+    async function acceptPendingPlan(target) {
+        const planFile = pendingPlan.planPath ?? undefined;
+        clearPendingPlan();
+        if (target.newSession) {
+            await target.newSession(true);
+            titleAnnounced = false;
+        }
+        await target.setApprovedPlan(planFile);
+        const steps = planFile ? extractPlanSteps(readPlanFile(planFile)) : [];
+        if (target.newSession) {
+            write({
+                jsonrpc: "2.0",
+                method: "_gg/session_reset",
+                params: { sessionId, agentSessionId: target.getState().sessionId, planTotal: steps.length },
+            });
+        }
+        notifyPlanState();
+        if (planFile)
+            adoptPlan(planFile);
+    }
+    /** Desktop reenterPlanModeForRevision. */
+    async function reenterPlanModeForRevision(target) {
+        if (target.getPlanMode())
+            return;
+        await target.setPlanMode(true);
+        notifyModeChange(MODE_PLAN);
+    }
+    async function handlePlanDecision(decision) {
+        const target = session;
+        if (!target)
+            throw new InvalidParams("No session. Call session/new first.");
+        if (pendingPlan.planPath === null || decision.generation !== pendingPlan.generation) {
+            throw new InvalidParams("That plan is no longer pending.");
+        }
+        if (decision.action === "reject") {
+            clearPendingPlan();
+            if (target.getPlanMode()) {
+                await target.setPlanMode(false);
+                notifyModeChange(MODE_DEFAULT);
+            }
+            notifyPlanState();
+            return { stopReason: "end_turn" };
+        }
+        if (decision.action === "accept") {
+            await acceptPendingPlan(target);
+            return runBuildTurn(IMPLEMENT_PLAN_PROMPT, (t) => t.prompt(IMPLEMENT_PLAN_PROMPT, {
+                source: "runtime",
+                kind: "notification",
+                visibility: "hidden",
+            }));
+        }
+        const feedback = decision.feedback.trim();
+        if (!feedback)
+            throw new InvalidParams("planDecision feedback needs text.");
+        clearPendingPlan();
+        await reenterPlanModeForRevision(target);
+        notifyPlanState();
+        notifyUpdate({
+            sessionUpdate: "user_message_chunk",
+            content: { type: "text", text: feedback },
+        });
+        return runBuildTurn(feedback, (t) => t.prompt(buildUserPlanFeedbackPrompt(feedback)));
+    }
+    async function handleAutopilotSet(params) {
+        activeSession(params, "_gg/autopilot/set");
+        const enabled = params.enabled;
+        if (typeof enabled !== "boolean")
+            throw new InvalidParams("_gg/autopilot/set needs enabled.");
+        if (goal)
+            throw new InvalidParams("Autopilot is for coding sessions.");
+        await saveAutopilot(sessionCwd, enabled);
+        if (autopilot.enabled !== enabled) {
+            autopilot.enabled = enabled;
+            notifyAutopilotState();
+        }
+        return { enabled };
+    }
+    async function handleChecklist(params) {
+        activeSession(params, "_gg/checklist");
+        const snapshot = await readChecklistSnapshot(sessionCwd, new Date());
+        if (!snapshot.ok)
+            throw new InvalidParams(snapshot.error);
+        return snapshot.value;
+    }
     /**
      * The id chunks of the current agent message share, minted on demand.
      */
@@ -689,7 +1359,7 @@ export async function runAcpMode(options) {
             // announce its own commands.
             if (session !== target || sessionId !== forSession)
                 return;
-            void availableCommands(target, options.cwd)
+            void availableCommands(target, sessionCwd)
                 .then((commands) => {
                 if (session !== target || sessionId !== forSession)
                     return;
@@ -770,7 +1440,7 @@ export async function runAcpMode(options) {
                 // A tool call ends the message it interrupted; whatever the agent says
                 // afterwards is a new one.
                 endMessage();
-                const locations = toolLocations(args, options.cwd);
+                const locations = toolLocations(args, sessionCwd);
                 // Snapshot BEFORE the tool runs. This handler is synchronous and the
                 // tool starts writing immediately after it, which is the only window
                 // where the file still holds its pre-edit contents.
@@ -838,6 +1508,22 @@ export async function runAcpMode(options) {
             bus.on("compaction_end", () => {
                 notifyUsage(target);
             }),
+            // Queued steering was folded into the run: tell the client which ones,
+            // so it can log them as user turns at this point.
+            bus.on("queue_drained", () => {
+                if (target !== session)
+                    return;
+                const current = queueSnapshot();
+                const drained = knownQueue.filter((m) => !current.some((c) => c.id === m.id));
+                if (drained.length > 0)
+                    notifyQueue({ drained });
+                else
+                    knownQueue = current;
+            }),
+            bus.on("subagent_state", () => {
+                if (target === session)
+                    notifyGoalStateSoon();
+            }),
         ];
     }
     function unwireAll() {
@@ -852,6 +1538,7 @@ export async function runAcpMode(options) {
      */
     function resetSessionState() {
         diffSnapshots.clear();
+        injectedPrompts = [];
         planPath = undefined;
         planSteps = [];
         completedSteps.clear();
@@ -859,15 +1546,30 @@ export async function runAcpMode(options) {
         titleAnnounced = false;
         currentMessageId = null;
         messageSeq = 0;
+        knownQueue = [];
+        pendingPlan.planPath = null;
+        pendingPlan.content = "";
+        pendingPlan.generation++;
+        pendingPlan.offeredGeneration = -1;
+        if (goalStateTimer)
+            clearTimeout(goalStateTimer);
+        goalStateTimer = null;
     }
     async function disposeSession() {
         if (!session)
             return;
+        // Questions belong to the session that asked them.
+        asks.cancelAll();
         unwireAll();
         resetSessionState();
+        cycle.stop ??= cycle.active ? "cancelled" : null;
+        const ken = kenReviewer;
+        kenReviewer = null;
+        await ken?.dispose().catch(() => undefined);
         const previous = session;
         session = null;
         sessionId = "";
+        goal = null;
         await previous.dispose();
     }
     /**
@@ -885,8 +1587,17 @@ export async function runAcpMode(options) {
         onEnterPlan: async () => {
             await session?.setPlanMode(true);
             notifyModeChange(MODE_PLAN);
+            notifyPlanState();
         },
         onExitPlan: async (approvedPath) => {
+            if (sessionPlanReview) {
+                // Desktop onExitPlan: park the plan; it is offered once the run settles.
+                await session?.setPlanMode(false);
+                notifyModeChange(MODE_DEFAULT);
+                setPendingPlan(approvedPath, readPlanFile(approvedPath));
+                notifyPlanState();
+                return PLAN_SUBMITTED_FOR_REVIEW;
+            }
             await session?.setPlanMode(false);
             await session?.setApprovedPlan(approvedPath);
             notifyModeChange(MODE_DEFAULT);
@@ -900,36 +1611,67 @@ export async function runAcpMode(options) {
         },
     };
     const createSession = options.createSession ??
-        ((signal, hooks) => new AgentSession({
-            provider: options.provider,
-            model: options.model,
-            cwd: options.cwd,
-            baseUrl: options.baseUrl,
-            systemPrompt: options.systemPrompt,
-            thinkingLevel: options.thinkingLevel,
-            // MCP connect (spawning stdio servers, HTTP handshakes) takes seconds
-            // and would otherwise sit on the critical path of session/new and
-            // session/load. The desktop sidecar already ships this path: the tool
-            // catalog is seeded from the disk cache so tools are visible
-            // immediately, and live connections promote in the background. A phone
-            // client gets its session in milliseconds and the same tools a moment
-            // later.
-            backgroundMcpConnect: true,
-            onEnterPlan: hooks.onEnterPlan,
-            onExitPlan: hooks.onExitPlan,
-            signal,
-        }));
+        ((signal, hooks, context) => {
+            const additionalTools = context.askUserTool ? [context.askUserTool] : [];
+            if (context.goal) {
+                // A goal folder's session is GG Goals, the coordinator, as on the desktop.
+                return createGoalsAgentSession({
+                    provider: options.provider,
+                    model: options.model,
+                    cwd: context.cwd,
+                    baseUrl: options.baseUrl,
+                    thinkingLevel: options.thinkingLevel,
+                    backgroundMcpConnect: true,
+                    signal,
+                    goal: context.goal,
+                    extras: context.goalExtras,
+                    isActive: context.isGoalActive,
+                    getChildModel: context.getChildModel,
+                    additionalTools,
+                });
+            }
+            return new AgentSession({
+                provider: options.provider,
+                model: options.model,
+                cwd: context.cwd,
+                baseUrl: options.baseUrl,
+                systemPrompt: options.systemPrompt,
+                thinkingLevel: options.thinkingLevel,
+                // MCP connect (spawning stdio servers, HTTP handshakes) takes seconds
+                // and would otherwise sit on the critical path of session/new and
+                // session/load. The desktop sidecar already ships this path: the tool
+                // catalog is seeded from the disk cache so tools are visible
+                // immediately, and live connections promote in the background. A phone
+                // client gets its session in milliseconds and the same tools a moment
+                // later.
+                backgroundMcpConnect: true,
+                onEnterPlan: hooks.onEnterPlan,
+                onExitPlan: hooks.onExitPlan,
+                ...(context.planReview ? { planSubmissionGate: true } : {}),
+                ...(additionalTools.length > 0 ? { additionalTools } : {}),
+                signal,
+            });
+        });
     // ── Method handlers ──────────────────────────────────────
-    function handleInitialize() {
+    function handleInitialize(params) {
+        const gg = params?.clientCapabilities?._meta?.gg;
+        clientAsksUser = gg?.askUser === true;
+        clientPlanReview = gg?.planReview === true;
+        clientSpeaksGg = gg !== undefined && gg !== null;
         return {
             protocolVersion: ACP_PROTOCOL_VERSION,
             agentCapabilities: {
                 loadSession: true,
-                promptCapabilities: { image: false, audio: false, embeddedContext: false },
+                promptCapabilities: { image: true, audio: false, embeddedContext: false },
                 mcpCapabilities: { http: false, sse: false, acp: false },
                 // `{}` is how ACP says "supported" for a capability with no options of
                 // its own. Omitting the key means unsupported, so this is not cosmetic.
                 sessionCapabilities: { list: {}, resume: {}, close: {}, delete: {} },
+                // GG's own extensions (custom `_gg/*` methods). Clients that don't
+                // read this see standard ACP only.
+                _meta: {
+                    gg: { queue: 1, askUser: 1, goals: 1, planReview: 1, autopilot: 1, checklist: 1 },
+                },
             },
             authMethods: [],
             agentInfo: { name: "ggcoder", title: "GG Coder", version: options.version },
@@ -941,25 +1683,59 @@ export async function runAcpMode(options) {
      * `session/new` and `session/load` differ only in whether history is
      * restored first, so they share this path rather than drifting apart.
      */
-    async function startSession(restorePath) {
+    async function startSession(restorePath, requestedCwd) {
         // Replacing an in-flight session would strand the prompt that is running
         // on it, so the old one is stopped first, deliberately and visibly.
         await disposeSession();
+        // A session whose cwd is a goal folder is that goal's coordinator.
+        // Everything else keeps the directory the agent was started in.
+        const record = isGoalDir(goalsRoot(agentDir), requestedCwd)
+            ? await readGoal(requestedCwd)
+            : null;
+        goal = record ? { dir: requestedCwd, record } : null;
+        sessionCwd = goal ? goal.dir : options.cwd;
+        const goalExtras = goal ? await loadGoalBriefExtras(goal) : undefined;
         abort = new AbortController();
-        const created = createSession(abort.signal, planHooks);
+        // Plan review is for coding sessions only; GG Goals has no plan mode.
+        sessionPlanReview = clientPlanReview && !goal;
+        autopilot.enabled = goal ? false : await loadAutopilot(sessionCwd).catch(() => false);
+        autopilot.reviewing = false;
+        const created = createSession(abort.signal, planHooks, {
+            ...(sessionPlanReview ? { planReview: true } : {}),
+            cwd: sessionCwd,
+            goal,
+            ...(goalExtras ? { goalExtras } : {}),
+            isGoalActive: () => Boolean(goal?.record.startedAt),
+            getChildModel: () => goalCritterPick(goal?.record),
+            ...(clientAsksUser ? { askUserTool } : {}),
+        });
         await created.initialize();
         if (restorePath)
             await created.loadSession(restorePath);
+        // A goal's attached folders join its workspace so the coordinator can read
+        // them. A resumed session may already carry them.
+        if (goal && created.addDirectory) {
+            for (const item of goal.record.context) {
+                if (item.kind !== "folder")
+                    continue;
+                await created.addDirectory(item.path).catch(() => undefined);
+            }
+        }
         session = created;
         sessionId = created.getState().sessionId;
         wire(created);
         return created;
     }
-    async function handleNewSession() {
-        const created = await startSession();
+    async function handleNewSession(params) {
+        const created = await startSession(undefined, requestCwd(params));
         notifyAvailableCommands(created);
         announceSessionSoon(created);
-        return { sessionId, configOptions: configOptionsFor(created), modes: sessionModes(created) };
+        return {
+            sessionId,
+            configOptions: configOptionsFor(created),
+            modes: sessionModes(created),
+            ...goalMeta(created),
+        };
     }
     /** The directory a request is about, defaulting to the one we were started in. */
     function requestCwd(params) {
@@ -1016,7 +1792,7 @@ export async function runAcpMode(options) {
         const sessionPath = await findSessionById(requested, requestCwd(params));
         if (!sessionPath)
             throw new InvalidParams(`Unknown session '${requested}'.`);
-        const restored = await startSession(sessionPath);
+        const restored = await startSession(sessionPath, requestCwd(params));
         // Display history is reconstructed separately. The live AgentSession above
         // deliberately keeps only the canonical newest checkpoint as model context.
         const checkpoints = await loadSessionCheckpointChain(sessionPath);
@@ -1025,11 +1801,26 @@ export async function runAcpMode(options) {
         // adopt a different internal one, and answering with that would leave the
         // client addressing a session it never heard of.
         sessionId = requested;
-        for (const update of historyUpdates(displayMessages))
-            notifyUpdate(update);
+        // Ken's verdict markers ride between the replayed frames as
+        // `_gg/autopilot_event` with `history: true`, only for `_gg` clients.
+        const markers = clientSpeaksGg ? (restored.getAutopilotMarkers?.() ?? []) : [];
+        for (const frame of historyFrames(displayMessages, markers)) {
+            if ("update" in frame)
+                notifyUpdate(frame.update);
+            else
+                write({
+                    jsonrpc: "2.0",
+                    method: "_gg/autopilot_event",
+                    params: { sessionId, ...frame.autopilot },
+                });
+        }
         notifyAvailableCommands(restored);
         announceSessionSoon(restored);
-        return { configOptions: configOptionsFor(restored), modes: sessionModes(restored) };
+        return {
+            configOptions: configOptionsFor(restored),
+            modes: sessionModes(restored),
+            ...goalMeta(restored),
+        };
     }
     /**
      * Abort the running turn and WAIT for it to unwind.
@@ -1065,12 +1856,16 @@ export async function runAcpMode(options) {
         const sessionPath = await findSessionById(requested, requestCwd(params));
         if (!sessionPath)
             throw new InvalidParams(`Unknown session '${requested}'.`);
-        const restored = await startSession(sessionPath);
+        const restored = await startSession(sessionPath, requestCwd(params));
         // As in session/load: the client keeps addressing the id it asked for.
         sessionId = requested;
         notifyAvailableCommands(restored);
         announceSessionSoon(restored);
-        return { configOptions: configOptionsFor(restored), modes: sessionModes(restored) };
+        return {
+            configOptions: configOptionsFor(restored),
+            modes: sessionModes(restored),
+            ...goalMeta(restored),
+        };
     }
     /**
      * Close the active session, cancelling whatever it is doing.
@@ -1199,20 +1994,27 @@ export async function runAcpMode(options) {
             .join("\n")
             .trim();
     }
-    async function handlePrompt(params) {
-        if (!session)
+    /** `_meta.gg.goalTurn` on a `session/prompt`: GG Goals' kickoff or resume. */
+    function goalTurnOf(params) {
+        const turn = params?._meta?.gg
+            ?.goalTurn;
+        return turn === "kickoff" || turn === "resume" ? turn : undefined;
+    }
+    /**
+     * Run one turn with the ACP lifecycle around it: one at a time, cancel
+     * resolves as `cancelled`, leftover queued steering is handed back.
+     */
+    async function runTurn(work) {
+        const target = session;
+        if (!target)
             throw new InvalidParams("No session. Call session/new first.");
-        if (running)
-            throw new InvalidParams("A prompt is already running in this session.");
-        const text = promptText(params);
-        if (!text)
-            throw new InvalidParams("prompt must contain at least one non-empty text block.");
         running = true;
         cancelled = false;
         truncation = undefined;
         hitMaxTurns = false;
+        knownQueue = [];
         try {
-            await session.prompt(text);
+            await work(target);
         }
         catch (err) {
             // A cancel aborts the loop, which surfaces here. The spec requires the
@@ -1231,13 +2033,90 @@ export async function runAcpMode(options) {
             // Cleared here rather than on `turn_end`, which fires before that turn's
             // tools execute and would discard snapshots still in use.
             diffSnapshots.clear();
+            // Steering that never reached a boundary goes back to the client as the
+            // next prompt; ggcoder never starts a turn by itself.
+            if (!cancelled && target === session)
+                returnQueue(true);
         }
         return { stopReason: cancelled ? "cancelled" : stopReasonFor(truncation, hitMaxTurns) };
     }
+    async function handlePrompt(params) {
+        if (!session)
+            throw new InvalidParams("No session. Call session/new first.");
+        if (running || cycle.active) {
+            throw new InvalidParams("A prompt is already running in this session.");
+        }
+        const goalTurn = goalTurnOf(params);
+        if (goalTurn)
+            return runGoalTurn(goalTurn);
+        const decision = planDecisionOf(params);
+        if (decision)
+            return handlePlanDecision(decision);
+        const text = promptText(params);
+        const images = acpImageAttachments(params?.prompt);
+        if (!text && images.length === 0) {
+            throw new InvalidParams("prompt must contain at least one non-empty text block.");
+        }
+        return runBuildTurn(text, async (target) => {
+            if (images.length > 0 && target.promptWithAttachments) {
+                // Same path as the desktop: saved under .gg/uploads, sent as native blocks.
+                const prepared = await prepareAttachments(sessionCwd, images);
+                await target.promptWithAttachments(text, prepared);
+                return;
+            }
+            if (!text)
+                return;
+            await target.prompt(text);
+        });
+    }
+    /**
+     * GG Goals' kickoff / resume as an ordinary turn, with the hidden runtime
+     * provenance the desktop uses. Nothing to do answers `end_turn` at once.
+     */
+    async function runGoalTurn(kind) {
+        const current = goal;
+        if (!current || !session)
+            return { stopReason: "end_turn" };
+        if (kind === "kickoff" && !goalNeedsKickoff(current.record, session.getMessages())) {
+            return { stopReason: "end_turn" };
+        }
+        return runTurn(async (target) => {
+            if (kind === "kickoff") {
+                const updated = await markGoalKickoff(current.dir, new Date());
+                if (!updated)
+                    return;
+                if (goal === current)
+                    goal = { dir: current.dir, record: updated };
+                await target.prompt(goalKickoffPrompt(updated), GOAL_RUNTIME_PROVENANCE);
+                return;
+            }
+            const wasPaused = Boolean(current.record.pausedAt);
+            const record = wasPaused
+                ? ((await setGoalPaused(current.dir, false, new Date())) ?? current.record)
+                : current.record;
+            if (goal === current)
+                goal = { dir: current.dir, record };
+            if (wasPaused)
+                notifyGoalState();
+            const cutOff = wasPaused ||
+                goalWasInterrupted(record, target.getMessages(), target.listSubAgents?.() ?? []);
+            if (!cutOff)
+                return;
+            await target.prompt(goalResumePrompt(record), GOAL_RUNTIME_PROVENANCE);
+        });
+    }
     function handleCancel() {
+        // A question parked on the user is not released by the signal.
+        cancelPendingAsks();
+        if (cycle.active) {
+            cycle.stop = "cancelled";
+            kenReviewer?.abort();
+        }
         if (!running || !session)
             return;
         cancelled = true;
+        // Whatever was still queued is handed back, not run.
+        returnQueue(false);
         abort.abort();
         // `AgentSession` keeps the construction signal for future turns. Re-arm it
         // immediately after aborting this turn, or every later prompt sees an
@@ -1245,12 +2124,136 @@ export async function runAcpMode(options) {
         abort = new AbortController();
         session.setSignal(abort.signal);
     }
+    // ── GG extensions: queue ──
+    /** The active session a `_gg/*` request names, validated. */
+    function activeSession(params, method) {
+        const requested = requestedSessionId(params, method);
+        if (!session || requested !== sessionId) {
+            throw new InvalidParams(`Session '${requested}' is not active.`);
+        }
+        return session;
+    }
+    function handleQueue(params) {
+        const target = activeSession(params, "_gg/queue");
+        const text = params.text;
+        if (typeof text !== "string" || !text.trim()) {
+            throw new InvalidParams("_gg/queue requires non-empty text.");
+        }
+        if (cycle.active && !running && target.queueMessage && target.listQueuedMessages) {
+            // Desktop: a user message during Ken's review ends the cycle (ignored)
+            // and runs next; here it is handed back with turnEnded when the cycle ends.
+            cycle.stop ??= "ignored";
+            kenReviewer?.abort();
+        }
+        else if (!running || !target.queueMessage || !target.listQueuedMessages) {
+            throw new InvalidParams("No prompt is running. Send session/prompt instead.");
+        }
+        target.queueMessage(text);
+        const queued = target.listQueuedMessages();
+        knownQueue = queued;
+        return { id: queued.at(-1)?.id ?? "", queued };
+    }
+    function handleQueueCancel(params) {
+        const target = activeSession(params, "_gg/queue/cancel");
+        const id = params.id;
+        if (typeof id !== "string" || !id)
+            throw new InvalidParams("_gg/queue/cancel requires an id.");
+        // false is the normal race (it already drained), not an error.
+        const cancelled = target.cancelQueuedMessage?.(id) ?? false;
+        const queued = queueSnapshot();
+        knownQueue = queued;
+        return { cancelled, queued };
+    }
+    // ── GG extensions: goals ──
+    async function handleGoalsCreate(params) {
+        const created = await createAcpGoal(agentDir, params);
+        if (!created.ok)
+            throw new InvalidParams(created.error);
+        return { goal: created.value };
+    }
+    async function handleGoalsDelete(params) {
+        const id = params?.id;
+        if (typeof id !== "string" || !id)
+            throw new InvalidParams("Missing goal id");
+        const ownsIt = goal?.record.id === id;
+        if (ownsIt && running)
+            throw new InvalidParams("This goal is still working. Stop it first.");
+        const deleted = await deleteGoal(goalsRoot(agentDir), path.join(agentDir, "sessions"), id);
+        if (!deleted.ok)
+            throw new InvalidParams(deleted.error);
+        if (ownsIt)
+            goal = null;
+        return { ok: true };
+    }
+    /** The goal the named session coordinates. */
+    function activeGoal(params, method) {
+        const target = activeSession(params, method);
+        if (!goal)
+            throw new InvalidParams("This session is not a goal.");
+        return { target, current: goal };
+    }
+    async function handleGoalPause(params) {
+        const { current } = activeGoal(params, "_gg/goal/pause");
+        const updated = await setGoalPaused(current.dir, true, new Date());
+        if (!updated)
+            throw new InvalidParams("Unknown goal");
+        if (goal === current)
+            goal = { dir: current.dir, record: updated };
+        // Stops the run; its workers stop through the same signal.
+        handleCancel();
+        notifyGoalState();
+        return { paused: true };
+    }
+    async function handleGoalUpdate(params) {
+        const { target, current } = activeGoal(params, "_gg/goal/update");
+        if (running)
+            throw new InvalidParams("This goal is still working. Pause it first.");
+        const { context, instructions } = params;
+        const updated = await updateGoal(current.dir, {
+            ...(Array.isArray(context)
+                ? { context: context.filter((p) => typeof p === "string") }
+                : {}),
+            ...(typeof instructions === "string" ? { instructions } : {}),
+        });
+        if (!updated.ok)
+            throw new InvalidParams(updated.error);
+        if (goal === current)
+            goal = { dir: current.dir, record: updated.value };
+        // GG Goals' brief is fixed for the session (prompt cache): it hears the new
+        // settings at its next turn, and they're in the brief from the next session.
+        target.notify?.("goal-settings", goalSettingsNote(updated.value));
+        for (const item of updated.value.context) {
+            if (item.kind !== "folder")
+                continue;
+            await target.addDirectory?.(item.path).catch(() => undefined);
+        }
+        return { context: updated.value.context, instructions: updated.value.instructions ?? "" };
+    }
+    async function handleGoalCritterModel(params) {
+        const { current } = activeGoal(params, "_gg/goal/critter_model");
+        const raw = params.model;
+        const requested = typeof raw === "string" && raw.trim() ? raw.trim() : null;
+        let pick = null;
+        if (requested !== null) {
+            const target = getModel(requested);
+            if (!target)
+                throw new InvalidParams(`unknown model: ${requested}`);
+            pick = { provider: target.provider, model: target.id };
+        }
+        const updated = await setGoalCritterModel(current.dir, pick);
+        if (!updated)
+            throw new InvalidParams("Unknown goal");
+        if (goal === current)
+            goal = { dir: current.dir, record: updated };
+        notifyGoalState();
+        return { critterModel: goalCritterPick(updated)?.model ?? null };
+    }
     async function dispatch(method, params) {
         switch (method) {
             case "initialize":
-                return handleInitialize();
+                return handleInitialize(params);
             case "session/new":
-                return handleNewSession();
+                return handleNewSession(params);
             case "session/prompt":
                 return handlePrompt(params);
             case "session/list":
@@ -1267,6 +2270,26 @@ export async function runAcpMode(options) {
                 return handleSetConfigOption(params);
             case "session/set_mode":
                 return handleSetMode(params);
+            case "_gg/queue":
+                return handleQueue(params);
+            case "_gg/queue/cancel":
+                return handleQueueCancel(params);
+            case "_gg/goals/list":
+                return { goals: await listAcpGoals(agentDir) };
+            case "_gg/goals/create":
+                return handleGoalsCreate(params);
+            case "_gg/goals/delete":
+                return handleGoalsDelete(params);
+            case "_gg/goal/pause":
+                return handleGoalPause(params);
+            case "_gg/goal/update":
+                return handleGoalUpdate(params);
+            case "_gg/goal/critter_model":
+                return handleGoalCritterModel(params);
+            case "_gg/autopilot/set":
+                return handleAutopilotSet(params);
+            case "_gg/checklist":
+                return handleChecklist(params);
             default:
                 return undefined;
         }
@@ -1321,6 +2344,11 @@ export async function runAcpMode(options) {
             }
             const { id, method } = frame;
             if (typeof method !== "string") {
+                // A response to one of our own requests (`_gg/ask_user`).
+                if (typeof id === "string" && asks.openIds().includes(id)) {
+                    settleAsk(id, frame);
+                    continue;
+                }
                 if (id !== undefined)
                     fail(id, RPC_INVALID_REQUEST, "Missing 'method'");
                 continue;
@@ -1337,6 +2365,8 @@ export async function runAcpMode(options) {
     }
     finally {
         rl.close();
+        // Nobody is left to answer a question: it counts as cancel.
+        cancelPendingAsks();
         // The client is gone, so a turn still running has nowhere to report to.
         // Cancelling first is what stops the wait below from being unbounded.
         handleCancel();