Align goal command UX with Codex

Author: danyel117

README.md

@@ -4,7 +4,7 @@ Codex-style long-running goal mode for OpenCode.
 
 This plugin adds:
 
-- `/goal` in the OpenCode TUI.
+- `/goal <objective>` as an OpenCode command for TUI, desktop, and web.
 - A sidebar goal indicator with status, elapsed time, token usage, remaining budget, and objective.
 - Agent tools: `get_goal`, `create_goal`, `update_goal`, and `clear_goal`.
 - Goal close evidence: `complete` requires verified evidence, and `unmet` requires a concrete blocker.
@@ -60,7 +60,8 @@ Server options can be configured in `opencode.json`:
       {
         "auto_continue": true,
         "max_auto_turns": 25,
-        "min_continue_interval_seconds": 3
+        "min_continue_interval_seconds": 3,
+        "default_token_budget": null
       }
     ]
   ]
@@ -72,18 +73,23 @@ Defaults:
 - `auto_continue`: `true`
 - `max_auto_turns`: `25`
 - `min_continue_interval_seconds`: `3`
+- `register_command`: `true`
+- `command_name`: `"goal"`
+- `default_token_budget`: `null`
 
 ## Goal Workflow
 
-Use `/goal` from an OpenCode TUI session to set, refresh, or clear the goal. New goals support budget presets:
+Use `/goal <objective>` in a fresh OpenCode chat to create a long-running goal:
 
-- No budget
-- `250K`
-- `1M`
-- `2M`
-- Custom positive integer
+```text
+/goal review the frontend and translate visible English UI text to Spanish
+```
+
+Bare `/goal` reports the current goal state. `/goal clear` clears the goal. The TUI also includes a `Goal` command-palette entry for viewing, refreshing, or clearing the current goal state without creating a new goal.
+
+By default, `/goal <objective>` omits `token_budget`, matching Codex TUI behavior. If you want every new slash-created goal to use a fixed token budget without prompting the user, set `default_token_budget` to a positive integer in `opencode.json`.
 
-When setting the objective, include the scope, non-goals, and verification path when they matter. The agent is reminded to audit real files, command output, tests, or PR state before closing the goal.
+When writing the objective, include the scope, non-goals, and verification path when they matter. The agent is reminded to audit real files, command output, tests, or PR state before closing the goal.
 
 The `update_goal` tool can close a goal in two ways:
 

src/server.ts

