@bybrawe/opencode-loop 0.5.31 → 0.5.33

package/src/source/runtime/goal-runtime.js

@@ -1,105 +1,13 @@
-import { promises as fs } from "node:fs"
-import path from "node:path"
-import { DEFAULT_GOAL_MAX_NO_PROGRESS, now, safeID } from "../core/args.js"
-import { matchJob, isGoalJob, goalStatusText } from "../core/jobs.js"
-import { stateDir, ensureDir, readState, writeState } from "../core/state.js"
-import { appendLoopLog, readSmallTextFile } from "../core/process.js"
+import { now } from "../core/args.js"
+import { matchJob, isGoalJob } from "../core/jobs.js"
+import { readState, writeState } from "../core/state.js"
+import { appendLoopLog } from "../core/process.js"
+import { writeGoalReport } from "./goal-report.js"
+import { hasConcreteGoalEvidence, goalChecksPassed, goalRequiresPassingChecks } from "./goal-evidence.js"
 
-const GOAL_REPORT_DIR = "goals"
-const GOAL_PROMPT_PREFIX = "EXPERIMENTAL OPENCODE GOAL MODE ITERATION"
-
-export async function buildGoalPrompt(directory, job) {
-  const sections = []
-  sections.push(`Working directory:\n${path.resolve(directory)}\nKeep every file operation inside this directory. Prefer workspace-relative paths such as \"src/index.js\"; never turn a relative path into a root path such as \"/src/index.js\".`)
-  const objective = String(job.action || "").trim()
-  if (objective) sections.push(`Goal objective:\n${objective}`)
-  if (job.goalFile) {
-    const text = await readSmallTextFile(path.resolve(directory, job.goalFile), 120_000)
-    if (text.trim()) sections.push(`Goal file ${job.goalFile}:\n${text.trim()}`)
-    else sections.push(`Goal file ${job.goalFile} was requested but could not be read. Continue from the inline goal objective.`)
-  }
-  if (job.promptFile) {
-    const text = await readSmallTextFile(path.resolve(directory, job.promptFile), 120_000)
-    if (text.trim()) sections.push(`Extra goal instructions from ${job.promptFile}:\n${text.trim()}`)
-  }
-  if (job.goalAcceptance?.length) sections.push("Acceptance criteria:\n" + job.goalAcceptance.map((item, index) => `${index + 1}. ${item}`).join("\n"))
-  if (job.goalChecks?.length) sections.push("Verification commands that define useful evidence:\n" + job.goalChecks.map((item, index) => `${index + 1}. ${item}`).join("\n"))
-  if (job.verifyCommand) sections.push(`Post-turn verify command configured by the loop: ${job.verifyCommand}`)
-  if (job.lastGoalChecks?.length) sections.push("Latest goal check results:\n" + job.lastGoalChecks.map((item) => `- ${item.command}: exit ${item.code}`).join("\n"))
-  if (job.lastVerifyFailure) sections.push("Previous verify/check failure summary:\n" + String(job.lastVerifyFailure).slice(0, 1600))
-  if (job.goalCompletionRejectedReason) sections.push(`Previous completion attempt was rejected:\n${job.goalCompletionRejectedReason}`)
-  if ((job.maxNoProgress ?? DEFAULT_GOAL_MAX_NO_PROGRESS) > 0) sections.push(`No-progress guard:\n${job.noProgressCount || 0}/${job.maxNoProgress ?? DEFAULT_GOAL_MAX_NO_PROGRESS} recent turn(s) without recorded meaningful progress.`)
-  if (job.goalProgress?.length) sections.push("Recent goal progress:\n" + job.goalProgress.slice(-5).map((item) => `- ${item.time}: ${item.summary}`).join("\n"))
-  for (const file of job.includeFiles || []) {
-    const text = await readSmallTextFile(path.resolve(directory, file), 80_000)
-    if (text.trim()) sections.push(`Context from ${file}:\n${text.trim().slice(0, 20_000)}`)
-  }
-
-  return `${GOAL_PROMPT_PREFIX}.
-
-You are pursuing an experimental persistent goal for this OpenCode session. This is not a timer loop and not a one-shot prompt. Keep working toward the goal until it is completed, blocked, paused, cleared, or stopped by safety limits.
-
-Rules:
-- Work on the next smallest useful step toward the goal.
-- Prefer direct code changes, tests, typechecks, builds, and evidence over discussion.
-- Do not claim the goal is complete unless the acceptance criteria are satisfied and verification evidence supports it.
-- If verification commands are configured, do not call opencode_loop_goal_complete until the latest relevant checks have passed unless the user explicitly overrides the goal.
-- Completion evidence must be concrete: mention commands, files, checks, results, or code inspection details.
-- When the goal is complete, call the tool opencode_loop_goal_complete with a summary and evidence.
-- If you are truly blocked and need user input, call the tool opencode_loop_goal_blocked with the reason and what is needed.
-- If you made meaningful progress but the goal is not complete, call the tool opencode_loop_goal_progress with the summary and next step.
-- If you cannot make meaningful progress for this turn, call opencode_loop_goal_blocked instead of repeating the same attempt.
-- Do not call completion tools just to be polite; only call them when the state is real.
-- Do not ask the user questions unless blocked; make reasonable assumptions and continue.
-- Follow safety rules: no destructive commands, force pushes, production deploys, production database resets, or deleting user data.
-
-${sections.join("\n\n---\n\n")}`
-}
-
-export function goalReportPath(directory, sessionID, job) {
-  return path.join(stateDir(directory), GOAL_REPORT_DIR, `${safeID(sessionID)}-${safeID(job.name || job.id)}.md`)
-}
-
-export function goalReportText(job) {
-  const lines = []
-  lines.push(`# OpenCode Loop Goal Report`)
-  lines.push("")
-  lines.push(`Status: ${goalStatusText(job) || "unknown"}`)
-  lines.push(`Goal: ${job.action || job.goalFile || ""}`)
-  lines.push(`Created: ${job.createdAt || ""}`)
-  if (job.goalCompletedAt) lines.push(`Completed: ${new Date(job.goalCompletedAt).toISOString()}`)
-  if (job.goalBlockedAt) lines.push(`Blocked: ${new Date(job.goalBlockedAt).toISOString()}`)
-  if (job.lastUserInterruptAt) lines.push(`Paused by user message: ${new Date(job.lastUserInterruptAt).toISOString()}`)
-  if (job.goalNoProgressPausedAt) lines.push(`Paused by no-progress guard: ${new Date(job.goalNoProgressPausedAt).toISOString()}`)
-  if (job.runCount) lines.push(`Turns: ${job.runCount}`)
-  if ((job.maxNoProgress ?? DEFAULT_GOAL_MAX_NO_PROGRESS) > 0) lines.push(`No-progress: ${job.noProgressCount || 0}/${job.maxNoProgress ?? DEFAULT_GOAL_MAX_NO_PROGRESS}`)
-  lines.push("")
-  if (job.goalSummary) lines.push("## Summary", "", String(job.goalSummary), "")
-  if (job.goalEvidence) lines.push("## Evidence", "", String(job.goalEvidence), "")
-  if (job.goalBlockedReason) lines.push("## Blocked reason", "", String(job.goalBlockedReason), "")
-  if (job.goalCompletionRejectedReason) lines.push("## Last completion rejection", "", String(job.goalCompletionRejectedReason), "")
-  if (job.goalInterruptedReason) lines.push("## Interrupt", "", String(job.goalInterruptedReason), "")
-  if (job.goalNoProgressReason) lines.push("## No-progress guard", "", String(job.goalNoProgressReason), "")
-  if (job.goalAcceptance?.length) lines.push("## Acceptance criteria", "", ...job.goalAcceptance.map((item) => `- ${item}`), "")
-  if (job.lastGoalChecks?.length) {
-    lines.push("## Latest checks", "")
-    for (const item of job.lastGoalChecks) lines.push(`- ${item.command}: exit ${item.code}`)
-    lines.push("")
-  }
-  if (job.goalProgress?.length) {
-    lines.push("## Progress", "")
-    for (const item of job.goalProgress) lines.push(`- ${item.time}: ${item.summary}${item.next ? ` Next: ${item.next}` : ""}`)
-    lines.push("")
-  }
-  return lines.join("\n")
-}
-
-export async function writeGoalReport(directory, sessionID, job) {
-  if (!isGoalJob(job)) return
-  const target = job.goalEvidenceFile ? path.resolve(directory, job.goalEvidenceFile) : goalReportPath(directory, sessionID, job)
-  await ensureDir(path.dirname(target))
-  await fs.writeFile(target, goalReportText(job), "utf8")
-}
+export { buildGoalPrompt } from "./goal-prompt.js"
+export { goalReportPath, goalReportText, writeGoalReport } from "./goal-report.js"
+export { hasConcreteGoalEvidence, goalChecksPassed, goalRequiresPassingChecks, goalProgressSnapshot, goalMadeMeaningfulProgress } from "./goal-evidence.js"
 
 export function pickGoalJob(state, target = "") {
   const goals = (state.jobs || []).filter(isGoalJob)
@@ -115,46 +23,6 @@ export function parseGoalToolText(args, fields) {
   return result
 }
 
-export function hasConcreteGoalEvidence(value) {
-  const text = String(value || "").trim()
-  if (text.length < 24) return false
-  const normalized = text.toLowerCase().replace(/\s+/g, " ")
-  const weak = new Set(["done", "complete", "completed", "ok", "looks good", "n/a", "none", "no evidence", "no evidence provided", "goal completed", "marked complete"])
-  if (weak.has(normalized) || normalized.startsWith("marked complete by /loop-goal-done")) return false
-  return /(\b(npm|pnpm|yarn|bun|node|pytest|cargo|dotnet|go test|tsc|typecheck|test|tests|lint|build|check|checks|exit\s*\d|passed|verified|changed|updated|created|fixed|file|files|diff|commit)\b|[`\\/][\w./:-]+)/i.test(text) || text.length >= 80
-}
-
-export function goalChecksPassed(job) {
-  return Array.isArray(job?.lastGoalChecks) && job.lastGoalChecks.length > 0 && job.lastGoalChecks.every((item) => Number(item?.code) === 0)
-}
-
-export function goalRequiresPassingChecks(job) {
-  return job?.goalRequireChecksPass !== false && Array.isArray(job?.goalChecks) && job.goalChecks.length > 0
-}
-
-export function goalProgressSnapshot(job) {
-  return {
-    status: job?.goalStatus || "",
-    progressCount: Array.isArray(job?.goalProgress) ? job.goalProgress.length : 0,
-    evidence: String(job?.goalEvidence || ""),
-    checksPassedAt: Number(job?.goalChecksPassedAt || 0),
-    lastGoalCheckAt: Number(job?.lastGoalCheckAt || 0),
-    lastVerifyAt: Number(job?.lastVerifyAt || 0),
-    lastVerifyCode: Number.isFinite(Number(job?.lastVerifyCode)) ? Number(job.lastVerifyCode) : undefined,
-  }
-}
-
-export function goalMadeMeaningfulProgress(beforeJob, afterJob) {
-  const before = goalProgressSnapshot(beforeJob || {})
-  const after = goalProgressSnapshot(afterJob || {})
-  if (["completed", "blocked"].includes(after.status) && after.status !== before.status) return true
-  if (after.progressCount > before.progressCount) return true
-  if (after.evidence !== before.evidence && hasConcreteGoalEvidence(after.evidence)) return true
-  if (after.checksPassedAt > before.checksPassedAt || goalChecksPassed(afterJob) && after.lastGoalCheckAt > before.lastGoalCheckAt) return true
-  if (after.lastVerifyAt > before.lastVerifyAt && after.lastVerifyCode === 0) return true
-  return false
-}
-
 export async function rejectGoalCompletion(directory, sessionID, state, job, reason) {
   job.goalCompletionRejectedAt = now()
   job.goalCompletionRejectedReason = reason

package/src/source/runtime/run-admission.js

@@ -0,0 +1,132 @@
+import path from "node:path"
+import { now as defaultNow } from "../core/args.js"
+import { isGoalJob } from "../core/jobs.js"
+import { pathExists as defaultPathExists, writeState as defaultWriteState } from "../core/state.js"
+import { appendLoopLog as defaultAppendLoopLog, runShellCommand as defaultRunShellCommand, notifyJob as defaultNotifyJob } from "../core/process.js"
+import { toast as defaultToast } from "../opencode/host.js"
+import { dangerousShell as defaultDangerousShell } from "./job-workspace.js"
+
+function requireFunction(value, label) {
+  if (typeof value !== "function") throw new TypeError(`createRunAdmissionRuntime requires ${label}`)
+  return value
+}
+
+export function createRunAdmissionRuntime(options = {}) {
+  const untilReached = requireFunction(options.untilReached, "untilReached")
+  const scheduleDueWork = requireFunction(options.scheduleDueWork, "scheduleDueWork")
+
+  const now = typeof options.now === "function" ? options.now : defaultNow
+  const pathExists = typeof options.pathExists === "function" ? options.pathExists : defaultPathExists
+  const writeState = typeof options.writeState === "function" ? options.writeState : defaultWriteState
+  const appendLoopLog = typeof options.appendLoopLog === "function" ? options.appendLoopLog : defaultAppendLoopLog
+  const runShellCommand = typeof options.runShellCommand === "function" ? options.runShellCommand : defaultRunShellCommand
+  const notifyJob = typeof options.notifyJob === "function" ? options.notifyJob : defaultNotifyJob
+  const toast = typeof options.toast === "function" ? options.toast : defaultToast
+  const dangerousShell = typeof options.dangerousShell === "function" ? options.dangerousShell : defaultDangerousShell
+
+  function dueJobs(state, force = false) {
+    const current = now()
+    const due = (state.jobs || []).filter((job) => {
+      if (isGoalJob(job) && ["completed", "blocked", "cleared"].includes(job.goalStatus)) return false
+      if (!job.enabled || job.paused) return false
+      if (job.maxRuns > 0 && (job.runCount || 0) >= job.maxRuns) return false
+      if (job.maxRuntimeMs > 0 && current - Date.parse(job.createdAt || new Date().toISOString()) >= job.maxRuntimeMs) return true
+      if (Number(job.runNowRequestedAt || 0) > 0) return true
+      if (force) return true
+      if (job.watchPaths?.length) return job.watchTriggered === true
+      return job.intervalMs === 0 || !job.lastRunAt || current - job.lastRunAt >= job.intervalMs
+    })
+    return due.sort((a, b) => Number(Number(b.runNowRequestedAt || 0) > 0) - Number(Number(a.runNowRequestedAt || 0) > 0))
+  }
+
+  async function reschedule(directory, client, sessionID) {
+    await scheduleDueWork(directory, client, sessionID)
+  }
+
+  async function stopAndRemove(directory, client, sessionID, state, job, reason, message, logEvent) {
+    state.jobs = (state.jobs || []).filter((candidate) => candidate.id !== job.id)
+    await writeState(directory, sessionID, state)
+    await notifyJob(directory, job, reason)
+    await toast(client, message, "success")
+    if (logEvent) await appendLoopLog(directory, logEvent, { sessionID, job: job.name || job.id })
+    await reschedule(directory, client, sessionID)
+    return { admitted: false, reason }
+  }
+
+  async function admitJob(directory, client, sessionID, state, job) {
+    const runNowRequested = Number(job.runNowRequestedAt || 0) > 0
+
+    if (job.maxRuntimeMs > 0 && now() - Date.parse(job.createdAt || new Date().toISOString()) >= job.maxRuntimeMs) {
+      return await stopAndRemove(
+        directory,
+        client,
+        sessionID,
+        state,
+        job,
+        "max_runtime_reached",
+        `Loop stopped by --max-runtime: ${job.name || job.id}`,
+        "max-runtime",
+      )
+    }
+
+    if (job.stopFile && await pathExists(path.resolve(directory, job.stopFile))) {
+      return await stopAndRemove(
+        directory,
+        client,
+        sessionID,
+        state,
+        job,
+        "stop_file",
+        "Loop stopped by --stop-file: " + job.stopFile,
+      )
+    }
+
+    if (await untilReached(directory, job)) {
+      return await stopAndRemove(
+        directory,
+        client,
+        sessionID,
+        state,
+        job,
+        "until_reached",
+        `Loop stopped by --until: ${job.until}`,
+      )
+    }
+
+    if (job.preflightCommand) {
+      if (job.safe && dangerousShell(job.preflightCommand)) {
+        if (runNowRequested) delete job.runNowRequestedAt
+        job.paused = true
+        await writeState(directory, sessionID, state)
+        await notifyJob(directory, job, "preflight_blocked")
+        await toast(client, "Preflight blocked in safe mode and loop paused: " + job.preflightCommand, "error")
+        await reschedule(directory, client, sessionID)
+        return { admitted: false, reason: "preflight_blocked" }
+      }
+
+      const preflight = await runShellCommand(job.preflightCommand, directory, job.timeoutMs || 300_000)
+      await appendLoopLog(directory, "preflight", {
+        sessionID,
+        job: job.name || job.id,
+        command: job.preflightCommand,
+        code: preflight.code,
+      })
+      if (preflight.code !== 0) {
+        if (runNowRequested) delete job.runNowRequestedAt
+        job.paused = true
+        job.failureCount = (job.failureCount || 0) + 1
+        job.lastPreflightFailure = (job.preflightCommand + "\nexit=" + preflight.code + "\n" + preflight.stdout + "\n" + preflight.stderr).slice(0, 4000)
+        state.jobs = (state.jobs || []).map((candidate) => candidate.id === job.id ? job : candidate)
+        await writeState(directory, sessionID, state)
+        await notifyJob(directory, job, "preflight_failed")
+        await toast(client, "Preflight failed and loop paused: " + job.preflightCommand, "warning")
+        await reschedule(directory, client, sessionID)
+        return { admitted: false, reason: "preflight_failed" }
+      }
+    }
+
+    return { admitted: true, job, runNowRequested }
+  }
+
+  return { dueJobs, admitJob }
+}

package/src/source/runtime/run-finalization.js

@@ -0,0 +1,100 @@
+import { now as defaultNow } from "../core/args.js"
+import { isGoalJob } from "../core/jobs.js"
+import { writeState as defaultWriteState } from "../core/state.js"
+import { appendLoopLog as defaultAppendLoopLog, runShellCommand as defaultRunShellCommand, notifyJob as defaultNotifyJob } from "../core/process.js"
+import { toast as defaultToast } from "../opencode/host.js"
+import { writeGoalReport as defaultWriteGoalReport } from "./goal-runtime.js"
+import { dangerousShell as defaultDangerousShell } from "./job-workspace.js"
+
+function requireFunction(value, label) {
+  if (typeof value !== "function") throw new TypeError(`createRunFinalizationRuntime requires ${label}`)
+  return value
+}
+
+export function createRunFinalizationRuntime(options = {}) {
+  const runGoalChecks = requireFunction(options.runGoalChecks, "runGoalChecks")
+  const applyGoalNoProgressGuard = requireFunction(options.applyGoalNoProgressGuard, "applyGoalNoProgressGuard")
+  const createCheckpoint = requireFunction(options.createCheckpoint, "createCheckpoint")
+  const scheduleDueWork = requireFunction(options.scheduleDueWork, "scheduleDueWork")
+
+  const now = typeof options.now === "function" ? options.now : defaultNow
+  const writeState = typeof options.writeState === "function" ? options.writeState : defaultWriteState
+  const appendLoopLog = typeof options.appendLoopLog === "function" ? options.appendLoopLog : defaultAppendLoopLog
+  const runShellCommand = typeof options.runShellCommand === "function" ? options.runShellCommand : defaultRunShellCommand
+  const notifyJob = typeof options.notifyJob === "function" ? options.notifyJob : defaultNotifyJob
+  const toast = typeof options.toast === "function" ? options.toast : defaultToast
+  const writeGoalReport = typeof options.writeGoalReport === "function" ? options.writeGoalReport : defaultWriteGoalReport
+  const dangerousShell = typeof options.dangerousShell === "function" ? options.dangerousShell : defaultDangerousShell
+
+  async function finalizeJob(directory, client, sessionID, state, job, previousJob) {
+    if (job.verifyCommand) {
+      const verify = await runShellCommand(job.verifyCommand, directory, job.timeoutMs || 300_000)
+      job.lastVerifyAt = now()
+      job.lastVerifyCode = verify.code
+      if (verify.code === 0) {
+        job.failureCount = 0
+        job.lastVerifyFailure = ""
+        await toast(client, "Loop verify passed: " + job.verifyCommand, "success")
+      } else {
+        job.failureCount = (job.failureCount || 0) + 1
+        job.lastVerifyFailure = (job.verifyCommand + "\nexit=" + verify.code + "\n" + verify.stdout + "\n" + verify.stderr).slice(0, 4000)
+        await toast(client, "Loop verify failed: " + job.verifyCommand, "warning")
+        if (job.pauseOnVerifyFail || (job.maxFailures > 0 && job.failureCount >= job.maxFailures)) {
+          job.paused = true
+          await notifyJob(directory, job, "verify_failed")
+        }
+      }
+      await appendLoopLog(directory, "verify", {
+        sessionID,
+        job: job.name || job.id,
+        command: job.verifyCommand,
+        code: verify.code,
+        failures: job.failureCount || 0,
+      })
+    }
+
+    if (job.postrunCommand) {
+      if (job.safe && dangerousShell(job.postrunCommand)) {
+        await appendLoopLog(directory, "postrun-blocked", {
+          sessionID,
+          job: job.name || job.id,
+          command: job.postrunCommand,
+        })
+      } else {
+        const postrun = await runShellCommand(job.postrunCommand, directory, job.timeoutMs || 300_000)
+        job.lastPostrunCode = postrun.code
+        job.lastPostrunAt = now()
+        if (postrun.code !== 0) {
+          job.failureCount = (job.failureCount || 0) + 1
+          job.lastPostrunFailure = (job.postrunCommand + "\nexit=" + postrun.code + "\n" + postrun.stdout + "\n" + postrun.stderr).slice(0, 4000)
+          if (job.maxFailures > 0 && job.failureCount >= job.maxFailures) {
+            job.paused = true
+            await notifyJob(directory, job, "postrun_failed")
+          }
+        }
+        await appendLoopLog(directory, "postrun", {
+          sessionID,
+          job: job.name || job.id,
+          command: job.postrunCommand,
+          code: postrun.code,
+        })
+      }
+    }
+
+    if (isGoalJob(job)) {
+      job = await runGoalChecks(directory, sessionID, job, client)
+      job = await applyGoalNoProgressGuard(directory, client, sessionID, job, previousJob)
+    }
+
+    state.jobs = (state.jobs || [])
+      .map((candidate) => candidate.id === job.id ? job : candidate)
+      .filter((candidate) => candidate.enabled !== false || isGoalJob(candidate))
+    await writeState(directory, sessionID, state)
+    if (isGoalJob(job)) await writeGoalReport(directory, sessionID, job)
+    await createCheckpoint(directory, sessionID, job, client)
+    await scheduleDueWork(directory, client, sessionID)
+    return job
+  }
+
+  return { finalizeJob }
+}