@bybrawe/opencode-loop 0.5.28 → 0.5.29

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

@@ -0,0 +1,231 @@
+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"
+
+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 function pickGoalJob(state, target = "") {
+  const goals = (state.jobs || []).filter(isGoalJob)
+  if (!goals.length) return undefined
+  const text = String(target || "").trim()
+  if (!text || ["active", "current", "goal"].includes(text.toLowerCase())) return goals.find((job) => job.goalStatus === "active" && job.enabled !== false) || goals[0]
+  return goals.find((job, index) => matchJob(job, text, index))
+}
+
+export function parseGoalToolText(args, fields) {
+  const result = {}
+  for (const field of fields) result[field] = String(args?.[field] || "").trim()
+  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
+  job.goalCompletionRejectedCount = (job.goalCompletionRejectedCount || 0) + 1
+  state.jobs = (state.jobs || []).map((candidate) => candidate.id === job.id ? job : candidate)
+  await writeState(directory, sessionID, state)
+  await writeGoalReport(directory, sessionID, job)
+  await appendLoopLog(directory, "goal-complete-rejected", { sessionID, job: job.name || job.id, reason })
+  return { ok: false, job, rejected: true, message: `Goal completion rejected: ${reason}` }
+}
+
+export async function setGoalComplete(directory, sessionID, args = {}) {
+  const state = await readState(directory, sessionID)
+  const job = pickGoalJob(state, args.target)
+  if (!job) return { ok: false, message: "No active experimental goal was found." }
+  const parsed = parseGoalToolText(args, ["summary", "evidence"])
+  const manualOverride = args.manual === true || args.manualOverride === true
+  const completionEvidence = parsed.evidence || job.goalEvidence || ""
+  const skipEvidenceGate = manualOverride || args.allowWeakEvidence === true || job.goalRequireEvidence === false
+  const skipCheckGate = manualOverride || args.allowFailingChecks === true || job.goalRequireChecksPass === false
+  if (!skipEvidenceGate && !hasConcreteGoalEvidence(completionEvidence)) {
+    return await rejectGoalCompletion(directory, sessionID, state, job, "concrete evidence is required before the goal tool can complete the goal")
+  }
+  if (!skipCheckGate && goalRequiresPassingChecks(job) && !goalChecksPassed(job)) {
+    return await rejectGoalCompletion(directory, sessionID, state, job, "configured goal checks have not passed yet")
+  }
+  job.goalStatus = "completed"
+  job.enabled = false
+  job.paused = true
+  job.goalCompletedAt = now()
+  job.goalSummary = parsed.summary || job.goalSummary || "Goal completed."
+  job.goalEvidence = completionEvidence || "No evidence provided."
+  job.noProgressCount = 0
+  state.jobs = (state.jobs || []).map((candidate) => candidate.id === job.id ? job : candidate)
+  await writeState(directory, sessionID, state)
+  await writeGoalReport(directory, sessionID, job)
+  await appendLoopLog(directory, "goal-complete", { sessionID, job: job.name || job.id, summary: job.goalSummary })
+  return { ok: true, job, message: `Goal completed: ${job.goalSummary}` }
+}
+
+export async function setGoalBlocked(directory, sessionID, args = {}) {
+  const state = await readState(directory, sessionID)
+  const job = pickGoalJob(state, args.target)
+  if (!job) return { ok: false, message: "No active experimental goal was found." }
+  const parsed = parseGoalToolText(args, ["reason", "needed", "evidence"])
+  job.goalStatus = "blocked"
+  job.enabled = false
+  job.paused = true
+  job.goalBlockedAt = now()
+  job.goalBlockedReason = [parsed.reason, parsed.needed ? `Needed: ${parsed.needed}` : ""].filter(Boolean).join("\n") || "Goal blocked."
+  if (parsed.evidence) job.goalEvidence = parsed.evidence
+  state.jobs = (state.jobs || []).map((candidate) => candidate.id === job.id ? job : candidate)
+  await writeState(directory, sessionID, state)
+  await writeGoalReport(directory, sessionID, job)
+  await appendLoopLog(directory, "goal-blocked", { sessionID, job: job.name || job.id, reason: job.goalBlockedReason })
+  return { ok: true, job, message: `Goal blocked: ${job.goalBlockedReason}` }
+}
+
+export async function setGoalProgress(directory, sessionID, args = {}) {
+  const state = await readState(directory, sessionID)
+  const job = pickGoalJob(state, args.target)
+  if (!job) return { ok: false, message: "No active experimental goal was found." }
+  const parsed = parseGoalToolText(args, ["summary", "next", "evidence"])
+  const item = { time: new Date().toISOString(), summary: parsed.summary || "Progress recorded.", next: parsed.next || "", evidence: parsed.evidence || "" }
+  job.goalProgress = [...(job.goalProgress || []), item].slice(-30)
+  if (parsed.evidence) job.goalEvidence = parsed.evidence
+  job.noProgressCount = 0
+  job.lastProgressAt = now()
+  state.jobs = (state.jobs || []).map((candidate) => candidate.id === job.id ? job : candidate)
+  await writeState(directory, sessionID, state)
+  await writeGoalReport(directory, sessionID, job)
+  await appendLoopLog(directory, "goal-progress", { sessionID, job: job.name || job.id, summary: item.summary })
+  return { ok: true, job, message: `Goal progress recorded: ${item.summary}` }
+}

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

