@prevalentware/opencode-goal-plugin 0.1.41 → 0.1.43

package/README.md

@@ -16,9 +16,9 @@ Links:
 
 The OpenCode Goal Plugin adds:
 
-- `/goal <objective>` as an OpenCode command for TUI, desktop, and web.
+- `/goal <objective>`, `/pause_goal`, and `/resume_goal` as OpenCode commands for TUI, desktop, web, and remote integrations that expose the server command catalog.
 - A sidebar goal indicator with status, elapsed time, and objective.
-- Agent tools: `get_goal`, `get_goal_history`, `list_all_goals`, `create_goal`, `set_goal`, `update_goal_objective`, `update_goal`, and `clear_goal`.
+- Agent tools: `get_goal`, `get_goal_history`, `list_all_goals`, `create_goal`, `set_goal`, `update_goal_objective`, `update_goal_status`, `update_goal`, and `clear_goal`.
 - Goal close evidence: `complete` requires verified evidence, and `unmet` requires a concrete blocker.
 - Persistent per-session goal state with history, checkpoints, budgets, and owner-only file permissions.
 - Optional automatic continuation on `session.idle` / `session.status`, with no-progress pause and budget wrap-up safeguards.
@@ -165,8 +165,8 @@ Defaults:
 - `max_goal_duration_seconds`: unset by default; when set, new goals inherit this elapsed-time safety limit.
 - `no_progress_token_threshold`: `50`; output-token floor used to judge whether a goal continuation turn made progress.
 - `max_no_progress_turns`: `2`; consecutive low-progress goal continuation turns before pausing. Only turns produced by a reserved goal continuation count — ordinary low-output assistant messages (for example short tool-call-only turns from PTY or status checks) never increment this counter.
-- `register_command`: `true`
-- `command_name`: `"goal"`
+- `register_command`: `true`; registers `/goal`, `/pause_goal`, and `/resume_goal`.
+- `command_name`: `"goal"`; renames the main goal command only. The reserved names `pause_goal` and `resume_goal` fall back to `goal` so the standalone controls remain available.
 - `restricted_agents`: `["plan"]`; agents (matched case-insensitively) treated as planning-only for goal execution.
 - `allow_goal_execution_from_plan`: `false`; when `true`, disables Plan-mode goal restrictions entirely.
 
