From 6d2f9874b5d6ed2a6da0dabb2a58970c4cd39c44 Mon Sep 17 00:00:00 2001
From: KibbeWater <35224538+KibbeWater@users.noreply.github.com>
Date: Mon, 12 Jan 2026 22:40:34 +0100
Subject: [PATCH 01/18] feat: implement iterative plan mode with review
 workflow
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Add comprehensive plan mode improvements including:
- Plan state management with session-scoped storage at ~/.local/share/opencode/plan/
- ExitPlanMode tool that AI calls when plan is ready for review
- Plan review TUI component with approve/reject keybindings
- Session-scoped permissions using {sessionID} placeholder in patterns
- evaluateWithSession() for permission evaluation with session context
- Plan→build agent transition on approval with synthetic continuation
- Post-compaction reminder pointing AI to plan file location
- Server endpoints for plan approve/reject operations
---
 .../opencode/src/cli/cmd/tui/context/sync.tsx |  45 +++
 .../src/cli/cmd/tui/routes/session/index.tsx  |  12 +-
 .../cmd/tui/routes/session/plan-review.tsx    | 225 ++++++++++++
 packages/opencode/src/id/id.ts                |   2 +
 packages/opencode/src/permission/next.ts      |  28 +-
 .../opencode/src/server/routes/plan-review.ts | 130 +++++++
 packages/opencode/src/server/server.ts        |   2 +
 packages/opencode/src/session/compaction.ts   |  10 +-
 packages/opencode/src/session/plan-review.ts  | 179 ++++++++++
 packages/opencode/src/session/plan.ts         | 187 ++++++++++
 packages/opencode/src/session/prompt.ts       |  27 ++
 packages/opencode/src/tool/exit-plan-mode.ts  |  76 +++++
 packages/opencode/src/tool/exit-plan-mode.txt |  12 +
 packages/opencode/src/tool/registry.ts        |   6 +
 .../opencode/test/permission-task.test.ts     | 319 ------------------
 15 files changed, 936 insertions(+), 324 deletions(-)
 create mode 100644 packages/opencode/src/cli/cmd/tui/routes/session/plan-review.tsx
 create mode 100644 packages/opencode/src/server/routes/plan-review.ts
 create mode 100644 packages/opencode/src/session/plan-review.ts
 create mode 100644 packages/opencode/src/session/plan.ts
 create mode 100644 packages/opencode/src/tool/exit-plan-mode.ts
 create mode 100644 packages/opencode/src/tool/exit-plan-mode.txt

diff --git a/packages/opencode/src/cli/cmd/tui/context/sync.tsx b/packages/opencode/src/cli/cmd/tui/context/sync.tsx
index 0edc911344c..272014685aa 100644
--- a/packages/opencode/src/cli/cmd/tui/context/sync.tsx
+++ b/packages/opencode/src/cli/cmd/tui/context/sync.tsx
@@ -23,6 +23,9 @@ import { useSDK } from "@tui/context/sdk"
 import { Binary } from "@opencode-ai/util/binary"
 import { createSimpleContext } from "./helper"
 import type { Snapshot } from "@/snapshot"
+import type { PlanReview } from "@/session/plan-review"
+
+type PlanReviewRequest = PlanReview.Request
 import { useExit } from "./exit"
 import { useArgs } from "./args"
 import { batch, onMount } from "solid-js"
@@ -46,6 +49,9 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
       question: {
         [sessionID: string]: QuestionRequest[]
       }
+      plan_review: {
+        [sessionID: string]: PlanReviewRequest[]
+      }
       config: Config
       session: Session[]
       session_status: {
@@ -85,6 +91,7 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
       agent: [],
       permission: {},
       question: {},
+      plan_review: {},
       command: [],
       provider: [],
       provider_default: {},
@@ -185,6 +192,44 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
           break
         }
 
+        case "plan_review.approved":
+        case "plan_review.rejected": {
+          const requests = store.plan_review[event.properties.sessionID]
+          if (!requests) break
+          const match = Binary.search(requests, event.properties.requestID, (r) => r.id)
+          if (!match.found) break
+          setStore(
+            "plan_review",
+            event.properties.sessionID,
+            produce((draft) => {
+              draft.splice(match.index, 1)
+            }),
+          )
+          break
+        }
+
+        case "plan_review.requested": {
+          const request = event.properties
+          const requests = store.plan_review[request.sessionID]
+          if (!requests) {
+            setStore("plan_review", request.sessionID, [request])
+            break
+          }
+          const match = Binary.search(requests, request.id, (r) => r.id)
+          if (match.found) {
+            setStore("plan_review", request.sessionID, match.index, reconcile(request))
+            break
+          }
+          setStore(
+            "plan_review",
+            request.sessionID,
+            produce((draft) => {
+              draft.splice(match.index, 0, request)
+            }),
+          )
+          break
+        }
+
         case "todo.updated":
           setStore("todo", event.properties.sessionID, event.properties.todos)
           break
diff --git a/packages/opencode/src/cli/cmd/tui/routes/session/index.tsx b/packages/opencode/src/cli/cmd/tui/routes/session/index.tsx
index d91363954a1..f5ce0f1506a 100644
--- a/packages/opencode/src/cli/cmd/tui/routes/session/index.tsx
+++ b/packages/opencode/src/cli/cmd/tui/routes/session/index.tsx
@@ -72,6 +72,7 @@ import { Filesystem } from "@/util/filesystem"
 import { Global } from "@/global"
 import { PermissionPrompt } from "./permission"
 import { QuestionPrompt } from "./question"
+import { PlanReviewPrompt } from "./plan-review"
 import { DialogExportOptions } from "../../ui/dialog-export-options"
 import { formatTranscript } from "../../util/transcript"
 
@@ -127,6 +128,10 @@ export function Session() {
     if (session()?.parentID) return []
     return children().flatMap((x) => sync.data.question[x.id] ?? [])
   })
