@bybrawe/opencode-loop 0.5.26 → 0.5.28

package/src/opencode/v1.js

@@ -0,0 +1 @@
+export { OpenCodeLoopPlugin, default } from "../index.js"

package/src/source/core/args.js

@@ -0,0 +1,281 @@
+// Pure Loop command parsing helpers. Keep host/runtime state out of this module.
+export const DEFAULT_GOAL_MAX_NO_PROGRESS = 3
+
+export function now() {
+  return Date.now()
+}
+
+export function safeID(value) {
+  return String(value || "job")
+    .replace(/[^a-zA-Z0-9_.-]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 80) || "job"
+}
+
+export function parseDuration(value) {
+  const input = String(value || "").trim()
+  if (input === "0") return 0
+  const match = input.match(/^(\d+)\s*(ms|s|sec|secs|second|seconds|m|min|mins|minute|minutes|h|hr|hrs|hour|hours|d|day|days)$/i)
+  if (!match) return null
+  const amount = Number.parseInt(match[1], 10)
+  const unit = match[2].toLowerCase()
+  if (!Number.isFinite(amount) || amount < 0) return null
+  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 null
+}
+
+export function durationToText(ms) {
+  if (ms === 0) return "every idle"
+  if (!Number.isFinite(ms)) return "unknown"
+  if (ms % 86_400_000 === 0) return `${ms / 86_400_000}d`
+  if (ms % 3_600_000 === 0) return `${ms / 3_600_000}h`
+  if (ms % 60_000 === 0) return `${ms / 60_000}m`
+  if (ms % 1000 === 0) return `${ms / 1000}s`
+  return `${ms}ms`
+}
+
+export function splitFirst(input) {
+  const match = String(input || "").trim().match(/^(\S+)\s*([\s\S]*)$/)
+  if (!match) return ["", ""]
+  return [match[1], (match[2] || "").trim()]
+}
+
+export function stripOuterQuotes(value) {
+  const input = String(value || "").trim()
+  if ((input.startsWith('"') && input.endsWith('"')) || (input.startsWith("'") && input.endsWith("'"))) {
+    return input.slice(1, -1)
+  }
+  return input
+}
+
+export function escapeRegExp(value) {
+  return String(value).replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&")
+}
+
+export function takeFlag(rest, flag) {
+  const pattern = new RegExp(`(^|\\s)${escapeRegExp(flag)}(?=\\s|$)`, "i")
+  const found = pattern.test(rest)
+  return [found, rest.replace(pattern, " ").replace(/\s+/g, " ").trim()]
+}
+
+export function takeFlagValue(rest, flag) {
+  const pattern = new RegExp(`(^|\\s)${escapeRegExp(flag)}\\s+(?:\"([^\"]*)\"|'([^']*)'|(\\S+))`, "i")
+  const match = rest.match(pattern)
+  if (!match) return [undefined, rest]
+  const value = match[2] ?? match[3] ?? match[4]
+  return [value, rest.replace(pattern, " ").replace(/\s+/g, " ").trim()]
+}
+
+export function takeAllFlagValues(rest, flag) {
+  const values = []
+  let current = rest
+  while (true) {
+    const [value, next] = takeFlagValue(current, flag)
+    if (value === undefined) return [values, current]
+    values.push(value)
+    current = next
+  }
+}
+
+export function parsePositiveInt(value, fallback = 0) {
+  const parsed = Number.parseInt(String(value || ""), 10)
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback
+}
+
+export function parseNonNegativeInt(value, fallback = 0) {
+  const parsed = Number.parseInt(String(value || ""), 10)
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : fallback
+}
+
+export function parseCompactEvery(value) {
+  const duration = parseDuration(value)
+  if (duration !== null) return { compactEveryMs: duration }
+  const runs = parsePositiveInt(value, 0)
+  return runs > 0 ? { compactEveryRuns: runs } : {}
+}
+
+export function parseLoopArgs(raw, defaults = {}) {
+  let input = stripOuterQuotes(String(raw || "").trim())
+  let first = ""
+  let rest = input
+  let intervalMs = defaults.intervalMs ?? null
+
+  if (!input && defaults.action) {
+    rest = defaults.action
+  } else {
+    ;[first, rest] = splitFirst(input)
+    if (first === "--watch") {
+      intervalMs = defaults.intervalMs ?? 0
+      rest = input
+    } else if (first) {
+      const parsedDuration = parseDuration(first)
+      if (parsedDuration !== null) intervalMs = parsedDuration
+      else if (intervalMs === null) return { ok: false, error: "Usage: /loop 0s <prompt> | /loop 5m <prompt> | /loop-goal <objective> | /loop-command 200m /compact | /loop-shell 10m npm test | /loop --watch progress.md <prompt>" }
+      else rest = input
+    }
+  }
+
+  if (intervalMs === null) intervalMs = 0
+
+  const job = {
+    id: `${now().toString(36)}-${Math.random().toString(16).slice(2, 8)}`,
+    name: defaults.name,
+    action: defaults.action || "",
+    kind: defaults.kind || undefined,
+    intervalMs,
+    immediate: defaults.immediate ?? true,
+    maxRuns: defaults.maxRuns ?? 0,
+    maxRuntimeMs: defaults.maxRuntimeMs ?? 0,
+    maxFailures: defaults.maxFailures ?? 0,
+    timeoutMs: defaults.timeoutMs ?? 0,
+    until: defaults.until,
+    stopFile: defaults.stopFile,
+    progressFile: defaults.progressFile,
+    promptFile: defaults.promptFile,
+    includeFiles: Array.isArray(defaults.includeFiles) ? [...defaults.includeFiles] : [],
+    watchPaths: Array.isArray(defaults.watchPaths) ? [...defaults.watchPaths] : [],
+    compactEveryRuns: defaults.compactEveryRuns ?? 0,
+    compactEveryMs: defaults.compactEveryMs ?? 0,
+    testCommand: defaults.testCommand,
+    verifyCommand: defaults.verifyCommand,
+    preflightCommand: defaults.preflightCommand,
+    postrunCommand: defaults.postrunCommand,
+    notifyCommand: defaults.notifyCommand,
+    branch: defaults.branch,
+    branchDone: false,
+    goalStatus: defaults.goalStatus,
+    goalFile: defaults.goalFile,
+    goalAcceptance: Array.isArray(defaults.goalAcceptance) ? [...defaults.goalAcceptance] : [],
+    goalChecks: Array.isArray(defaults.goalChecks) ? [...defaults.goalChecks] : [],
+    goalCompleteWhenChecksPass: defaults.goalCompleteWhenChecksPass ?? false,
+    goalRequireEvidence: defaults.goalRequireEvidence,
+    goalRequireChecksPass: defaults.goalRequireChecksPass,
+    goalEvidenceFile: defaults.goalEvidenceFile,
+    goalSummary: defaults.goalSummary || "",
+    goalEvidence: defaults.goalEvidence || "",
+    goalBlockedReason: defaults.goalBlockedReason || "",
+    goalProgress: Array.isArray(defaults.goalProgress) ? [...defaults.goalProgress] : [],
+    maxNoProgress: defaults.maxNoProgress,
+    noProgressCount: defaults.noProgressCount ?? 0,
+    lastProgressAt: defaults.lastProgressAt ?? 0,
+    noOverlap: defaults.noOverlap ?? true,
+    safe: defaults.safe ?? false,
+    quiet: defaults.quiet ?? false,
+    askNever: defaults.askNever ?? false,
+    pauseOnVerifyFail: defaults.pauseOnVerifyFail ?? false,
+    gitCheckpoint: defaults.gitCheckpoint ?? false,
+    checkpointOnly: defaults.checkpointOnly ?? false,
+    dryRun: defaults.dryRun ?? false,
+    multi: defaults.multi ?? false,
+    batch: defaults.batch ?? 0,
+    runCount: 0,
+    failureCount: 0,
+    lastRunAt: 0,
+    lastCompactAt: 0,
+    lastCompactRunCount: 0,
+    watchSnapshot: {},
+    watchTriggered: false,
+    createdAt: new Date().toISOString(),
+    enabled: true,
+    paused: false,
+  }
+
+  let found
+  let value
+
+  ;[found, rest] = takeFlag(rest, "--no-now"); if (found) job.immediate = false
+  ;[found, rest] = takeFlag(rest, "--now"); if (found) job.immediate = true
+  ;[found, rest] = takeFlag(rest, "--no-overlap"); if (found) job.noOverlap = true
+  ;[found, rest] = takeFlag(rest, "--allow-overlap"); if (found) job.noOverlap = false
+  ;[found, rest] = takeFlag(rest, "--safe"); if (found) job.safe = true
+  ;[found, rest] = takeFlag(rest, "--quiet"); if (found) job.quiet = true
+  ;[found, rest] = takeFlag(rest, "--ask-never"); if (found) job.askNever = true
+  ;[found, rest] = takeFlag(rest, "--git-checkpoint"); if (found) job.gitCheckpoint = true
+  ;[found, rest] = takeFlag(rest, "--checkpoint-only"); if (found) job.checkpointOnly = true
+  ;[found, rest] = takeFlag(rest, "--pause-on-verify-fail"); if (found) job.pauseOnVerifyFail = true
+  ;[found, rest] = takeFlag(rest, "--dry-run"); if (found) job.dryRun = true
+  ;[found, rest] = takeFlag(rest, "--multi"); if (found) job.multi = true
+  ;[found, rest] = takeFlag(rest, "--replace"); if (found) job.multi = false
+  ;[found, rest] = takeFlag(rest, "--prompt"); if (found) job.kind = "prompt"
+  ;[found, rest] = takeFlag(rest, "--ask"); if (found) job.kind = "prompt"
+  ;[found, rest] = takeFlag(rest, "--command"); if (found) job.kind = "command"
+  ;[found, rest] = takeFlag(rest, "--cmd"); if (found) job.kind = "command"
+  ;[found, rest] = takeFlag(rest, "--slash"); if (found) job.kind = "command"
+  ;[found, rest] = takeFlag(rest, "--shell"); if (found) job.kind = "shell"
+  ;[found, rest] = takeFlag(rest, "--compact"); if (found) job.kind = "compact"
+  ;[found, rest] = takeFlag(rest, "--goal"); if (found) job.kind = "goal"
+  ;[found, rest] = takeFlag(rest, "--complete-when-checks-pass"); if (found) job.goalCompleteWhenChecksPass = true
+  ;[found, rest] = takeFlag(rest, "--no-complete-when-checks-pass"); if (found) job.goalCompleteWhenChecksPass = false
+  ;[found, rest] = takeFlag(rest, "--require-evidence"); if (found) job.goalRequireEvidence = true
+  ;[found, rest] = takeFlag(rest, "--allow-weak-evidence"); if (found) job.goalRequireEvidence = false
+  ;[found, rest] = takeFlag(rest, "--require-checks-pass"); if (found) job.goalRequireChecksPass = true
+  ;[found, rest] = takeFlag(rest, "--allow-complete-without-checks"); if (found) job.goalRequireChecksPass = false
+  ;[found, rest] = takeFlag(rest, "--allow-complete-with-failing-checks"); if (found) job.goalRequireChecksPass = false
+
+  ;[value, rest] = takeFlagValue(rest, "--name"); if (value !== undefined) job.name = value.trim()
+  ;[value, rest] = takeFlagValue(rest, "--max-runs"); if (value !== undefined) job.maxRuns = parsePositiveInt(value, 0)
+  ;[value, rest] = takeFlagValue(rest, "--max-turns"); if (value !== undefined) job.maxRuns = parsePositiveInt(value, 0)
+  ;[value, rest] = takeFlagValue(rest, "--max-no-progress"); if (value !== undefined) job.maxNoProgress = parseNonNegativeInt(value, DEFAULT_GOAL_MAX_NO_PROGRESS)
+  ;[value, rest] = takeFlagValue(rest, "--timeout"); if (value !== undefined) job.timeoutMs = parseDuration(value) ?? 0
+  ;[value, rest] = takeFlagValue(rest, "--max-runtime"); if (value !== undefined) job.maxRuntimeMs = parseDuration(value) ?? 0
+  ;[value, rest] = takeFlagValue(rest, "--max-failures"); if (value !== undefined) job.maxFailures = parsePositiveInt(value, 0)
+  ;[value, rest] = takeFlagValue(rest, "--until"); if (value !== undefined) job.until = stripOuterQuotes(value)
+  ;[value, rest] = takeFlagValue(rest, "--stop-file"); if (value !== undefined) job.stopFile = stripOuterQuotes(value)
+  ;[value, rest] = takeFlagValue(rest, "--progress-file"); if (value !== undefined) job.progressFile = stripOuterQuotes(value)
+  ;[value, rest] = takeFlagValue(rest, "--prompt-file"); if (value !== undefined) job.promptFile = stripOuterQuotes(value)
+  ;[value, rest] = takeFlagValue(rest, "--goal-file"); if (value !== undefined) job.goalFile = stripOuterQuotes(value)
+  ;[value, rest] = takeFlagValue(rest, "--evidence-file"); if (value !== undefined) job.goalEvidenceFile = stripOuterQuotes(value)
+  ;[value, rest] = takeFlagValue(rest, "--test"); if (value !== undefined) job.testCommand = stripOuterQuotes(value)
+  ;[value, rest] = takeFlagValue(rest, "--verify"); if (value !== undefined) job.verifyCommand = stripOuterQuotes(value)
+  ;[value, rest] = takeFlagValue(rest, "--preflight"); if (value !== undefined) job.preflightCommand = stripOuterQuotes(value)
+  ;[value, rest] = takeFlagValue(rest, "--postrun"); if (value !== undefined) job.postrunCommand = stripOuterQuotes(value)
+  ;[value, rest] = takeFlagValue(rest, "--notify"); if (value !== undefined) job.notifyCommand = stripOuterQuotes(value)
+  ;[value, rest] = takeFlagValue(rest, "--branch"); if (value !== undefined) job.branch = stripOuterQuotes(value)
+  ;[value, rest] = takeFlagValue(rest, "--batch"); if (value !== undefined) job.batch = parsePositiveInt(value, 0)
+  ;[value, rest] = takeFlagValue(rest, "--compact-every")
+  if (value !== undefined) Object.assign(job, parseCompactEvery(value))
+
+  const watch = takeAllFlagValues(rest, "--watch")
+  job.watchPaths.push(...watch[0].map(stripOuterQuotes).filter(Boolean))
+  rest = watch[1]
+
+  const includes = takeAllFlagValues(rest, "--include-file")
+  job.includeFiles.push(...includes[0].map(stripOuterQuotes).filter(Boolean))
+  rest = includes[1]
+
+  const acceptances = takeAllFlagValues(rest, "--acceptance")
+  job.goalAcceptance.push(...acceptances[0].map(stripOuterQuotes).filter(Boolean))
+  rest = acceptances[1]
+
+  const success = takeAllFlagValues(rest, "--success")
+  job.goalAcceptance.push(...success[0].map(stripOuterQuotes).filter(Boolean))
+  rest = success[1]
+
+  const checks = takeAllFlagValues(rest, "--check")
+  job.goalChecks.push(...checks[0].map(stripOuterQuotes).filter(Boolean))
+  rest = checks[1]
+
+  job.action = stripOuterQuotes(rest || job.action || "")
+  job.watchPaths = [...new Set(job.watchPaths)]
+  job.includeFiles = [...new Set(job.includeFiles)]
+  job.goalAcceptance = [...new Set(job.goalAcceptance || [])]
+  job.goalChecks = [...new Set(job.goalChecks || [])]
+  if (String(job.kind || "").toLowerCase() === "goal") {
+    job.name = job.name || "goal"
+    job.goalStatus = job.goalStatus || "active"
+    job.safe = job.safe !== false
+    job.askNever = job.askNever !== false
+    job.noOverlap = job.noOverlap !== false
+    job.goalRequireEvidence = job.goalRequireEvidence !== false
+    job.goalRequireChecksPass = job.goalRequireChecksPass ?? job.goalChecks.length > 0
+    job.maxNoProgress = job.maxNoProgress ?? DEFAULT_GOAL_MAX_NO_PROGRESS
+  }
+  job.lastRunAt = job.immediate ? 0 : now()
+
+  if (!job.action && !job.promptFile && !job.goalFile) return { ok: false, error: "Missing action. Example: /loop 0s continue from progress.md, /loop-goal ship the feature, or /loop 0s --prompt-file loop-prompt.md" }
+  return { ok: true, job }
+}

