opencode-goal-plugin 0.6.4 → 0.6.6

package/src/goal-plugin.js

@@ -1,4 +1,4 @@
-import { randomUUID } from "node:crypto"
+import { createHash, randomUUID } from "node:crypto"
 import { AsyncLocalStorage } from "node:async_hooks"
 import {
   promises as fs,
@@ -51,6 +51,8 @@ const MAX_TRACKED_MESSAGE_IDS = 20_000
 const DEFAULT_LEDGER_MAX_BYTES = 2 * 1024 * 1024
 const DEFAULT_LEDGER_RETENTION_FILES = 3
 const MAX_LEDGER_LINE_BYTES = 16 * 1024
+const MIGRATION_LEASE_RETRIES = 200
+const MIGRATION_LEASE_DELAY_MS = 25
 
 const DEFAULT_OPTIONS = {
   maxTurns: 10,
@@ -74,7 +76,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(),
@@ -93,9 +95,8 @@ function createRuntimeState() {
     sessionExecutionContexts: new Map(),
     readOnlyCommandGuards: new Set(),
     ledgerSink: null,
-    persistenceLease: null,
-    migrationLease: null,
-    drainPersistence: null,
+    sessionPersistence: new Map(),
+    sessionLoadPromises: new Map(),
     disposed: false,
   }
 }
@@ -129,7 +130,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")
@@ -147,6 +148,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": {
@@ -211,8 +215,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()
@@ -681,12 +685,6 @@ function listSessionGoals(sessionID) {
   return map ? [...map.values()] : []
 }
 
-function totalLiveGoals() {
-  let total = 0
-  for (const goals of sessionGoals.values()) total += goals.size
-  return total
-}
-
 function rememberMessageID(goal, messageID) {
   goal.messageIDs.add(messageID)
   while (goal.messageIDs.size > MAX_MESSAGE_IDS_PER_GOAL) {
@@ -727,7 +725,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).
@@ -743,7 +741,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
 }
@@ -786,6 +784,29 @@ function clearRuntimeState() {
   runtime.readOnlyCommandGuards.clear()
 }
 
+function clearSessionRuntimeState(sessionID) {
+  const runtime = currentRuntime()
+  for (const goal of sessionGoals.get(sessionID)?.values() || []) {
+    for (const messageID of goal.messageIDs || []) {
+      seenTokens.delete(messageID)
+      seenUsage.delete(messageID)
+      seenOutputTokens.delete(messageID)
+    }
+  }
+  runtime.continuationControllers.get(sessionID)?.abort()
+  goalStates.delete(sessionID)
+  sessionGoals.delete(sessionID)
+  sessionArchive.delete(sessionID)
+  sessionOrdered.delete(sessionID)
+  lastGoalResults.delete(sessionID)
+  activeContinues.delete(sessionID)
+  runtime.continuationControllers.delete(sessionID)
+  runtime.promptInFlightSessions.delete(sessionID)
+  runtime.sessionStatuses.delete(sessionID)
+  runtime.sessionExecutionContexts.delete(sessionID)
+  runtime.readOnlyCommandGuards.delete(sessionID)
+}
+
 function pruneGoalResults(options) {
   const retentionMs = options?.resultRetentionMs ?? DEFAULT_OPTIONS.resultRetentionMs
   const maxStoredResults = options?.maxStoredResults ?? DEFAULT_OPTIONS.maxStoredResults
@@ -994,6 +1015,26 @@ function ledgerPathFor(stateFilePath) {
   return `${stateFilePath}.ledger.jsonl`
 }
 
+// Persist each OpenCode session in its own directory. Session IDs are hashed so
+// arbitrary host-provided IDs cannot become path components, and the resulting
+// paths are portable across POSIX and Windows filesystems.
+function sessionDirectoryFor(stateFilePath) {
+  return `${stateFilePath}.sessions`
+}
+
+function sessionKey(sessionID) {
+  return createHash("sha256").update(sessionID).digest("hex")
+}
+
+function sessionPathsFor(persistenceOptions, sessionID) {
+  const directory = join(persistenceOptions.sessionDirectory, sessionKey(sessionID))
+  const stateFilePath = join(directory, "state.json")
+  return {
+    stateFilePath,
+    ledgerFilePath: ledgerPathFor(stateFilePath),
+  }
+}
+
 // XDG-style state path: $XDG_STATE_HOME/opencode-goal-plugin/state.json,
 // defaulting to ~/.local/state when XDG_STATE_HOME is unset.
 function xdgStateFilePath(env = process.env) {
@@ -1044,11 +1085,14 @@ function normalizePersistenceOptions(options = {}, { env = process.env, cwd } =
       : ledgerPathFor(stateFilePath)
   const ledgerMaxBytes = toPositiveInteger(options.ledgerMaxBytes, DEFAULT_LEDGER_MAX_BYTES)
   const ledgerRetentionFiles = Number.isSafeInteger(options.ledgerRetentionFiles) && options.ledgerRetentionFiles >= 0
-    ? Math.min(options.ledgerRetentionFiles, 10)
-    : DEFAULT_LEDGER_RETENTION_FILES
+      ? Math.min(options.ledgerRetentionFiles, 10)
+      : DEFAULT_LEDGER_RETENTION_FILES
+  const sessionDirectory = sessionDirectoryFor(stateFilePath)
   return {
     persistState,
     stateFilePath,
+    sessionDirectory,
+    migrationMarkerPath: join(sessionDirectory, ".migration-v1-complete"),
     fallbackPaths,
     ledgerFilePath,
     ledgerMaxBytes,
@@ -1280,7 +1324,7 @@ function deserializeGoal(goal) {
 // Parse one state-file body and apply it to runtime state. Returns "loaded" on
 // success or "invalid" when the version/shape is unsupported. Throws on
 // JSON.parse failure (handled by the caller).
-async function applyParsedStateFile(raw, client) {
+async function applyParsedStateFile(raw, client, onlySessionID = null) {
   const parsed = JSON.parse(raw)
   if (parsed?.version !== STATE_FILE_VERSION) {
     await logPluginError(
@@ -1300,6 +1344,7 @@ async function applyParsedStateFile(raw, client) {
   const loadedGoalCounts = new Map()
   for (const rawGoal of parsed.goals.slice(0, MAX_PERSISTED_ENTRIES)) {
     const normalizedGoal = normalizePersistedGoal(rawGoal)
+    if (onlySessionID && normalizedGoal?.sessionID !== onlySessionID) continue
     const sessionCount = normalizedGoal
       ? loadedGoalCounts.get(normalizedGoal.sessionID) || 0
       : 0
@@ -1315,6 +1360,7 @@ async function applyParsedStateFile(raw, client) {
   let skippedResults = 0
   for (const rawResult of parsed.results.slice(-MAX_PERSISTED_ENTRIES)) {
     const normalizedResult = normalizePersistedResult(rawResult)
+    if (onlySessionID && normalizedResult?.sessionID !== onlySessionID) continue
     if (normalizedResult) {
       loadedResults.push(normalizedResult)
     } else {
@@ -1329,7 +1375,8 @@ async function applyParsedStateFile(raw, client) {
     )
   }
 
-  clearRuntimeState()
+  if (onlySessionID) clearSessionRuntimeState(onlySessionID)
+  else clearRuntimeState()
 
   const focusBySession = new Map()
   for (const { goal, focused } of loadedGoals) {
@@ -1342,6 +1389,7 @@ async function applyParsedStateFile(raw, client) {
   // Restore focus. Older single-goal state files have no `focused` flag, so
   // fall back to focusing a session's first (typically only) goal.
   for (const [sessionID, goalMap] of sessionGoals.entries()) {
+    if (onlySessionID && sessionID !== onlySessionID) continue
     const focusTarget = focusBySession.get(sessionID) || goalMap.values().next().value
     if (focusTarget) focusGoal(sessionID, focusTarget)
   }
@@ -1353,6 +1401,7 @@ async function applyParsedStateFile(raw, client) {
   if (Array.isArray(parsed.archives)) {
     for (const entry of parsed.archives.slice(-MAX_PERSISTED_ENTRIES)) {
       if (!isPlainObject(entry) || typeof entry.sessionID !== "string" || !entry.sessionID) continue
+      if (onlySessionID && entry.sessionID !== onlySessionID) continue
       const results = Array.isArray(entry.results)
         ? entry.results.map(normalizePersistedResult).filter(Boolean)
         : []
@@ -1364,6 +1413,7 @@ async function applyParsedStateFile(raw, client) {
 
   if (Array.isArray(parsed.orderedSessions)) {
     for (const sessionID of parsed.orderedSessions) {
+      if (onlySessionID && sessionID !== onlySessionID) continue
       // Only honor the ordered flag for sessions that still have goals loaded.
       if (typeof sessionID === "string" && sessionGoals.has(sessionID)) {
         sessionOrdered.add(sessionID)
@@ -1378,7 +1428,7 @@ async function applyParsedStateFile(raw, client) {
 // 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) {
+async function reconcileLoadedStateWithLedger(persistenceOptions, client, onlySessionID = null) {
   const entries = await readLedgerEntries(persistenceOptions.ledgerFilePath, {
     maxBytes: persistenceOptions.ledgerMaxBytes,
     retentionFiles: persistenceOptions.ledgerRetentionFiles,
@@ -1392,6 +1442,7 @@ async function reconcileLoadedStateWithLedger(persistenceOptions, client) {
       typeof entry.sessionID === "string" && entry.sessionID &&
       typeof entry.goalId === "string" && entry.goalId
     ) {
+      if (onlySessionID && entry.sessionID !== onlySessionID) continue
       terminalGoals.add(`${entry.sessionID}\0${entry.goalId}`)
     }
   }
@@ -1399,6 +1450,7 @@ async function reconcileLoadedStateWithLedger(persistenceOptions, client) {
 
   let removed = 0
   for (const [sessionID, goals] of sessionGoals.entries()) {
+    if (onlySessionID && sessionID !== onlySessionID) continue
     for (const goal of [...goals.values()]) {
       if (!terminalGoals.has(`${sessionID}\0${goal.goalId}`)) continue
       removeSessionGoal(sessionID, goal.goalId)
@@ -1417,114 +1469,250 @@ async function reconcileLoadedStateWithLedger(persistenceOptions, client) {
   }
 }
 
-async function loadPersistedState(persistenceOptions, client) {
-  if (!persistenceOptions.persistState) return "disabled"
+async function pathExists(path) {
+  try {
+    await fs.lstat(path)
+    return true
+  } catch (error) {
+    if (error?.code === "ENOENT") return false
+    throw error
+  }
+}
 
-  const candidates = [
-    { path: persistenceOptions.stateFilePath, primary: true },
-    ...(persistenceOptions.fallbackPaths || []).map((path) => ({ path, primary: false })),
-  ]
-  const recoverInvalidPrimary = async () => {
-    const status = await reconstructFromLedger(persistenceOptions, client)
-    if (status !== "reconstructed") return "invalid"
-    const quarantinePath = `${persistenceOptions.stateFilePath}.corrupt.${Date.now()}.${randomUUID()}`
+async function acquireMigrationLease(stateFilePath, migrationMarkerPath) {
+  let lastError
+  for (let attempt = 0; attempt < MIGRATION_LEASE_RETRIES; attempt += 1) {
+    if (await pathExists(migrationMarkerPath)) return null
     try {
-      await fs.rename(persistenceOptions.stateFilePath, quarantinePath)
+      return await acquirePersistenceLease(stateFilePath)
+    } catch (error) {
+      if (!String(error?.message || error).includes("goal persistence is already owned")) throw error
+      lastError = error
+      await new Promise((resolve) => setTimeout(resolve, MIGRATION_LEASE_DELAY_MS))
+    }
+  }
+  throw lastError || new Error("could not acquire goal migration lease")
+}
+
+async function readPersistedStateFile(path, client) {
+  let raw
+  try {
+    const info = await fs.lstat(path)
+    if (info.isSymbolicLink() || !info.isFile() || info.size > MAX_STATE_FILE_BYTES) {
       await logPluginError(
         client,
-        `Preserved invalid persisted goal state at ${quarantinePath} before ledger recovery.`,
+        `Skipped persisted goal state: file is not regular or exceeds ${MAX_STATE_FILE_BYTES} bytes.`,
       )
-    } catch (error) {
-      await logPluginError(client, "Could not quarantine invalid persisted goal state", error)
-      return "invalid"
+      return { status: "invalid" }
     }
-    return status
+    raw = await fs.readFile(path, "utf8")
+  } catch (error) {
+    if (error?.code === "ENOENT") return { status: "missing" }
+    await logPluginError(client, "Failed to load persisted goal state", error)
+    return { status: "invalid" }
   }
 
-  for (const { path, primary } of candidates) {
-    let migrationLease = null
-    if (!primary) {
-      try {
-        migrationLease = await acquirePersistenceLease(path)
-        currentRuntime().migrationLease = migrationLease
-      } catch (error) {
-        await logPluginError(client, `Skipped legacy state migration because another process owns ${path}.`, error)
-        continue
-      }
+  try {
+    const parsed = JSON.parse(raw)
+    if (parsed?.version !== STATE_FILE_VERSION || !Array.isArray(parsed.goals) || !Array.isArray(parsed.results)) {
+      await logPluginError(client, `Skipped persisted goal state: unsupported or malformed state at ${path}.`)
+      return { status: "invalid" }
     }
-    let raw
+  } catch (error) {
+    await logPluginError(client, "Failed to parse persisted goal state", error)
+    return { status: "invalid" }
+  }
+  return { status: "loaded", raw }
+}
+
+function migrationCandidates(persistenceOptions) {
+  return [
+    {
+      stateFilePath: persistenceOptions.stateFilePath,
+      ledgerFilePath: persistenceOptions.ledgerFilePath,
+    },
+    ...(persistenceOptions.fallbackPaths || []).map((stateFilePath) => ({
+      stateFilePath,
+      ledgerFilePath: ledgerPathFor(stateFilePath),
+    })),
+  ]
+}
+
+function sessionStatePayload(sessionID, parsedState, ledgerEntries = []) {
+  const goals = []
+  const results = []
+  const archives = []
+  const orderedSessions = []
+
+  for (const rawGoal of parsedState?.goals || []) {
+    const goal = normalizePersistedGoal(rawGoal)
+    if (!goal || goal.sessionID !== sessionID) continue
+    goals.push({ ...serializeGoal(goal), focused: rawGoal?.focused === true })
+  }
+
+  for (const rawResult of parsedState?.results || []) {
+    const result = normalizePersistedResult(rawResult)
+    if (result?.sessionID === sessionID) results.push(result)
+  }
+
+  for (const rawArchive of parsedState?.archives || []) {
+    if (!isPlainObject(rawArchive) || rawArchive.sessionID !== sessionID) continue
+    const archiveResults = Array.isArray(rawArchive.results)
+      ? rawArchive.results.map(normalizePersistedResult).filter((result) => result?.sessionID === sessionID)
+      : []
+    if (archiveResults.length) archives.push({ sessionID, results: archiveResults.slice(-MAX_ARCHIVED_PER_SESSION) })
+  }
+
+  if (parsedState?.orderedSessions?.includes(sessionID)) orderedSessions.push(sessionID)
+
+  const sessionLedger = ledgerEntries.filter((entry) => entry?.sessionID === sessionID)
+  const knownGoalIDs = new Set(goals.map((goal) => goal.goalId))
+  for (const reconstructed of reconstructGoalsFromLedger(sessionLedger)) {
+    const goal = normalizePersistedGoal(reconstructed)
+    if (!goal || knownGoalIDs.has(goal.goalId)) continue
+    goals.push({ ...serializeGoal(goal), focused: true })
+    knownGoalIDs.add(goal.goalId)
+    if (reconstructed.ordered === true && !orderedSessions.includes(sessionID)) orderedSessions.push(sessionID)
+  }
+
+  return {
+    version: STATE_FILE_VERSION,
+    goals: goals.slice(-MAX_PERSISTED_ENTRIES),
+    results: results.slice(-MAX_PERSISTED_ENTRIES),
+    archives,
+    orderedSessions,
+  }
+}
+
+async function writeStateSnapshot(stateFilePath, payload) {
+  const tmpPath = `${stateFilePath}.${process.pid}.${randomUUID()}.tmp`
+  try {
+    await fs.mkdir(dirname(stateFilePath), { recursive: true, mode: 0o700 })
+    await fs.writeFile(tmpPath, JSON.stringify(payload, null, 2), { encoding: "utf8", mode: 0o600 })
+    await fs.rename(tmpPath, stateFilePath)
+    await fs.chmod(stateFilePath, 0o600)
+    return true
+  } catch (error) {
+    await fs.rm(tmpPath, { force: true }).catch(() => {})
+    throw error
+  }
+}
+
+async function writeMigrationMarker(path) {
+  await writeStateSnapshot(path, { version: 1, migratedAt: Date.now() })
+}
+
+async function migrateLegacyState(persistenceOptions, client) {
+  if (await pathExists(persistenceOptions.migrationMarkerPath)) return
+
+  for (const candidate of migrationCandidates(persistenceOptions)) {
+    const sourceHasState = await pathExists(candidate.stateFilePath)
+    const sourceHasLedger = await pathExists(candidate.ledgerFilePath)
+    if (!sourceHasState && !sourceHasLedger) continue
+
+    const migrationLease = await acquireMigrationLease(
+      candidate.stateFilePath,
+      persistenceOptions.migrationMarkerPath,
+    )
+    if (!migrationLease) return
     try {
-      const info = await fs.lstat(path)
-      if (info.isSymbolicLink() || !info.isFile() || info.size > MAX_STATE_FILE_BYTES) {
-        await logPluginError(
-          client,
-          `Skipped persisted goal state: file is not regular or exceeds ${MAX_STATE_FILE_BYTES} bytes.`,
-        )
-        if (primary) return recoverInvalidPrimary()
-        await migrationLease?.release()
-        continue
+      if (await pathExists(persistenceOptions.migrationMarkerPath)) return
+
+      const state = await readPersistedStateFile(candidate.stateFilePath, client)
+      const ledgerEntries = await readLedgerEntries(candidate.ledgerFilePath, {
+        maxBytes: persistenceOptions.ledgerMaxBytes,
+        retentionFiles: persistenceOptions.ledgerRetentionFiles,
+      })
+      if (state.status === "invalid" && ledgerEntries.length === 0) return
+      if (state.status === "missing" && ledgerEntries.length === 0) return
+
+      const parsedState = state.status === "loaded" ? JSON.parse(state.raw) : null
+      const sessionIDs = new Set(ledgerEntries.map((entry) => entry?.sessionID).filter(Boolean))
+      for (const rawGoal of parsedState?.goals || []) if (rawGoal?.sessionID) sessionIDs.add(rawGoal.sessionID)
+      for (const rawResult of parsedState?.results || []) if (rawResult?.sessionID) sessionIDs.add(rawResult.sessionID)
+      for (const rawArchive of parsedState?.archives || []) if (rawArchive?.sessionID) sessionIDs.add(rawArchive.sessionID)
+      for (const orderedSession of parsedState?.orderedSessions || []) if (orderedSession) sessionIDs.add(orderedSession)
+
+      for (const sessionID of [...sessionIDs].sort()) {
+        const targetPaths = sessionPathsFor(persistenceOptions, sessionID)
+        if (await pathExists(targetPaths.stateFilePath)) continue
+
+        const payload = sessionStatePayload(sessionID, parsedState, ledgerEntries)
+        const sessionLedger = ledgerEntries.filter((entry) => entry?.sessionID === sessionID)
+        if (sessionLedger.length && !(await pathExists(targetPaths.ledgerFilePath))) {
+          for (const entry of sessionLedger) {
+            if (!appendLedgerLine(targetPaths.ledgerFilePath, entry, {
+              maxBytes: persistenceOptions.ledgerMaxBytes,
+              retentionFiles: persistenceOptions.ledgerRetentionFiles,
+            })) {
+              throw new Error(`could not migrate the goal ledger for session ${sessionID}`)
+            }
+          }
+        }
+        await writeStateSnapshot(targetPaths.stateFilePath, payload)
       }
-      raw = await fs.readFile(path, "utf8")
-    } catch (error) {
-      if (error?.code === "ENOENT") {
-        await migrationLease?.release()
-        continue
+
+      await writeMigrationMarker(persistenceOptions.migrationMarkerPath)
+      for (const sourcePath of [candidate.stateFilePath, candidate.ledgerFilePath]) {
+        if (!(await pathExists(sourcePath))) continue
+        const backupPath = `${sourcePath}.migrated.${Date.now()}.${randomUUID()}`
+        try {
+          await fs.rename(sourcePath, backupPath)
+        } catch (error) {
+          await logPluginError(client, `Could not retire migrated goal persistence at ${sourcePath}.`, error)
+        }
       }
-      // A present-but-unreadable primary file should not be silently
-      // overwritten, so report it as invalid rather than missing.
-      await logPluginError(client, "Failed to load persisted goal state", error)
-      if (primary) return "invalid"
-      await migrationLease?.release()
-      continue
+      return
+    } finally {
+      await migrationLease.release()
     }
+  }
 
-    let status
+  // A fresh project has no aggregate or legacy state. Mark the namespace so a
+  // later session does not repeatedly probe global fallback paths.
+  await writeMigrationMarker(persistenceOptions.migrationMarkerPath)
+}
+
+async function loadPersistedSessionState(persistence, client, sessionID) {
+  const state = await readPersistedStateFile(persistence.stateFilePath, client)
+  if (state.status === "loaded") {
+    await applyParsedStateFile(state.raw, client, sessionID)
+    await reconcileLoadedStateWithLedger(persistence, client, sessionID)
+    return "loaded"
+  }
+  const recovered = await reconstructFromLedger(persistence, client, sessionID)
+  if (state.status === "invalid" && recovered === "reconstructed") {
+    const quarantinePath = `${persistence.stateFilePath}.corrupt.${Date.now()}.${randomUUID()}`
     try {
-      status = await applyParsedStateFile(raw, client)
+      await fs.rename(persistence.stateFilePath, quarantinePath)
+      await logPluginError(
+        client,
+        `Preserved invalid persisted goal state at ${quarantinePath} before ledger recovery.`,
+      )
     } catch (error) {
-      await logPluginError(client, "Failed to load persisted goal state", error)
-      if (primary) return recoverInvalidPrimary()
-      await migrationLease?.release()
-      continue
-    }
-
-    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)
-      if (primary) return "loaded"
-      persistenceOptions.migrationClaim = { path, lease: migrationLease }
-      currentRuntime().migrationLease = migrationLease
-      return "migrated"
+      await logPluginError(client, "Could not quarantine invalid persisted goal state", error)
     }
-    // status === "invalid": preserve a present-but-corrupt primary; for a
-    // fallback, keep trying the next candidate.
-    if (primary) return recoverInvalidPrimary()
-    await migrationLease?.release()
   }
-
-  // No state file found at any candidate path → try reconstructing from the
-  // append-only ledger before giving up.
-  return reconstructFromLedger(persistenceOptions, client)
+  return recovered
 }
 
 // Last-resort recovery: when the main state file is absent, rebuild still-active
 // goals from the append-only ledger so a lost/rotated state file does not drop
 // in-flight goals. Recovered goals are paused (via deserializeGoal).
-async function reconstructFromLedger(persistenceOptions, client) {
+async function reconstructFromLedger(persistenceOptions, client, onlySessionID = null) {
   const entries = await readLedgerEntries(persistenceOptions.ledgerFilePath, {
     maxBytes: persistenceOptions.ledgerMaxBytes,
     retentionFiles: persistenceOptions.ledgerRetentionFiles,
   })
   if (!entries.length) return "missing"
 
-  const reconstructed = reconstructGoalsFromLedger(entries)
+  const reconstructed = reconstructGoalsFromLedger(entries).filter(
+    (goal) => !onlySessionID || goal.sessionID === onlySessionID,
+  )
   if (!reconstructed.length) return "missing"
 
-  clearRuntimeState()
+  if (onlySessionID) clearSessionRuntimeState(onlySessionID)
+  else clearRuntimeState()
   const focusCandidates = new Map()
   for (const stub of reconstructed) {
     const normalized = normalizePersistedGoal(stub)
@@ -1536,6 +1724,7 @@ async function reconstructFromLedger(persistenceOptions, client) {
     }
   }
   for (const [sessionID, goals] of sessionGoals.entries()) {
+    if (onlySessionID && sessionID !== onlySessionID) continue
     const preferred = focusCandidates.get(sessionID)
     const focused = (preferred && goals.get(preferred)) || goals.values().next().value
     if (focused) focusGoal(sessionID, focused)
@@ -1547,55 +1736,46 @@ async function reconstructFromLedger(persistenceOptions, client) {
   return goalStates.size > 0 ? "reconstructed" : "missing"
 }
 
-async function persistState(persistenceOptions, client) {
-  if (!persistenceOptions.persistState) return true
-
-  const tmpPath = `${persistenceOptions.stateFilePath}.${process.pid}.${randomUUID()}.tmp`
-  try {
-    await fs.mkdir(dirname(persistenceOptions.stateFilePath), { recursive: true, mode: 0o700 })
-    await fs.writeFile(
-      tmpPath,
-      JSON.stringify(
-        {
-          version: STATE_FILE_VERSION,
-          // All live goals across sessions, each flagged whether it is the
-          // session's focused goal so focus survives a restart.
-          goals: [...sessionGoals.values()]
-            .flatMap((map) => [...map.values()])
-            .slice(-MAX_PERSISTED_ENTRIES)
-            .map((goal) => ({
-              ...serializeGoal(goal),
-              focused: goalStates.get(goal.sessionID)?.goalId === goal.goalId,
-            })),
-          results: [...lastGoalResults.entries()].slice(-MAX_PERSISTED_ENTRIES).map(([sessionID, result]) => ({
+function currentSessionStatePayload(sessionID) {
+  return {
+    version: STATE_FILE_VERSION,
+    goals: (listSessionGoals(sessionID) || [])
+      .slice(-MAX_LIVE_GOALS_PER_SESSION)
+      .map((goal) => ({
+        ...serializeGoal(goal),
+        focused: goalStates.get(sessionID)?.goalId === goal.goalId,
+      })),
+    results: lastGoalResults.has(sessionID)
+      ? [{
+          ...lastGoalResults.get(sessionID),
+          sessionID,
+          history: [...(lastGoalResults.get(sessionID).history || [])],
+          checkpoints: [...(lastGoalResults.get(sessionID).checkpoints || [])],
+          lastCheckpoint: lastGoalResults.get(sessionID).lastCheckpoint || null,
+        }]
+      : [],
+    archives: sessionArchive.has(sessionID)
+      ? [{
+          sessionID,
+          results: sessionArchive.get(sessionID).map((result) => ({
             ...result,
             sessionID,
             history: [...(result.history || [])],
             checkpoints: [...(result.checkpoints || [])],
             lastCheckpoint: result.lastCheckpoint || null,
           })),
-          archives: [...sessionArchive.entries()].slice(-MAX_PERSISTED_ENTRIES).map(([sessionID, results]) => ({
-            sessionID,
-            results: results.map((result) => ({
-              ...result,
-              sessionID,
-              history: [...(result.history || [])],
-              checkpoints: [...(result.checkpoints || [])],
-              lastCheckpoint: result.lastCheckpoint || null,
-            })),
-          })),
-          orderedSessions: [...sessionOrdered].slice(-MAX_PERSISTED_ENTRIES),
-        },
-        null,
-        2,
-      ),
-      { encoding: "utf8", mode: 0o600 },
-    )
-    await fs.rename(tmpPath, persistenceOptions.stateFilePath)
-    await fs.chmod(persistenceOptions.stateFilePath, 0o600)
+        }]
+      : [],
+    orderedSessions: sessionOrdered.has(sessionID) ? [sessionID] : [],
+  }
+}
+
+async function persistState(persistence, client, sessionID) {
+  if (!persistence.persistState) return true
+  try {
+    await writeStateSnapshot(persistence.stateFilePath, currentSessionStatePayload(sessionID))
     return true
   } catch (error) {
-    await fs.rm(tmpPath, { force: true }).catch(() => {})
     await logPluginError(client, "Failed to persist goal state", error)
     return false
   }
@@ -2339,10 +2519,6 @@ function buildAgentToolHandlers({ defaultGoalOptions, persist, persistTerminalSt
       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 ")}).`
-    if (!goalStates.has(sessionID) && totalLiveGoals() >= MAX_PERSISTED_ENTRIES) {
-      return `The plugin already tracks ${MAX_PERSISTED_ENTRIES} live goals; clear or complete one before creating another.`
-    }
-
     const options = normalizeOptions({
       ...defaultGoalOptions,
       ...(Number.isFinite(args.maxTurns) ? { maxTurns: args.maxTurns } : {}),
@@ -2368,7 +2544,7 @@ function buildAgentToolHandlers({ defaultGoalOptions, persist, persistTerminalSt
     lastGoalResults.delete(sessionID)
     registerSessionGoal(goal)
     focusGoal(sessionID, goal)
-    await persist()
+    await persist(sessionID)
     // 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
@@ -2450,7 +2626,7 @@ function buildAgentToolHandlers({ defaultGoalOptions, persist, persistTerminalSt
             goal.stopReason = "audit rejected"
             goal.lastStatus = `Completion audit rejected: ${summarizeText(reason, 200)}. Address it, then run /${commandName} resume.`
             pushHistory(goal, "audit-rejected", `Agent tool completion audit rejected: ${summarizeText(reason, 300)}`)
-            await persist()
+            await persist(sessionID)
             return `Completion audit rejected: ${summarizeText(reason, 200)}. Goal paused; use /${commandName} resume after addressing the issue.`
           }
         }
@@ -2463,9 +2639,9 @@ 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)
+        const durable = await persistFinal(sessionID, "completion", ledgerDurable)
         if (durable === false) {
           restoreAfterTerminalPersistenceFailure(sessionID, goal, { ordered })
           return "Completion verified, but terminal state could not be persisted. Goal remains paused."
@@ -2509,7 +2685,7 @@ function buildAgentToolHandlers({ defaultGoalOptions, persist, persistTerminalSt
     if (!messages.length) {
       return "Nothing to update. Provide `objective` and/or `status`."
     }
-    await persist()
+    await persist(sessionID)
     return messages.join(" ")
   }
 
@@ -2525,7 +2701,7 @@ function buildAgentToolHandlers({ defaultGoalOptions, persist, persistTerminalSt
     sessionGoals.delete(sessionID)
     cleanupGoal(sessionID)
     lastGoalResults.delete(sessionID)
-    await persistFinal("clear")
+    await persistFinal(sessionID, "clear")
     return "Goal cleared."
   }
 
@@ -2550,11 +2726,12 @@ async function loadOpencodePluginModule() {
   return opencodePluginModulePromise
 }
 
-function buildAgentTools(toolHelper, handlers) {
+function buildAgentTools(toolHelper, handlers, ensureSessionLoaded = async () => true) {
   const schema = toolHelper.schema
   const run = (handler) => async (args, ctx) => {
     const sessionID = agentToolSessionID(ctx)
     if (!sessionID) return "No session id available for the goal tool."
+    await ensureSessionLoaded(sessionID)
     return handler(sessionID, args || {})
   }
   // Canonical tools use a small, versioned machine-readable envelope. Keep the
@@ -2568,6 +2745,7 @@ function buildAgentTools(toolHelper, handlers) {
         goalToolFailure("missing_session", "No session id available for the goal tool."),
       )
     }
+    await ensureSessionLoaded(sessionID)
     return serializeGoalToolResult(operation, await handler(sessionID, args || {}))
   }
 
@@ -2707,7 +2885,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"}` : ""
@@ -2899,30 +3077,67 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
     env: pluginOptions.env,
     cwd: pluginOptions.cwd || directory,
   })
-  if (persistenceOptions.persistState) {
-    await assertSafeProjectPersistencePath(persistenceOptions)
-    currentRuntime().persistenceLease = await acquirePersistenceLease(persistenceOptions.stateFilePath)
-  }
   const { commandName, registerCommand } = normalizeCommandOptions(pluginOptions)
-  // 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 = () => {
-    if (runtime.disposed) return Promise.resolve(false)
-    persistChain = persistChain
+
+  // Each session owns an independent snapshot, ledger, write chain, and
+  // lifetime lease. A project can therefore host any number of unrelated goal
+  // sessions without allowing two processes to drive the same session.
+  const persist = (sessionID) => {
+    const persistence = runtime.sessionPersistence.get(sessionID)
+    if (runtime.disposed || !persistence) return Promise.resolve(false)
+    persistence.persistChain = persistence.persistChain
       .catch(() => false)
-      .then(() => persistState(persistenceOptions, client))
-    return persistChain
+      .then(() => persistState(persistence, client, sessionID))
+    return persistence.persistChain
+  }
+
+  const ensureSessionLoaded = async (sessionID) => {
+    if (!persistenceOptions.persistState || !sessionID) return true
+    const existingLoad = runtime.sessionLoadPromises.get(sessionID)
+    if (existingLoad) return existingLoad
+    if (runtime.sessionPersistence.has(sessionID)) return true
+
+    const load = (async () => {
+      const paths = sessionPathsFor(persistenceOptions, sessionID)
+      await assertSafeProjectPersistencePath({
+        ...persistenceOptions,
+        stateFilePath: paths.stateFilePath,
+      })
+      const lease = await acquirePersistenceLease(paths.stateFilePath)
+      const persistence = {
+        ...persistenceOptions,
+        ...paths,
+        persistChain: Promise.resolve(true),
+        lease,
+      }
+      runtime.sessionPersistence.set(sessionID, persistence)
+      try {
+        await migrateLegacyState(persistenceOptions, client)
+        const status = await loadPersistedSessionState(persistence, client, sessionID)
+        pruneGoalResults(defaultGoalOptions)
+        if (status === "loaded" || status === "missing" || status === "reconstructed") await persist(sessionID)
+        return true
+      } catch (error) {
+        runtime.sessionPersistence.delete(sessionID)
+        await lease.release().catch(() => false)
+        throw error
+      }
+    })()
+
+    runtime.sessionLoadPromises.set(sessionID, load)
+    try {
+      return await load
+    } finally {
+      runtime.sessionLoadPromises.delete(sessionID)
+    }
   }
-  runtime.drainPersistence = () => persistChain.catch(() => false)
 
   // Fail closed when persisting a terminal state (complete/blocked)
   // fails, surface it loudly. The terminal event is already in the append-only
   // ledger, so it stays recoverable across a restart even though the main state
   // file write did not land.
-  const persistTerminalState = async (label, ledgerDurable = false) => {
-    const stateDurable = await persist()
+  const persistTerminalState = async (sessionID, label, ledgerDurable = false) => {
+    const stateDurable = await persist(sessionID)
     if (!stateDurable && persistenceOptions.persistState) {
       await logPluginError(
         client,
@@ -2936,10 +3151,14 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
 
   // Route lifecycle events to the JSONL ledger only when persistence is on.
   if (persistenceOptions.persistState) {
-    setLedgerSink((entry) => appendLedgerLine(persistenceOptions.ledgerFilePath, entry, {
-      maxBytes: persistenceOptions.ledgerMaxBytes,
-      retentionFiles: persistenceOptions.ledgerRetentionFiles,
-    }))
+    setLedgerSink((entry) => {
+      const persistence = runtime.sessionPersistence.get(entry.sessionID)
+      if (!persistence) return false
+      return appendLedgerLine(persistence.ledgerFilePath, entry, {
+        maxBytes: persistence.ledgerMaxBytes,
+        retentionFiles: persistence.ledgerRetentionFiles,
+      })
+    })
   } else {
     setLedgerSink(null)
   }
@@ -2982,34 +3201,14 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
         : null
 
   clearRuntimeState()
-  const persistedStateStatus = await loadPersistedState(persistenceOptions, client)
-  pruneGoalResults(defaultGoalOptions)
-  // "migrated" = loaded from a legacy/XDG fallback path; "reconstructed" =
-  // rebuilt from the ledger. Both persist forward to the resolved path.
-  if (
-    persistedStateStatus === "loaded" ||
-    persistedStateStatus === "missing" ||
-    persistedStateStatus === "migrated" ||
-    persistedStateStatus === "reconstructed"
-  ) {
-    const initialPersisted = await persist()
-    if (persistedStateStatus === "migrated" && persistenceOptions.migrationClaim) {
-      const { path, lease } = persistenceOptions.migrationClaim
-      if (initialPersisted) {
-        const backupPath = `${path}.migrated.${Date.now()}.${randomUUID()}`
-        try {
-          await fs.rename(path, backupPath)
-        } catch (error) {
-          await logPluginError(client, `Could not retire migrated legacy goal state at ${path}.`, error)
-        }
-      }
-      await lease.release()
-      runtime.migrationLease = null
-      persistenceOptions.migrationClaim = null
-    }
-  }
 
-  const agentToolHandlers = buildAgentToolHandlers({ defaultGoalOptions, persist, persistTerminalState, completionAuditor, commandName })
+  const agentToolHandlers = buildAgentToolHandlers({
+    defaultGoalOptions,
+    persist,
+    persistTerminalState,
+    completionAuditor,
+    commandName,
+  })
 
   const abortAcceptedContinuation = async (sessionID) => {
     const runtimeState = currentRuntime()
@@ -3040,7 +3239,7 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
     goal.continuationClaim = null
     pushHistory(goal, "paused", history)
     activeContinues.delete(sessionID)
-    await persist()
+    await persist(sessionID)
     if (abortAccepted) await abortAcceptedContinuation(sessionID)
     return true
   }
@@ -3110,7 +3309,7 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
     }
 
     goal.continuationClaim = { runId: runID, sourceAssistantMessageID }
-    const claimPersisted = await persist()
+    const claimPersisted = await persist(sessionID)
     if (!claimPersisted && persistenceOptions.persistState) {
       goal.continuationClaim = null
       goal.stopped = true
@@ -3132,6 +3331,7 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
     },
     "chat.params": async (input) => {
       if (!input?.sessionID) return
+      await ensureSessionLoaded(input.sessionID)
       const context = normalizeExecutionContext({
         agent: input.agent,
         model: input.model,
@@ -3142,6 +3342,7 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
     "chat.message": async (input, output) => {
       const sessionID = input?.sessionID
       if (!sessionID) return
+      await ensureSessionLoaded(sessionID)
       const context = normalizeExecutionContext(input)
       if (context) currentRuntime().sessionExecutionContexts.set(sessionID, context)
 
@@ -3162,7 +3363,9 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
     },
     "tool.execute.before": async (input) => {
       const sessionID = input?.sessionID
-      if (!sessionID || !currentRuntime().readOnlyCommandGuards.has(sessionID)) return
+      if (!sessionID) return
+      await ensureSessionLoaded(sessionID)
+      if (!currentRuntime().readOnlyCommandGuards.has(sessionID)) return
       if (READ_ONLY_COMMAND_TOOLS.has(input?.tool)) return
       throw new Error(
         `This /${commandName} control command is read-only for the routed model turn. Tool "${input?.tool || "unknown"}" was blocked. Wait for a separate user turn; do not modify work or goal state now.`,
@@ -3181,6 +3384,7 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
       }
       const args = input.arguments.trim()
       const sessionID = input.sessionID
+      await ensureSessionLoaded(sessionID)
       currentRuntime().readOnlyCommandGuards.delete(sessionID)
       pruneGoalResults(defaultGoalOptions)
 
@@ -3243,7 +3447,7 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
         sessionGoals.delete(sessionID)
         cleanupGoal(sessionID)
         lastGoalResults.delete(sessionID)
-        await persist()
+        await persist(sessionID)
         output.parts = [makeTextPart("Goal cleared.")]
         return
       }
@@ -3262,7 +3466,7 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
         goal.continuationClaim = null
         activeContinues.delete(sessionID)
         pushHistory(goal, "paused", "User paused the active goal.")
-        await persist()
+        await persist(sessionID)
         await abortAcceptedContinuation(sessionID)
         output.parts = [makeTextPart(`Goal paused: ${goal.condition}`)]
         return
@@ -3288,7 +3492,7 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
         goal.blockedReason = ""
         goal.lastStatus = "Goal resumed with a fresh local budget."
         pushHistory(goal, "resumed", "User resumed the goal with a fresh local budget window.")
-        await persist()
+        await persist(sessionID)
         output.parts = [makeTextPart(`Goal resumed with fresh limits: ${goal.condition}`)]
         return
       }
@@ -3328,7 +3532,7 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
         goal.continuationClaim = null
         goal.lastStatus = "Goal objective updated."
         pushHistory(goal, "edited", `Objective updated to: ${summarizeText(newObjective, 400)}`)
-        await persist()
+        await persist(sessionID)
         output.parts = [
           makeTextPart(
             [
@@ -3347,8 +3551,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()))
@@ -3356,7 +3563,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
@@ -3365,11 +3572,6 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
           output.parts = [makeTextPart(`An ordered sequence may contain at most ${MAX_LIVE_GOALS_PER_SESSION} goals.`)]
           return
         }
-        const existingCount = listSessionGoals(sessionID).length
-        if (totalLiveGoals() - existingCount + objectives.length > MAX_PERSISTED_ENTRIES) {
-          output.parts = [makeTextPart(`The plugin may track at most ${MAX_PERSISTED_ENTRIES} live goals across sessions.`)]
-          return
-        }
         if (objectives.some((objective) => objective.length > MAX_GOAL_OBJECTIVE_LENGTH)) {
           output.parts = [makeTextPart(`Each goal objective must be ${MAX_GOAL_OBJECTIVE_LENGTH} characters or fewer.`)]
           return
@@ -3400,17 +3602,17 @@ 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)
         })
         focusGoal(sessionID, firstGoal)
         sessionOrdered.add(sessionID)
-        await persist()
+        await persist(sessionID)
         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}`,
@@ -3465,7 +3667,7 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
         resumeGoalClock(target)
         pushHistory(target, "focused", "Brought into focus as the session's active goal.")
         focusGoal(sessionID, target)
-        await persist()
+        await persist(sessionID)
         output.parts = [
           makeTextPart(
             [
@@ -3505,10 +3707,6 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
           output.parts = [makeTextPart(`A session may contain at most ${MAX_LIVE_GOALS_PER_SESSION} live goals.`)]
           return
         }
-        if (totalLiveGoals() >= MAX_PERSISTED_ENTRIES) {
-          output.parts = [makeTextPart(`The plugin may track at most ${MAX_PERSISTED_ENTRIES} live goals across sessions.`)]
-          return
-        }
         // Keep the current goal (background it) and focus a new one.
         const current = goalStates.get(sessionID)
         if (current) {
@@ -3525,7 +3723,7 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
         )
         registerSessionGoal(added)
         focusGoal(sessionID, added)
-        await persist()
+        await persist(sessionID)
         const total = listSessionGoals(sessionID).length
         output.parts = [
           makeTextPart(
@@ -3545,10 +3743,6 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
       }
 
       const replacedGoal = goalStates.get(sessionID)
-      if (!replacedGoal && totalLiveGoals() >= MAX_PERSISTED_ENTRIES) {
-        output.parts = [makeTextPart(`The plugin may track at most ${MAX_PERSISTED_ENTRIES} live goals across sessions.`)]
-        return
-      }
       const goal = buildGoalState(sessionID, parsed.condition, parsed.options, parsed.meta)
 
       pushHistory(
@@ -3560,14 +3754,14 @@ 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)
       lastGoalResults.delete(sessionID)
       registerSessionGoal(goal)
       focusGoal(sessionID, goal)
-      await persist()
+      await persist(sessionID)
       output.parts = [
         makeTextPart(
           [
@@ -3599,6 +3793,9 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
     },
 
     event: async ({ event }) => {
+      const eventSessionID = getSessionID(event) || messageSessionID(messageInfoFromEvent(event))
+      if (eventSessionID) await ensureSessionLoaded(eventSessionID)
+
       if (event?.type === "session.status") {
         const sessionID = getSessionID(event)
         const status = event?.properties?.status?.type || event?.data?.status?.type
@@ -3635,7 +3832,7 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
         if (!goal) return
         goal.messageIDs = new Set()
         goal.totalTokens = 0
-        await persist()
+        await persist(sessionID)
         return
       }
 
@@ -3694,7 +3891,7 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
           changed = true
         }
 
-        if (changed) await persist()
+        if (changed) await persist(messageSessionID(message))
         return
       }
 
@@ -3829,7 +4026,7 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
                 auditedGoal.stopReason = "audit rejected"
                 auditedGoal.lastStatus = `Completion audit rejected: ${summarizeText(reason, 200)}. Address it, then run /${commandName} resume.`
                 pushHistory(auditedGoal, "audit-rejected", `Completion audit rejected: ${summarizeText(reason, 300)}`)
-                await persist()
+                await persist(sessionID)
                 await announceAudit(sessionID, `Audit result: completion rejected — ${summarizeText(reason, 160)}.`)
                 return
               }
@@ -3852,12 +4049,12 @@ 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)
             }
-            const durable = await persistTerminalState("completion", ledgerDurable)
+            const durable = await persistTerminalState(sessionID, "completion", ledgerDurable)
             if (durable === false) {
               restoreAfterTerminalPersistenceFailure(sessionID, activeGoalAfterMessages, { ordered })
               await announceAudit(
@@ -3891,7 +4088,7 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
             blockedGoal.stopped = true
             blockedGoal.stopReason = "blocked"
             const ledgerDurable = pushHistory(blockedGoal, "blocked", reason)
-            const durable = await persistTerminalState("blocked", ledgerDurable)
+            const durable = await persistTerminalState(sessionID, "blocked", ledgerDurable)
             if (durable === false) {
               blockedGoal.stopReason = "terminal persistence failed"
               blockedGoal.lastStatus = "Blocked state could not be persisted; goal remains paused."
@@ -3931,7 +4128,7 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
             claimedGoal.stopReason = limitReason
             claimedGoal.lastStatus = `${limitReason}; requested final handoff.`
             pushHistory(claimedGoal, "limit", `${limitReason}; requested a final handoff.`)
-            await persist()
+            await persist(sessionID)
             currentRuntime().promptInFlightSessions.add(sessionID)
             let response
             try {
@@ -3952,7 +4149,7 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
             activeGoalAfterMessages.lastStatus = limitReason
             pushHistory(activeGoalAfterMessages, "limit", limitReason)
           }
-          await persist()
+          await persist(sessionID)
           return
         }
 
@@ -4007,7 +4204,7 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
               "paused",
               `Paused after ${activeGoalAfterMessages.noProgressTurns} low-progress turn(s) below ${activeGoalAfterMessages.options.noProgressTokenThreshold} output tokens.`,
             )
-            await persist()
+            await persist(sessionID)
             return
           }
 
@@ -4052,7 +4249,7 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
               "paused",
               `Paused after ${activeGoalAfterMessages.noToolCallTurns} continuation turn(s) that produced no tool calls.`,
             )
-            await persist()
+            await persist(sessionID)
             return
           }
 
@@ -4101,7 +4298,7 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
           // 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()
+          await persist(sessionID)
         }
 
         activeGoalBeforePrompt.turnCount += 1
@@ -4141,7 +4338,7 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
               "paused",
               `Paused after ${activeGoalBeforePrompt.formatFailures} consecutive format-validation failure(s).`,
             )
-            await persist()
+            await persist(sessionID)
             return
           }
         }
@@ -4202,7 +4399,7 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
             )
           }
         }
-        await persist()
+        await persist(sessionID)
       } catch (error) {
         const activeGoalAfterError = currentGoal(sessionID, goalID, runID)
         if (activeGoalAfterError) {
@@ -4222,7 +4419,7 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
             activeGoalAfterError.stopReason = "auto-continue failures"
             activeGoalAfterError.lastStatus = `${message}; paused after ${activeGoalAfterError.promptFailures} failure(s). Run /${commandName} resume to retry.`
           }
-          await persist()
+          await persist(sessionID)
         }
         await logPluginError(client, "Auto-continue failed", error)
       } finally {
@@ -4239,6 +4436,7 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
 
     "experimental.chat.system.transform": async (input, output) => {
       if (!input.sessionID) return
+      await ensureSessionLoaded(input.sessionID)
 
       const goal = goalStates.get(input.sessionID)
       if (!goal) return
@@ -4288,6 +4486,7 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
 
     "experimental.session.compacting": async (input, output) => {
       if (!input?.sessionID || !output) return
+      await ensureSessionLoaded(input.sessionID)
       const goal = goalStates.get(input.sessionID)
       if (!goal) return
       const context = buildCompactionContext(goal)
@@ -4307,6 +4506,7 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
       // auto-continue to avoid two continuations racing after a compaction.
       // Paused/stopped goals leave the native behavior untouched.
       if (!input?.sessionID || !output) return
+      await ensureSessionLoaded(input.sessionID)
       const goal = goalStates.get(input.sessionID)
       if (!goal || goal.stopped) return
       output.enabled = false
@@ -4328,7 +4528,7 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
     const toolModule = await loadOpencodePluginModule()
     if (toolModule?.tool?.schema) {
       try {
-        hooks.tool = buildAgentTools(toolModule.tool, agentToolHandlers)
+        hooks.tool = buildAgentTools(toolModule.tool, agentToolHandlers, ensureSessionLoaded)
       } catch (error) {
         await logPluginError(client, "Failed to register goal agent tools", error)
       }
@@ -4370,13 +4570,17 @@ function bindHooksToRuntime(hooks, runtime) {
     if (runtime.disposed) return
     runtime.disposed = true
     for (const controller of runtime.continuationControllers.values()) controller.abort()
-    await runtime.drainPersistence?.()
+    await Promise.allSettled([...runtime.sessionLoadPromises.values()])
+    for (const persistence of runtime.sessionPersistence.values()) {
+      await persistence.persistChain.catch(() => false)
+    }
     clearRuntimeState()
     setLedgerSink(null)
-    await runtime.persistenceLease?.release()
-    runtime.persistenceLease = null
-    await runtime.migrationLease?.release()
-    runtime.migrationLease = null
+    for (const persistence of runtime.sessionPersistence.values()) {
+      await persistence.lease?.release().catch(() => false)
+    }
+    runtime.sessionPersistence.clear()
+    runtime.sessionLoadPromises.clear()
   })
   return bound
 }
@@ -4390,11 +4594,13 @@ export const GoalPlugin = async (context = {}, pluginOptions = {}) => {
       return bindHooksToRuntime(hooks, runtime)
     } catch (error) {
       runtime.disposed = true
-      await runtime.drainPersistence?.()
-      await runtime.persistenceLease?.release().catch(() => false)
-      runtime.persistenceLease = null
-      await runtime.migrationLease?.release().catch(() => false)
-      runtime.migrationLease = null
+      await Promise.allSettled([...runtime.sessionLoadPromises.values()])
+      for (const persistence of runtime.sessionPersistence.values()) {
+        await persistence.persistChain.catch(() => false)
+        await persistence.lease?.release().catch(() => false)
+      }
+      runtime.sessionPersistence.clear()
+      runtime.sessionLoadPromises.clear()
       throw error
     }
   })
@@ -4451,6 +4657,7 @@ export const testInternals = {
   normalizeMessageUsage,
   normalizeUsage,
   normalizePersistenceOptions,
+  sessionPathsFor,
   userInterventionDetected,
   outputTokensForMessage,
   parseGoalArguments,