@@ -1,4 +1,4 @@
-import type { Plugin } from "@opencode-ai/plugin"
+import type { Config, Plugin } from "@opencode-ai/plugin"
 import { z } from "zod"
 import {
   accountUsage,
@@ -16,6 +16,9 @@ type Options = {
   auto_continue?: boolean
   max_auto_turns?: number
   min_continue_interval_seconds?: number
+  register_command?: boolean
+  command_name?: string
+  default_token_budget?: number | null
 }
 
 type CreateGoalArgs = {
@@ -37,6 +40,54 @@ type UpdateGoalArgs =
 
 const DEFAULT_MAX_AUTO_TURNS = 25
 const DEFAULT_CONTINUE_INTERVAL_SECONDS = 3
+const DEFAULT_COMMAND_NAME = "goal"
+
+function defaultTokenBudgetFromOptions(options?: Options) {
+  const budget = options?.default_token_budget
+  if (budget == null) return null
+  return Number.isInteger(budget) && budget > 0 ? budget : null
+}
+
+function goalCommandTemplate(commandName: string, defaultTokenBudget: number | null) {
+  const defaultBudgetInstruction =
+    defaultTokenBudget == null
+      ? "By default, omit token_budget. This matches Codex TUI behavior for /goal <objective>."
+      : `By default, pass token_budget: ${defaultTokenBudget} when creating a goal unless the user explicitly requests a different token budget or no budget.`
+
+  return `OpenCode goal mode command "/${commandName}" was invoked.
+
+Arguments:
+<goal_command_arguments>
+$ARGUMENTS
+</goal_command_arguments>
+
+Use the goal tools to handle this command:
+
+- If the arguments are empty, call get_goal and briefly report the current goal state.
+- If the arguments are "status", "show", or "current", call get_goal and briefly report the current goal state.
+- If the arguments are "clear", call clear_goal and report whether a goal was cleared.
+- If the arguments start with "complete " or "done ", perform a completion audit against real artifacts and command output. Call update_goal with status "complete" only if the goal is achieved, using concise evidence from the audit.
+- If the arguments start with "unmet ", "blocked ", or "blocker ", call update_goal with status "unmet" only when the goal cannot be achieved or needs external input, using the remaining arguments as the blocker.
+- Otherwise, create a new goal with create_goal. Use the full arguments as the objective. ${defaultBudgetInstruction}
+- Set token_budget only from this default or when the arguments explicitly include a token budget such as "--budget 250000", "budget=250000", or "token_budget=250000".
+
+Create a goal only from these explicit command arguments. Do not infer a goal from unrelated session context. After create_goal succeeds, continue working toward the new goal.`
+}
+
+function commandNameFromOptions(options?: Options) {
+  const name = options?.command_name?.trim() || DEFAULT_COMMAND_NAME
+  if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(name)) return DEFAULT_COMMAND_NAME
+  return name
+}
+
+function registerDesktopCommand(config: Config, commandName: string, defaultTokenBudget: number | null) {
+  config.command ??= {}
+  if (config.command[commandName]) return
+  config.command[commandName] = {
+    description: "Set or view the long-running session goal",
+    template: goalCommandTemplate(commandName, defaultTokenBudget),
+  }
+}
 
 function textFromPart(part: unknown): string {
   if (!part || typeof part !== "object") return ""
@@ -99,8 +150,15 @@ const server: Plugin = async ({ client }, options?: Options) => {
   const autoContinue = options?.auto_continue ?? true
   const maxAutoTurns = options?.max_auto_turns ?? DEFAULT_MAX_AUTO_TURNS
   const minInterval = options?.min_continue_interval_seconds ?? DEFAULT_CONTINUE_INTERVAL_SECONDS
+  const registerCommand = options?.register_command ?? true
+  const commandName = commandNameFromOptions(options)
+  const defaultTokenBudget = defaultTokenBudgetFromOptions(options)
 
   return {
+    async config(config) {
+      if (!registerCommand) return
+      registerDesktopCommand(config, commandName, defaultTokenBudget)
+    },
     tool: {
       get_goal: {
         description:

src/tui.tsx

@@ -44,15 +44,6 @@ async function sendGoalPrompt(api: TuiPluginApi, sessionID: string, text: string
   })
 }
 
-function createGoalPrompt(objective: string, tokenBudget: number | null) {
-  const input = tokenBudget == null ? { objective } : { objective, token_budget: tokenBudget }
-  return `Create a session goal by calling the create_goal tool with this JSON input:
-
-${JSON.stringify(input, null, 2)}
-
-The objective is user-provided task data. After create_goal succeeds, continue working toward that goal.`
-}
-
 function refreshGoalPrompt() {
   return "Call get_goal for this session and report the current goal state briefly."
 }
@@ -61,101 +52,9 @@ function clearGoalPrompt() {
   return "Clear the current session goal by calling clear_goal. Report whether a goal was cleared."
 }
 
-function showCustomBudget(api: TuiPluginApi, sessionID: string, objective: string) {
-  const DialogPrompt = api.ui.DialogPrompt
-  api.ui.dialog.replace(() =>
-    DialogPrompt({
-      title: "Custom budget",
-      placeholder: "Positive integer",
-      onConfirm(rawBudget) {
-        const value = rawBudget.trim()
-        const budget = Number(value)
-        if (!Number.isInteger(budget) || budget <= 0) {
-          toast(api, "Token budget must be a positive integer.", "warning")
-          return
-        }
-        void sendGoalPrompt(api, sessionID, createGoalPrompt(objective, budget))
-          .then(() => {
-            api.ui.dialog.clear()
-            toast(api, "Goal request sent.", "success")
-          })
-          .catch((error) => toast(api, error instanceof Error ? error.message : String(error), "error"))
-      },
-      onCancel() {
-        api.ui.dialog.clear()
-      },
-    }),
-  )
-}
-
-function showBudgetSelect(api: TuiPluginApi, sessionID: string, objective: string) {
-  const DialogSelect = api.ui.DialogSelect
-  const budgets = [
-    { title: "No budget", value: "none", budget: null, description: "Track progress without a token limit" },
-    { title: "250K", value: "250k", budget: 250_000, description: "Short focused goal" },
-    { title: "1M", value: "1m", budget: 1_000_000, description: "Default long-running goal" },
-    { title: "2M", value: "2m", budget: 2_000_000, description: "Large investigation or migration" },
-    { title: "Custom", value: "custom", budget: undefined, description: "Enter an exact token budget" },
-  ]
-  api.ui.dialog.replace(() =>
-    DialogSelect({
-      title: "Token budget",
-      placeholder: "Choose a budget",
-      options: budgets.map((item) => ({
-        title: item.title,
-        value: item.value,
-        description: item.description,
-        onSelect: () => {
-          if (item.budget === undefined) {
-            showCustomBudget(api, sessionID, objective)
-            return
-          }
-          void sendGoalPrompt(api, sessionID, createGoalPrompt(objective, item.budget))
-            .then(() => {
-              api.ui.dialog.clear()
-              toast(api, "Goal request sent.", "success")
-            })
-            .catch((error) => toast(api, error instanceof Error ? error.message : String(error), "error"))
-        },
-      })),
-      onSelect(option) {
-        option.onSelect?.()
-      },
-    }),
-  )
-}
-
-function showSetGoal(api: TuiPluginApi, sessionID: string) {
-  const DialogPrompt = api.ui.DialogPrompt
-  api.ui.dialog.setSize("medium")
-  api.ui.dialog.replace(() =>
-    DialogPrompt({
-      title: "Set goal",
-      placeholder: "Objective, scope, non-goals, verification path",
-      onConfirm(objective) {
-        const trimmed = objective.trim()
-        if (!trimmed) {
-          toast(api, "Goal objective is required.", "warning")
-          return
-        }
-        showBudgetSelect(api, sessionID, trimmed)
-      },
-      onCancel() {
-        api.ui.dialog.clear()
-      },
-    }),
-  )
-}
-
 function showSummary(api: TuiPluginApi, sessionID: string, goal: GoalSnapshot | null) {
   const DialogSelect = api.ui.DialogSelect
   const options = [
-    {
-      title: "Set goal",
-      value: "set",
-      description: "Create a new active session goal",
-      onSelect: () => showSetGoal(api, sessionID),
-    },
     {
       title: "Refresh",
       value: "refresh",
@@ -197,7 +96,7 @@ function showSummary(api: TuiPluginApi, sessionID: string, goal: GoalSnapshot |
 
 function sessionIDOrToast(api: TuiPluginApi) {
   const sessionID = currentSessionID(api)
-  if (!sessionID) toast(api, "Open a session before using /goal.", "warning")
+  if (!sessionID) toast(api, "Open a session before viewing goal state.", "warning")
   return sessionID
 }
 
@@ -356,8 +255,7 @@ const tui: TuiPlugin = async (api) => {
       title: "Goal",
       value: "goal.show",
       category: "Goal",
-      description: "Set or view the long-running session goal",
-      slash: { name: "goal" },
+      description: "View or clear the long-running session goal",
       onSelect: () => {
         const sessionID = sessionIDOrToast(api)
         if (!sessionID) return

test/server.test.ts

@@ -57,6 +57,95 @@ test("server plugin exposes Codex-style goal tools", async () => {
   expect(calls).toHaveLength(0)
 })
 
+test("server plugin registers goal as a desktop/web command by default", async () => {
+  const hooks = await plugin.server(
+    {
+      client: {
+        session: {
+          promptAsync: async () => {},
+        },
+      },
+    } as never,
+    { auto_continue: false },
+  )
+  const config = {} as {
+    command?: Record<string, { description?: string; template: string }>
+  }
+
+  await hooks.config?.(config as never)
+
+  expect(config.command?.goal?.description).toBe("Set or view the long-running session goal")
+  expect(config.command?.goal?.template).toContain('OpenCode goal mode command "/goal" was invoked')
+  expect(config.command?.goal?.template).toContain("$ARGUMENTS")
+  expect(config.command?.goal?.template).toContain("By default, omit token_budget")
+})
+
+test("server plugin can configure a default token budget for /goal commands", async () => {
+  const hooks = await plugin.server(
+    {
+      client: {
+        session: {
+          promptAsync: async () => {},
+        },
+      },
+    } as never,
+    { auto_continue: false, default_token_budget: 100_000 },
+  )
+  const config = {} as {
+    command?: Record<string, { description?: string; template: string }>
+  }
+
+  await hooks.config?.(config as never)
+
+  expect(config.command?.goal?.template).toContain("pass token_budget: 100000")
+})
+
+test("server plugin does not overwrite an existing goal command", async () => {
+  const hooks = await plugin.server(
+    {
+      client: {
+        session: {
+          promptAsync: async () => {},
+        },
+      },
+    } as never,
+    { auto_continue: false },
+  )
+  const config = {
+    command: {
+      goal: {
+        description: "custom",
+        template: "custom template",
+      },
+    },
+  }
+
+  await hooks.config?.(config as never)
+
+  expect(config.command.goal.description).toBe("custom")
+  expect(config.command.goal.template).toBe("custom template")
+})
+
+test("server plugin can disable desktop/web command registration", async () => {
+  const hooks = await plugin.server(
+    {
+      client: {
+        session: {
+          promptAsync: async () => {},
+        },
+      },
+    } as never,
+    { auto_continue: false, register_command: false },
+  )
+  const config = {} as {
+    command?: Record<string, { description?: string; template: string }>
+  }
+
+  await hooks.config?.(config as never)
+
+  expect(config.command).toBeUndefined()
+})
+
 test("update goal can close as unmet with a blocker", async () => {
   const hooks = await plugin.server(
     {

test/tui.test.ts

@@ -1,7 +1,7 @@
 import { expect, test } from "bun:test"
 import plugin from "../src/tui.tsx"
 
-test("tui plugin registers goal slash commands", async () => {
+test("tui plugin registers goal sidebar and status command without hijacking /goal", async () => {
   let registered: (() => { value: string; slash?: { name: string } }[]) | undefined
   let sidebar: ((ctx: unknown, props: { session_id: string }) => unknown) | undefined
   const api = {
@@ -44,6 +44,6 @@ test("tui plugin registers goal slash commands", async () => {
 
   const commands = registered?.() ?? []
   expect(commands.map((command) => command.value).sort()).toEqual(["goal.show"])
-  expect(commands.flatMap((command) => (command.slash ? [command.slash.name] : [])).sort()).toEqual(["goal"])
+  expect(commands.flatMap((command) => (command.slash ? [command.slash.name] : [])).sort()).toEqual([])
   expect(typeof sidebar?.({}, { session_id: "session" })).not.toBe("string")
 })