@@ -0,0 +1,198 @@
+import { now as defaultNow } from "../core/args.js"
+import { isGoalJob } from "../core/jobs.js"
+import { readState as defaultReadState } from "../core/state.js"
+import { appendLoopLog as defaultAppendLoopLog } from "../core/process.js"
+import { fireSdk as defaultFireSdk } from "../opencode/host.js"
+
+const DEFAULT_STEERING_SUPPRESSION_MS = 5 * 60_000
+const DEFAULT_SEEN_USER_MESSAGE_MS = 10 * 60_000
+
+function requireFunction(value, label) {
+  if (typeof value !== "function") throw new TypeError(`createGoalSteeringRuntime requires ${label}`)
+  return value
+}
+
+function messageInfo(event) {
+  if (!["message.updated", "message.created"].includes(String(event?.type || ""))) return undefined
+  const props = event?.properties || {}
+  return props.info || props.message || props
+}
+
+function userMessageFromEvent(event) {
+  const info = messageInfo(event)
+  if (!info || info.role !== "user") return undefined
+  const props = event?.properties || {}
+  const sessionID = info.sessionID || props.sessionID
+  if (typeof sessionID !== "string" || !sessionID) return undefined
+  const messageID = typeof (info.id || props.messageID) === "string" ? (info.id || props.messageID) : ""
+  return { sessionID, messageID }
+}
+
+function assistantMessageFromEvent(event) {
+  const info = messageInfo(event)
+  if (!info || info.role !== "assistant") return undefined
+  const props = event?.properties || {}
+  const sessionID = info.sessionID || props.sessionID
+  if (typeof sessionID !== "string" || !sessionID) return undefined
+  const parentID = typeof (info.parentID || props.parentID) === "string" ? (info.parentID || props.parentID) : ""
+  const createdAt = Number(info?.time?.created || 0)
+  return { sessionID, parentID, createdAt: Number.isFinite(createdAt) ? createdAt : 0 }
+}
+
+function activeGoalJobs(state) {
+  return (state?.jobs || []).filter((job) => {
+    if (!isGoalJob(job)) return false
+    if (job.paused || job.enabled === false) return false
+    return !["completed", "blocked", "cleared"].includes(job.goalStatus)
+  })
+}
+
+export function createGoalSteeringRuntime(options = {}) {
+  const getActiveRun = requireFunction(options.getActiveRun, "getActiveRun")
+  const clearActiveRun = requireFunction(options.clearActiveRun, "clearActiveRun")
+  const isLoopOwnedUserMessage = typeof options.isLoopOwnedUserMessage === "function" ? options.isLoopOwnedUserMessage : () => false
+  const readState = typeof options.readState === "function" ? options.readState : defaultReadState
+  const appendLoopLog = typeof options.appendLoopLog === "function" ? options.appendLoopLog : defaultAppendLoopLog
+  const fireSdk = typeof options.fireSdk === "function" ? options.fireSdk : defaultFireSdk
+  const now = typeof options.now === "function" ? options.now : defaultNow
+  const suppressionMs = Number.isFinite(Number(options.suppressionMs)) && Number(options.suppressionMs) > 0
+    ? Number(options.suppressionMs)
+    : DEFAULT_STEERING_SUPPRESSION_MS
+  const seenUserMessageMs = Number.isFinite(Number(options.seenUserMessageMs)) && Number(options.seenUserMessageMs) > 0
+    ? Number(options.seenUserMessageMs)
+    : DEFAULT_SEEN_USER_MESSAGE_MS
+
+  const pendingSteering = new Map()
+  const seenUserMessages = new Map()
+
+  function pendingForSession(sessionID) {
+    const entry = pendingSteering.get(sessionID)
+    if (!entry) return undefined
+    if (entry.expiresAt <= now()) {
+      pendingSteering.delete(sessionID)
+      return undefined
+    }
+    return entry
+  }
+
+  function shouldSuppressIdle(sessionID) {
+    return Boolean(pendingForSession(sessionID))
+  }
+
+  function seenKey(sessionID, messageID) {
+    return messageID ? `${sessionID}\u0000${messageID}` : ""
+  }
+
+  function alreadyHandled(sessionID, messageID) {
+    const key = seenKey(sessionID, messageID)
+    if (!key) return false
+    const expiresAt = seenUserMessages.get(key)
+    if (!expiresAt) return false
+    if (expiresAt <= now()) {
+      seenUserMessages.delete(key)
+      return false
+    }
+    return true
+  }
+
+  function rememberHandled(sessionID, messageID) {
+    const key = seenKey(sessionID, messageID)
+    if (!key) return
+    const current = now()
+    seenUserMessages.set(key, current + seenUserMessageMs)
+    for (const [candidate, expiresAt] of seenUserMessages.entries()) {
+      if (expiresAt <= current) seenUserMessages.delete(candidate)
+    }
+  }
+
+  function observeAssistantMessage(event) {
+    const assistant = assistantMessageFromEvent(event)
+    if (!assistant) return false
+    const entry = pendingForSession(assistant.sessionID)
+    if (!entry) return false
+    const matchesMessage = entry.messageID && assistant.parentID === entry.messageID
+    const matchesFallback = !entry.messageID && (!assistant.createdAt || assistant.createdAt >= entry.armedAt)
+    if (!matchesMessage && !matchesFallback) return false
+    pendingSteering.delete(assistant.sessionID)
+    return true
+  }
+
+  async function handleUserMessage(directory, client, user) {
+    const sessionID = typeof user?.sessionID === "string" ? user.sessionID : ""
+    const messageID = typeof user?.messageID === "string" ? user.messageID : ""
+    if (!sessionID) return undefined
+    if (alreadyHandled(sessionID, messageID)) return { handled: false, duplicate: true, sessionID, messageID }
+    rememberHandled(sessionID, messageID)
+
+    if (isLoopOwnedUserMessage(sessionID, messageID)) {
+      return { handled: false, loopOwned: true, sessionID, messageID }
+    }
+
+    const state = await readState(directory, sessionID)
+    const goals = activeGoalJobs(state)
+    if (!goals.length) return { handled: false, sessionID, messageID }
+
+    const active = getActiveRun(sessionID)
+    const activeGoalIDs = new Set(goals.map((goal) => goal.id))
+    const canPreempt = active && activeGoalIDs.has(active.jobId) && isGoalJob(active.job) && typeof client?.session?.abort === "function"
+    let preempted = false
+    let abortError = ""
+
+    if (canPreempt) {
+      pendingSteering.set(sessionID, {
+        messageID,
+        goalID: active.jobId,
+        armedAt: now(),
+        expiresAt: now() + suppressionMs,
+      })
+      try {
+        await fireSdk(
+          client,
+          "session.abort",
+          client.session.abort.bind(client.session),
+          { path: { id: sessionID }, body: {} },
+          { path: { sessionID }, body: {} },
+          { sessionID },
+        )
+        clearActiveRun(sessionID)
+        preempted = true
+      } catch (error) {
+        pendingSteering.delete(sessionID)
+        abortError = error instanceof Error ? error.message : String(error)
+      }
+    }
+
+    await appendLoopLog(directory, "goal-user-steering", {
+      sessionID,
+      messageID,
+      goals: goals.length,
+      preempted,
+      ...(abortError ? { abortError } : {}),
+    })
+
+    return { handled: true, preempted, sessionID, messageID }
+  }
+
+  async function handleEvent(directory, client, event) {
+    observeAssistantMessage(event)
+    const user = userMessageFromEvent(event)
+    if (!user) return undefined
+    return await handleUserMessage(directory, client, user)
+  }
+
+  function clearSession(sessionID) {
+    pendingSteering.delete(sessionID)
+    const prefix = `${sessionID}\u0000`
+    for (const key of seenUserMessages.keys()) if (key.startsWith(prefix)) seenUserMessages.delete(key)
+  }
+
+  return {
+    handleUserMessage,
+    handleEvent,
+    observeAssistantMessage,
+    shouldSuppressIdle,
+    hasPendingSteering: shouldSuppressIdle,
+    pendingForSession,
+    clearSession,
+  }
+}

