fix(core): keep the upstream todowrite tool alongside the goal todo

Author: Te-River

packages/core/src/plugin/internal.ts

@@ -77,6 +77,7 @@ import { PatchTool } from "../tool/plugin/patch.js"
 import { EditTool } from "../tool/plugin/edit.js"
 import { GlobTool } from "../tool/plugin/glob.js"
 import { GoalTool } from "../tool/plugin/goal.js"
+import { GoalTodoTool } from "../tool/plugin/goal-todo.js"
 import { GrepTool } from "../tool/plugin/grep.js"
 import { McpResourceTools } from "../tool/plugin/mcp-resource.js"
 import { OpenCodeTools } from "../tool/plugin/opencode.js"
@@ -255,6 +256,7 @@ const pre = [
   EditTool.Plugin,
   GlobTool.Plugin,
   GoalTool.Plugin,
+  GoalTodoTool.Plugin,
   GrepTool.Plugin,
   OpenCodeTools.Plugin,
   McpResourceTools.Plugin,

packages/core/src/session/goal-driver.ts

@@ -179,11 +179,11 @@ const renderRoundPrompt = (state: SessionGoalSchema.State) => {
     unmet.length === 0
       ? "The verifier has not rejected anything yet."
       : `The verifier did not accept these items:\n${unmet.join("\n")}`,
-    "Keep the list accurate with the todo tool. Only the verifier marks an item completed, so finish the work rather than the list.",
+    "Keep the list accurate with the goal_todo tool. Only the verifier marks an item completed, so finish the work rather than the list.",
   ].join("\n\n")
 }
 
 const renderTodo = (todo: ReadonlyArray<SessionGoalSchema.TodoItem>) =>
   todo.length === 0
-    ? "(the list is empty; write it with the todo tool)"
+    ? "(the list is empty; write it with the goal_todo tool)"
     : todo.map((item) => `- [${item.position}] ${item.status}: ${item.content}`).join("\n")

packages/core/src/session/goal.ts