@@ -178,7 +178,7 @@ Use `/goal <objective>` in a fresh OpenCode chat to create a long-running goal:
 /goal review the frontend and translate visible English UI text to Spanish
 ```
 
-Bare `/goal` reports the current goal state. `/goal history` reports lifecycle history and recent checkpoints. `/goal edit <objective>` updates the current objective. `/goal pause` pauses the goal without clearing it, and `/goal resume` resumes it. `/goal clear` clears the goal; `/goal stop`, `/goal off`, `/goal reset`, `/goal none`, and `/goal cancel` are clear aliases. The TUI also includes a `Goal` command-palette entry for viewing, refreshing, pausing, resuming, showing history, or clearing the current goal state without creating a new goal.
+Bare `/goal` reports the current goal state. `/goal history` reports lifecycle history and recent checkpoints. `/goal edit <objective>` updates the current objective. `/goal pause` pauses the goal without clearing it, and `/goal resume` resumes it. The standalone `/pause_goal` and `/resume_goal` controls are discoverable by remote integrations that expose OpenCode's server command catalog. Their arguments and resolved attachments are removed before composing the goal-control prompt, although OpenCode V1 may evaluate its own command syntax before plugin hooks run. `/pause_goal` persists the pause before its acknowledgement turn starts, preventing a later idle event from starting another continuation. It cannot cancel a continuation that was already delivered or whose delivery was already in flight when the pause was committed. Pausing a goal that is already `budgetLimited` or `usageLimited` preserves that safety status; resuming a closed `complete` or `unmet` goal is rejected. `/goal clear` clears the goal; `/goal stop`, `/goal off`, `/goal reset`, `/goal none`, and `/goal cancel` are clear aliases. The TUI also includes a `Goal` command-palette entry for viewing, refreshing, pausing, resuming, showing history, or clearing the current goal state without creating a new goal.
 
 You can also ask the agent to formulate the objective and call `set_goal` itself, for example: "set your own goal to finish this refactor safely." The tool uses the agent-written objective but still only creates a goal when explicitly requested.
 
@@ -231,6 +231,8 @@ Ordinary fsync improves crash consistency but is not `F_FULLFSYNC`, so sudden po
 
 If the rename succeeds but syncing the parent directory reports a genuine I/O error, the mutation reports a write failure even though the new valid state may already be present. This avoids claiming durability that the filesystem did not confirm.
 
+If a non-empty state file contains only whitespace, a UTF-8 BOM, or NUL bytes after an interrupted write, the next mutation preserves its exact contents beside the state file as `goals.json.corrupt-<timestamp>-<uuid>` before writing recovered state. If another process replaces the state during recovery, the mutation refuses to overwrite that newer content. If the quarantine copy itself cannot be created, the plugin reports the failure and continues recovery rather than making every prompt fail indefinitely. OpenCode 1 also records the quarantine outcome and path through its application log so the data-loss event remains discoverable.
+
 ## Credits
 
 This plugin follows Codex's native goal-mode semantics where OpenCode plugin hooks allow it. Several hardening ideas were adapted from William Ricchiuti's [`willytop8/OpenCode-goal-plugin`](https://github.com/willytop8/OpenCode-goal-plugin), especially lifecycle history, checkpoints, no-progress safeguards, budget wrap-up behavior, and strict-provider-safe system prompt merging. Thank you, William.

package/dist/server.js

@@ -3,6 +3,7 @@
 import { z } from "zod";
 
 // src/state.ts
+import { randomUUID as randomUUID2 } from "crypto";
 import { mkdir, readFile } from "fs/promises";
 import { homedir } from "os";
 import { dirname as dirname2, join } from "path";
@@ -220,6 +221,23 @@ function mutableState(state) {
   return JSON.parse(JSON.stringify(state));
 }
 var warnedEmptyStatePaths = new Set;
+var stateRecoveryListeners = new Set;
+function onStateRecovery(stateFile, report) {
+  const listener = { stateFile, report };
+  stateRecoveryListeners.add(listener);
+  return () => stateRecoveryListeners.delete(listener);
+}
+function notifyStateRecovery(notice) {
+  for (const listener of stateRecoveryListeners) {
+    if (listener.stateFile !== notice.stateFile)
+      continue;
+    Promise.resolve().then(() => listener.report(notice)).catch((error) => {
+      try {
+        console.error(`[opencode-goal-plugin] Failed to report quarantined state at ${notice.quarantineFile}:`, error instanceof Error ? error.message : String(error));
+      } catch {}
+    });
+  }
+}
 function isStatePadding(character) {
   return character === "\x00" || character.trim() === "";
 }
@@ -232,24 +250,53 @@ function parseStateText(raw, file) {
     end -= 1;
   const content = raw.slice(start, end);
   if (content)
-    return JSON.parse(content);
+    return { value: JSON.parse(content), recoveryContent: null };
   if (!warnedEmptyStatePaths.has(file)) {
     warnedEmptyStatePaths.add(file);
     console.warn(`[opencode-goal-plugin] Empty or zero-filled state file at ${file}; recovering with empty state.`);
   }
-  return emptyState();
+  return { value: emptyState(), recoveryContent: raw || null };
 }
 function decodeState(value) {
   return Schema.decodeUnknown(StateSchema)(value).pipe(Effect.map(mutableState), Effect.map(normalizeState), Effect.mapError((cause) => new StateDecodeError({ cause })));
 }
-function readStateEffect(file = statePath()) {
+function readStateResultEffect(file = statePath()) {
   return Effect.tryPromise({
     try: () => readFile(file, "utf8"),
     catch: (cause) => new StateReadError({ cause })
   }).pipe(Effect.flatMap((raw) => Effect.try({
     try: () => parseStateText(raw, file),
     catch: (cause) => new StateDecodeError({ cause })
-  })), Effect.flatMap(decodeState), Effect.catchAll((error) => error._tag === "StateReadError" && isMissingStateFile(error.cause) ? Effect.succeed(emptyState()) : Effect.fail(error)));
+  })), Effect.flatMap(({ value, recoveryContent }) => decodeState(value).pipe(Effect.map((state) => ({ state, recoveryContent })))), Effect.catchAll((error) => error._tag === "StateReadError" && isMissingStateFile(error.cause) ? Effect.succeed({ state: emptyState(), recoveryContent: null }) : Effect.fail(error)));
+}
+function readStateEffect(file = statePath()) {
+  return readStateResultEffect(file).pipe(Effect.map(({ state }) => state));
+}
+function quarantineStateEffect(file, content) {
+  return Effect.promise(async () => {
+    const quarantineFile = `${file}.corrupt-${Date.now()}-${randomUUID2()}`;
+    try {
+      await mkdir(dirname2(file), { recursive: true, mode: 448 });
+      await atomicWriteFile(quarantineFile, content);
+      return { quarantineFile, error: null };
+    } catch (error) {
+      return { quarantineFile, error: error instanceof Error ? error.message : String(error) };
+    }
+  });
+}
+function verifyRecoverySourceEffect(file, expectedContent, quarantineFile) {
+  return Effect.promise(async () => {
+    try {
+      return await readFile(file, "utf8") === expectedContent;
+    } catch (error) {
+      if (!isMissingStateFile(error)) {
+        try {
+          console.error(`[opencode-goal-plugin] Could not re-read ${file} after preserving it at ${quarantineFile}; continuing recovery:`, error instanceof Error ? error.message : String(error));
+        } catch {}
+      }
+      return true;
+    }
+  });
 }
 function writeStateEffect(state, file = statePath()) {
   return Effect.tryPromise({
@@ -278,11 +325,46 @@ async function mutate(fn) {
   return enqueueMutation(() => {
     const file = statePath();
     return Effect.runPromise(Effect.gen(function* () {
-      const state = yield* readStateEffect(file);
+      const { state, recoveryContent } = yield* readStateResultEffect(file);
       const result = yield* Effect.tryPromise({
         try: () => Promise.resolve(fn(state)),
         catch: (cause) => cause instanceof Error ? cause : new Error(String(cause))
       });
+      if (recoveryContent != null) {
+        const quarantine = yield* quarantineStateEffect(file, recoveryContent);
+        if (quarantine.error != null) {
+          const notice = {
+            stateFile: file,
+            quarantineFile: quarantine.quarantineFile,
+            outcome: "quarantineFailed",
+            error: quarantine.error
+          };
+          try {
+            console.error(`[opencode-goal-plugin] Could not quarantine corrupt state at ${file}; continuing recovery:`, quarantine.error);
+          } catch {}
+          notifyStateRecovery(notice);
+        } else {
+          const unchanged = yield* verifyRecoverySourceEffect(file, recoveryContent, quarantine.quarantineFile);
+          if (!unchanged) {
+            const message = "goal state changed while recovery was being quarantined; refusing to overwrite it";
+            notifyStateRecovery({
+              stateFile: file,
+              quarantineFile: quarantine.quarantineFile,
+              outcome: "sourceChanged",
+              error: message
+            });
+            return yield* Effect.fail(new StateWriteError({ cause: new Error(message) }));
+          }
+          try {
+            console.warn(`[opencode-goal-plugin] Preserved corrupt state from ${file} at ${quarantine.quarantineFile}; continuing recovery.`);
+          } catch {}
+          notifyStateRecovery({
+            stateFile: file,
+            quarantineFile: quarantine.quarantineFile,
+            outcome: "quarantined"
+          });
+        }
+      }
       yield* writeStateEffect(state, file);
       return result;
     }));
@@ -609,6 +691,12 @@ async function setGoalStatus(sessionID, status, agent) {
     const goal = state.goals[sessionID];
     if (!goal)
       throw new Error("cannot update goal because this session has no goal");
+    if (isClosed(goal.status))
+      throw new Error("cannot update goal status because this goal is closed");
+    if (goal.status === status)
+      return snapshot(goal);
+    if (status === "paused" && goal.status !== "active")
+      return snapshot(goal);
     accountWallClock(goal);
     goal.status = status;
     goal.updatedAt = nowSeconds();
@@ -903,8 +991,8 @@ async function markPendingContinuationStarted(sessionID) {
     return current ? snapshotInternal(current) : null;
   if (current.pendingAttempt == null || current.pendingAttempt.started)
     return snapshotInternal(current);
-  return mutate((state2) => {
-    const goal = state2.goals[sessionID];
+  return mutate((state) => {
+    const goal = state.goals[sessionID];
     if (!goal || goal.status !== "active")
       return goal ? snapshotInternal(goal) : null;
     if (goal.pendingAttempt == null || goal.pendingAttempt.started)
@@ -1203,10 +1291,60 @@ Use the goal tools to handle this command:
 
 Create a goal only from these explicit command arguments. Do not infer a goal from unrelated session context. After create_goal succeeds or returns an existing matching goal, never call it again for this command; continue working from the returned goal state.`;
 }
