@prevalentware/opencode-goal-plugin 0.1.53 → 0.1.55

package/README.md

@@ -315,6 +315,13 @@ OpenCode plugin modules are target-specific. This package exports separate modul
 }
 ```
 
-Codex goal mode has deeper runtime integration for thread lifecycle control. This plugin implements the same workflow using OpenCode plugin hooks. Token usage is read from OpenCode step-finish usage when available and falls back to message token metadata or text estimation when exact usage is unavailable. Continuation is driven by V2 `session.execution.succeeded` events and legacy `session.idle` / `session.status` idle notifications, never by intermediate model-step completion. V2 execution starts arm busy tracking; native `session.retry.scheduled` events cancel plugin recovery while OpenCode retries. Terminal execution transport failures use bounded recovery, while interruptions (user, shutdown, or superseded) cancel local timers without starting another turn or charging a prompt failure. Interrupted or non-transport-failed executions remain suppressed until the host starts a new execution; this does not change the persisted goal status. Use `/pause_goal` for a durable pause. Each V2 plugin instance handles goal events only for its own location while still observing cross-location child task lifecycles. The optional `max_turn_time` watchdog can retry one goal continuation prompt when a model turn remains busy, without consuming the goal's auto-turn or no-progress budgets; recognized transport failures do count toward the prompt-failure ceiling. By default, continuation is deferred while OpenCode Task child sessions are active or their terminal result still needs an orchestrator turn, bounded by the `max_task_block_seconds` ceiling so an unobservable child cannot stall a goal indefinitely. During compaction on OpenCode 1, the plugin disables OpenCode's generic synthetic auto-continue while an active goal exists so the goal-specific continuation prompt remains authoritative; on OpenCode 2, compaction runs inside the session's execution flow, so the plugin instead injects the goal snapshot through the `session.compaction` hook where the host provides it.
+Codex goal mode has deeper runtime integration for thread lifecycle control. This plugin implements the same workflow using OpenCode plugin hooks. Token usage is read from OpenCode step-finish usage when available and falls back to message token metadata or text estimation when exact usage is unavailable. Continuation is driven by V2 `session.execution.succeeded` events and legacy `session.idle` / `session.status` idle notifications, never by intermediate model-step completion. V2 execution starts arm busy tracking; native `session.retry.scheduled` events cancel plugin recovery while OpenCode retries. Terminal execution transport failures use bounded recovery. A V2 `session.execution.interrupted` event with reason `user`, or a V1 session/assistant `MessageAbortedError`, persists a terminal `cancelled` state for an active goal and invalidates timers and outstanding continuation preparation without charging a prompt failure. A later idle, unrelated prompt, or plugin reload cannot resume that goal; start an explicitly requested new goal with `/goal <objective>` or `/goal replace <objective>`. Cancelling a manual turn preserves paused or limited goals. V2 shutdown, superseded, and other interruptions only suppress local continuation until the host starts another execution; they do not cancel the persisted goal. V1 exposes only `MessageAbortedError`, so it cannot distinguish user cancellation from other host aborts of an active goal. Use `/pause_goal` for a durable, resumable pause. Each V2 plugin instance handles goal events only for its own location while still observing cross-location child task lifecycles. The optional `max_turn_time` watchdog can retry one goal continuation prompt when a model turn remains busy, without consuming the goal's auto-turn or no-progress budgets; recognized transport failures do count toward the prompt-failure ceiling. By default, continuation is deferred while OpenCode Task child sessions are active or their terminal result still needs an orchestrator turn, bounded by the `max_task_block_seconds` ceiling so an unobservable child cannot stall a goal indefinitely. During compaction on OpenCode 1, the plugin disables OpenCode's generic synthetic auto-continue while an active goal exists so the goal-specific continuation prompt remains authoritative; on OpenCode 2, compaction runs inside the session's execution flow, so the plugin instead injects the goal snapshot through the `session.compaction` hook where the host provides it.
 
-The goal sidebar shows the current status, elapsed time, token usage, auto-continue count, latest checkpoint, latest status message, stop reason, and objective when a goal is active, paused, or safety-limited. Closed goals remain visible briefly through the latest tool state as achieved or unmet.
+The goal sidebar shows the current status, elapsed time, token usage, auto-continue count, latest checkpoint, latest status message, stop reason, and objective when a goal is active, paused, or safety-limited. It checks the shared goal state file every second so usage and checkpoints stay current during a long run. Closed goals remain visible briefly through the latest tool state as achieved or unmet.
+
+
+### Zed and ACP lifecycle boundaries
+
+Cancelling an active goal from an ACP client is durable when OpenCode emits the user-cancellation events described above. The plugin prevents subsequent goal continuations, including callbacks still preparing a prompt when cancellation arrives. OpenCode owns cancellation of in-flight model requests, tools, subprocesses, and already submitted prompts; the plugin cannot guarantee process termination if the host does not abort them or does not publish a cancellation signal. It does not interpret ordinary idle events, provider-error text, or completed tool calls as user cancellation.
+
+Goal lifetime and ACP prompt-turn lifetime are separate. The plugin continues an active goal across successful executions, but does not control the ACP adapter's response to `session/prompt`. A host that returns `end_turn` after the initial execution can therefore show an idle client while subsequent goal work runs. In an isolated OpenCode 2.0.21 ACP test, registered `/goal` commands returned `end_turn` while their submitted execution was still running; a normal `session/prompt` remained open and returned `cancelled` after Cancel. Keeping that ACP request open across goal continuations, and exposing structured goal plans as ACP `plan` updates, requires host integration. Request or phase completion alone must not mark a goal complete. Long-running goals remain supported within the configured budgets; this cancellation handling adds no timeout.

package/dist/server.js

@@ -5,8 +5,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";
+import { dirname as dirname2 } from "path";
 import { Data, Effect, Schema } from "effect";
 
 // src/atomic-write.ts
@@ -117,6 +116,16 @@ async function atomicWriteFile(file, data, ops = defaultAtomicWriteOps) {
   }
 }
 
+// src/state-path.ts
+import { homedir } from "os";
+import { join } from "path";
+function statePath() {
+  if (process.env.OPENCODE_GOAL_STATE_PATH)
+    return process.env.OPENCODE_GOAL_STATE_PATH;
+  const dataHome = process.env.XDG_DATA_HOME || (process.platform === "win32" && process.env.APPDATA ? process.env.APPDATA : join(homedir(), ".local", "share"));
+  return join(dataHome, "opencode-goal-plugin", "goals.json");
+}
+
 // src/state.ts
 class StateReadError extends Data.TaggedError("StateReadError") {
 }
@@ -232,13 +241,6 @@ var StateSchema = Schema.Struct({
   })
 });
 var PersistedStateSchema = Schema.Union(LegacyStateSchema, StateSchema);
-function defaultStateFile() {
-  const dataHome = process.env.XDG_DATA_HOME || (process.platform === "win32" && process.env.APPDATA ? process.env.APPDATA : join(homedir(), ".local", "share"));
-  return join(dataHome, "opencode-goal-plugin", "goals.json");
-}
-function statePath() {
-  return process.env.OPENCODE_GOAL_STATE_PATH || defaultStateFile();
-}
 function nowSeconds() {
   return Math.floor(Date.now() / 1000);
 }
@@ -886,6 +888,16 @@ async function cancelGoal(sessionID, reason = "cancelled") {
     return snapshot(goal);
   });
 }
+async function cancelActiveGoal(sessionID) {
+  return mutate((state) => {
+    const goal = state.goals[sessionID];
+    if (!goal)
+      return null;
+    if (goal.status === "active")
+      cancelGoalRecord(goal, "cancelled");
+    return snapshot(goal);
+  });
+}
 async function clearGoal(sessionID) {
   return mutate((state) => {
     const goal = state.goals[sessionID];
@@ -1935,6 +1947,27 @@ var NON_TRANSPORT_TERMINAL_PATTERN = /\b(?:abort(?:ed)?|interrupt(?:ed|ion)?)\b/
 var NON_PROGRESS_TOOLS = new Set(["get_goal", "get_goal_history", "list_all_goals"]);
 var TASK_TERMINAL_STATES = new Set(["completed", "error", "cancelled"]);
 var activeContinuations = new Set;
+
+class ContinuationEpochs {
+  values = new Map;
+  current(sessionID) {
+    return this.values.get(sessionID) ?? 0;
+  }
+  invalidate(sessionID) {
+    this.values.set(sessionID, this.current(sessionID) + 1);
+  }
+}
+function isUserAbortEvent(event) {
+  const properties = event.properties;
+  if (event.type === "session.error") {
+    return isRecord(properties?.error) && properties.error.name === "MessageAbortedError";
+  }
+  const message = properties?.info;
+  return event.type === "message.updated" && isRecord(message) && message.role === "assistant" && isRecord(message.error) && message.error.name === "MessageAbortedError";
+}
+function continuationStillReserved(goal, current) {
+  return current?.id === goal.id && current.status === goal.status && (goal.status !== "active" || current.pendingAttempt?.id === goal.pendingAttempt?.id);
+}
 function restrictedAgentSet(options) {
   if (options?.allow_goal_execution_from_plan === true)
     return new Set;
@@ -2961,6 +2994,7 @@ var server = async ({ client }, options) => {
   const toolAttempts = new Map;
   const explicitResumeRequests = new Set;
   const restartAfterContinuation = new Set;
+  const continuationEpochs = new ContinuationEpochs;
   const watchdogRescuedSessions = new Set;
   const planAgents = restrictedAgentSet(options);
   const isPlanAgent = (agent) => typeof agent === "string" && planAgents.has(agent.trim().toLowerCase());
@@ -2972,6 +3006,7 @@ var server = async ({ client }, options) => {
     maxObjectiveChars: objectiveChars,
     consumeAutoTurnReset: (sessionID) => explicitResumeRequests.delete(sessionID),
     stopAutonomy: (sessionID, mode = "stop") => {
+      continuationEpochs.invalidate(sessionID);
       cancelScheduledContinuation(sessionID);
       if (mode === "stop")
         clearTurnWatchdog(sessionID);
@@ -3025,6 +3060,8 @@ var server = async ({ client }, options) => {
     turnWatchdogs.set(sessionID, watchdog);
   }
   async function runTurnWatchdog(sessionID, watchdog) {
+    const epoch = continuationEpochs.current(sessionID);
+    const isCurrent = () => !disposed && epoch === continuationEpochs.current(sessionID);
     let claimedContinuation = false;
     let claimedGoalID;
     try {
@@ -3060,17 +3097,23 @@ var server = async ({ client }, options) => {
       claimedContinuation = true;
       claimedGoalID = current.id;
       watchdogRescuedSessions.add(sessionID);
+      if (!isCurrent())
+        return;
       await sendContinuation(client, sessionID, continuationPrompt(current, locale), current.lastPromptAgent ?? latestTurnAgent ?? null);
-      await recordContinuationResult(sessionID, "success", maxPromptFailures, {
+      if (!isCurrent())
+        return;
+      const delivered = await recordContinuationResult(sessionID, "success", maxPromptFailures, {
         armNoProgress: false,
         started: true,
         expectedGoalID: claimedGoalID
       });
-      locallyDeliveredPendingSessions.add(sessionID);
-      clearTurnWatchdog(sessionID);
+      if (isCurrent() && delivered?.pendingAttempt?.delivered) {
+        locallyDeliveredPendingSessions.add(sessionID);
+        clearTurnWatchdog(sessionID);
+      }
     } catch (error) {
       try {
-        if (claimedContinuation && isTransportError(error)) {
+        if (claimedContinuation && isCurrent() && isTransportError(error)) {
           await recordContinuationResult(sessionID, "failure", maxPromptFailures, { expectedGoalID: claimedGoalID });
         }
         await client.app?.log?.({
@@ -3140,16 +3183,24 @@ var server = async ({ client }, options) => {
       return;
     if (activeContinuations.has(sessionID))
       return;
+    const epoch = continuationEpochs.current(sessionID);
+    const isCurrent = () => !disposed && epoch === continuationEpochs.current(sessionID);
     activeContinuations.add(sessionID);
     let attemptReservedAt = Date.now();
     let attemptGoalID;
     let attemptID;
     try {
       const latestAssistant = await fetchLatestAssistant(client, sessionID);
+      if (!isCurrent())
+        return;
       taskTracker.observeAssistantMessage(sessionID, latestAssistant);
       const taskStatus = await taskBlockStatus(sessionID);
+      if (!isCurrent())
+        return;
       if (taskStatus && taskStatus.blocked) {
         const deferralGoal = await getGoalInternal(sessionID);
+        if (!isCurrent())
+          return;
         if (!taskDeferralGoalContinuable(deferralGoal)) {
           taskDeferredSessions.delete(sessionID);
           cancelScheduledContinuation(sessionID);
@@ -3159,7 +3210,7 @@ var server = async ({ client }, options) => {
         scheduleSettledContinuation(sessionID, taskStatus.retryAt != null ? taskStatus.retryAt - Date.now() : TASK_BLOCK_RETRY_MS, scheduled != null || taskStatus.retryAt != null);
         return;
       }
-      if (busySessions.has(sessionID))
+      if (!isCurrent() || busySessions.has(sessionID))
         return;
       const observed = await recordAssistantMessage(sessionID, latestAssistant, options ?? {}, true);
       await reconcileLocalMarkerAfterProgress(locallyDeliveredPendingSessions, sessionID, observed.goal);
@@ -3169,7 +3220,7 @@ var server = async ({ client }, options) => {
       if (scheduled && scheduledContinuations.get(sessionID) !== scheduled)
         return;
       const current = await getGoalInternal(sessionID);
-      if (!current)
+      if (!isCurrent() || !current)
         return;
       const latestTurnAgent = agentFromMessage(latestAssistant);
       if (isPlanAgent(current.lastPromptAgent) || isPlanAgent(latestTurnAgent)) {
@@ -3207,7 +3258,7 @@ var server = async ({ client }, options) => {
         return;
       if (!autoContinue)
         return;
-      if (nativeRetrySessions.has(sessionID))
+      if (!isCurrent() || nativeRetrySessions.has(sessionID))
         return;
       const goal = await reserveContinuation(sessionID, maxAutoTurns, minInterval);
       if (!goal)
@@ -3215,7 +3266,8 @@ var server = async ({ client }, options) => {
       attemptReservedAt = goal.pendingAttempt?.reservedAt ?? Date.now();
       attemptGoalID = goal.id;
       attemptID = goal.pendingAttempt?.id;
-      if (nativeRetrySessions.has(sessionID)) {
+      const beforeDelivery = await getGoalInternal(sessionID);
+      if (!isCurrent() || !continuationStillReserved(goal, beforeDelivery) || busySessions.has(sessionID) || nativeRetrySessions.has(sessionID)) {
         await rollbackContinuationAttempt(sessionID, { goalID: attemptGoalID, attemptID });
         return;
       }
@@ -3224,19 +3276,20 @@ var server = async ({ client }, options) => {
         return;
       }
       await sendContinuation(client, sessionID, goal.status === "active" ? continuationPrompt(goal, locale) : limitPrompt(goal, locale), goal.lastPromptAgent ?? latestTurnAgent ?? null);
-      if (disposed) {
+      if (!isCurrent()) {
         await rollbackContinuationAttempt(sessionID, { goalID: attemptGoalID, attemptID });
         return;
       }
       const delivered = await recordContinuationResult(sessionID, "success", maxPromptFailures, {
         expectedGoalID: attemptGoalID
       });
-      locallyDeliveredPendingSessions.add(sessionID);
+      if (isCurrent() && delivered?.pendingAttempt?.delivered)
+        locallyDeliveredPendingSessions.add(sessionID);
       if (!delivered?.pendingAttempt?.delivered) {
         await rollbackContinuationAttempt(sessionID, { goalID: attemptGoalID, attemptID });
       }
     } catch (error) {
-      if (disposed) {
+      if (!isCurrent()) {
         await rollbackContinuationAttempt(sessionID, { goalID: attemptGoalID, attemptID });
         return;
       }
@@ -3501,6 +3554,17 @@ var server = async ({ client }, options) => {
     async event({ event }) {
       const sessionID = sessionIDFromEvent(event);
       const eventType = event.type;
+      if (sessionID && isUserAbortEvent(event)) {
+        explicitResumeRequests.delete(sessionID);
+        goalServices.stopAutonomy?.(sessionID);
+        busySessions.delete(sessionID);
+        nativeRetrySessions.delete(sessionID);
+        watchdogRescuedSessions.delete(sessionID);
+        clearToolAttemptsForSession(toolAttempts, sessionID);
+        taskTracker.observeSessionStatus(sessionID, "idle");
+        await cancelActiveGoal(sessionID);
+        return;
+      }
       if (eventType === "session.created") {
         taskTracker.observeSessionCreated(event);
       }
@@ -3569,6 +3633,7 @@ var server = async ({ client }, options) => {
         }
       }
       if (sessionID && eventType === "session.deleted") {
+        continuationEpochs.invalidate(sessionID);
         explicitResumeRequests.delete(sessionID);
         busySessions.delete(sessionID);
         clearTurnWatchdog(sessionID);
@@ -3633,6 +3698,7 @@ async function setupV2(context) {
   const isPlanAgent = (agent) => typeof agent === "string" && planAgents.has(agent.trim().toLowerCase());
   const activeContinuationsV2 = new Set;
   const restartAfterContinuation = new Set;
+  const continuationEpochs = new ContinuationEpochs;
   const stoppedExecutions = new Set;
   const latestStepBySession = new Map;
   const stepTextBuffers = new Map;
@@ -3652,6 +3718,7 @@ async function setupV2(context) {
       }
     },
     stopAutonomy: (sessionID, mode = "stop") => {
+      continuationEpochs.invalidate(sessionID);
       cancelScheduledContinuation(sessionID);
       if (mode === "stop")
         clearTurnWatchdog(sessionID);
@@ -3710,6 +3777,8 @@ async function setupV2(context) {
     turnWatchdogs.set(sessionID, watchdog);
   }
   async function runTurnWatchdog(sessionID, watchdog) {
+    const epoch = continuationEpochs.current(sessionID);
+    const isCurrent = () => !disposed && epoch === continuationEpochs.current(sessionID);
     let claimedContinuation = false;
     let claimedGoalID;
     try {
@@ -3741,17 +3810,23 @@ async function setupV2(context) {
       claimedContinuation = true;
       claimedGoalID = current.id;
       watchdogRescuedSessions.add(sessionID);
+      if (!isCurrent())
+        return;
       await sendContinuation(sessionID, continuationPrompt(current, locale), current.lastPromptAgent ?? latestStep?.agent ?? null);
-      await recordContinuationResult(sessionID, "success", maxPromptFailures, {
+      if (!isCurrent())
+        return;
+      const delivered = await recordContinuationResult(sessionID, "success", maxPromptFailures, {
         armNoProgress: false,
         started: true,
         expectedGoalID: claimedGoalID
       });
-      locallyDeliveredPendingSessions.add(sessionID);
-      clearTurnWatchdog(sessionID);
+      if (isCurrent() && delivered?.pendingAttempt?.delivered) {
+        locallyDeliveredPendingSessions.add(sessionID);
+        clearTurnWatchdog(sessionID);
+      }
     } catch (error) {
       try {
-        if (claimedContinuation && isTransportError(error)) {
+        if (claimedContinuation && isCurrent() && isTransportError(error)) {
           await recordContinuationResult(sessionID, "failure", maxPromptFailures, { expectedGoalID: claimedGoalID });
         }
         v2ErrorLog("Turn watchdog retry failed", error);
@@ -3816,8 +3891,10 @@ async function setupV2(context) {
       return;
     if (activeContinuationsV2.has(sessionID))
       return;
+    const epoch = continuationEpochs.current(sessionID);
+    const isCurrent = () => !disposed && epoch === continuationEpochs.current(sessionID);
     await taskRecoveryComplete;
-    if (disposed || stoppedExecutions.has(sessionID) || busySessions.has(sessionID))
+    if (!isCurrent() || stoppedExecutions.has(sessionID) || busySessions.has(sessionID))
       return;
     activeContinuationsV2.add(sessionID);
     let attemptReservedAt = Date.now();
@@ -3831,6 +3908,8 @@ async function setupV2(context) {
       const taskStatus = taskBlockStatus(sessionID);
       if (taskStatus && taskStatus.blocked) {
         const deferralGoal = await getGoalInternal(sessionID);
+        if (!isCurrent())
+          return;
         if (!taskDeferralGoalContinuable(deferralGoal)) {
           taskDeferredSessions.delete(sessionID);
           cancelScheduledContinuation(sessionID);
@@ -3862,7 +3941,7 @@ async function setupV2(context) {
       if (scheduled && scheduledContinuations.get(sessionID) !== scheduled)
         return;
       const current = await getGoalInternal(sessionID);
-      if (!current)
+      if (!isCurrent() || !current)
         return;
       const latestTurnAgent = latestStep?.agent;
       if (isPlanAgent(current.lastPromptAgent) || isPlanAgent(latestTurnAgent)) {
@@ -3900,7 +3979,7 @@ async function setupV2(context) {
         return;
       if (!autoContinue)
         return;
-      if (nativeRetrySessions.has(sessionID))
+      if (!isCurrent() || nativeRetrySessions.has(sessionID))
         return;
       const goal = await reserveContinuation(sessionID, maxAutoTurns, minInterval);
       if (!goal) {
@@ -3913,7 +3992,8 @@ async function setupV2(context) {
       attemptReservedAt = goal.pendingAttempt?.reservedAt ?? Date.now();
       attemptGoalID = goal.id;
       attemptID = goal.pendingAttempt?.id;
-      if (nativeRetrySessions.has(sessionID)) {
+      const beforeDelivery = await getGoalInternal(sessionID);
+      if (!isCurrent() || !continuationStillReserved(goal, beforeDelivery) || busySessions.has(sessionID) || nativeRetrySessions.has(sessionID)) {
         await rollbackContinuationAttempt(sessionID, { goalID: attemptGoalID, attemptID });
         return;
       }
@@ -3922,19 +4002,20 @@ async function setupV2(context) {
         return;
       }
       await sendContinuation(sessionID, goal.status === "active" ? continuationPrompt(goal, locale) : limitPrompt(goal, locale), goal.lastPromptAgent ?? latestTurnAgent ?? null);
-      if (disposed) {
+      if (!isCurrent()) {
         await rollbackContinuationAttempt(sessionID, { goalID: attemptGoalID, attemptID });
         return;
       }
       const delivered = await recordContinuationResult(sessionID, "success", maxPromptFailures, {
         expectedGoalID: attemptGoalID
       });
-      locallyDeliveredPendingSessions.add(sessionID);
+      if (isCurrent() && delivered?.pendingAttempt?.delivered)
+        locallyDeliveredPendingSessions.add(sessionID);
       if (!delivered?.pendingAttempt?.delivered) {
         await rollbackContinuationAttempt(sessionID, { goalID: attemptGoalID, attemptID });
       }
     } catch (error) {
-      if (disposed) {
+      if (!isCurrent()) {
         await rollbackContinuationAttempt(sessionID, { goalID: attemptGoalID, attemptID });
         return;
       }
@@ -4099,9 +4180,11 @@ async function setupV2(context) {
         nativeRetrySessions.delete(sessionID);
         clearTurnWatchdog(sessionID);
         watchdogRescuedSessions.delete(sessionID);
-        cancelScheduledContinuation(sessionID);
-        taskDeferredSessions.delete(sessionID);
+        goalServices.stopAutonomy?.(sessionID);
+        clearToolAttemptsForSession(toolAttempts, sessionID);
         taskTracker.observeSessionStatus(sessionID, "idle");
+        if (data.reason === "user")
+          await cancelActiveGoal(sessionID);
         return;
       }
       case "session.execution.failed": {
@@ -4142,6 +4225,7 @@ async function setupV2(context) {
       case "session.deleted": {
         if (!sessionID)
           return;
+        continuationEpochs.invalidate(sessionID);
         explicitResumeRequests.delete(sessionID);
         stoppedExecutions.delete(sessionID);
         sessionOwnership.delete(sessionID);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prevalentware/opencode-goal-plugin",
-  "version": "0.1.53",
+  "version": "0.1.55",
   "description": "OpenCode goal plugin that adds Codex-style long-running goal mode, /goal commands, persistence, and TUI status for AI coding agents.",
   "keywords": [
     "opencode",
@@ -40,6 +40,7 @@
     "dist",
     "src/tui.ts",
     "src/i18n.ts",
+    "src/state-path.ts",
     "LICENSE",
     "README.md"
   ],

package/src/state-path.ts

@@ -0,0 +1,10 @@
+import { homedir } from "node:os"
+import { join } from "node:path"
+
+export function statePath() {
+  if (process.env.OPENCODE_GOAL_STATE_PATH) return process.env.OPENCODE_GOAL_STATE_PATH
+  const dataHome =
+    process.env.XDG_DATA_HOME ||
+    (process.platform === "win32" && process.env.APPDATA ? process.env.APPDATA : join(homedir(), ".local", "share"))
+  return join(dataHome, "opencode-goal-plugin", "goals.json")
+}

package/src/tui.ts

@@ -3,8 +3,10 @@ import type { Plugin as TuiPluginV2 } from "@opencode/plugin/tui"
 import type { SessionMessageInfo } from "@opencode/client"
 import { createElement, insert, setProp } from "@opentui/solid"
 import { createEffect, createMemo, createSignal, onCleanup } from "solid-js"
+import { readFile, stat } from "node:fs/promises"
 import type { GoalMessages } from "./i18n"
 import { messagesFor, presentGoalLastStatus, presentGoalStatus, presentGoalStopReason, resolveLocale } from "./i18n"
+import { statePath } from "./state-path"
 
 type GoalCheckpoint = {
   summary: string
@@ -413,6 +415,66 @@ function isGoalSnapshot(value: unknown): value is GoalSnapshot {
   return true
 }
 
+/** Read only the current session from the server's atomic state file. */
+export async function readPersistedGoal(sessionID: string): Promise<GoalSnapshot | null | undefined> {
+  try {
+    const state: unknown = JSON.parse(await readFile(statePath(), "utf8"))
+    if (!isRecord(state) || (state.version !== 1 && state.version !== 2) || !isRecord(state.goals)) return undefined
+    const stored = state.goals[sessionID]
+    if (stored === undefined) return null
+    if (!isRecord(stored) || stored.sessionID !== sessionID) return undefined
+    const sampledAt = currentEpochSeconds()
+    const timeUsedSeconds = typeof stored.timeUsedSeconds === "number" ? stored.timeUsedSeconds : 0
+    const activeSeconds = stored.status === "active" && typeof stored.lastAccountedAt === "number"
+      ? Math.max(0, sampledAt - stored.lastAccountedAt)
+      : 0
+    const tokenBudget = stored.tokenBudget
+    const tokensUsed = stored.tokensUsed
+    const snapshot = {
+      ...stored,
+      timeUsedSeconds: timeUsedSeconds + activeSeconds,
+      sampledAt,
+      remainingTokens: typeof tokenBudget === "number" && typeof tokensUsed === "number"
+        ? Math.max(0, tokenBudget - tokensUsed)
+        : null,
+    }
+    return isGoalSnapshot(snapshot) ? snapshot : undefined
+  } catch {
+    // Keep the last valid snapshot when the file is unavailable or incomplete.
+    return undefined
+  }
+}
+
+function usePersistedGoal(sessionID: string) {
+  const [persisted, setPersisted] = createSignal<GoalSnapshot | null | undefined>(undefined)
+  let disposed = false
+  let reading = false
+  let lastFile: { ino: number; mtimeMs: number; size: number } | undefined
+  const refresh = async () => {
+    if (reading) return
+    reading = true
+    try {
+      const file = await stat(statePath())
+      if (lastFile && lastFile.ino === file.ino && lastFile.mtimeMs === file.mtimeMs && lastFile.size === file.size) return
+      const next = await readPersistedGoal(sessionID)
+      if (next === undefined) return
+      lastFile = { ino: file.ino, mtimeMs: file.mtimeMs, size: file.size }
+      if (!disposed && (next !== null || persisted() !== undefined)) setPersisted(() => next)
+    } catch {
+      // Missing or unreadable state leaves the last valid view in place.
+    } finally {
+      reading = false
+    }
+  }
+  void refresh()
+  const timer = setInterval(() => void refresh(), 1000)
+  onCleanup(() => {
+    disposed = true
+    clearInterval(timer)
+  })
+  return persisted
+}
+
 function parseGoalToolOutput(part: GoalToolPart): GoalSnapshot | null | undefined {
   if (part.type !== "tool") return undefined
   if (!GOAL_TOOL_NAMES.includes(part.tool ?? "")) return undefined
@@ -474,39 +536,50 @@ export function formatGoal(goal: GoalSnapshot | null, messages: GoalMessages, lo
 function GoalSidebar(api: TuiPluginApi, messages: GoalMessages, locale: ReturnType<typeof resolveLocale>, sessionID: string) {
   const theme = api.theme.current
   const state = goalStateFromSession(api, sessionID)
-  const goal = state.goal
-  if (!goal) return null
-  if (goal.status === "complete" || goal.status === "unmet") {
-    const elapsed = liveTimeUsedSeconds(goal)
-    const label = goal.status === "complete" ? messages.tui.achieved : messages.tui.unmet
-    return text({ fg: goal.status === "complete" ? theme.primary : theme.textMuted }, [
-      `${label} (${formatDurationBadge(elapsed)})`,
-    ])
-  }
+  if (!state.goal) return null
+  const persisted = usePersistedGoal(sessionID)
+  const goal = createMemo(() => {
+    const live = persisted()
+    if (live === undefined) return state.goal
+    if (live && state.goal && (state.goal.createdAt > live.createdAt || state.goal.updatedAt > live.updatedAt)) return state.goal
+    return live
+  })
   const [nowSeconds, setNowSeconds] = createSignal(currentEpochSeconds())
-  if (goal.status === "active") {
+  const active = createMemo(() => goal()?.status === "active")
+  createEffect(() => {
+    if (!active()) return
     const timer = setInterval(() => setNowSeconds(currentEpochSeconds()), 1000)
     onCleanup(() => clearInterval(timer))
-  }
-  return box({}, [
-    text({ fg: theme.text }, [messages.tui.title]),
-    text({ fg: theme.textMuted }, [`${messages.tui.status}: ${presentGoalStatus(goal.status, locale)}`]),
-    text({ fg: theme.textMuted }, [() => `${messages.tui.time}: ${formatDuration(liveTimeUsedSeconds(goal, nowSeconds()))}`]),
-    text({ fg: theme.textMuted }, [
-      `${messages.tui.tokens}: ${goal.tokensUsed}${goal.tokenBudget == null ? "" : `/${goal.tokenBudget}`}`,
-    ]),
-    text({ fg: theme.textMuted }, [
-      `${messages.tui.autoContinues}: ${goal.autoTurns}${goal.maxAutoTurns == null ? "" : `/${goal.maxAutoTurns}`}`,
-    ]),
-    ...(goal.lastCheckpoint
-      ? [text({ fg: theme.textMuted }, [`${messages.tui.checkpoint}: ${goal.lastCheckpoint.summary}`])]
-      : []),
-    ...(goal.stopReason
-      ? [text({ fg: theme.textMuted }, [`${messages.tui.stop}: ${presentGoalStopReason(goal.stopReason, locale)}`])]
-      : []),
-    ...(goal.lastStatus ? [text({ fg: theme.textMuted }, [presentGoalLastStatus(goal.lastStatus, locale)])] : []),
-    text({ fg: theme.textMuted }, [goal.objective]),
-  ])
+  })
+  return box({}, [() => {
+    const snapshot = goal()
+    if (!snapshot) return null
+    if (snapshot.status === "complete" || snapshot.status === "unmet") {
+      const elapsed = liveTimeUsedSeconds(snapshot)
+      return text({ fg: snapshot.status === "complete" ? theme.primary : theme.textMuted }, [
+        `${snapshot.status === "complete" ? messages.tui.achieved : messages.tui.unmet} (${formatDurationBadge(elapsed)})`,
+      ])
+    }
+    return box({}, [
+      text({ fg: theme.text }, [messages.tui.title]),
+      text({ fg: theme.textMuted }, [`${messages.tui.status}: ${presentGoalStatus(snapshot.status, locale)}`]),
+      text({ fg: theme.textMuted }, [`${messages.tui.time}: ${formatDuration(liveTimeUsedSeconds(snapshot, nowSeconds()))}`]),
+      text({ fg: theme.textMuted }, [
+        `${messages.tui.tokens}: ${snapshot.tokensUsed}${snapshot.tokenBudget == null ? "" : `/${snapshot.tokenBudget}`}`,
+      ]),
+      text({ fg: theme.textMuted }, [
+        `${messages.tui.autoContinues}: ${snapshot.autoTurns}${snapshot.maxAutoTurns == null ? "" : `/${snapshot.maxAutoTurns}`}`,
+      ]),
+      ...(snapshot.lastCheckpoint
+        ? [text({ fg: theme.textMuted }, [`${messages.tui.checkpoint}: ${snapshot.lastCheckpoint.summary}`])]
+        : []),
+      ...(snapshot.stopReason
+        ? [text({ fg: theme.textMuted }, [`${messages.tui.stop}: ${presentGoalStopReason(snapshot.stopReason, locale)}`])]
+        : []),
+      ...(snapshot.lastStatus ? [text({ fg: theme.textMuted }, [presentGoalLastStatus(snapshot.lastStatus, locale)])] : []),
+      text({ fg: theme.textMuted }, [snapshot.objective]),
+    ])
+  }])
 }
 
 function registerGoalCommand(api: TuiPluginApi, command: TuiCommand) {
@@ -657,8 +730,16 @@ function GoalSidebarV2(
   const [cache, setCache] = api.storage.memory<{ goal: GoalSnapshot | null }>(`goal-mode.v2.${sessionID}`, {
     initial: { goal: null },
   })
+  const persisted = usePersistedGoal(sessionID)
+  const messageGoal = createMemo(() => goalFromV2Messages(api.data.session.message.list(sessionID)))
   const goal = createMemo<GoalSnapshot | null>(() => {
-    const found = goalFromV2Messages(api.data.session.message.list(sessionID))
+    const found = messageGoal()
+    if (found === null) return null
+    const live = persisted()
+    if (live !== undefined) {
+      if (found && live && (found.createdAt > live.createdAt || found.updatedAt > live.updatedAt)) return found
+      return live
+    }
     return found === undefined ? cache.goal : found
   })
   createEffect(() =>
@@ -668,8 +749,9 @@ function GoalSidebarV2(
   )
 
   const [nowSeconds, setNowSeconds] = createSignal(currentEpochSeconds())
+  const active = createMemo(() => goal()?.status === "active")
   createEffect(() => {
-    if (goal()?.status !== "active") return
+    if (!active()) return
     const timer = setInterval(() => setNowSeconds(currentEpochSeconds()), 1000)
     onCleanup(() => clearInterval(timer))
   })