@bybrawe/opencode-loop 0.5.37 → 0.6.0

package/scripts/publish-workflow-test.mjs

@@ -2,24 +2,70 @@ import assert from "node:assert/strict"
 import { readFile } from "node:fs/promises"
 import path from "node:path"
 import { fileURLToPath } from "node:url"
+import { validateRelease, releaseDecision, assertPublishedSource, waitForPublishedGoal } from "./native-release.mjs"
 
 const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..")
-const workflowPath = path.join(repoRoot, ".github", "workflows", "publish-npm.yml")
-const workflow = await readFile(workflowPath, "utf8")
-
-assert.match(workflow, /ref:\s*\$\{\{ github\.sha \}\}/, "publish workflow must checkout the release trigger SHA")
-assert.doesNotMatch(workflow, /ref:\s*main\b/, "publish workflow must not checkout a moving main branch")
-assert.match(workflow, /git merge-base --is-ancestor "\$GITHUB_SHA" origin\/main/, "release source must be verified against main history")
-assert.match(workflow, /COMMIT_SHA="\$GITHUB_SHA"/, "release tag must target the immutable trigger SHA")
-assert.match(workflow, /group:\s*npm-release/, "npm publication must be serialized")
-assert.match(workflow, /cancel-in-progress:\s*false/, "a newer release must not cancel an in-flight publication")
+const workflow = await readFile(path.join(repoRoot, ".github/workflows/publish-npm.yml"), "utf8")
+assert.match(workflow, /ref:\s*\$\{\{ github\.sha \}\}/, "checkout must use the immutable trigger SHA")
+assert.doesNotMatch(workflow, /ref:\s*main\b/, "publication cannot checkout moving main")
+assert.match(workflow, /git merge-base --is-ancestor "\$GITHUB_SHA" origin\/main/)
+assert.match(workflow, /COMMIT_SHA="\$GITHUB_SHA"/)
+assert.match(workflow, /group:\s*npm-release/)
+assert.match(workflow, /cancel-in-progress:\s*false/)
+assert.match(workflow, /branches:\s*\[main\]/)
+assert.match(workflow, /paths:\s*\[\.github\/npm-release\.json\]/)
+assert.doesNotMatch(workflow, /release\/npm-v|git push|Remove one-shot release branch/, "main-only publication must not create or delete branches")
+assert.match(workflow, /needs:\s*\[native-regressions, real-native-pair\]/)
+assert.match(workflow, /node scripts\/native-release\.mjs ci/)
+assert.match(workflow, /git diff --exit-code -- src\/index.js src\/server.js src\/native.js/)
+assert.match(workflow, /npm run package:smoke/)
+assert.match(workflow, /windows-latest/)
+assert.match(workflow, /Decide whether npm publish is needed/)
+assert.match(workflow, /steps\.npm-state\.outputs\.publish == 'true'/)
+assert.match(workflow, /for attempt in \{1\.\.60\}/)
+assert.match(workflow, /--registry=https:\/\/registry\.npmjs\.org/)
+assert.match(workflow, /native-release\.mjs verify/)
+assert.match(workflow, /node_modules\/@bybrawe\/opencode-loop\/scripts\/opencode2-loop-canary.mjs/)
+assert.match(workflow, /node_modules\/@bybrawe\/opencode-goal\/dist\/server.js/)
+assert.match(workflow, /ref: \$\{\{ steps.release.outputs.goal_sha \}\}/)
+assert.doesNotMatch(workflow, /secrets\.NPM_TOKEN/)
 
 const publishIndex = workflow.indexOf("npm publish --access public")
 const verifyIndex = workflow.indexOf("Verify published version is readable from npm")
 const tagIndex = workflow.indexOf("Create tag and GitHub release")
