diff --git a/.gitignore b/.gitignore
index d9643715..95112315 100644
--- a/.gitignore
+++ b/.gitignore
@@ -38,4 +38,10 @@ AGENTS.md
 .envrc
 
 # Session store used for example-client.ts
-.session-store.json
\ No newline at end of file
+.session-store.json
+
+# PostHog task artifacts (generated per-task)
+.posthog/
+
+# Test media files
+sounds/
\ No newline at end of file
diff --git a/apps/array/src/main/services/session-manager.ts b/apps/array/src/main/services/session-manager.ts
index 9756c46f..3ade69fe 100644
--- a/apps/array/src/main/services/session-manager.ts
+++ b/apps/array/src/main/services/session-manager.ts
@@ -276,7 +276,7 @@ export class SessionManager {
         await connection.newSession({
           cwd: repoPath,
           mcpServers,
-          _meta: { sessionId: taskRunId },
+          _meta: { sessionId: taskRunId, taskId },
         });
       }
 
diff --git a/apps/array/src/renderer/features/editor/components/PlanEditor.tsx b/apps/array/src/renderer/features/editor/components/PlanEditor.tsx
index 55bb21bf..03c1e3a2 100644
--- a/apps/array/src/renderer/features/editor/components/PlanEditor.tsx
+++ b/apps/array/src/renderer/features/editor/components/PlanEditor.tsx
@@ -1,14 +1,48 @@
-import { RichTextEditor } from "@features/editor/components/RichTextEditor";
 import { usePanelLayoutStore } from "@features/panels/store/panelLayoutStore";
 import { FloppyDiskIcon } from "@phosphor-icons/react";
 import { Box, Button, TextArea } from "@radix-ui/themes";
 import { logger } from "@renderer/lib/logger";
 import { useQuery, useQueryClient } from "@tanstack/react-query";
-import { useCallback, useEffect, useState } from "react";
+import { useCallback, useEffect, useRef, useState } from "react";
 import { useHotkeys } from "react-hotkeys-hook";
 
 const log = logger.scope("plan-editor");
 
