@prevalentware/opencode-goal-plugin 0.1.54 → 0.1.56

package/README.md

@@ -259,6 +259,8 @@ Ordinary fsync improves crash consistency but is not `F_FULLFSYNC`, so sudden po
 
 The plugin migrates version 1 state files to version 2 on the next write. Version 2 adds stable goal identities, the terminal `cancelled` status, and compact archives. Older plugin versions intentionally reject version 2 instead of silently dropping archived history on their next write; back up or isolate `OPENCODE_GOAL_STATE_PATH` before downgrading.
 
+Planless version 3 files from the planning development build are also compatible: empty `plan: null` and `planRevision: 0` metadata survives reads, updates, and archival, and writes retain version 3. This prevents an otherwise valid shared state file from breaking ordinary OpenCode tool calls in sessions without a goal. Populated plans, nonzero planning revisions, and unknown future versions remain rejected without rewriting the file; use the corresponding planning build or an isolated `OPENCODE_GOAL_STATE_PATH` for those files.
+
 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.
@@ -315,6 +317,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. 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

@@ -179,6 +179,8 @@ var GoalSchema = Schema.Struct({
   id: Schema.optionalWith(Schema.String, { default: () => "" }),
   sessionID: Schema.String,
   objective: Schema.String,
+  plan: Schema.optional(Schema.Null),
+  planRevision: Schema.optional(Schema.Literal(0)),
   status: Schema.Literal("active", "paused", "budgetLimited", "usageLimited", "complete", "unmet", "cancelled"),
   tokenBudget: NullableNumber,
   tokensUsed: Schema.Number,
@@ -216,6 +218,8 @@ var ArchivedGoalSchema = Schema.Struct({
   id: Schema.String,
   sessionID: Schema.String,
   objective: Schema.String,
+  plan: Schema.optional(Schema.Null),
+  planRevision: Schema.optional(Schema.Literal(0)),
   status: Schema.Literal("active", "paused", "budgetLimited", "usageLimited", "complete", "unmet", "cancelled"),
   tokenBudget: NullableNumber,
   tokensUsed: Schema.Number,
@@ -234,7 +238,7 @@ var LegacyStateSchema = Schema.Struct({
   goals: Schema.Record({ key: Schema.String, value: GoalSchema })
 });
 var StateSchema = Schema.Struct({
-  version: Schema.Literal(2),
+  version: Schema.Literal(2, 3),
   goals: Schema.Record({ key: Schema.String, value: GoalSchema }),
   archives: Schema.optionalWith(Schema.Record({ key: Schema.String, value: Schema.Array(ArchivedGoalSchema) }), {
     default: () => ({})
@@ -551,6 +555,8 @@ function snapshot(goal) {
     id: goal.id,
     sessionID: goal.sessionID,
     objective: goal.objective,
+    ...goal.plan === null ? { plan: null } : {},
+    ...goal.planRevision === 0 ? { planRevision: 0 } : {},
     status: goal.status,
     tokenBudget: goal.tokenBudget,
     tokensUsed: goal.tokensUsed,
@@ -678,6 +684,8 @@ function archivedGoal(goal) {
     id: goal.id,
     sessionID: goal.sessionID,
     objective: summarizeText(goal.objective, MAX_ARCHIVED_OBJECTIVE_CHARS),
+    ...goal.plan === null ? { plan: null } : {},
+    ...goal.planRevision === 0 ? { planRevision: 0 } : {},
     status: goal.status,
     tokenBudget: goal.tokenBudget,
     tokensUsed: goal.tokensUsed,
@@ -888,6 +896,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];
@@ -1937,6 +1955,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;
@@ -2963,6 +3002,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());
@@ -2974,6 +3014,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);
@@ -3027,6 +3068,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 {
@@ -3062,17 +3105,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?.({
@@ -3142,16 +3191,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);
@@ -3161,7 +3218,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);
@@ -3171,7 +3228,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)) {
@@ -3209,7 +3266,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)
@@ -3217,7 +3274,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;
       }
@@ -3226,19 +3284,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;
       }
@@ -3503,6 +3562,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);
       }
@@ -3571,6 +3641,7 @@ var server = async ({ client }, options) => {
         }
       }
       if (sessionID && eventType === "session.deleted") {
+        continuationEpochs.invalidate(sessionID);
         explicitResumeRequests.delete(sessionID);
         busySessions.delete(sessionID);
         clearTurnWatchdog(sessionID);
@@ -3635,6 +3706,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;
@@ -3654,6 +3726,7 @@ async function setupV2(context) {
       }
     },
     stopAutonomy: (sessionID, mode = "stop") => {
+      continuationEpochs.invalidate(sessionID);
       cancelScheduledContinuation(sessionID);
       if (mode === "stop")
         clearTurnWatchdog(sessionID);
@@ -3712,6 +3785,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 {
@@ -3743,17 +3818,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);
@@ -3818,8 +3899,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();
@@ -3833,6 +3916,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);
@@ -3864,7 +3949,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)) {
@@ -3902,7 +3987,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) {
@@ -3915,7 +4000,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;
       }
@@ -3924,19 +4010,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;
       }
@@ -4101,9 +4188,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": {
@@ -4144,6 +4233,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.54",
+  "version": "0.1.56",
   "description": "OpenCode goal plugin that adds Codex-style long-running goal mode, /goal commands, persistence, and TUI status for AI coding agents.",
   "keywords": [
     "opencode",

package/src/tui.ts

@@ -419,10 +419,12 @@ function isGoalSnapshot(value: unknown): value is GoalSnapshot {
 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
+    if (!isRecord(state) || (state.version !== 1 && state.version !== 2 && state.version !== 3) || !isRecord(state.goals)) return undefined
     const stored = state.goals[sessionID]
     if (stored === undefined) return null
     if (!isRecord(stored) || stored.sessionID !== sessionID) return undefined
+    if (stored.plan !== undefined && stored.plan !== null) return undefined
+    if (stored.planRevision !== undefined && stored.planRevision !== 0) return undefined
     const sampledAt = currentEpochSeconds()
     const timeUsedSeconds = typeof stored.timeUsedSeconds === "number" ? stored.timeUsedSeconds : 0
     const activeSeconds = stored.status === "active" && typeof stored.lastAccountedAt === "number"