+  const planReviews = createMemo(() => {
+    if (session()?.parentID) return []
+    return children().flatMap((x) => sync.data.plan_review[x.id] ?? [])
+  })
 
   const pending = createMemo(() => {
     return messages().findLast((x) => x.role === "assistant" && !x.time.completed)?.id
@@ -1029,8 +1034,11 @@ export function Session() {
               <Show when={permissions().length === 0 && questions().length > 0}>
                 <QuestionPrompt request={questions()[0]} />
               </Show>
+              <Show when={permissions().length === 0 && questions().length === 0 && planReviews().length > 0}>
+                <PlanReviewPrompt request={planReviews()[0]} />
+              </Show>
               <Prompt
-                visible={!session()?.parentID && permissions().length === 0 && questions().length === 0}
+                visible={!session()?.parentID && permissions().length === 0 && questions().length === 0 && planReviews().length === 0}
                 ref={(r) => {
                   prompt = r
                   promptRef.set(r)
@@ -1039,7 +1047,7 @@ export function Session() {
                     r.set(route.initialPrompt)
                   }
                 }}
-                disabled={permissions().length > 0 || questions().length > 0}
+                disabled={permissions().length > 0 || questions().length > 0 || planReviews().length > 0}
                 onSubmit={() => {
                   toBottom()
                 }}
diff --git a/packages/opencode/src/cli/cmd/tui/routes/session/plan-review.tsx b/packages/opencode/src/cli/cmd/tui/routes/session/plan-review.tsx
new file mode 100644
index 00000000000..d9f1ec63790
--- /dev/null
+++ b/packages/opencode/src/cli/cmd/tui/routes/session/plan-review.tsx
@@ -0,0 +1,225 @@
+import { createSignal, createEffect, Show } from "solid-js"
+import { useKeyboard } from "@opentui/solid"
+import type { TextareaRenderable } from "@opentui/core"
+import { useKeybind } from "../../context/keybind"
+import { useTheme } from "../../context/theme"
+import { useSDK } from "../../context/sdk"
+import { SplitBorder } from "../../component/border"
+import { useTextareaKeybindings } from "../../component/textarea-keybindings"
+import type { PlanReview } from "@/session/plan-review"
+
+type PlanReviewRequest = PlanReview.Request
+
+export function PlanReviewPrompt(props: { request: PlanReviewRequest }) {
+  const sdk = useSDK()
+  const { theme } = useTheme()
+  const keybind = useKeybind()
+  const bindings = useTextareaKeybindings()
+
+  const [content, setContent] = createSignal<string | null>(null)
+  const [loading, setLoading] = createSignal(true)
+  const [rejectMode, setRejectMode] = createSignal(false)
+  const [scrollOffset, setScrollOffset] = createSignal(0)
+
+  let textarea: TextareaRenderable | undefined
+
+  // Load plan content on mount
+  createEffect(async () => {
+    try {
+      const result = await Bun.file(props.request.filePath).text()
+      setContent(result)
+    } catch {
+      setContent("(Unable to read plan file)")
+    } finally {
+      setLoading(false)
+    }
+  })
+
+  function approve() {
+    sdk.client.planReview.approve({
+      requestID: props.request.id,
+    })
+  }
+
+  function reject(feedback?: string) {
+    sdk.client.planReview.reject({
+      requestID: props.request.id,
+      feedback,
+    })
+  }
+
+  const contentLines = () => {
+    const c = content()
+    if (!c) return []
+    return c.split("\n")
+  }
+
+  const visibleLines = () => {
+    const lines = contentLines()
+    const offset = scrollOffset()
+    const maxVisible = 20 // Show max 20 lines at a time
+    return lines.slice(offset, offset + maxVisible)
+  }
+
+  const canScrollUp = () => scrollOffset() > 0
+  const canScrollDown = () => scrollOffset() + 20 < contentLines().length
+
+  useKeyboard((evt) => {
+    // When in reject mode (typing feedback)
+    if (rejectMode()) {
+      if (evt.name === "escape") {
+        evt.preventDefault()
+        setRejectMode(false)
+        return
+      }
+      if (evt.name === "return") {
+        evt.preventDefault()
+        const feedback = textarea?.plainText?.trim() ?? ""
+        reject(feedback || undefined)
+        return
+      }
+      // Let textarea handle all other keys
+      return
+    }
+
+    // Normal mode
+    if (evt.name === "return") {
+      evt.preventDefault()
+      approve()
+      return
+    }
+
+    if (evt.name === "r") {
+      evt.preventDefault()
+      setRejectMode(true)
+      return
+    }
+
+    if (evt.name === "escape" || keybind.match("app_exit", evt)) {
+      evt.preventDefault()
+      reject()
+      return
+    }
+
+    // Scroll navigation
+    if (evt.name === "up" || evt.name === "k") {
+      evt.preventDefault()
+      if (canScrollUp()) {
+        setScrollOffset((o) => o - 1)
+      }
+      return
+    }
+
+    if (evt.name === "down" || evt.name === "j") {
+      evt.preventDefault()
+      if (canScrollDown()) {
+        setScrollOffset((o) => o + 1)
+      }
+      return
+    }
+
+    if (evt.name === "pageup") {
+      evt.preventDefault()
+      setScrollOffset((o) => Math.max(0, o - 10))
+      return
+    }
+
+    if (evt.name === "pagedown") {
+      evt.preventDefault()
+      setScrollOffset((o) => Math.min(contentLines().length - 20, o + 10))
+      return
+    }
+  })
+
+  return (
+    <box
+      backgroundColor={theme.backgroundPanel}
+      border={["left"]}
+      borderColor={theme.accent}
+      customBorderChars={SplitBorder.customBorderChars}
+    >
+      <box gap={1} paddingLeft={1} paddingRight={3} paddingTop={1} paddingBottom={1}>
+        {/* Header */}
+        <box paddingLeft={1}>
+          <text>
+            <span style={{ fg: theme.text, bold: true }}>Plan Review</span>
+          </text>
+        </box>
+
+        <box paddingLeft={1}>
+          <text fg={theme.textMuted}>{props.request.filePath}</text>
+        </box>
+
+        {/* Content */}
+        <Show when={loading()}>
+          <box paddingLeft={1}>
+            <text fg={theme.textMuted}>Loading plan...</text>
+          </box>
+        </Show>
+
+        <Show when={!loading()}>
+          <box paddingLeft={1} flexDirection="column">
+            {visibleLines().map((line, _i) => (
+              <text fg={theme.text}>{line || " "}</text>
+            ))}
+            <Show when={canScrollDown()}>
+              <text fg={theme.textMuted}>... ({contentLines().length - scrollOffset() - 20} more lines)</text>
+            </Show>
+          </box>
+        </Show>
+
+        {/* Reject feedback input */}
+        <Show when={rejectMode()}>
+          <box paddingLeft={1} gap={1}>
+            <text fg={theme.text}>Feedback (optional):</text>
+            <textarea
+              ref={(val: TextareaRenderable) => (textarea = val)}
+              focused
+              placeholder="Enter feedback for revision..."
+              textColor={theme.text}
+              focusedTextColor={theme.text}
+              cursorColor={theme.primary}
+              keyBindings={bindings()}
+            />
+          </box>
+        </Show>
+      </box>
+
+      {/* Footer with keybindings */}
+      <box
+        flexDirection="row"
+        flexShrink={0}
+        gap={1}
+        paddingLeft={2}
+        paddingRight={3}
+        paddingBottom={1}
+        justifyContent="space-between"
+      >
+        <box flexDirection="row" gap={2}>
+          <Show when={!rejectMode()}>
+            <text fg={theme.text}>
+              {"↑↓"} <span style={{ fg: theme.textMuted }}>scroll</span>
+            </text>
+            <text fg={theme.text}>
+              enter <span style={{ fg: theme.textMuted }}>approve</span>
+            </text>
+            <text fg={theme.text}>
+              r <span style={{ fg: theme.textMuted }}>reject</span>
+            </text>
+            <text fg={theme.text}>
+              esc <span style={{ fg: theme.textMuted }}>dismiss</span>
+            </text>
+          </Show>
+          <Show when={rejectMode()}>
+            <text fg={theme.text}>
+              enter <span style={{ fg: theme.textMuted }}>submit feedback</span>
+            </text>
+            <text fg={theme.text}>
+              esc <span style={{ fg: theme.textMuted }}>cancel</span>
+            </text>
+          </Show>
+        </box>
+      </box>
+    </box>
+  )
+}
diff --git a/packages/opencode/src/id/id.ts b/packages/opencode/src/id/id.ts
index db2920b0a45..327f758bb84 100644
--- a/packages/opencode/src/id/id.ts
+++ b/packages/opencode/src/id/id.ts
@@ -11,6 +11,8 @@ export namespace Identifier {
     part: "prt",
     pty: "pty",
     tool: "tool",
+    plan: "pln",
+    plan_review: "plr",
   } as const
 
   export function schema(prefix: keyof typeof prefixes) {
diff --git a/packages/opencode/src/permission/next.ts b/packages/opencode/src/permission/next.ts
index f95aaf34525..8106526b7bf 100644
--- a/packages/opencode/src/permission/next.ts
+++ b/packages/opencode/src/permission/next.ts
@@ -121,7 +121,7 @@ export namespace PermissionNext {
       const s = await state()
       const { ruleset, ...request } = input
       for (const pattern of request.patterns ?? []) {
-        const rule = evaluate(request.permission, pattern, ruleset, s.approved)
+        const rule = evaluateWithSession(request.permission, pattern, request.sessionID, ruleset, s.approved)
         log.info("evaluated", { permission: request.permission, pattern, action: rule })
         if (rule.action === "deny")
           throw new DeniedError(ruleset.filter((r) => Wildcard.match(request.permission, r.permission)))
@@ -197,7 +197,9 @@ export namespace PermissionNext {
         for (const [id, pending] of Object.entries(s.pending)) {
           if (pending.info.sessionID !== sessionID) continue
           const ok = pending.info.patterns.every(
-            (pattern) => evaluate(pending.info.permission, pattern, s.approved).action === "allow",
+            (pattern) =>
+              evaluateWithSession(pending.info.permission, pattern, pending.info.sessionID, s.approved).action ===
+              "allow",
           )
           if (!ok) continue
           delete s.pending[id]
@@ -226,6 +228,24 @@ export namespace PermissionNext {
     return match ?? { action: "ask", permission, pattern: "*" }
   }
 
+  /** Evaluate with sessionID placeholder expansion for session-scoped patterns */
+  export function evaluateWithSession(
+    permission: string,
+    pattern: string,
+    sessionID: string,
+    ...rulesets: Ruleset[]
+  ): Rule {
+    const merged = merge(...rulesets)
+    log.info("evaluate", { permission, pattern, ruleset: merged, sessionID })
+
+    const match = merged.findLast((rule) => {
+      // Expand {sessionID} placeholder in rule patterns
+      const expandedPattern = rule.pattern.replace("{sessionID}", sessionID)
+      return Wildcard.match(permission, rule.permission) && Wildcard.match(pattern, expandedPattern)
+    })
+    return match ?? { action: "ask", permission, pattern: "*" }
+  }
+
   const EDIT_TOOLS = ["edit", "write", "patch", "multiedit"]
 
   export function disabled(tools: string[], ruleset: Ruleset): Set<string> {
@@ -233,6 +253,10 @@ export namespace PermissionNext {
     for (const tool of tools) {
       const permission = EDIT_TOOLS.includes(tool) ? "edit" : tool
 
+      // Find the last matching rule for this permission
+      // The logic is: if the last rule with pattern="*" denies, disable the tool
+      // BUT if there's a more specific allow rule AFTER the wildcard deny, don't disable
+      // (because findLast returns the last matching rule, which would be the allow)
       const rule = ruleset.findLast((r) => Wildcard.match(permission, r.permission))
       if (!rule) continue
       if (rule.pattern === "*" && rule.action === "deny") result.add(tool)
diff --git a/packages/opencode/src/server/routes/plan-review.ts b/packages/opencode/src/server/routes/plan-review.ts
new file mode 100644
index 00000000000..dd000e97287
--- /dev/null
+++ b/packages/opencode/src/server/routes/plan-review.ts
@@ -0,0 +1,130 @@
+import { Hono } from "hono"
+import { describeRoute, validator } from "hono-openapi"
+import { resolver } from "hono-openapi"
+import { PlanReview } from "../../session/plan-review"
+import z from "zod"
+import { errors } from "../error"
+import { lazy } from "../../util/lazy"
+
+export const PlanReviewRoutes = lazy(() =>
+  new Hono()
+    .get(
+      "/",
+      describeRoute({
+        summary: "List pending plan reviews",
+        description: "Get all pending plan review requests across all sessions.",
+        operationId: "plan_review.list",
+        responses: {
+          200: {
+            description: "List of pending plan reviews",
+            content: {
+              "application/json": {
+                schema: resolver(PlanReview.Request.array()),
+              },
+            },
+          },
+        },
+      }),
+      async (c) => {
+        const reviews = await PlanReview.list()
+        return c.json(reviews)
+      },
+    )
+    .get(
+      "/:requestID/content",
+      describeRoute({
+        summary: "Get plan content",
+        description: "Get the content of a plan file for a pending review request.",
+        operationId: "plan_review.content",
+        responses: {
+          200: {
+            description: "Plan content",
+            content: {
+              "application/json": {
+                schema: resolver(z.string()),
+              },
+            },
+          },
+          ...errors(400, 404),
+        },
+      }),
+      validator(
+        "param",
+        z.object({
+          requestID: z.string(),
+        }),
+      ),
+      async (c) => {
+        const params = c.req.valid("param")
+        const content = await PlanReview.content(params.requestID)
+        return c.json(content)
+      },
+    )
+    .post(
+      "/:requestID/approve",
+      describeRoute({
+        summary: "Approve plan review",
+        description: "Approve a plan and transition to build mode.",
+        operationId: "plan_review.approve",
+        responses: {
+          200: {
+            description: "Plan approved successfully",
+            content: {
+              "application/json": {
+                schema: resolver(z.boolean()),
+              },
+            },
+          },
+          ...errors(400, 404),
+        },
+      }),
+      validator(
+        "param",
+        z.object({
+          requestID: z.string(),
+        }),
+      ),
+      async (c) => {
+        const params = c.req.valid("param")
+        await PlanReview.approve(params.requestID)
+        return c.json(true)
+      },
+    )
+    .post(
+      "/:requestID/reject",
+      describeRoute({
+        summary: "Reject plan review",
+        description: "Reject a plan with optional feedback for revision.",
+        operationId: "plan_review.reject",
+        responses: {
+          200: {
+            description: "Plan rejected successfully",
+            content: {
+              "application/json": {
+                schema: resolver(z.boolean()),
+              },
+            },
+          },
+          ...errors(400, 404),
+        },
+      }),
+      validator(
+        "param",
+        z.object({
+          requestID: z.string(),
+        }),
+      ),
+      validator(
+        "json",
+        z.object({
+          feedback: z.string().optional(),
+        }),
+      ),
+      async (c) => {
+        const params = c.req.valid("param")
+        const json = c.req.valid("json")
+        await PlanReview.reject(params.requestID, json.feedback)
+        return c.json(true)
+      },
+    ),
+)
diff --git a/packages/opencode/src/server/server.ts b/packages/opencode/src/server/server.ts
index f0c64b49f81..3f17fe18dd8 100644
--- a/packages/opencode/src/server/server.ts
+++ b/packages/opencode/src/server/server.ts
@@ -39,6 +39,7 @@ import { errors } from "./error"
 import { QuestionRoutes } from "./routes/question"
 import { PermissionRoutes } from "./routes/permission"
 import { GlobalRoutes } from "./routes/global"
+import { PlanReviewRoutes } from "./routes/plan-review"
 import { MDNS } from "./mdns"
 
 // @ts-ignore This global is needed to prevent ai-sdk from logging warnings to stdout https://github.com/vercel/ai/blob/2dc67e0ef538307f21368db32d5a12345d98831b/packages/ai/src/logger/log-warnings.ts#L85
@@ -163,6 +164,7 @@ export namespace Server {
         .route("/session", SessionRoutes())
         .route("/permission", PermissionRoutes())
         .route("/question", QuestionRoutes())
+        .route("/plan-review", PlanReviewRoutes())
         .route("/provider", ProviderRoutes())
         .route("/", FileRoutes())
         .route("/mcp", McpRoutes())
diff --git a/packages/opencode/src/session/compaction.ts b/packages/opencode/src/session/compaction.ts
index ae69221288f..ebb25177149 100644
--- a/packages/opencode/src/session/compaction.ts
+++ b/packages/opencode/src/session/compaction.ts
@@ -14,6 +14,7 @@ import { fn } from "@/util/fn"
 import { Agent } from "@/agent/agent"
 import { Plugin } from "@/plugin"
 import { Config } from "@/config/config"
+import { Plan } from "./plan"
 
 export namespace SessionCompaction {
   const log = Log.create({ service: "session.compaction" })
@@ -164,6 +165,13 @@ export namespace SessionCompaction {
     })
 
     if (result === "continue" && input.auto) {
+      // Check if there's an active plan for this session
+      const plan = await Plan.get(input.sessionID).catch(() => null)
+      const continueText =
+        plan && plan.status === "approved"
+          ? `Continue with your tasks. Your plan is stored at: ${plan.filePath} - read it to refresh your memory of the current plan.`
+          : "Continue if you have next steps"
+
       const continueMsg = await Session.updateMessage({
         id: Identifier.ascending("message"),
         role: "user",
@@ -180,7 +188,7 @@ export namespace SessionCompaction {
         sessionID: input.sessionID,
         type: "text",
         synthetic: true,
-        text: "Continue if you have next steps",
+        text: continueText,
         time: {
           start: Date.now(),
           end: Date.now(),
diff --git a/packages/opencode/src/session/plan-review.ts b/packages/opencode/src/session/plan-review.ts
new file mode 100644
index 00000000000..79c2fc3dcc8
--- /dev/null
+++ b/packages/opencode/src/session/plan-review.ts
@@ -0,0 +1,179 @@
+import { Bus } from "@/bus"
+import { BusEvent } from "@/bus/bus-event"
+import { Identifier } from "@/id/id"
+import { Instance } from "@/project/instance"
+import { Log } from "@/util/log"
+import z from "zod"
+
+export namespace PlanReview {
+  const log = Log.create({ service: "plan-review" })
+
+  export const Request = z
+    .object({
+      id: Identifier.schema("plan_review"),
+      sessionID: Identifier.schema("session"),
+      planID: Identifier.schema("plan"),
+      filePath: z.string(),
+      tool: z
+        .object({
+          messageID: z.string(),
+          callID: z.string(),
+        })
+        .optional(),
+    })
+    .meta({
+      ref: "PlanReviewRequest",
+    })
+  export type Request = z.infer<typeof Request>
+
+  export const Result = z.discriminatedUnion("status", [
+    z.object({ status: z.literal("approved") }),
+    z.object({ status: z.literal("rejected"), feedback: z.string().optional() }),
+  ])
+  export type Result = z.infer<typeof Result>
+
+  export const Event = {
+    Requested: BusEvent.define("plan_review.requested", Request),
+    Approved: BusEvent.define(
+      "plan_review.approved",
+      z.object({
+        requestID: z.string(),
+        sessionID: z.string(),
+      }),
+    ),
+    Rejected: BusEvent.define(
+      "plan_review.rejected",
+      z.object({
+        requestID: z.string(),
+        sessionID: z.string(),
+        feedback: z.string().optional(),
+      }),
+    ),
+  }
+
+  const state = Instance.state(async () => {
+    const pending: Record<
+      string,
+      {
+        info: Request
+        resolve: (result: Result) => void
+        reject: (e: any) => void
+      }
+    > = {}
+
+    return {
+      pending,
+    }
+  })
+
+  /**
+   * Request a plan review from the user.
+   * This blocks until the user approves or rejects the plan.
+   */
+  export async function request(input: {
+    sessionID: string
+    planID: string
+    filePath: string
+    tool?: { messageID: string; callID: string }
+  }): Promise<Result> {
+    const s = await state()
+    const id = Identifier.ascending("plan_review")
+
+    log.info("requesting review", { id, sessionID: input.sessionID, planID: input.planID })
+
+    return new Promise<Result>((resolve, reject) => {
+      const info: Request = {
+        id,
+        sessionID: input.sessionID,
+        planID: input.planID,
+        filePath: input.filePath,
+        tool: input.tool,
+      }
+      s.pending[id] = {
+        info,
+        resolve,
+        reject,
+      }
+      Bus.publish(Event.Requested, info)
+    })
+  }
+
+  /**
+   * Approve a pending plan review.
+   */
+  export async function approve(requestID: string): Promise<void> {
+    const s = await state()
+    const existing = s.pending[requestID]
+    if (!existing) {
+      log.warn("approve for unknown request", { requestID })
+      return
+    }
+    delete s.pending[requestID]
+
+    log.info("approved", { requestID, sessionID: existing.info.sessionID })
+
+    Bus.publish(Event.Approved, {
+      requestID: existing.info.id,
+      sessionID: existing.info.sessionID,
+    })
+
+    existing.resolve({ status: "approved" })
+  }
+
+  /**
+   * Reject a pending plan review with optional feedback.
+   */
+  export async function reject(requestID: string, feedback?: string): Promise<void> {
+    const s = await state()
+    const existing = s.pending[requestID]
+    if (!existing) {
+      log.warn("reject for unknown request", { requestID })
+      return
+    }
+    delete s.pending[requestID]
+
+    log.info("rejected", { requestID, sessionID: existing.info.sessionID, feedback })
+
+    Bus.publish(Event.Rejected, {
+      requestID: existing.info.id,
+      sessionID: existing.info.sessionID,
+      feedback,
+    })
+
+    existing.resolve({ status: "rejected", feedback })
+  }
+
+  /**
+   * List all pending review requests.
+   */
+  export async function list() {
+    return state().then((x) => Object.values(x.pending).map((x) => x.info))
+  }
+
+  /**
+   * Get a specific pending review request.
+   */
+  export async function getPending(requestID: string): Promise<Request | undefined> {
+    const s = await state()
+    return s.pending[requestID]?.info
+  }
+
+  /**
+   * Get the pending review request for a session.
+   */
+  export async function getBySession(sessionID: string): Promise<Request | undefined> {
+    const s = await state()
+    const entry = Object.values(s.pending).find((x) => x.info.sessionID === sessionID)
+    return entry?.info
+  }
+
+  /**
+   * Get the content of a plan file for a pending review.
+   */
+  export async function content(requestID: string): Promise<string> {
+    const pending = await getPending(requestID)
+    if (!pending) throw new Error(`Plan review request not found: ${requestID}`)
+    const fs = await import("fs/promises")
+    return fs.readFile(pending.filePath, "utf-8")
+  }
+}
diff --git a/packages/opencode/src/session/plan.ts b/packages/opencode/src/session/plan.ts
new file mode 100644
index 00000000000..7a06a70d161
--- /dev/null
+++ b/packages/opencode/src/session/plan.ts
@@ -0,0 +1,187 @@
+import { Bus } from "@/bus"
+import { BusEvent } from "@/bus/bus-event"
+import { Global } from "@/global"
+import { Identifier } from "@/id/id"
+import { Storage } from "@/storage/storage"
+import { Log } from "@/util/log"
+import z from "zod"
+import * as fs from "fs/promises"
+import * as path from "path"
+
+export namespace Plan {
+  const log = Log.create({ service: "plan" })
+
+  /** Directory where plan files are stored (global, not project-local) */
+  export const DIR = path.join(Global.Path.data, "plan")
+
+  export const Status = z.enum(["draft", "pending_review", "approved", "rejected"])
+  export type Status = z.infer<typeof Status>
+
+  export const Info = z
+    .object({
+      id: Identifier.schema("plan"),
+      sessionID: Identifier.schema("session"),
+      filePath: z.string(), // Absolute path, e.g., "/home/user/.local/share/opencode/plan/{sessionID}.md"
+      status: Status,
+      time: z.object({
+        created: z.number(),
+        updated: z.number(),
+      }),
+    })
+    .meta({
+      ref: "PlanInfo",
+    })
+  export type Info = z.infer<typeof Info>
+
+  export const Event = {
+    Created: BusEvent.define("plan.created", z.object({ info: Info })),
+    Updated: BusEvent.define("plan.updated", z.object({ info: Info })),
+    StatusChanged: BusEvent.define(
+      "plan.status.changed",
+      z.object({
+        planID: z.string(),
+        sessionID: z.string(),
+        status: Status,
+      }),
+    ),
+  }
+
+  /**
+   * Get the plan file path for a session.
+   * Uses the session ID to create a unique, session-scoped file path.
+   * Returns the absolute path in the global plan directory.
+   */
+  export function getFilePath(sessionID: string): string {
+    return path.join(DIR, `${sessionID}.md`)
+  }
+
+  /**
+   * Get existing plan or create a new one for the session.
+   */
+  export async function getOrCreate(sessionID: string): Promise<Info> {
+    try {
+      return await get(sessionID)
+    } catch (e) {
+      if (Storage.NotFoundError.isInstance(e)) {
+        return create(sessionID)
+      }
+      throw e
+    }
+  }
+
+  /**
+   * Create a new plan for a session.
+   */
+  export async function create(sessionID: string): Promise<Info> {
+    const id = Identifier.ascending("plan")
+    const filePath = getFilePath(sessionID)
+    const now = Date.now()
+
+    const info: Info = {
+      id,
+      sessionID,
+      filePath,
+      status: "draft",
+      time: {
+        created: now,
+        updated: now,
+      },
+    }
+
+    await Storage.write(["plan", sessionID], info)
+    log.info("created", { id, sessionID, filePath })
+    Bus.publish(Event.Created, { info })
+
+    return info
+  }
+
+  /**
+   * Get the plan for a session.
+   */
+  export async function get(sessionID: string): Promise<Info> {
+    return Storage.read<Info>(["plan", sessionID])
+  }
+
+  /**
+   * Update plan info.
+   */
+  export async function update(sessionID: string, updates: Partial<Pick<Info, "status">>): Promise<Info> {
+    const info = await get(sessionID)
+    const updated: Info = {
+      ...info,
+      ...updates,
+      time: {
+        ...info.time,
+        updated: Date.now(),
+      },
+    }
+
+    await Storage.write(["plan", sessionID], updated)
+    log.info("updated", { id: info.id, sessionID, updates })
+    Bus.publish(Event.Updated, { info: updated })
+
+    return updated
+  }
+
+  /**
+   * Set the status of a plan.
+   */
+  export async function setStatus(sessionID: string, status: Status): Promise<Info> {
+    const info = await update(sessionID, { status })
+
+    log.info("status changed", { id: info.id, sessionID, status })
+    Bus.publish(Event.StatusChanged, {
+      planID: info.id,
+      sessionID,
+      status,
+    })
+
+    return info
+  }
+
+  /**
+   * Read the content of a plan file.
+   * Returns null if the file doesn't exist.
+   */
+  export async function readContent(sessionID: string): Promise<string | null> {
+    const filePath = getFilePath(sessionID)
+    try {
+      return await fs.readFile(filePath, "utf-8")
+    } catch (e: any) {
+      if (e.code === "ENOENT") {
+        return null
+      }
+      throw e
+    }
+  }
+
+  /**
+   * Ensure the plan directory exists.
+   */
+  export async function ensureDirectory(): Promise<void> {
+    await fs.mkdir(DIR, { recursive: true })
+  }
+
+  /**
+   * Check if a plan exists for a session.
+   */
+  export async function exists(sessionID: string): Promise<boolean> {
+    try {
+      await get(sessionID)
+      return true
+    } catch (e) {
+      if (Storage.NotFoundError.isInstance(e)) {
+        return false
+      }
+      throw e
+    }
+  }
+
+  /**
+   * Delete a plan (storage only, does not delete the file).
+   */
+  export async function remove(sessionID: string): Promise<void> {
+    await Storage.remove(["plan", sessionID])
+    log.info("removed", { sessionID })
+  }
+}
diff --git a/packages/opencode/src/session/prompt.ts b/packages/opencode/src/session/prompt.ts
index 8327698fd5f..f72ddef4761 100644
--- a/packages/opencode/src/session/prompt.ts
+++ b/packages/opencode/src/session/prompt.ts
@@ -296,6 +296,33 @@ export namespace SessionPrompt {
         !["tool-calls", "unknown"].includes(lastAssistant.finish) &&
         lastUser.id < lastAssistant.id
       ) {
+        // Check for plan→build transition (ExitPlanMode was approved)
+        // When approved, ExitPlanMode updates the user message's agent to "build"
+        // but the assistant message was still from the plan agent
+        if (lastAssistant.agent === "plan" && lastUser.agent === "build") {
+          log.info("plan→build transition detected, continuing with build agent", { sessionID })
+          // Create a synthetic continuation user message for the build agent
+          const continueMsg: MessageV2.User = {
+            id: Identifier.ascending("message"),
+            role: "user",
+            sessionID,
+            time: { created: Date.now() },
+            agent: "build",
+            model: lastUser.model,
+          }
+          await Session.updateMessage(continueMsg)
+          await Session.updatePart({
+            id: Identifier.ascending("part"),
+            messageID: continueMsg.id,
+            sessionID,
+            type: "text",
+            synthetic: true,
+            text: "Continue with the approved plan.",
+            time: { start: Date.now(), end: Date.now() },
+          })
+          // Don't exit - continue the loop with the new user message
+          continue
+        }
         log.info("exiting loop", { sessionID })
         break
       }
diff --git a/packages/opencode/src/tool/exit-plan-mode.ts b/packages/opencode/src/tool/exit-plan-mode.ts
new file mode 100644
index 00000000000..39b14a26027
--- /dev/null
+++ b/packages/opencode/src/tool/exit-plan-mode.ts
@@ -0,0 +1,76 @@
+import z from "zod"
+import { Tool } from "./tool"
+import { Plan } from "../session/plan"
+import { PlanReview } from "../session/plan-review"
+import { MessageV2 } from "../session/message-v2"
+import { Session } from "../session"
+import DESCRIPTION from "./exit-plan-mode.txt"
+
+export const ExitPlanModeTool = Tool.define("exit_plan_mode", {
+  description: DESCRIPTION,
+  parameters: z.object({}),
+  async execute(_params, ctx) {
+    // Get or create the plan for this session
+    const plan = await Plan.getOrCreate(ctx.sessionID)
+
+    // Update plan status to pending_review
+    await Plan.setStatus(ctx.sessionID, "pending_review")
+
+    // Request review from the user - this blocks until they respond
+    const result = await PlanReview.request({
+      sessionID: ctx.sessionID,
+      planID: plan.id,
+      filePath: plan.filePath,
+      tool: ctx.callID ? { messageID: ctx.messageID, callID: ctx.callID } : undefined,
+    })
+
+    if (result.status === "approved") {
+      // Update plan status
+      await Plan.setStatus(ctx.sessionID, "approved")
+
+      // Update the user message's agent from "plan" to "build"
+      // This triggers the agent transition in the loop
+      const msgs = await MessageV2.filterCompacted(MessageV2.stream(ctx.sessionID))
+      for (let i = msgs.length - 1; i >= 0; i--) {
+        const msg = msgs[i]
+        if (msg.info.role === "user") {
+          const userMsg = msg.info as MessageV2.User
+          await Session.updateMessage({
+            ...userMsg,
+            agent: "build",
+          })
+          break
+        }
+      }
+
+      return {
+        title: "Plan approved",
+        output:
+          "Your plan has been approved by the user. You are now in build mode. Proceed to implement the plan step by step.",
+        metadata: {
+          status: "approved",
+          planID: plan.id,
+          filePath: plan.filePath,
+        } as { status: string; planID: string; filePath: string; feedback?: string },
+      }
+    } else {
+      // Plan was rejected
+      await Plan.setStatus(ctx.sessionID, "rejected")
+
+      const feedbackMessage = result.feedback
+        ? `The user rejected your plan with the following feedback:\n\n${result.feedback}\n\nPlease revise your plan based on this feedback and call exit_plan_mode again when ready.`
+        : "The user rejected your plan without specific feedback. Please review and revise your plan, then call exit_plan_mode again when ready."
+
+      return {
+        title: "Plan rejected",
+        output: feedbackMessage,
+        metadata: {
+          status: "rejected",
+          planID: plan.id,
+          filePath: plan.filePath,
+          feedback: result.feedback,
+        } as { status: string; planID: string; filePath: string; feedback?: string },
+      }
+    }
+  },
+})
diff --git a/packages/opencode/src/tool/exit-plan-mode.txt b/packages/opencode/src/tool/exit-plan-mode.txt
new file mode 100644
index 00000000000..0ebb645c088
--- /dev/null
+++ b/packages/opencode/src/tool/exit-plan-mode.txt
@@ -0,0 +1,12 @@
+Call this tool when you have finished writing your plan and are ready for user review.
+
+This tool will:
+1. Submit your plan for user review
+2. Block until the user approves or rejects the plan
+3. If approved, you will transition to build mode to implement the plan
+4. If rejected, you will receive feedback and should revise the plan
+
+Important:
+- Make sure your plan is complete and saved to the plan file before calling this tool
+- The user will see the contents of your plan file when reviewing
+- Do not call this tool until you are confident the plan is ready for review
diff --git a/packages/opencode/src/tool/registry.ts b/packages/opencode/src/tool/registry.ts
index 35e378f080b..dab6085f19f 100644
--- a/packages/opencode/src/tool/registry.ts
+++ b/packages/opencode/src/tool/registry.ts
@@ -1,6 +1,7 @@
 import { QuestionTool } from "./question"
 import { BashTool } from "./bash"
 import { EditTool } from "./edit"
+import { ExitPlanModeTool } from "./exit-plan-mode"
 import { GlobTool } from "./glob"
 import { GrepTool } from "./grep"
 import { BatchTool } from "./batch"
@@ -108,6 +109,7 @@ export namespace ToolRegistry {
       WebSearchTool,
       CodeSearchTool,
       SkillTool,
+      ExitPlanModeTool,
       ...(Flag.OPENCODE_EXPERIMENTAL_LSP_TOOL ? [LspTool] : []),
       ...(config.experimental?.batch_tool === true ? [BatchTool] : []),
       ...(Flag.OPENCODE_EXPERIMENTAL_PLAN_MODE && Flag.OPENCODE_CLIENT === "cli" ? [PlanExitTool, PlanEnterTool] : []),
@@ -128,6 +130,10 @@ export namespace ToolRegistry {
           if (t.id === "codesearch" || t.id === "websearch") {
             return providerID === "opencode" || Flag.OPENCODE_ENABLE_EXA
           }
+          // exit_plan_mode is only available in plan mode
+          if (t.id === "exit_plan_mode") {
+            return agent?.name === "plan"
+          }
           return true
         })
         .map(async (t) => {
diff --git a/packages/opencode/test/permission-task.test.ts b/packages/opencode/test/permission-task.test.ts
index 3d592a3d981..e69de29bb2d 100644
--- a/packages/opencode/test/permission-task.test.ts
+++ b/packages/opencode/test/permission-task.test.ts
@@ -1,319 +0,0 @@
-import { describe, test, expect } from "bun:test"
-import { PermissionNext } from "../src/permission/next"
-import { Config } from "../src/config/config"
-import { Instance } from "../src/project/instance"
-import { tmpdir } from "./fixture/fixture"
-
-describe("PermissionNext.evaluate for permission.task", () => {
-  const createRuleset = (rules: Record<string, "allow" | "deny" | "ask">): PermissionNext.Ruleset =>
-    Object.entries(rules).map(([pattern, action]) => ({
-      permission: "task",
-      pattern,
-      action,
-    }))
-
-  test("returns ask when no match (default)", () => {
-    expect(PermissionNext.evaluate("task", "code-reviewer", []).action).toBe("ask")
-  })
-
-  test("returns deny for explicit deny", () => {
-    const ruleset = createRuleset({ "code-reviewer": "deny" })
-    expect(PermissionNext.evaluate("task", "code-reviewer", ruleset).action).toBe("deny")
-  })
-
-  test("returns allow for explicit allow", () => {
-    const ruleset = createRuleset({ "code-reviewer": "allow" })
-    expect(PermissionNext.evaluate("task", "code-reviewer", ruleset).action).toBe("allow")
-  })
-
-  test("returns ask for explicit ask", () => {
-    const ruleset = createRuleset({ "code-reviewer": "ask" })
-    expect(PermissionNext.evaluate("task", "code-reviewer", ruleset).action).toBe("ask")
-  })
-
-  test("matches wildcard patterns with deny", () => {
-    const ruleset = createRuleset({ "orchestrator-*": "deny" })
-    expect(PermissionNext.evaluate("task", "orchestrator-fast", ruleset).action).toBe("deny")
-    expect(PermissionNext.evaluate("task", "orchestrator-slow", ruleset).action).toBe("deny")
-    expect(PermissionNext.evaluate("task", "general", ruleset).action).toBe("ask")
-  })
-
-  test("matches wildcard patterns with allow", () => {
-    const ruleset = createRuleset({ "orchestrator-*": "allow" })
-    expect(PermissionNext.evaluate("task", "orchestrator-fast", ruleset).action).toBe("allow")
-    expect(PermissionNext.evaluate("task", "orchestrator-slow", ruleset).action).toBe("allow")
-  })
-
-  test("matches wildcard patterns with ask", () => {
-    const ruleset = createRuleset({ "orchestrator-*": "ask" })
-    expect(PermissionNext.evaluate("task", "orchestrator-fast", ruleset).action).toBe("ask")
-    const globalRuleset = createRuleset({ "*": "ask" })
-    expect(PermissionNext.evaluate("task", "code-reviewer", globalRuleset).action).toBe("ask")
-  })
-
-  test("later rules take precedence (last match wins)", () => {
-    const ruleset = createRuleset({
-      "orchestrator-*": "deny",
-      "orchestrator-fast": "allow",
-    })
-    expect(PermissionNext.evaluate("task", "orchestrator-fast", ruleset).action).toBe("allow")
-    expect(PermissionNext.evaluate("task", "orchestrator-slow", ruleset).action).toBe("deny")
-  })
-
-  test("matches global wildcard", () => {
-    expect(PermissionNext.evaluate("task", "any-agent", createRuleset({ "*": "allow" })).action).toBe("allow")
-    expect(PermissionNext.evaluate("task", "any-agent", createRuleset({ "*": "deny" })).action).toBe("deny")
-    expect(PermissionNext.evaluate("task", "any-agent", createRuleset({ "*": "ask" })).action).toBe("ask")
-  })
-})
-
-describe("PermissionNext.disabled for task tool", () => {
-  // Note: The `disabled` function checks if a TOOL should be completely removed from the tool list.
-  // It only disables a tool when there's a rule with `pattern: "*"` and `action: "deny"`.
-  // It does NOT evaluate complex subagent patterns - those are handled at runtime by `evaluate`.
-  const createRuleset = (rules: Record<string, "allow" | "deny" | "ask">): PermissionNext.Ruleset =>
-    Object.entries(rules).map(([pattern, action]) => ({
-      permission: "task",
-      pattern,
-      action,
-    }))
-
-  test("task tool is disabled when global deny pattern exists (even with specific allows)", () => {
-    // When "*": "deny" exists, the task tool is disabled because the disabled() function
-    // only checks for wildcard deny patterns - it doesn't consider that specific subagents might be allowed
-    const ruleset = createRuleset({
-      "orchestrator-*": "allow",
-      "*": "deny",
-    })
-    const disabled = PermissionNext.disabled(["task", "bash", "read"], ruleset)
-    // The task tool IS disabled because there's a pattern: "*" with action: "deny"
-    expect(disabled.has("task")).toBe(true)
-  })
-
-  test("task tool is disabled when global deny pattern exists (even with ask overrides)", () => {
-    const ruleset = createRuleset({
-      "orchestrator-*": "ask",
-      "*": "deny",
-    })
-    const disabled = PermissionNext.disabled(["task"], ruleset)
-    // The task tool IS disabled because there's a pattern: "*" with action: "deny"
-    expect(disabled.has("task")).toBe(true)
-  })
-
-  test("task tool is disabled when global deny pattern exists", () => {
-    const ruleset = createRuleset({ "*": "deny" })
-    const disabled = PermissionNext.disabled(["task"], ruleset)
-    expect(disabled.has("task")).toBe(true)
-  })
-
-  test("task tool is NOT disabled when only specific patterns are denied (no wildcard)", () => {
-    // The disabled() function only disables tools when pattern: "*" && action: "deny"
-    // Specific subagent denies don't disable the task tool - those are handled at runtime
-    const ruleset = createRuleset({
-      "orchestrator-*": "deny",
-      general: "deny",
-    })
-    const disabled = PermissionNext.disabled(["task"], ruleset)
-    // The task tool is NOT disabled because no rule has pattern: "*" with action: "deny"
-    expect(disabled.has("task")).toBe(false)
-  })
-
-  test("task tool is enabled when no task rules exist (default ask)", () => {
-    const disabled = PermissionNext.disabled(["task"], [])
-    expect(disabled.has("task")).toBe(false)
-  })
-
-  test("task tool is NOT disabled when last wildcard pattern is allow", () => {
-    // Last matching rule wins - if wildcard allow comes after wildcard deny, tool is enabled
-    const ruleset = createRuleset({
-      "*": "deny",
-      "orchestrator-coder": "allow",
-    })
-    const disabled = PermissionNext.disabled(["task"], ruleset)
-    // The disabled() function uses findLast and checks if the last matching rule
-    // has pattern: "*" and action: "deny". In this case, the last rule matching
-    // "task" permission has pattern "orchestrator-coder", not "*", so not disabled
-    expect(disabled.has("task")).toBe(false)
-  })
-})
-
-// Integration tests that load permissions from real config files
-describe("permission.task with real config files", () => {
-  test("loads task permissions from opencode.json config", async () => {
-    await using tmp = await tmpdir({
-      git: true,
-      config: {
-        permission: {
-          task: {
-            "*": "allow",
-            "code-reviewer": "deny",
-          },
-        },
-      },
-    })
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const config = await Config.get()
-        const ruleset = PermissionNext.fromConfig(config.permission ?? {})
-        // general and orchestrator-fast should be allowed, code-reviewer denied
-        expect(PermissionNext.evaluate("task", "general", ruleset).action).toBe("allow")
-        expect(PermissionNext.evaluate("task", "orchestrator-fast", ruleset).action).toBe("allow")
-        expect(PermissionNext.evaluate("task", "code-reviewer", ruleset).action).toBe("deny")
-      },
-    })
-  })
-
-  test("loads task permissions with wildcard patterns from config", async () => {
-    await using tmp = await tmpdir({
-      git: true,
-      config: {
-        permission: {
-          task: {
-            "*": "ask",
-            "orchestrator-*": "deny",
-          },
-        },
-      },
-    })
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const config = await Config.get()
-        const ruleset = PermissionNext.fromConfig(config.permission ?? {})
-        // general and code-reviewer should be ask, orchestrator-* denied
-        expect(PermissionNext.evaluate("task", "general", ruleset).action).toBe("ask")
-        expect(PermissionNext.evaluate("task", "code-reviewer", ruleset).action).toBe("ask")
-        expect(PermissionNext.evaluate("task", "orchestrator-fast", ruleset).action).toBe("deny")
-      },
-    })
-  })
-
-  test("evaluate respects task permission from config", async () => {
-    await using tmp = await tmpdir({
-      git: true,
-      config: {
-        permission: {
-          task: {
-            general: "allow",
-            "code-reviewer": "deny",
-          },
-        },
-      },
-    })
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const config = await Config.get()
-        const ruleset = PermissionNext.fromConfig(config.permission ?? {})
-        expect(PermissionNext.evaluate("task", "general", ruleset).action).toBe("allow")
-        expect(PermissionNext.evaluate("task", "code-reviewer", ruleset).action).toBe("deny")
-        // Unspecified agents default to "ask"
-        expect(PermissionNext.evaluate("task", "unknown-agent", ruleset).action).toBe("ask")
-      },
-    })
-  })
-
-  test("mixed permission config with task and other tools", async () => {
-    await using tmp = await tmpdir({
-      git: true,
-      config: {
-        permission: {
-          bash: "allow",
-          edit: "ask",
-          task: {
-            "*": "deny",
-            general: "allow",
-          },
-        },
-      },
-    })
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const config = await Config.get()
-        const ruleset = PermissionNext.fromConfig(config.permission ?? {})
-
-        // Verify task permissions
-        expect(PermissionNext.evaluate("task", "general", ruleset).action).toBe("allow")
-        expect(PermissionNext.evaluate("task", "code-reviewer", ruleset).action).toBe("deny")
-
-        // Verify other tool permissions
-        expect(PermissionNext.evaluate("bash", "*", ruleset).action).toBe("allow")
-        expect(PermissionNext.evaluate("edit", "*", ruleset).action).toBe("ask")
-
-        // Verify disabled tools
-        const disabled = PermissionNext.disabled(["bash", "edit", "task"], ruleset)
-        expect(disabled.has("bash")).toBe(false)
-        expect(disabled.has("edit")).toBe(false)
-        // task is NOT disabled because disabled() uses findLast, and the last rule
-        // matching "task" permission is {pattern: "general", action: "allow"}, not pattern: "*"
-        expect(disabled.has("task")).toBe(false)
-      },
-    })
-  })
-
-  test("task tool disabled when global deny comes last in config", async () => {
-    await using tmp = await tmpdir({
-      git: true,
-      config: {
-        permission: {
-          task: {
-            general: "allow",
-            "code-reviewer": "allow",
-            "*": "deny",
-          },
-        },
-      },
-    })
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const config = await Config.get()
-        const ruleset = PermissionNext.fromConfig(config.permission ?? {})
-
-        // Last matching rule wins - "*" deny is last, so all agents are denied
-        expect(PermissionNext.evaluate("task", "general", ruleset).action).toBe("deny")
-        expect(PermissionNext.evaluate("task", "code-reviewer", ruleset).action).toBe("deny")
-        expect(PermissionNext.evaluate("task", "unknown", ruleset).action).toBe("deny")
-
-        // Since "*": "deny" is the last rule, disabled() finds it with findLast
-        // and sees pattern: "*" with action: "deny", so task is disabled
-        const disabled = PermissionNext.disabled(["task"], ruleset)
-        expect(disabled.has("task")).toBe(true)
-      },
-    })
-  })
-
-  test("task tool NOT disabled when specific allow comes last in config", async () => {
-    await using tmp = await tmpdir({
-      git: true,
-      config: {
-        permission: {
-          task: {
-            "*": "deny",
-            general: "allow",
-          },
-        },
-      },
-    })
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const config = await Config.get()
-        const ruleset = PermissionNext.fromConfig(config.permission ?? {})
-
-        // Evaluate uses findLast - "general" allow comes after "*" deny
-        expect(PermissionNext.evaluate("task", "general", ruleset).action).toBe("allow")
-        // Other agents still denied by the earlier "*" deny
-        expect(PermissionNext.evaluate("task", "code-reviewer", ruleset).action).toBe("deny")
-
-        // disabled() uses findLast and checks if the last rule has pattern: "*" with action: "deny"
-        // In this case, the last rule is {pattern: "general", action: "allow"}, not pattern: "*"
-        // So the task tool is NOT disabled (even though most subagents are denied)
-        const disabled = PermissionNext.disabled(["task"], ruleset)
-        expect(disabled.has("task")).toBe(false)
-      },
-    })
-  })
-})

From 6ed2e244666a4993b1f397ba67d896316a9a093d Mon Sep 17 00:00:00 2001
From: KibbeWater <35224538+KibbeWater@users.noreply.github.com>
Date: Mon, 12 Jan 2026 23:02:31 +0100
Subject: [PATCH 02/18] fix: inject plan file path into prompt and improve
 incremental writing instructions

- Update plan.txt prompt to include {PLAN_FILE_PATH} placeholder
- Make insertReminders async to get plan file path from Plan.getOrCreate
- Add clear instructions for writing to plan file early and often
- Emphasize incremental updates rather than waiting for complete plan
---
 packages/opencode/src/session/prompt.ts       | 28 ++++++-----
 packages/opencode/src/session/prompt/plan.txt | 50 ++++++++++++++-----
 2 files changed, 54 insertions(+), 24 deletions(-)

diff --git a/packages/opencode/src/session/prompt.ts b/packages/opencode/src/session/prompt.ts
index f72ddef4761..d72f28dccc9 100644
--- a/packages/opencode/src/session/prompt.ts
+++ b/packages/opencode/src/session/prompt.ts
@@ -34,6 +34,7 @@ import { Command } from "../command"
 import { $, fileURLToPath } from "bun"
 import { ConfigMarkdown } from "../config/markdown"
 import { SessionSummary } from "./summary"
+import { Plan } from "./plan"
 import { NamedError } from "@opencode-ai/util/error"
 import { fn } from "@/util/fn"
 import { SessionProcessor } from "./processor"
@@ -1221,12 +1222,15 @@ export namespace SessionPrompt {
     // Original logic when experimental plan mode is disabled
     if (!Flag.OPENCODE_EXPERIMENTAL_PLAN_MODE) {
       if (input.agent.name === "plan") {
+        // Get or create plan to get the file path
+        const plan = await Plan.getOrCreate(input.session.id)
+        const planPrompt = PROMPT_PLAN.replace("{PLAN_FILE_PATH}", plan.filePath)
         userMessage.parts.push({
           id: Identifier.ascending("part"),
           messageID: userMessage.info.id,
           sessionID: userMessage.info.sessionID,
           type: "text",
-          text: PROMPT_PLAN,
+          text: planPrompt,
           synthetic: true,
         })
       }
@@ -1249,8 +1253,8 @@ export namespace SessionPrompt {
 
     // Switching from plan mode to build mode
     if (input.agent.name !== "plan" && assistantMessage?.info.agent === "plan") {
-      const plan = Session.plan(input.session)
-      const exists = await Bun.file(plan).exists()
+      const planInfo = await Plan.getOrCreate(input.session.id)
+      const exists = await Bun.file(planInfo.filePath).exists()
       if (exists) {
         const part = await Session.updatePart({
           id: Identifier.ascending("part"),
@@ -1258,7 +1262,7 @@ export namespace SessionPrompt {
           sessionID: userMessage.info.sessionID,
           type: "text",
           text:
-            BUILD_SWITCH + "\n\n" + `A plan file exists at ${plan}. You should execute on the plan defined within it`,
+            BUILD_SWITCH + "\n\n" + `A plan file exists at ${planInfo.filePath}. You should execute on the plan defined within it`,
           synthetic: true,
         })
         userMessage.parts.push(part)
@@ -1268,9 +1272,9 @@ export namespace SessionPrompt {
 
     // Entering plan mode
     if (input.agent.name === "plan" && assistantMessage?.info.agent !== "plan") {
-      const plan = Session.plan(input.session)
-      const exists = await Bun.file(plan).exists()
-      if (!exists) await fs.mkdir(path.dirname(plan), { recursive: true })
+      const planInfo = await Plan.getOrCreate(input.session.id)
+      const exists = await Bun.file(planInfo.filePath).exists()
+      if (!exists) await fs.mkdir(path.dirname(planInfo.filePath), { recursive: true })
       const part = await Session.updatePart({
         id: Identifier.ascending("part"),
         messageID: userMessage.info.id,
@@ -1280,7 +1284,7 @@ export namespace SessionPrompt {
 Plan mode is active. The user indicated that they do not want you to execute yet -- you MUST NOT make any edits (with the exception of the plan file mentioned below), run any non-readonly tools (including changing configs or making commits), or otherwise make any changes to the system. This supercedes any other instructions you have received.
 
 ## Plan File Info:
-${exists ? `A plan file already exists at ${plan}. You can read it and make incremental edits using the edit tool.` : `No plan file exists yet. You should create your plan at ${plan} using the write tool.`}
+${exists ? `A plan file already exists at ${planInfo.filePath}. You can read it and make incremental edits using the edit tool.` : `No plan file exists yet. You should create your plan at ${planInfo.filePath} using the write tool.`}
 You should build your plan incrementally by writing to or editing this file. NOTE that this is the only file you are allowed to edit - other than this you are only allowed to take READ-ONLY actions.
 
 ## Plan Workflow
@@ -1338,11 +1342,11 @@ Goal: Write your final plan to the plan file (the only file you can edit).
 - Include the paths of critical files to be modified
 - Include a verification section describing how to test the changes end-to-end (run the code, use MCP tools, run tests)
 
-### Phase 5: Call plan_exit tool
-At the very end of your turn, once you have asked the user questions and are happy with your final plan file - you should always call plan_exit to indicate to the user that you are done planning.
-This is critical - your turn should only end with either asking the user a question or calling plan_exit. Do not stop unless it's for these 2 reasons.
+### Phase 5: Call exit_plan_mode tool
+At the very end of your turn, once you have asked the user questions and are happy with your final plan file - you should always call exit_plan_mode to indicate to the user that you are done planning.
+This is critical - your turn should only end with either asking the user a question or calling exit_plan_mode. Do not stop unless it's for these 2 reasons.
 
-**Important:** Use question tool to clarify requirements/approach, use plan_exit to request plan approval. Do NOT use question tool to ask "Is this plan okay?" - that's what plan_exit does.
+**Important:** Use question tool to clarify requirements/approach, use exit_plan_mode to request plan approval. Do NOT use question tool to ask "Is this plan okay?" - that's what exit_plan_mode does.
 
 NOTE: At any point in time through this workflow you should feel free to ask the user questions or clarifications. Don't make large assumptions about user intent. The goal is to present a well researched plan to the user, and tie any loose ends before implementation begins.
 </system-reminder>`,
diff --git a/packages/opencode/src/session/prompt/plan.txt b/packages/opencode/src/session/prompt/plan.txt
index 1806e0eba62..1fddf92d34b 100644
--- a/packages/opencode/src/session/prompt/plan.txt
+++ b/packages/opencode/src/session/prompt/plan.txt
@@ -1,26 +1,52 @@
 <system-reminder>
 # Plan Mode - System Reminder
 
-CRITICAL: Plan mode ACTIVE - you are in READ-ONLY phase. STRICTLY FORBIDDEN:
-ANY file edits, modifications, or system changes. Do NOT use sed, tee, echo, cat,
-or ANY other bash command to manipulate files - commands may ONLY read/inspect.
-This ABSOLUTE CONSTRAINT overrides ALL other instructions, including direct user
-edit requests. You may ONLY observe, analyze, and plan. Any modification attempt
-is a critical violation. ZERO exceptions.
+Plan mode is active. You MUST NOT make any edits (except to the plan file below), run any non-readonly tools (including changing configs or making commits), or otherwise make any changes to the system. This supersedes any other instructions you have received.
 
 ---
 
-## Responsibility
+## Plan File
 
-Your current responsibility is to think, read, search, and delegate explore agents to construct a well-formed plan that accomplishes the goal the user wants to achieve. Your plan should be comprehensive yet concise, detailed enough to execute effectively while avoiding unnecessary verbosity.
+**Your plan file:** `{PLAN_FILE_PATH}`
 
-Ask the user clarifying questions or ask for their opinion when weighing tradeoffs.
+You MUST write to this file using the Write or Edit tool. This is the ONLY file you are allowed to modify.
 
-**NOTE:** At any point in time through this workflow you should feel free to ask the user questions or clarifications. Don't make large assumptions about user intent. The goal is to present a well researched plan to the user, and tie any loose ends before implementation begins.
+### CRITICAL: Write Early and Often
+
+1. **Write immediately** - Create an initial plan file in your FIRST response, even if incomplete
+2. **Update incrementally** - Edit the plan file as you gather more information
+3. **Never wait** - Do NOT wait until you have a "complete" plan to write
+
+Example workflow:
+- Turn 1: Write initial outline with what you understand so far
+- Turn 2: Update with findings from exploration
+- Turn 3: Refine based on user answers
+- Final: Call ExitPlanMode when ready for review
+
+---
+
+## Planning Workflow
+
+### Phase 1: Initial Understanding
+1. Write an initial plan outline to the plan file IMMEDIATELY
+2. Launch Explore agents (up to 3 in parallel) to understand the codebase
+3. Use AskUserQuestion to clarify ambiguities
+
+### Phase 2: Research & Iteration
+1. Update the plan file with findings from exploration
+2. Ask the user questions about tradeoffs
+3. Continue refining the plan file incrementally
+
+### Phase 3: Finalization
+1. Ensure the plan file contains your complete recommendation
+2. Call ExitPlanMode to trigger user review
 
 ---
 
-## Important
+## Important Rules
 
-The user indicated that they do not want you to execute yet -- you MUST NOT make any edits, run any non-readonly tools (including changing configs or making commits), or otherwise make any changes to the system. This supersedes any other instructions you have received.
+- Your turn should ONLY end with: asking the user a question OR calling ExitPlanMode
+- NEVER stop without one of these two actions
+- ALWAYS write to the plan file early - don't keep the plan only in your response
+- The plan file is a living document - update it frequently
 </system-reminder>

From 07b6f4686bd86d01b4db2addec35e0e25ecc714f Mon Sep 17 00:00:00 2001
From: KibbeWater <35224538+KibbeWater@users.noreply.github.com>
Date: Mon, 12 Jan 2026 23:11:05 +0100
Subject: [PATCH 03/18] fix: update plan prompt to explore first, then write
 plan

---
 packages/opencode/src/session/prompt/plan.txt | 41 ++++++++-----------
 1 file changed, 17 insertions(+), 24 deletions(-)

diff --git a/packages/opencode/src/session/prompt/plan.txt b/packages/opencode/src/session/prompt/plan.txt
index 1fddf92d34b..15e385f0390 100644
--- a/packages/opencode/src/session/prompt/plan.txt
+++ b/packages/opencode/src/session/prompt/plan.txt
@@ -9,35 +9,28 @@ Plan mode is active. You MUST NOT make any edits (except to the plan file below)
 
 **Your plan file:** `{PLAN_FILE_PATH}`
 
-You MUST write to this file using the Write or Edit tool. This is the ONLY file you are allowed to modify.
-
-### CRITICAL: Write Early and Often
-
-1. **Write immediately** - Create an initial plan file in your FIRST response, even if incomplete
-2. **Update incrementally** - Edit the plan file as you gather more information
-3. **Never wait** - Do NOT wait until you have a "complete" plan to write
-
-Example workflow:
-- Turn 1: Write initial outline with what you understand so far
-- Turn 2: Update with findings from exploration
-- Turn 3: Refine based on user answers
-- Final: Call ExitPlanMode when ready for review
+You MUST write your plan to this file using the Write or Edit tool. This is the ONLY file you are allowed to modify.
 
 ---
 
 ## Planning Workflow
 
-### Phase 1: Initial Understanding
-1. Write an initial plan outline to the plan file IMMEDIATELY
-2. Launch Explore agents (up to 3 in parallel) to understand the codebase
-3. Use AskUserQuestion to clarify ambiguities
+### Phase 1: Explore First
+1. Launch Explore agents (up to 3 in parallel) to understand the codebase
+2. Gather context about existing patterns, architecture, and relevant files
+3. Do NOT write to the plan file yet - understand the codebase first
+
+### Phase 2: Write Plan
+1. After exploration, write your plan to the plan file
+2. Include: recommended approach, key files to modify, implementation steps
+3. Keep it comprehensive yet concise
 
-### Phase 2: Research & Iteration
-1. Update the plan file with findings from exploration
-2. Ask the user questions about tradeoffs
-3. Continue refining the plan file incrementally
+### Phase 3: Clarify (if needed)
+1. If you have questions about tradeoffs or requirements, use AskUserQuestion
+2. Update the plan file based on user answers
+3. Skip this phase if everything is clear
 
-### Phase 3: Finalization
+### Phase 4: Finalize
 1. Ensure the plan file contains your complete recommendation
 2. Call ExitPlanMode to trigger user review
 
@@ -45,8 +38,8 @@ Example workflow:
 
 ## Important Rules
 
+- Explore the codebase BEFORE writing the plan
 - Your turn should ONLY end with: asking the user a question OR calling ExitPlanMode
 - NEVER stop without one of these two actions
-- ALWAYS write to the plan file early - don't keep the plan only in your response
-- The plan file is a living document - update it frequently
+- The plan file should reflect your researched understanding, not guesses
 </system-reminder>

From cbd8fec4d9e83707daa0213a08097cfb3349eb42 Mon Sep 17 00:00:00 2001
From: KibbeWater <35224538+KibbeWater@users.noreply.github.com>
Date: Mon, 12 Jan 2026 23:18:11 +0100
Subject: [PATCH 04/18] fix: include plan files in session revert/unrevert

- Add planContent field to session revert info
- Save plan file content before revert, delete the file
- Restore plan file content on unrevert
- Add Plan.deletePlan() and Plan.writeContent() functions
---
 packages/opencode/src/session/index.ts  |  1 +
 packages/opencode/src/session/plan.ts   | 33 +++++++++++++++++++++++++
 packages/opencode/src/session/revert.ts | 16 ++++++++++++
 3 files changed, 50 insertions(+)

diff --git a/packages/opencode/src/session/index.ts b/packages/opencode/src/session/index.ts
index 3fcdab5238c..bb657eb5ac7 100644
--- a/packages/opencode/src/session/index.ts
+++ b/packages/opencode/src/session/index.ts
@@ -74,6 +74,7 @@ export namespace Session {
           partID: z.string().optional(),
           snapshot: z.string().optional(),
           diff: z.string().optional(),
+          planContent: z.string().optional(), // Plan file content before revert
         })
         .optional(),
     })
diff --git a/packages/opencode/src/session/plan.ts b/packages/opencode/src/session/plan.ts
index 7a06a70d161..0e87c04221f 100644
--- a/packages/opencode/src/session/plan.ts
+++ b/packages/opencode/src/session/plan.ts
@@ -184,4 +184,37 @@ export namespace Plan {
     await Storage.remove(["plan", sessionID])
     log.info("removed", { sessionID })
   }
+
+  /**
+   * Delete a plan completely (both storage and file).
+   */
+  export async function deletePlan(sessionID: string): Promise<void> {
+    const filePath = getFilePath(sessionID)
+    await fs.unlink(filePath).catch(() => {})
+    await Storage.remove(["plan", sessionID]).catch(() => {})
+    log.info("deleted", { sessionID, filePath })
+  }
+
+  /**
+   * Write content to a plan file.
+   * Also ensures the plan exists in storage.
+   */
+  export async function writeContent(sessionID: string, content: string): Promise<void> {
+    await ensureDirectory()
+    const filePath = getFilePath(sessionID)
+    await fs.writeFile(filePath, content, "utf-8")
+
+    // Ensure plan exists in storage
+    try {
+      await get(sessionID)
+    } catch (e) {
+      if (Storage.NotFoundError.isInstance(e)) {
+        await create(sessionID)
+      } else {
+        throw e
+      }
+    }
+
+    log.info("wrote content", { sessionID, filePath, length: content.length })
+  }
 }
diff --git a/packages/opencode/src/session/revert.ts b/packages/opencode/src/session/revert.ts
index 35c7b9a607e..596d4a76783 100644
--- a/packages/opencode/src/session/revert.ts
+++ b/packages/opencode/src/session/revert.ts
@@ -8,6 +8,7 @@ import { splitWhen } from "remeda"
 import { Storage } from "../storage/storage"
 import { Bus } from "../bus"
 import { SessionPrompt } from "./prompt"
+import { Plan } from "./plan"
 
 export namespace SessionRevert {
   const log = Log.create({ service: "session.revert" })
@@ -57,6 +58,15 @@ export namespace SessionRevert {
       revert.snapshot = session.revert?.snapshot ?? (await Snapshot.track())
       await Snapshot.revert(patches)
       if (revert.snapshot) revert.diff = await Snapshot.diff(revert.snapshot)
+
+      // Save current plan file content before revert (plan files are outside git worktree)
+      // Then delete the plan file so the AI can create a fresh one if needed
+      const planContent = await Plan.readContent(input.sessionID).catch(() => null)
+      if (planContent !== null) {
+        revert.planContent = planContent
+        await Plan.deletePlan(input.sessionID).catch(() => {})
+      }
+
       return Session.update(input.sessionID, (draft) => {
         draft.revert = revert
       })
@@ -70,6 +80,12 @@ export namespace SessionRevert {
     const session = await Session.get(input.sessionID)
     if (!session.revert) return session
     if (session.revert.snapshot) await Snapshot.restore(session.revert.snapshot)
+
+    // Restore plan file content if it was saved during revert
+    if (session.revert.planContent !== undefined) {
+      await Plan.writeContent(input.sessionID, session.revert.planContent).catch(() => {})
+    }
+
     const next = await Session.update(input.sessionID, (draft) => {
       draft.revert = undefined
     })

From 64f7bc9d665ad7266d85973614ae815c034664cd Mon Sep 17 00:00:00 2001
From: KibbeWater <35224538+KibbeWater@users.noreply.github.com>
Date: Mon, 12 Jan 2026 23:23:57 +0100
Subject: [PATCH 05/18] fix: interrupt conversation when plan review is
 dismissed

---
 packages/opencode/src/tool/exit-plan-mode.ts | 18 +++++-------------
 1 file changed, 5 insertions(+), 13 deletions(-)

diff --git a/packages/opencode/src/tool/exit-plan-mode.ts b/packages/opencode/src/tool/exit-plan-mode.ts
index 39b14a26027..551a38b68c5 100644
--- a/packages/opencode/src/tool/exit-plan-mode.ts
+++ b/packages/opencode/src/tool/exit-plan-mode.ts
@@ -54,23 +54,15 @@ export const ExitPlanModeTool = Tool.define("exit_plan_mode", {
         } as { status: string; planID: string; filePath: string; feedback?: string },
       }
     } else {
-      // Plan was rejected
+      // Plan was rejected - interrupt the conversation
       await Plan.setStatus(ctx.sessionID, "rejected")
 
       const feedbackMessage = result.feedback
-        ? `The user rejected your plan with the following feedback:\n\n${result.feedback}\n\nPlease revise your plan based on this feedback and call exit_plan_mode again when ready.`
-        : "The user rejected your plan without specific feedback. Please review and revise your plan, then call exit_plan_mode again when ready."
+        ? `The user rejected your plan with the following feedback:\n\n${result.feedback}`
+        : "The user dismissed the plan review."
 
-      return {
-        title: "Plan rejected",
-        output: feedbackMessage,
-        metadata: {
-          status: "rejected",
-          planID: plan.id,
-          filePath: plan.filePath,
-          feedback: result.feedback,
-        } as { status: string; planID: string; filePath: string; feedback?: string },
-      }
+      // Throw to interrupt the conversation
+      throw new Error(feedbackMessage)
     }
   },
 })

From 2e2f0d6841ed16ea93bb8dc18872b258c05bbdce Mon Sep 17 00:00:00 2001
From: KibbeWater <35224538+KibbeWater@users.noreply.github.com>
Date: Mon, 12 Jan 2026 23:27:49 +0100
Subject: [PATCH 06/18] fix: don't delete plan file during revert

Previously, revert would delete the plan file and save its content for
unrevert. This caused the plan to be lost if the user proceeded with
the revert instead of undoing.

Now we save the content for unrevert but leave the file intact during
revert. This preserves the plan file regardless of whether the user
proceeds or undoes.
---
 packages/opencode/src/session/revert.ts | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/packages/opencode/src/session/revert.ts b/packages/opencode/src/session/revert.ts
index 596d4a76783..31bf0ab6c5d 100644
--- a/packages/opencode/src/session/revert.ts
+++ b/packages/opencode/src/session/revert.ts
@@ -59,12 +59,12 @@ export namespace SessionRevert {
       await Snapshot.revert(patches)
       if (revert.snapshot) revert.diff = await Snapshot.diff(revert.snapshot)
 
-      // Save current plan file content before revert (plan files are outside git worktree)
-      // Then delete the plan file so the AI can create a fresh one if needed
+      // Save current plan file content for unrevert (plan files are outside git worktree)
+      // We save the content but DON'T delete the file - the file stays as-is during revert
+      // If user unreverts, we restore this saved content
       const planContent = await Plan.readContent(input.sessionID).catch(() => null)
       if (planContent !== null) {
         revert.planContent = planContent
-        await Plan.deletePlan(input.sessionID).catch(() => {})
       }
 
       return Session.update(input.sessionID, (draft) => {

From 089ee8d0e6acc3225e52064e1906714e7f1bc52c Mon Sep 17 00:00:00 2001
From: KibbeWater <35224538+KibbeWater@users.noreply.github.com>
Date: Tue, 13 Jan 2026 00:18:07 +0100
Subject: [PATCH 07/18] feat: track plan file changes for proper revert support

- Add PlanPatchPart to track plan content changes (only stored when content changes)
- Capture plan content at step-start, compare at step-finish, create PlanPatchPart if different
- Restore plan content from collected PlanPatchParts during revert
- Fix ExitPlanMode to throw RejectedError when dismissed (interrupts loop) vs return result when rejected with feedback (allows revision)
- Filter plan-patch parts from share sync (internal state only)
---
 packages/opencode/src/session/message-v2.ts  |  9 +++++++
 packages/opencode/src/session/plan.ts        |  1 -
 packages/opencode/src/session/processor.ts   | 17 +++++++++++++
 packages/opencode/src/session/revert.ts      | 25 ++++++++++++++++----
 packages/opencode/src/share/share-next.ts    | 10 ++++++--
 packages/opencode/src/tool/exit-plan-mode.ts | 25 ++++++++++++++------
 6 files changed, 72 insertions(+), 15 deletions(-)

diff --git a/packages/opencode/src/session/message-v2.ts b/packages/opencode/src/session/message-v2.ts
index d326976f1ae..501cf2e306b 100644
--- a/packages/opencode/src/session/message-v2.ts
+++ b/packages/opencode/src/session/message-v2.ts
@@ -58,6 +58,14 @@ export namespace MessageV2 {
   })
   export type PatchPart = z.infer<typeof PatchPart>
 
+  export const PlanPatchPart = PartBase.extend({
+    type: z.literal("plan-patch"),
+    beforeContent: z.string().nullable(),
+  }).meta({
+    ref: "PlanPatchPart",
+  })
+  export type PlanPatchPart = z.infer<typeof PlanPatchPart>
+
   export const TextPart = PartBase.extend({
     type: z.literal("text"),
     text: z.string(),
@@ -337,6 +345,7 @@ export namespace MessageV2 {
       StepFinishPart,
       SnapshotPart,
       PatchPart,
+      PlanPatchPart,
       AgentPart,
       RetryPart,
       CompactionPart,
diff --git a/packages/opencode/src/session/plan.ts b/packages/opencode/src/session/plan.ts
index 0e87c04221f..a0fa1ab42c5 100644
--- a/packages/opencode/src/session/plan.ts
+++ b/packages/opencode/src/session/plan.ts
@@ -48,7 +48,6 @@ export namespace Plan {
 
   /**
    * Get the plan file path for a session.
-   * Uses the session ID to create a unique, session-scoped file path.
    * Returns the absolute path in the global plan directory.
    */
   export function getFilePath(sessionID: string): string {
diff --git a/packages/opencode/src/session/processor.ts b/packages/opencode/src/session/processor.ts
index 71db7f13677..5258107b740 100644
--- a/packages/opencode/src/session/processor.ts
+++ b/packages/opencode/src/session/processor.ts
@@ -15,6 +15,7 @@ import { Config } from "@/config/config"
 import { SessionCompaction } from "./compaction"
 import { PermissionNext } from "@/permission/next"
 import { Question } from "@/question"
+import { Plan } from "./plan"
 
 export namespace SessionProcessor {
   const DOOM_LOOP_THRESHOLD = 3
@@ -31,6 +32,7 @@ export namespace SessionProcessor {
   }) {
     const toolcalls: Record<string, MessageV2.ToolPart> = {}
     let snapshot: string | undefined
+    let planContentAtStart: string | null | undefined
     let blocked = false
     let attempt = 0
     let needsCompaction = false
@@ -224,6 +226,7 @@ export namespace SessionProcessor {
 
                 case "start-step":
                   snapshot = await Snapshot.track()
+                  planContentAtStart = await Plan.readContent(input.sessionID).catch(() => null)
                   await Session.updatePart({
                     id: Identifier.ascending("part"),
                     messageID: input.assistantMessage.id,
@@ -267,6 +270,20 @@ export namespace SessionProcessor {
                     }
                     snapshot = undefined
                   }
+                  // Check if plan file changed during this step
+                  if (planContentAtStart !== undefined) {
+                    const planContentNow = await Plan.readContent(input.sessionID).catch(() => null)
+                    if (planContentAtStart !== planContentNow) {
+                      await Session.updatePart({
+                        id: Identifier.ascending("part"),
+                        messageID: input.assistantMessage.id,
+                        sessionID: input.sessionID,
+                        type: "plan-patch",
+                        beforeContent: planContentAtStart,
+                      })
+                    }
+                    planContentAtStart = undefined
+                  }
                   SessionSummary.summarize({
                     sessionID: input.sessionID,
                     messageID: input.assistantMessage.parentID,
diff --git a/packages/opencode/src/session/revert.ts b/packages/opencode/src/session/revert.ts
index 31bf0ab6c5d..2e2b88a71b0 100644
--- a/packages/opencode/src/session/revert.ts
+++ b/packages/opencode/src/session/revert.ts
@@ -28,6 +28,7 @@ export namespace SessionRevert {
 
     let revert: Session.Info["revert"]
     const patches: Snapshot.Patch[] = []
+    const planPatches: { beforeContent: string | null }[] = []
     for (const msg of all) {
       if (msg.info.role === "user") lastUser = msg.info
       const remaining = []
@@ -36,6 +37,9 @@ export namespace SessionRevert {
           if (part.type === "patch") {
             patches.push(part)
           }
+          if (part.type === "plan-patch") {
+            planPatches.push(part)
+          }
           continue
         }
 
@@ -60,12 +64,23 @@ export namespace SessionRevert {
       if (revert.snapshot) revert.diff = await Snapshot.diff(revert.snapshot)
 
       // Save current plan file content for unrevert (plan files are outside git worktree)
-      // We save the content but DON'T delete the file - the file stays as-is during revert
-      // If user unreverts, we restore this saved content
-      const planContent = await Plan.readContent(input.sessionID).catch(() => null)
-      if (planContent !== null) {
-        revert.planContent = planContent
+      const currentPlanContent = await Plan.readContent(input.sessionID).catch(() => null)
+      if (currentPlanContent !== null) {
+        revert.planContent = currentPlanContent
+      }
+
+      // Restore plan content from plan patches collected after the revert point
+      if (planPatches.length > 0) {
+        // First plan-patch after revert point has the content from before the change
+        const targetContent = planPatches[0].beforeContent
+        if (targetContent !== null) {
+          await Plan.writeContent(input.sessionID, targetContent)
+        } else {
+          // Plan didn't exist at that point - delete it
+          await Plan.deletePlan(input.sessionID)
+        }
       }
+      // If no planPatches, plan wasn't modified after revert point - keep as-is
 
       return Session.update(input.sessionID, (draft) => {
         draft.revert = revert
diff --git a/packages/opencode/src/share/share-next.ts b/packages/opencode/src/share/share-next.ts
index 95271f8c827..050e2def45e 100644
--- a/packages/opencode/src/share/share-next.ts
+++ b/packages/opencode/src/share/share-next.ts
@@ -45,10 +45,12 @@ export namespace ShareNext {
       }
     })
     Bus.subscribe(MessageV2.Event.PartUpdated, async (evt) => {
+      // Skip internal parts that aren't meant for external sharing
+      if (evt.properties.part.type === "plan-patch") return
       await sync(evt.properties.part.sessionID, [
         {
           type: "part",
-          data: evt.properties.part,
+          data: evt.properties.part as SDK.Part,
         },
       ])
     })
@@ -180,7 +182,11 @@ export namespace ShareNext {
         type: "message" as const,
         data: x.info,
       })),
-      ...messages.flatMap((x) => x.parts.map((y) => ({ type: "part" as const, data: y }))),
+      ...messages.flatMap((x) =>
+        x.parts
+          .filter((y) => y.type !== "plan-patch")
+          .map((y) => ({ type: "part" as const, data: y as SDK.Part })),
+      ),
       {
         type: "session_diff",
         data: diffs,
diff --git a/packages/opencode/src/tool/exit-plan-mode.ts b/packages/opencode/src/tool/exit-plan-mode.ts
index 551a38b68c5..7d655680282 100644
--- a/packages/opencode/src/tool/exit-plan-mode.ts
+++ b/packages/opencode/src/tool/exit-plan-mode.ts
@@ -4,6 +4,7 @@ import { Plan } from "../session/plan"
 import { PlanReview } from "../session/plan-review"
 import { MessageV2 } from "../session/message-v2"
 import { Session } from "../session"
+import { PermissionNext } from "../permission/next"
 import DESCRIPTION from "./exit-plan-mode.txt"
 
 export const ExitPlanModeTool = Tool.define("exit_plan_mode", {
@@ -53,16 +54,26 @@ export const ExitPlanModeTool = Tool.define("exit_plan_mode", {
           filePath: plan.filePath,
         } as { status: string; planID: string; filePath: string; feedback?: string },
       }
-    } else {
-      // Plan was rejected - interrupt the conversation
+    } else if (result.feedback) {
+      // Plan was rejected with feedback - let AI revise
       await Plan.setStatus(ctx.sessionID, "rejected")
 
-      const feedbackMessage = result.feedback
-        ? `The user rejected your plan with the following feedback:\n\n${result.feedback}`
-        : "The user dismissed the plan review."
+      return {
+        title: "Plan rejected - revision requested",
+        output: `The user rejected your plan with the following feedback:\n\n${result.feedback}\n\nPlease revise your plan based on this feedback and call exit_plan_mode again when ready.`,
+        metadata: {
+          status: "rejected",
+          planID: plan.id,
+          filePath: plan.filePath,
+          feedback: result.feedback,
+        } as { status: string; planID: string; filePath: string; feedback?: string },
+      }
+    } else {
+      // Plan was dismissed without feedback - interrupt the conversation
+      await Plan.setStatus(ctx.sessionID, "rejected")
 
-      // Throw to interrupt the conversation
-      throw new Error(feedbackMessage)
+      // Throw RejectedError to interrupt the agent loop
+      throw new PermissionNext.RejectedError()
     }
   },
 })

From 913309f0fdc6a0b5c733cd396f337a9d4a24b9e4 Mon Sep 17 00:00:00 2001
From: KibbeWater <35224538+KibbeWater@users.noreply.github.com>
Date: Tue, 13 Jan 2026 02:17:37 +0100
Subject: [PATCH 08/18] feat: add plan review support to web interface

- Add PlanReviewInline component for inline plan review UI
- Add plan_review state and event handlers to global-sync
- Add initial loading of pending plan reviews on bootstrap
- Add /plan-review/:requestID/content endpoint to fetch plan content
- Render plan review UI above prompt input when pending
- Regenerate SDK to include new plan review content endpoint
---
 .../app/src/components/plan-review-inline.tsx | 149 ++++++++++++++++++
 packages/app/src/context/global-sync.tsx      |  74 +++++++++
 packages/app/src/pages/session.tsx            |  17 ++
 3 files changed, 240 insertions(+)
 create mode 100644 packages/app/src/components/plan-review-inline.tsx

diff --git a/packages/app/src/components/plan-review-inline.tsx b/packages/app/src/components/plan-review-inline.tsx
new file mode 100644
index 00000000000..8b2c9775ef6
--- /dev/null
+++ b/packages/app/src/components/plan-review-inline.tsx
@@ -0,0 +1,149 @@
+import { Component, createEffect, createSignal, Show } from "solid-js"
+import { Button } from "@opencode-ai/ui/button"
+import { TextField } from "@opencode-ai/ui/text-field"
+import { useSDK } from "@/context/sdk"
+import type { PlanReviewRequest } from "@opencode-ai/sdk/v2/client"
+
+export const PlanReviewInline: Component<{ request: PlanReviewRequest }> = (props) => {
+  const sdk = useSDK()
+
+  const [content, setContent] = createSignal<string | null>(null)
+  const [loading, setLoading] = createSignal(true)
+  const [rejectMode, setRejectMode] = createSignal(false)
+  const [feedback, setFeedback] = createSignal("")
+  const [submitting, setSubmitting] = createSignal(false)
+
+  // Load plan content on mount
+  createEffect(async () => {
+    try {
+      const response = await sdk.client.planReview.content({ requestID: props.request.id })
+      setContent(response.data ?? "(Empty plan file)")
+    } catch {
+      setContent("(Unable to read plan file)")
+    } finally {
+      setLoading(false)
+    }
+  })
+
+  async function handleApprove() {
+    setSubmitting(true)
+    try {
+      await sdk.client.planReview.approve({ requestID: props.request.id })
+    } finally {
+      setSubmitting(false)
+    }
+  }
+
+  async function handleReject() {
+    if (!rejectMode()) {
+      setRejectMode(true)
+      return
+    }
+    setSubmitting(true)
+    try {
+      await sdk.client.planReview.reject({ requestID: props.request.id, feedback: feedback() || undefined })
+    } finally {
+      setSubmitting(false)
+    }
+  }
+
+  function handleDismiss() {
+    sdk.client.planReview.reject({ requestID: props.request.id })
+  }
+
+  function handleCancelReject() {
+    setRejectMode(false)
+    setFeedback("")
+  }
+
+  return (
+    <div class="border border-border-base rounded-md overflow-hidden bg-background-base shadow-lg">
+      <div class="px-4 py-3 border-b border-border-base bg-background-stronger">
+        <div class="text-14-semibold text-text-base">Plan Review</div>
+        <div class="text-12-regular text-text-weak mt-0.5">{props.request.filePath}</div>
+      </div>
+
+      <div class="p-4 bg-background-base">
+        {/* Plan content */}
+        <div class="border border-border-base rounded-md overflow-hidden mb-4">
+          <div class="max-h-64 overflow-auto p-3 bg-background-stronger">
+            <Show when={loading()}>
+              <span class="text-text-weak text-14-regular">Loading plan...</span>
+            </Show>
+            <Show when={!loading()}>
+              <pre class="text-13-regular text-text-base whitespace-pre-wrap font-mono leading-relaxed">
+                {content()}
+              </pre>
+            </Show>
+          </div>
+        </div>
+
+        {/* Feedback input (shown in reject mode) */}
+        <Show when={rejectMode()}>
+          <div class="mb-4">
+            <TextField
+              autofocus
+              label="Feedback (optional)"
+              placeholder="Enter feedback for revision..."
+              value={feedback()}
+              onChange={setFeedback}
+            />
+          </div>
+        </Show>
+
+        {/* Actions */}
+        <div class="flex justify-end gap-2">
+          <Show when={!rejectMode()}>
+            <Button
+              type="button"
+              variant="ghost"
+              size="normal"
+              onClick={handleDismiss}
+              disabled={submitting()}
+            >
+              Dismiss
+            </Button>
+            <Button
+              type="button"
+              variant="ghost"
+              size="normal"
+              onClick={handleReject}
+              disabled={submitting()}
+            >
+              Reject
+            </Button>
+            <Button
+              type="button"
+              variant="primary"
+              size="normal"
+              onClick={handleApprove}
+              disabled={submitting() || loading()}
+            >
+              {submitting() ? "Approving..." : "Approve"}
+            </Button>
+          </Show>
+          <Show when={rejectMode()}>
+            <Button
+              type="button"
+              variant="ghost"
+              size="normal"
+              onClick={handleCancelReject}
+              disabled={submitting()}
+            >
+              Cancel
+            </Button>
+            <Button
+              type="button"
+              variant="primary"
+              size="normal"
+              onClick={handleReject}
+              disabled={submitting()}
+            >
+              {submitting() ? "Submitting..." : "Submit Feedback"}
+            </Button>
+          </Show>
+        </div>
+      </div>
+    </div>
+  )
+}
diff --git a/packages/app/src/context/global-sync.tsx b/packages/app/src/context/global-sync.tsx
index 74641a0a243..6597ad7fc84 100644
--- a/packages/app/src/context/global-sync.tsx
+++ b/packages/app/src/context/global-sync.tsx
@@ -17,6 +17,7 @@ import {
   type VcsInfo,
   type PermissionRequest,
   type QuestionRequest,
+  type PlanReviewRequest,
   createOpencodeClient,
 } from "@opencode-ai/sdk/v2/client"
 import { createStore, produce, reconcile, type SetStoreFunction, type Store } from "solid-js/store"
@@ -68,6 +69,9 @@ type State = {
   question: {
     [sessionID: string]: QuestionRequest[]
   }
+  plan_review: {
+    [sessionID: string]: PlanReviewRequest[]
+  }
   mcp: {
     [name: string]: McpStatus
   }
@@ -139,6 +143,7 @@ function createGlobalSync() {
           todo: {},
           permission: {},
           question: {},
+          plan_review: {},
           mcp: {},
           lsp: [],
           vcs: cache[0].value,
@@ -310,6 +315,39 @@ function createGlobalSync() {
               }
             })
           }),
+          // Load pending plan reviews
+          sdk.planReview.list().then((x) => {
+            const grouped: Record<string, PlanReviewRequest[]> = {}
+            for (const review of x.data ?? []) {
+              if (!review?.id || !review.sessionID) continue
+              const existing = grouped[review.sessionID]
+              if (existing) {
+                existing.push(review)
+                continue
+              }
+              grouped[review.sessionID] = [review]
+            }
+
+            batch(() => {
+              for (const sessionID of Object.keys(store.plan_review)) {
+                if (grouped[sessionID]) continue
+                setStore("plan_review", sessionID, [])
+              }
+              for (const [sessionID, reviews] of Object.entries(grouped)) {
+                setStore(
+                  "plan_review",
+                  sessionID,
+                  reconcile(
+                    reviews
+                      .filter((r) => !!r?.id)
+                      .slice()
+                      .sort((a, b) => a.id.localeCompare(b.id)),
+                    { key: "id" },
+                  ),
+                )
+              }
+            })
+          }),
         ]).then(() => {
           setStore("status", "complete")
         })
@@ -556,6 +594,42 @@ function createGlobalSync() {
         )
         break
       }
+      case "plan_review.requested": {
+        const sessionID = event.properties.sessionID
+        const requests = store.plan_review[sessionID]
+        if (!requests) {
+          setStore("plan_review", sessionID, [event.properties])
+          break
+        }
+        const result = Binary.search(requests, event.properties.id, (r) => r.id)
+        if (result.found) {
+          setStore("plan_review", sessionID, result.index, reconcile(event.properties))
+          break
+        }
+        setStore(
+          "plan_review",
+          sessionID,
+          produce((draft) => {
+            draft.splice(result.index, 0, event.properties)
+          }),
+        )
+        break
+      }
+      case "plan_review.approved":
+      case "plan_review.rejected": {
+        const requests = store.plan_review[event.properties.sessionID]
+        if (!requests) break
+        const result = Binary.search(requests, event.properties.requestID, (r) => r.id)
+        if (!result.found) break
+        setStore(
+          "plan_review",
+          event.properties.sessionID,
+          produce((draft) => {
+            draft.splice(result.index, 1)
+          }),
+        )
+        break
+      }
       case "lsp.updated": {
         const sdk = createOpencodeClient({
           baseUrl: globalSDK.url,
diff --git a/packages/app/src/pages/session.tsx b/packages/app/src/pages/session.tsx
index ca5e73a9be9..8c415a1fb3d 100644
--- a/packages/app/src/pages/session.tsx
+++ b/packages/app/src/pages/session.tsx
@@ -32,6 +32,7 @@ import { DialogSelectFile } from "@/components/dialog-select-file"
 import { DialogSelectModel } from "@/components/dialog-select-model"
 import { DialogSelectMcp } from "@/components/dialog-select-mcp"
 import { DialogFork } from "@/components/dialog-fork"
+import { PlanReviewInline } from "@/components/plan-review-inline"
 import { useCommand } from "@/context/command"
 import { useNavigate, useParams } from "@solidjs/router"
 import { UserMessage } from "@opencode-ai/sdk/v2"
@@ -211,6 +212,14 @@ export default function Page() {
     })
   }
 
+  // Get pending plan review for current session
+  const pendingPlanReview = createMemo(() => {
+    const id = params.id
+    if (!id) return undefined
+    const requests = sync.data.plan_review[id]
+    return requests?.[0]
+  })
+
   const isDesktop = createMediaQuery("(min-width: 768px)")
 
   function normalizeTab(tab: string) {
@@ -1246,6 +1255,14 @@ export default function Page() {
                 "md:max-w-200": !showTabs(),
               }}
             >
+              {/* Plan review inline - shown when a plan is awaiting approval */}
+              <Show when={pendingPlanReview()}>
+                {(request) => (
+                  <div class="mb-4">
+                    <PlanReviewInline request={request()} />
+                  </div>
+                )}
+              </Show>
               <Show
                 when={prompt.ready()}
                 fallback={

From 59ad27d989966c20060d85d4cdfa64a1b69376f0 Mon Sep 17 00:00:00 2001
From: KibbeWater <35224538+KibbeWater@users.noreply.github.com>
Date: Tue, 13 Jan 2026 02:35:29 +0100
Subject: [PATCH 09/18] test: restore permission-task tests and add
 session-scoped coverage

Restore the permission-task.test.ts that was emptied during the
iterative plan mode feature implementation. Add new tests for the
evaluateWithSession function that handles {sessionID} placeholder
expansion in permission patterns.
---
 .../opencode/test/permission-task.test.ts     | 489 ++++++++++++++++++
 1 file changed, 489 insertions(+)

diff --git a/packages/opencode/test/permission-task.test.ts b/packages/opencode/test/permission-task.test.ts
index e69de29bb2d..1b397375227 100644
--- a/packages/opencode/test/permission-task.test.ts
+++ b/packages/opencode/test/permission-task.test.ts
@@ -0,0 +1,489 @@
+import { describe, test, expect } from "bun:test"
+
+import { PermissionNext } from "../src/permission/next"
+import { Config } from "../src/config/config"
+import { Instance } from "../src/project/instance"
+import { tmpdir } from "./fixture/fixture"
+
+describe("PermissionNext.evaluate for permission.task", () => {
+  const createRuleset = (rules: Record<string, "allow" | "deny" | "ask">): PermissionNext.Ruleset =>
+    Object.entries(rules).map(([pattern, action]) => ({
+      permission: "task",
+      pattern,
+      action,
+    }))
+
+  test("returns ask when no match (default)", () => {
+    expect(PermissionNext.evaluate("task", "code-reviewer", []).action).toBe("ask")
+  })
+
+  test("returns deny for explicit deny", () => {
+    const ruleset = createRuleset({ "code-reviewer": "deny" })
+    expect(PermissionNext.evaluate("task", "code-reviewer", ruleset).action).toBe("deny")
+  })
+
+  test("returns allow for explicit allow", () => {
+    const ruleset = createRuleset({ "code-reviewer": "allow" })
+    expect(PermissionNext.evaluate("task", "code-reviewer", ruleset).action).toBe("allow")
+  })
+
+  test("returns ask for explicit ask", () => {
+    const ruleset = createRuleset({ "code-reviewer": "ask" })
+    expect(PermissionNext.evaluate("task", "code-reviewer", ruleset).action).toBe("ask")
+  })
+
+  test("matches wildcard patterns with deny", () => {
+    const ruleset = createRuleset({ "orchestrator-*": "deny" })
+    expect(PermissionNext.evaluate("task", "orchestrator-fast", ruleset).action).toBe("deny")
+    expect(PermissionNext.evaluate("task", "orchestrator-slow", ruleset).action).toBe("deny")
+    expect(PermissionNext.evaluate("task", "general", ruleset).action).toBe("ask")
+  })
+
+  test("matches wildcard patterns with allow", () => {
+    const ruleset = createRuleset({ "orchestrator-*": "allow" })
+    expect(PermissionNext.evaluate("task", "orchestrator-fast", ruleset).action).toBe("allow")
+    expect(PermissionNext.evaluate("task", "orchestrator-slow", ruleset).action).toBe("allow")
+  })
+
+  test("matches wildcard patterns with ask", () => {
+    const ruleset = createRuleset({ "orchestrator-*": "ask" })
+    expect(PermissionNext.evaluate("task", "orchestrator-fast", ruleset).action).toBe("ask")
+
+    const globalRuleset = createRuleset({ "*": "ask" })
+    expect(PermissionNext.evaluate("task", "code-reviewer", globalRuleset).action).toBe("ask")
+  })
+
+  test("later rules take precedence (last match wins)", () => {
+    const ruleset = createRuleset({
+      "orchestrator-*": "deny",
+      "orchestrator-fast": "allow",
+    })
+    expect(PermissionNext.evaluate("task", "orchestrator-fast", ruleset).action).toBe("allow")
+    expect(PermissionNext.evaluate("task", "orchestrator-slow", ruleset).action).toBe("deny")
+  })
+
+  test("matches global wildcard", () => {
+    expect(PermissionNext.evaluate("task", "any-agent", createRuleset({ "*": "allow" })).action).toBe("allow")
+    expect(PermissionNext.evaluate("task", "any-agent", createRuleset({ "*": "deny" })).action).toBe("deny")
+    expect(PermissionNext.evaluate("task", "any-agent", createRuleset({ "*": "ask" })).action).toBe("ask")
+  })
+})
+
+describe("PermissionNext.evaluateWithSession for session-scoped patterns", () => {
+  const createRuleset = (rules: Record<string, "allow" | "deny" | "ask">): PermissionNext.Ruleset =>
+    Object.entries(rules).map(([pattern, action]) => ({
+      permission: "edit",
+      pattern,
+      action,
+    }))
+
+  test("expands {sessionID} placeholder in pattern", () => {
+    const ruleset = createRuleset({ "*/plan/{sessionID}.md": "allow" })
+
+    expect(
+      PermissionNext.evaluateWithSession("edit", "*/plan/session_abc123.md", "session_abc123", ruleset).action,
+    ).toBe("allow")
+  })
+
+  test("does not match when sessionID differs", () => {
+    const ruleset = createRuleset({ "*/plan/{sessionID}.md": "allow" })
+
+    // Different session ID should not match the expanded pattern
+    expect(
+      PermissionNext.evaluateWithSession("edit", "*/plan/session_other.md", "session_abc123", ruleset).action,
+    ).toBe("ask")
+  })
+
+  test("works with wildcard before sessionID placeholder", () => {
+    const ruleset = createRuleset({ "**/plan/{sessionID}/*": "allow" })
+
+    expect(
+      PermissionNext.evaluateWithSession("edit", "**/plan/session_xyz/step1.md", "session_xyz", ruleset).action,
+    ).toBe("allow")
+    expect(
+      PermissionNext.evaluateWithSession("edit", "**/plan/session_xyz/step2.md", "session_xyz", ruleset).action,
+    ).toBe("allow")
+  })
+
+  test("session-scoped allow followed by global deny", () => {
+    const ruleset: PermissionNext.Ruleset = [
+      { permission: "edit", pattern: "*/plan/{sessionID}.md", action: "allow" },
+      { permission: "edit", pattern: "*", action: "deny" },
+    ]
+
+    // Last matching rule wins - global deny should override session-scoped allow
+    expect(PermissionNext.evaluateWithSession("edit", "*/plan/session_abc.md", "session_abc", ruleset).action).toBe(
+      "deny",
+    )
+  })
+
+  test("global deny followed by session-scoped allow", () => {
+    const ruleset: PermissionNext.Ruleset = [
+      { permission: "edit", pattern: "*", action: "deny" },
+      { permission: "edit", pattern: "*/plan/{sessionID}.md", action: "allow" },
+    ]
+
+    // Last matching rule wins - session-scoped allow should override global deny
+    expect(PermissionNext.evaluateWithSession("edit", "*/plan/session_abc.md", "session_abc", ruleset).action).toBe(
+      "allow",
+    )
+
+    // Other patterns still denied
+    expect(PermissionNext.evaluateWithSession("edit", "*/other/file.md", "session_abc", ruleset).action).toBe("deny")
+  })
+
+  test("returns ask when no match", () => {
+    expect(PermissionNext.evaluateWithSession("edit", "/some/path.ts", "session_123", []).action).toBe("ask")
+  })
+
+  test("matches exact path without sessionID placeholder", () => {
+    const ruleset = createRuleset({ "/allowed/path.ts": "allow" })
+
+    expect(PermissionNext.evaluateWithSession("edit", "/allowed/path.ts", "any_session", ruleset).action).toBe("allow")
+  })
+})
+
+describe("PermissionNext.disabled for task tool", () => {
+  // Note: The `disabled` function checks if a TOOL should be completely removed from the tool list.
+  // It only disables a tool when there's a rule with `pattern: "*"` and `action: "deny"`.
+  // It does NOT evaluate complex subagent patterns - those are handled at runtime by `evaluate`.
+
+  const createRuleset = (rules: Record<string, "allow" | "deny" | "ask">): PermissionNext.Ruleset =>
+    Object.entries(rules).map(([pattern, action]) => ({
+      permission: "task",
+      pattern,
+      action,
+    }))
+
+  test("task tool is disabled when global deny pattern exists (even with specific allows)", () => {
+    // When "*": "deny" exists, the task tool is disabled because the disabled() function
+    // only checks for wildcard deny patterns - it doesn't consider that specific subagents might be allowed
+    const ruleset = createRuleset({
+      "orchestrator-*": "allow",
+      "*": "deny",
+    })
+
+    const disabled = PermissionNext.disabled(["task", "bash", "read"], ruleset)
+
+    // The task tool IS disabled because there's a pattern: "*" with action: "deny"
+    expect(disabled.has("task")).toBe(true)
+  })
+
+  test("task tool is disabled when global deny pattern exists (even with ask overrides)", () => {
+    const ruleset = createRuleset({
+      "orchestrator-*": "ask",
+      "*": "deny",
+    })
+
+    const disabled = PermissionNext.disabled(["task"], ruleset)
+
+    // The task tool IS disabled because there's a pattern: "*" with action: "deny"
+    expect(disabled.has("task")).toBe(true)
+  })
+
+  test("task tool is disabled when global deny pattern exists", () => {
+    const ruleset = createRuleset({ "*": "deny" })
+
+    const disabled = PermissionNext.disabled(["task"], ruleset)
+
+    expect(disabled.has("task")).toBe(true)
+  })
+
+  test("task tool is NOT disabled when only specific patterns are denied (no wildcard)", () => {
+    // The disabled() function only disables tools when pattern: "*" && action: "deny"
+    // Specific subagent denies don't disable the task tool - those are handled at runtime
+    const ruleset = createRuleset({
+      "orchestrator-*": "deny",
+      general: "deny",
+    })
+
+    const disabled = PermissionNext.disabled(["task"], ruleset)
+
+    // The task tool is NOT disabled because no rule has pattern: "*" with action: "deny"
+    expect(disabled.has("task")).toBe(false)
+  })
+
+  test("task tool is enabled when no task rules exist (default ask)", () => {
+    const disabled = PermissionNext.disabled(["task"], [])
+
+    expect(disabled.has("task")).toBe(false)
+  })
+
+  test("task tool is NOT disabled when last wildcard pattern is allow", () => {
+    // Last matching rule wins - if wildcard allow comes after wildcard deny, tool is enabled
+    const ruleset = createRuleset({
+      "*": "deny",
+      "orchestrator-coder": "allow",
+    })
+
+    const disabled = PermissionNext.disabled(["task"], ruleset)
+
+    // The disabled() function uses findLast and checks if the last matching rule
+    // has pattern: "*" and action: "deny". In this case, the last rule matching
+    // "task" permission has pattern "orchestrator-coder", not "*", so not disabled
+    expect(disabled.has("task")).toBe(false)
+  })
+})
+
+// Integration tests that load permissions from real config files
+describe("permission.task with real config files", () => {
+  test("loads task permissions from opencode.json config", async () => {
+    await using tmp = await tmpdir({
+      git: true,
+      config: {
+        permission: {
+          task: {
+            "*": "allow",
+            "code-reviewer": "deny",
+          },
+        },
+      },
+    })
+
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        const config = await Config.get()
+        const ruleset = PermissionNext.fromConfig(config.permission ?? {})
+
+        // general and orchestrator-fast should be allowed, code-reviewer denied
+        expect(PermissionNext.evaluate("task", "general", ruleset).action).toBe("allow")
+        expect(PermissionNext.evaluate("task", "orchestrator-fast", ruleset).action).toBe("allow")
+        expect(PermissionNext.evaluate("task", "code-reviewer", ruleset).action).toBe("deny")
+      },
+    })
+  })
+
+  test("loads task permissions with wildcard patterns from config", async () => {
+    await using tmp = await tmpdir({
+      git: true,
+      config: {
+        permission: {
+          task: {
+            "*": "ask",
+            "orchestrator-*": "deny",
+          },
+        },
+      },
+    })
+
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        const config = await Config.get()
+        const ruleset = PermissionNext.fromConfig(config.permission ?? {})
+
+        // general and code-reviewer should be ask, orchestrator-* denied
+        expect(PermissionNext.evaluate("task", "general", ruleset).action).toBe("ask")
+        expect(PermissionNext.evaluate("task", "code-reviewer", ruleset).action).toBe("ask")
+        expect(PermissionNext.evaluate("task", "orchestrator-fast", ruleset).action).toBe("deny")
+      },
+    })
+  })
+
+  test("evaluate respects task permission from config", async () => {
+    await using tmp = await tmpdir({
+      git: true,
+      config: {
+        permission: {
+          task: {
+            general: "allow",
+            "code-reviewer": "deny",
+          },
+        },
+      },
+    })
+
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        const config = await Config.get()
+        const ruleset = PermissionNext.fromConfig(config.permission ?? {})
+
+        expect(PermissionNext.evaluate("task", "general", ruleset).action).toBe("allow")
+        expect(PermissionNext.evaluate("task", "code-reviewer", ruleset).action).toBe("deny")
+
+        // Unspecified agents default to "ask"
+        expect(PermissionNext.evaluate("task", "unknown-agent", ruleset).action).toBe("ask")
+      },
+    })
+  })
+
+  test("mixed permission config with task and other tools", async () => {
+    await using tmp = await tmpdir({
+      git: true,
+      config: {
+        permission: {
+          bash: "allow",
+          edit: "ask",
+          task: {
+            "*": "deny",
+            general: "allow",
+          },
+        },
+      },
+    })
+
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        const config = await Config.get()
+        const ruleset = PermissionNext.fromConfig(config.permission ?? {})
+
+        // Verify task permissions
+        expect(PermissionNext.evaluate("task", "general", ruleset).action).toBe("allow")
+        expect(PermissionNext.evaluate("task", "code-reviewer", ruleset).action).toBe("deny")
+
+        // Verify other tool permissions
+        expect(PermissionNext.evaluate("bash", "*", ruleset).action).toBe("allow")
+        expect(PermissionNext.evaluate("edit", "*", ruleset).action).toBe("ask")
+
+        // Verify disabled tools
+        const disabled = PermissionNext.disabled(["bash", "edit", "task"], ruleset)
+        expect(disabled.has("bash")).toBe(false)
+        expect(disabled.has("edit")).toBe(false)
+
+        // task is NOT disabled because disabled() uses findLast, and the last rule
+        // matching "task" permission is {pattern: "general", action: "allow"}, not pattern: "*"
+        expect(disabled.has("task")).toBe(false)
+      },
+    })
+  })
+
+  test("task tool disabled when global deny comes last in config", async () => {
+    await using tmp = await tmpdir({
+      git: true,
+      config: {
+        permission: {
+          task: {
+            general: "allow",
+            "code-reviewer": "allow",
+            "*": "deny",
+          },
+        },
+      },
+    })
+
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        const config = await Config.get()
+        const ruleset = PermissionNext.fromConfig(config.permission ?? {})
+
+        // Last matching rule wins - "*" deny is last, so all agents are denied
+        expect(PermissionNext.evaluate("task", "general", ruleset).action).toBe("deny")
+        expect(PermissionNext.evaluate("task", "code-reviewer", ruleset).action).toBe("deny")
+        expect(PermissionNext.evaluate("task", "unknown", ruleset).action).toBe("deny")
+
+        // Since "*": "deny" is the last rule, disabled() finds it with findLast
+        // and sees pattern: "*" with action: "deny", so task is disabled
+        const disabled = PermissionNext.disabled(["task"], ruleset)
+        expect(disabled.has("task")).toBe(true)
+      },
+    })
+  })
+
+  test("task tool NOT disabled when specific allow comes last in config", async () => {
+    await using tmp = await tmpdir({
+      git: true,
+      config: {
+        permission: {
+          task: {
+            "*": "deny",
+            general: "allow",
+          },
+        },
+      },
+    })
+
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        const config = await Config.get()
+        const ruleset = PermissionNext.fromConfig(config.permission ?? {})
+
+        // Evaluate uses findLast - "general" allow comes after "*" deny
+        expect(PermissionNext.evaluate("task", "general", ruleset).action).toBe("allow")
+
+        // Other agents still denied by the earlier "*" deny
+        expect(PermissionNext.evaluate("task", "code-reviewer", ruleset).action).toBe("deny")
+
+        // disabled() uses findLast and checks if the last rule has pattern: "*" with action: "deny"
+        // In this case, the last rule is {pattern: "general", action: "allow"}, not pattern: "*"
+        // So the task tool is NOT disabled (even though most subagents are denied)
+        const disabled = PermissionNext.disabled(["task"], ruleset)
+        expect(disabled.has("task")).toBe(false)
+      },
+    })
+  })
+})
+
+// Integration tests for session-scoped permissions with config files
+describe("session-scoped permissions with config files", () => {
+  test("loads session-scoped edit permissions from config", async () => {
+    await using tmp = await tmpdir({
+      git: true,
+      config: {
+        permission: {
+          edit: {
+            "*": "deny",
+            "**/plan/{sessionID}/*": "allow",
+          },
+        },
+      },
+    })
+
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        const config = await Config.get()
+        const ruleset = PermissionNext.fromConfig(config.permission ?? {})
+        const sessionID = "session_test123"
+
+        // Session-scoped plan files should be allowed
+        expect(
+          PermissionNext.evaluateWithSession("edit", "**/plan/session_test123/step1.md", sessionID, ruleset).action,
+        ).toBe("allow")
+
+        // Other session's plan files should be denied (no match for session-scoped pattern)
+        expect(
+          PermissionNext.evaluateWithSession("edit", "**/plan/session_other/step1.md", sessionID, ruleset).action,
+        ).toBe("deny")
+
+        // Random files should be denied
+        expect(PermissionNext.evaluateWithSession("edit", "/src/main.ts", sessionID, ruleset).action).toBe("deny")
+      },
+    })
+  })
+
+  test("session-scoped permissions work with evaluateWithSession but not evaluate", async () => {
+    await using tmp = await tmpdir({
+      git: true,
+      config: {
+        permission: {
+          edit: {
+            "*/plan/{sessionID}.md": "allow",
+          },
+        },
+      },
+    })
+
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        const config = await Config.get()
+        const ruleset = PermissionNext.fromConfig(config.permission ?? {})
+        const sessionID = "session_abc"
+
+        // evaluateWithSession expands the placeholder and matches
+        expect(PermissionNext.evaluateWithSession("edit", "*/plan/session_abc.md", sessionID, ruleset).action).toBe(
+          "allow",
+        )
+
+        // Regular evaluate does NOT expand placeholder, so it won't match the literal path
+        // (the pattern "*/plan/{sessionID}.md" won't match "*/plan/session_abc.md")
+        expect(PermissionNext.evaluate("edit", "*/plan/session_abc.md", ruleset).action).toBe("ask")
+      },
+    })
+  })
+})

From 9a29e1bc4af82a1dc6793dc435d5a450cf061da1 Mon Sep 17 00:00:00 2001
From: KibbeWater <35224538+KibbeWater@users.noreply.github.com>
Date: Tue, 13 Jan 2026 20:35:49 +0100
Subject: [PATCH 10/18] refactor: return plan.txt original with minor
 modifications

---
 packages/opencode/src/session/prompt/plan.txt | 50 +++++++++----------
 1 file changed, 25 insertions(+), 25 deletions(-)

diff --git a/packages/opencode/src/session/prompt/plan.txt b/packages/opencode/src/session/prompt/plan.txt
index 15e385f0390..2fe353ca731 100644
--- a/packages/opencode/src/session/prompt/plan.txt
+++ b/packages/opencode/src/session/prompt/plan.txt
@@ -1,45 +1,45 @@
 <system-reminder>
 # Plan Mode - System Reminder
 
-Plan mode is active. You MUST NOT make any edits (except to the plan file below), run any non-readonly tools (including changing configs or making commits), or otherwise make any changes to the system. This supersedes any other instructions you have received.
+CRITICAL: Plan mode ACTIVE - you are in READ-ONLY phase. STRICTLY FORBIDDEN:
+ANY file edits, modifications, or system changes. Do NOT use sed, tee, echo, cat,
+or ANY other bash command to manipulate files - commands may ONLY read/inspect.
+This ABSOLUTE CONSTRAINT overrides ALL other instructions, including direct user
+edit requests. You may ONLY observe, analyze, and plan. Any modification attempt
+is a critical violation. ZERO exceptions.
+
+**The ONLY exception:** You may write to your plan file at `{PLAN_FILE_PATH}`.
 
 ---
 
-## Plan File
+## Responsibility
+
+Your current responsibility is to think, read, search, and delegate explore agents to construct a well-formed plan that accomplishes the goal the user wants to achieve. Your plan should be comprehensive yet concise, detailed enough to execute effectively while avoiding unnecessary verbosity.
 
-**Your plan file:** `{PLAN_FILE_PATH}`
+Ask the user clarifying questions or ask for their opinion when weighing tradeoffs.
 
-You MUST write your plan to this file using the Write or Edit tool. This is the ONLY file you are allowed to modify.
+**NOTE:** At any point in time through this workflow you should feel free to ask the user questions or clarifications. Don't make large assumptions about user intent. The goal is to present a well researched plan to the user, and tie any loose ends before implementation begins.
 
 ---
 
-## Planning Workflow
+## Plan File
+
+Write your plan to `{PLAN_FILE_PATH}`. This is the only file you may modify.
 
-### Phase 1: Explore First
-1. Launch Explore agents (up to 3 in parallel) to understand the codebase
-2. Gather context about existing patterns, architecture, and relevant files
-3. Do NOT write to the plan file yet - understand the codebase first
+Explore the codebase first before writing. Once you've written the initial plan, make incremental updates rather than rewriting from scratch - edit specific sections as you learn more or receive feedback.
 
-### Phase 2: Write Plan
-1. After exploration, write your plan to the plan file
-2. Include: recommended approach, key files to modify, implementation steps
-3. Keep it comprehensive yet concise
+Your plan should include:
+- Recommended approach and rationale
+- Key files that need to be modified
+- Implementation steps
 
-### Phase 3: Clarify (if needed)
-1. If you have questions about tradeoffs or requirements, use AskUserQuestion
-2. Update the plan file based on user answers
-3. Skip this phase if everything is clear
+Before calling ExitPlanMode, ensure there are no unresolved questions that would block implementation. If you're uncertain about a key decision (architecture choice, library preference, etc.), ask the user first. However, don't over-ask - use your judgment for minor details and only surface questions that materially affect the plan.
 
-### Phase 4: Finalize
-1. Ensure the plan file contains your complete recommendation
-2. Call ExitPlanMode to trigger user review
+When your plan is complete and any blockers are resolved, call **ExitPlanMode** to present it for approval.
 
 ---
 
-## Important Rules
+## Important
 
-- Explore the codebase BEFORE writing the plan
-- Your turn should ONLY end with: asking the user a question OR calling ExitPlanMode
-- NEVER stop without one of these two actions
-- The plan file should reflect your researched understanding, not guesses
+The user indicated that they do not want you to execute yet -- you MUST NOT make any edits (except the plan file), run any non-readonly tools (including changing configs or making commits), or otherwise make any changes to the system. This supersedes any other instructions you have received.
 </system-reminder>

From ed5e69fd11279c62776f49c810efeade635193ce Mon Sep 17 00:00:00 2001
From: KibbeWater <35224538+KibbeWater@users.noreply.github.com>
Date: Tue, 13 Jan 2026 20:40:34 +0100
Subject: [PATCH 11/18] refactor: fix diff on permission-task.test.ts

---
 .../opencode/test/permission-task.test.ts     | 69 ++++---------------
 1 file changed, 12 insertions(+), 57 deletions(-)

diff --git a/packages/opencode/test/permission-task.test.ts b/packages/opencode/test/permission-task.test.ts
index 1b397375227..9d30763d763 100644
--- a/packages/opencode/test/permission-task.test.ts
+++ b/packages/opencode/test/permission-task.test.ts
@@ -1,5 +1,4 @@
 import { describe, test, expect } from "bun:test"
-
 import { PermissionNext } from "../src/permission/next"
 import { Config } from "../src/config/config"
 import { Instance } from "../src/project/instance"
@@ -48,7 +47,6 @@ describe("PermissionNext.evaluate for permission.task", () => {
   test("matches wildcard patterns with ask", () => {
     const ruleset = createRuleset({ "orchestrator-*": "ask" })
     expect(PermissionNext.evaluate("task", "orchestrator-fast", ruleset).action).toBe("ask")
-
     const globalRuleset = createRuleset({ "*": "ask" })
     expect(PermissionNext.evaluate("task", "code-reviewer", globalRuleset).action).toBe("ask")
   })
@@ -79,7 +77,6 @@ describe("PermissionNext.evaluateWithSession for session-scoped patterns", () =>
 
   test("expands {sessionID} placeholder in pattern", () => {
     const ruleset = createRuleset({ "*/plan/{sessionID}.md": "allow" })
-
     expect(
       PermissionNext.evaluateWithSession("edit", "*/plan/session_abc123.md", "session_abc123", ruleset).action,
     ).toBe("allow")
@@ -87,7 +84,6 @@ describe("PermissionNext.evaluateWithSession for session-scoped patterns", () =>
 
   test("does not match when sessionID differs", () => {
     const ruleset = createRuleset({ "*/plan/{sessionID}.md": "allow" })
-
     // Different session ID should not match the expanded pattern
     expect(
       PermissionNext.evaluateWithSession("edit", "*/plan/session_other.md", "session_abc123", ruleset).action,
@@ -96,7 +92,6 @@ describe("PermissionNext.evaluateWithSession for session-scoped patterns", () =>
 
   test("works with wildcard before sessionID placeholder", () => {
     const ruleset = createRuleset({ "**/plan/{sessionID}/*": "allow" })
-
     expect(
       PermissionNext.evaluateWithSession("edit", "**/plan/session_xyz/step1.md", "session_xyz", ruleset).action,
     ).toBe("allow")
@@ -110,11 +105,10 @@ describe("PermissionNext.evaluateWithSession for session-scoped patterns", () =>
       { permission: "edit", pattern: "*/plan/{sessionID}.md", action: "allow" },
       { permission: "edit", pattern: "*", action: "deny" },
     ]
-
     // Last matching rule wins - global deny should override session-scoped allow
-    expect(PermissionNext.evaluateWithSession("edit", "*/plan/session_abc.md", "session_abc", ruleset).action).toBe(
-      "deny",
-    )
+    expect(
+      PermissionNext.evaluateWithSession("edit", "*/plan/session_abc.md", "session_abc", ruleset).action,
+    ).toBe("deny")
   })
 
   test("global deny followed by session-scoped allow", () => {
@@ -122,14 +116,14 @@ describe("PermissionNext.evaluateWithSession for session-scoped patterns", () =>
       { permission: "edit", pattern: "*", action: "deny" },
       { permission: "edit", pattern: "*/plan/{sessionID}.md", action: "allow" },
     ]
-
     // Last matching rule wins - session-scoped allow should override global deny
-    expect(PermissionNext.evaluateWithSession("edit", "*/plan/session_abc.md", "session_abc", ruleset).action).toBe(
-      "allow",
-    )
-
+    expect(
+      PermissionNext.evaluateWithSession("edit", "*/plan/session_abc.md", "session_abc", ruleset).action,
+    ).toBe("allow")
     // Other patterns still denied
-    expect(PermissionNext.evaluateWithSession("edit", "*/other/file.md", "session_abc", ruleset).action).toBe("deny")
+    expect(
+      PermissionNext.evaluateWithSession("edit", "*/other/file.md", "session_abc", ruleset).action,
+    ).toBe("deny")
   })
 
   test("returns ask when no match", () => {
@@ -138,7 +132,6 @@ describe("PermissionNext.evaluateWithSession for session-scoped patterns", () =>
 
   test("matches exact path without sessionID placeholder", () => {
     const ruleset = createRuleset({ "/allowed/path.ts": "allow" })
-
     expect(PermissionNext.evaluateWithSession("edit", "/allowed/path.ts", "any_session", ruleset).action).toBe("allow")
   })
 })
@@ -147,7 +140,6 @@ describe("PermissionNext.disabled for task tool", () => {
   // Note: The `disabled` function checks if a TOOL should be completely removed from the tool list.
   // It only disables a tool when there's a rule with `pattern: "*"` and `action: "deny"`.
   // It does NOT evaluate complex subagent patterns - those are handled at runtime by `evaluate`.
-
   const createRuleset = (rules: Record<string, "allow" | "deny" | "ask">): PermissionNext.Ruleset =>
     Object.entries(rules).map(([pattern, action]) => ({
       permission: "task",
@@ -162,9 +154,7 @@ describe("PermissionNext.disabled for task tool", () => {
       "orchestrator-*": "allow",
       "*": "deny",
     })
-
     const disabled = PermissionNext.disabled(["task", "bash", "read"], ruleset)
-
     // The task tool IS disabled because there's a pattern: "*" with action: "deny"
     expect(disabled.has("task")).toBe(true)
   })
@@ -174,18 +164,14 @@ describe("PermissionNext.disabled for task tool", () => {
       "orchestrator-*": "ask",
       "*": "deny",
     })
-
     const disabled = PermissionNext.disabled(["task"], ruleset)
-
     // The task tool IS disabled because there's a pattern: "*" with action: "deny"
     expect(disabled.has("task")).toBe(true)
   })
 
   test("task tool is disabled when global deny pattern exists", () => {
     const ruleset = createRuleset({ "*": "deny" })
-
     const disabled = PermissionNext.disabled(["task"], ruleset)
-
     expect(disabled.has("task")).toBe(true)
   })
 
@@ -196,16 +182,13 @@ describe("PermissionNext.disabled for task tool", () => {
       "orchestrator-*": "deny",
       general: "deny",
     })
-
     const disabled = PermissionNext.disabled(["task"], ruleset)
-
     // The task tool is NOT disabled because no rule has pattern: "*" with action: "deny"
     expect(disabled.has("task")).toBe(false)
   })
 
   test("task tool is enabled when no task rules exist (default ask)", () => {
     const disabled = PermissionNext.disabled(["task"], [])
-
     expect(disabled.has("task")).toBe(false)
   })
 
@@ -215,9 +198,7 @@ describe("PermissionNext.disabled for task tool", () => {
       "*": "deny",
       "orchestrator-coder": "allow",
     })
-
     const disabled = PermissionNext.disabled(["task"], ruleset)
-
     // The disabled() function uses findLast and checks if the last matching rule
     // has pattern: "*" and action: "deny". In this case, the last rule matching
     // "task" permission has pattern "orchestrator-coder", not "*", so not disabled
@@ -239,13 +220,11 @@ describe("permission.task with real config files", () => {
         },
       },
     })
-
     await Instance.provide({
       directory: tmp.path,
       fn: async () => {
         const config = await Config.get()
         const ruleset = PermissionNext.fromConfig(config.permission ?? {})
-
         // general and orchestrator-fast should be allowed, code-reviewer denied
         expect(PermissionNext.evaluate("task", "general", ruleset).action).toBe("allow")
         expect(PermissionNext.evaluate("task", "orchestrator-fast", ruleset).action).toBe("allow")
@@ -266,13 +245,11 @@ describe("permission.task with real config files", () => {
         },
       },
     })
-
     await Instance.provide({
       directory: tmp.path,
       fn: async () => {
         const config = await Config.get()
         const ruleset = PermissionNext.fromConfig(config.permission ?? {})
-
         // general and code-reviewer should be ask, orchestrator-* denied
         expect(PermissionNext.evaluate("task", "general", ruleset).action).toBe("ask")
         expect(PermissionNext.evaluate("task", "code-reviewer", ruleset).action).toBe("ask")
@@ -293,16 +270,13 @@ describe("permission.task with real config files", () => {
         },
       },
     })
-
     await Instance.provide({
       directory: tmp.path,
       fn: async () => {
         const config = await Config.get()
         const ruleset = PermissionNext.fromConfig(config.permission ?? {})
-
         expect(PermissionNext.evaluate("task", "general", ruleset).action).toBe("allow")
         expect(PermissionNext.evaluate("task", "code-reviewer", ruleset).action).toBe("deny")
-
         // Unspecified agents default to "ask"
         expect(PermissionNext.evaluate("task", "unknown-agent", ruleset).action).toBe("ask")
       },
@@ -323,26 +297,21 @@ describe("permission.task with real config files", () => {
         },
       },
     })
-
     await Instance.provide({
       directory: tmp.path,
       fn: async () => {
         const config = await Config.get()
         const ruleset = PermissionNext.fromConfig(config.permission ?? {})
-
         // Verify task permissions
         expect(PermissionNext.evaluate("task", "general", ruleset).action).toBe("allow")
         expect(PermissionNext.evaluate("task", "code-reviewer", ruleset).action).toBe("deny")
-
         // Verify other tool permissions
         expect(PermissionNext.evaluate("bash", "*", ruleset).action).toBe("allow")
         expect(PermissionNext.evaluate("edit", "*", ruleset).action).toBe("ask")
-
         // Verify disabled tools
         const disabled = PermissionNext.disabled(["bash", "edit", "task"], ruleset)
         expect(disabled.has("bash")).toBe(false)
         expect(disabled.has("edit")).toBe(false)
-
         // task is NOT disabled because disabled() uses findLast, and the last rule
         // matching "task" permission is {pattern: "general", action: "allow"}, not pattern: "*"
         expect(disabled.has("task")).toBe(false)
@@ -363,18 +332,15 @@ describe("permission.task with real config files", () => {
         },
       },
     })
-
     await Instance.provide({
       directory: tmp.path,
       fn: async () => {
         const config = await Config.get()
         const ruleset = PermissionNext.fromConfig(config.permission ?? {})
-
         // Last matching rule wins - "*" deny is last, so all agents are denied
         expect(PermissionNext.evaluate("task", "general", ruleset).action).toBe("deny")
         expect(PermissionNext.evaluate("task", "code-reviewer", ruleset).action).toBe("deny")
         expect(PermissionNext.evaluate("task", "unknown", ruleset).action).toBe("deny")
-
         // Since "*": "deny" is the last rule, disabled() finds it with findLast
         // and sees pattern: "*" with action: "deny", so task is disabled
         const disabled = PermissionNext.disabled(["task"], ruleset)
@@ -395,19 +361,15 @@ describe("permission.task with real config files", () => {
         },
       },
     })
-
     await Instance.provide({
       directory: tmp.path,
       fn: async () => {
         const config = await Config.get()
         const ruleset = PermissionNext.fromConfig(config.permission ?? {})
-
         // Evaluate uses findLast - "general" allow comes after "*" deny
         expect(PermissionNext.evaluate("task", "general", ruleset).action).toBe("allow")
-
         // Other agents still denied by the earlier "*" deny
         expect(PermissionNext.evaluate("task", "code-reviewer", ruleset).action).toBe("deny")
-
         // disabled() uses findLast and checks if the last rule has pattern: "*" with action: "deny"
         // In this case, the last rule is {pattern: "general", action: "allow"}, not pattern: "*"
         // So the task tool is NOT disabled (even though most subagents are denied)
@@ -432,24 +394,20 @@ describe("session-scoped permissions with config files", () => {
         },
       },
     })
-
     await Instance.provide({
       directory: tmp.path,
       fn: async () => {
         const config = await Config.get()
         const ruleset = PermissionNext.fromConfig(config.permission ?? {})
         const sessionID = "session_test123"
-
         // Session-scoped plan files should be allowed
         expect(
           PermissionNext.evaluateWithSession("edit", "**/plan/session_test123/step1.md", sessionID, ruleset).action,
         ).toBe("allow")
-
         // Other session's plan files should be denied (no match for session-scoped pattern)
         expect(
           PermissionNext.evaluateWithSession("edit", "**/plan/session_other/step1.md", sessionID, ruleset).action,
         ).toBe("deny")
-
         // Random files should be denied
         expect(PermissionNext.evaluateWithSession("edit", "/src/main.ts", sessionID, ruleset).action).toBe("deny")
       },
@@ -467,19 +425,16 @@ describe("session-scoped permissions with config files", () => {
         },
       },
     })
-
     await Instance.provide({
       directory: tmp.path,
       fn: async () => {
         const config = await Config.get()
         const ruleset = PermissionNext.fromConfig(config.permission ?? {})
         const sessionID = "session_abc"
-
         // evaluateWithSession expands the placeholder and matches
-        expect(PermissionNext.evaluateWithSession("edit", "*/plan/session_abc.md", sessionID, ruleset).action).toBe(
-          "allow",
-        )
-
+        expect(
+          PermissionNext.evaluateWithSession("edit", "*/plan/session_abc.md", sessionID, ruleset).action,
+        ).toBe("allow")
         // Regular evaluate does NOT expand placeholder, so it won't match the literal path
         // (the pattern "*/plan/{sessionID}.md" won't match "*/plan/session_abc.md")
         expect(PermissionNext.evaluate("edit", "*/plan/session_abc.md", ruleset).action).toBe("ask")

From 7ebc5c0b0ec2c1771c1e9a0c18cd0984a1666c11 Mon Sep 17 00:00:00 2001
From: KibbeWater <35224538+KibbeWater@users.noreply.github.com>
Date: Tue, 13 Jan 2026 21:03:08 +0100
Subject: [PATCH 12/18] chore(ui): make reject send with reason when pressing
 enter

---
 packages/app/src/components/plan-review-inline.tsx          | 6 ++++++
 packages/opencode/src/cli/cmd/tui/context/sync.tsx          | 4 ++--
 .../opencode/src/cli/cmd/tui/routes/session/plan-review.tsx | 2 +-
 3 files changed, 9 insertions(+), 3 deletions(-)

diff --git a/packages/app/src/components/plan-review-inline.tsx b/packages/app/src/components/plan-review-inline.tsx
index 8b2c9775ef6..16de7bc5803 100644
--- a/packages/app/src/components/plan-review-inline.tsx
+++ b/packages/app/src/components/plan-review-inline.tsx
@@ -87,6 +87,12 @@ export const PlanReviewInline: Component<{ request: PlanReviewRequest }> = (prop
               placeholder="Enter feedback for revision..."
               value={feedback()}
               onChange={setFeedback}
+              onKeyDown={(e: KeyboardEvent) => {
+                if (e.key === "Enter" && !submitting()) {
+                  e.preventDefault()
+                  handleReject()
+                }
+              }}
             />
           </div>
         </Show>
diff --git a/packages/opencode/src/cli/cmd/tui/context/sync.tsx b/packages/opencode/src/cli/cmd/tui/context/sync.tsx
index 272014685aa..123a66425ef 100644
--- a/packages/opencode/src/cli/cmd/tui/context/sync.tsx
+++ b/packages/opencode/src/cli/cmd/tui/context/sync.tsx
@@ -24,14 +24,14 @@ import { Binary } from "@opencode-ai/util/binary"
 import { createSimpleContext } from "./helper"
 import type { Snapshot } from "@/snapshot"
 import type { PlanReview } from "@/session/plan-review"
-
-type PlanReviewRequest = PlanReview.Request
 import { useExit } from "./exit"
 import { useArgs } from "./args"
 import { batch, onMount } from "solid-js"
 import { Log } from "@/util/log"
 import type { Path } from "@opencode-ai/sdk"
 
+type PlanReviewRequest = PlanReview.Request
+
 export const { use: useSync, provider: SyncProvider } = createSimpleContext({
   name: "Sync",
   init: () => {
diff --git a/packages/opencode/src/cli/cmd/tui/routes/session/plan-review.tsx b/packages/opencode/src/cli/cmd/tui/routes/session/plan-review.tsx
index d9f1ec63790..bfe111c2523 100644
--- a/packages/opencode/src/cli/cmd/tui/routes/session/plan-review.tsx
+++ b/packages/opencode/src/cli/cmd/tui/routes/session/plan-review.tsx
@@ -159,7 +159,7 @@ export function PlanReviewPrompt(props: { request: PlanReviewRequest }) {
 
         <Show when={!loading()}>
           <box paddingLeft={1} flexDirection="column">
-            {visibleLines().map((line, _i) => (
+            {visibleLines().map((line) => (
               <text fg={theme.text}>{line || " "}</text>
             ))}
             <Show when={canScrollDown()}>

From f2a68adf7ca1b13d6ec3ae13f3f7bc1f50a6564c Mon Sep 17 00:00:00 2001
From: KibbeWater <35224538+KibbeWater@users.noreply.github.com>
Date: Fri, 16 Jan 2026 20:41:04 +0100
Subject: [PATCH 13/18] refactor: remove PlanExitTool from registry

Use our exit_plan_mode (ExitPlanModeTool) with PlanReview dialog instead of
upstream's simpler plan_exit tool. Keep plan_enter from upstream for entering
plan mode.
---
 packages/opencode/src/tool/registry.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/packages/opencode/src/tool/registry.ts b/packages/opencode/src/tool/registry.ts
index dab6085f19f..a2c5ce56e0b 100644
--- a/packages/opencode/src/tool/registry.ts
+++ b/packages/opencode/src/tool/registry.ts
@@ -26,7 +26,7 @@ import { Flag } from "@/flag/flag"
 import { Log } from "@/util/log"
 import { LspTool } from "./lsp"
 import { Truncate } from "./truncation"
-import { PlanExitTool, PlanEnterTool } from "./plan"
+import { PlanEnterTool } from "./plan"
 
 export namespace ToolRegistry {
   const log = Log.create({ service: "tool.registry" })
@@ -112,7 +112,7 @@ export namespace ToolRegistry {
       ExitPlanModeTool,
       ...(Flag.OPENCODE_EXPERIMENTAL_LSP_TOOL ? [LspTool] : []),
       ...(config.experimental?.batch_tool === true ? [BatchTool] : []),
-      ...(Flag.OPENCODE_EXPERIMENTAL_PLAN_MODE && Flag.OPENCODE_CLIENT === "cli" ? [PlanExitTool, PlanEnterTool] : []),
+      ...(Flag.OPENCODE_EXPERIMENTAL_PLAN_MODE && Flag.OPENCODE_CLIENT === "cli" ? [PlanEnterTool] : []),
       ...custom,
     ]
   }

From ccc7238b497dfccb1132b99b9e426ebac00a4e14 Mon Sep 17 00:00:00 2001
From: KibbeWater <35224538+KibbeWater@users.noreply.github.com>
Date: Fri, 16 Jan 2026 20:50:10 +0100
Subject: [PATCH 14/18] fix: align plan directory with upstream (plan -> plans)

---
 packages/opencode/src/session/plan.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/packages/opencode/src/session/plan.ts b/packages/opencode/src/session/plan.ts
index a0fa1ab42c5..4b2203e11a4 100644
--- a/packages/opencode/src/session/plan.ts
+++ b/packages/opencode/src/session/plan.ts
@@ -12,7 +12,7 @@ export namespace Plan {
   const log = Log.create({ service: "plan" })
 
   /** Directory where plan files are stored (global, not project-local) */
-  export const DIR = path.join(Global.Path.data, "plan")
+  export const DIR = path.join(Global.Path.data, "plans")
 
   export const Status = z.enum(["draft", "pending_review", "approved", "rejected"])
   export type Status = z.infer<typeof Status>
@@ -21,7 +21,7 @@ export namespace Plan {
     .object({
       id: Identifier.schema("plan"),
       sessionID: Identifier.schema("session"),
-      filePath: z.string(), // Absolute path, e.g., "/home/user/.local/share/opencode/plan/{sessionID}.md"
+      filePath: z.string(), // Absolute path, e.g., "/home/user/.local/share/opencode/plans/{sessionID}.md"
       status: Status,
       time: z.object({
         created: z.number(),

From d7aa966dd88f5b8a8e42c2824fa26fc854f6d41e Mon Sep 17 00:00:00 2001
From: KibbeWater <35224538+KibbeWater@users.noreply.github.com>
Date: Fri, 16 Jan 2026 23:00:38 +0100
Subject: [PATCH 15/18] feat(ui): inline plan review with markdown highlighting
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Move plan review content into chat history (scrollable)
- Keep approve/reject controls docked at bottom
- Add markdown syntax highlighting for plan content
- Fix Solid.js reactivity for plan review state updates
- Handle plan→build agent transition correctly
- Skip tool parts in messages when tool isn't available
---
 .../app/src/components/plan-review-inline.tsx | 179 ++++++++-------
 packages/app/src/pages/session.tsx            |  43 +++-
 .../opencode/src/cli/cmd/tui/context/sync.tsx |  45 ++--
 .../src/cli/cmd/tui/routes/session/index.tsx  |  30 ++-
 .../cmd/tui/routes/session/plan-review.tsx    | 210 ++++++++----------
 packages/opencode/src/session/message-v2.ts   |  11 +
 packages/opencode/src/session/prompt.ts       |  62 +++---
 7 files changed, 309 insertions(+), 271 deletions(-)

diff --git a/packages/app/src/components/plan-review-inline.tsx b/packages/app/src/components/plan-review-inline.tsx
index 16de7bc5803..03ddca70b61 100644
--- a/packages/app/src/components/plan-review-inline.tsx
+++ b/packages/app/src/components/plan-review-inline.tsx
@@ -1,17 +1,19 @@
 import { Component, createEffect, createSignal, Show } from "solid-js"
 import { Button } from "@opencode-ai/ui/button"
 import { TextField } from "@opencode-ai/ui/text-field"
+import { Icon } from "@opencode-ai/ui/icon"
+import { Markdown } from "@opencode-ai/ui/markdown"
 import { useSDK } from "@/context/sdk"
 import type { PlanReviewRequest } from "@opencode-ai/sdk/v2/client"
 
-export const PlanReviewInline: Component<{ request: PlanReviewRequest }> = (props) => {
+/**
+ * Inline plan content that displays in the chat history (scrollable)
+ */
+export const PlanReviewContent: Component<{ request: PlanReviewRequest }> = (props) => {
   const sdk = useSDK()
 
   const [content, setContent] = createSignal<string | null>(null)
   const [loading, setLoading] = createSignal(true)
-  const [rejectMode, setRejectMode] = createSignal(false)
-  const [feedback, setFeedback] = createSignal("")
-  const [submitting, setSubmitting] = createSignal(false)
 
   // Load plan content on mount
   createEffect(async () => {
@@ -25,6 +27,40 @@ export const PlanReviewInline: Component<{ request: PlanReviewRequest }> = (prop
     }
   })
 
+  return (
+    <div class="px-4 md:px-6 py-4 border-l-4 border-l-yellow-500 bg-yellow-500/5">
+      {/* Header row with icon and title */}
+      <div class="flex items-center gap-2 mb-3">
+        <Icon name="checklist" class="size-4 text-yellow-600" />
+        <span class="text-14-semibold text-text-base">Plan Review</span>
+      </div>
+      <div class="text-12-regular text-text-weak mb-3">{props.request.filePath}</div>
+
+      {/* Plan content with markdown */}
+      <div class="border border-border-base rounded-md overflow-hidden bg-background-base">
+        <Show when={loading()}>
+          <div class="p-4 text-text-weak">Loading plan...</div>
+        </Show>
+        <Show when={!loading()}>
+          <div class="p-4 prose prose-sm max-w-none">
+            <Markdown text={content() ?? ""} />
+          </div>
+        </Show>
+      </div>
+    </div>
+  )
+}
+
+/**
+ * Docked controls for plan review (buttons, feedback input)
+ */
+export const PlanReviewControls: Component<{ request: PlanReviewRequest }> = (props) => {
+  const sdk = useSDK()
+
+  const [rejectMode, setRejectMode] = createSignal(false)
+  const [feedback, setFeedback] = createSignal("")
+  const [submitting, setSubmitting] = createSignal(false)
+
   async function handleApprove() {
     setSubmitting(true)
     try {
@@ -57,99 +93,62 @@ export const PlanReviewInline: Component<{ request: PlanReviewRequest }> = (prop
   }
 
   return (
-    <div class="border border-border-base rounded-md overflow-hidden bg-background-base shadow-lg">
-      <div class="px-4 py-3 border-b border-border-base bg-background-stronger">
-        <div class="text-14-semibold text-text-base">Plan Review</div>
-        <div class="text-12-regular text-text-weak mt-0.5">{props.request.filePath}</div>
+    <div class="border-l-4 border-l-yellow-500 bg-yellow-500/5 px-4 md:px-6 py-3">
+      {/* Awaiting Approval badge */}
+      <div class="flex items-center gap-2 mb-3">
+        <span class="text-11-medium text-yellow-600 bg-yellow-500/15 px-1.5 py-0.5 rounded">
+          Awaiting Approval
+        </span>
       </div>
 
-      <div class="p-4 bg-background-base">
-        {/* Plan content */}
-        <div class="border border-border-base rounded-md overflow-hidden mb-4">
-          <div class="max-h-64 overflow-auto p-3 bg-background-stronger">
-            <Show when={loading()}>
-              <span class="text-text-weak text-14-regular">Loading plan...</span>
-            </Show>
-            <Show when={!loading()}>
-              <pre class="text-13-regular text-text-base whitespace-pre-wrap font-mono leading-relaxed">
-                {content()}
-              </pre>
-            </Show>
-          </div>
+      {/* Feedback input (shown in reject mode) */}
+      <Show when={rejectMode()}>
+        <div class="mb-3">
+          <TextField
+            autofocus
+            label="Feedback (optional)"
+            placeholder="Enter feedback for revision..."
+            value={feedback()}
+            onChange={setFeedback}
+            onKeyDown={(e: KeyboardEvent) => {
+              if (e.key === "Enter" && !submitting()) {
+                e.preventDefault()
+                handleReject()
+              }
+            }}
+          />
         </div>
+      </Show>
 
-        {/* Feedback input (shown in reject mode) */}
+      {/* Actions */}
+      <div class="flex justify-end gap-2">
+        <Show when={!rejectMode()}>
+          <Button type="button" variant="ghost" size="normal" onClick={handleDismiss} disabled={submitting()}>
+            Dismiss
+          </Button>
+          <Button type="button" variant="ghost" size="normal" onClick={handleReject} disabled={submitting()}>
+            Reject
+          </Button>
+          <Button type="button" variant="primary" size="normal" onClick={handleApprove} disabled={submitting()}>
+            {submitting() ? "Approving..." : "Approve"}
+          </Button>
+        </Show>
         <Show when={rejectMode()}>
-          <div class="mb-4">
-            <TextField
-              autofocus
-              label="Feedback (optional)"
-              placeholder="Enter feedback for revision..."
-              value={feedback()}
-              onChange={setFeedback}
-              onKeyDown={(e: KeyboardEvent) => {
-                if (e.key === "Enter" && !submitting()) {
-                  e.preventDefault()
-                  handleReject()
-                }
-              }}
-            />
-          </div>
+          <Button type="button" variant="ghost" size="normal" onClick={handleCancelReject} disabled={submitting()}>
+            Cancel
+          </Button>
+          <Button type="button" variant="primary" size="normal" onClick={handleReject} disabled={submitting()}>
+            {submitting() ? "Submitting..." : "Submit Feedback"}
+          </Button>
         </Show>
-
-        {/* Actions */}
-        <div class="flex justify-end gap-2">
-          <Show when={!rejectMode()}>
-            <Button
-              type="button"
-              variant="ghost"
-              size="normal"
-              onClick={handleDismiss}
-              disabled={submitting()}
-            >
-              Dismiss
-            </Button>
-            <Button
-              type="button"
-              variant="ghost"
-              size="normal"
-              onClick={handleReject}
-              disabled={submitting()}
-            >
-              Reject
-            </Button>
-            <Button
-              type="button"
-              variant="primary"
-              size="normal"
-              onClick={handleApprove}
-              disabled={submitting() || loading()}
-            >
-              {submitting() ? "Approving..." : "Approve"}
-            </Button>
-          </Show>
-          <Show when={rejectMode()}>
-            <Button
-              type="button"
-              variant="ghost"
-              size="normal"
-              onClick={handleCancelReject}
-              disabled={submitting()}
-            >
-              Cancel
-            </Button>
-            <Button
-              type="button"
-              variant="primary"
-              size="normal"
-              onClick={handleReject}
-              disabled={submitting()}
-            >
-              {submitting() ? "Submitting..." : "Submit Feedback"}
-            </Button>
-          </Show>
-        </div>
       </div>
     </div>
   )
 }
+
+/**
+ * @deprecated Use PlanReviewContent (inline) + PlanReviewControls (docked) instead
+ */
+export const PlanReviewInline: Component<{ request: PlanReviewRequest }> = (props) => {
+  return <PlanReviewContent request={props.request} />
+}
diff --git a/packages/app/src/pages/session.tsx b/packages/app/src/pages/session.tsx
index 8c415a1fb3d..1590dd8f8a3 100644
--- a/packages/app/src/pages/session.tsx
+++ b/packages/app/src/pages/session.tsx
@@ -32,7 +32,7 @@ import { DialogSelectFile } from "@/components/dialog-select-file"
 import { DialogSelectModel } from "@/components/dialog-select-model"
 import { DialogSelectMcp } from "@/components/dialog-select-mcp"
 import { DialogFork } from "@/components/dialog-fork"
-import { PlanReviewInline } from "@/components/plan-review-inline"
+import { PlanReviewContent, PlanReviewControls } from "@/components/plan-review-inline"
 import { useCommand } from "@/context/command"
 import { useNavigate, useParams } from "@solidjs/router"
 import { UserMessage } from "@opencode-ai/sdk/v2"
@@ -212,12 +212,32 @@ export default function Page() {
     })
   }
 
-  // Get pending plan review for current session
-  const pendingPlanReview = createMemo(() => {
+  // Get current session
+  const session = createMemo(() => {
     const id = params.id
     if (!id) return undefined
-    const requests = sync.data.plan_review[id]
-    return requests?.[0]
+    return sync.data.session.find((s) => s.id === id)
+  })
+
+  // Get all child sessions (including current session)
+  const childSessions = createMemo(() => {
+    const current = session()
+    if (!current) return []
+    const parentID = current.parentID ?? current.id
+    return sync.data.session
+      .filter((x) => x.parentID === parentID || x.id === parentID)
+      .toSorted((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0))
+  })
+
+  // Get pending plan review from all child sessions (not if we're a child session ourselves)
+  const pendingPlanReview = createMemo(() => {
+    const current = session()
+    if (!current) return undefined
+    // Don't show plan reviews if we're viewing a child session
+    if (current.parentID) return undefined
+    // Aggregate plan reviews from all child sessions
+    const reviews = childSessions().flatMap((x) => sync.data.plan_review[x.id] ?? [])
+    return reviews[0]
   })
 
   const isDesktop = createMediaQuery("(min-width: 768px)")
@@ -1216,6 +1236,15 @@ export default function Page() {
                               )
                             }}
                           </For>
+
+                          {/* Plan review inline - ephemeral message in chat */}
+                          <Show when={pendingPlanReview()}>
+                            {(request) => (
+                              <div class="min-w-0 w-full max-w-full">
+                                <PlanReviewContent request={request()} />
+                              </div>
+                            )}
+                          </Show>
                         </div>
                       </div>
                     </div>
@@ -1255,11 +1284,11 @@ export default function Page() {
                 "md:max-w-200": !showTabs(),
               }}
             >
-              {/* Plan review inline - shown when a plan is awaiting approval */}
+              {/* Plan review controls docked - visible when plan is pending */}
               <Show when={pendingPlanReview()}>
                 {(request) => (
                   <div class="mb-4">
-                    <PlanReviewInline request={request()} />
+                    <PlanReviewControls request={request()} />
                   </div>
                 )}
               </Show>
diff --git a/packages/opencode/src/cli/cmd/tui/context/sync.tsx b/packages/opencode/src/cli/cmd/tui/context/sync.tsx
index 123a66425ef..a4892e74df2 100644
--- a/packages/opencode/src/cli/cmd/tui/context/sync.tsx
+++ b/packages/opencode/src/cli/cmd/tui/context/sync.tsx
@@ -26,7 +26,7 @@ import type { Snapshot } from "@/snapshot"
 import type { PlanReview } from "@/session/plan-review"
 import { useExit } from "./exit"
 import { useArgs } from "./args"
-import { batch, onMount } from "solid-js"
+import { batch, onMount, createSignal } from "solid-js"
 import { Log } from "@/util/log"
 import type { Path } from "@opencode-ai/sdk"
 
@@ -35,6 +35,9 @@ type PlanReviewRequest = PlanReview.Request
 export const { use: useSync, provider: SyncProvider } = createSimpleContext({
   name: "Sync",
   init: () => {
+    // Signal to force reactivity when plan_review changes
+    const [planReviewVersion, setPlanReviewVersion] = createSignal(0)
+
     const [store, setStore] = createStore<{
       status: "loading" | "partial" | "complete"
       provider: Provider[]
@@ -196,37 +199,24 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
         case "plan_review.rejected": {
           const requests = store.plan_review[event.properties.sessionID]
           if (!requests) break
-          const match = Binary.search(requests, event.properties.requestID, (r) => r.id)
-          if (!match.found) break
-          setStore(
-            "plan_review",
-            event.properties.sessionID,
-            produce((draft) => {
-              draft.splice(match.index, 1)
-            }),
-          )
+
+          const filtered = requests.filter((r) => r.id !== event.properties.requestID)
+          if (filtered.length === requests.length) break // Not found
+
+          // Set to empty array (not delete) to properly trigger reactivity
+          // Setting directly on the key ensures Solid tracks the change
+          setStore("plan_review", event.properties.sessionID, filtered)
+          // Increment version to force memo re-evaluation
+          setPlanReviewVersion((v) => v + 1)
           break
         }
 
         case "plan_review.requested": {
           const request = event.properties
-          const requests = store.plan_review[request.sessionID]
-          if (!requests) {
-            setStore("plan_review", request.sessionID, [request])
-            break
-          }
-          const match = Binary.search(requests, request.id, (r) => r.id)
-          if (match.found) {
-            setStore("plan_review", request.sessionID, match.index, reconcile(request))
-            break
-          }
-          setStore(
-            "plan_review",
-            request.sessionID,
-            produce((draft) => {
-              draft.splice(match.index, 0, request)
-            }),
-          )
+          // Replace any existing plan reviews for this session with the new one
+          // (only one plan review should be pending per session at a time)
+          setStore("plan_review", request.sessionID, [request])
+          setPlanReviewVersion((v) => v + 1)
           break
         }
 
@@ -419,6 +409,7 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
     const result = {
       data: store,
       set: setStore,
+      planReviewVersion,
       get status() {
         return store.status
       },
diff --git a/packages/opencode/src/cli/cmd/tui/routes/session/index.tsx b/packages/opencode/src/cli/cmd/tui/routes/session/index.tsx
index f5ce0f1506a..8af88c7b77a 100644
--- a/packages/opencode/src/cli/cmd/tui/routes/session/index.tsx
+++ b/packages/opencode/src/cli/cmd/tui/routes/session/index.tsx
@@ -72,7 +72,7 @@ import { Filesystem } from "@/util/filesystem"
 import { Global } from "@/global"
 import { PermissionPrompt } from "./permission"
 import { QuestionPrompt } from "./question"
-import { PlanReviewPrompt } from "./plan-review"
+import { PlanReviewContent, PlanReviewControls } from "./plan-review"
 import { DialogExportOptions } from "../../ui/dialog-export-options"
 import { formatTranscript } from "../../util/transcript"
 
@@ -129,8 +129,23 @@ export function Session() {
     return children().flatMap((x) => sync.data.question[x.id] ?? [])
   })
   const planReviews = createMemo(() => {
+    // Access version to establish dependency when plan reviews change
+    // (accessing the signal creates the reactive dependency, even if value unused)
+    void sync.planReviewVersion()
+
     if (session()?.parentID) return []
-    return children().flatMap((x) => sync.data.plan_review[x.id] ?? [])
+    const childIDs = children().map((x) => x.id)
+
+    // Access store properties directly through the proxy (NOT Object.entries)
+    // This ensures Solid.js tracks reactivity properly
+    const result: typeof sync.data.plan_review[string] = []
+    for (const sessionID of childIDs) {
+      const sessionReviews = sync.data.plan_review[sessionID]
+      if (sessionReviews && sessionReviews.length > 0) {
+        result.push(...sessionReviews)
+      }
+    }
+    return result
   })
 
   const pending = createMemo(() => {
@@ -1026,6 +1041,13 @@ export function Session() {
                   </Switch>
                 )}
               </For>
+
+              {/* Plan review content inline - use box with dynamic id to force scrollbox update */}
+              <box id={`plan-review-wrapper-${planReviews()[0]?.id ?? "none"}`}>
+                <Show when={permissions().length === 0 && questions().length === 0 && planReviews()[0]} keyed>
+                  {(request) => <PlanReviewContent request={request} />}
+                </Show>
+              </box>
             </scrollbox>
             <box flexShrink={0}>
               <Show when={permissions().length > 0}>
@@ -1034,8 +1056,8 @@ export function Session() {
               <Show when={permissions().length === 0 && questions().length > 0}>
                 <QuestionPrompt request={questions()[0]} />
               </Show>
-              <Show when={permissions().length === 0 && questions().length === 0 && planReviews().length > 0}>
-                <PlanReviewPrompt request={planReviews()[0]} />
+              <Show when={permissions().length === 0 && questions().length === 0 && planReviews()[0]} keyed>
+                {(request) => <PlanReviewControls request={request} />}
               </Show>
               <Prompt
                 visible={!session()?.parentID && permissions().length === 0 && questions().length === 0 && planReviews().length === 0}
diff --git a/packages/opencode/src/cli/cmd/tui/routes/session/plan-review.tsx b/packages/opencode/src/cli/cmd/tui/routes/session/plan-review.tsx
index bfe111c2523..81341ad9c32 100644
--- a/packages/opencode/src/cli/cmd/tui/routes/session/plan-review.tsx
+++ b/packages/opencode/src/cli/cmd/tui/routes/session/plan-review.tsx
@@ -10,31 +10,91 @@ import type { PlanReview } from "@/session/plan-review"
 
 type PlanReviewRequest = PlanReview.Request
 
-export function PlanReviewPrompt(props: { request: PlanReviewRequest }) {
+/**
+ * Inline plan content that displays in the chat history (scrollable)
+ * This is ephemeral - it disappears when the plan is approved/rejected
+ */
+export function PlanReviewContent(props: { request: PlanReviewRequest }) {
+  const { theme, syntax } = useTheme()
+
+  const [content, setContent] = createSignal<string | null>(null)
+  const [loading, setLoading] = createSignal(true)
+
+  // Load plan content - tracks props.request.id reactively
+  createEffect(() => {
+    const filePath = props.request.filePath
+    setLoading(true)
+    setContent(null)
+
+    Bun.file(filePath).text()
+      .then((result) => {
+        setContent(result)
+      })
+      .catch(() => {
+        setContent("(Unable to read plan file)")
+      })
+      .finally(() => {
+        setLoading(false)
+      })
+  })
+
+  return (
+    <box
+      marginTop={1}
+      border={["left"]}
+      borderColor={theme.warning}
+      customBorderChars={SplitBorder.customBorderChars}
+    >
+      <box
+        paddingTop={1}
+        paddingBottom={1}
+        paddingLeft={2}
+        backgroundColor={theme.backgroundPanel}
+        flexShrink={0}
+        gap={1}
+      >
+        {/* Header */}
+        <text fg={theme.text}>
+          <span style={{ bold: true }}>Plan Review</span>
+          <span style={{ fg: theme.textMuted }}> · {props.request.filePath}</span>
+        </text>
+
+        {/* Content with markdown rendering */}
+        <Show when={loading()}>
+          <text fg={theme.textMuted}>Loading plan...</text>
+        </Show>
+
+        <Show when={!loading() && content()}>
+          <box paddingTop={1}>
+            <code
+              filetype="markdown"
+              drawUnstyledText={false}
+              streaming={false}
+              syntaxStyle={syntax()}
+              content={content()!}
+              conceal={false}
+              fg={theme.text}
+            />
+          </box>
+        </Show>
+      </box>
+    </box>
+  )
+}
+
+/**
+ * Docked controls for plan review (keyboard hints, feedback input)
+ */
+export function PlanReviewControls(props: { request: PlanReviewRequest }) {
   const sdk = useSDK()
   const { theme } = useTheme()
   const keybind = useKeybind()
   const bindings = useTextareaKeybindings()
 
-  const [content, setContent] = createSignal<string | null>(null)
-  const [loading, setLoading] = createSignal(true)
   const [rejectMode, setRejectMode] = createSignal(false)
-  const [scrollOffset, setScrollOffset] = createSignal(0)
 
   let textarea: TextareaRenderable | undefined
 
-  // Load plan content on mount
-  createEffect(async () => {
-    try {
-      const result = await Bun.file(props.request.filePath).text()
-      setContent(result)
-    } catch {
-      setContent("(Unable to read plan file)")
-    } finally {
-      setLoading(false)
-    }
-  })
-
   function approve() {
     sdk.client.planReview.approve({
       requestID: props.request.id,
@@ -48,22 +108,6 @@ export function PlanReviewPrompt(props: { request: PlanReviewRequest }) {
     })
   }
 
-  const contentLines = () => {
-    const c = content()
-    if (!c) return []
-    return c.split("\n")
-  }
-
-  const visibleLines = () => {
-    const lines = contentLines()
-    const offset = scrollOffset()
-    const maxVisible = 20 // Show max 20 lines at a time
-    return lines.slice(offset, offset + maxVisible)
-  }
-
-  const canScrollUp = () => scrollOffset() > 0
-  const canScrollDown = () => scrollOffset() + 20 < contentLines().length
-
   useKeyboard((evt) => {
     // When in reject mode (typing feedback)
     if (rejectMode()) {
@@ -100,77 +144,24 @@ export function PlanReviewPrompt(props: { request: PlanReviewRequest }) {
       reject()
       return
     }
-
-    // Scroll navigation
-    if (evt.name === "up" || evt.name === "k") {
-      evt.preventDefault()
-      if (canScrollUp()) {
-        setScrollOffset((o) => o - 1)
-      }
-      return
-    }
-
-    if (evt.name === "down" || evt.name === "j") {
-      evt.preventDefault()
-      if (canScrollDown()) {
-        setScrollOffset((o) => o + 1)
-      }
-      return
-    }
-
-    if (evt.name === "pageup") {
-      evt.preventDefault()
-      setScrollOffset((o) => Math.max(0, o - 10))
-      return
-    }
-
-    if (evt.name === "pagedown") {
-      evt.preventDefault()
-      setScrollOffset((o) => Math.min(contentLines().length - 20, o + 10))
-      return
-    }
   })
 
   return (
     <box
       backgroundColor={theme.backgroundPanel}
       border={["left"]}
-      borderColor={theme.accent}
+      borderColor={theme.warning}
       customBorderChars={SplitBorder.customBorderChars}
     >
-      <box gap={1} paddingLeft={1} paddingRight={3} paddingTop={1} paddingBottom={1}>
-        {/* Header */}
-        <box paddingLeft={1}>
-          <text>
-            <span style={{ fg: theme.text, bold: true }}>Plan Review</span>
-          </text>
-        </box>
-
-        <box paddingLeft={1}>
-          <text fg={theme.textMuted}>{props.request.filePath}</text>
-        </box>
-
-        {/* Content */}
-        <Show when={loading()}>
-          <box paddingLeft={1}>
-            <text fg={theme.textMuted}>Loading plan...</text>
-          </box>
-        </Show>
-
-        <Show when={!loading()}>
-          <box paddingLeft={1} flexDirection="column">
-            {visibleLines().map((line) => (
-              <text fg={theme.text}>{line || " "}</text>
-            ))}
-            <Show when={canScrollDown()}>
-              <text fg={theme.textMuted}>... ({contentLines().length - scrollOffset() - 20} more lines)</text>
-            </Show>
-          </box>
-        </Show>
+      <box paddingLeft={2} paddingRight={3} paddingTop={1} paddingBottom={1} gap={1}>
+        {/* Awaiting Approval badge */}
+        <text fg={theme.textMuted}>
+          <span style={{ bg: theme.warning, fg: theme.background, bold: true }}> AWAITING APPROVAL </span>
+        </text>
 
         {/* Reject feedback input */}
         <Show when={rejectMode()}>
-          <box paddingLeft={1} gap={1}>
+          <box gap={1}>
             <text fg={theme.text}>Feedback (optional):</text>
             <textarea
               ref={(val: TextareaRenderable) => (textarea = val)}
@@ -183,39 +174,26 @@ export function PlanReviewPrompt(props: { request: PlanReviewRequest }) {
             />
           </box>
         </Show>
-      </box>
 
-      {/* Footer with keybindings */}
-      <box
-        flexDirection="row"
-        flexShrink={0}
-        gap={1}
-        paddingLeft={2}
-        paddingRight={3}
-        paddingBottom={1}
-        justifyContent="space-between"
-      >
+        {/* Keyboard hints */}
         <box flexDirection="row" gap={2}>
           <Show when={!rejectMode()}>
-            <text fg={theme.text}>
-              {"↑↓"} <span style={{ fg: theme.textMuted }}>scroll</span>
-            </text>
-            <text fg={theme.text}>
-              enter <span style={{ fg: theme.textMuted }}>approve</span>
+            <text fg={theme.textMuted}>
+              <span style={{ fg: theme.text }}>enter</span> approve
             </text>
-            <text fg={theme.text}>
-              r <span style={{ fg: theme.textMuted }}>reject</span>
+            <text fg={theme.textMuted}>
+              <span style={{ fg: theme.text }}>r</span> reject
             </text>
-            <text fg={theme.text}>
-              esc <span style={{ fg: theme.textMuted }}>dismiss</span>
+            <text fg={theme.textMuted}>
+              <span style={{ fg: theme.text }}>esc</span> dismiss
             </text>
           </Show>
           <Show when={rejectMode()}>
-            <text fg={theme.text}>
-              enter <span style={{ fg: theme.textMuted }}>submit feedback</span>
+            <text fg={theme.textMuted}>
+              <span style={{ fg: theme.text }}>enter</span> submit feedback
             </text>
-            <text fg={theme.text}>
-              esc <span style={{ fg: theme.textMuted }}>cancel</span>
+            <text fg={theme.textMuted}>
+              <span style={{ fg: theme.text }}>esc</span> cancel
             </text>
           </Show>
         </box>
diff --git a/packages/opencode/src/session/message-v2.ts b/packages/opencode/src/session/message-v2.ts
index 501cf2e306b..d8f536c9ab1 100644
--- a/packages/opencode/src/session/message-v2.ts
+++ b/packages/opencode/src/session/message-v2.ts
@@ -511,6 +511,17 @@ export namespace MessageV2 {
               type: "step-start",
             })
           if (part.type === "tool") {
+            // Skip tool parts if the tool isn't in the current tools object
+            // This handles cases like plan→build transition where exit_plan_mode
+            // was used by plan agent but isn't available to build agent
+            if (options?.tools && !options.tools[part.tool]) {
+              // Convert to a text summary instead of a tool call
+              assistantMessage.parts.push({
+                type: "text",
+                text: `[Tool ${part.tool} was called${part.state.status === "completed" ? " and completed successfully" : ""}]`,
+              })
+              continue
+            }
             if (part.state.status === "completed") {
               if (part.state.attachments?.length) {
                 result.push({
diff --git a/packages/opencode/src/session/prompt.ts b/packages/opencode/src/session/prompt.ts
index d72f28dccc9..25b24d59243 100644
--- a/packages/opencode/src/session/prompt.ts
+++ b/packages/opencode/src/session/prompt.ts
@@ -292,38 +292,46 @@ export namespace SessionPrompt {
       }
 
       if (!lastUser) throw new Error("No user message found in stream. This should never happen.")
+
+      // Check for plan→build transition (ExitPlanMode was approved)
+      // When approved, ExitPlanMode updates the user message's agent to "build"
+      // but the assistant message was still from the plan agent with finish: "tool-calls"
+      // This check must run BEFORE the normal exit check since tool-calls finish would skip it
+      if (
+        lastAssistant?.finish === "tool-calls" &&
+        lastAssistant.agent === "plan" &&
+        lastUser.agent === "build" &&
+        lastUser.id < lastAssistant.id
+      ) {
+        log.info("plan→build transition detected, continuing with build agent", { sessionID })
+        // Create a synthetic continuation user message for the build agent
+        const continueMsg: MessageV2.User = {
+          id: Identifier.ascending("message"),
+          role: "user",
+          sessionID,
+          time: { created: Date.now() },
+          agent: "build",
+          model: lastUser.model,
+        }
+        await Session.updateMessage(continueMsg)
+        await Session.updatePart({
+          id: Identifier.ascending("part"),
+          messageID: continueMsg.id,
+          sessionID,
+          type: "text",
+          synthetic: true,
+          text: "Continue with the approved plan.",
+          time: { start: Date.now(), end: Date.now() },
+        })
+        // Don't exit - continue the loop with the new user message
+        continue
+      }
+
       if (
         lastAssistant?.finish &&
         !["tool-calls", "unknown"].includes(lastAssistant.finish) &&
         lastUser.id < lastAssistant.id
       ) {
-        // Check for plan→build transition (ExitPlanMode was approved)
-        // When approved, ExitPlanMode updates the user message's agent to "build"
-        // but the assistant message was still from the plan agent
-        if (lastAssistant.agent === "plan" && lastUser.agent === "build") {
-          log.info("plan→build transition detected, continuing with build agent", { sessionID })
-          // Create a synthetic continuation user message for the build agent
-          const continueMsg: MessageV2.User = {
-            id: Identifier.ascending("message"),
-            role: "user",
-            sessionID,
-            time: { created: Date.now() },
-            agent: "build",
-            model: lastUser.model,
-          }
-          await Session.updateMessage(continueMsg)
-          await Session.updatePart({
-            id: Identifier.ascending("part"),
-            messageID: continueMsg.id,
-            sessionID,
-            type: "text",
-            synthetic: true,
-            text: "Continue with the approved plan.",
-            time: { start: Date.now(), end: Date.now() },
-          })
-          // Don't exit - continue the loop with the new user message
-          continue
-        }
         log.info("exiting loop", { sessionID })
         break
       }

From f4de8dc2d3578fe39ab10765520b226457de9bfd Mon Sep 17 00:00:00 2001
From: KibbeWater <35224538+KibbeWater@users.noreply.github.com>
Date: Fri, 16 Jan 2026 23:14:18 +0100
Subject: [PATCH 16/18] fix(ui): improve plan review styling to match app
 design

---
 .../app/src/components/plan-review-inline.tsx | 125 ++++++++++--------
 packages/app/src/pages/session.tsx            |   7 +-
 2 files changed, 79 insertions(+), 53 deletions(-)

diff --git a/packages/app/src/components/plan-review-inline.tsx b/packages/app/src/components/plan-review-inline.tsx
index 03ddca70b61..488e54e0b83 100644
--- a/packages/app/src/components/plan-review-inline.tsx
+++ b/packages/app/src/components/plan-review-inline.tsx
@@ -3,8 +3,10 @@ import { Button } from "@opencode-ai/ui/button"
 import { TextField } from "@opencode-ai/ui/text-field"
 import { Icon } from "@opencode-ai/ui/icon"
 import { Markdown } from "@opencode-ai/ui/markdown"
+import { Spinner } from "@opencode-ai/ui/spinner"
 import { useSDK } from "@/context/sdk"
 import type { PlanReviewRequest } from "@opencode-ai/sdk/v2/client"
+import { getFilename } from "@opencode-ai/util/path"
 
 /**
  * Inline plan content that displays in the chat history (scrollable)
@@ -28,18 +30,23 @@ export const PlanReviewContent: Component<{ request: PlanReviewRequest }> = (pro
   })
 
   return (
-    <div class="px-4 md:px-6 py-4 border-l-4 border-l-yellow-500 bg-yellow-500/5">
-      {/* Header row with icon and title */}
+    <div class="px-4 md:px-6 py-4">
+      {/* Header */}
       <div class="flex items-center gap-2 mb-3">
-        <Icon name="checklist" class="size-4 text-yellow-600" />
-        <span class="text-14-semibold text-text-base">Plan Review</span>
+        <div class="flex items-center justify-center size-6 rounded-md bg-surface-warning-weaker">
+          <Icon name="checklist" class="size-4 text-icon-warning" />
+        </div>
+        <span class="text-14-semibold text-text-strong">Plan</span>
+        <span class="text-12-regular text-text-subtle">{getFilename(props.request.filePath)}</span>
       </div>
-      <div class="text-12-regular text-text-weak mb-3">{props.request.filePath}</div>
 
       {/* Plan content with markdown */}
-      <div class="border border-border-base rounded-md overflow-hidden bg-background-base">
+      <div class="rounded-md border border-border-base bg-surface-inset-base overflow-hidden">
         <Show when={loading()}>
-          <div class="p-4 text-text-weak">Loading plan...</div>
+          <div class="p-4 flex items-center gap-2 text-text-weak">
+            <Spinner />
+            <span class="text-14-regular">Loading plan...</span>
+          </div>
         </Show>
         <Show when={!loading()}>
           <div class="p-4 prose prose-sm max-w-none">
@@ -93,54 +100,68 @@ export const PlanReviewControls: Component<{ request: PlanReviewRequest }> = (pr
   }
 
   return (
-    <div class="border-l-4 border-l-yellow-500 bg-yellow-500/5 px-4 md:px-6 py-3">
-      {/* Awaiting Approval badge */}
-      <div class="flex items-center gap-2 mb-3">
-        <span class="text-11-medium text-yellow-600 bg-yellow-500/15 px-1.5 py-0.5 rounded">
-          Awaiting Approval
-        </span>
-      </div>
-
-      {/* Feedback input (shown in reject mode) */}
-      <Show when={rejectMode()}>
-        <div class="mb-3">
-          <TextField
-            autofocus
-            label="Feedback (optional)"
-            placeholder="Enter feedback for revision..."
-            value={feedback()}
-            onChange={setFeedback}
-            onKeyDown={(e: KeyboardEvent) => {
-              if (e.key === "Enter" && !submitting()) {
-                e.preventDefault()
-                handleReject()
-              }
-            }}
-          />
+    <div class="bg-surface-raised-stronger-non-alpha shadow-xs-border rounded-md overflow-clip">
+      <div class="px-4 py-3">
+        {/* Header row */}
+        <div class="flex items-center justify-between gap-4 mb-3">
+          <div class="flex items-center gap-2 min-w-0">
+            <div class="flex items-center justify-center size-6 rounded-md bg-surface-warning-weaker shrink-0">
+              <Icon name="checklist" class="size-4 text-icon-warning" />
+            </div>
+            <span class="text-14-semibold text-text-strong">Plan Review</span>
+            <span class="text-12-regular text-text-subtle truncate">{getFilename(props.request.filePath)}</span>
+          </div>
+          <span class="text-11-medium text-text-warning bg-surface-warning-weaker px-1.5 py-0.5 rounded shrink-0">
+            Awaiting Approval
+          </span>
         </div>
-      </Show>
-
-      {/* Actions */}
-      <div class="flex justify-end gap-2">
-        <Show when={!rejectMode()}>
-          <Button type="button" variant="ghost" size="normal" onClick={handleDismiss} disabled={submitting()}>
-            Dismiss
-          </Button>
-          <Button type="button" variant="ghost" size="normal" onClick={handleReject} disabled={submitting()}>
-            Reject
-          </Button>
-          <Button type="button" variant="primary" size="normal" onClick={handleApprove} disabled={submitting()}>
-            {submitting() ? "Approving..." : "Approve"}
-          </Button>
-        </Show>
+
+        {/* Description */}
+        <p class="text-12-regular text-text-weak mb-3">
+          Review the plan above. Approve to begin implementation, or reject with feedback to revise.
+        </p>
+
+        {/* Feedback input (shown in reject mode) */}
         <Show when={rejectMode()}>
-          <Button type="button" variant="ghost" size="normal" onClick={handleCancelReject} disabled={submitting()}>
-            Cancel
-          </Button>
-          <Button type="button" variant="primary" size="normal" onClick={handleReject} disabled={submitting()}>
-            {submitting() ? "Submitting..." : "Submit Feedback"}
-          </Button>
+          <div class="mb-3">
+            <TextField
+              autofocus
+              label="Feedback (optional)"
+              placeholder="Enter feedback for revision..."
+              value={feedback()}
+              onChange={setFeedback}
+              onKeyDown={(e: KeyboardEvent) => {
+                if (e.key === "Enter" && !submitting()) {
+                  e.preventDefault()
+                  handleReject()
+                }
+              }}
+            />
+          </div>
         </Show>
+
+        {/* Actions */}
+        <div class="flex justify-end gap-2">
+          <Show when={!rejectMode()}>
+            <Button type="button" variant="ghost" size="normal" onClick={handleDismiss} disabled={submitting()}>
+              Dismiss
+            </Button>
+            <Button type="button" variant="ghost" size="normal" onClick={handleReject} disabled={submitting()}>
+              Reject
+            </Button>
+            <Button type="button" variant="primary" size="normal" onClick={handleApprove} disabled={submitting()}>
+              {submitting() ? "Approving..." : "Approve"}
+            </Button>
+          </Show>
+          <Show when={rejectMode()}>
+            <Button type="button" variant="ghost" size="normal" onClick={handleCancelReject} disabled={submitting()}>
+              Cancel
+            </Button>
+            <Button type="button" variant="primary" size="normal" onClick={handleReject} disabled={submitting()}>
+              {submitting() ? "Submitting..." : "Submit Feedback"}
+            </Button>
+          </Show>
+        </div>
       </div>
     </div>
   )
diff --git a/packages/app/src/pages/session.tsx b/packages/app/src/pages/session.tsx
index 1590dd8f8a3..0119cd0421f 100644
--- a/packages/app/src/pages/session.tsx
+++ b/packages/app/src/pages/session.tsx
@@ -1240,7 +1240,12 @@ export default function Page() {
                           {/* Plan review inline - ephemeral message in chat */}
                           <Show when={pendingPlanReview()}>
                             {(request) => (
-                              <div class="min-w-0 w-full max-w-full">
+                              <div
+                                classList={{
+                                  "min-w-0 w-full": true,
+                                  "md:max-w-200 md:mx-auto": !showTabs(),
+                                }}
+                              >
                                 <PlanReviewContent request={request()} />
                               </div>
                             )}

From a7245a2bbc6a29cb9dd20026317f0f3f3db72507 Mon Sep 17 00:00:00 2001
From: KibbeWater <35224538+KibbeWater@users.noreply.github.com>
Date: Fri, 16 Jan 2026 23:43:14 +0100
Subject: [PATCH 17/18] chore: regenerate SDK and fix toModelMessage options

---
 .../src/cli/cmd/tui/routes/session/index.tsx  |   9 +-
 .../cmd/tui/routes/session/plan-review.tsx    |  10 +-
 packages/opencode/src/session/message-v2.ts   |   2 +-
 packages/opencode/src/session/prompt.ts       |   6 +-
 packages/opencode/src/share/share-next.ts     |   4 +-
 .../opencode/test/permission-task.test.ts     |  22 +-
 packages/sdk/js/src/v2/gen/sdk.gen.ts         | 130 +++++
 packages/sdk/js/src/v2/gen/types.gen.ts       | 202 ++++++++
 packages/sdk/openapi.json                     | 480 ++++++++++++++++++
 9 files changed, 838 insertions(+), 27 deletions(-)

diff --git a/packages/opencode/src/cli/cmd/tui/routes/session/index.tsx b/packages/opencode/src/cli/cmd/tui/routes/session/index.tsx
index 8af88c7b77a..384fc255f5f 100644
--- a/packages/opencode/src/cli/cmd/tui/routes/session/index.tsx
+++ b/packages/opencode/src/cli/cmd/tui/routes/session/index.tsx
@@ -138,7 +138,7 @@ export function Session() {
 
     // Access store properties directly through the proxy (NOT Object.entries)
     // This ensures Solid.js tracks reactivity properly
-    const result: typeof sync.data.plan_review[string] = []
+    const result: (typeof sync.data.plan_review)[string] = []
     for (const sessionID of childIDs) {
       const sessionReviews = sync.data.plan_review[sessionID]
       if (sessionReviews && sessionReviews.length > 0) {
@@ -1060,7 +1060,12 @@ export function Session() {
                 {(request) => <PlanReviewControls request={request} />}
               </Show>
               <Prompt
-                visible={!session()?.parentID && permissions().length === 0 && questions().length === 0 && planReviews().length === 0}
+                visible={
+                  !session()?.parentID &&
+                  permissions().length === 0 &&
+                  questions().length === 0 &&
+                  planReviews().length === 0
+                }
                 ref={(r) => {
                   prompt = r
                   promptRef.set(r)
diff --git a/packages/opencode/src/cli/cmd/tui/routes/session/plan-review.tsx b/packages/opencode/src/cli/cmd/tui/routes/session/plan-review.tsx
index 81341ad9c32..8a948084da6 100644
--- a/packages/opencode/src/cli/cmd/tui/routes/session/plan-review.tsx
+++ b/packages/opencode/src/cli/cmd/tui/routes/session/plan-review.tsx
@@ -26,7 +26,8 @@ export function PlanReviewContent(props: { request: PlanReviewRequest }) {
     setLoading(true)
     setContent(null)
 
-    Bun.file(filePath).text()
+    Bun.file(filePath)
+      .text()
       .then((result) => {
         setContent(result)
       })
@@ -39,12 +40,7 @@ export function PlanReviewContent(props: { request: PlanReviewRequest }) {
   })
 
   return (
-    <box
-      marginTop={1}
-      border={["left"]}
-      borderColor={theme.warning}
-      customBorderChars={SplitBorder.customBorderChars}
-    >
+    <box marginTop={1} border={["left"]} borderColor={theme.warning} customBorderChars={SplitBorder.customBorderChars}>
       <box
         paddingTop={1}
         paddingBottom={1}
diff --git a/packages/opencode/src/session/message-v2.ts b/packages/opencode/src/session/message-v2.ts
index d8f536c9ab1..ae0115c7d9e 100644
--- a/packages/opencode/src/session/message-v2.ts
+++ b/packages/opencode/src/session/message-v2.ts
@@ -441,7 +441,7 @@ export namespace MessageV2 {
   })
   export type WithParts = z.infer<typeof WithParts>
 
-  export function toModelMessage(input: WithParts[]): ModelMessage[] {
+  export function toModelMessage(input: WithParts[], options?: { tools?: Record<string, unknown> }): ModelMessage[] {
     const result: UIMessage[] = []
 
     for (const msg of input) {
diff --git a/packages/opencode/src/session/prompt.ts b/packages/opencode/src/session/prompt.ts
index 25b24d59243..98352b24702 100644
--- a/packages/opencode/src/session/prompt.ts
+++ b/packages/opencode/src/session/prompt.ts
@@ -633,7 +633,7 @@ export namespace SessionPrompt {
         sessionID,
         system: [...(await SystemPrompt.environment()), ...(await SystemPrompt.custom())],
         messages: [
-          ...MessageV2.toModelMessage(sessionMessages),
+          ...MessageV2.toModelMessage(sessionMessages, { tools }),
           ...(isLastStep
             ? [
                 {
@@ -1270,7 +1270,9 @@ export namespace SessionPrompt {
           sessionID: userMessage.info.sessionID,
           type: "text",
           text:
-            BUILD_SWITCH + "\n\n" + `A plan file exists at ${planInfo.filePath}. You should execute on the plan defined within it`,
+            BUILD_SWITCH +
+            "\n\n" +
+            `A plan file exists at ${planInfo.filePath}. You should execute on the plan defined within it`,
           synthetic: true,
         })
         userMessage.parts.push(part)
diff --git a/packages/opencode/src/share/share-next.ts b/packages/opencode/src/share/share-next.ts
index 050e2def45e..8bdf0c6847c 100644
--- a/packages/opencode/src/share/share-next.ts
+++ b/packages/opencode/src/share/share-next.ts
@@ -183,9 +183,7 @@ export namespace ShareNext {
         data: x.info,
       })),
       ...messages.flatMap((x) =>
-        x.parts
-          .filter((y) => y.type !== "plan-patch")
-          .map((y) => ({ type: "part" as const, data: y as SDK.Part })),
+        x.parts.filter((y) => y.type !== "plan-patch").map((y) => ({ type: "part" as const, data: y as SDK.Part })),
       ),
       {
         type: "session_diff",
diff --git a/packages/opencode/test/permission-task.test.ts b/packages/opencode/test/permission-task.test.ts
index 9d30763d763..4bfd52cf3d4 100644
--- a/packages/opencode/test/permission-task.test.ts
+++ b/packages/opencode/test/permission-task.test.ts
@@ -106,9 +106,9 @@ describe("PermissionNext.evaluateWithSession for session-scoped patterns", () =>
       { permission: "edit", pattern: "*", action: "deny" },
     ]
     // Last matching rule wins - global deny should override session-scoped allow
-    expect(
-      PermissionNext.evaluateWithSession("edit", "*/plan/session_abc.md", "session_abc", ruleset).action,
-    ).toBe("deny")
+    expect(PermissionNext.evaluateWithSession("edit", "*/plan/session_abc.md", "session_abc", ruleset).action).toBe(
+      "deny",
+    )
   })
 
   test("global deny followed by session-scoped allow", () => {
@@ -117,13 +117,11 @@ describe("PermissionNext.evaluateWithSession for session-scoped patterns", () =>
       { permission: "edit", pattern: "*/plan/{sessionID}.md", action: "allow" },
     ]
     // Last matching rule wins - session-scoped allow should override global deny
-    expect(
-      PermissionNext.evaluateWithSession("edit", "*/plan/session_abc.md", "session_abc", ruleset).action,
-    ).toBe("allow")
+    expect(PermissionNext.evaluateWithSession("edit", "*/plan/session_abc.md", "session_abc", ruleset).action).toBe(
+      "allow",
+    )
     // Other patterns still denied
-    expect(
-      PermissionNext.evaluateWithSession("edit", "*/other/file.md", "session_abc", ruleset).action,
-    ).toBe("deny")
+    expect(PermissionNext.evaluateWithSession("edit", "*/other/file.md", "session_abc", ruleset).action).toBe("deny")
   })
 
   test("returns ask when no match", () => {
@@ -432,9 +430,9 @@ describe("session-scoped permissions with config files", () => {
         const ruleset = PermissionNext.fromConfig(config.permission ?? {})
         const sessionID = "session_abc"
         // evaluateWithSession expands the placeholder and matches
-        expect(
-          PermissionNext.evaluateWithSession("edit", "*/plan/session_abc.md", sessionID, ruleset).action,
-        ).toBe("allow")
+        expect(PermissionNext.evaluateWithSession("edit", "*/plan/session_abc.md", sessionID, ruleset).action).toBe(
+          "allow",
+        )
         // Regular evaluate does NOT expand placeholder, so it won't match the literal path
         // (the pattern "*/plan/{sessionID}.md" won't match "*/plan/session_abc.md")
         expect(PermissionNext.evaluate("edit", "*/plan/session_abc.md", ruleset).action).toBe("ask")
diff --git a/packages/sdk/js/src/v2/gen/sdk.gen.ts b/packages/sdk/js/src/v2/gen/sdk.gen.ts
index 6f699319965..5de9d52873c 100644
--- a/packages/sdk/js/src/v2/gen/sdk.gen.ts
+++ b/packages/sdk/js/src/v2/gen/sdk.gen.ts
@@ -64,6 +64,13 @@ import type {
   PermissionRespondErrors,
   PermissionRespondResponses,
   PermissionRuleset,
+  PlanReviewApproveErrors,
+  PlanReviewApproveResponses,
+  PlanReviewContentErrors,
+  PlanReviewContentResponses,
+  PlanReviewListResponses,
+  PlanReviewRejectErrors,
+  PlanReviewRejectResponses,
   ProjectCurrentResponses,
   ProjectListResponses,
   ProjectUpdateErrors,
@@ -1842,6 +1849,124 @@ export class Question extends HeyApiClient {
   }
 }
 
+export class PlanReview extends HeyApiClient {
+  /**
+   * List pending plan reviews
+   *
+   * Get all pending plan review requests across all sessions.
+   */
+  public list<ThrowOnError extends boolean = false>(
+    parameters?: {
+      directory?: string
+    },
+    options?: Options<never, ThrowOnError>,
+  ) {
+    const params = buildClientParams([parameters], [{ args: [{ in: "query", key: "directory" }] }])
+    return (options?.client ?? this.client).get<PlanReviewListResponses, unknown, ThrowOnError>({
+      url: "/plan-review",
+      ...options,
+      ...params,
+    })
+  }
+
+  /**
+   * Get plan content
+   *
+   * Get the content of a plan file for a pending review request.
+   */
+  public content<ThrowOnError extends boolean = false>(
+    parameters: {
+      requestID: string
+      directory?: string
+    },
+    options?: Options<never, ThrowOnError>,
+  ) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "path", key: "requestID" },
+            { in: "query", key: "directory" },
+          ],
+        },
+      ],
+    )
+    return (options?.client ?? this.client).get<PlanReviewContentResponses, PlanReviewContentErrors, ThrowOnError>({
+      url: "/plan-review/{requestID}/content",
+      ...options,
+      ...params,
+    })
+  }
+
+  /**
+   * Approve plan review
+   *
+   * Approve a plan and transition to build mode.
+   */
+  public approve<ThrowOnError extends boolean = false>(
+    parameters: {
+      requestID: string
+      directory?: string
+    },
+    options?: Options<never, ThrowOnError>,
+  ) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "path", key: "requestID" },
+            { in: "query", key: "directory" },
+          ],
+        },
+      ],
+    )
+    return (options?.client ?? this.client).post<PlanReviewApproveResponses, PlanReviewApproveErrors, ThrowOnError>({
+      url: "/plan-review/{requestID}/approve",
+      ...options,
+      ...params,
+    })
+  }
+
+  /**
+   * Reject plan review
+   *
+   * Reject a plan with optional feedback for revision.
+   */
+  public reject<ThrowOnError extends boolean = false>(
+    parameters: {
+      requestID: string
+      directory?: string
+      feedback?: string
+    },
+    options?: Options<never, ThrowOnError>,
+  ) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "path", key: "requestID" },
+            { in: "query", key: "directory" },
+            { in: "body", key: "feedback" },
+          ],
+        },
+      ],
+    )
+    return (options?.client ?? this.client).post<PlanReviewRejectResponses, PlanReviewRejectErrors, ThrowOnError>({
+      url: "/plan-review/{requestID}/reject",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers,
+      },
+    })
+  }
+}
+
 export class Oauth extends HeyApiClient {
   /**
    * OAuth authorize
@@ -3072,6 +3197,11 @@ export class OpencodeClient extends HeyApiClient {
     return (this._question ??= new Question({ client: this.client }))
   }
 
+  private _planReview?: PlanReview
+  get planReview(): PlanReview {
+    return (this._planReview ??= new PlanReview({ client: this.client }))
+  }
+
   private _provider?: Provider
   get provider(): Provider {
     return (this._provider ??= new Provider({ client: this.client }))
diff --git a/packages/sdk/js/src/v2/gen/types.gen.ts b/packages/sdk/js/src/v2/gen/types.gen.ts
index 32321a7dfd8..a5fbd554eef 100644
--- a/packages/sdk/js/src/v2/gen/types.gen.ts
+++ b/packages/sdk/js/src/v2/gen/types.gen.ts
@@ -393,6 +393,14 @@ export type PatchPart = {
   files: Array<string>
 }
 
+export type PlanPatchPart = {
+  id: string
+  sessionID: string
+  messageID: string
+  type: "plan-patch"
+  beforeContent: string | null
+}
+
 export type AgentPart = {
   id: string
   sessionID: string
@@ -449,6 +457,7 @@ export type Part =
   | StepFinishPart
   | SnapshotPart
   | PatchPart
+  | PlanPatchPart
   | AgentPart
   | RetryPart
   | CompactionPart
@@ -470,6 +479,40 @@ export type EventMessagePartRemoved = {
   }
 }
 
+export type PlanInfo = {
+  id: string
+  sessionID: string
+  filePath: string
+  status: "draft" | "pending_review" | "approved" | "rejected"
+  time: {
+    created: number
+    updated: number
+  }
+}
+
+export type EventPlanCreated = {
+  type: "plan.created"
+  properties: {
+    info: PlanInfo
+  }
+}
+
+export type EventPlanUpdated = {
+  type: "plan.updated"
+  properties: {
+    info: PlanInfo
+  }
+}
+
+export type EventPlanStatusChanged = {
+  type: "plan.status.changed"
+  properties: {
+    planID: string
+    sessionID: string
+    status: "draft" | "pending_review" | "approved" | "rejected"
+  }
+}
+
 export type PermissionRequest = {
   id: string
   sessionID: string
@@ -606,6 +649,39 @@ export type EventSessionCompacted = {
   }
 }
 
+export type PlanReviewRequest = {
+  id: string
+  sessionID: string
+  planID: string
+  filePath: string
+  tool?: {
+    messageID: string
+    callID: string
+  }
+}
+
+export type EventPlanReviewRequested = {
+  type: "plan_review.requested"
+  properties: PlanReviewRequest
+}
+
+export type EventPlanReviewApproved = {
+  type: "plan_review.approved"
+  properties: {
+    requestID: string
+    sessionID: string
+  }
+}
+
+export type EventPlanReviewRejected = {
+  type: "plan_review.rejected"
+  properties: {
+    requestID: string
+    sessionID: string
+    feedback?: string
+  }
+}
+
 export type Todo = {
   /**
    * Brief description of the task
@@ -749,6 +825,7 @@ export type Session = {
     partID?: string
     snapshot?: string
     diff?: string
+    planContent?: string
   }
 }
 
@@ -869,6 +946,9 @@ export type Event =
   | EventMessageRemoved
   | EventMessagePartUpdated
   | EventMessagePartRemoved
+  | EventPlanCreated
+  | EventPlanUpdated
+  | EventPlanStatusChanged
   | EventPermissionAsked
   | EventPermissionReplied
   | EventSessionStatus
@@ -877,6 +957,9 @@ export type Event =
   | EventQuestionReplied
   | EventQuestionRejected
   | EventSessionCompacted
+  | EventPlanReviewRequested
+  | EventPlanReviewApproved
+  | EventPlanReviewRejected
   | EventTodoUpdated
   | EventTuiPromptAppend
   | EventTuiCommandExecute
@@ -3731,6 +3814,125 @@ export type QuestionRejectResponses = {
 
 export type QuestionRejectResponse = QuestionRejectResponses[keyof QuestionRejectResponses]
 
+export type PlanReviewListData = {
+  body?: never
+  path?: never
+  query?: {
+    directory?: string
+  }
+  url: "/plan-review"
+}
+
+export type PlanReviewListResponses = {
+  /**
+   * List of pending plan reviews
+   */
+  200: Array<PlanReviewRequest>
+}
+
+export type PlanReviewListResponse = PlanReviewListResponses[keyof PlanReviewListResponses]
+
+export type PlanReviewContentData = {
+  body?: never
+  path: {
+    requestID: string
+  }
+  query?: {
+    directory?: string
+  }
+  url: "/plan-review/{requestID}/content"
+}
+
+export type PlanReviewContentErrors = {
+  /**
+   * Bad request
+   */
+  400: BadRequestError
+  /**
+   * Not found
+   */
+  404: NotFoundError
+}
+
+export type PlanReviewContentError = PlanReviewContentErrors[keyof PlanReviewContentErrors]
+
+export type PlanReviewContentResponses = {
+  /**
+   * Plan content
+   */
+  200: string
+}
+
+export type PlanReviewContentResponse = PlanReviewContentResponses[keyof PlanReviewContentResponses]
+
+export type PlanReviewApproveData = {
+  body?: never
+  path: {
+    requestID: string
+  }
+  query?: {
+    directory?: string
+  }
+  url: "/plan-review/{requestID}/approve"
+}
+
+export type PlanReviewApproveErrors = {
+  /**
+   * Bad request
+   */
+  400: BadRequestError
+  /**
+   * Not found
+   */
+  404: NotFoundError
+}
+
+export type PlanReviewApproveError = PlanReviewApproveErrors[keyof PlanReviewApproveErrors]
+
+export type PlanReviewApproveResponses = {
+  /**
+   * Plan approved successfully
+   */
+  200: boolean
+}
+
+export type PlanReviewApproveResponse = PlanReviewApproveResponses[keyof PlanReviewApproveResponses]
+
+export type PlanReviewRejectData = {
+  body?: {
+    feedback?: string
+  }
+  path: {
+    requestID: string
+  }
+  query?: {
+    directory?: string
+  }
+  url: "/plan-review/{requestID}/reject"
+}
+
+export type PlanReviewRejectErrors = {
+  /**
+   * Bad request
+   */
+  400: BadRequestError
+  /**
+   * Not found
+   */
+  404: NotFoundError
+}
+
+export type PlanReviewRejectError = PlanReviewRejectErrors[keyof PlanReviewRejectErrors]
+
+export type PlanReviewRejectResponses = {
+  /**
+   * Plan rejected successfully
+   */
+  200: boolean
+}
+
+export type PlanReviewRejectResponse = PlanReviewRejectResponses[keyof PlanReviewRejectResponses]
+
 export type ProviderListData = {
   body?: never
   path?: never
diff --git a/packages/sdk/openapi.json b/packages/sdk/openapi.json
index 904f3eeaefa..cdec6550b14 100644
--- a/packages/sdk/openapi.json
+++ b/packages/sdk/openapi.json
@@ -3315,6 +3315,243 @@
         ]
       }
     },
+    "/plan-review": {
+      "get": {
+        "operationId": "plan_review.list",
+        "parameters": [
+          {
+            "in": "query",
+            "name": "directory",
+            "schema": {
+              "type": "string"
+            }
+          }
+        ],
+        "summary": "List pending plan reviews",
+        "description": "Get all pending plan review requests across all sessions.",
+        "responses": {
+          "200": {
+            "description": "List of pending plan reviews",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "array",
+                  "items": {
+                    "$ref": "#/components/schemas/PlanReviewRequest"
+                  }
+                }
+              }
+            }
+          }
+        },
+        "x-codeSamples": [
+          {
+            "lang": "js",
+            "source": "import { createOpencodeClient } from \"@opencode-ai/sdk\n\nconst client = createOpencodeClient()\nawait client.plan_review.list({\n  ...\n})"
+          }
+        ]
+      }
+    },
+    "/plan-review/{requestID}/content": {
+      "get": {
+        "operationId": "plan_review.content",
+        "parameters": [
+          {
+            "in": "query",
+            "name": "directory",
+            "schema": {
+              "type": "string"
+            }
+          },
+          {
+            "in": "path",
+            "name": "requestID",
+            "schema": {
+              "type": "string"
+            },
+            "required": true
+          }
+        ],
+        "summary": "Get plan content",
+        "description": "Get the content of a plan file for a pending review request.",
+        "responses": {
+          "200": {
+            "description": "Plan content",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "string"
+                }
+              }
+            }
+          },
+          "400": {
+            "description": "Bad request",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/BadRequestError"
+                }
+              }
+            }
+          },
+          "404": {
+            "description": "Not found",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/NotFoundError"
+                }
+              }
+            }
+          }
+        },
+        "x-codeSamples": [
+          {
+            "lang": "js",
+            "source": "import { createOpencodeClient } from \"@opencode-ai/sdk\n\nconst client = createOpencodeClient()\nawait client.plan_review.content({\n  ...\n})"
+          }
+        ]
+      }
+    },
+    "/plan-review/{requestID}/approve": {
+      "post": {
+        "operationId": "plan_review.approve",
+        "parameters": [
+          {
+            "in": "query",
+            "name": "directory",
+            "schema": {
+              "type": "string"
+            }
+          },
+          {
+            "in": "path",
+            "name": "requestID",
+            "schema": {
+              "type": "string"
+            },
+            "required": true
+          }
+        ],
+        "summary": "Approve plan review",
+        "description": "Approve a plan and transition to build mode.",
+        "responses": {
+          "200": {
+            "description": "Plan approved successfully",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "boolean"
+                }
+              }
+            }
+          },
+          "400": {
+            "description": "Bad request",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/BadRequestError"
+                }
+              }
+            }
+          },
+          "404": {
+            "description": "Not found",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/NotFoundError"
+                }
+              }
+            }
+          }
+        },
+        "x-codeSamples": [
+          {
+            "lang": "js",
+            "source": "import { createOpencodeClient } from \"@opencode-ai/sdk\n\nconst client = createOpencodeClient()\nawait client.plan_review.approve({\n  ...\n})"
+          }
+        ]
+      }
+    },
+    "/plan-review/{requestID}/reject": {
+      "post": {
+        "operationId": "plan_review.reject",
+        "parameters": [
+          {
+            "in": "query",
+            "name": "directory",
+            "schema": {
+              "type": "string"
+            }
+          },
+          {
+            "in": "path",
+            "name": "requestID",
+            "schema": {
+              "type": "string"
+            },
+            "required": true
+          }
+        ],
+        "summary": "Reject plan review",
+        "description": "Reject a plan with optional feedback for revision.",
+        "responses": {
+          "200": {
+            "description": "Plan rejected successfully",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "boolean"
+                }
+              }
+            }
+          },
+          "400": {
+            "description": "Bad request",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/BadRequestError"
+                }
+              }
+            }
+          },
+          "404": {
+            "description": "Not found",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/NotFoundError"
+                }
+              }
+            }
+          }
+        },
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "type": "object",
+                "properties": {
+                  "feedback": {
+                    "type": "string"
+                  }
+                }
+              }
+            }
+          }
+        },
+        "x-codeSamples": [
+          {
+            "lang": "js",
+            "source": "import { createOpencodeClient } from \"@opencode-ai/sdk\n\nconst client = createOpencodeClient()\nawait client.plan_review.reject({\n  ...\n})"
+          }
+        ]
+      }
+    },
     "/provider": {
       "get": {
         "operationId": "provider.list",
@@ -6763,6 +7000,35 @@
         },
         "required": ["id", "sessionID", "messageID", "type", "hash", "files"]
       },
+      "PlanPatchPart": {
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "string"
+          },
+          "sessionID": {
+            "type": "string"
+          },
+          "messageID": {
+            "type": "string"
+          },
+          "type": {
+            "type": "string",
+            "const": "plan-patch"
+          },
+          "beforeContent": {
+            "anyOf": [
+              {
+                "type": "string"
+              },
+              {
+                "type": "null"
+              }
+            ]
+          }
+        },
+        "required": ["id", "sessionID", "messageID", "type", "beforeContent"]
+      },
       "AgentPart": {
         "type": "object",
         "properties": {
@@ -6929,6 +7195,9 @@
           {
             "$ref": "#/components/schemas/PatchPart"
           },
+          {
+            "$ref": "#/components/schemas/PlanPatchPart"
+          },
           {
             "$ref": "#/components/schemas/AgentPart"
           },
@@ -6987,6 +7256,103 @@
         },
         "required": ["type", "properties"]
       },
+      "PlanInfo": {
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "string",
+            "pattern": "^pln.*"
+          },
+          "sessionID": {
+            "type": "string",
+            "pattern": "^ses.*"
+          },
+          "filePath": {
+            "type": "string"
+          },
+          "status": {
+            "type": "string",
+            "enum": ["draft", "pending_review", "approved", "rejected"]
+          },
+          "time": {
+            "type": "object",
+            "properties": {
+              "created": {
+                "type": "number"
+              },
+              "updated": {
+                "type": "number"
+              }
+            },
+            "required": ["created", "updated"]
+          }
+        },
+        "required": ["id", "sessionID", "filePath", "status", "time"]
+      },
+      "Event.plan.created": {
+        "type": "object",
+        "properties": {
+          "type": {
+            "type": "string",
+            "const": "plan.created"
+          },
+          "properties": {
+            "type": "object",
+            "properties": {
+              "info": {
+                "$ref": "#/components/schemas/PlanInfo"
+              }
+            },
+            "required": ["info"]
+          }
+        },
+        "required": ["type", "properties"]
+      },
+      "Event.plan.updated": {
+        "type": "object",
+        "properties": {
+          "type": {
+            "type": "string",
+            "const": "plan.updated"
+          },
+          "properties": {
+            "type": "object",
+            "properties": {
+              "info": {
+                "$ref": "#/components/schemas/PlanInfo"
+              }
+            },
+            "required": ["info"]
+          }
+        },
+        "required": ["type", "properties"]
+      },
+      "Event.plan.status.changed": {
+        "type": "object",
+        "properties": {
+          "type": {
+            "type": "string",
+            "const": "plan.status.changed"
+          },
+          "properties": {
+            "type": "object",
+            "properties": {
+              "planID": {
+                "type": "string"
+              },
+              "sessionID": {
+                "type": "string"
+              },
+              "status": {
+                "type": "string",
+                "enum": ["draft", "pending_review", "approved", "rejected"]
+              }
+            },
+            "required": ["planID", "sessionID", "status"]
+          }
+        },
+        "required": ["type", "properties"]
+      },
       "PermissionRequest": {
         "type": "object",
         "properties": {
@@ -7323,6 +7689,99 @@
         },
         "required": ["type", "properties"]
       },
+      "PlanReviewRequest": {
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "string",
+            "pattern": "^plr.*"
+          },
+          "sessionID": {
+            "type": "string",
+            "pattern": "^ses.*"
+          },
+          "planID": {
+            "type": "string",
+            "pattern": "^pln.*"
+          },
+          "filePath": {
+            "type": "string"
+          },
+          "tool": {
+            "type": "object",
+            "properties": {
+              "messageID": {
+                "type": "string"
+              },
+              "callID": {
+                "type": "string"
+              }
+            },
+            "required": ["messageID", "callID"]
+          }
+        },
+        "required": ["id", "sessionID", "planID", "filePath"]
+      },
+      "Event.plan_review.requested": {
+        "type": "object",
+        "properties": {
+          "type": {
+            "type": "string",
+            "const": "plan_review.requested"
+          },
+          "properties": {
+            "$ref": "#/components/schemas/PlanReviewRequest"
+          }
+        },
+        "required": ["type", "properties"]
+      },
+      "Event.plan_review.approved": {
+        "type": "object",
+        "properties": {
+          "type": {
+            "type": "string",
+            "const": "plan_review.approved"
+          },
+          "properties": {
+            "type": "object",
+            "properties": {
+              "requestID": {
+                "type": "string"
+              },
+              "sessionID": {
+                "type": "string"
+              }
+            },
+            "required": ["requestID", "sessionID"]
+          }
+        },
+        "required": ["type", "properties"]
+      },
+      "Event.plan_review.rejected": {
+        "type": "object",
+        "properties": {
+          "type": {
+            "type": "string",
+            "const": "plan_review.rejected"
+          },
+          "properties": {
+            "type": "object",
+            "properties": {
+              "requestID": {
+                "type": "string"
+              },
+              "sessionID": {
+                "type": "string"
+              },
+              "feedback": {
+                "type": "string"
+              }
+            },
+            "required": ["requestID", "sessionID"]
+          }
+        },
+        "required": ["type", "properties"]
+      },
       "Todo": {
         "type": "object",
         "properties": {
@@ -7670,6 +8129,9 @@
               },
               "diff": {
                 "type": "string"
+              },
+              "planContent": {
+                "type": "string"
               }
             },
             "required": ["messageID"]
@@ -8025,6 +8487,15 @@
           {
             "$ref": "#/components/schemas/Event.message.part.removed"
           },
+          {
+            "$ref": "#/components/schemas/Event.plan.created"
+          },
+          {
+            "$ref": "#/components/schemas/Event.plan.updated"
+          },
+          {
+            "$ref": "#/components/schemas/Event.plan.status.changed"
+          },
           {
             "$ref": "#/components/schemas/Event.permission.asked"
           },
@@ -8049,6 +8520,15 @@
           {
             "$ref": "#/components/schemas/Event.session.compacted"
           },
+          {
+            "$ref": "#/components/schemas/Event.plan_review.requested"
+          },
+          {
+            "$ref": "#/components/schemas/Event.plan_review.approved"
+          },
+          {
+            "$ref": "#/components/schemas/Event.plan_review.rejected"
+          },
           {
             "$ref": "#/components/schemas/Event.todo.updated"
           },

From 05b4fcf965444eafcd9d7374afe335ff56960dc3 Mon Sep 17 00:00:00 2001
From: KibbeWater <35224538+KibbeWater@users.noreply.github.com>
Date: Fri, 16 Jan 2026 23:50:34 +0100
Subject: [PATCH 18/18] fix: restore ExitPlanModeTool under experimental flag

---
 packages/opencode/src/tool/registry.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/opencode/src/tool/registry.ts b/packages/opencode/src/tool/registry.ts
index a2c5ce56e0b..097cddbbca4 100644
--- a/packages/opencode/src/tool/registry.ts
+++ b/packages/opencode/src/tool/registry.ts
@@ -109,9 +109,9 @@ export namespace ToolRegistry {
       WebSearchTool,
       CodeSearchTool,
       SkillTool,
-      ExitPlanModeTool,
       ...(Flag.OPENCODE_EXPERIMENTAL_LSP_TOOL ? [LspTool] : []),
       ...(config.experimental?.batch_tool === true ? [BatchTool] : []),
+      ...(Flag.OPENCODE_EXPERIMENTAL_PLAN_MODE ? [ExitPlanModeTool] : []),
       ...(Flag.OPENCODE_EXPERIMENTAL_PLAN_MODE && Flag.OPENCODE_CLIENT === "cli" ? [PlanEnterTool] : []),
       ...custom,
     ]