-const cleanupIndex = workflow.indexOf("Remove one-shot release branch")
-assert.ok(publishIndex >= 0 && verifyIndex > publishIndex, "npm publication must be verified after publish")
-assert.ok(tagIndex > verifyIndex, "tag/release creation must happen only after npm verification")
-assert.ok(cleanupIndex > tagIndex, "release branch cleanup must be the final release step")
+assert.ok(publishIndex >= 0 && verifyIndex > publishIndex)
+assert.ok(tagIndex > verifyIndex)
+assert.match(workflow.slice(tagIndex), /needs:\s*publish/, "GitHub release must depend on verified publication")
+for (const block of workflow.split(/- uses: actions\/checkout@/).slice(1)) assert.match(block.split(/\n\s*- (?:uses|name|run):/)[0], /persist-credentials:\s*false/)
+const publisher = workflow.slice(workflow.indexOf("  publish:\n"), workflow.indexOf("  github-release:\n"))
+assert.doesNotMatch(publisher, /contents:\s*write/, "OIDC publisher must not gain repository mutation privileges")
+
+const sha = "a".repeat(40)
+const request = { name: "@bybrawe/opencode-loop", version: "0.6.0", predecessor: "0.5.38", goal: { version: "1.3.39", sha: "b".repeat(40) } }
+const pkg = { name: request.name, version: request.version }
+const env = { GITHUB_REPOSITORY: "ByBrawe/opencode-loop", GITHUB_REF: "refs/heads/main", GITHUB_SHA: sha }
+assert.strictEqual(validateRelease(request, pkg, env), request)
+for (const change of [{ GITHUB_REPOSITORY: "someone/fork" }, { GITHUB_REF: "refs/heads/release" }, { GITHUB_SHA: "main" }]) assert.throws(() => validateRelease(request, pkg, { ...env, ...change }))
+assert.throws(() => validateRelease({ ...request, version: "9.0.0" }, pkg, env))
+assert.throws(() => validateRelease(request, { ...pkg, version: "0.5.38" }, env))
+assert.equal(releaseDecision(404, null, request, sha, "0.5.38"), true)
+for (const status of [401, 403, 429, 500, 503]) assert.throws(() => releaseDecision(status, null, request, sha, "0.5.38"))
+assert.throws(() => releaseDecision(404, null, request, sha, "0.7.0"))
+const manifest = { ...pkg, gitHead: sha }
+assert.equal(releaseDecision(200, manifest, request, sha), false)
+assert.throws(() => releaseDecision(200, { ...manifest, gitHead: "b".repeat(40) }, request, sha))
+assert.throws(() => assertPublishedSource({ ...manifest, gitHead: undefined }, pkg.name, pkg.version, sha))
 
-console.log("publish workflow tests passed")
+let calls = 0, sleeps = 0
+const goalManifest = { name: "@bybrawe/opencode-goal", version: request.goal.version, gitHead: request.goal.sha }
+const recovered = await waitForPublishedGoal(request.goal, {
+  attempts: 2, sleep: async () => { sleeps++ },
+  request: async () => ++calls === 1 ? { ok: false, status: 404 } : { ok: true, json: async () => goalManifest },
+})
+assert.deepEqual(recovered, goalManifest)
+assert.equal(calls, 2)
+assert.equal(sleeps, 1)
+await assert.rejects(waitForPublishedGoal(request.goal, { attempts: 1, request: async () => ({ ok: false, status: 404 }) }), /not published/)
+for (const status of [403, 429, 503]) await assert.rejects(waitForPublishedGoal(request.goal, { attempts: 1, request: async () => ({ ok: false, status }) }), /transport\/auth/)
+await assert.rejects(waitForPublishedGoal(request.goal, { attempts: 1, request: async () => ({ ok: true, json: async () => ({ ...goalManifest, gitHead: sha }) }) }), /different source/)
+console.log("main-only publish workflow, source identity and registry failure regressions passed")

package/scripts/pulse-check.mjs

