feat(code): add "clear and continue from plan" option in plan mode

Adds "Yes, clear history and continue from plan" option when exiting
plan mode. Clears conversation history and re-injects the approved plan
as the first prompt. Useful when context window is filling up during
planning — lets the agent start fresh with just the plan.

Author: littlekirkycode

apps/code/src/renderer/features/sessions/service/service.ts

@@ -25,6 +25,8 @@ import {
 } from "@features/sessions/stores/sessionStore";
 import { useSettingsStore } from "@features/settings/stores/settingsStore";
 import { taskViewedApi } from "@features/sidebar/hooks/useTaskViewed";
+import { workspaceApi } from "@features/workspace/hooks/useWorkspace";
+import { POSTHOG_NOTIFICATIONS } from "@posthog/agent/acp-extensions";
 import { DEFAULT_GATEWAY_MODEL } from "@posthog/agent/gateway-models";
 import { getIsOnline } from "@renderer/stores/connectivityStore";
 import { trpcClient } from "@renderer/trpc/client";
@@ -116,6 +118,8 @@ export class SessionService {
   >();
   /** AbortController for the current in-flight preview session start */
   private previewAbort: AbortController | null = null;
+  /** Pending plan text to inject after session clear, keyed by taskRunId */
+  private pendingPlanContinuations = new Map<string, string>();
   /** Active cloud task watchers, keyed by taskId */
   private cloudTaskWatchers = new Map<
     string,
@@ -858,8 +862,35 @@ export class SessionService {
 
       taskViewedApi.markActivity(session.taskId);
 
-      // Process queued messages after turn completes - send all as one prompt
-      if (hasQueuedMessages) {
+      // Clear-and-continue from plan takes priority over queued messages
+      const pendingPlan = this.pendingPlanContinuations.get(taskRunId);
+      if (pendingPlan) {
+        this.pendingPlanContinuations.delete(taskRunId);
+        const { taskId } = session;
+        // Look up repoPath from workspace — session doesn't store it directly
+        workspaceApi
+          .get(taskId)
+          .then((workspace) => {
+            const repoPath = workspace?.worktreePath ?? workspace?.folderPath;
+            if (repoPath) {
+              return this.executeClearAndContinue(
+                taskId,
+                repoPath,
+                pendingPlan,
+              );
+            }
+            log.error("Cannot clear-and-continue: no workspace for task", {
+              taskId,
+            });
+            return undefined;
+          })
+          .catch((err) => {
+            log.error("Failed to clear and continue from plan", {
+              taskId,
+              error: err,
+            });
+          });
+      } else if (hasQueuedMessages) {
         setTimeout(() => {
           this.sendQueuedMessages(session.taskId).catch((err) => {
             log.error("Failed to send queued messages", {
@@ -914,6 +945,21 @@ export class SessionService {
         });
       }
     }
+
+    // Handle clear_and_continue — store plan text for post-turn injection
+    // extNotification may double the underscore prefix, so match both forms
+    if (
+      "method" in msg &&
+      (msg.method === POSTHOG_NOTIFICATIONS.CLEAR_AND_CONTINUE ||
+        msg.method === `_${POSTHOG_NOTIFICATIONS.CLEAR_AND_CONTINUE}`) &&
+      "params" in msg
+    ) {
+      const params = msg.params as { plan?: string };
+      if (params?.plan) {
+        this.pendingPlanContinuations.set(taskRunId, params.plan);
+        log.info("Plan continuation queued", { taskRunId });
+      }
+    }
   }
 
   private handlePermissionRequest(
@@ -1754,6 +1800,22 @@ export class SessionService {
     await this.reconnectInPlace(taskId, repoPath, null, true);
   }
 
+  /**
+   * Clear conversation history and re-inject an approved plan as the first prompt.
+   * Used by the "clear and continue from plan" flow.
+   */
+  private async executeClearAndContinue(
+    taskId: string,
+    repoPath: string,
+    plan: string,
+  ): Promise<void> {
+    await this.resetSession(taskId, repoPath);
+    await this.sendPrompt(
+      taskId,
+      `Continue implementing this approved plan:\n\n${plan}`,
+    );
+  }
+
   /**
    * Cancel the current backend agent and reconnect under the same taskRunId.
    * Does NOT remove the session from the store (avoids connect effect loop).

packages/agent/package.json

@@ -12,6 +12,10 @@
       "types": "./dist/agent.d.ts",
       "import": "./dist/agent.js"
     },
+    "./acp-extensions": {
+      "types": "./dist/acp-extensions.d.ts",
+      "import": "./dist/acp-extensions.js"
+    },
     "./gateway-models": {
       "types": "./dist/gateway-models.d.ts",
       "import": "./dist/gateway-models.js"

packages/agent/src/acp-extensions.ts

@@ -64,4 +64,7 @@ export const POSTHOG_NOTIFICATIONS = {
 
   /** Marks a boundary for log compaction */
   COMPACT_BOUNDARY: "_posthog/compact_boundary",
+
+  /** Request to clear session history and continue from an approved plan */
+  CLEAR_AND_CONTINUE: "_posthog/clear_and_continue",
 } as const;

packages/agent/src/adapters/claude/permissions/permission-handlers.ts

@@ -3,6 +3,7 @@ import type {
   RequestPermissionResponse,
 } from "@agentclientprotocol/sdk";
 import type { PermissionUpdate } from "@anthropic-ai/claude-agent-sdk";
+import { POSTHOG_NOTIFICATIONS } from "../../../acp-extensions";
 import { text } from "../../../utils/acp-content";
 import type { Logger } from "../../../utils/logger";
 import { toolInfoFromToolUse } from "../conversion/tool-use-to-acp";
@@ -190,6 +191,44 @@ async function applyPlanApproval(
     };
   }
 
+  // Clear history and continue from plan — approve, switch mode, then signal renderer
+  if (
+    response.outcome?.outcome === "selected" &&
+    response.outcome.optionId === "clearAndContinue"
+  ) {
+    const planText = extractPlanText(updatedInput);
+
+    session.permissionMode = "default";
+    await session.query.setPermissionMode("default");
+    await context.client.sessionUpdate({
+      sessionId: context.sessionId,
+      update: {
+        sessionUpdate: "current_mode_update",
+        currentModeId: "default",
+      },
+    });
+    await context.updateConfigOption("mode", "default");
+
+    // Signal the renderer to clear the session and re-inject the plan
+    if (planText) {
+      await context.client.extNotification(
+        POSTHOG_NOTIFICATIONS.CLEAR_AND_CONTINUE,
+        {
+          sessionId: context.sessionId,
+          plan: planText,
+        },
+      );
+    }
+
+    return {
+      behavior: "allow",
+      updatedInput,
+      updatedPermissions: context.suggestions ?? [
+        { type: "setMode", mode: "default", destination: "localSettings" },
+      ],
+    };
+  }
+
   const customInput = (response._meta as Record<string, unknown> | undefined)
     ?.customInput as string | undefined;
   const feedback = customInput?.trim();

packages/agent/src/adapters/claude/permissions/permission-options.ts

@@ -103,6 +103,11 @@ export function buildExitPlanModePermissionOptions(): PermissionOption[] {
       name: "Yes, and manually approve edits",
       optionId: "default",
     },
+    {
+      kind: "allow_once",
+      name: "Yes, clear history and continue from plan",
+      optionId: "clearAndContinue",
+    },
     {
       kind: "reject_once",
       name: "No, and tell the agent what to do differently",

packages/agent/tsup.config.ts

@@ -72,6 +72,7 @@ export default defineConfig([
   {
     entry: [
       "src/index.ts",
+      "src/acp-extensions.ts",
       "src/agent.ts",
       "src/gateway-models.ts",
       "src/posthog-api.ts",