package/src/source/core/jobs.js

@@ -0,0 +1,80 @@
+import { DEFAULT_GOAL_MAX_NO_PROGRESS, parseDuration, durationToText } from "./args.js"
+
+export function presetDefaults(name) {
+  // parseLoopArgs owns duration/flag/action parsing. Presets only provide real
+  // defaults; deriving an action from the raw string made flag-only invocations
+  // such as `/loop-compact --dry-run` use "--dry-run" as the action.
+  if (name === "loop-compact") return { intervalMs: parseDuration("200m"), action: "/compact", kind: "compact", name: "compact", immediate: false }
+  if (name === "loop-command" || name === "loop-cmd") return { intervalMs: 0, kind: "command", name: "command", immediate: false }
+  if (name === "loop-prompt") return { intervalMs: 0, kind: "prompt", name: "prompt", immediate: true }
+  if (name === "loop-ask") return { intervalMs: 0, kind: "prompt", name: "ask", immediate: false }
+  if (name === "loop-shell") return { intervalMs: 0, kind: "shell", name: "shell", immediate: false }
+  if (name === "loop-testfix") return { intervalMs: 0, name: "testfix", safe: true, askNever: true, verifyCommand: "npm test", testfixPreset: true, action: "Run the project tests. Fix failures. Re-run the tests. Test command hint: npm test" }
+  if (name === "loop-progress") return { intervalMs: 0, name: "progress", safe: true, askNever: true, progressFile: "progress.md", action: "Read progress.md and continue the next unfinished TODO. Mark completed TODOs with [x]. Add useful TODOs when you discover them." }
+  if (name === "loop-safe-dev") return { intervalMs: 0, name: "safe-dev", safe: true, askNever: true, noOverlap: true, checkpointOnly: true, batch: 5, progressFile: "progress.md", action: "Develop the project from progress.md. Work in small safe batches. Mark completed TODOs with [x]. Add new ideas to progress.md. Run tests/lint/build if available." }
+  return { intervalMs: 0, name: "dev", askNever: true, progressFile: "progress.md", action: "Continue developing the project from progress.md. Mark completed TODOs with [x]. Add new ideas to progress.md. Run tests/lint/build if available." }
+}
+
+export function jobLabel(job) {
+  const title = job.name ? `${job.name}: ` : ""
+  const kind = job.kind ? ` [${job.kind}]` : ""
+  const limit = job.maxRuns > 0 ? `, max ${job.maxRuns}` : ""
+  const runtime = job.maxRuntimeMs > 0 ? `, runtime ${durationToText(job.maxRuntimeMs)}` : ""
+  const timeout = job.timeoutMs > 0 ? `, timeout ${durationToText(job.timeoutMs)}` : ""
+  const compact = job.compactEveryRuns > 0 ? `, compact every ${job.compactEveryRuns} runs` : job.compactEveryMs > 0 ? `, compact every ${durationToText(job.compactEveryMs)}` : ""
+  const verify = job.verifyCommand ? ", verify" : ""
+  const preflight = job.preflightCommand ? ", preflight" : ""
+  const failures = job.maxFailures > 0 ? `, max failures ${job.maxFailures}` : ""
+  const noProgress = isGoalJob(job) && (job.maxNoProgress ?? DEFAULT_GOAL_MAX_NO_PROGRESS) > 0 ? `, max no-progress ${job.maxNoProgress ?? DEFAULT_GOAL_MAX_NO_PROGRESS}` : ""
+  const stopFile = job.stopFile ? ", stop-file" : ""
+  const watch = job.watchPaths?.length ? `, watch ${job.watchPaths.join(",")}` : ""
+  const paused = job.paused ? ", paused" : ""
+  return `${title}${durationToText(job.intervalMs)}${kind} -> ${job.action || `[prompt-file: ${job.promptFile}]`}${limit}${runtime}${timeout}${compact}${verify}${preflight}${failures}${noProgress}${stopFile}${watch}${paused}`
+}
+
+export function matchJob(job, target, index) {
+  const text = String(target || "").trim()
+  if (!text || text.toLowerCase() === "all") return true
+  return job.id === text || job.name === text || String(index + 1) === text
+}
+
+export function actionKind(action, job = {}) {
+  const text = String(action || "").trim()
+  const forced = String(job.kind || "").trim().toLowerCase()
+  if (forced === "compact") return "compact"
+  if (forced === "goal") return "goal"
+  if (text === "/compact" || text === "/summarize") return "compact"
+  if (forced === "prompt" || forced === "ask") return "prompt"
+  if (forced === "command" || forced === "cmd" || forced === "slash") return "command"
+  if (forced === "shell") return "shell"
+  if (text.startsWith("/")) return "command"
+  if (text.startsWith("!") || text.startsWith("$")) return "shell"
+  return "prompt"
+}
+
+export function decoratePrompt(job) {
+  const additions = []
+  if (job.progressFile) additions.push(`Use ${job.progressFile} as the main progress/TODO state file. Read it before choosing the next task and update it after work.`)
+  if (job.lastVerifyFailure) additions.push("Previous verify command failed. Fix this before moving on. Failure summary: " + String(job.lastVerifyFailure).slice(0, 1200))
+  if (job.askNever) additions.push("Do not ask the user questions. Make reasonable assumptions and continue. Only write a short BLOCKED note if truly blocked.")
+  if (job.safe) additions.push("Safety rules: do not run destructive commands such as git reset, git clean, rm -rf, del /s, rmdir /s, force push, production deploys, production migrations, terraform destroy, or deleting user data. If such an action seems needed, write a BLOCKED note instead.")
+  if (job.batch > 0) additions.push(`Batch rule: in this run, work on at most ${job.batch} unfinished TODO item(s). Mark completed items with [x].`)
+  if (job.quiet) additions.push("Keep replies short. Summarize only what changed, tests run, and next step.")
+  if (job.testCommand) additions.push(`After making changes, run this test/check command if applicable: ${job.testCommand}. If it fails, fix the failure and try again.`)
+  if (job.checkpointOnly || job.gitCheckpoint) additions.push("Keep changes incremental and easy to review because the loop will create a checkpoint after the run.")
+  if (!additions.length) return job.action
+  return `${job.action}\n\nOpenCode loop instructions:\n- ${additions.join("\n- ")}`
+}
+
+export function isGoalJob(job) {
+  return String(job?.kind || "").toLowerCase() === "goal"
+}
+
+export function goalStatusText(job) {
+  const status = job?.goalStatus || (isGoalJob(job) ? "active" : "")
+  if (!status) return ""
+  if (status === "completed") return "completed"
+  if (status === "blocked") return "blocked"
+  if (job?.paused) return "paused"
+  return status
+}