+function goalStatusCommandTemplate(commandName) {
+  if (commandName === "pause_goal") {
+    return `OpenCode goal mode command "/pause_goal" was invoked.
+
+The command handler pauses an active goal before this acknowledgement turn when possible. Ignore any command arguments, call get_goal first, then handle only this pause request:
+
+- If there is no goal, briefly report that no goal is set.
+- If the goal is paused, do not mutate it again; briefly confirm "Goal paused."
+- If the goal is still active, call update_goal_status with status "paused" and briefly report the result.
+- If the goal is budgetLimited or usageLimited, do not mutate it; briefly report that it remains stopped by its safety limit.
+- If the goal is complete or unmet, do not mutate it; briefly report that it is closed.
+
+Do not create, resume, or continue a goal. Do not edit, clear, complete, or mark a goal unmet.`;
+  }
+  return `OpenCode goal mode command "/resume_goal" was invoked.
+
+Ignore any command arguments. Call get_goal first, then handle only this resume request:
+
+- If there is no goal, briefly report that no goal is set.
+- If the goal is complete or unmet, do not mutate it; you must not reopen it.
+- If the goal is already active, do not mutate it; continue working toward its existing objective.
+- If the goal is paused, budgetLimited, or usageLimited, call update_goal_status with status "active", then continue working toward its existing objective.
+- If Plan mode or another restricted agent prevents resuming, report that the user must switch to Build mode instead of retrying.
+
+Do not create, edit, clear, complete, or mark a goal unmet.`;
+}
+function goalCommandDefinitions(commandName) {
+  return [
+    {
+      name: commandName,
+      description: "Set or view the long-running session goal",
+      template: goalCommandTemplate(commandName),
+      action: "goal"
+    },
+    {
+      name: "pause_goal",
+      description: "Pause the current long-running session goal",
+      template: goalStatusCommandTemplate("pause_goal"),
+      action: "pause"
+    },
+    {
+      name: "resume_goal",
+      description: "Resume the current long-running session goal",
+      template: goalStatusCommandTemplate("resume_goal"),
+      action: "resume"
+    }
+  ];
+}
 function commandNameFromOptions(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;
+  if (name.toLowerCase() === "pause_goal" || name.toLowerCase() === "resume_goal")
+    return DEFAULT_COMMAND_NAME;
   return name;
 }
 function positiveIntegerOrNull2(value) {
@@ -1220,14 +1358,25 @@ function timeoutMillisecondsFromSeconds(value) {
     return null;
   return Math.min(Math.ceil(value * 1000), MAX_TIMER_DELAY_MS);
 }
-function registerDesktopCommand(config, commandName) {
+function registerDesktopCommands(config, commandName) {
   config.command ??= {};
-  if (config.command[commandName])
-    return;
-  config.command[commandName] = {
-    description: "Set or view the long-running session goal",
-    template: goalCommandTemplate(commandName)
-  };
+  const commands = goalCommandDefinitions(commandName);
+  for (const command of commands) {
+    if (config.command[command.name])
+      continue;
+    config.command[command.name] = {
+      description: command.description,
+      template: command.template
+    };
+  }
+}
+function sanitizeGoalStatusCommandParts(output, template) {
+  const text = output.parts.find((part) => part.type === "text" && part.text?.startsWith(template));
+  if (!text)
+    return false;
+  text.text = template;
+  output.parts.splice(0, output.parts.length, text);
+  return true;
 }
 function textFromPart(part) {
   if (!part || typeof part !== "object")
@@ -1851,10 +2000,10 @@ async function updateGoalObjectiveFromTool(input, context, services) {
 }
 async function closeGoalFromTool(input, context) {
   if (input.status === "complete") {
-    const goal2 = await completeGoal(context.sessionID, input.evidence ?? "");
-    const budget = goal2.tokenBudget == null ? "" : ` Token usage: ${goal2.tokensUsed}/${goal2.tokenBudget}.`;
-    const report2 = `Goal achieved. Time used: ${goal2.timeUsedSeconds} seconds.${budget} Evidence: ${goal2.completionEvidence}.`;
-    return JSON.stringify({ goal: goal2, completion_report: report2 }, null, 2);
+    const goal = await completeGoal(context.sessionID, input.evidence ?? "");
+    const budget = goal.tokenBudget == null ? "" : ` Token usage: ${goal.tokensUsed}/${goal.tokenBudget}.`;
+    const report = `Goal achieved. Time used: ${goal.timeUsedSeconds} seconds.${budget} Evidence: ${goal.completionEvidence}.`;
+    return JSON.stringify({ goal, completion_report: report }, null, 2);
   }
   const goal = await markGoalUnmet(context.sessionID, input.blocker ?? "");
   const report = `Goal unmet. Time used: ${goal.timeUsedSeconds} seconds. Blocker: ${goal.blocker}.`;
@@ -1932,6 +2081,16 @@ var server = async ({ client }, options) => {
   const planAgents = restrictedAgentSet(options);
   const isPlanAgent = (agent) => typeof agent === "string" && planAgents.has(agent.trim().toLowerCase());
   const goalServices = { options: options ?? {}, isPlanAgent };
+  const stopStateRecoveryReporting = onStateRecovery(statePath(), async ({ stateFile, quarantineFile, outcome, error }) => {
+    await client.app?.log?.({
+      body: {
+        service: "opencode-goal-plugin",
+        level: "error",
+        message: outcome === "quarantined" ? "Corrupt goal state quarantined before recovery" : outcome === "sourceChanged" ? "Goal state changed during recovery; refusing to overwrite it" : "Corrupt goal state could not be quarantined; continuing recovery",
+        extra: { stateFile, quarantineFile, outcome, ...error ? { error } : {} }
+      }
+    });
+  });
   let disposed = false;
   async function taskBlockStatus(sessionID) {
     if (!deferWhileTasksActive)
@@ -2180,6 +2339,7 @@ var server = async ({ client }, options) => {
   return {
     async dispose() {
       disposed = true;
+      stopStateRecoveryReporting();
       for (const scheduled of scheduledContinuations.values())
         clearTimeout(scheduled.timer);
       scheduledContinuations.clear();
@@ -2194,7 +2354,7 @@ var server = async ({ client }, options) => {
     async config(config) {
       if (!registerCommand)
         return;
-      registerDesktopCommand(config, commandName);
+      registerDesktopCommands(config, commandName);
     },
     tool: {
       get_goal: {
@@ -2290,6 +2450,20 @@ var server = async ({ client }, options) => {
         toolAttempts.set(toolAttemptKey(sessionID, callID), goal?.pendingAttempt?.id ?? null);
       }
     },
+    async "command.execute.before"(input, output) {
+      if (input.command !== "pause_goal" && input.command !== "resume_goal")
+        return;
+      const template = goalStatusCommandTemplate(input.command);
+      if (!sanitizeGoalStatusCommandParts(output, template))
+        return;
+      if (input.command !== "pause_goal")
+        return;
+      const goal = await getGoal(input.sessionID);
+      if (goal?.status === "active")
+        await setGoalStatus(input.sessionID, "paused");
+      cancelScheduledContinuation(input.sessionID);
+      clearTurnWatchdog(input.sessionID);
+    },
     async "tool.execute.after"(input, output) {
       taskTracker.noteTaskOutput(input, output);
       const sessionID = typeof input?.sessionID === "string" ? input.sessionID : undefined;
@@ -2496,10 +2670,10 @@ async function setupV2(context) {
   };
   const registrations = [];
   let disposed = false;
-  function stepKey(sessionID, messageID2) {
-    return `${sessionID}\x00${messageID2}`;
+  function stepKey(sessionID, messageID) {
+    return `${sessionID}\x00${messageID}`;
   }
-  async function sendContinuation2(sessionID, prompt, agent) {
+  async function sendContinuation(sessionID, prompt, agent) {
     await context.session.prompt({
       sessionID,
       text: prompt,
@@ -2564,7 +2738,7 @@ async function setupV2(context) {
       activeContinuationsV2.add(sessionID);
       claimedContinuation = true;
       watchdogRescuedSessions.add(sessionID);
-      await sendContinuation2(sessionID, continuationPrompt(current), current.lastPromptAgent ?? latestStep?.agent ?? null);
+      await sendContinuation(sessionID, continuationPrompt(current), current.lastPromptAgent ?? latestStep?.agent ?? null);
       await recordContinuationResult(sessionID, "success", maxPromptFailures, { armNoProgress: false, started: true });
       locallyDeliveredPendingSessions.add(sessionID);
       clearTurnWatchdog(sessionID);
@@ -2716,7 +2890,7 @@ async function setupV2(context) {
         await rollbackContinuationAttempt(sessionID);
         return;
       }
-      await sendContinuation2(sessionID, goal.status === "active" ? continuationPrompt(goal) : limitPrompt(goal), goal.lastPromptAgent ?? latestTurnAgent ?? null);
+      await sendContinuation(sessionID, goal.status === "active" ? continuationPrompt(goal) : limitPrompt(goal), goal.lastPromptAgent ?? latestTurnAgent ?? null);
       if (disposed) {
         await rollbackContinuationAttempt(sessionID);
         return;
@@ -2861,16 +3035,16 @@ async function setupV2(context) {
       case "session.step.started": {
         if (!sessionID || typeof data.assistantMessageID !== "string")
           return;
-        const messageID2 = data.assistantMessageID;
+        const messageID = data.assistantMessageID;
         const agent = typeof data.agent === "string" ? data.agent : undefined;
         if (agent)
           await recordPromptAgent(sessionID, agent);
         taskTracker.observeAssistantMessage(sessionID, {
-          info: { id: messageID2, role: "assistant", time: { completed: event.created } }
+          info: { id: messageID, role: "assistant", time: { completed: event.created } }
         });
-        if (!stepTextBuffers.has(stepKey(sessionID, messageID2)))
-          stepTextBuffers.set(stepKey(sessionID, messageID2), "");
-        latestStepBySession.set(sessionID, { messageID: messageID2, agent, text: "", outputTokens: null, completedAt: event.created });
+        if (!stepTextBuffers.has(stepKey(sessionID, messageID)))
+          stepTextBuffers.set(stepKey(sessionID, messageID), "");
+        latestStepBySession.set(sessionID, { messageID, agent, text: "", outputTokens: null, completedAt: event.created });
         return;
       }
       case "session.text.delta": {
@@ -2889,7 +3063,7 @@ async function setupV2(context) {
       case "session.step.ended": {
         if (!sessionID || typeof data.assistantMessageID !== "string")
           return;
-        const messageID2 = data.assistantMessageID;
+        const messageID = data.assistantMessageID;
         const tokens = tokensFromRecord(data.tokens);
         if (typeof tokens === "number") {
           const sum = (stepTokenSums.get(sessionID) ?? 0) + tokens;
@@ -2900,11 +3074,11 @@ async function setupV2(context) {
             initialBaseline: Math.ceil(sum - tokens)
           });
         }
-        const text = stepTextBuffers.get(stepKey(sessionID, messageID2)) ?? "";
-        stepTextBuffers.delete(stepKey(sessionID, messageID2));
+        const text = stepTextBuffers.get(stepKey(sessionID, messageID)) ?? "";
+        stepTextBuffers.delete(stepKey(sessionID, messageID));
         const outputTokens = outputTokensFromRecord(data.tokens) ?? null;
         const afterStep = await recordAssistantProgress(sessionID, {
-          messageID: messageID2,
+          messageID,
           text,
           outputTokens,
           noProgressTokenThreshold: positiveIntegerOrNull2(options.no_progress_token_threshold),
@@ -2918,7 +3092,7 @@ async function setupV2(context) {
             cancelScheduledContinuation(sessionID);
         }
         latestStepBySession.set(sessionID, {
-          messageID: messageID2,
+          messageID,
           agent: latestStepBySession.get(sessionID)?.agent,
           text,
           outputTokens,
@@ -2929,7 +3103,7 @@ async function setupV2(context) {
       case "session.step.failed": {
         if (!sessionID || typeof data.assistantMessageID !== "string")
           return;
-        const messageID2 = data.assistantMessageID;
+        const messageID = data.assistantMessageID;
         const tokens = tokensFromRecord(data.tokens);
         if (typeof tokens === "number") {
           const sum = (stepTokenSums.get(sessionID) ?? 0) + tokens;
@@ -2940,11 +3114,11 @@ async function setupV2(context) {
             initialBaseline: Math.ceil(sum - tokens)
           });
         }
-        const text = stepTextBuffers.get(stepKey(sessionID, messageID2)) ?? "";
-        stepTextBuffers.delete(stepKey(sessionID, messageID2));
+        const text = stepTextBuffers.get(stepKey(sessionID, messageID)) ?? "";
+        stepTextBuffers.delete(stepKey(sessionID, messageID));
         const outputTokens = outputTokensFromRecord(data.tokens) ?? null;
         const afterStep = await recordAssistantProgress(sessionID, {
-          messageID: messageID2,
+          messageID,
           text,
           outputTokens,
           noProgressTokenThreshold: positiveIntegerOrNull2(options.no_progress_token_threshold),
@@ -2958,7 +3132,7 @@ async function setupV2(context) {
             cancelScheduledContinuation(sessionID);
         }
         latestStepBySession.set(sessionID, {
-          messageID: messageID2,
+          messageID,
           agent: latestStepBySession.get(sessionID)?.agent,
           text,
           outputTokens,
@@ -2977,23 +3151,39 @@ async function setupV2(context) {
     }
   }
   if (registerCommand) {
+    const existingCommands = new Set((await context.command.list()).data.map((command) => command.name));
     registrations.push(await context.command.transform((draft) => {
-      draft.add({
-        name: commandName,
-        description: "Set or view the long-running session goal",
-        execute: async (input) => {
-          const stripMention = ({ mention: _mention, ...attachment }) => attachment;
-          await context.session.prompt({
-            ...input.prompt,
-            files: input.prompt.files?.map(stripMention),
-            agents: input.prompt.agents?.map(stripMention),
-            skills: input.prompt.skills?.map(stripMention),
-            sessionID: input.sessionID,
-            text: goalCommandTemplate(commandName).replaceAll("$ARGUMENTS", () => input.prompt.text.trim()),
-            delivery: input.delivery
-          });
-        }
-      });
+      const claimedCommands = new Set(existingCommands);
+      for (const command of goalCommandDefinitions(commandName)) {
+        if (claimedCommands.has(command.name))
+          continue;
+        claimedCommands.add(command.name);
+        draft.add({
+          name: command.name,
+          description: command.description,
+          execute: async (input) => {
+            if (command.action === "pause") {
+              const goal = await getGoal(input.sessionID);
+              if (goal?.status === "active")
+                await setGoalStatus(input.sessionID, "paused");
+              cancelScheduledContinuation(input.sessionID);
+              clearTurnWatchdog(input.sessionID);
+            }
+            const stripMention = ({ mention: _mention, ...attachment }) => attachment;
+            await context.session.prompt({
+              ...command.action === "goal" ? {
+                ...input.prompt,
+                files: input.prompt.files?.map(stripMention),
+                agents: input.prompt.agents?.map(stripMention),
+                skills: input.prompt.skills?.map(stripMention)
+              } : {},
+              sessionID: input.sessionID,
+              text: command.template.replaceAll("$ARGUMENTS", () => input.prompt.text.trim()),
+              delivery: input.delivery
+            });
+          }
+        });
+      }
     }));
   }
   registrations.push(await context.tool.transform((draft) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prevalentware/opencode-goal-plugin",
-  "version": "0.1.41",
+  "version": "0.1.43",
   "description": "OpenCode goal plugin that adds Codex-style long-running goal mode, /goal commands, persistence, and TUI status for AI coding agents.",
   "keywords": [
     "opencode",