opencode-goal-plugin 0.6.3 → 0.6.5

package/CHANGELOG.md

@@ -1,6 +1,13 @@
 # Changelog
 
-## Unreleased
+## 0.6.5 — 2026-07-12
+
+- Make `/goal sequence` the canonical ordered multi-goal command, retain the previous command and mode spelling as input-only compatibility aliases, correct the public auditor snapshot mode type to `"normal" | "ordered"`, and align README archive and compatibility claims with verified behavior.
+
+## 0.6.4 — 2026-07-12
+
+- Re-check session status and recent messages after an auto-continue cooldown, pause immediately for human intervention, Plan-agent switches, permission rejection, aborts, and provider errors, and abort an accepted continuation when the user takes control.
+- Persist one continuation claim per goal execution epoch and source assistant turn to prevent sequential duplicate idle events, while preserving the initiating agent, model, and variant on every continuation prompt.
 
 ## 0.6.3 — 2026-07-11
 

package/README.md

@@ -36,15 +36,16 @@ surface and versioning expectations.
 
 ### OpenCode version compatibility
 
-Manually tested via the OpenCode TUI (`tmux` + real provider credentials, no mocks), verified against the plugin's own persisted state rather than terminal display alone:
+Tested against real OpenCode 1.17.15 processes with live provider credentials and no mocked plugin hooks. State, ledger entries, and workspace files were checked independently of terminal or model prose:
 
 | OpenCode Version | Provider Tested | `/goal status` | Auto-continue | Evidence-gated completion | Hook Output Display |
 |---|---|---|---|---|---|
+| 1.17.15 | opencode (`deepseek-v4-flash-free`) | ✅ Canonical tool | ✅ Checkpoint + idle continuation | ✅ Structured `goal_complete` claim | ⚠️ Command text routed to model; mutation guard verified |
 | 1.17.15 | opencode-go (`qwen3.7-plus`) | ✅ | ✅ | ✅ Self-corrected after one rejection (bare `[goal:complete]` with no evidence), then completed cleanly | ⚠️ Not displayed |
 | 1.17.15 | opencode-go (`glm-5.2`) | ✅ | ✅ | ✅ Clean `[goal:evidence]` + `[goal:complete]` on the first attempt | ⚠️ Not displayed |
 | 1.17.15 | deepseek (`deepseek-chat`) | ✅ | ✅ | ✅ Clean `[goal:evidence]` + `[goal:complete]` on the first attempt; also verified end-to-end via the [demo](demo/) — autonomously fixed a real bug and reported evidence-backed completion | ⚠️ Not displayed |
 