package/src/source/core/process.js

@@ -0,0 +1,51 @@
+import { promises as fs } from "node:fs"
+import path from "node:path"
+import { spawn } from "node:child_process"
+import { stateDir, ensureDir } from "./state.js"
+
+export async function appendLoopLog(directory, line, extra = {}) {
+  try {
+    await ensureDir(stateDir(directory))
+    await fs.appendFile(path.join(stateDir(directory), "loop.log"), JSON.stringify({ time: new Date().toISOString(), line, ...extra }) + "\n")
+  } catch {}
+}
+
+export async function readSmallTextFile(filePath, maxBytes = 120_000) {
+  try {
+    const stat = await fs.stat(filePath)
+    if (!stat.isFile() || stat.size > maxBytes) return ""
+    return await fs.readFile(filePath, "utf8")
+  } catch { return "" }
+}
+
+export async function runProcess(command, args, cwd, timeoutMs = 60_000) {
+  return await new Promise((resolve) => {
+    const child = spawn(command, args, { cwd, shell: false, windowsHide: true })
+    const stdout = []
+    const stderr = []
+    const timer = setTimeout(() => { try { child.kill("SIGTERM") } catch {} }, timeoutMs)
+    child.stdout?.on("data", (data) => stdout.push(Buffer.from(data)))
+    child.stderr?.on("data", (data) => stderr.push(Buffer.from(data)))
+    child.on("error", (error) => { clearTimeout(timer); resolve({ code: -1, stdout: "", stderr: String(error) }) })
+    child.on("close", (code) => { clearTimeout(timer); resolve({ code: code ?? 0, stdout: Buffer.concat(stdout).toString("utf8"), stderr: Buffer.concat(stderr).toString("utf8") }) })
+  })
+}
+
+export async function runShellCommand(command, cwd, timeoutMs = 120_000) {
+  return await new Promise((resolve) => {
+    const child = spawn(command, [], { cwd, shell: true, windowsHide: true })
+    const stdout = []
+    const stderr = []
+    const timer = setTimeout(() => { try { child.kill("SIGTERM") } catch {} }, timeoutMs)
+    child.stdout?.on("data", (data) => stdout.push(Buffer.from(data)))
+    child.stderr?.on("data", (data) => stderr.push(Buffer.from(data)))
+    child.on("error", (error) => { clearTimeout(timer); resolve({ code: -1, stdout: "", stderr: String(error) }) })
+    child.on("close", (code) => { clearTimeout(timer); resolve({ code: code ?? 0, stdout: Buffer.concat(stdout).toString("utf8"), stderr: Buffer.concat(stderr).toString("utf8") }) })
+  })
+}
+
+export async function notifyJob(directory, job, reason) {
+  if (!job.notifyCommand) return
+  const command = String(job.notifyCommand).replace(/\{reason\}/g, String(reason || "")).replace(/\{job\}/g, String(job.name || job.id || ""))
+  await runShellCommand(command, directory, 60_000)
+}

