@bybrawe/opencode-loop 0.5.37 → 0.5.38

package/scripts/session-status-test.mjs

@@ -157,6 +157,36 @@ try {
     completion = "unknown"
   }
 
+  {
+    const sessionID = "concurrent-recovery-log-dedupe"
+    track(sessionID)
+    runtime.clearSessionStatus(sessionID)
+    activeRuns.set(sessionID, { jobId: "job-dedupe", job: { id: "job-dedupe", name: "dedupe" }, startedAt: 1_000 })
+    completion = "completed"
+    let releaseStatus
+    const gate = new Promise((resolve) => { releaseStatus = resolve })
+    let calls = 0
+    const client = {
+      session: {
+        status: async () => {
+          calls += 1
+          await gate
+          return { data: { [sessionID]: { type: "busy" } } }
+        },
+      },
+    }
+    const before = logs.filter((entry) => entry[1] === "status-message-complete-recovery" && entry[2]?.sessionID === sessionID).length
+    const pending = Array.from({ length: 20 }, () => runtime.sessionStatusType(client, sessionID, "/repo"))
+    await Promise.resolve()
+    assert.equal(calls, 20, "all concurrent status reads should be in flight before release")
+    releaseStatus()
+    assert.deepEqual(await Promise.all(pending), Array(20).fill("idle"))
+    const after = logs.filter((entry) => entry[1] === "status-message-complete-recovery" && entry[2]?.sessionID === sessionID).length
+    assert.equal(after - before, 1, "one active run must emit at most one copy of the same stale-recovery diagnostic")
+    activeRuns.delete(sessionID)
+    completion = "unknown"
+  }
+
   {
     const sessionID = "retry-remains-owned"
     track(sessionID)

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

@@ -56,7 +56,13 @@ async function waitFor(predicate, description, timeoutMs = 2_000) {
   await adapter.start()
   const result = await adapter.command({ sessionID: "ses_adapter", command: "/review", arguments: "--quick" })
   assert.deepEqual(result, { accepted: true })
-  assert.deepEqual(commands, [{ sessionID: "ses_adapter", command: "review", arguments: "--quick" }])
+  assert.deepEqual(commands, [{
+    sessionID: "ses_adapter",
+    name: "review",
+    command: "review",
+    arguments: "--quick",
+    text: "--quick",
+  }])
   assert.equal(Object.prototype.hasOwnProperty.call(commands[0], "id"), false)
   await adapter.dispose()
 }
@@ -103,7 +109,13 @@ async function waitFor(predicate, description, timeoutMs = 2_000) {
     })
     events.push({ directory, payload: { type: "session.idle", properties: { sessionID } } })
     await waitFor(() => commands.length === 1, "V2 command dispatch")
-    assert.deepEqual(commands[0], { sessionID, command: "review", arguments: "--quick" })
+    assert.deepEqual(commands[0], {
+      sessionID,
+      name: "review",
+      command: "review",
+      arguments: "--quick",
+      text: "--quick",
+    })
   } finally {
     await cleanup?.()
     await rm(directory, { recursive: true, force: true })

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

@@ -1086,6 +1086,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 +1106,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)))
@@ -3048,7 +3071,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 +3307,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 +3328,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 +3363,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 +3457,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 +3674,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 +3871,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 +4195,7 @@ function createLoopExecutor(options = {}) {
     clearActiveRun,
     disposeSession,
     recoverActiveDispatchFailure,
+    handleSessionError,
     recoverStuckProviderRetry,
     finalizeActiveRun,
     fireAction,
@@ -4288,6 +4417,7 @@ var executorRuntime = createLoopExecutor({
 });
 var {
   clearActiveRun,
+  handleSessionError,
   finalizeActiveRun,
   maybeRunDueJobs: runDueJobs,
   sessionIsIdle,
@@ -4517,6 +4647,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);