@@ -0,0 +1,246 @@
+import { promises as fs } from "node:fs"
+import path from "node:path"
+import { dedicatedGoalOwnsContinuation } from "../src/source/runtime/companion-goal.js"
+
+const LOCK_STALE_MS = 30_000
+const LOCK_RETRY_MS = 25
+const LOCK_RETRIES = 80
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+export function parsePulseDurationMs(value) {
+  const text = String(value ?? "").trim().toLowerCase()
+  if (text === "0" || text === "0s" || text === "now") return 0
+  const match = text.match(/^(\d+(?:\.\d+)?)\s*(ms|s|sec|secs|m|min|mins|h|hr|hrs|d|day|days)$/)
+  if (!match) throw new Error(`Invalid duration: ${value}`)
+  const amount = Number(match[1])
+  const unit = match[2]
+  if (unit === "ms") return amount
+  if (unit.startsWith("s")) return amount * 1000
+  if (unit.startsWith("m")) return amount * 60_000
+  if (unit.startsWith("h")) return amount * 3_600_000
+  if (unit.startsWith("d")) return amount * 86_400_000
+  return amount
+}
+
+function pulseDirectory(project) {
+  return path.join(project, ".opencode", "opencode-loop")
+}
+
+function pulseStateFile(project) {
+  return path.join(pulseDirectory(project), "pulse-check.json")
+}
+
+function pulseLockDirectory(project) {
+  return path.join(pulseDirectory(project), "pulse-check.lock")
+}
+
+function goalDirectory(project) {
+  return path.join(project, ".opencode", "goals")
+}
+
+function timestamp(value) {
+  const parsed = Number(value)
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : undefined
+}
+
+function revision(value) {
+  const parsed = Number(value)
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : 0
+}
+
+function goalFingerprint(goal) {
+  return [
+    String(goal?.status || "unknown"),
+    timestamp(goal?.updatedAt) ?? 0,
+    revision(goal?.progressRevision),
+    revision(goal?.revision),
+    revision(goal?.storageGeneration),
+  ].join(":")
+}
+
+function formatAge(ms) {
+  if (ms < 60_000) return `${Math.max(0, Math.round(ms / 1000))}s`
+  if (ms < 3_600_000) return `${Math.round(ms / 60_000)}m`
+  if (ms < 86_400_000) return `${(ms / 3_600_000).toFixed(ms < 36_000_000 ? 1 : 0)}h`
+  return `${(ms / 86_400_000).toFixed(ms < 864_000_000 ? 1 : 0)}d`
+}
+
+function iso(value) {
+  const parsed = timestamp(value)
+  if (parsed === undefined) return "unknown"
+  try { return new Date(parsed).toISOString() } catch { return "unknown" }
+}
+
+async function readJson(file, fallback) {
+  try {
+    return JSON.parse(await fs.readFile(file, "utf8"))
+  } catch (error) {
+    if (error?.code === "ENOENT") return fallback
+    throw error
+  }
+}
+
+async function writeJsonAtomic(file, value) {
+  await fs.mkdir(path.dirname(file), { recursive: true })
+  const temporary = `${file}.${process.pid}.${Date.now()}.tmp`
+  await fs.writeFile(temporary, JSON.stringify(value, null, 2) + "\n", "utf8")
+  try {
+    await fs.rename(temporary, file)
+  } catch (error) {
+    try { await fs.rm(temporary, { force: true }) } catch {}
+    throw error
+  }
+}
+
+async function acquireLock(project) {
+  const directory = pulseDirectory(project)
+  const lock = pulseLockDirectory(project)
+  await fs.mkdir(directory, { recursive: true })
+
+  for (let attempt = 0; attempt < LOCK_RETRIES; attempt += 1) {
+    try {
+      await fs.mkdir(lock)
+      return async () => {
+        try { await fs.rm(lock, { recursive: true, force: true }) } catch {}
+      }
+    } catch (error) {
+      if (error?.code !== "EEXIST") throw error
+      try {
+        const stat = await fs.stat(lock)
+        if (Date.now() - stat.mtimeMs > LOCK_STALE_MS) {
+          await fs.rm(lock, { recursive: true, force: true })
+          continue
+        }
+      } catch (statError) {
+        if (statError?.code !== "ENOENT") throw statError
+      }
+      await sleep(LOCK_RETRY_MS)
+    }
+  }
+
+  throw new Error("Goal pulse-check state is busy; another checker still holds the lock")
+}
+
+async function readGoalSnapshots(project, target) {
+  let names
+  try {
+    names = await fs.readdir(goalDirectory(project))
+  } catch (error) {
+    if (error?.code === "ENOENT") return []
+    throw error
+  }
+
+  const goals = []
+  for (const name of names.sort()) {
+    if (!name.endsWith(".json")) continue
+    try {
+      const goal = JSON.parse(await fs.readFile(path.join(goalDirectory(project), name), "utf8"))
+      if (!goal?.id || !goal?.sessionID) continue
+      if (target && goal.id !== target && goal.sessionID !== target) continue
+      goals.push(goal)
+    } catch {}
+  }
+  return goals
+}
+
+export async function checkGoalPulse(project, options = {}) {
+  const staleAfterMs = Number(options.staleAfterMs)
+  if (!Number.isFinite(staleAfterMs) || staleAfterMs < 0) throw new Error("staleAfterMs must be a non-negative number")
+  const now = Number.isFinite(Number(options.now)) ? Number(options.now) : Date.now()
+  const target = options.target ? String(options.target) : undefined
+  const sessionActivity = options.sessionActivity && typeof options.sessionActivity === "object" ? options.sessionActivity : {}
+  const release = await acquireLock(project)
+
+  try {
+    const goals = await readGoalSnapshots(project, target)
+    const stateFile = pulseStateFile(project)
+    const state = await readJson(stateFile, { schemaVersion: 1, goals: {} })
+    if (!state.goals || typeof state.goals !== "object") state.goals = {}
+
+    const alerts = []
+    for (const goal of goals) {
+      const id = String(goal.id)
+      const status = String(goal.status || "unknown")
+      const progressRevision = revision(goal.progressRevision)
+      const goalUpdatedAt = timestamp(goal.updatedAt) ?? now
+      const fingerprint = goalFingerprint(goal)
+      const previous = state.goals[id]
+      const changed = !previous || previous.fingerprint !== fingerprint
+      const statusChanged = Boolean(previous && previous.status !== status)
+      const progressChanged = Boolean(previous && Number(previous.progressRevision || 0) !== progressRevision)
+      const updatedAdvanced = Boolean(previous && goalUpdatedAt > Number(previous.goalUpdatedAt || 0))
+
+      let lastActivityAt
+      if (!previous) {
+        lastActivityAt = goalUpdatedAt
+      } else if (!changed) {
+        lastActivityAt = Number(previous.lastActivityAt || goalUpdatedAt)
+      } else if (updatedAdvanced) {
+        lastActivityAt = goalUpdatedAt
+      } else if (statusChanged || progressChanged || Number(previous.revision || 0) !== revision(goal.revision)) {
+        lastActivityAt = now
+      } else {
+        lastActivityAt = Math.max(Number(previous.lastActivityAt || 0), goalUpdatedAt)
+      }
+
+      let alerted = changed ? false : Boolean(previous?.alerted)
+      let newAlert = false
+      const active = dedicatedGoalOwnsContinuation(goal)
+      const ageMs = Math.max(0, now - lastActivityAt)
+      const sessionUpdatedAt = timestamp(sessionActivity[goal.sessionID])
+
+      if (!active) {
+        alerted = false
+      } else if (ageMs >= staleAfterMs && !alerted) {
+        alerted = true
+        newAlert = true
+        const message = [
+          "[opencode-loopd] GOAL PULSE STALLED",
+          `goal=${id}`,
+          `session=${goal.sessionID}`,
+          `stale=${formatAge(ageMs)}`,
+          `goalUpdated=${iso(goalUpdatedAt)}`,
+          sessionUpdatedAt === undefined ? undefined : `sessionUpdated=${iso(sessionUpdatedAt)}`,
+          'action="/goal resume"',
+        ].filter(Boolean).join(" ")
+        alerts.push({
+          goalID: id,
+          sessionID: String(goal.sessionID),
+          ageMs,
+          goalUpdatedAt,
+          sessionUpdatedAt,
+          progressRevision,
+          message,
+        })
+      } else if (ageMs < staleAfterMs) {
+        alerted = false
+      }
+
+      state.goals[id] = {
+        fingerprint,
+        status,
+        progressRevision,
+        revision: revision(goal.revision),
+        goalUpdatedAt,
+        lastActivityAt,
+        alerted,
+        ...(alerted ? { lastAlertAt: newAlert ? now : previous?.lastAlertAt } : {}),
+        sessionID: String(goal.sessionID),
+      }
+    }
+
+    state.schemaVersion = 1
+    state.updatedAt = now
+    await writeJsonAtomic(stateFile, state)
+    return {
+      alerts,
+      checked: goals.length,
+      stateFile,
+    }
+  } finally {
+    await release()
+  }
+}