-`/goal status` and auto-continue are graded on **state correctness** (verified directly against the plugin's persisted state file: correct limits parsed, correct turn/stop accounting, correct completion detection) — not on what's rendered in the terminal, since that's tracked separately as Hook Output Display.
+`/goal status` and auto-continue are graded on **state correctness** (verified directly against persisted state: correct limits, turn/stop accounting, completion state, and file effects), not on terminal rendering. The `deepseek-v4-flash-free` canary suite additionally covers pause/resume across processes, blocker/restart, hard-process recovery, real host compaction, and stale-history clear enforcement. See [`docs/providers.md`](docs/providers.md) for the complete lifecycle matrix and session evidence.
 
 **Note:** Hook output display depends on OpenCode version — on 1.17.15, `command.execute.before`'s `output.parts` text is not rendered in the TUI for any provider tested; the raw command argument is instead routed to the model as a normal chat turn (see [Limitations](#limitations)). State mutations always work regardless of display: goal creation, flag parsing, auto-continue, limit enforcement, and evidence-gated completion detection were all verified correct via the persisted state file in every combination above. Re-test against your own OpenCode build before relying on unattended runs, and see [`docs/providers.md`](docs/providers.md) for the full per-model marker-compliance notes.
 
@@ -89,7 +90,7 @@ Add success criteria, constraints / non-goals, and a mode:
 /goal ship the release --success "tests pass and changelog updated" --constraints "do not touch the public API" --mode ordered
 ```
 
-`--success` (alias `--success-criteria`) and `--constraints` (alias `--non-goals`) take quoted text and are injected alongside the objective so the assistant keeps them in view. `--mode` is `normal` (default) or `ordered` (alias `sisyphus`); `ordered` asks the assistant to work through the objective as a strict sequence. Multi-word values must be quoted.
+`--success` (alias `--success-criteria`) and `--constraints` (alias `--non-goals`) take quoted text and are injected alongside the objective so the assistant keeps them in view. `--mode` is `normal` (default) or `ordered`; `ordered` tells the assistant to preserve step order inside one objective. To queue distinct objectives that auto-promote one at a time, use `/goal sequence`. Multi-word values must be quoted.
 
 Flags accept either `--flag value` or `--flag=value`. If a flag is unknown, missing a value, given a non-positive integer, or (for `--mode`) an unrecognized mode, the plugin rejects the command with a helpful error instead of silently folding the bad flag into the goal text.
 
@@ -125,7 +126,7 @@ Pause without clearing the active goal:
 /goal pause
 ```
 
-Clear the active goal:
+Clear all live goals in the current session and discard their saved status:
 
 ```
 /goal clear
@@ -155,14 +156,14 @@ A session can hold more than one goal. `/goal <condition>` replaces the focused
 /goal focus 1
 ```
 
-`/goal list` shows the numbered live goals (which is focused, which are backgrounded) and a per-session archive of completed/cleared goals so they stay readable. `/goal focus <number>` switches the active goal, backgrounding the previous one. Focus is tracked per session and survives a restart.
+`/goal list` shows numbered live goals (focused and backgrounded) plus achieved goals retained in the per-session archive. `/goal clear` intentionally removes live goals and saved status from these views; its terminal ledger entries remain available for crash-safe recovery decisions. `/goal focus <number>` switches the active goal, backgrounding the previous one. Focus is tracked per session and survives a restart.
 
-#### Ordered (sisyphus) sequences
+#### Ordered sequences
 
-`/goal sisyphus` sets up a strict execution sequence: separate the objectives with `;` or newlines, and the plugin runs them one at a time, auto-focusing the next as soon as the current one completes.
+`/goal sequence` sets up a strict execution queue: separate objectives with `;` or newlines, and the plugin runs them one at a time, focusing the next as soon as the current one completes.
 
 ```
-/goal sisyphus build the parser; write the tests; ship the release
+/goal sequence build the parser; write the tests; ship the release
 ```
 
 The first goal is focused and the rest are queued. `/goal list` marks the session as ordered. Auto-promotion stops when the sequence is exhausted; `/goal clear` ends the sequence.
@@ -187,16 +188,16 @@ With success criteria, constraints, and a token budget shorthand:
 An ordered sequence, run as a strict pipeline:
 
 ```
-/goal sisyphus build the parser; write the tests; ship the release
+/goal sequence build the parser; write the tests; ship the release
 ```
 
 ## How it works
 
 1. When you set a goal, the plugin stores it in session memory and injects it into the system prompt so the assistant keeps it in view on every turn.
-2. Each time the session goes idle, the plugin sends a continuation prompt containing the goal, the remaining budget, and a completion audit asking the assistant to verify the current state before declaring done.
+2. Each time the session goes idle, the plugin sends a continuation prompt containing the goal, the remaining budget, and a completion audit asking the assistant to verify the current state before declaring done. Continuations retain the agent, provider/model, and variant that initiated the goal. Before sending after a cooldown, the plugin re-checks that the session is still idle and no human message, newer assistant turn, Plan-agent switch, rejected permission, abort, or provider error has superseded the request.
 3. The plugin stops auto-continuing when the assistant ends a response with a substantiated `[goal:complete]` or `[goal:blocked]`, or when a safety limit is reached. A `[goal:complete]` is only honored when it is preceded by a `[goal:evidence]` line; a `[goal:blocked]` is only honored when a concrete blocker is stated. Unsubstantiated claims are rejected and the plugin re-prompts for the missing evidence or blocker.
 4. If OpenCode compacts the session, the plugin injects a deterministic summary into the compaction context so the goal survives the compaction and the assistant keeps the thread. The summary — objective, status, budget usage, recent checkpoints, and recent lifecycle events — is reconstructed from the plugin's persisted goal record rather than from chat memory, so it is stable and reproducible. While a goal is active, the plugin also disables OpenCode's generic post-compaction auto-continue so it does not race the plugin's own continuation.
-5. If you send a message of your own while the goal is running, the plugin treats it as the latest instruction and pauses auto-continue so it does not talk over you. The plugin's own continuation prompts are ignored for this check (they are not "your" messages). Run `/goal resume` to hand control back to the goal loop.
+5. If you send a message of your own while the goal is running, the plugin treats it as the latest instruction, pauses auto-continue, and asks OpenCode to abort an already accepted continuation so it does not talk over you. The plugin's own continuation prompts are ignored for this check (they are not "your" messages). A durable claim on the source assistant turn also prevents different idle event IDs from sending the same continuation twice. Run `/goal resume` to hand control back to the goal loop.
 
 ## Completion markers
 
@@ -272,7 +273,7 @@ Override any limit for a single goal:
 | `--no-progress-turns <n>` | Consecutive stalled low-output turns before pausing |
 | `--success <text>` | Success criteria that define when the goal is satisfied (quote multi-word text) |
 | `--constraints <text>` | Constraints / non-goals to respect (alias `--non-goals`) |
-| `--mode <normal\|ordered>` | Execution mode; `ordered` (alias `sisyphus`) asks for a strict sequence |
+| `--mode <normal\|ordered>` | Prompt mode for one goal; `ordered` preserves step order inside its objective |
 | `--no-tool-turns <n>` | Consecutive tool-free continuation turns before pausing |
 
 Examples:
@@ -343,7 +344,7 @@ Registered tools:
 
 `goal_set` and `set_goal` are explicitly constrained to user-requested goals. `goal_complete` accepts a structured claim: a required non-empty `summary`, plus optional criterion/evidence pairs, checks (`passed`, `failed`, or `not-run`), changed files, and known limitations. Failed checks and empty criterion evidence are rejected before archival; accepted claims are serialized deterministically for the configured completion auditor. The legacy `update_goal` tool retains its string `evidence` field for compatibility.
 
-These operate on the same per-session multi-goal state as the command path: a tool-set goal persists, shows up in `/goal list`, and is driven by the idle auto-continue; completing a goal in an ordered (sisyphus) sequence auto-promotes the next.
+These operate on the same per-session multi-goal state as the command path: a tool-set goal persists, shows up in `/goal list`, and is driven by the idle auto-continue; completing a goal in an ordered sequence auto-promotes the next.
 
 > Integration note: the tool execute-context shape (`ctx.sessionID`) and the `tool.schema` surface follow the OpenCode plugin docs. The tool **logic** is unit-tested independently, but the live registration should be confirmed against a real OpenCode run (see the smoke-test checklist).
 

package/index.d.ts

@@ -48,7 +48,7 @@ export interface GoalAuditSnapshot {
   condition: string
   successCriteria: string
   constraints: string
-  mode: "normal" | "sisyphus"
+  mode: "normal" | "ordered"
   sessionID: string
   turnCount: number
   startedAt: number

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-goal-plugin",
-  "version": "0.6.3",
+  "version": "0.6.5",
   "description": "Durable, guarded goal workflows for OpenCode.",
   "type": "module",
   "main": "./src/goal-plugin.js",

package/src/goal-plugin.js

@@ -74,7 +74,7 @@ const DEFAULT_OPTIONS = {
 // handler drives and that the system-prompt transform injects. `sessionGoals`
 // is the full registry of live goals per session (focused + backgrounded);
 // the focused goal is the same object reference held in both. `sessionArchive`
-// keeps a capped list of completed/cleared goals so they stay readable.
+// keeps a capped list of achieved goals so completed work stays readable.
 function createRuntimeState() {
   return {
     goalStates: new Map(),
@@ -87,7 +87,10 @@ function createRuntimeState() {
     seenOutputTokens: new Map(),
     activeContinues: new Map(),
     continuationControllers: new Map(),
+    promptInFlightSessions: new Set(),
     seenIdleEventIDs: new Set(),
+    sessionStatuses: new Map(),
+    sessionExecutionContexts: new Map(),
     readOnlyCommandGuards: new Set(),
     ledgerSink: null,
     persistenceLease: null,
@@ -126,7 +129,7 @@ function runtimeCollection(name) {
 const goalStates = runtimeCollection("goalStates")
 const sessionGoals = runtimeCollection("sessionGoals")
 const sessionArchive = runtimeCollection("sessionArchive")
-// Sessions running an ordered (sisyphus) sequence: when the focused goal
+// Sessions running an ordered sequence: when the focused goal
 // completes, the next live goal (in creation order) is auto-promoted to focus
 // so the sequence advances on its own.
 const sessionOrdered = runtimeCollection("sessionOrdered")
@@ -144,6 +147,9 @@ const seenOutputTokens = runtimeCollection("seenOutputTokens")
 const activeContinues = runtimeCollection("activeContinues")
 const CLEAR_COMMANDS = new Set(["clear", "stop", "off", "reset", "none", "cancel"])
 const PAUSE_COMMANDS = new Set(["pause"])
+// `sequence` is canonical. The former public spelling remains accepted at
+// the parser boundary so existing scripts do not break.
+const SEQUENCE_COMMANDS = ["sequence", "sisyphus"]
 const READ_ONLY_COMMAND_TOOLS = new Set(["goal_status", "get_goal", "get_goal_history", "read", "glob", "grep"])
 const GOAL_FLAG_SPECS = {
   "--max-turns": {
@@ -208,8 +214,8 @@ function messageHasToolCall(message) {
 
 const GOAL_MODES = new Set(["normal", "ordered"])
 
-// Goal mode: normal vs ordered (a.k.a. sisyphus). `ordered`
-// signals a strict execution sequence; `sisyphus` is accepted as an alias.
+// Goal mode: normal vs ordered. The former public spelling remains accepted
+// as an input alias, while stored state and output always use `ordered`.
 // Returns the canonical mode or null when unrecognized.
 function normalizeMode(value) {
   const normalized = String(value || "").trim().toLowerCase()
@@ -242,7 +248,13 @@ function makeContinuationPart(text) {
 }
 
 function getSessionID(event) {
-  return event?.properties?.sessionID || event?.properties?.info?.sessionID || null
+  return (
+    event?.properties?.sessionID ||
+    event?.properties?.info?.sessionID ||
+    event?.data?.sessionID ||
+    event?.data?.info?.sessionID ||
+    null
+  )
 }
 
 function isIdleEvent(event) {
@@ -252,12 +264,76 @@ function isIdleEvent(event) {
   )
 }
 
-function isAbortErrorEvent(event) {
-  if (event?.type !== "session.error") return false
-  const error = event?.properties?.error
+function normalizeExecutionContext(value) {
+  if (!isPlainObject(value)) return null
+  const model = isPlainObject(value.model) ? value.model : {}
+  const boundedContextText = (candidate) => {
+    if (typeof candidate !== "string") return ""
+    const normalized = candidate.trim()
+    return normalized.length <= MAX_GOAL_META_LENGTH ? normalized : ""
+  }
+  const agent = boundedContextText(value.agent)
+  const providerID = boundedContextText(model.providerID)
+  const modelID =
+    boundedContextText(model.modelID) || boundedContextText(model.id)
+  const variantValue = value.variant ?? model.variant
+  const variant = boundedContextText(variantValue)
+  if (!agent && !(providerID && modelID) && !variant) return null
+  return {
+    ...(agent ? { agent } : {}),
+    ...(providerID && modelID ? { model: { providerID, modelID } } : {}),
+    ...(variant ? { variant } : {}),
+  }
+}
+
+function continuationContextInput(goal) {
+  const context = normalizeExecutionContext(goal?.executionContext)
+  return context ? { ...context } : {}
+}
+
+function isPlanAgent(agent) {
+  return typeof agent === "string" && agent.trim().toLowerCase() === "plan"
+}
+
+function terminalEvent(event) {
+  const permissionReply = String(
+    event?.properties?.reply ??
+      event?.properties?.response ??
+      event?.data?.reply ??
+      event?.data?.response ??
+      "",
+  )
+  if (event?.type === "permission.replied" && /^(?:reject(?:ed)?|deny|denied)$/i.test(permissionReply)) {
+    return {
+      sessionID: getSessionID(event),
+      stopReason: "permission rejected",
+      status: "Goal paused after a permission request was rejected.",
+      history: "Paused after OpenCode reported a rejected permission request.",
+    }
+  }
+
+  let error = null
+  if (event?.type === "session.error") {
+    error = event?.properties?.error || event?.data?.error
+  } else if (event?.type === "message.updated") {
+    error = messageInfoFromEvent(event)?.error
+  }
+  if (!error) return null
+
   const name = String(error?.name || error?.data?.name || "")
   const message = String(error?.message || error?.data?.message || "")
-  return name === "MessageAbortedError" || /\babort(?:ed)?\b/i.test(`${name} ${message}`)
+  const aborted = name === "MessageAbortedError" || /\babort(?:ed)?\b/i.test(`${name} ${message}`)
+  const summary = summarizeText(`${name}${message ? `: ${message}` : ""}`, 240) || "unknown provider error"
+  return {
+    sessionID: getSessionID(event) || messageSessionID(messageInfoFromEvent(event)),
+    stopReason: aborted ? "user interrupted" : "provider error",
+    status: aborted
+      ? "Goal paused after user interruption."
+      : `Goal paused after a terminal provider error: ${summary}`,
+    history: aborted
+      ? "Paused after OpenCode reported that the active turn was aborted."
+      : `Paused after OpenCode reported a terminal provider error: ${summary}`,
+  }
 }
 
 function summarizeText(text, limit = CHECKPOINT_CHAR_LIMIT) {
@@ -654,7 +730,7 @@ function archiveSessionResult(sessionID, result) {
   sessionArchive.set(sessionID, list.slice(-MAX_ARCHIVED_PER_SESSION))
 }
 
-// Advance an ordered (sisyphus) sequence: focus the next live goal in creation
+// Advance an ordered sequence: focus the next live goal in creation
 // order, clearing any backgrounded state so the idle handler drives it. Returns
 // the promoted goal, or null when the sequence is exhausted (which also clears
 // the session's ordered flag).
@@ -670,7 +746,7 @@ function promoteNextOrderedGoal(sessionID) {
   resumeGoalClock(next)
   next.skipNextTerminalCheck = true
   next.lastStatus = "Promoted as the next ordered goal."
-  pushHistory(next, "focused", "Auto-promoted as the next goal in the ordered (sisyphus) sequence.")
+  pushHistory(next, "focused", "Auto-promoted as the next goal in the ordered sequence.")
   focusGoal(sessionID, next)
   return next
 }
@@ -706,7 +782,10 @@ function clearRuntimeState() {
   seenOutputTokens.clear()
   activeContinues.clear()
   runtime.continuationControllers.clear()
+  runtime.promptInFlightSessions.clear()
   runtime.seenIdleEventIDs.clear()
+  runtime.sessionStatuses.clear()
+  runtime.sessionExecutionContexts.clear()
   runtime.readOnlyCommandGuards.clear()
 }
 
@@ -805,6 +884,7 @@ function resetGoalBudget(goal) {
   goal.promptFailures = 0
   goal.formatFailures = 0
   goal.lastAssistantMessageID = ""
+  goal.continuationClaim = null
   goal.skipNextTerminalCheck = false
   goal.history = [...(goal.history || [])].slice(-MAX_HISTORY_ENTRIES)
 }
@@ -1109,6 +1189,18 @@ function normalizePersistedGoal(rawGoal) {
     stopReason: typeof rawGoal.stopReason === "string" ? rawGoal.stopReason : "",
     promptFailures: toNonNegativeInteger(rawGoal.promptFailures),
     formatFailures: toNonNegativeInteger(rawGoal.formatFailures),
+    executionContext: normalizeExecutionContext(rawGoal.executionContext),
+    continuationClaim:
+      isPlainObject(rawGoal.continuationClaim) &&
+      typeof rawGoal.continuationClaim.runId === "string" &&
+      rawGoal.continuationClaim.runId.length <= MAX_GOAL_META_LENGTH &&
+      typeof rawGoal.continuationClaim.sourceAssistantMessageID === "string" &&
+      rawGoal.continuationClaim.sourceAssistantMessageID.length <= MAX_GOAL_META_LENGTH
+        ? {
+            runId: rawGoal.continuationClaim.runId,
+            sourceAssistantMessageID: rawGoal.continuationClaim.sourceAssistantMessageID,
+          }
+        : null,
     messageIDs: Array.isArray(rawGoal.messageIDs)
       ? rawGoal.messageIDs.slice(-MAX_MESSAGE_IDS_PER_GOAL).filter((messageID) => typeof messageID === "string" && messageID.length <= MAX_GOAL_META_LENGTH)
       : [],
@@ -1181,6 +1273,9 @@ function deserializeGoal(goal) {
       "Recovered persisted goal state after plugin restart; auto-continue remains paused until you resume.",
     )
   }
+  // Recovered goals always require an explicit resume, which starts a fresh
+  // execution epoch and makes any pre-crash continuation claim obsolete.
+  hydrated.continuationClaim = null
 
   return hydrated
 }
@@ -1898,7 +1993,8 @@ function messageRole(message) {
 }
 
 function messageID(message) {
-  return message?.info?.id || message?.id || ""
+  const id = message?.info?.id || message?.id || ""
+  return typeof id === "string" && id.length <= MAX_GOAL_META_LENGTH ? id : ""
 }
 
 function messageSessionID(message) {
@@ -1986,6 +2082,9 @@ function messageInfoFromEvent(event) {
     event?.properties?.info,
     event?.properties?.message?.info,
     event?.properties?.message,
+    event?.data?.info,
+    event?.data?.message?.info,
+    event?.data?.message,
   ]
   return candidates.find(isPlainObject) || null
 }
@@ -2049,6 +2148,35 @@ function findLatestAssistantMessage(messages) {
   return [...(messages || [])].reverse().find((message) => messageRole(message) === "assistant") || null
 }
 
+function findLatestExecutionContext(messages) {
+  for (const message of [...(messages || [])].reverse()) {
+    if (messageRole(message) !== "user") continue
+    const info = isPlainObject(message?.info) ? message.info : message
+    const context = normalizeExecutionContext(info)
+    if (context) return context
+  }
+  return null
+}
+
+function continuationSnapshot(messages) {
+  const list = Array.isArray(messages) ? messages : []
+  const latestAssistant = findLatestAssistantMessage(list)
+  const latestRealUser = [...list]
+    .reverse()
+    .find((message) => messageRole(message) === "user" && !isPluginContinuationMessage(message))
+  const latestRelevant = [...list]
+    .reverse()
+    .find((message) =>
+      (messageRole(message) === "assistant" || messageRole(message) === "user") &&
+      !isPluginContinuationMessage(message),
+    )
+  return {
+    latestAssistantID: messageID(latestAssistant),
+    latestRealUserMessageID: messageID(latestRealUser),
+    latestRelevantMessageID: messageID(latestRelevant),
+  }
+}
+
 // The plugin drives auto-continue by sending its own prompts via promptAsync,
 // which appear in the session as user-role messages. Every such prompt is
 // framed inside <goal_continuation>, so a user message containing that marker
@@ -2136,6 +2264,10 @@ function buildGoalState(sessionID, condition, options, meta = {}, lastStatus = "
     stopReason: "",
     promptFailures: 0,
     formatFailures: 0,
+    executionContext: normalizeExecutionContext(
+      meta.executionContext || currentRuntime().sessionExecutionContexts.get(sessionID),
+    ),
+    continuationClaim: null,
     messageIDs: new Set(),
     history: [],
     checkpoints: [],
@@ -2334,7 +2466,7 @@ function buildAgentToolHandlers({ defaultGoalOptions, persist, persistTerminalSt
         const ordered = sessionOrdered.has(sessionID)
         rememberGoalResult(sessionID, goal, "achieved", "", evidence)
         cleanupGoal(sessionID)
-        // Advance an ordered (sisyphus) sequence just like the marker path does.
+        // Advance an ordered sequence just like the marker path does.
         if (ordered) promoteNextOrderedGoal(sessionID)
         const durable = await persistFinal("completion", ledgerDurable)
         if (durable === false) {
@@ -2578,7 +2710,7 @@ function formatGoalList(sessionID, commandName = "goal") {
 
   const lines = []
   if (goals.length) {
-    lines.push(`Goals (${goals.length})${sessionOrdered.has(sessionID) ? " — ordered (sisyphus)" : ""}:`)
+    lines.push(`Goals (${goals.length})${sessionOrdered.has(sessionID) ? " — ordered sequence" : ""}:`)
     goals.forEach((goal, index) => {
       const marker = goal.goalId === focusedId ? "focused" : goal.stopped ? "background" : "idle"
       const state = goal.stopped && goal.goalId !== focusedId ? ` — ${goal.stopReason || "stopped"}` : ""
@@ -2882,6 +3014,117 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
 
   const agentToolHandlers = buildAgentToolHandlers({ defaultGoalOptions, persist, persistTerminalState, completionAuditor, commandName })
 
+  const abortAcceptedContinuation = async (sessionID) => {
+    const runtimeState = currentRuntime()
+    runtimeState.continuationControllers.get(sessionID)?.abort()
+    if (
+      !runtimeState.promptInFlightSessions.has(sessionID) ||
+      typeof client?.session?.abort !== "function"
+    ) {
+      return
+    }
+    try {
+      await sessionApi.abort(sessionID)
+    } catch (error) {
+      await logPluginError(client, "Failed to abort an accepted auto-continue after intervention", error)
+    }
+  }
+
+  const pauseActiveGoal = async (
+    sessionID,
+    { stopReason: reason, status, history, abortAccepted = false },
+  ) => {
+    const goal = goalStates.get(sessionID)
+    if (!goal) return false
+    currentRuntime().continuationControllers.get(sessionID)?.abort()
+    goal.stopped = true
+    goal.stopReason = reason
+    goal.lastStatus = `${status} Run /${commandName} resume to continue.`
+    goal.continuationClaim = null
+    pushHistory(goal, "paused", history)
+    activeContinues.delete(sessionID)
+    await persist()
+    if (abortAccepted) await abortAcceptedContinuation(sessionID)
+    return true
+  }
+
+  const claimContinuationSource = async (
+    sessionID,
+    goalID,
+    runID,
+    baselineMessages,
+    { refreshMessages = false } = {},
+  ) => {
+    const goalBeforeRefresh = activeGoal(sessionID, goalID, runID)
+    if (!goalBeforeRefresh) return null
+    const hostMessages = refreshMessages
+      ? await sessionApi.messages(sessionID, {
+          limit: goalBeforeRefresh.options.maxRecentMessages,
+        })
+      : baselineMessages
+    const goal = activeGoal(sessionID, goalID, runID)
+    if (!goal) return null
+    const messages = Array.isArray(hostMessages)
+      ? hostMessages.slice(-goal.options.maxRecentMessages)
+      : []
+    const baseline = continuationSnapshot(baselineMessages)
+    const refreshed = continuationSnapshot(messages)
+
+    if (currentRuntime().sessionStatuses.get(sessionID) !== "idle") return null
+
+    const currentContext = currentRuntime().sessionExecutionContexts.get(sessionID)
+    if (isPlanAgent(currentContext?.agent)) {
+      await pauseActiveGoal(sessionID, {
+        stopReason: "plan agent active",
+        status: "Auto-continue paused because the active agent switched to Plan.",
+        history: "Paused before auto-continue because the active session agent switched to Plan.",
+      })
+      return null
+    }
+
+    const newHumanMessage =
+      refreshed.latestRealUserMessageID &&
+      refreshed.latestRealUserMessageID !== baseline.latestRealUserMessageID
+    if (newHumanMessage || userInterventionDetected(messages, goal)) {
+      await pauseActiveGoal(sessionID, {
+        stopReason: "user intervention",
+        status: "Auto-continue paused because a new human message arrived; the latest instruction wins.",
+        history: "Paused auto-continue after a real user message arrived; latest instruction wins.",
+      })
+      return null
+    }
+
+    if (
+      refreshed.latestAssistantID !== baseline.latestAssistantID ||
+      refreshed.latestRelevantMessageID !== baseline.latestRelevantMessageID
+    ) {
+      return null
+    }
+
+    if (!goal.executionContext) {
+      goal.executionContext = findLatestExecutionContext(messages)
+    }
+    const sourceAssistantMessageID = refreshed.latestAssistantID || "<no-assistant>"
+    if (
+      goal.continuationClaim?.runId === runID &&
+      goal.continuationClaim?.sourceAssistantMessageID === sourceAssistantMessageID
+    ) {
+      return null
+    }
+
+    goal.continuationClaim = { runId: runID, sourceAssistantMessageID }
+    const claimPersisted = await persist()
+    if (!claimPersisted && persistenceOptions.persistState) {
+      goal.continuationClaim = null
+      goal.stopped = true
+      goal.stopReason = "continuation claim persistence failed"
+      goal.lastStatus = `Auto-continue paused because its source-turn claim could not be persisted. Run /${commandName} resume after fixing storage.`
+      pushHistory(goal, "paused", "Paused because the durable continuation source claim could not be persisted.")
+      return null
+    }
+    return goal
+  }
+
   const hooks = {
     config: async (config) => {
       applyNativeGoalConfig(config, {
@@ -2890,6 +3133,36 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
       })
       if (pluginOptions.completionAudit) verifierRegistrationReady = true
     },
+    "chat.params": async (input) => {
+      if (!input?.sessionID) return
+      const context = normalizeExecutionContext({
+        agent: input.agent,
+        model: input.model,
+        variant: input?.message?.model?.variant,
+      })
+      if (context) currentRuntime().sessionExecutionContexts.set(input.sessionID, context)
+    },
+    "chat.message": async (input, output) => {
+      const sessionID = input?.sessionID
+      if (!sessionID) return
+      const context = normalizeExecutionContext(input)
+      if (context) currentRuntime().sessionExecutionContexts.set(sessionID, context)
+
+      const message = { role: "user", parts: Array.isArray(output?.parts) ? output.parts : [] }
+      if (isPluginContinuationMessage(message)) return
+      const text = getText(message.parts)
+      const commandPrefix = `/${commandName}`
+      if (text === commandPrefix || text.startsWith(`${commandPrefix} `)) return
+
+      const goal = goalStates.get(sessionID)
+      if (!goal || goal.stopped) return
+      await pauseActiveGoal(sessionID, {
+        stopReason: "user intervention",
+        status: "Auto-continue paused because a new human message arrived; the latest instruction wins.",
+        history: "Paused immediately when a new human message arrived; latest instruction wins.",
+        abortAccepted: true,
+      })
+    },
     "tool.execute.before": async (input) => {
       const sessionID = input?.sessionID
       if (!sessionID || !currentRuntime().readOnlyCommandGuards.has(sessionID)) return
@@ -2985,11 +3258,15 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
           output.parts = [makeTextPart(`No active goal. Set one with \`/${commandName} <condition>\`.`)]
           return
         }
+        currentRuntime().continuationControllers.get(sessionID)?.abort()
         goal.stopped = true
         goal.stopReason = "paused"
         goal.lastStatus = "Goal paused."
+        goal.continuationClaim = null
+        activeContinues.delete(sessionID)
         pushHistory(goal, "paused", "User paused the active goal.")
         await persist()
+        await abortAcceptedContinuation(sessionID)
         output.parts = [makeTextPart(`Goal paused: ${goal.condition}`)]
         return
       }
@@ -3051,6 +3328,7 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
         goal.noProgressTurns = 0
         goal.noToolCallTurns = 0
         goal.formatFailures = 0
+        goal.continuationClaim = null
         goal.lastStatus = "Goal objective updated."
         pushHistory(goal, "edited", `Objective updated to: ${summarizeText(newObjective, 400)}`)
         await persist()
@@ -3072,8 +3350,11 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
         return
       }
 
-      if (args === "sisyphus" || args.toLowerCase().startsWith("sisyphus ")) {
-        const rest = args.slice("sisyphus".length).trim()
+      const sequenceCommand = SEQUENCE_COMMANDS.find(
+        (command) => args.toLowerCase() === command || args.toLowerCase().startsWith(`${command} `),
+      )
+      if (sequenceCommand) {
+        const rest = args.slice(sequenceCommand.length).trim()
         const objectives = rest
           .split(/\n|;/)
           .map((part) => stripWrappingQuotes(part.trim()))
@@ -3081,7 +3362,7 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
         if (!objectives.length) {
           output.parts = [
             makeTextPart(
-              `No objectives provided. Use \`/${commandName} sisyphus <objective 1>; <objective 2>; …\` (separate with \`;\` or newlines).`,
+              `No objectives provided. Use \`/${commandName} sequence <objective 1>; <objective 2>; …\` (separate with \`;\` or newlines).`,
             ),
           ]
           return
@@ -3125,7 +3406,7 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
           pushHistory(
             created,
             "set",
-            `Ordered goal ${index + 1}/${objectives.length} created (sisyphus sequence).`,
+            `Ordered goal ${index + 1}/${objectives.length} created.`,
           )
           registerSessionGoal(created)
         })
@@ -3135,7 +3416,7 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
         output.parts = [
           makeTextPart(
             [
-              `Started an ordered sequence of ${objectives.length} goal(s) (sisyphus mode):`,
+              `Started an ordered sequence of ${objectives.length} goal(s):`,
               ...objectives.map((objective, index) => `${index + 1}. ${objective}`),
               "",
               `Focused goal 1: ${firstGoal.condition}`,
@@ -3285,7 +3566,7 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
       // Replace the focused goal (cleanupGoal discards it); backgrounded goals
       // for this session are preserved. Use `/goal add` to keep the current
       // goal and add another. Clear any ordered-sequence flag so the new
-      // standalone goal does not trigger sisyphus auto-promotion of old sequence
+      // standalone goal does not trigger auto-promotion of the old sequence
       // goals that may still be in the registry (matches the agent setGoal path).
       sessionOrdered.delete(sessionID)
       cleanupGoal(sessionID)
@@ -3324,17 +3605,33 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
     },
 
     event: async ({ event }) => {
-      if (isAbortErrorEvent(event)) {
+      if (event?.type === "session.status") {
         const sessionID = getSessionID(event)
-        const goal = goalStates.get(sessionID)
-        if (!goal) return
-        currentRuntime().continuationControllers.get(sessionID)?.abort()
-        goal.stopped = true
-        goal.stopReason = "user interrupted"
-        goal.lastStatus = `Goal paused after user interruption. Run /${commandName} resume to continue.`
-        pushHistory(goal, "paused", "Paused after OpenCode reported that the user interrupted the active turn.")
-        activeContinues.delete(sessionID)
-        await persist()
+        const status = event?.properties?.status?.type || event?.data?.status?.type
+        if (sessionID && status) currentRuntime().sessionStatuses.set(sessionID, status)
+      }
+
+      if (event?.type === "session.updated") {
+        const sessionID = getSessionID(event)
+        const context = normalizeExecutionContext(event?.properties?.info || event?.data?.info)
+        if (sessionID && context) currentRuntime().sessionExecutionContexts.set(sessionID, context)
+      }
+
+      if (event?.type === "message.updated") {
+        const message = messageInfoFromEvent(event)
+        if (messageRole(message) === "user") {
+          const context = normalizeExecutionContext(message)
+          const sessionID = messageSessionID(message) || getSessionID(event)
+          if (sessionID && context) currentRuntime().sessionExecutionContexts.set(sessionID, context)
+        }
+      }
+
+      const terminal = terminalEvent(event)
+      if (terminal?.sessionID) {
+        await pauseActiveGoal(terminal.sessionID, {
+          ...terminal,
+          abortAccepted: true,
+        })
         return
       }
 
@@ -3410,6 +3707,12 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
       if (!isIdleEvent(event)) return
 
       const sessionID = getSessionID(event)
+      // Deprecated session.idle carries no status object but is itself an
+      // authoritative idle signal. Current session.status events were recorded
+      // above before entering this branch.
+      if (event?.type === "session.idle") {
+        currentRuntime().sessionStatuses.set(sessionID, "idle")
+      }
       currentRuntime().readOnlyCommandGuards.delete(sessionID)
       const eventID = typeof event?.id === "string" ? event.id : ""
       const seenIdleEventIDs = currentRuntime().seenIdleEventIDs
@@ -3429,6 +3732,7 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
 
       const continueToken = randomUUID()
       const continueController = new AbortController()
+      let claimedSourceAssistantMessageID = ""
       activeContinues.set(sessionID, continueToken)
       currentRuntime().continuationControllers.set(sessionID, continueController)
       try {
@@ -3440,9 +3744,12 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
           : []
         const activeGoalAfterMessages = activeGoal(sessionID, goalID, runID)
         if (!activeGoalAfterMessages) return
+        if (!activeGoalAfterMessages.executionContext) {
+          activeGoalAfterMessages.executionContext = findLatestExecutionContext(messages)
+        }
 
         const latestAssistant = findLatestAssistantMessage(messages)
-        const latestAssistantID = latestAssistant?.info?.id || ""
+        const latestAssistantID = messageID(latestAssistant)
         const latestText = getText(latestAssistant?.parts)
         const latestOutputTokens = latestAssistant ? outputTokensForMessage(latestAssistant) : null
         const previousAssistantText = activeGoalAfterMessages.lastAssistantText
@@ -3462,16 +3769,20 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
         // since the last auto-continue, stop driving the loop and defer to the
         // human. They can /goal resume to hand control back to the plugin.
         if (userInterventionDetected(messages, activeGoalAfterMessages)) {
-          activeGoalAfterMessages.stopped = true
-          activeGoalAfterMessages.stopReason = "user intervention"
-          activeGoalAfterMessages.lastStatus =
-            `Auto-continue paused: you sent a new message, so the latest instruction wins. Run /${commandName} resume to continue the goal.`
-          pushHistory(
-            activeGoalAfterMessages,
-            "paused",
-            "Paused auto-continue after a real user message arrived; latest instruction wins.",
-          )
-          await persist()
+          await pauseActiveGoal(sessionID, {
+            stopReason: "user intervention",
+            status: "Auto-continue paused because a new human message arrived; the latest instruction wins.",
+            history: "Paused auto-continue after a real user message arrived; latest instruction wins.",
+          })
+          return
+        }
+
+        const sourceAssistantMessageID = latestAssistantID || "<no-assistant>"
+        if (
+          activeGoalAfterMessages.continuationClaim?.runId === runID &&
+          activeGoalAfterMessages.continuationClaim?.sourceAssistantMessageID ===
+            sourceAssistantMessageID
+        ) {
           return
         }
 
@@ -3547,7 +3858,7 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
             const ordered = sessionOrdered.has(sessionID)
             rememberGoalResult(sessionID, activeGoalAfterMessages, "achieved", "", evidence)
             cleanupGoal(sessionID)
-            // Ordered (sisyphus) sequence: auto-promote the next goal so the
+            // Ordered sequence: auto-promote the next goal so the
             // session keeps working through the sequence without manual /goal focus.
             if (ordered) {
               promoteNextOrderedGoal(sessionID)
@@ -3612,14 +3923,35 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
         const limitReason = stopReason(activeGoalAfterMessages)
         if (limitReason) {
           if (!activeGoalAfterMessages.budgetWrapupSent) {
-            activeGoalAfterMessages.budgetWrapupSent = true
-            activeGoalAfterMessages.stopped = true
-            activeGoalAfterMessages.stopReason = limitReason
-            activeGoalAfterMessages.lastStatus = `${limitReason}; requested final handoff.`
-            pushHistory(activeGoalAfterMessages, "limit", `${limitReason}; requested a final handoff.`)
-            await sessionApi.promptAsync(sessionID, {
-              parts: [makeContinuationPart(buildContinueMessage(activeGoalAfterMessages, { budgetWrapup: true }))],
-            })
+            const claimedGoal = await claimContinuationSource(
+              sessionID,
+              goalID,
+              runID,
+              messages,
+            )
+            if (!claimedGoal) return
+            claimedSourceAssistantMessageID =
+              claimedGoal.continuationClaim?.sourceAssistantMessageID || ""
+            claimedGoal.budgetWrapupSent = true
+            claimedGoal.stopped = true
+            claimedGoal.stopReason = limitReason
+            claimedGoal.lastStatus = `${limitReason}; requested final handoff.`
+            pushHistory(claimedGoal, "limit", `${limitReason}; requested a final handoff.`)
+            await persist()
+            currentRuntime().promptInFlightSessions.add(sessionID)
+            let response
+            try {
+              response = await sessionApi.promptAsync(sessionID, {
+                ...continuationContextInput(claimedGoal),
+                parts: [makeContinuationPart(buildContinueMessage(claimedGoal, { budgetWrapup: true }))],
+              })
+            } finally {
+              currentRuntime().promptInFlightSessions.delete(sessionID)
+            }
+            if (response?.error) {
+              claimedGoal.lastStatus = `${limitReason}; final handoff request failed: ${response.error.name || "unknown error"}.`
+              pushHistory(claimedGoal, "error", claimedGoal.lastStatus)
+            }
           } else {
             activeGoalAfterMessages.stopped = true
             activeGoalAfterMessages.stopReason = limitReason
@@ -3741,6 +4073,7 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
         }
 
         const elapsedSinceLastContinue = Date.now() - activeGoalAfterMessages.lastContinueAt
+        let cooldownWaited = false
         if (
           activeGoalAfterMessages.lastContinueAt &&
           elapsedSinceLastContinue < activeGoalAfterMessages.options.minDelayMs
@@ -3750,10 +4083,19 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
             continueController.signal,
           )
           if (!delayCompleted) return
+          cooldownWaited = true
         }
 
-        const activeGoalBeforePrompt = activeGoal(sessionID, goalID, runID)
+        const activeGoalBeforePrompt = await claimContinuationSource(
+          sessionID,
+          goalID,
+          runID,
+          messages,
+          { refreshMessages: cooldownWaited },
+        )
         if (!activeGoalBeforePrompt) return
+        claimedSourceAssistantMessageID =
+          activeGoalBeforePrompt.continuationClaim?.sourceAssistantMessageID || ""
 
         const budgetWrapup = budgetWrapupNeeded(activeGoalBeforePrompt)
         if (budgetWrapup) {
@@ -3810,22 +4152,33 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
           }
         }
 
-        const response = await sessionApi.promptAsync(sessionID, {
-          parts: [
-            makeContinuationPart(
-              buildContinueMessage(activeGoalBeforePrompt, {
-                budgetWrapup,
-                completionUnverified,
-                blockerUnstated,
-              }),
-            ),
-          ],
-        })
+        currentRuntime().promptInFlightSessions.add(sessionID)
+        let response
+        try {
+          response = await sessionApi.promptAsync(sessionID, {
+            ...continuationContextInput(activeGoalBeforePrompt),
+            parts: [
+              makeContinuationPart(
+                buildContinueMessage(activeGoalBeforePrompt, {
+                  budgetWrapup,
+                  completionUnverified,
+                  blockerUnstated,
+                }),
+              ),
+            ],
+          })
+        } finally {
+          currentRuntime().promptInFlightSessions.delete(sessionID)
+        }
 
         if (response.error) {
           const activeGoalAfterPrompt = currentGoal(sessionID, goalID, runID)
           const message = `Auto-continue failed: ${response.error.name || "unknown error"}`
-          if (activeGoalAfterPrompt) {
+          if (
+            activeGoalAfterPrompt?.continuationClaim?.sourceAssistantMessageID ===
+            claimedSourceAssistantMessageID
+          ) {
+            activeGoalAfterPrompt.continuationClaim = null
             activeGoalAfterPrompt.promptFailures += 1
             activeGoalAfterPrompt.lastStatus = message
             pushHistory(activeGoalAfterPrompt, "error", message)
@@ -3838,7 +4191,10 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
           await logPluginError(client, message, response.error)
         } else {
           const activeGoalAfterPrompt = currentGoal(sessionID, goalID, runID)
-          if (activeGoalAfterPrompt) {
+          if (
+            activeGoalAfterPrompt?.continuationClaim?.sourceAssistantMessageID ===
+            claimedSourceAssistantMessageID
+          ) {
             // Decrement rather than reset: an alternating error/success pattern
             // should still accumulate toward the circuit-breaker cap over time,
             // matching the formatFailures approach for the same reason.
@@ -3856,6 +4212,13 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
       } catch (error) {
         const activeGoalAfterError = currentGoal(sessionID, goalID, runID)
         if (activeGoalAfterError) {
+          if (
+            claimedSourceAssistantMessageID &&
+            activeGoalAfterError.continuationClaim?.sourceAssistantMessageID ===
+              claimedSourceAssistantMessageID
+          ) {
+            activeGoalAfterError.continuationClaim = null
+          }
           activeGoalAfterError.promptFailures += 1
           const message = `Auto-continue failed: ${error?.message || error}`
           activeGoalAfterError.lastStatus = message
@@ -3869,6 +4232,7 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
         }
         await logPluginError(client, "Auto-continue failed", error)
       } finally {
+        currentRuntime().promptInFlightSessions.delete(sessionID)
         // Only delete our own entry. If cleanupGoal already removed it (because
         // the goal completed) and a new handler has since set a fresh token,
         // we must not clobber the new handler's guard.