opencode-goal-plugin 0.4.1 → 0.5.0

package/src/goal-plugin.js

@@ -56,7 +56,13 @@ const MAX_ARCHIVED_PER_SESSION = 10
 const lastGoalResults = new Map()
 const seenTokens = new Map()
 const seenOutputTokens = new Map()
-const activeContinues = new Set()
+// Map<sessionID, token> rather than Set so the idle handler's finally block can
+// detect whether its entry has been superseded by a new handler: if cleanupGoal
+// deletes the sessionID (allowing a new handler to start and set a fresh token)
+// before the old handler's finally fires, the old finally skips the delete
+// because the token no longer matches. With a plain Set, the old finally would
+// unconditionally delete the new handler's guard, exposing a race window.
+const activeContinues = new Map()
 const CLEAR_COMMANDS = new Set(["clear", "stop", "off", "reset", "none", "cancel"])
 const PAUSE_COMMANDS = new Set(["pause"])
 const GOAL_FLAG_SPECS = {
@@ -111,7 +117,9 @@ const GOAL_FLAG_SPECS = {
 // shapes count as tool-using turns too). A continuation turn with none of these
 // is "talk only" — a signal of a self-chat loop the auto-continue should not
 // keep feeding.
-const TOOL_PART_TYPES = new Set(["tool", "tool-invocation", "subtask"])
+// Covers both normalized OpenCode types and raw provider-specific part types
+// (some adapters forward the provider's original shape without normalizing).
+const TOOL_PART_TYPES = new Set(["tool", "tool-invocation", "subtask", "tool_use", "function_call", "tool-call"])
 
 function messageHasToolCall(message) {
   const parts = Array.isArray(message?.parts) ? message.parts : []
@@ -442,10 +450,13 @@ function promoteNextOrderedGoal(sessionID) {
 function cleanupGoal(sessionID) {
   const goal = goalStates.get(sessionID)
   if (goal) {
-    for (const messageID of goal.messageIDs) {
-      seenTokens.delete(messageID)
-      seenOutputTokens.delete(messageID)
-    }
+    // seenTokens entries for this goal's message IDs are intentionally NOT deleted
+    // here. resetGoalBudget also leaves them in place. The message.updated handler
+    // uses the presence of an ID in seenTokens combined with its absence from the
+    // current goal.messageIDs to detect and skip stale re-deliveries — deleting
+    // entries here would break that guard for post-replacement stale events.
+    // Entries are cleared in bulk by clearRuntimeState on plugin teardown; the
+    // per-process accumulation is small (O(turns × messages_per_turn)).
     removeSessionGoal(sessionID, goal.goalId)
   }
   goalStates.delete(sessionID)
@@ -505,10 +516,11 @@ function rememberGoalResult(sessionID, goal, state, reason = "", evidence = "")
 }
 
 function resetGoalBudget(goal) {
-  for (const messageID of goal.messageIDs) {
-    seenTokens.delete(messageID)
-    seenOutputTokens.delete(messageID)
-  }
+  // Do NOT delete old message IDs from seenTokens here. The message.updated
+  // handler guards against stale re-deliveries by checking whether the message ID
+  // is in seenTokens but NOT in the current goal.messageIDs — keeping the entries
+  // alive is what makes that check reliable. cleanupGoal removes them when the
+  // goal is fully discarded, so seenTokens entries are bounded to active goals.
   goal.goalId = randomUUID()
   goal.startedAt = Date.now()
   goal.turnCount = 0
@@ -765,6 +777,7 @@ function normalizePersistedGoal(rawGoal) {
     stopped: rawGoal.stopped === true,
     stopReason: typeof rawGoal.stopReason === "string" ? rawGoal.stopReason : "",
     promptFailures: toNonNegativeInteger(rawGoal.promptFailures),
+    formatFailures: toNonNegativeInteger(rawGoal.formatFailures),
     messageIDs: Array.isArray(rawGoal.messageIDs)
       ? rawGoal.messageIDs.filter((messageID) => typeof messageID === "string" && messageID)
       : [],
@@ -925,6 +938,38 @@ async function applyParsedStateFile(raw, client) {
   return "loaded"
 }
 
+// After applyParsedStateFile loads goals into goalStates, check the ledger for
+// terminal events. If a goal has a "completed" or "cleared" entry in the ledger
+// but still appears active in the state file (because the state write failed
+// after the terminal ledger write), remove it so it is not re-driven.
+async function reconcileLoadedStateWithLedger(persistenceOptions, client) {
+  const entries = await readLedgerEntries(persistenceOptions.ledgerFilePath)
+  if (!entries.length) return
+
+  const terminalGoalIds = new Set()
+  for (const entry of entries) {
+    if (LEDGER_TERMINAL_TYPES.has(entry.type) && typeof entry.goalId === "string" && entry.goalId) {
+      terminalGoalIds.add(entry.goalId)
+    }
+  }
+  if (!terminalGoalIds.size) return
+
+  let removed = 0
+  for (const [sessionID, goal] of goalStates.entries()) {
+    if (terminalGoalIds.has(goal.goalId)) {
+      removeSessionGoal(sessionID, goal.goalId)
+      goalStates.delete(sessionID)
+      removed++
+    }
+  }
+  if (removed > 0) {
+    await logPluginError(
+      client,
+      `Ledger cross-check: removed ${removed} goal(s) whose terminal state was recorded in the ledger but not yet reflected in the state file (likely a failed terminal persist).`,
+    )
+  }
+}
+
 async function loadPersistedState(persistenceOptions, client) {
   if (!persistenceOptions.persistState) return "disabled"
 
@@ -955,7 +1000,15 @@ async function loadPersistedState(persistenceOptions, client) {
       continue
     }
 
-    if (status === "loaded") return primary ? "loaded" : "migrated"
+    if (status === "loaded") {
+      // Cross-check: the ledger is written before the state file for terminal
+      // events (completed, cleared). If the terminal persist succeeded in the
+      // ledger but the state file write failed (e.g. process killed between the
+      // two writes), the reloaded state may still have the goal as active. Remove
+      // any loaded active goals whose goalId has a terminal ledger entry.
+      await reconcileLoadedStateWithLedger(persistenceOptions, client)
+      return primary ? "loaded" : "migrated"
+    }
     // status === "invalid": preserve a present-but-corrupt primary; for a
     // fallback, keep trying the next candidate.
     if (primary) return "invalid"
@@ -1179,6 +1232,17 @@ const STRUCTURAL_TAGS = [
   "next_step",
   "completion_audit",
   "evidence_required",
+  // Role-like names that model providers treat as elevated context (second-order
+  // injection: a goal could guide the model to emit these in output captured by
+  // recordCheckpoint, then re-injected via compaction or buildGoalBlock).
+  "system",
+  "instructions",
+  "human",
+  "assistant",
+  "anthropic",
+  "claude",
+  "context",
+  "prompt",
 ]
 const STRUCTURAL_OPEN_TAG_RE = new RegExp(`<(${STRUCTURAL_TAGS.join("|")})\\b`, "gi")
 
@@ -1321,14 +1385,17 @@ function buildCompactionProgressSummary(goal, { maxCheckpoints = 3, maxEvents =
   if (checkpoints.length) {
     lines.push("Recent checkpoints (oldest first):")
     for (const checkpoint of checkpoints) {
-      lines.push(`- ${summarizeText(checkpoint.summary, 200)}`)
+      // Escape: checkpoint summaries contain assistant-generated text; an
+      // adversarial model output could inject structural tags into this string,
+      // which would be re-embedded in the compaction context system message.
+      lines.push(`- ${escapeGoalText(summarizeText(checkpoint.summary, 200))}`)
     }
   }
   const events = Array.isArray(goal.history) ? goal.history.slice(-maxEvents) : []
   if (events.length) {
     lines.push("Recent lifecycle events (oldest first):")
     for (const event of events) {
-      lines.push(`- ${event.type}: ${summarizeText(event.detail, 160)}`)
+      lines.push(`- ${event.type}: ${escapeGoalText(summarizeText(event.detail, 160))}`)
     }
   }
   return lines
@@ -1339,14 +1406,19 @@ function buildCompactionContext(goal) {
   // this, a compaction can drop the goal objective and budget state from the
   // working context, so the assistant loses the thread mid-run even though the
   // plugin still re-injects via system.transform afterward.
-  const elapsedSeconds = Math.round((Date.now() - goal.startedAt) / 1000)
+  // Use goal.lastContinueAt (set on each persist cycle) rather than Date.now()
+  // so buildCompactionContext is deterministic. If OpenCode calls the compacting
+  // hook more than once, each invocation produces the same elapsedSeconds and
+  // therefore the same string — preserving the prefix cache from this point on.
+  const snapshotAt = goal.lastContinueAt || goal.startedAt || 0
+  const elapsedSeconds = Math.round((snapshotAt - goal.startedAt) / 1000)
   return [
     "An OpenCode goal is active for this session. Preserve it across compaction.",
     "The summary below is reconstructed deterministically from the plugin's persisted goal record, not from chat memory.",
     buildGoalBlock(goal),
     `Goal status: ${goal.stopped ? goal.stopReason || "stopped" : "active"}.`,
     `Auto-continues used: ${goal.turnCount}/${goal.options.maxTurns}. Context tokens: ${goal.totalTokens}/${goal.options.maxTokens}. Elapsed: ${elapsedSeconds}s.`,
-    goal.lastCheckpoint ? `Latest checkpoint: ${goal.lastCheckpoint.summary}` : null,
+    goal.lastCheckpoint ? `Latest checkpoint: ${escapeGoalText(goal.lastCheckpoint.summary)}` : null,
     ...buildCompactionProgressSummary(goal),
     "After compaction, continue from the next concrete unfinished step while the goal is active. Verify the result against the goal objective before ending; output [goal:complete] (preceded by a [goal:evidence] line) only when fully satisfied, or [goal:blocked] (preceded by a concrete blocker) only if user input is required.",
   ]
@@ -1601,7 +1673,11 @@ const AGENT_UPDATE_STATUSES = new Set(["complete", "blocked", "paused", "resumed
 // result. Goal creation/replacement routes through the multi-goal registry
 // (buildGoalState + registerSessionGoal + focusGoal) exactly like the command
 // path, so tool-created goals persist and are driven by the idle handler.
-function buildAgentToolHandlers({ defaultGoalOptions, persist }) {
+function buildAgentToolHandlers({ defaultGoalOptions, persist, persistTerminalState = null, completionAuditor = null }) {
+  // Use persistTerminalState (which logs on failure) for terminal operations when
+  // available; fall back to plain persist for callers that don't wire it up (e.g.
+  // tests using buildAgentToolHandlers directly).
+  const persistFinal = persistTerminalState || persist
   async function getGoal(sessionID) {
     const goal = goalStates.get(sessionID)
     if (goal) return formatStatus(goal)
@@ -1638,6 +1714,17 @@ function buildAgentToolHandlers({ defaultGoalOptions, persist }) {
     const objective = typeof args.objective === "string" ? args.objective.trim() : ""
     if (!objective) return "No objective provided. Pass a non-empty `objective`."
 
+    // Validate budget args before normalizing: normalizeOptions silently substitutes
+    // defaults for non-positive values, giving no feedback to the caller.
+    if (Number.isFinite(args.maxTurns) && args.maxTurns <= 0)
+      return `Invalid maxTurns: ${args.maxTurns} — must be a positive integer.`
+    if (Number.isFinite(args.maxTokens) && args.maxTokens <= 0)
+      return `Invalid maxTokens: ${args.maxTokens} — must be a positive integer.`
+    if (Number.isFinite(args.maxDurationMs) && args.maxDurationMs <= 0)
+      return `Invalid maxDurationMs: ${args.maxDurationMs} — must be a positive number.`
+    if (args.mode !== undefined && !GOAL_MODES.has(String(args.mode).toLowerCase()))
+      return `Invalid mode: ${args.mode} (expected ${[...GOAL_MODES].join(" or ")}).`
+
     const options = normalizeOptions({
       ...defaultGoalOptions,
       ...(Number.isFinite(args.maxTurns) ? { maxTurns: args.maxTurns } : {}),
@@ -1664,25 +1751,48 @@ function buildAgentToolHandlers({ defaultGoalOptions, persist }) {
     registerSessionGoal(goal)
     focusGoal(sessionID, goal)
     await persist()
-    return `New active goal: ${goal.condition}`
+    // Escape in the tool result only: goal.condition is stored raw so callers
+    // that build XML (buildGoalBlock, buildContinueMessage) can apply escaping
+    // themselves. Escaping here prevents XML metacharacters in user-supplied
+    // objectives from breaking tool-result boundaries in XML-serialized formats.
+    return `New active goal: ${escapeGoalText(goal.condition)}`
   }
 
   async function updateGoal(sessionID, args = {}) {
     const goal = goalStates.get(sessionID)
     if (!goal) return "No active goal to update. Use set_goal first."
 
+    // Reject the combination of an objective update with status='complete': the
+    // completion would be archived under a condition that was never executed,
+    // falsifying the audit trail. Require two separate calls.
+    if (
+      typeof args.objective === "string" &&
+      args.objective.trim() &&
+      String(args.status || "").trim().toLowerCase() === "complete"
+    ) {
+      return (
+        "Cannot combine an objective update with status='complete'. " +
+        "Use two separate calls: first update the objective (which revises the goal), " +
+        "then mark it complete after completing the revised work."
+      )
+    }
+
     const messages = []
 
     if (typeof args.objective === "string" && args.objective.trim()) {
       goal.condition = args.objective.trim()
-      goal.stopped = false
-      goal.stopReason = ""
+      // Deliberately NOT clearing goal.stopped or goal.stopReason: updating the
+      // objective does not un-stop a goal. Use status='resumed' to explicitly
+      // restart a stopped goal; silently un-stopping would resurrect audit-rejected
+      // or user-paused goals without the user's knowledge.
       goal.blockedReason = ""
       goal.budgetWrapupSent = false
       goal.noProgressTurns = 0
+      goal.noToolCallTurns = 0
+      goal.formatFailures = 0
       goal.lastStatus = "Goal objective updated."
       pushHistory(goal, "edited", `Objective updated to: ${summarizeText(goal.condition, 400)}`)
-      messages.push(`Objective updated: ${goal.condition}`)
+      messages.push(`Objective updated: ${escapeGoalText(goal.condition)}`)
     }
 
     if (args.status !== undefined) {
@@ -1692,6 +1802,27 @@ function buildAgentToolHandlers({ defaultGoalOptions, persist }) {
       }
       if (status === "complete") {
         const evidence = typeof args.evidence === "string" ? args.evidence.trim() : ""
+        // If a completion auditor is configured, run it before archiving so the
+        // agent tool path has the same integrity gate as the [goal:complete] marker
+        // path. Without this, an autonomous agent could bypass the auditor by
+        // calling update_goal({status:"complete"}) instead of using the marker.
+        if (completionAuditor) {
+          let verdict
+          try {
+            verdict = await completionAuditor({ goal, sessionID, latestText: evidence })
+          } catch (error) {
+            verdict = { approved: false, reason: "auditor error" }
+          }
+          if (!verdict || verdict.approved !== true) {
+            const reason = (verdict && verdict.reason) || "completion not substantiated"
+            goal.stopped = true
+            goal.stopReason = "audit rejected"
+            goal.lastStatus = `Completion audit rejected: ${summarizeText(reason, 200)}. Address it, then run /goal resume.`
+            pushHistory(goal, "audit-rejected", `Agent tool completion audit rejected: ${summarizeText(reason, 300)}`)
+            await persist()
+            return `Completion audit rejected: ${summarizeText(reason, 200)}. Goal paused; use /goal resume after addressing the issue.`
+          }
+        }
         goal.lastStatus = "Goal completed."
         pushHistory(
           goal,
@@ -1702,15 +1833,18 @@ function buildAgentToolHandlers({ defaultGoalOptions, persist }) {
         cleanupGoal(sessionID)
         // Advance an ordered (sisyphus) sequence just like the marker path does.
         if (sessionOrdered.has(sessionID)) promoteNextOrderedGoal(sessionID)
-        await persist()
+        await persistFinal("completion")
         return "Goal marked complete and archived."
       }
       if (status === "blocked") {
-        goal.blockedReason = typeof args.blocker === "string" ? args.blocker.trim() : ""
+        const blockerText = typeof args.blocker === "string" ? args.blocker.trim() : ""
+        if (!blockerText)
+          return "status 'blocked' requires a non-empty 'blocker' argument describing what is needed."
+        goal.blockedReason = blockerText
         goal.stopped = true
         goal.stopReason = "blocked"
         goal.lastStatus = "Assistant reported blocked."
-        pushHistory(goal, "blocked", goal.blockedReason || "Marked blocked via agent tool.")
+        pushHistory(goal, "blocked", goal.blockedReason)
         messages.push("Goal marked blocked.")
       } else if (status === "paused") {
         goal.stopped = true
@@ -1719,15 +1853,15 @@ function buildAgentToolHandlers({ defaultGoalOptions, persist }) {
         pushHistory(goal, "paused", "Paused via agent tool.")
         messages.push("Goal paused.")
       } else if (status === "resumed") {
+        if (!goal.stopped)
+          return "Goal is already running. Pause or stop it first if you want to reset the budget window."
         const previousGoalId = goal.goalId
         resetGoalBudget(goal)
-        // resetGoalBudget rotates goalId; re-key the registry so the goal stays
-        // findable by its new id (the focused pointer holds the same object).
-        if (goal.goalId !== previousGoalId) {
-          removeSessionGoal(sessionID, previousGoalId)
-          registerSessionGoal(goal)
-          focusGoal(sessionID, goal)
-        }
+        // resetGoalBudget always rotates goalId via randomUUID; unconditionally
+        // re-key the registry so the goal stays findable by its new id.
+        removeSessionGoal(sessionID, previousGoalId)
+        registerSessionGoal(goal)
+        focusGoal(sessionID, goal)
         goal.stopped = false
         goal.stopReason = ""
         goal.blockedReason = ""
@@ -1745,11 +1879,17 @@ function buildAgentToolHandlers({ defaultGoalOptions, persist }) {
   }
 
   async function clearGoal(sessionID) {
-    // Mirror `/goal clear`: drop the ordered flag and the focused goal + result.
+    // Mirror `/goal clear`: drop the ordered flag, ALL backgrounded goals, and the
+    // focused goal + result. Without sessionGoals.delete, background goals added via
+    // `/goal add` survive clear and resurrect as the focused goal on restart.
+    // Record the clear in the ledger before cleanupGoal removes the goal object.
+    const goalBeforeClear = goalStates.get(sessionID)
+    if (goalBeforeClear) pushHistory(goalBeforeClear, "cleared", "Cleared via agent tool.")
     sessionOrdered.delete(sessionID)
+    sessionGoals.delete(sessionID)
     cleanupGoal(sessionID)
     lastGoalResults.delete(sessionID)
-    await persist()
+    await persistFinal("clear")
     return "Goal cleared."
   }
 
@@ -1925,9 +2065,9 @@ function extractAuditVerdictText(response) {
 // so a missing/broken auditor pipeline never blocks legitimate completions.
 // NOTE: the exact child-session SDK shape should be confirmed against a live
 // OpenCode; the orchestration around it is what the tests cover.
-function createChildSessionAuditor(client, { agent = "build" } = {}) {
+function createChildSessionAuditor(client, { agent = "build", timeoutMs = 120_000 } = {}) {
   return async ({ goal, sessionID, latestText }) => {
-    try {
+    const run = async () => {
       const sessionApi = client?.session
       if (!sessionApi?.create || !sessionApi?.prompt) {
         return { approved: true, reason: "child-session API unavailable; auto-approved" }
@@ -1948,20 +2088,50 @@ function createChildSessionAuditor(client, { agent = "build" } = {}) {
         verdictText = getText(findLatestAssistantMessage(messages?.data)?.parts)
       }
       return parseAuditVerdict(verdictText)
+    }
+
+    let timerID
+    const timeout = new Promise((resolve) => {
+      timerID = setTimeout(
+        () => resolve({ approved: false, reason: `auditor timed out after ${timeoutMs}ms` }),
+        timeoutMs,
+      )
+    })
+
+    try {
+      const result = await Promise.race([run(), timeout])
+      return result
     } catch (error) {
       return { approved: true, reason: `auditor error (auto-approved): ${error?.message || error}` }
+    } finally {
+      clearTimeout(timerID)
     }
   }
 }
 
-export const GoalPlugin = async ({ client }, pluginOptions = {}) => {
+export const GoalPlugin = async ({ client, directory } = {}, pluginOptions = {}) => {
   const defaultGoalOptions = normalizeOptions(pluginOptions)
+  // OpenCode's PluginInput carries the active session's project directory
+  // separately from the Node process's own process.cwd(), which — when
+  // OpenCode runs as a persistent server/daemon serving multiple
+  // projects/sessions — does NOT track the session's directory. Falling back
+  // to process.cwd() here would silently resolve the project-local state
+  // path against wherever the server happened to boot, not the project the
+  // user is actually working in. An explicit `cwd` plugin option (mainly for
+  // tests) still takes precedence.
   const persistenceOptions = normalizePersistenceOptions(pluginOptions, {
     env: pluginOptions.env,
-    cwd: pluginOptions.cwd,
+    cwd: pluginOptions.cwd || directory,
   })
   const { commandName, registerCommand } = normalizeCommandOptions(pluginOptions)
-  const persist = async () => persistState(persistenceOptions, client)
+  // Serialize all persist() calls through a promise chain so concurrent callers
+  // never race on the temp-file rename. persistState returns a boolean and never
+  // rejects, so the chain cannot stall on a thrown error.
+  let persistChain = Promise.resolve(true)
+  const persist = () => {
+    persistChain = persistChain.then(() => persistState(persistenceOptions, client))
+    return persistChain
+  }
 
   // Fail-closed (item 2.5): when persisting a terminal state (complete/blocked)
   // fails, surface it loudly. The terminal event is already in the append-only
@@ -2023,7 +2193,7 @@ export const GoalPlugin = async ({ client }, pluginOptions = {}) => {
     await persist()
   }
 
-  const agentToolHandlers = buildAgentToolHandlers({ defaultGoalOptions, persist })
+  const agentToolHandlers = buildAgentToolHandlers({ defaultGoalOptions, persist, persistTerminalState, completionAuditor })
 
   const hooks = {
     "command.execute.before": async (input, output) => {
@@ -2076,7 +2246,16 @@ export const GoalPlugin = async ({ client }, pluginOptions = {}) => {
       }
 
       if (CLEAR_COMMANDS.has(args)) {
+        // Record the clear in the ledger before cleanupGoal removes the goal
+        // object, so reconstructFromLedger can identify cleared goals and skip
+        // them rather than reconstructing them after a missing state file.
+        // sessionGoals.delete clears ALL backgrounded goals so they do not
+        // resurrect as the focused goal on restart (cleanupGoal only removes the
+        // focused one; background goals from `/goal add` would survive otherwise).
+        const goalBeforeClear = goalStates.get(sessionID)
+        if (goalBeforeClear) pushHistory(goalBeforeClear, "cleared", "User cleared the goal.")
         sessionOrdered.delete(sessionID)
+        sessionGoals.delete(sessionID)
         cleanupGoal(sessionID)
         lastGoalResults.delete(sessionID)
         await persist()
@@ -2112,14 +2291,11 @@ export const GoalPlugin = async ({ client }, pluginOptions = {}) => {
 
         const previousGoalId = goal.goalId
         resetGoalBudget(goal)
-        // resetGoalBudget rotates goalId; re-key the multi-goal registry to the
-        // new id so a later clear/replace removes the goal instead of leaking a
-        // stale entry (the focused pointer holds the same object reference).
-        if (goal.goalId !== previousGoalId) {
-          removeSessionGoal(sessionID, previousGoalId)
-          registerSessionGoal(goal)
-          focusGoal(sessionID, goal)
-        }
+        // resetGoalBudget always rotates goalId via randomUUID; unconditionally
+        // re-key the registry so a later clear/replace removes the right entry.
+        removeSessionGoal(sessionID, previousGoalId)
+        registerSessionGoal(goal)
+        focusGoal(sessionID, goal)
         goal.stopped = false
         goal.stopReason = ""
         goal.blockedReason = ""
@@ -2156,6 +2332,8 @@ export const GoalPlugin = async ({ client }, pluginOptions = {}) => {
         goal.blockedReason = ""
         goal.budgetWrapupSent = false
         goal.noProgressTurns = 0
+        goal.noToolCallTurns = 0
+        goal.formatFailures = 0
         goal.lastStatus = "Goal objective updated."
         pushHistory(goal, "edited", `Objective updated to: ${summarizeText(newObjective, 400)}`)
         await persist()
@@ -2358,7 +2536,11 @@ export const GoalPlugin = async ({ client }, 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.
+      // goal and add another. Clear any ordered-sequence flag so the new
+      // standalone goal does not trigger sisyphus auto-promotion of old sequence
+      // goals that may still be in the registry (matches the agent setGoal path).
+      const replacedGoal = goalStates.get(sessionID)
+      sessionOrdered.delete(sessionID)
       cleanupGoal(sessionID)
       lastGoalResults.delete(sessionID)
       registerSessionGoal(goal)
@@ -2367,6 +2549,13 @@ export const GoalPlugin = async ({ client }, pluginOptions = {}) => {
       output.parts = [
         makeTextPart(
           [
+            ...(replacedGoal
+              ? [
+                  `⚠️ Replacing active goal: "${replacedGoal.condition}"`,
+                  `Use \`/${commandName} add <condition>\` instead to keep it running in the background.`,
+                  "",
+                ]
+              : []),
             `New active goal: ${goal.condition}`,
             goal.successCriteria ? `Success criteria: ${goal.successCriteria}` : null,
             goal.constraints ? `Constraints / non-goals: ${goal.constraints}` : null,
@@ -2398,6 +2587,14 @@ export const GoalPlugin = async ({ client }, pluginOptions = {}) => {
         const currentMessageID = messageID(message)
         if (!currentMessageID) return
 
+        // Skip stale re-deliveries from a prior budget window or a replaced goal.
+        // resetGoalBudget and cleanupGoal both leave seenTokens entries in place
+        // so this guard can fire: if an ID is already recorded in seenTokens but
+        // is absent from the current goal.messageIDs, it belongs to a previous
+        // budget epoch or a different goal that was replaced, and the event must
+        // not re-inflate totalTokens.
+        if (seenTokens.has(currentMessageID) && !goal.messageIDs.has(currentMessageID)) return
+
         let changed = false
         const currentOutputTokens = outputTokensForMessage(message)
         const previousOutputTokens = seenOutputTokens.get(currentMessageID) || 0
@@ -2438,7 +2635,8 @@ export const GoalPlugin = async ({ client }, pluginOptions = {}) => {
       if (!goal || goal.stopped || activeContinues.has(sessionID)) return
       const goalID = goal.goalId
 
-      activeContinues.add(sessionID)
+      const continueToken = randomUUID()
+      activeContinues.set(sessionID, continueToken)
       try {
         const messages = await client.session.messages({
           path: { id: sessionID },
@@ -2494,6 +2692,11 @@ export const GoalPlugin = async ({ client }, pluginOptions = {}) => {
               sessionID,
               `Auditing goal completion: verifying "${summarizeText(activeGoalAfterMessages.condition, 120)}" is satisfied before archiving.`,
             )
+            // Re-check liveness: announceAudit is async and can yield long enough
+            // for the user to /goal clear or replace the goal. If it's gone,
+            // bail out without archiving — archiving a cleared goal would resurrect
+            // it in memory and potentially in the persisted state.
+            if (!activeGoal(sessionID, goalID)) return
             // Optional independent auditor (item 2.2): an approved verdict
             // archives; a rejected verdict restores (pauses) the goal instead.
             if (completionAuditor) {
@@ -2505,7 +2708,18 @@ export const GoalPlugin = async ({ client }, pluginOptions = {}) => {
                 verdict = { approved: false, reason: "auditor error" }
               }
               const auditedGoal = activeGoal(sessionID, goalID)
-              if (!auditedGoal) return
+              if (!auditedGoal) {
+                // The goal was cleared or replaced while the auditor was running.
+                // If the verdict was approved, surface the loss so the user knows
+                // the completion was verified but not recorded — they can re-engage.
+                if (verdict && verdict.approved === true) {
+                  await announceAudit(
+                    sessionID,
+                    "Audit result: completion was approved but the goal was modified while the audit ran — completion not recorded.",
+                  )
+                }
+                return
+              }
               if (!verdict || verdict.approved !== true) {
                 const reason = (verdict && verdict.reason) || "completion not substantiated"
                 auditedGoal.stopped = true
@@ -2525,8 +2739,10 @@ export const GoalPlugin = async ({ client }, pluginOptions = {}) => {
               )
             }
             activeGoalAfterMessages.lastStatus = "Goal completed."
-            // pushHistory writes the terminal event to the durable ledger first,
-            // so the completion survives even if the state write below fails.
+            // pushHistory attempts to append the terminal event to the ledger before
+            // the state write below. Note: ledger write failures are silent (bare
+            // catch in emitLedgerEvent), and the ledger only enables recovery when
+            // the state file is absent — a stale state file always takes precedence.
             pushHistory(
               activeGoalAfterMessages,
               "completed",
@@ -2608,6 +2824,13 @@ export const GoalPlugin = async ({ client }, pluginOptions = {}) => {
         // tokens), so it resets noProgressTurns the same way the noToolCall
         // gate already resets noToolCallTurns.
         const latestHasToolCall = messageHasToolCall(latestAssistant)
+        // A turn that produced only reasoning tokens (no prose, no tool calls)
+        // is an extended-thinking pass, not a stall. latestOutputTokens counts
+        // prose output only; reasoning tokens are tracked separately. Without
+        // this guard a pure-thinking turn matches lowOutputTurn (output=0 < threshold)
+        // and latestText is empty, so it would false-positively look stalled.
+        const latestHasThinkingTokens =
+          toNonNegativeInteger(messageTokens(latestAssistant).reasoning) > 0
 
         const lowOutputTurn =
           activeGoalAfterMessages.turnCount > 0 &&
@@ -2618,13 +2841,25 @@ export const GoalPlugin = async ({ client }, pluginOptions = {}) => {
         // real work via tool calls. Excluding tool-call turns prevents false
         // noProgress pauses on thinking models.
         const lowOutputLooksStalled =
-          lowOutputTurn && !latestHasToolCall && (assistantRepeated || !latestText || !assistantChanged)
+          lowOutputTurn &&
+          !latestHasToolCall &&
+          !latestHasThinkingTokens &&
+          (assistantRepeated || !latestText || !assistantChanged)
         if (lowOutputLooksStalled) {
           activeGoalAfterMessages.noProgressTurns += 1
           if (
             activeGoalAfterMessages.noProgressTurns >=
             activeGoalAfterMessages.options.noProgressTurnsBeforePause
           ) {
+            // Accumulate format-validation failures even when the stall gate fires
+            // first and returns early, so the formatFailures cap remains reachable
+            // for low-output unverified completions. Without this, a model that
+            // repeatedly emits bare [goal:complete] with low output tokens causes
+            // the stall gate to fire before formatFailures can accumulate, and
+            // /goal resume resets it to zero, making the cap permanently unreachable.
+            if (completionUnverified || blockerUnstated) {
+              activeGoalAfterMessages.formatFailures += 1
+            }
             activeGoalAfterMessages.stopped = true
             activeGoalAfterMessages.stopReason = "no progress"
             activeGoalAfterMessages.lastStatus = `Goal auto-continue paused after ${activeGoalAfterMessages.noProgressTurns} low-progress turn(s); the latest turn produced ${latestOutputTokens} output token(s). Run /${commandName} resume to continue.`
@@ -2643,7 +2878,7 @@ export const GoalPlugin = async ({ client }, pluginOptions = {}) => {
             "warning",
             `Observed a low-progress turn below ${activeGoalAfterMessages.options.noProgressTokenThreshold} output tokens; grace count ${activeGoalAfterMessages.noProgressTurns}/${activeGoalAfterMessages.options.noProgressTurnsBeforePause}.`,
           )
-        } else if (latestOutputTokens !== null || assistantChanged) {
+        } else if (latestOutputTokens !== null || assistantChanged || !latestAssistant) {
           activeGoalAfterMessages.noProgressTurns = 0
         }
 
@@ -2653,9 +2888,14 @@ export const GoalPlugin = async ({ client }, pluginOptions = {}) => {
         // configured grace window. Complements the low-output check above:
         // a turn can be high-output yet still make no real progress because it
         // never touched a tool.
+        // Guard on !lowOutputLooksStalled: if the noProgress gate already fired
+        // for this turn, the noToolCall counter must NOT also increment. Without
+        // this guard, the effective grace window is min(noProgress, noToolCall)
+        // rather than two independent limits — the user's higher noProgress
+        // threshold gets silently overridden by the lower noToolCall threshold.
         const noToolCallContinuation =
           activeGoalAfterMessages.turnCount > 0 && Boolean(latestAssistant) && !latestHasToolCall
-        if (noToolCallContinuation) {
+        if (noToolCallContinuation && !lowOutputLooksStalled) {
           activeGoalAfterMessages.noToolCallTurns += 1
           if (
             activeGoalAfterMessages.noToolCallTurns >=
@@ -2679,7 +2919,7 @@ export const GoalPlugin = async ({ client }, pluginOptions = {}) => {
             "warning",
             `Observed a continuation turn with no tool calls; grace count ${activeGoalAfterMessages.noToolCallTurns}/${activeGoalAfterMessages.options.noToolCallTurnsBeforePause}.`,
           )
-        } else if (latestHasToolCall) {
+        } else if (latestHasToolCall || !latestAssistant) {
           activeGoalAfterMessages.noToolCallTurns = 0
         }
 
@@ -2700,6 +2940,11 @@ export const GoalPlugin = async ({ client }, pluginOptions = {}) => {
           activeGoalBeforePrompt.stopped = true
           activeGoalBeforePrompt.stopReason = "budget wrap-up requested"
           activeGoalBeforePrompt.lastStatus = "Budget threshold reached; requested final handoff."
+          // Persist before sending the wrapup prompt so that a crash during
+          // promptAsync doesn't cause a duplicate wrapup on resume. This mirrors
+          // the hard-limit path which also persists before its promptAsync call.
+          pushHistory(activeGoalBeforePrompt, "budget-wrapup", "Budget threshold reached; sending final handoff prompt.")
+          await persist()
         }
 
         activeGoalBeforePrompt.turnCount += 1
@@ -2712,7 +2957,14 @@ export const GoalPlugin = async ({ client }, pluginOptions = {}) => {
             activeGoalBeforePrompt.formatFailures += 1
             activeGoalBeforePrompt.lastStatus = `Rejected a [goal:blocked] with no concrete blocker; re-prompting on turn ${activeGoalBeforePrompt.turnCount}.`
           } else {
-            activeGoalBeforePrompt.formatFailures = 0
+            // Decrement rather than reset: an alternating bad/good/bad pattern
+            // should not indefinitely bypass the consecutive-failure cap. A model
+            // that produces one clean turn for every violation keeps formatFailures
+            // pinned near 1, which still accumulates toward the cap over time.
+            activeGoalBeforePrompt.formatFailures = Math.max(
+              0,
+              activeGoalBeforePrompt.formatFailures - 1,
+            )
             activeGoalBeforePrompt.lastStatus = latestText
               ? `Continuing after assistant turn ${activeGoalBeforePrompt.turnCount}.`
               : `Continuing after idle event ${activeGoalBeforePrompt.turnCount}.`
@@ -2769,7 +3021,10 @@ export const GoalPlugin = async ({ client }, pluginOptions = {}) => {
         } else {
           const activeGoalAfterPrompt = currentGoal(sessionID, goalID)
           if (activeGoalAfterPrompt) {
-            activeGoalAfterPrompt.promptFailures = 0
+            // 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.
+            activeGoalAfterPrompt.promptFailures = Math.max(0, activeGoalAfterPrompt.promptFailures - 1)
             pushHistory(
               activeGoalAfterPrompt,
               budgetWrapup ? "budget-wrapup" : "auto-continue",
@@ -2796,7 +3051,10 @@ export const GoalPlugin = async ({ client }, pluginOptions = {}) => {
         }
         await logPluginError(client, "Auto-continue failed", error)
       } finally {
-        activeContinues.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.
+        if (activeContinues.get(sessionID) === continueToken) activeContinues.delete(sessionID)
       }
     },
 
@@ -2849,6 +3107,18 @@ export const GoalPlugin = async ({ client }, pluginOptions = {}) => {
       } else {
         output.context = [context]
       }
+      // Reset the token high-water mark so the remaining budget reflects the
+      // compacted context size, not the pre-compaction peak. Without this,
+      // Math.max semantics mean totalTokens never decreases: a goal that crossed
+      // the 80% wrapup threshold before compaction would permanently stay above it
+      // even after the context shrinks to a fraction of its prior size.
+      // Move current message IDs to priorMessageIDs so the message.updated guard
+      // ignores stale events for pre-compaction messages.
+      if (!goal.priorMessageIDs) goal.priorMessageIDs = new Set()
+      for (const id of goal.messageIDs) goal.priorMessageIDs.add(id)
+      goal.messageIDs = new Set()
+      goal.totalTokens = 0
+      await persist()
     },
 
     "experimental.compaction.autocontinue": async (input, output) => {