@@ -311,7 +311,7 @@ const layer = Layer.effect(
         yield* activation.disarm(sessionID)
         const snapshot = { ...goal, revision: goal.revision + 1, phase: "paused" as const }
         yield* publishUpdated(bus, sessionID, snapshot)
-        if (armed && input.interrupt !== false) yield* Effect.uninterruptible(execution.interrupt(sessionID, { reason: "user" }))
+        if (armed && input.interrupt !== false) yield* Effect.uninterruptible(execution.interrupt(sessionID))
         return snapshot
       }
       if (input.action === "resume") {

packages/core/src/tool/plugin/goal-todo.ts

@@ -0,0 +1,95 @@
+export * as GoalTodoTool from "./goal-todo.js"
+
+import { ToolFailure } from "@opencode/ai"
+import type { Context } from "@opencode/plugin/effect/plugin"
+import { SessionGoal as SessionGoalSchema } from "@opencode/schema/session-goal"
+import { Effect, Schema } from "effect"
+import { SessionGoal } from "../../session/goal.js"
+
+export const name = "goal_todo"
+
+const Acceptance = Schema.String.check(Schema.isMaxLength(200))
+
+/**
+ * The model's goal todo surface. `completed` is absent: the verifier owns it, so
+ * the model cannot tick its own list. `acceptance` is how the verifier knows
+ * what "done" means for an item.
+ */
+export const Input = Schema.Struct({
+  todos: Schema.Array(
+    Schema.Struct({
+      content: Schema.String,
+      status: Schema.Literals(["pending", "in_progress", "cancelled"]),
+      acceptance: Schema.optionalKey(Acceptance),
+    }),
+  ),
+})
+
+export const Output = Schema.Struct({
+  todos: Schema.Array(SessionGoalSchema.TodoItem),
+  unmet: Schema.Array(
+    Schema.Struct({
+      position: Schema.Number,
+      reason: Schema.String,
+    }),
+  ),
+})
+
+export const description = [
+  "Replace the session's whole todo list for the current goal.",
+  "",
+  "This is the durable goal list, not `todowrite`. The list is stored on the session, and the goal verifier judges every item against its `acceptance` statement; `todowrite` only echoes a working plan back and stores nothing. Use `todowrite` for a working plan outside a goal, and this tool for the list a goal is verified against.",
+  "`acceptance` states how the item is judged done; the verifier reads it and nothing else about the item.",
+  "The verifier alone marks an item `completed`, so use `pending`, `in_progress` and `cancelled` here.",
+  "The result echoes the verifier's unmet items verbatim: fix those before anything else.",
+].join("\n")
+
+export const Plugin = {
+  id: "opencode.tool.goal-todo",
+  effect: Effect.fn("GoalTodoTool.Plugin")(function* (ctx: Context) {
+    const goal = yield* SessionGoal.Service
+    yield* ctx.tool
+      .transform((editor) =>
+        editor.add({
+          name,
+          options: { codemode: false },
+          description,
+          input: Input,
+          output: Output,
+          execute: (input, context) =>
+            Effect.gen(function* () {
+              // The verifier's reasons live on the rows this call replaces, so read
+              // them first: the echo below is where the model sees them.
+              const before = yield* goal.readTodo(context.sessionID)
+              const unmet = before.flatMap((item) =>
+                item.feedback === undefined || item.feedback === ""
+                  ? []
+                  : [{ position: item.position, reason: item.feedback }],
+              )
+              yield* goal.replaceTodo(context.sessionID, input.todos)
+              const after = yield* goal.readTodo(context.sessionID)
+              return { output: { todos: after, unmet }, content: render(after, unmet) }
+            }).pipe(Effect.mapError((error) => new ToolFailure({ message: error.message }))),
+        }),
+      )
+      .pipe(Effect.orDie)
+  }),
+}
+
+const render = (
+  todos: ReadonlyArray<SessionGoalSchema.TodoItem>,
+  unmet: ReadonlyArray<{ readonly position: number; readonly reason: string }>,
+) =>
+  [
+    todos.length === 0
+      ? "Todo list: (empty)"
+      : `Todo list:\n${todos
+          .map(
+            (item) =>
+              `- [${item.position}] ${item.status}: ${item.content}${item.acceptance === undefined ? "" : `\n  acceptance: ${item.acceptance}`}`,
+          )
+          .join("\n")}`,
+    unmet.length === 0
+      ? "The verifier has not rejected anything."
+      : `The verifier did not accept these items:\n${unmet.map((item) => `- [${item.position}] ${item.reason}`).join("\n")}`,
+  ].join("\n\n")

packages/core/src/tool/plugin/goal.ts

@@ -78,6 +78,6 @@ const render = (snapshot: SessionGoalSchema.Snapshot, state: SessionGoalSchema.S
     `Objective: ${snapshot.objective}`,
     `Rounds: ${state.rounds}/${state.maxGoalRounds}.`,
     state.todo.length === 0
-      ? "Todo list: (empty; write it with the todo tool)"
+      ? "Todo list: (empty; write it with the goal_todo tool)"
       : `Todo list:\n${state.todo.map((item) => `- [${item.position}] ${item.status}: ${item.content}`).join("\n")}`,
   ].join("\n")

packages/core/src/tool/plugin/todo.ts

@@ -2,93 +2,82 @@ export * as TodoTool from "./todo.js"
 
 import { ToolFailure } from "@opencode/ai"
 import type { Context } from "@opencode/plugin/effect/plugin"
-import { SessionGoal as SessionGoalSchema } from "@opencode/schema/session-goal"
 import { Effect, Schema } from "effect"
-import { SessionGoal } from "../../session/goal.js"
+import { Config } from "../../config.js"
+import { ConfigEntryObserver } from "../../config/plugin/entry-observer.js"
+import { Permission } from "../../permission.js"
+import DESCRIPTION from "../todowrite.txt"
 
-export const name = "todo"
+export const name = "todowrite"
 
-const Acceptance = Schema.String.check(Schema.isMaxLength(200))
+export const Info = Schema.Struct({
+  content: Schema.String.annotate({ description: "Brief description of the task" }),
+  status: Schema.Literals(["pending", "in_progress", "completed", "cancelled"]).annotate({
+    description: "Current status of the task: pending, in_progress, completed, cancelled",
+  }),
+})
+export type Info = typeof Info.Type
 
-/**
- * The model's todo surface. `completed` is absent: the verifier owns it, so
- * the model cannot tick its own list. `acceptance` is how the verifier knows
- * what "done" means for an item.
- */
 export const Input = Schema.Struct({
-  todos: Schema.Array(
-    Schema.Struct({
-      content: Schema.String,
-      status: Schema.Literals(["pending", "in_progress", "cancelled"]),
-      acceptance: Schema.optionalKey(Acceptance),
-    }),
-  ),
+  todos: Schema.Array(Info).annotate({ description: "The updated todo list" }),
 })
 
 export const Output = Schema.Struct({
-  todos: Schema.Array(SessionGoalSchema.TodoItem),
-  unmet: Schema.Array(
-    Schema.Struct({
-      position: Schema.Number,
-      reason: Schema.String,
-    }),
-  ),
+  todos: Schema.Array(Info),
 })
+export type Output = typeof Output.Type
 
-export const description = [
-  "Replace the session's whole todo list for the current goal.",
-  "",
-  "`acceptance` states how the item is judged done; the verifier reads it and nothing else about the item.",
-  "The verifier alone marks an item `completed`, so use `pending`, `in_progress` and `cancelled` here.",
-  "The result echoes the verifier's unmet items verbatim: fix those before anything else.",
-].join("\n")
+export const summarize = (todos: ReadonlyArray<Info>) => {
+  if (todos.length === 0) return "Todos cleared"
+  const count = (status: Info["status"]) => todos.filter((todo) => todo.status === status).length
+  const counts = [
+    `${count("completed")}/${todos.length} completed`,
+    ...(["in_progress", "pending", "cancelled"] as const).flatMap((status) =>
+      count(status) ? [`${count(status)} ${status.replace("_", " ")}`] : [],
+    ),
+  ].join(", ")
+  const active = todos.filter((todo) => todo.status === "in_progress").map((todo) => JSON.stringify(todo.content))
+  return `Todos updated: ${counts}${active.length ? `. In progress: ${active.join(", ")}` : ""}`
+}
 
 export const Plugin = {
   id: "opencode.tool.todo",
   effect: Effect.fn("TodoTool.Plugin")(function* (ctx: Context) {
-    const goal = yield* SessionGoal.Service
+    const config = yield* Config.Service
+    const permission = yield* Permission.Service
+    // Internal plugins are not re-run on config changes, so reload the tool transform instead.
+    const loaded = yield* ConfigEntryObserver.observe(config, ctx.event, ctx.tool.reload())
+    const enabled = () => Config.latest(loaded.entries, "experimental")?.todo === true
+
     yield* ctx.tool
-      .transform((editor) =>
+      .transform((editor) => {
+        if (!enabled()) return
         editor.add({
           name,
           options: { codemode: false },
-          description,
+          description: DESCRIPTION,
           input: Input,
           output: Output,
           execute: (input, context) =>
-            Effect.gen(function* () {
-              // The verifier's reasons live on the rows this call replaces, so read
-              // them first: the echo below is where the model sees them.
-              const before = yield* goal.readTodo(context.sessionID)
-              const unmet = before.flatMap((item) =>
-                item.feedback === undefined || item.feedback === ""
-                  ? []
-                  : [{ position: item.position, reason: item.feedback }],
-              )
-              yield* goal.replaceTodo(context.sessionID, input.todos)
-              const after = yield* goal.readTodo(context.sessionID)
-              return { output: { todos: after, unmet }, content: render(after, unmet) }
-            }).pipe(Effect.mapError((error) => new ToolFailure({ message: error.message }))),
-        }),
-      )
+            permission
+              .assert({
+                action: name,
+                resources: ["*"],
+                save: ["*"],
+                sessionID: context.sessionID,
+                agent: context.agent,
+                source: { type: "tool", messageID: context.messageID, id: context.id },
+              })
+              .pipe(
+                Effect.mapError((error) => new ToolFailure({ message: "Unable to update todos", error })),
+                Effect.as({
+                  output: { todos: input.todos },
+                  content: summarize(input.todos),
+                  metadata: { todos: input.todos },
+                }),
+              ),
+        })
+      })
       .pipe(Effect.orDie)
   }),
 }
-
-const render = (
-  todos: ReadonlyArray<SessionGoalSchema.TodoItem>,
-  unmet: ReadonlyArray<{ readonly position: number; readonly reason: string }>,
-) =>
-  [
-    todos.length === 0
-      ? "Todo list: (empty)"
-      : `Todo list:\n${todos
-          .map(
-            (item) =>
-              `- [${item.position}] ${item.status}: ${item.content}${item.acceptance === undefined ? "" : `\n  acceptance: ${item.acceptance}`}`,
-          )
-          .join("\n")}`,
-    unmet.length === 0
-      ? "The verifier has not rejected anything."
-      : `The verifier did not accept these items:\n${unmet.map((item) => `- [${item.position}] ${item.reason}`).join("\n")}`,
-  ].join("\n\n")