@bybrawe/opencode-loop 0.5.37 → 0.6.0

package/scripts/v2-plugin-sentinel-test.mjs

@@ -3,7 +3,7 @@ import plugin, {
   OPENCODE_LOOP_V2_COMMANDS,
   OPENCODE_LOOP_V2_PLUGIN_ID,
 } from "../src/source/opencode2/experimental.js"
-import { parseOpenCode2LoopCommandText } from "../src/source/opencode2/commands.js"
+import { parseOpenCode2LoopCommandText, registerOpenCode2LoopCommands } from "../src/source/opencode2/commands.js"
 import {
   OPENCODE_LOOP_V2_COMMAND_SOURCE,
   OPENCODE_LOOP_V2_HOST_REQUIREMENTS,
@@ -77,13 +77,43 @@ for (const [name, definition] of Object.entries(OPENCODE_LOOP_V2_COMMANDS)) {
   assert.equal(command?.description, definition.description)
 }
 
-let missingDraftUpdateFailed = false
+let missingDraftMutationFailed = false
 try {
   await registered({})
 } catch (error) {
-  missingDraftUpdateFailed = /command draft\.update capability is unavailable/.test(String(error))
+  missingDraftMutationFailed = /neither add\(\) nor update\(\)/.test(String(error))
 }
-assert.equal(missingDraftUpdateFailed, true)
+assert.equal(missingDraftMutationFailed, true)
+
+const addedCommands = new Map()
+const executedCommands = []
+registerOpenCode2LoopCommands({
+  add(definition) {
+    addedCommands.set(definition.name, definition)
+  },
+}, {
+  execute: async (event) => {
+    executedCommands.push(structuredClone(event))
+  },
+})
+assert.deepEqual([...addedCommands.keys()], Object.keys(OPENCODE_LOOP_V2_COMMANDS))
+for (const [name, definition] of Object.entries(OPENCODE_LOOP_V2_COMMANDS)) {
+  const command = addedCommands.get(name)
+  assert.equal(command?.name, name)
+  assert.equal(command?.description, definition.description)
+  assert.equal(typeof command?.execute, "function")
+}
+await addedCommands.get("loop").execute({
+  sessionID: "ses_2_0_11",
+  prompt: { text: "devam et" },
+  delivery: "steer",
+})
+assert.deepEqual(executedCommands, [{
+  name: "loop",
+  sessionID: "ses_2_0_11",
+  arguments: "devam et",
+  delivery: "steer",
+}])
 
 assert.deepEqual(inspectOpenCode2Context(currentContext), {
   commandTransform: true,
@@ -98,6 +128,7 @@ assert.deepEqual(inspectOpenCode2Context(currentContext), {
 assert.deepEqual(inspectOpenCode2CommandDraft(currentDraft), {
   list: true,
   get: true,
+  add: false,
   update: true,
   remove: true,
 })

package/scripts/v2-runtime-adapter-test.mjs

@@ -164,6 +164,8 @@ async function verifyTwoTurnLoop({ directory, sessionID, events, prompts, native
     sessionID: "ses_v2",
     noReply: true,
     parts: [{ type: "text", text: "OpenCode loop status:\nNo active loop jobs." }],
+    text: "OpenCode loop status:\nNo active loop jobs.",
+    resume: false,
     agent: "build",
     model: { providerID: "canary", modelID: "canary" },
   })
@@ -301,6 +303,79 @@ async function verifyTwoTurnLoop({ directory, sessionID, events, prompts, native
   }
 }
 
+{
+  const directory = await mkdtemp(path.join(os.tmpdir(), "opencode-loop-v2-2-0-11-command-add-"))
+  const sessionID = "ses_v2_2_0_11_add"
+  const events = controllableStream()
+  const prompts = []
+  const commands = new Map()
+  const ctx = {
+    app: { name: "opencode", version: "2.0.11", channel: "latest" },
+    location: { directory },
+    command: {
+      transform: async (callback) => {
+        await callback({
+          add(definition) {
+            commands.set(definition.name, definition)
+          },
+        })
+        return { dispose: async () => {} }
+      },
+    },
+    event: {
+      // OpenCode 2.0.11 exposes subscribe(options), so Function.length === 1
+      // even though it returns an AsyncIterable rather than accepting a callback.
+      subscribe(options) {
+        assert.equal(options, undefined)
+        return events.stream
+      },
+    },
+    session: {
+      prompt: async (input) => {
+        prompts.push(structuredClone(input))
+        return { accepted: true }
+      },
+    },
+  }
+
+  const cleanup = await OpenCodeLoopV2ExperimentalPlugin.setup(ctx)
+  try {
+    assert.ok(commands.has("loop"), "OpenCode 2.0.11 add() command editor must receive /loop")
+    await commands.get("loop").execute({
+      sessionID,
+      prompt: { text: "0s --max-runs 2 continue exact 2.0.11 command path" },
+      delivery: "steer",
+    })
+
+    const stateFile = path.join(directory, ".opencode", "opencode-loop", `${sessionID}.json`)
+    await waitFor(async () => {
+      try { return JSON.parse(await readFile(stateFile, "utf8")).jobs?.length === 1 } catch { return false }
+    }, "OpenCode 2.0.11 direct command state creation")
+
+    await waitFor(() => prompts.length === 1, "OpenCode 2.0.11 direct command first local-kick dispatch")
+    assert.equal(prompts[0].sessionID, sessionID)
+    assert.match(prompts[0].text || "", /continue exact 2\.0\.11 command path/)
+
+    events.push({
+      type: "session.status",
+      location: { directory },
+      data: { sessionID, status: { type: "busy" } },
+    })
+    events.push({
+      type: "session.status",
+      location: { directory },
+      data: { sessionID, status: { type: "idle" } },
+    })
+    await waitFor(() => prompts.length === 2, "OpenCode 2.0.11 second dispatch from native idle status")
+    const state = JSON.parse(await readFile(stateFile, "utf8"))
+    assert.equal(state.jobs[0].runCount, 2)
+    assert.equal(state.jobs[0].enabled, false)
+  } finally {
+    await cleanup?.()
+    await rm(directory, { recursive: true, force: true })
+  }
+}
+
 {
   let commandDisposals = 0
   const result = await OpenCodeLoopV2ExperimentalPlugin.setup({

package/src/index.js

@@ -619,7 +619,9 @@ async function runProcess(command, args, cwd, timeoutMs = 60000) {
     const child = spawn(command, args, { cwd, shell: false, windowsHide: true });
     const stdout = [];
     const stderr = [];
+    let timedOut = false;
     const timer = setTimeout(() => {
+      timedOut = true;
       try {
         child.kill("SIGTERM");
       } catch {}
@@ -632,7 +634,7 @@ async function runProcess(command, args, cwd, timeoutMs = 60000) {
     });
     child.on("close", (code) => {
       clearTimeout(timer);
-      resolve({ code: code ?? 0, stdout: Buffer.concat(stdout).toString("utf8"), stderr: Buffer.concat(stderr).toString("utf8") });
+      resolve({ code: timedOut ? 124 : code ?? -1, stdout: Buffer.concat(stdout).toString("utf8"), stderr: Buffer.concat(stderr).toString("utf8") });
     });
   });
 }
@@ -641,7 +643,9 @@ async function runShellCommand(command, cwd, timeoutMs = 120000) {
     const child = spawn(command, [], { cwd, shell: true, windowsHide: true });
     const stdout = [];
     const stderr = [];
+    let timedOut = false;
     const timer = setTimeout(() => {
+      timedOut = true;
       try {
         child.kill("SIGTERM");
       } catch {}
@@ -654,7 +658,7 @@ async function runShellCommand(command, cwd, timeoutMs = 120000) {
     });
     child.on("close", (code) => {
       clearTimeout(timer);
-      resolve({ code: code ?? 0, stdout: Buffer.concat(stdout).toString("utf8"), stderr: Buffer.concat(stderr).toString("utf8") });
+      resolve({ code: timedOut ? 124 : code ?? -1, stdout: Buffer.concat(stdout).toString("utf8"), stderr: Buffer.concat(stderr).toString("utf8") });
     });
   });
 }
@@ -819,6 +823,8 @@ async function activeRunCompletionFromMessages(directory, client, sessionID, act
   if (!messages)
     return "unknown";
   const ordered = orderedSessionMessages(messages);
+  if (ordered.length === 0)
+    return "unknown";
   const tail = ordered.at(-1);
   const info = tail?.info || tail;
   if (!info || info.role !== "assistant")
@@ -1086,6 +1092,19 @@ var NEXT_WORK_PATTERNS = [
   /\bremaining (?:work|task|todo|step)/i,
   /devam (?:edece\u011Fim|ediyorum|etmek gerek)(?=\s|[.,;:!\u2014-]|$)/i
 ];
+var WAITING_USER_PATTERNS = [
+  /(?:^|\n)\s*onay bekleyenler\s*:/i,
+  /(?:^|\n)\s*(?:kullan\u0131c\u0131|user) (?:onay\u0131|onayi|aksiyonu|i\u015Flemi|islemi|eri\u015Fimi|erisimi) (?:bekleniyor|gerekiyor|gerekli)\b/i,
+  /\b(?:senin|sizin) (?:onay\u0131n|onay\u0131n\u0131z|onayiniz|aksiyonun|aksiyonunuz|eri\u015Fimin|erisimin) (?:bekleniyor|gerekiyor|gerekli)\b/i,
+  /\b(?:onay|eri\u015Fim|erisim|yetki) olmadan (?:devam edemem|ilerleyemem|i\u015Flem yapamam|islem yapamam)\b/i,
+  /(?:^|\n)\s*(?:waiting (?:for|on) (?:your|user) (?:approval|input|action|access|credentials?)|(?:approval|user action|access) (?:required|pending))\s*:?/i,
+  /\b(?:requires?|needs?) (?:your|user) (?:approval|input|action|access|credentials?)\b/i,
+  /\bblocked (?:pending|until|on) (?:your|user|approval|access|credentials?)\b/i
+];
+var WAITING_USER_NEGATIONS = [
+  /\b(?:onay|eri\u015Fim|erisim|yetki) (?:gerekmiyor|gerekli de\u011Fil|gerekli degil|beklenmiyor)\b/i,
+  /\bno (?:user )?(?:approval|input|action|access|credentials?) (?:is )?(?:needed|required|pending)\b/i
+];
 function isContinuationShorthand(value) {
   return CONTINUATION_SHORTHANDS.has(String(value || "").trim().toLowerCase().replace(/\s+/g, " "));
 }
@@ -1093,6 +1112,16 @@ function isCompletionBoundedContinuation(value) {
   const text = String(value || "").trim();
   return COMPLETION_BOUNDED_PATTERNS.some((pattern) => pattern.test(text));
 }
+function isWaitingUserReply(value) {
+  const text = String(value || "").trim();
+  if (!text)
+    return false;
+  if (WAITING_USER_NEGATIONS.some((pattern) => pattern.test(text)))
+    return false;
+  if (NEXT_WORK_PATTERNS.some((pattern) => pattern.test(text)))
+    return false;
+  return WAITING_USER_PATTERNS.some((pattern) => pattern.test(text));
+}
 function isTerminalNoWorkReply(value) {
   const text = String(value || "").trim();
   if (!text || NEXT_WORK_PATTERNS.some((pattern) => pattern.test(text)))
@@ -1215,6 +1244,20 @@ function goalStatusText(job) {
     return "paused";
   return status;
 }
+function applyTestfixPreset(job, defaults = {}) {
+  if (defaults.testfixPreset) {
+    const defaultCommand = String(defaults.verifyCommand || "npm test");
+    const parsedAction = String(job.action || "").trim();
+    const usedDefaultAction = parsedAction === String(defaults.action || "").trim();
+    if (!usedDefaultAction && job.verifyCommand === defaults.verifyCommand) {
+      job.verifyCommand = parsedAction;
+      job.action = `Run the project tests. Fix failures. Re-run the tests. Test command hint: ${parsedAction}`;
+    } else if (usedDefaultAction && job.verifyCommand !== defaults.verifyCommand) {
+      job.action = `Run the project tests. Fix failures. Re-run the tests. Test command hint: ${job.verifyCommand || defaultCommand}`;
+    }
+  }
+  return job;
+}
 
 // src/source/opencode/command-router.js
 var HANDLER_NAMES = [
@@ -1716,6 +1759,34 @@ function createGoalCommandHandlers(options = {}) {
 import { promises as fs6 } from "fs";
 import path7 from "path";
 
+// src/source/core/progress.js
+var DEFAULT_PROGRESS_MD = `# Progress
+
+## Current Goal
+Describe the current project goal here.
+
+## Agent Rules
+- Do not ask questions unless truly blocked.
+- Make reasonable assumptions and continue.
+- Work on unfinished TODOs in order.
+- Mark completed TODOs with [x].
+- Add new bugs, ideas, and follow-up work as TODOs.
+- Run tests, lint, or build when available.
+- Do not run destructive commands, force pushes, production deploys, or database resets.
+
+## Active TODO
+- [ ] Review the project structure and pick the next safe improvement.
+
+## Completed
+- [x] Created progress.md.
+
+## Backlog Ideas
+- [ ] Add more project-specific tasks here.
+
+## Blocked
+- None.
+`;
+
 // src/source/runtime/companion-goal.js
 import { promises as fs4 } from "fs";
 import path5 from "path";
@@ -1893,32 +1964,6 @@ async function listPersistedLoopSessions(directory, currentSessionID) {
 
 // src/source/opencode/loop-commands.js
 var SERVICE2 = "opencode-loop";
-var DEFAULT_PROGRESS_MD = `# Progress
-
-## Current Goal
-Describe the current project goal here.
-
-## Agent Rules
-- Do not ask questions unless truly blocked.
-- Make reasonable assumptions and continue.
-- Work on unfinished TODOs in order.
-- Mark completed TODOs with [x].
-- Add new bugs, ideas, and follow-up work as TODOs.
-- Run tests, lint, or build when available.
-- Do not run destructive commands, force pushes, production deploys, or database resets.
-
-## Active TODO
-- [ ] Review the project structure and pick the next safe improvement.
-
-## Completed
-- [x] Created progress.md.
-
-## Backlog Ideas
-- [ ] Add more project-specific tasks here.
-
-## Blocked
-- None.
-`;
 function requireFunction3(value, name) {
   if (typeof value !== "function")
     throw new TypeError(`createLoopCommandHandlers requires ${name}`);
@@ -2218,17 +2263,7 @@ function createLoopRegistration(options = {}) {
     const executionContext = getSessionExecutionContext2(sessionID) || { agent: "build" };
     parsed.job.agent = defaults.agent || executionContext.agent || "build";
     parsed.job.model = normalizedModelRef2(defaults.model) || executionContext.model;
-    if (defaults.testfixPreset) {
-      const defaultCommand = String(defaults.verifyCommand || "npm test");
-      const parsedAction = String(parsed.job.action || "").trim();
-      const usedDefaultAction = parsedAction === String(defaults.action || "").trim();
-      if (!usedDefaultAction && parsed.job.verifyCommand === defaults.verifyCommand) {
-        parsed.job.verifyCommand = parsedAction;
-        parsed.job.action = `Run the project tests. Fix failures. Re-run the tests. Test command hint: ${parsedAction}`;
-      } else if (usedDefaultAction && parsed.job.verifyCommand !== defaults.verifyCommand) {
-        parsed.job.action = `Run the project tests. Fix failures. Re-run the tests. Test command hint: ${parsed.job.verifyCommand || defaultCommand}`;
-      }
-    }
+    applyTestfixPreset(parsed.job, defaults);
     if (parsed.job.watchPaths.length)
       parsed.job.watchSnapshot = await snapshotPaths(directory, parsed.job.watchPaths);
     if (!parsed.job.activeRecoveryMs) {
@@ -2753,13 +2788,14 @@ ${text.trim().slice(0, 20000)}`);
     const branch = safeID(job.branch);
     const inRepo = await runProcess2("git", ["rev-parse", "--is-inside-work-tree"], directory, 1e4);
     if (inRepo.code !== 0) {
-      job.branchDone = true;
+      job.branchDone = false;
+      job.branchUnavailable = true;
       return job;
     }
     let result = await runProcess2("git", ["switch", branch], directory, 30000);
     if (result.code !== 0)
       result = await runProcess2("git", ["switch", "-c", branch], directory, 30000);
-    job.branchDone = true;
+    job.branchDone = result.code === 0;
     await toast(client, result.code === 0 ? `Loop branch active: ${branch}` : `Could not switch/create branch: ${branch}`, result.code === 0 ? "success" : "warning");
     await appendLoopLog2(directory, "branch", { sessionID, branch, code: result.code });
     return job;
@@ -2799,6 +2835,10 @@ ${text.trim().slice(0, 20000)}`);
   async function untilReached(directory, job) {
     if (!job.until)
       return false;
+    const controlRoots = new Set([
+      stateDir(directory),
+      ...["goals", "goal-locks", "goal-handoff-locks", "goal-sequences"].map((name) => path8.join(directory, ".opencode", name))
+    ].map((root) => path8.resolve(root).toLowerCase()));
     const files = ["progress.md", "PROGRESS.md", "todo.md", "TODO.md", "todolist.md", "TODOLIST.md", path8.join(".opencode", "opencode-loop", "until.txt")];
     for (const file of files)
       if (await fileContains(path8.resolve(directory, file), job.until))
@@ -2819,6 +2859,8 @@ ${text.trim().slice(0, 20000)}`);
         if ([".git", "node_modules", "dist", "build", ".next", "coverage"].includes(entry.name))
           continue;
         const full = path8.join(current, entry.name);
+        if (controlRoots.has(path8.resolve(full).toLowerCase()))
+          continue;
         if (entry.isDirectory()) {
           if (await walk(full))
             return true;
@@ -2971,8 +3013,10 @@ function createSessionStatusRuntime(options = {}) {
   async function canFinalizeActiveRun(directory, client, sessionID, active, options = {}) {
     if (hasActiveToolCalls(sessionID) || hasBusyDescendant(sessionID))
       return false;
-    if (!options.requireIdle && !options.forceStale)
-      return true;
+    if (!options.requireIdle && !options.forceStale) {
+      const completion = await activeRunCompletionFromMessages2(directory, client, sessionID, active);
+      return completion !== "incomplete";
+    }
     const completion = options.forceStale ? await activeRunCompletionFromMessages2(directory, client, sessionID, active) : undefined;
     if (settledAssistantCompletion(completion))
       return true;
@@ -3048,7 +3092,11 @@ function createSessionStatusRuntime(options = {}) {
               ...completion === "completed" ? {} : { staleStatus: live.type }
             };
             const recoveryEvent = completion === "empty" ? "status-message-empty-recovery" : completion === "completed" ? "status-message-complete-recovery" : "status-stale-recovery";
-            await appendLoopLog2(directory, recoveryEvent, logDetails);
+            active.statusRecoveryLogEvents ??= new Set;
+            if (!active.statusRecoveryLogEvents.has(recoveryEvent)) {
+              active.statusRecoveryLogEvents.add(recoveryEvent);
+              await appendLoopLog2(directory, recoveryEvent, logDetails);
+            }
             return "idle";
           }
         }
@@ -3280,8 +3328,10 @@ function messageText(message) {
   return "";
 }
 async function applyTerminalContinuationGuard(directory, client, sessionID, job, options = {}) {
-  if (job?.scheduleMode !== "idle" || !isCompletionBoundedContinuation(job?.action)) {
-    return { job, terminal: false, pausedNow: false };
+  const completionBounded = isCompletionBoundedContinuation(job?.action);
+  const continuation = completionBounded || isContinuationShorthand(job?.action);
+  if (job?.scheduleMode !== "idle" || !continuation) {
+    return { job, terminal: false, pausedNow: false, waitingUser: false, waitingUserPausedNow: false };
   }
   const messages = await readRecentSessionMessages(client, sessionID, directory, options.messageLimit || 8);
   if (!messages)
@@ -3299,11 +3349,31 @@ async function applyTerminalContinuationGuard(directory, client, sessionID, job,
     return { job, terminal: false, pausedNow: false };
   }
   const text = messageText(tail);
+  const waitingUser = isWaitingUserReply(text);
+  if (waitingUser) {
+    if (job.terminalNoWorkCount)
+      job.terminalNoWorkCount = 0;
+    job.waitingUserCount = (job.waitingUserCount || 0) + 1;
+    job.lastWaitingUserAt = Date.now();
+    job.lastWaitingUserSummary = text.slice(0, 1000);
+    const threshold = Math.max(2, Number(options.waitingUserThreshold) || 2);
+    const waitingUserPausedNow = job.waitingUserCount >= threshold && !job.paused;
+    if (waitingUserPausedNow) {
+      job.paused = true;
+      job.lastFailureReason = "waiting_user";
+    }
+    return { job, terminal: false, pausedNow: false, waitingUser: true, waitingUserPausedNow, text };
+  }
+  if (job.waitingUserCount)
+    job.waitingUserCount = 0;
+  if (!completionBounded) {
+    return { job, terminal: false, pausedNow: false, waitingUser: false, waitingUserPausedNow: false, text };
+  }
   const terminal = isTerminalNoWorkReply(text);
   if (!terminal) {
     if (job.terminalNoWorkCount)
       job.terminalNoWorkCount = 0;
-    return { job, terminal: false, pausedNow: false, text };
+    return { job, terminal: false, pausedNow: false, waitingUser: false, waitingUserPausedNow: false, text };
   }
   job.terminalNoWorkCount = (job.terminalNoWorkCount || 0) + 1;
   job.lastTerminalNoWorkAt = Date.now();
@@ -3314,7 +3384,7 @@ async function applyTerminalContinuationGuard(directory, client, sessionID, job,
     job.paused = true;
     job.lastFailureReason = "terminal_no_work";
   }
-  return { job, terminal: true, pausedNow, text };
+  return { job, terminal: true, pausedNow, waitingUser: false, waitingUserPausedNow: false, text };
 }
 
 // src/source/runtime/run-finalization.js
@@ -3408,6 +3478,16 @@ exit=` + postrun.code + `
     }
     const terminal = await applyTerminalContinuationGuard2(directory, client, sessionID, job);
     job = terminal.job;
+    if (terminal.waitingUserPausedNow) {
+      await appendLoopLog2(directory, "waiting-user", {
+        sessionID,
+        job: job.name || job.id,
+        count: job.waitingUserCount,
+        summary: String(terminal.text || "").slice(0, 1000)
+      });
+      await notifyJob2(directory, job, "waiting_user");
+      await toast2(client, "Loop paused: autonomous continuation is waiting for explicit user approval, access, or action.", "warning");
+    }
     if (terminal.pausedNow) {
       await appendLoopLog2(directory, "terminal-no-work", {
         sessionID,
@@ -3615,6 +3695,25 @@ function requireFunction10(value, label) {
     throw new TypeError(`createLoopExecutor requires ${label}`);
   return value;
 }
+function sessionErrorDetails(event, fallbackMessage) {
+  if (event?.type !== "session.error")
+    return;
+  const sessionID = event?.properties?.sessionID;
+  if (typeof sessionID !== "string" || !sessionID)
+    return;
+  const error = event?.properties?.error;
+  const name = error && typeof error === "object" && typeof error.name === "string" ? error.name : "SessionError";
+  const data = error && typeof error === "object" && error.data && typeof error.data === "object" ? error.data : undefined;
+  const message = typeof data?.message === "string" && data.message.trim() ? data.message.trim() : fallbackMessage(error);
+  return {
+    sessionID,
+    error,
+    name,
+    message,
+    aborted: name === "MessageAbortedError",
+    retryable: name === "APIError" && data?.isRetryable === true
+  };
+}
 function createLoopExecutor(options = {}) {
   const workspace = options.workspace || {};
   const goalPolicy = options.goalPolicy || {};
@@ -3793,6 +3892,56 @@ function createLoopExecutor(options = {}) {
     await scheduleDueWork(directory, client, sessionID, retryDelay);
     return true;
   }
+  async function handleSessionError(directory, client, event) {
+    const details = sessionErrorDetails(event, errorMessage);
+    if (!details || details.aborted)
+      return false;
+    const active = activeRuns.get(details.sessionID);
+    if (!active || active.compactionOnly)
+      return false;
+    const snapshot = active;
+    clearActiveRun(details.sessionID);
+    clearSessionStatus(details.sessionID);
+    if (details.retryable) {
+      const refunded = await persistInfrastructureRefund(directory, details.sessionID, snapshot, {
+        reason: "session_error_retryable",
+        error: details.message
+      });
+      await appendLoopLog2(directory, "provider-session-error-retry", {
+        sessionID: details.sessionID,
+        job: refunded.job?.name || snapshot.jobId,
+        errorName: details.name,
+        error: details.message,
+        retryInMs: refunded.delayMs
+      });
+      await toast2(client, `Loop provider turn failed after OpenCode retries; the logical run was refunded and will retry with backoff: ${details.message}`, "warning");
+      await scheduleDueWork(directory, client, details.sessionID, refunded.delayMs);
+      return true;
+    }
+    const state = await readState2(directory, details.sessionID);
+    const job = (state.jobs || []).find((candidate) => candidate.id === snapshot.jobId);
+    if (job) {
+      job.failureCount = (job.failureCount || 0) + 1;
+      job.paused = true;
+      job.lastFailureReason = "session_error";
+      job.lastSessionErrorName = details.name;
+      job.lastSessionError = details.message.slice(0, 4000);
+      job.lastSessionErrorAt = now2();
+      state.jobs = (state.jobs || []).map((candidate) => candidate.id === job.id ? job : candidate);
+      await writeState2(directory, details.sessionID, state);
+      await notifyJob2(directory, job, "session_error");
+    }
+    await appendLoopLog2(directory, "session-error", {
+      sessionID: details.sessionID,
+      job: job?.name || snapshot.jobId,
+      errorName: details.name,
+      error: details.message,
+      paused: Boolean(job?.paused)
+    });
+    await toast2(client, `Loop paused after a terminal OpenCode session error: ${details.message}`, "error");
+    await scheduleDueWork(directory, client, details.sessionID);
+    return true;
+  }
   async function recoverStuckProviderRetry(directory, client, sessionID) {
     const active = activeRuns.get(sessionID);
     if (!active || active.compactionOnly) {
@@ -4067,6 +4216,7 @@ function createLoopExecutor(options = {}) {
     clearActiveRun,
     disposeSession,
     recoverActiveDispatchFailure,
+    handleSessionError,
     recoverStuckProviderRetry,
     finalizeActiveRun,
     fireAction,
@@ -4139,6 +4289,7 @@ function createGoalSteeringRuntime(options = {}) {
   const now2 = typeof options.now === "function" ? options.now : now;
   const suppressionMs = Number.isFinite(Number(options.suppressionMs)) && Number(options.suppressionMs) > 0 ? Number(options.suppressionMs) : DEFAULT_STEERING_SUPPRESSION_MS;
   const seenUserMessageMs = Number.isFinite(Number(options.seenUserMessageMs)) && Number(options.seenUserMessageMs) > 0 ? Number(options.seenUserMessageMs) : DEFAULT_SEEN_USER_MESSAGE_MS;
+  const compactingSessions = new Set;
   const pendingSteering = new Map;
   const seenUserMessages = new Map;
   function pendingForSession(sessionID) {
@@ -4212,7 +4363,7 @@ function createGoalSteeringRuntime(options = {}) {
       return { handled: false, sessionID, messageID };
     const active = getActiveRun(sessionID);
     const activeGoalIDs = new Set(goals.map((goal) => goal.id));
-    const canPreempt = active && activeGoalIDs.has(active.jobId) && isGoalJob(active.job) && typeof client?.session?.abort === "function";
+    const canPreempt = !compactingSessions.has(sessionID) && active && activeGoalIDs.has(active.jobId) && isGoalJob(active.job) && typeof client?.session?.abort === "function";
     let preempted = false;
     let abortError = "";
     if (canPreempt) {
@@ -4224,7 +4375,8 @@ function createGoalSteeringRuntime(options = {}) {
       });
       try {
         await fireSdk2(client, "session.abort", client.session.abort.bind(client.session), { path: { id: sessionID }, body: {} }, { path: { sessionID }, body: {} }, { sessionID });
-        clearActiveRun(sessionID);
+        if (getActiveRun(sessionID) === active)
+          clearActiveRun(sessionID);
         preempted = true;
       } catch (error) {
         pendingSteering.delete(sessionID);
@@ -4245,9 +4397,20 @@ function createGoalSteeringRuntime(options = {}) {
     const user = userMessageFromEvent(event);
     if (!user)
       return;
-    return await handleUserMessage(directory, client, user);
+    if (alreadyHandled(user.sessionID, user.messageID))
+      return { handled: false, duplicate: true, ...user };
+    return { handled: false, reason: "untrusted-message-event", ...user };
+  }
+  function setCompacting(sessionID, value = true) {
+    if (typeof sessionID !== "string" || !sessionID)
+      return;
+    if (value)
+      compactingSessions.add(sessionID);
+    else
+      compactingSessions.delete(sessionID);
   }
   function clearSession(sessionID) {
+    compactingSessions.delete(sessionID);
     pendingSteering.delete(sessionID);
     const prefix = `${sessionID}\x00`;
     for (const key of seenUserMessages.keys())
@@ -4261,6 +4424,7 @@ function createGoalSteeringRuntime(options = {}) {
     shouldSuppressIdle,
     hasPendingSteering: shouldSuppressIdle,
     pendingForSession,
+    setCompacting,
     clearSession
   };
 }
@@ -4288,6 +4452,7 @@ var executorRuntime = createLoopExecutor({
 });
 var {
   clearActiveRun,
+  handleSessionError,
   finalizeActiveRun,
   maybeRunDueJobs: runDueJobs,
   sessionIsIdle,
@@ -4486,10 +4651,10 @@ var OpenCodeLoopPlugin = async ({ client, directory }) => {
     "command.execute.before": async (input, output) => {
       await handleCommand(directory, client, input, undefined, undefined, output);
     },
-    "chat.message": async (input) => {
+    "chat.message": async (input, output) => {
       const steering = await goalSteeringRuntime.handleUserMessage(directory, client, {
         sessionID: input?.sessionID,
-        messageID: input?.messageID
+        messageID: input?.messageID || output?.message?.id
       });
       if (steering?.handled && steering.sessionID)
         rememberSession(directory, client, steering.sessionID);
@@ -4501,9 +4666,13 @@ var OpenCodeLoopPlugin = async ({ client, directory }) => {
       markToolCallFinished(input);
     },
     "experimental.session.compacting": async (input) => {
+      goalSteeringRuntime.setCompacting(input?.sessionID);
       await noteLoopCompactionStarted(directory, input?.sessionID);
     },
     event: async ({ event }) => {
+      if (["session.compacted", "session.error", "session.deleted"].includes(event?.type)) {
+        goalSteeringRuntime.setCompacting(event?.properties?.sessionID || event?.properties?.info?.id, false);
+      }
       if (event.type === "session.compacted")
         await noteLoopCompactionCompleted(directory, client, event?.properties?.sessionID);
       updateSessionRelationshipFromEvent(event);
@@ -4517,6 +4686,11 @@ var OpenCodeLoopPlugin = async ({ client, directory }) => {
       const steering = await goalSteeringRuntime.handleEvent(directory, client, event);
       if (steering?.handled && steering.sessionID)
         rememberSession(directory, client, steering.sessionID);
+      if (event.type === "session.error") {
+        const handledError = await handleSessionError(directory, client, event);
+        if (handledError && event?.properties?.sessionID)
+          rememberSession(directory, client, event.properties.sessionID);
+      }
       const statusUpdate = updateSessionStatusFromEvent(event);
       if (statusUpdate?.sessionID)
         rememberSession(directory, client, statusUpdate.sessionID);