package/src/source/core/state.js

@@ -0,0 +1,211 @@
+import { promises as fs } from "node:fs"
+import os from "node:os"
+import path from "node:path"
+import { safeID } from "./args.js"
+
+const STATE_DIR = ".opencode/opencode-loop"
+const STATE_BASELINE = Symbol("opencode-loop-state-baseline")
+const stateWriteLocks = new Map()
+
+export function stateDir(directory) { return path.join(directory, STATE_DIR) }
+function statePath(directory, sessionID) { return path.join(stateDir(directory), `${safeID(sessionID)}.json`) }
+export async function ensureDir(directory) { await fs.mkdir(directory, { recursive: true }) }
+export async function pathExists(filePath) { try { await fs.access(filePath); return true } catch { return false } }
+
+function stateLockKey(directory, sessionID) {
+  return `${path.resolve(directory)}:${safeID(sessionID)}`
+}
+
+async function withStateWriteLock(directory, sessionID, fn) {
+  const key = stateLockKey(directory, sessionID)
+  const previous = stateWriteLocks.get(key) || Promise.resolve()
+  let release
+  const current = new Promise((resolve) => { release = resolve })
+  const next = previous.catch(() => {}).then(() => current)
+  stateWriteLocks.set(key, next)
+  await previous.catch(() => {})
+  try {
+    return await fn()
+  } finally {
+    release()
+    if (stateWriteLocks.get(key) === next) stateWriteLocks.delete(key)
+  }
+}
+
+async function readStateFile(directory, sessionID) {
+  const target = statePath(directory, sessionID)
+  const attempts = 5
+  for (let attempt = 0; attempt < attempts; attempt++) {
+    try {
+      const parsed = JSON.parse(await fs.readFile(target, "utf8"))
+      return { version: 4, jobs: Array.isArray(parsed.jobs) ? parsed.jobs : [] }
+    } catch (error) {
+      if (error?.code === "ENOENT") return { version: 4, jobs: [] }
+      const transient = error instanceof SyntaxError || isRetriableStateWriteError(error)
+      if (!transient || attempt === attempts - 1) break
+      await delay(25 * (attempt + 1))
+    }
+  }
+  try {
+    await ensureDir(stateDir(directory))
+    await fs.copyFile(target, `${target}.corrupt-${Date.now()}`)
+  } catch {}
+  return { version: 4, jobs: [] }
+}
+
+export async function readState(directory, sessionID) {
+  const state = await readStateFile(directory, sessionID)
+  Object.defineProperty(state, STATE_BASELINE, {
+    value: structuredClone(state.jobs || []),
+    enumerable: false,
+    configurable: false,
+    writable: true,
+  })
+  return state
+}
+
+function isRetriableStateWriteError(error) {
+  const code = error?.code
+  return code === "EPERM" || code === "EACCES" || code === "EBUSY" || code === "EEXIST" || code === "EAGAIN"
+}
+
+async function delay(ms) {
+  await new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+// Windows often fails POSIX-style "write temp next to target, then rename over it":
+// existing destinations can return EPERM/EEXIST while antivirus, IDE indexers, or
+// OpenCode's own snapshotter briefly hold the state file. Temp files next to the
+// target also show up in project git snapshots as *.tmp pathspec noise.
+//
+// Write the payload outside the project first, then replace the target with
+// rename when possible and a copy/unlink fallback with short retries.
+async function writeFileAtomically(target, contents, options = {}) {
+  const encoding = options.encoding || "utf8"
+  const attempts = Math.max(1, Number(options.attempts) || 5)
+  const temp = path.join(
+    os.tmpdir(),
+    `opencode-loop-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}.tmp`,
+  )
+  await fs.writeFile(temp, contents, encoding)
+  try {
+    let lastError
+    // Prefer an atomic rename and retry transient Windows destination locks
+    // before falling back to a non-atomic copy/overwrite.
+    for (let attempt = 0; attempt < attempts; attempt++) {
+      try {
+        await fs.rename(temp, target)
+        return
+      } catch (error) {
+        lastError = error
+        if (error?.code === "EXDEV") break
+        if (!isRetriableStateWriteError(error)) throw error
+        if (attempt < attempts - 1) await delay(25 * (attempt + 1))
+      }
+    }
+
+    for (let attempt = 0; attempt < attempts; attempt++) {
+      try {
+        await fs.copyFile(temp, target)
+        return
+      } catch (error) {
+        lastError = error
+        if (!isRetriableStateWriteError(error)) throw error
+        if (attempt < attempts - 1) await delay(25 * (attempt + 1))
+      }
+    }
+
+    try {
+      await fs.writeFile(target, contents, encoding)
+      return
+    } catch (error) {
+      if (lastError && !error.cause) error.cause = lastError
+      throw error
+    }
+  } finally {
+    try { await fs.rm(temp, { force: true }) } catch {}
+  }
+}
+
+function stateValuesEqual(left, right) {
+  if (Object.is(left, right)) return true
+  try { return JSON.stringify(left) === JSON.stringify(right) } catch { return false }
+}
+
+function mergeStateJob(baseJob, intendedJob, currentJob) {
+  const merged = structuredClone(currentJob || {})
+  const keys = new Set([
+    ...Object.keys(baseJob || {}),
+    ...Object.keys(intendedJob || {}),
+  ])
+  for (const key of keys) {
+    const baseHas = Object.prototype.hasOwnProperty.call(baseJob || {}, key)
+    const intendedHas = Object.prototype.hasOwnProperty.call(intendedJob || {}, key)
+    const currentHas = Object.prototype.hasOwnProperty.call(currentJob || {}, key)
+    const intendedChanged = baseHas !== intendedHas || !stateValuesEqual(baseJob?.[key], intendedJob?.[key])
+    if (!intendedChanged) continue
+    const currentChanged = baseHas !== currentHas || !stateValuesEqual(baseJob?.[key], currentJob?.[key])
+    const sameResult = intendedHas === currentHas && stateValuesEqual(intendedJob?.[key], currentJob?.[key])
+    // First committed writer wins a true same-field conflict. A stale snapshot
+    // can still apply changes to unrelated fields without erasing newer state.
+    if (currentChanged && !sameResult) continue
+    if (intendedHas) merged[key] = structuredClone(intendedJob[key])
+    else delete merged[key]
+  }
+  return merged
+}
+
+function mergeStateJobs(baseJobs, intendedJobs, currentJobs) {
+  const byID = (jobs) => new Map((jobs || []).filter((job) => job?.id).map((job) => [job.id, job]))
+  const base = byID(baseJobs)
+  const intended = byID(intendedJobs)
+  const current = byID(currentJobs)
+  const merged = []
+
+  for (const currentJob of currentJobs || []) {
+    const id = currentJob?.id
+    if (!id || !base.has(id)) {
+      merged.push(structuredClone(currentJob))
+      continue
+    }
+    const baseJob = base.get(id)
+    const intendedJob = intended.get(id)
+    if (!intendedJob) {
+      // A deletion based on an old snapshot must not erase a job that changed
+      // after that snapshot was read.
+      if (!stateValuesEqual(baseJob, currentJob)) merged.push(structuredClone(currentJob))
+      continue
+    }
+    merged.push(mergeStateJob(baseJob, intendedJob, currentJob))
+  }
+
+  for (const intendedJob of intendedJobs || []) {
+    const id = intendedJob?.id
+    if (!id || base.has(id) || current.has(id)) continue
+    merged.push(structuredClone(intendedJob))
+  }
+  return merged
+}
+
+export async function writeState(directory, sessionID, state) {
+  await withStateWriteLock(directory, sessionID, async () => {
+    await ensureDir(stateDir(directory))
+    const target = statePath(directory, sessionID)
+    const baseline = state?.[STATE_BASELINE]
+    let jobs = structuredClone(state.jobs || [])
+    if (Array.isArray(baseline)) {
+      const current = await readStateFile(directory, sessionID)
+      jobs = mergeStateJobs(baseline, jobs, current.jobs || [])
+      state.jobs = structuredClone(jobs)
+      state[STATE_BASELINE] = structuredClone(jobs)
+    }
+    const payload = JSON.stringify({ version: 4, jobs }, null, 2)
+    await writeFileAtomically(target, payload)
+  })
+}
+
+export async function removeState(directory, sessionID) {
+  await withStateWriteLock(directory, sessionID, async () => {
+    try { await fs.unlink(statePath(directory, sessionID)) } catch {}
+  })
+}