+// Hook to watch for external file changes
+function usePlanFileWatcher(
+  repoPath: string | undefined,
+  taskId: string,
+  fileName: string,
+  onFileChanged: () => void,
+) {
+  const onFileChangedRef = useRef(onFileChanged);
+  onFileChangedRef.current = onFileChanged;
+
+  useEffect(() => {
+    if (!repoPath || !window.electronAPI?.onFileChanged) return;
+
+    // Build the expected path for the plan file
+    const expectedPath = `${repoPath}/.posthog/${taskId}/${fileName}`;
+
+    log.debug("Watching for changes to:", expectedPath);
+
+    const unsubscribe = window.electronAPI.onFileChanged(
+      ({ repoPath: eventRepoPath, filePath }) => {
+        // Only process events for our repo
+        if (eventRepoPath !== repoPath) return;
+
+        // Check if the changed file is our plan file
+        if (filePath === expectedPath) {
+          log.debug("Plan file changed externally:", filePath);
+          onFileChangedRef.current();
+        }
+      },
+    );
+
+    return unsubscribe;
+  }, [repoPath, taskId, fileName]);
+}
+
 interface PlanEditorProps {
   taskId: string;
   repoPath: string;
@@ -29,12 +63,12 @@ export function PlanEditor({
   const [content, setContent] = useState(initialContent || "");
   const [isSaving, setIsSaving] = useState(false);
   const [hasUnsavedChanges, setHasUnsavedChanges] = useState(false);
+  const [hasInitialized, setHasInitialized] = useState(!!initialContent);
+  const savedContentRef = useRef<string>(initialContent || "");
   const updateTabMetadata = usePanelLayoutStore(
     (state) => state.updateTabMetadata,
   );
 
-  const isMarkdownFile = fileName.endsWith(".md");
-
   const queryClient = useQueryClient();
   const { data: fetchedContent } = useQuery({
     queryKey: ["task-file", repoPath, taskId, fileName],
@@ -56,11 +90,49 @@ export function PlanEditor({
     },
   });
 
+  // Initialize content from fetched data only once
   useEffect(() => {
-    if (!initialContent && fetchedContent && content === "") {
+    if (!hasInitialized && fetchedContent !== undefined) {
       setContent(fetchedContent);
+      savedContentRef.current = fetchedContent;
+      setHasInitialized(true);
     }
-  }, [fetchedContent, initialContent, content]);
+  }, [fetchedContent, hasInitialized]);
+
+  // Handle external file changes
+  const handleExternalFileChange = useCallback(async () => {
+    // Refetch the file content
+    try {
+      let newContent: string | null = null;
+      if (fileName === "plan.md") {
+        newContent = await window.electronAPI?.readPlanFile(repoPath, taskId);
+      } else {
+        newContent = await window.electronAPI?.readTaskArtifact(
+          repoPath,
+          taskId,
+          fileName,
+        );
+      }
+
+      if (newContent !== null && newContent !== savedContentRef.current) {
+        // Only update if the file content actually changed from what we last saved/loaded
+        setContent(newContent);
+        savedContentRef.current = newContent;
+        // Also reset unsaved changes since we just loaded fresh content
+        setHasUnsavedChanges(false);
+        queryClient.setQueryData(
+          ["task-file", repoPath, taskId, fileName],
+          newContent,
+        );
+        log.debug("Reloaded plan content from external change");
+      }
+    } catch (error) {
+      log.error("Failed to reload file after external change:", error);
+    }
+  }, [repoPath, taskId, fileName, queryClient]);
+
+  // Watch for external file changes
+  usePlanFileWatcher(repoPath, taskId, fileName, handleExternalFileChange);
 
   const handleSave = useCallback(
     async (contentToSave: string) => {
@@ -80,6 +152,7 @@ export function PlanEditor({
           ["task-file", repoPath, taskId, fileName],
           contentToSave,
         );
+        savedContentRef.current = contentToSave;
         setHasUnsavedChanges(false);
       } catch (error) {
         log.error("Failed to save file:", error);
@@ -94,10 +167,10 @@ export function PlanEditor({
     handleSave(content);
   }, [content, handleSave]);
 
-  // Track unsaved changes
+  // Track unsaved changes by comparing to last saved content
   useEffect(() => {
-    setHasUnsavedChanges(content !== fetchedContent);
-  }, [content, fetchedContent]);
+    setHasUnsavedChanges(content !== savedContentRef.current);
+  }, [content]);
 
   // Update tab metadata when unsaved changes state changes
   useEffect(() => {
@@ -115,7 +188,7 @@ export function PlanEditor({
         handleManualSave();
       }
     },
-    { enableOnFormTags: ["INPUT", "TEXTAREA"] },
+    { enableOnFormTags: ["INPUT", "TEXTAREA"], enableOnContentEditable: true },
     [hasUnsavedChanges, isSaving, handleManualSave],
   );
 
@@ -134,23 +207,22 @@ export function PlanEditor({
           overflow: "hidden",
         }}
       >
-        {isMarkdownFile ? (
-          <RichTextEditor
-            value={content}
-            onChange={setContent}
-            repoPath={repoPath}
-            placeholder="Your implementation plan will appear here..."
-            showToolbar={true}
-            minHeight="100%"
-          />
-        ) : (
-          <TextArea
-            value={content}
-            onChange={(e) => setContent(e.target.value)}
-            placeholder="File content will appear here..."
-            className="min-h-full flex-1 resize-none rounded-none border-none bg-transparent font-mono text-sm shadow-none outline-none"
-          />
-        )}
+        <TextArea
+          value={content}
+          onChange={(e) => setContent(e.target.value)}
+          placeholder="Your implementation plan will appear here..."
+          style={{
+            height: "100%",
+            width: "100%",
+            resize: "none",
+            border: "none",
+            outline: "none",
+            fontFamily: "monospace",
+            fontSize: "13px",
+            padding: "16px",
+            backgroundColor: "transparent",
+          }}
+        />
       </Box>
 
       {/* Floating Save Button */}
diff --git a/apps/array/src/renderer/features/editor/components/RichTextEditor.tsx b/apps/array/src/renderer/features/editor/components/RichTextEditor.tsx
index cf66aa6e..8d8effad 100644
--- a/apps/array/src/renderer/features/editor/components/RichTextEditor.tsx
+++ b/apps/array/src/renderer/features/editor/components/RichTextEditor.tsx
@@ -467,7 +467,9 @@ export function RichTextEditor({
       }}
     >
       {showToolbar && editor && <FormattingToolbar editor={editor} />}
-      <EditorContent editor={editor} />
+      <Box style={{ flex: 1, overflow: "auto" }}>
+        <EditorContent editor={editor} />
+      </Box>
       <style>
         {`
           .rich-text-file-path {
diff --git a/apps/array/src/renderer/features/panels/constants/panelConstants.ts b/apps/array/src/renderer/features/panels/constants/panelConstants.ts
index 154a180a..20c88171 100644
--- a/apps/array/src/renderer/features/panels/constants/panelConstants.ts
+++ b/apps/array/src/renderer/features/panels/constants/panelConstants.ts
@@ -26,4 +26,5 @@ export const DEFAULT_TAB_IDS = {
   TODO_LIST: "todo-list",
   ARTIFACTS: "artifacts",
   CHANGES: "changes",
+  PLAN: "plan",
 } as const;
diff --git a/apps/array/src/renderer/features/panels/store/panelLayoutStore.ts b/apps/array/src/renderer/features/panels/store/panelLayoutStore.ts
index 3d834996..dfd1c5f7 100644
--- a/apps/array/src/renderer/features/panels/store/panelLayoutStore.ts
+++ b/apps/array/src/renderer/features/panels/store/panelLayoutStore.ts
@@ -51,6 +51,7 @@ export interface PanelLayoutStore {
   openFile: (taskId: string, filePath: string) => void;
   openArtifact: (taskId: string, fileName: string) => void;
   openDiff: (taskId: string, filePath: string, status?: string) => void;
+  openPlan: (taskId: string) => void;
   closeTab: (taskId: string, panelId: string, tabId: string) => void;
   closeOtherTabs: (taskId: string, panelId: string, tabId: string) => void;
   closeTabsToRight: (taskId: string, panelId: string, tabId: string) => void;
@@ -117,6 +118,14 @@ function createDefaultPanelTree(
           closeable: false,
           draggable: true,
         },
+        {
+          id: DEFAULT_TAB_IDS.PLAN,
+          label: "Plan",
+          data: { type: "plan" },
+          component: null,
+          closeable: true,
+          draggable: true,
+        },
       ],
       activeTabId: DEFAULT_TAB_IDS.LOGS,
       showTabs: true,
@@ -172,6 +181,14 @@ function createDefaultPanelTree(
                 closeable: false,
                 draggable: true,
               },
+              {
+                id: DEFAULT_TAB_IDS.PLAN,
+                label: "Plan",
+                data: { type: "plan" },
+                component: null,
+                closeable: true,
+                draggable: true,
+              },
               {
                 id: DEFAULT_TAB_IDS.SHELL,
                 label: "Terminal",
@@ -276,6 +293,10 @@ export const usePanelLayoutStore = createWithEqualityFn<PanelLayoutStore>()(
         set((state) => openTab(state, taskId, tabId));
       },
 
+      openPlan: (taskId) => {
+        set((state) => openTab(state, taskId, DEFAULT_TAB_IDS.PLAN));
+      },
+
       closeTab: (taskId, panelId, tabId) => {
         set((state) =>
           updateTaskLayout(state, taskId, (layout) => {
@@ -740,8 +761,70 @@ export const usePanelLayoutStore = createWithEqualityFn<PanelLayoutStore>()(
     {
       name: "panel-layout-store",
       // Bump this version when the default panel structure changes to reset all layouts
-      version: 8,
-      migrate: () => ({ taskLayouts: {} }),
+      version: 9,
+      migrate: (persistedState, version) => {
+        const state = persistedState as {
+          taskLayouts: Record<string, PanelNode>;
+        };
+
+        // Migration from version 8 to 9: Add Plan tab to existing layouts
+        if (version === 8 && state.taskLayouts) {
+          const planTab: Tab = {
+            id: DEFAULT_TAB_IDS.PLAN,
+            label: "Plan",
+            data: { type: "plan" },
+            component: null,
+            closeable: true,
+            draggable: true,
+          };
+
+          // Recursively add Plan tab to panels that have the Logs tab
+          const addPlanTabToNode = (node: PanelNode): PanelNode => {
+            if (node.type === "leaf") {
+              const hasLogsTab = node.content.tabs.some(
+                (tab) => tab.id === DEFAULT_TAB_IDS.LOGS,
+              );
+              const hasPlanTab = node.content.tabs.some(
+                (tab) => tab.id === DEFAULT_TAB_IDS.PLAN,
+              );
+
+              if (hasLogsTab && !hasPlanTab) {
+                // Find the index of the logs tab and insert plan tab after it
+                const logsIndex = node.content.tabs.findIndex(
+                  (tab) => tab.id === DEFAULT_TAB_IDS.LOGS,
+                );
+                const newTabs = [...node.content.tabs];
+                newTabs.splice(logsIndex + 1, 0, planTab);
+
+                return {
+                  ...node,
+                  content: {
+                    ...node.content,
+                    tabs: newTabs,
+                  },
+                };
+              }
+              return node;
+            }
+
+            // Recursively process group children
+            return {
+              ...node,
+              children: node.children.map(addPlanTabToNode),
+            };
+          };
+
+          const migratedLayouts: Record<string, PanelNode> = {};
+          for (const [taskId, layout] of Object.entries(state.taskLayouts)) {
+            migratedLayouts[taskId] = addPlanTabToNode(layout);
+          }
+
+          return { taskLayouts: migratedLayouts };
+        }
+
+        // For any other version, reset layouts
+        return { taskLayouts: {} };
+      },
     },
   ),
 );
diff --git a/apps/array/src/renderer/features/panels/store/panelStoreHelpers.ts b/apps/array/src/renderer/features/panels/store/panelStoreHelpers.ts
index d78f56c9..77e68fcd 100644
--- a/apps/array/src/renderer/features/panels/store/panelStoreHelpers.ts
+++ b/apps/array/src/renderer/features/panels/store/panelStoreHelpers.ts
@@ -85,6 +85,9 @@ export function createTabLabel(tabId: string): string {
     const label = getStatusLabel(parsed.status);
     return `${fileName} (${label})`;
   }
+  if (tabId === "plan") {
+    return "Plan";
+  }
   return parsed.value;
 }
 
@@ -189,6 +192,8 @@ export function createNewTab(tabId: string, closeable = true): Tab {
     case "system":
       if (tabId === "logs") {
         data = { type: "logs" };
+      } else if (tabId === "plan") {
+        data = { type: "plan" };
       } else if (tabId.startsWith("shell")) {
         data = {
           type: "terminal",
diff --git a/apps/array/src/renderer/features/panels/store/panelTypes.ts b/apps/array/src/renderer/features/panels/store/panelTypes.ts
index 525583fe..042c517e 100644
--- a/apps/array/src/renderer/features/panels/store/panelTypes.ts
+++ b/apps/array/src/renderer/features/panels/store/panelTypes.ts
@@ -40,6 +40,9 @@ export type TabData =
   | {
       type: "logs";
     }
+  | {
+      type: "plan";
+    }
   | {
       type: "other";
       // Generic tab without specific data
diff --git a/apps/array/src/renderer/features/sessions/components/SessionView.tsx b/apps/array/src/renderer/features/sessions/components/SessionView.tsx
index 682ce78a..7f4cf9d0 100644
--- a/apps/array/src/renderer/features/sessions/components/SessionView.tsx
+++ b/apps/array/src/renderer/features/sessions/components/SessionView.tsx
@@ -114,10 +114,18 @@ function parseSessionNotification(
     case "user_message_chunk":
     case "agent_message_chunk": {
       if (update.content.type === "text") {
+        const content = update.content.text;
+        // Filter out injected system reminders from display
+        if (
+          update.sessionUpdate === "user_message_chunk" &&
+          content.startsWith("[System reminder:")
+        ) {
+          return null; // Skip the system reminder block entirely
+        }
         return {
           type:
             update.sessionUpdate === "user_message_chunk" ? "user" : "agent",
-          content: update.content.text,
+          content,
         };
       }
       return null;
diff --git a/apps/array/src/renderer/features/sessions/stores/sessionStore.ts b/apps/array/src/renderer/features/sessions/stores/sessionStore.ts
index 1018c815..53f0a297 100644
--- a/apps/array/src/renderer/features/sessions/stores/sessionStore.ts
+++ b/apps/array/src/renderer/features/sessions/stores/sessionStore.ts
@@ -397,9 +397,25 @@ export const useSessionStore = create<SessionStore>((set, get) => ({
       throw new Error("No active session for task");
     }
 
-    const blocks: ContentBlock[] =
+    let blocks: ContentBlock[] =
       typeof prompt === "string" ? [{ type: "text", text: prompt }] : prompt;
 
+    // Inject a reminder to read the plan when user mentions "plan"
+    const promptText = blocks
+      .filter((b): b is { type: "text"; text: string } => b.type === "text")
+      .map((b) => b.text)
+      .join(" ")
+      .toLowerCase();
+    if (promptText.includes("plan")) {
+      blocks = [
+        {
+          type: "text",
+          text: "[System reminder: If implementing a plan, call mcp__acp__ReadPlan first to get the user's current version - they may have edited it.]",
+        },
+        ...blocks,
+      ];
+    }
+
     if (session.isCloud) {
       // Cloud: send via S3 log - cloud runner polls and picks up
       // No pending state needed since we just append to log
diff --git a/apps/array/src/renderer/features/task-detail/components/TabContentRenderer.tsx b/apps/array/src/renderer/features/task-detail/components/TabContentRenderer.tsx
index 27b594f6..3d80930e 100644
--- a/apps/array/src/renderer/features/task-detail/components/TabContentRenderer.tsx
+++ b/apps/array/src/renderer/features/task-detail/components/TabContentRenderer.tsx
@@ -6,6 +6,7 @@ import { FileTreePanel } from "@features/task-detail/components/FileTreePanel";
 import { TaskArtifactEditorPanel } from "@features/task-detail/components/TaskArtifactEditorPanel";
 import { TaskArtifactsPanel } from "@features/task-detail/components/TaskArtifactsPanel";
 import { TaskLogsPanel } from "@features/task-detail/components/TaskLogsPanel";
+import { TaskPlanPanel } from "@features/task-detail/components/TaskPlanPanel";
 import { TaskShellPanel } from "@features/task-detail/components/TaskShellPanel";
 import { TodoListPanel } from "@features/task-detail/components/TodoListPanel";
 import { WorkspaceTerminalPanel } from "@features/workspace/components/WorkspaceTerminalPanel";
@@ -69,6 +70,9 @@ export function TabContentRenderer({
         />
       );
 
+    case "plan":
+      return <TaskPlanPanel taskId={taskId} task={task} />;
+
     case "other":
       // Handle system tabs by ID
       // TODO: These should all have their own type as well
diff --git a/apps/array/src/renderer/features/task-detail/components/TaskDetail.tsx b/apps/array/src/renderer/features/task-detail/components/TaskDetail.tsx
index 8920904e..6a2d7cfc 100644
--- a/apps/array/src/renderer/features/task-detail/components/TaskDetail.tsx
+++ b/apps/array/src/renderer/features/task-detail/components/TaskDetail.tsx
@@ -8,7 +8,7 @@ import { useBlurOnEscape } from "@hooks/useBlurOnEscape";
 import { useFileWatcher } from "@hooks/useFileWatcher";
 import { useSetHeaderContent } from "@hooks/useSetHeaderContent";
 import { useStatusBar } from "@hooks/useStatusBar";
-import { Box, Code, Flex, Text } from "@radix-ui/themes";
+import { Box, Flex, Text } from "@radix-ui/themes";
 import type { Task } from "@shared/types";
 import { useMemo } from "react";
 import { useWorkspaceStore } from "@/renderer/features/workspace/stores/workspaceStore";
@@ -61,8 +61,6 @@ export function TaskDetail({ task: initialTask }: TaskDetailProps) {
     (state) => state.workspaces[taskId] ?? null,
   );
 
-  const branchName = workspace?.branchName;
-
   const headerContent = useMemo(
     () => (
       <Flex align="center" justify="between" gap="2" width="100%">
@@ -70,11 +68,6 @@ export function TaskDetail({ task: initialTask }: TaskDetailProps) {
           <Text size="2" weight="medium" truncate>
             {task.title}
           </Text>
-          {branchName && (
-            <Code size="1" color="gray" variant="ghost">
-              {branchName}
-            </Code>
-          )}
           <StartWorkspaceButton taskId={taskId} />
         </Flex>
         <Flex align="center" gap="2" flexShrink="0">
@@ -85,7 +78,7 @@ export function TaskDetail({ task: initialTask }: TaskDetailProps) {
         </Flex>
       </Flex>
     ),
-    [task.title, branchName, workspace, taskId, effectiveRepoPath],
+    [task.title, workspace, taskId, effectiveRepoPath],
   );
 
   useSetHeaderContent(headerContent);
diff --git a/apps/array/src/renderer/features/task-detail/components/TaskPlanPanel.tsx b/apps/array/src/renderer/features/task-detail/components/TaskPlanPanel.tsx
new file mode 100644
index 00000000..ea1201cc
--- /dev/null
+++ b/apps/array/src/renderer/features/task-detail/components/TaskPlanPanel.tsx
@@ -0,0 +1,35 @@
+import { BackgroundWrapper } from "@components/BackgroundWrapper";
+import { PlanEditor } from "@features/editor/components/PlanEditor";
+import { DEFAULT_TAB_IDS } from "@features/panels/constants/panelConstants";
+import { useTaskData } from "@features/task-detail/hooks/useTaskData";
+import { useWorkspaceStore } from "@features/workspace/stores/workspaceStore";
+import type { Task } from "@shared/types";
+
+interface TaskPlanPanelProps {
+  taskId: string;
+  task: Task;
+}
+
+export function TaskPlanPanel({ taskId, task }: TaskPlanPanelProps) {
+  const taskData = useTaskData({ taskId, initialTask: task });
+  const worktreePath = useWorkspaceStore(
+    (state) => state.workspaces[taskId]?.worktreePath,
+  );
+  // Use worktree path if available, otherwise fall back to main repo path
+  const effectiveRepoPath = worktreePath ?? taskData.repoPath;
+
+  if (!effectiveRepoPath) {
+    return null;
+  }
+
+  return (
+    <BackgroundWrapper>
+      <PlanEditor
+        taskId={taskId}
+        repoPath={effectiveRepoPath}
+        fileName="plan.md"
+        tabId={DEFAULT_TAB_IDS.PLAN}
+      />
+    </BackgroundWrapper>
+  );
+}
diff --git a/packages/agent/index.ts b/packages/agent/index.ts
index 2d2e03ce..903eceb0 100644
--- a/packages/agent/index.ts
+++ b/packages/agent/index.ts
@@ -18,6 +18,12 @@ export type {
 } from "./src/adapters/claude/claude.js";
 export { createAcpConnection } from "./src/adapters/claude/claude.js";
 export { Agent } from "./src/agent.js";
+export {
+  getPlanPath,
+  getTaskArtifactPath,
+  getTaskDir,
+  POSTHOG_FOLDER,
+} from "./src/paths.js";
 export type {
   AgentEvent,
   ConsoleEvent,
@@ -41,6 +47,7 @@ export type {
   KillShellTool,
   KnownTool,
   NotebookEditTool,
+  ReadPlanTool,
   ReadTool,
   SlashCommandTool,
   TaskTool,
@@ -49,6 +56,7 @@ export type {
   ToolCategory,
   WebFetchTool,
   WebSearchTool,
+  WritePlanTool,
   WriteTool,
 } from "./src/tools/types.js";
 export type {
@@ -67,9 +75,7 @@ export type {
   WorktreeInfo,
 } from "./src/types.js";
 export { PermissionMode } from "./src/types.js";
-
 export type { LoggerConfig } from "./src/utils/logger.js";
 export { Logger, LogLevel } from "./src/utils/logger.js";
-
 export type { WorktreeConfig } from "./src/worktree-manager.js";
 export { WorktreeManager } from "./src/worktree-manager.js";
diff --git a/packages/agent/src/adapters/claude/claude.ts b/packages/agent/src/adapters/claude/claude.ts
index a593ff38..e8c66875 100644
--- a/packages/agent/src/adapters/claude/claude.ts
+++ b/packages/agent/src/adapters/claude/claude.ts
@@ -119,6 +119,22 @@ type BackgroundTerminal =
  * Extra metadata that can be given to Claude Code when creating a new session.
  */
 export type NewSessionMeta = {
+  /** Custom session ID to use instead of generating one */
+  sessionId?: string;
+  /** Task ID for plan management tools */
+  taskId?: string;
+  /** Disable built-in ACP tools (Read, Write, Edit, Bash, etc.) */
+  disableBuiltInTools?: boolean;
+  /** Custom system prompt - either a string or an object with append */
+  systemPrompt?: string | { append: string };
+  /** Session persistence configuration */
+  persistence?: {
+    type: "local";
+    path: string;
+  };
+  /** SDK session ID for resuming sessions */
+  sdkSessionId?: string;
+  /** Claude Code specific options */
   claudeCode?: {
     /**
      * Options forwarded to Claude Code when starting a new session.
@@ -265,9 +281,8 @@ export class ClaudeAcpAgent implements Agent {
     }
 
     // Allow caller to specify sessionId via _meta (e.g. taskRunId in our case)
-    const sessionId =
-      (params._meta as { sessionId?: string } | undefined)?.sessionId ||
-      uuidv7();
+    const meta = params._meta as NewSessionMeta | undefined;
+    const sessionId = meta?.sessionId || uuidv7();
     const input = new Pushable<SDKUserMessage>();
 
     const mcpServers: Record<string, McpServerConfig> = {};
@@ -294,9 +309,15 @@ export class ClaudeAcpAgent implements Agent {
       }
     }
 
+    // Extract taskId from _meta if provided
+    const taskId = meta?.taskId;
+
     // Only add the acp MCP server if built-in tools are not disabled
-    if (!params._meta?.disableBuiltInTools) {
-      const server = createMcpServer(this, sessionId, this.clientCapabilities);
+    if (!meta?.disableBuiltInTools) {
+      const server = createMcpServer(this, sessionId, this.clientCapabilities, {
+        taskId,
+        cwd: params.cwd,
+      });
       mcpServers.acp = {
         type: "sdk",
         name: "acp",
@@ -308,8 +329,43 @@ export class ClaudeAcpAgent implements Agent {
       type: "preset",
       preset: "claude_code",
     };
-    if (params._meta?.systemPrompt) {
-      const customPrompt = params._meta.systemPrompt;
+
+    // Add plan tool instructions when taskId is available
+    if (taskId && params.cwd) {
+      const planInstructions = `
+
+# Implementation Planning
+
+You have access to plan management tools for this task:
+
+- **mcp__acp__WritePlan**: Use this to create or update the implementation plan. The plan is visible to the user in their Plan tab in real-time.
+- **mcp__acp__ReadPlan**: Use this to read the current plan from disk.
+
+## Critical: The plan file is the source of truth
+
+The user can edit the plan directly in their Plan tab at any time. Their edits are saved to disk immediately. **You MUST call mcp__acp__ReadPlan before implementing or executing the plan** - never rely on your memory of what you previously wrote, as the user may have modified it.
+
+## When to use these tools:
+
+1. **At the start of complex tasks**: Before diving into code, use mcp__acp__WritePlan to document your approach. Include:
+   - Overview of what needs to be done
+   - Key steps or phases
+   - Important considerations or trade-offs
+   - Files that will be modified
+
+2. **Before implementing the plan**: ALWAYS call mcp__acp__ReadPlan first to get the current version. The user may have edited it to add, remove, or modify steps.
+
+3. **During implementation**: Update the plan as you make progress. Mark completed items and add any new discoveries.
+
+The plan should be written in markdown format. Keep it concise but informative.
+
+REMEMBER: When the user asks to implement, execute, or "do" a plan, your FIRST action must be to call mcp__acp__ReadPlan to get the current version.
+`;
+      systemPrompt.append = (systemPrompt.append || "") + planInstructions;
+    }
+
+    if (meta?.systemPrompt) {
+      const customPrompt = meta.systemPrompt;
       if (typeof customPrompt === "string") {
         systemPrompt = customPrompt;
       } else if (
@@ -317,15 +373,14 @@ export class ClaudeAcpAgent implements Agent {
         "append" in customPrompt &&
         typeof customPrompt.append === "string"
       ) {
-        systemPrompt.append = customPrompt.append;
+        systemPrompt.append = (systemPrompt.append || "") + customPrompt.append;
       }
     }
 
     const permissionMode = "default";
 
     // Extract options from _meta if provided
-    const userProvidedOptions = (params._meta as NewSessionMeta | undefined)
-      ?.claudeCode?.options;
+    const userProvidedOptions = meta?.claudeCode?.options;
 
     const options: Options = {
       systemPrompt,
@@ -366,7 +421,7 @@ export class ClaudeAcpAgent implements Agent {
     const disallowedTools = [];
 
     // Check if built-in tools should be disabled
-    const disableBuiltInTools = params._meta?.disableBuiltInTools === true;
+    const disableBuiltInTools = meta?.disableBuiltInTools === true;
 
     if (!disableBuiltInTools) {
       if (this.clientCapabilities?.fs?.readTextFile) {
@@ -433,7 +488,7 @@ export class ClaudeAcpAgent implements Agent {
     this.createSession(sessionId, q, input, permissionMode);
 
     // Register for S3 persistence if config provided
-    const persistence = params._meta?.persistence as
+    const persistence = meta?.persistence as
       | SessionPersistenceConfig
       | undefined;
     if (persistence && this.sessionStore) {
@@ -938,10 +993,11 @@ export class ClaudeAcpAgent implements Agent {
     const { sessionId } = params;
 
     // Extract persistence config and SDK session ID from _meta
-    const persistence = params._meta?.persistence as
+    const meta = params._meta as NewSessionMeta | undefined;
+    const persistence = meta?.persistence as
       | SessionPersistenceConfig
       | undefined;
-    const sdkSessionId = params._meta?.sdkSessionId as string | undefined;
+    const sdkSessionId = meta?.sdkSessionId;
 
     if (!this.sessions[sessionId]) {
       const input = new Pushable<SDKUserMessage>();
diff --git a/packages/agent/src/adapters/claude/mcp-server.ts b/packages/agent/src/adapters/claude/mcp-server.ts
index 26bfe097..2bde70d0 100644
--- a/packages/agent/src/adapters/claude/mcp-server.ts
+++ b/packages/agent/src/adapters/claude/mcp-server.ts
@@ -1,4 +1,5 @@
 import { randomBytes } from "node:crypto";
+import fs from "node:fs";
 import type {
   ClientCapabilities,
   TerminalOutputResponse,
@@ -6,6 +7,7 @@ import type {
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import * as diff from "diff";
 import { z } from "zod";
+import { getPlanPath, getTaskDir } from "@/paths.js";
 import { Logger } from "@/utils/logger.js";
 import type { ClaudeAcpAgent } from "./claude.js";
 import { extractLinesWithByteLimit, sleep, unreachable } from "./utils.js";
@@ -39,10 +41,16 @@ export const toolNames = {
 
 export const EDIT_TOOL_NAMES = [toolNames.edit, toolNames.write];
 
+export type McpServerContext = {
+  taskId?: string;
+  cwd?: string;
+};
+
 export function createMcpServer(
   agent: ClaudeAcpAgent,
   sessionId: string,
   clientCapabilities: ClientCapabilities | undefined,
+  context: McpServerContext = {},
 ): McpServer {
   // Create MCP server
   const server = new McpServer(
@@ -342,6 +350,124 @@ Usage:
     );
   }
 
+  // WritePlan tool - writes to the task's plan.md file
+  // Registered independently of writeTextFile capability since it uses the agent's method
+  if (context.taskId && context.cwd) {
+    server.registerTool(
+      "WritePlan",
+      {
+        title: "WritePlan",
+        description: `Writes or updates the implementation plan for the current task.
+
+The plan is saved to disk and visible to the user in their Plan tab in real-time. The user can edit the plan directly, so always call mcp__acp__ReadPlan before implementing to get the current version.
+
+Write in markdown format. Include:
+- Overview of what needs to be done
+- Key steps (use checkboxes like "- [ ] Step 1")
+- Files that will be modified`,
+        inputSchema: {
+          content: z
+            .string()
+            .describe("The full plan content in markdown format"),
+        },
+        annotations: {
+          title: "Write Plan",
+          readOnlyHint: false,
+          destructiveHint: false,
+          openWorldHint: false,
+          idempotentHint: true,
+        },
+      },
+      async (input) => {
+        try {
+          const planDir = getTaskDir(context.cwd!, context.taskId!);
+          const planPath = getPlanPath(context.cwd!, context.taskId!);
+
+          // Create directory if it doesn't exist and write file directly
+          fs.mkdirSync(planDir, { recursive: true });
+          fs.writeFileSync(planPath, input.content, "utf-8");
+
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Plan saved. IMPORTANT: The user can edit this plan in their Plan tab. Before implementing, you MUST call mcp__acp__ReadPlan to get the current version - do not rely on your memory of what you wrote.`,
+              },
+            ],
+          };
+        } catch (error: any) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Writing plan failed: ${error.message}`,
+              },
+            ],
+          };
+        }
+      },
+    );
+
+    // ReadPlan tool - reads the task's plan.md file
+    server.registerTool(
+      "ReadPlan",
+      {
+        title: "ReadPlan",
+        description: `Reads the current implementation plan from disk.
+
+IMPORTANT: Always use this tool before implementing a plan. The user can edit the plan at any time in their Plan tab, so your memory of the plan may be outdated. This tool returns the user's current version.
+
+Call this tool:
+- Before starting implementation (required)
+- Before updating the plan
+- Whenever the user asks you to follow, execute, or implement "the plan"`,
+        inputSchema: {},
+        annotations: {
+          title: "Read Plan",
+          readOnlyHint: true,
+          destructiveHint: false,
+          openWorldHint: false,
+          idempotentHint: true,
+        },
+      },
+      async () => {
+        try {
+          const planPath = getPlanPath(context.cwd!, context.taskId!);
+
+          if (!fs.existsSync(planPath)) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: "No plan exists yet. Use mcp__acp__WritePlan to create one.",
+                },
+              ],
+            };
+          }
+
+          const content = fs.readFileSync(planPath, "utf-8");
+          return {
+            content: [
+              {
+                type: "text",
+                text: content,
+              },
+            ],
+          };
+        } catch (error: any) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Reading plan failed: ${error.message}`,
+              },
+            ],
+          };
+        }
+      },
+    );
+  }
+
   if (agent.clientCapabilities?.terminal) {
     server.registerTool(
       unqualifiedToolNames.bash,
diff --git a/packages/agent/src/adapters/claude/tools.ts b/packages/agent/src/adapters/claude/tools.ts
index 03d7a416..f149f039 100644
--- a/packages/agent/src/adapters/claude/tools.ts
+++ b/packages/agent/src/adapters/claude/tools.ts
@@ -389,6 +389,27 @@ export function toolInfoFromToolUse(
           : [],
       };
 
+    case "WritePlan":
+      return {
+        title: "Update Plan",
+        kind: "edit",
+        content: input?.content
+          ? [
+              {
+                type: "content",
+                content: { type: "text", text: input.content },
+              },
+            ]
+          : [],
+      };
+
+    case "ReadPlan":
+      return {
+        title: "Read Plan",
+        kind: "read",
+        content: [],
+      };
+
     case "Other": {
       let output: string;
       try {
diff --git a/packages/agent/src/paths.ts b/packages/agent/src/paths.ts
new file mode 100644
index 00000000..585358df
--- /dev/null
+++ b/packages/agent/src/paths.ts
@@ -0,0 +1,32 @@
+/**
+ * Shared path utilities for PostHog task artifacts.
+ *
+ * The .posthog folder structure:
+ *   .posthog/
+ *     {taskId}/
+ *       plan.md
+ *       context.md
+ *       ...other artifacts
+ */
+
+/** Base folder name for PostHog artifacts */
+export const POSTHOG_FOLDER = ".posthog";
+
+/** Get the directory path for a task's artifacts */
+export function getTaskDir(cwd: string, taskId: string): string {
+  return `${cwd}/${POSTHOG_FOLDER}/${taskId}`;
+}
+
+/** Get the path to a task's plan file */
+export function getPlanPath(cwd: string, taskId: string): string {
+  return `${getTaskDir(cwd, taskId)}/plan.md`;
+}
+
+/** Get the path to any task artifact */
+export function getTaskArtifactPath(
+  cwd: string,
+  taskId: string,
+  fileName: string,
+): string {
+  return `${getTaskDir(cwd, taskId)}/${fileName}`;
+}
diff --git a/packages/agent/src/tools/registry.ts b/packages/agent/src/tools/registry.ts
index 7fd1b6e1..5b1eed2a 100644
--- a/packages/agent/src/tools/registry.ts
+++ b/packages/agent/src/tools/registry.ts
@@ -89,6 +89,16 @@ const TOOL_DEFINITIONS: Record<string, Tool> = {
     category: "assistant",
     description: "Execute a slash command",
   },
+  WritePlan: {
+    name: "WritePlan",
+    category: "assistant",
+    description: "Write or update the implementation plan file",
+  },
+  ReadPlan: {
+    name: "ReadPlan",
+    category: "assistant",
+    description: "Read the current implementation plan file",
+  },
 };
 
 /**
diff --git a/packages/agent/src/tools/types.ts b/packages/agent/src/tools/types.ts
index 23972bf0..8dd09b77 100644
--- a/packages/agent/src/tools/types.ts
+++ b/packages/agent/src/tools/types.ts
@@ -105,6 +105,16 @@ export interface SlashCommandTool extends Tool {
   category: "assistant";
 }
 
+export interface WritePlanTool extends Tool {
+  name: "WritePlan";
+  category: "assistant";
+}
+
+export interface ReadPlanTool extends Tool {
+  name: "ReadPlan";
+  category: "assistant";
+}
+
 /**
  * Union type of all known tool types.
  * Useful for discriminated unions and type narrowing.
@@ -124,4 +134,6 @@ export type KnownTool =
   | TaskTool
   | TodoWriteTool
   | ExitPlanModeTool
-  | SlashCommandTool;
+  | SlashCommandTool
+  | WritePlanTool
+  | ReadPlanTool;