package/scripts/run-finalization-test.mjs

@@ -98,6 +98,39 @@ assert.equal(failedPostrun.failureCount, 1)
 assert.equal(failedPostrun.paused, true)
 assert.equal(notifications.at(-1)[2], "postrun_failed")
 
+const waitingNotifications = []
+const waitingLogs = []
+const waitingToasts = []
+const waitingRuntime = createRunFinalizationRuntime({
+  runGoalChecks: async (_directory, _sessionID, job) => job,
+  applyGoalNoProgressGuard: async (_directory, _client, _sessionID, job) => job,
+  createCheckpoint: async () => {},
+  scheduleDueWork: async () => {},
+  writeState: async () => {},
+  appendLoopLog: async (...args) => { waitingLogs.push(args) },
+  notifyJob: async (...args) => { waitingNotifications.push(args) },
+  toast: async (...args) => { waitingToasts.push(args) },
+  applyTerminalContinuationGuard: async (_directory, _client, _sessionID, job) => ({
+    job: {
+      ...job,
+      paused: true,
+      waitingUserCount: 2,
+      lastFailureReason: "waiting_user",
+    },
+    terminal: false,
+    pausedNow: false,
+    waitingUser: true,
+    waitingUserPausedNow: true,
+    text: "Onay bekleyenler: commit + push, canlı migration, cihaz testi.",
+  }),
+})
+const waitingJob = { id: "waiting-user", name: "default", enabled: true, paused: false }
+await waitingRuntime.finalizeJob("/repo", {}, "session-waiting", { jobs: [waitingJob] }, waitingJob, { id: "before-waiting" })
+assert.equal(waitingNotifications.at(-1)[2], "waiting_user")
+assert.equal(waitingLogs.at(-1)[1], "waiting-user")
+assert.match(waitingToasts.at(-1)[1], /waiting for explicit user approval/)
+assert.equal(waitingToasts.at(-1)[2], "warning")
+
 const goal = {
   id: "goal-job",
   kind: "goal",

package/scripts/server-entry-test.mjs

@@ -0,0 +1,15 @@
+import assert from "node:assert/strict"
+import plugin, {
+  OPENCODE_LOOP_PLUGIN_ID,
+  OpenCodeLoopPlugin,
+  OpenCodeLoopV2ExperimentalPlugin,
+} from "../src/source/server.js"
+
+assert.equal(plugin.id, OPENCODE_LOOP_PLUGIN_ID)
+assert.equal(plugin.id, "@bybrawe/opencode-loop")
+assert.equal(typeof plugin.server, "function", "OpenCode 1.x requires default.server()")
+assert.equal(typeof plugin.setup, "function", "OpenCode 2.x requires default.setup()")
+assert.strictEqual(plugin.server, OpenCodeLoopPlugin)
+assert.equal(typeof OpenCodeLoopV2ExperimentalPlugin.setup, "function")
+
+console.log("dual OpenCode 1/2 server entry contract passed")

package/scripts/session-error-recovery-test.mjs

@@ -0,0 +1,186 @@
+import assert from "node:assert/strict"
+import { createLoopExecutor } from "../src/source/runtime/executor.js"
+import { clearSessionActivity } from "../src/source/runtime/session-activity.js"
+
+function clone(value) {
+  return JSON.parse(JSON.stringify(value))
+}
+
+let clock = 1_000_000
+const directory = "/repo"
+const states = new Map()
+const logs = []
+const toasts = []
+const schedules = []
+const notifications = []
+
+function stateKey(sessionID) {
+  return `${directory}:${sessionID}`
+}
+
+function setJob(sessionID, overrides = {}) {
+  states.set(stateKey(sessionID), {
+    jobs: [{
+      id: `${sessionID}-job`,
+      name: `${sessionID}-job`,
+      action: "devam et",
+      enabled: true,
+      paused: false,
+      intervalMs: 0,
+      runCount: 0,
+      maxRuns: 0,
+      maxRuntimeMs: 0,
+      timeoutMs: 0,
+      noOverlap: true,
+      ...overrides,
+    }],
+  })
+}
+
+const executor = createLoopExecutor({
+  workspace: {
+    buildPrompt: async (_directory, job) => job.action,
+    ensureBranch: async (_directory, job) => job,
+    watchChanged: async () => false,
+    untilReached: async () => false,
+    createCheckpoint: async () => {},
+  },
+  goalPolicy: {
+    runGoalChecks: async (_directory, _sessionID, job) => job,
+    applyGoalNoProgressGuard: async (_directory, _client, _sessionID, job) => job,
+  },
+  scheduler: {
+    rememberSession: () => {},
+    scheduleDueWork: async (...args) => schedules.push(args),
+  },
+  now: () => clock,
+  readState: async (_directory, sessionID) => clone(states.get(stateKey(sessionID)) || { jobs: [] }),
+  writeState: async (_directory, sessionID, state) => states.set(stateKey(sessionID), clone(state)),
+  appendLoopLog: async (...args) => logs.push(args),
+  notifyJob: async (...args) => notifications.push(args),
+  toast: async (...args) => toasts.push(args),
+  runShellCommand: async () => ({ code: 0, stdout: "", stderr: "" }),
+  fireSdk: async () => ({ data: {} }),
+  sdkCall: async () => ({}),
+  normalizedModelRef: () => undefined,
+  compactTuiCommandName: () => undefined,
+  guardLoopOwnedUserMessage: () => {},
+  dangerousShell: () => false,
+  activeRunCompletionFromMessages: async () => "unknown",
+  busyRetryMs: 5_000,
+  networkRetryMaxMs: 60_000,
+})
+
+const client = {
+  session: {
+    status: async () => ({ data: {} }),
+    prompt: async () => ({ data: {} }),
+    abort: async () => ({ data: {} }),
+  },
+}
+
+{
+  const sessionID = "policy-error"
+  setJob(sessionID)
+  await executor.maybeRunDueJobs(directory, client, sessionID)
+  assert.ok(executor.getActiveRun(sessionID))
+  assert.equal(states.get(stateKey(sessionID)).jobs[0].runCount, 1)
+
+  const handled = await executor.handleSessionError(directory, client, {
+    type: "session.error",
+    properties: {
+      sessionID,
+      error: {
+        name: "APIError",
+        data: {
+          message: "OpenCode's free tier can only be used from within OpenCode",
+          statusCode: 403,
+          isRetryable: false,
+        },
+      },
+    },
+  })
+
+  assert.equal(handled, true)
+  assert.equal(executor.getActiveRun(sessionID), undefined)
+  const job = states.get(stateKey(sessionID)).jobs[0]
+  assert.equal(job.paused, true, "terminal provider policy error must pause an infinite idle loop")
+  assert.equal(job.failureCount, 1)
+  assert.equal(job.lastFailureReason, "session_error")
+  assert.equal(job.lastSessionErrorName, "APIError")
+  assert.equal(job.lastSessionError, "OpenCode's free tier can only be used from within OpenCode")
+  assert.equal(job.lastSessionErrorAt, clock)
+  assert.ok(notifications.some((call) => call[1]?.id === job.id && call[2] === "session_error"))
+  assert.ok(logs.some((call) => call[1] === "session-error" && call[2]?.sessionID === sessionID && call[2]?.paused === true))
+  assert.ok(toasts.some((call) => String(call[1]).includes("Loop paused after a terminal OpenCode session error")))
+
+  await executor.maybeRunDueJobs(directory, client, sessionID)
+  assert.equal(states.get(stateKey(sessionID)).jobs[0].runCount, 1, "paused terminal-error job must not immediately dispatch another run")
+}
+
+{
+  const sessionID = "retryable-provider-error"
+  setJob(sessionID, { maxRuns: 1 })
+  await executor.maybeRunDueJobs(directory, client, sessionID)
+  let job = states.get(stateKey(sessionID)).jobs[0]
+  assert.equal(job.runCount, 1)
+  assert.equal(job.enabled, false, "max-runs may disable while the provider turn is in flight")
+
+  clock += 10
+  const handled = await executor.handleSessionError(directory, client, {
+    type: "session.error",
+    properties: {
+      sessionID,
+      error: {
+        name: "APIError",
+        data: {
+          message: "provider temporarily unavailable",
+          statusCode: 503,
+          isRetryable: true,
+        },
+      },
+    },
+  })
+
+  assert.equal(handled, true)
+  assert.equal(executor.getActiveRun(sessionID), undefined)
+  job = states.get(stateKey(sessionID)).jobs[0]
+  assert.equal(job.runCount, 0, "retryable terminal provider error must refund the logical run")
+  assert.equal(job.enabled, true, "refunded max-runs disable must be rolled back")
+  assert.equal(job.paused, false)
+  assert.equal(job.failureCount || 0, 0, "retryable provider outage must not consume ordinary failure budget")
+  assert.equal(job.infrastructureFailureCount, 1)
+  assert.equal(job.lastInfrastructureFailure, "session_error_retryable")
+  assert.match(job.lastInfrastructureError, /provider temporarily unavailable/)
+  assert.ok(logs.some((call) => call[1] === "provider-session-error-retry" && call[2]?.sessionID === sessionID))
+  assert.ok(schedules.some((call) => call[2] === sessionID && call[3] >= 5_000))
+}
+
+{
+  const sessionID = "user-abort"
+  setJob(sessionID)
+  await executor.maybeRunDueJobs(directory, client, sessionID)
+  const active = executor.getActiveRun(sessionID)
+  assert.ok(active)
+
+  const handled = await executor.handleSessionError(directory, client, {
+    type: "session.error",
+    properties: {
+      sessionID,
+      error: {
+        name: "MessageAbortedError",
+        data: { message: "The operation was aborted." },
+      },
+    },
+  })
+
+  assert.equal(handled, false, "user/session abort must keep existing abort/finalization semantics")
+  assert.strictEqual(executor.getActiveRun(sessionID), active)
+}
+
+for (const sessionID of ["policy-error", "retryable-provider-error", "user-abort"]) {
+  executor.disposeSession(sessionID)
+  clearSessionActivity(sessionID)
+}
+
+console.log("session error recovery tests passed")

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)
@@ -201,6 +231,17 @@ try {
     track(sessionID)
     runtime.clearSessionStatus(sessionID)
     const active = { jobId: "job", job: {}, startedAt: clock - 100 }
+    completion = "unknown"
+    assert.equal(await runtime.canFinalizeActiveRun("/repo", {}, sessionID, active), true)
+
+    completion = "incomplete"
+    assert.equal(
+      await runtime.canFinalizeActiveRun("/repo", {}, sessionID, active),
+      false,
+      "a transient idle boundary must not finalize a Loop-owned run while the assistant turn is still incomplete",
+    )
+
+    completion = "completed"
     assert.equal(await runtime.canFinalizeActiveRun("/repo", {}, sessionID, active), true)
 
     markToolCallActive({ sessionID, callID: "tool-finalize" })
@@ -210,6 +251,7 @@ try {
     runtime.markSessionStatus(sessionID, "idle", clock + 1)
     const client = { session: { status: async () => { throw new Error("status unavailable") } } }
     assert.equal(await runtime.canFinalizeActiveRun("/repo", client, sessionID, active, { requireIdle: true }), true)
+    completion = "unknown"
   }
 
   {

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 })