package/src/source/runtime/job-workspace.js

@@ -0,0 +1,148 @@
+import { promises as fs } from "node:fs"
+import path from "node:path"
+import { safeID } from "../core/args.js"
+import { decoratePrompt, isGoalJob } from "../core/jobs.js"
+import { stateDir, ensureDir } from "../core/state.js"
+import { appendLoopLog as defaultAppendLoopLog, readSmallTextFile as defaultReadSmallTextFile, runProcess as defaultRunProcess } from "../core/process.js"
+import { buildGoalPrompt as defaultBuildGoalPrompt } from "./goal-runtime.js"
+
+const MAX_SCAN_FILES = 200
+const MAX_SCAN_BYTES = 2_000_000
+
+function requireFunction(value, name) {
+  if (typeof value !== "function") throw new TypeError(`createJobWorkspaceRuntime requires ${name}`)
+  return value
+}
+
+export function dangerousShell(command) {
+  const text = String(command || "").toLowerCase()
+  return [
+    /\brm\b(?=[^\r\n]*\s-{1,2}(?:[a-z]*r[a-z]*|recursive)\b)(?=[^\r\n]*\s-{1,2}(?:[a-z]*f[a-z]*|force)\b)/,
+    /\bremove-item\b[^\r\n]*(?:-recurse|-force)/,
+    /\bgit\s+reset\b/,
+    /\bgit\s+clean\b/,
+    /\bgit\s+push\b/,
+    /\bdel\b[^\r\n]*\s\/s\b/,
+    /\b(?:rmdir|rd)\b[^\r\n]*\s\/s\b/,
+    /(?:^|[;&|]\s*)format(?:\.com)?\s+(?:[a-z]:|\/(?:fs|q)\b)/,
+    /\bterraform\s+destroy\b/,
+    /\bkubectl\s+delete\b/,
+    /\bdeploy\b.*\bproduction\b/,
+  ].some((pattern) => pattern.test(text))
+}
+
+export function createJobWorkspaceRuntime(options = {}) {
+  const toast = requireFunction(options.toast, "toast")
+  const runProcess = typeof options.runProcess === "function" ? options.runProcess : defaultRunProcess
+  const appendLoopLog = typeof options.appendLoopLog === "function" ? options.appendLoopLog : defaultAppendLoopLog
+  const readSmallTextFile = typeof options.readSmallTextFile === "function" ? options.readSmallTextFile : defaultReadSmallTextFile
+  const buildGoalPrompt = typeof options.buildGoalPrompt === "function" ? options.buildGoalPrompt : defaultBuildGoalPrompt
+
+  async function buildPrompt(directory, job) {
+    if (isGoalJob(job)) return await buildGoalPrompt(directory, job)
+    const sections = []
+    if (job.promptFile) {
+      const text = await readSmallTextFile(path.resolve(directory, job.promptFile))
+      if (text.trim()) sections.push(`Instructions from ${job.promptFile}:\n${text.trim()}`)
+      else sections.push(`Prompt file ${job.promptFile} was requested but could not be read. Continue from the regular action instead.`)
+    }
+    if (job.action) sections.push(decoratePrompt(job))
+    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 sections.join("\n\n---\n\n") || decoratePrompt(job)
+  }
+
+  async function ensureBranch(directory, job, client, sessionID) {
+    if (!job.branch || job.branchDone) return job
+    const branch = safeID(job.branch)
+    const inRepo = await runProcess("git", ["rev-parse", "--is-inside-work-tree"], directory, 10_000)
+    if (inRepo.code !== 0) { job.branchDone = true; return job }
+    let result = await runProcess("git", ["switch", branch], directory, 30_000)
+    if (result.code !== 0) result = await runProcess("git", ["switch", "-c", branch], directory, 30_000)
+    job.branchDone = true
+    await toast(client, result.code === 0 ? `Loop branch active: ${branch}` : `Could not switch/create branch: ${branch}`, result.code === 0 ? "success" : "warning")
+    await appendLoopLog(directory, "branch", { sessionID, branch, code: result.code })
+    return job
+  }
+
+  async function snapshotPaths(directory, files) {
+    const snapshot = {}
+    for (const file of files || []) {
+      try {
+        const stat = await fs.stat(path.resolve(directory, file))
+        snapshot[file] = `${stat.mtimeMs}:${stat.size}`
+      } catch { snapshot[file] = "missing" }
+    }
+    return snapshot
+  }
+
+  async function watchChanged(directory, job) {
+    if (!job.watchPaths?.length) return false
+    const next = await snapshotPaths(directory, job.watchPaths)
+    const previous = job.watchSnapshot || {}
+    const changed = job.watchPaths.some((file) => previous[file] !== next[file])
+    if (changed) job.watchSnapshot = next
+    return changed
+  }
+
+  async function fileContains(filePath, needle) {
+    try {
+      const stat = await fs.stat(filePath)
+      if (!stat.isFile() || stat.size > MAX_SCAN_BYTES) return false
+      return (await fs.readFile(filePath, "utf8")).includes(needle)
+    } catch { return false }
+  }
+
+  async function untilReached(directory, job) {
+    if (!job.until) return false
+    const files = ["progress.md", "PROGRESS.md", "todo.md", "TODO.md", "todolist.md", "TODOLIST.md", path.join(".opencode", "opencode-loop", "until.txt")]
+    for (const file of files) if (await fileContains(path.resolve(directory, file), job.until)) return true
+    let scanned = 0
+    async function walk(current) {
+      if (scanned >= MAX_SCAN_FILES) return false
+      let entries
+      try { entries = await fs.readdir(current, { withFileTypes: true }) } catch { return false }
+      for (const entry of entries) {
+        if (scanned >= MAX_SCAN_FILES) return false
+        if ([".git", "node_modules", "dist", "build", ".next", "coverage"].includes(entry.name)) continue
+        const full = path.join(current, entry.name)
+        if (entry.isDirectory()) { if (await walk(full)) return true }
+        else if (entry.isFile() && /\.(md|txt|json|yaml|yml)$/i.test(entry.name)) { scanned++; if (await fileContains(full, job.until)) return true }
+      }
+      return false
+    }
+    return await walk(directory)
+  }
+
+  async function createCheckpoint(directory, sessionID, job, client) {
+    if (!job.checkpointOnly && !job.gitCheckpoint) return
+    const inRepo = await runProcess("git", ["rev-parse", "--is-inside-work-tree"], directory, 10_000)
+    if (inRepo.code !== 0) return
+    const status = await runProcess("git", ["status", "--short"], directory, 30_000)
+    if (!status.stdout.trim()) return
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-")
+    const checkpointDir = path.join(stateDir(directory), "checkpoints", safeID(sessionID))
+    await ensureDir(checkpointDir)
+    const diff = await runProcess("git", ["diff", "--binary"], directory, 120_000)
+    const staged = await runProcess("git", ["diff", "--cached", "--binary"], directory, 120_000)
+    const prefix = `${timestamp}-${safeID(job.name || job.id)}`
+    await fs.writeFile(path.join(checkpointDir, `${prefix}.status.txt`), status.stdout + status.stderr)
+    await fs.writeFile(path.join(checkpointDir, `${prefix}.patch`), `${diff.stdout}\n${staged.stdout}`)
+    if (job.gitCheckpoint) {
+      await runProcess("git", ["add", "-A"], directory, 120_000)
+      await runProcess("git", ["commit", "-m", `chore: opencode loop checkpoint ${timestamp}`], directory, 120_000)
+    }
+    await toast(client, `Loop checkpoint saved: ${prefix}`, "success")
+  }
+
+  return {
+    buildPrompt,
+    ensureBranch,
+    snapshotPaths,
+    watchChanged,
+    untilReached,
+    createCheckpoint,
+  }
+}