@bybrawe/opencode-loop 0.5.32 → 0.5.34

package/src/index.js

@@ -1021,6 +1021,27 @@ function commandArgsText(args) {
   return String(args);
 }
 
+// src/source/core/continuation.js
+var CONTINUATION_SHORTHANDS = new Set([
+  "continue",
+  "continue.",
+  "continue working",
+  "keep going",
+  "go on",
+  "devam",
+  "devam et",
+  "devam et.",
+  "devam et bakal\u0131m"
+]);
+function isContinuationShorthand(value) {
+  return CONTINUATION_SHORTHANDS.has(String(value || "").trim().toLowerCase().replace(/\s+/g, " "));
+}
+function continuationProjectInstruction(value) {
+  if (!isContinuationShorthand(value))
+    return "";
+  return "Treat this as continuation of the current project and conversation, not a fresh task. Inspect the repository state, relevant files, TODO/progress notes, recent changes, and git status as needed to identify the next unfinished step. Continue from existing work, do not redo completed work, and verify meaningful changes when practical.";
+}
+
 // src/source/core/jobs.js
 function presetDefaults(name) {
   if (name === "loop-compact")
@@ -1086,6 +1107,9 @@ function actionKind(action, job = {}) {
 }
 function decoratePrompt(job) {
   const additions = [];
+  const continuation = continuationProjectInstruction(job.action);
+  if (continuation)
+    additions.push(continuation);
   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)
@@ -1231,91 +1255,10 @@ function createCommandRouter(options = {}) {
   };
 }
 
-// src/source/runtime/goal-runtime.js
+// src/source/runtime/goal-report.js
 import { promises as fs3 } from "fs";
 import path3 from "path";
 var GOAL_REPORT_DIR = "goals";
-var GOAL_PROMPT_PREFIX = "EXPERIMENTAL OPENCODE GOAL MODE ITERATION";
-async function buildGoalPrompt(directory, job) {
-  const sections = [];
-  sections.push(`Working directory:
-${path3.resolve(directory)}
-Keep 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:
-${objective}`);
-  if (job.goalFile) {
-    const text = await readSmallTextFile(path3.resolve(directory, job.goalFile), 120000);
-    if (text.trim())
-      sections.push(`Goal file ${job.goalFile}:
-${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(path3.resolve(directory, job.promptFile), 120000);
-    if (text.trim())
-      sections.push(`Extra goal instructions from ${job.promptFile}:
-${text.trim()}`);
-  }
-  if (job.goalAcceptance?.length)
-    sections.push(`Acceptance criteria:
-` + job.goalAcceptance.map((item, index) => `${index + 1}. ${item}`).join(`
-`));
-  if (job.goalChecks?.length)
-    sections.push(`Verification commands that define useful evidence:
-` + job.goalChecks.map((item, index) => `${index + 1}. ${item}`).join(`
-`));
-  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:
-` + job.lastGoalChecks.map((item) => `- ${item.command}: exit ${item.code}`).join(`
-`));
-  if (job.lastVerifyFailure)
-    sections.push(`Previous verify/check failure summary:
-` + String(job.lastVerifyFailure).slice(0, 1600));
-  if (job.goalCompletionRejectedReason)
-    sections.push(`Previous completion attempt was rejected:
-${job.goalCompletionRejectedReason}`);
-  if ((job.maxNoProgress ?? DEFAULT_GOAL_MAX_NO_PROGRESS) > 0)
-    sections.push(`No-progress guard:
-${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:
-` + job.goalProgress.slice(-5).map((item) => `- ${item.time}: ${item.summary}`).join(`
-`));
-  for (const file of job.includeFiles || []) {
-    const text = await readSmallTextFile(path3.resolve(directory, file), 80000);
-    if (text.trim())
-      sections.push(`Context from ${file}:
-${text.trim().slice(0, 20000)}`);
-  }
-  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(`
-
----
-
-`)}`;
-}
 function goalReportPath(directory, sessionID, job) {
   return path3.join(stateDir(directory), GOAL_REPORT_DIR, `${safeID(sessionID)}-${safeID(job.name || job.id)}.md`);
 }
@@ -1375,21 +1318,8 @@ async function writeGoalReport(directory, sessionID, job) {
   await ensureDir(path3.dirname(target));
   await fs3.writeFile(target, goalReportText(job), "utf8");
 }
-function pickGoalJob(state, target = "") {
-  const goals = (state.jobs || []).filter(isGoalJob);
-  if (!goals.length)
-    return;
-  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));
-}
-function parseGoalToolText(args, fields) {
-  const result = {};
-  for (const field of fields)
-    result[field] = String(args?.[field] || "").trim();
-  return result;
-}
+
+// src/source/runtime/goal-evidence.js
 function hasConcreteGoalEvidence(value) {
   const text = String(value || "").trim();
   if (text.length < 24)
@@ -1432,6 +1362,107 @@ function goalMadeMeaningfulProgress(beforeJob, afterJob) {
     return true;
   return false;
 }
+
+// src/source/runtime/goal-prompt.js
+import path4 from "path";
+var GOAL_PROMPT_PREFIX = "EXPERIMENTAL OPENCODE GOAL MODE ITERATION";
+async function buildGoalPrompt(directory, job) {
+  const sections = [];
+  sections.push(`Working directory:
+${path4.resolve(directory)}
+Keep 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:
+${objective}`);
+  if (job.goalFile) {
+    const text = await readSmallTextFile(path4.resolve(directory, job.goalFile), 120000);
+    if (text.trim())
+      sections.push(`Goal file ${job.goalFile}:
+${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(path4.resolve(directory, job.promptFile), 120000);
+    if (text.trim())
+      sections.push(`Extra goal instructions from ${job.promptFile}:
+${text.trim()}`);
+  }
+  if (job.goalAcceptance?.length)
+    sections.push(`Acceptance criteria:
+` + job.goalAcceptance.map((item, index) => `${index + 1}. ${item}`).join(`
+`));
+  if (job.goalChecks?.length)
+    sections.push(`Verification commands that define useful evidence:
+` + job.goalChecks.map((item, index) => `${index + 1}. ${item}`).join(`
+`));
+  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:
+` + job.lastGoalChecks.map((item) => `- ${item.command}: exit ${item.code}`).join(`
+`));
+  if (job.lastVerifyFailure)
+    sections.push(`Previous verify/check failure summary:
+` + String(job.lastVerifyFailure).slice(0, 1600));
+  if (job.goalCompletionRejectedReason)
+    sections.push(`Previous completion attempt was rejected:
+${job.goalCompletionRejectedReason}`);
+  if ((job.maxNoProgress ?? DEFAULT_GOAL_MAX_NO_PROGRESS) > 0)
+    sections.push(`No-progress guard:
+${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:
+` + job.goalProgress.slice(-5).map((item) => `- ${item.time}: ${item.summary}`).join(`
+`));
+  for (const file of job.includeFiles || []) {
+    const text = await readSmallTextFile(path4.resolve(directory, file), 80000);
+    if (text.trim())
+      sections.push(`Context from ${file}:
+${text.trim().slice(0, 20000)}`);
+  }
+  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(`
+
+---
+
+`)}`;
+}
+
+// src/source/runtime/goal-runtime.js
+function pickGoalJob(state, target = "") {
+  const goals = (state.jobs || []).filter(isGoalJob);
+  if (!goals.length)
+    return;
+  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));
+}
+function parseGoalToolText(args, fields) {
+  const result = {};
+  for (const field of fields)
+    result[field] = String(args?.[field] || "").trim();
+  return result;
+}
 async function rejectGoalCompletion(directory, sessionID, state, job, reason) {
   job.goalCompletionRejectedAt = now();
   job.goalCompletionRejectedReason = reason;
@@ -1616,47 +1647,224 @@ function createGoalCommandHandlers(options = {}) {
 }
 
 // src/source/opencode/loop-commands.js
-import { promises as fs4 } from "fs";
-import path4 from "path";
-var SERVICE2 = "opencode-loop";
-var DEFAULT_PROGRESS_MD = `# Progress
-
-## Current Goal
-Describe the current project goal here.
-
-## Agent Rules
-- Do not ask questions unless truly blocked.
-- Make reasonable assumptions and continue.
-- Work on unfinished TODOs in order.
-- Mark completed TODOs with [x].
-- Add new bugs, ideas, and follow-up work as TODOs.
-- Run tests, lint, or build when available.
-- Do not run destructive commands, force pushes, production deploys, or database resets.
-
-## Active TODO
-- [ ] Review the project structure and pick the next safe improvement.
+import { promises as fs6 } from "fs";
+import path7 from "path";
 
-## Completed
-- [x] Created progress.md.
+// src/source/runtime/companion-goal.js
+import { promises as fs4 } from "fs";
+import path5 from "path";
+function goalRoot(directory) {
+  return path5.join(directory, ".opencode", "goals");
+}
+async function findDedicatedGoalForSession(directory, sessionID) {
+  if (!directory || !sessionID)
+    return;
+  let names;
+  try {
+    names = await fs4.readdir(goalRoot(directory));
+  } catch (error) {
+    if (error?.code === "ENOENT")
+      return;
+    return;
+  }
+  for (const name of names) {
+    if (!name.endsWith(".json"))
+      continue;
+    try {
+      const value = JSON.parse(await fs4.readFile(path5.join(goalRoot(directory), name), "utf8"));
+      if (value?.sessionID === sessionID)
+        return value;
+    } catch {}
+  }
+  return;
+}
+function dedicatedGoalOwnsContinuation(goal) {
+  return goal?.status === "active";
+}
+function dedicatedGoalSummary(goal) {
+  if (!goal)
+    return "not detected";
+  const id = String(goal.id || "unknown").slice(0, 12);
+  const status = String(goal.status || "unknown");
+  return `${status} (${id})`;
+}
 
-## Backlog Ideas
-- [ ] Add more project-specific tasks here.
+// src/source/runtime/loop-diagnostics.js
+import { promises as fs5 } from "fs";
+import path6 from "path";
 
-## Blocked
-- None.
-`;
-function requireFunction3(value, name) {
-  if (typeof value !== "function")
-    throw new TypeError(`createLoopCommandHandlers requires ${name}`);
-  return value;
+// src/source/runtime/schedule-policy.js
+var TERMINAL_GOAL_STATUSES = new Set(["completed", "blocked", "cleared"]);
+function inferredScheduleMode(job) {
+  const explicit = String(job?.scheduleMode || "").toLowerCase();
+  if (["idle", "interval", "once", "watch"].includes(explicit))
+    return explicit;
+  if (job?.watchPaths?.length)
+    return "watch";
+  if (Number(job?.maxRuns || 0) === 1 && job?.immediate === false && Number(job?.intervalMs || 0) > 0)
+    return "once";
+  return Number(job?.intervalMs || 0) === 0 ? "idle" : "interval";
+}
+function jobRunnable(job) {
+  if (!job)
+    return false;
+  if (isGoalJob(job) && TERMINAL_GOAL_STATUSES.has(job.goalStatus))
+    return false;
+  if (!job.enabled || job.paused)
+    return false;
+  if (Number(job.maxRuns || 0) > 0 && Number(job.runCount || 0) >= Number(job.maxRuns || 0))
+    return false;
+  return true;
 }
-function createLoopCommandHandlers(options = {}) {
-  const clearActiveRun = requireFunction3(options.clearActiveRun, "clearActiveRun");
-  const cancelDueWork = requireFunction3(options.cancelDueWork, "cancelDueWork");
-  const stopWatchdog = requireFunction3(options.stopWatchdog, "stopWatchdog");
-  const scheduleDueWork = requireFunction3(options.scheduleDueWork, "scheduleDueWork");
-  const maybeRunDueJobs = requireFunction3(options.maybeRunDueJobs, "maybeRunDueJobs");
-  const toast2 = requireFunction3(options.toast, "toast");
+function jobDueAt(job, current = Date.now()) {
+  if (!jobRunnable(job))
+    return Infinity;
+  if (Number(job.runNowRequestedAt || 0) > 0)
+    return current;
+  const created = Date.parse(job.createdAt || "");
+  if (Number(job.maxRuntimeMs || 0) > 0 && Number.isFinite(created) && current - created >= Number(job.maxRuntimeMs || 0))
+    return current;
+  if (job.watchPaths?.length)
+    return job.watchTriggered === true ? current : Infinity;
+  const intervalMs = Number(job.intervalMs || 0);
+  if (intervalMs === 0)
+    return current;
+  const lastRunAt = Number(job.lastRunAt || 0);
+  if (!lastRunAt) {
+    if (job.immediate === false)
+      return (Number.isFinite(created) ? created : current) + intervalMs;
+    return current;
+  }
+  return lastRunAt + intervalMs;
+}
+function jobIsDue(job, current = Date.now(), force = false) {
+  if (!jobRunnable(job))
+    return false;
+  if (force)
+    return true;
+  return jobDueAt(job, current) <= current;
+}
+function dueJobs(state, current = Date.now(), force = false) {
+  return (state?.jobs || []).filter((job) => jobIsDue(job, current, force)).sort((a, b) => Number(Number(b.runNowRequestedAt || 0) > 0) - Number(Number(a.runNowRequestedAt || 0) > 0));
+}
+function nextDueDelay(state, current = Date.now()) {
+  let soonest = Infinity;
+  for (const job of state?.jobs || [])
+    soonest = Math.min(soonest, jobDueAt(job, current));
+  if (!Number.isFinite(soonest))
+    return Infinity;
+  return Math.max(0, soonest - current);
+}
+function scheduleDescription(job) {
+  const mode = inferredScheduleMode(job);
+  const intervalMs = Number(job?.intervalMs || 0);
+  if (mode === "idle")
+    return "every idle";
+  if (mode === "watch")
+    return `on watch: ${(job.watchPaths || []).join(", ")}`;
+  if (mode === "once")
+    return intervalMs > 0 ? `once after ${durationToText(intervalMs)}` : "once on next idle";
+  if (job?.immediate === false)
+    return `every ${durationToText(intervalMs)}, first after ${durationToText(intervalMs)}`;
+  return `every ${durationToText(intervalMs)}, starts on next idle`;
+}
+function scheduleState(job, current = Date.now()) {
+  if (!job?.enabled)
+    return "stopped";
+  if (job?.paused)
+    return "paused";
+  if (Number(job?.runNowRequestedAt || 0) > 0)
+    return "due now; waiting for idle";
+  const mode = inferredScheduleMode(job);
+  const dueAt = jobDueAt(job, current);
+  if (!Number.isFinite(dueAt))
+    return mode === "watch" ? "waiting for watched change" : "not scheduled";
+  if (dueAt <= current)
+    return mode === "idle" ? "waiting for idle" : "due; waiting for idle";
+  return `due in ${durationToText(dueAt - current)}`;
+}
+
+// src/source/runtime/loop-diagnostics.js
+function describeJobScheduling(job, current = Date.now()) {
+  return {
+    schedule: scheduleDescription(job),
+    state: scheduleState(job, current)
+  };
+}
+async function listPersistedLoopSessions(directory, currentSessionID) {
+  const root = stateDir(directory);
+  let names;
+  try {
+    names = await fs5.readdir(root);
+  } catch (error) {
+    if (error?.code === "ENOENT")
+      return [];
+    return [];
+  }
+  const sessions = [];
+  for (const name of names) {
+    if (!name.endsWith(".json"))
+      continue;
+    const sessionID = name.slice(0, -5);
+    try {
+      const parsed = JSON.parse(await fs5.readFile(path6.join(root, name), "utf8"));
+      const jobs = Array.isArray(parsed?.jobs) ? parsed.jobs : [];
+      const enabled = jobs.filter((job) => job?.enabled !== false && !job?.paused).length;
+      const neverRan = jobs.filter((job) => Number(job?.runCount || 0) === 0).length;
+      sessions.push({
+        sessionID,
+        current: sessionID === currentSessionID,
+        jobs: jobs.length,
+        enabled,
+        neverRan
+      });
+    } catch {
+      sessions.push({ sessionID, current: sessionID === currentSessionID, jobs: 0, enabled: 0, neverRan: 0, corrupt: true });
+    }
+  }
+  return sessions.sort((a, b) => Number(b.current) - Number(a.current) || b.enabled - a.enabled || a.sessionID.localeCompare(b.sessionID));
+}
+
+// src/source/opencode/loop-commands.js
+var SERVICE2 = "opencode-loop";
+var DEFAULT_PROGRESS_MD = `# Progress
+
+## Current Goal
+Describe the current project goal here.
+
+## Agent Rules
+- Do not ask questions unless truly blocked.
+- Make reasonable assumptions and continue.
+- Work on unfinished TODOs in order.
+- Mark completed TODOs with [x].
+- Add new bugs, ideas, and follow-up work as TODOs.
+- Run tests, lint, or build when available.
+- Do not run destructive commands, force pushes, production deploys, or database resets.
+
+## Active TODO
+- [ ] Review the project structure and pick the next safe improvement.
+
+## Completed
+- [x] Created progress.md.
+
+## Backlog Ideas
+- [ ] Add more project-specific tasks here.
+
+## Blocked
+- None.
+`;
+function requireFunction3(value, name) {
+  if (typeof value !== "function")
+    throw new TypeError(`createLoopCommandHandlers requires ${name}`);
+  return value;
+}
+function createLoopCommandHandlers(options = {}) {
+  const clearActiveRun = requireFunction3(options.clearActiveRun, "clearActiveRun");
+  const cancelDueWork = requireFunction3(options.cancelDueWork, "cancelDueWork");
+  const stopWatchdog = requireFunction3(options.stopWatchdog, "stopWatchdog");
+  const scheduleDueWork = requireFunction3(options.scheduleDueWork, "scheduleDueWork");
+  const maybeRunDueJobs = requireFunction3(options.maybeRunDueJobs, "maybeRunDueJobs");
+  const toast2 = requireFunction3(options.toast, "toast");
   const say2 = requireFunction3(options.say, "say");
   const now2 = typeof options.now === "function" ? options.now : now;
   const readState2 = typeof options.readState === "function" ? options.readState : readState;
@@ -1664,8 +1872,10 @@ function createLoopCommandHandlers(options = {}) {
   const removeState2 = typeof options.removeState === "function" ? options.removeState : removeState;
   const pathExists2 = typeof options.pathExists === "function" ? options.pathExists : pathExists;
   const appendLoopLog2 = typeof options.appendLoopLog === "function" ? options.appendLoopLog : appendLoopLog;
-  const readFile = typeof options.readFile === "function" ? options.readFile : (...args) => fs4.readFile(...args);
-  const writeFile = typeof options.writeFile === "function" ? options.writeFile : (...args) => fs4.writeFile(...args);
+  const readFile = typeof options.readFile === "function" ? options.readFile : (...args) => fs6.readFile(...args);
+  const writeFile = typeof options.writeFile === "function" ? options.writeFile : (...args) => fs6.writeFile(...args);
+  const listPersistedLoopSessions2 = typeof options.listPersistedLoopSessions === "function" ? options.listPersistedLoopSessions : listPersistedLoopSessions;
+  const findDedicatedGoalForSession2 = typeof options.findDedicatedGoalForSession === "function" ? options.findDedicatedGoalForSession : findDedicatedGoalForSession;
   const runtimeVersion = options.runtimeVersion || process.version;
   const runtimePlatform = options.runtimePlatform || process.platform;
   async function stopLoop(directory, client, sessionID, args) {
@@ -1697,15 +1907,11 @@ function createLoopCommandHandlers(options = {}) {
   async function statusLoop(directory, client, sessionID) {
     const state = await readState2(directory, sessionID);
     const jobs = state.jobs || [];
+    const current = now2();
     const lines = jobs.length ? jobs.map((job, index) => {
-      const current = now2();
-      const intervalMs = Number(job.intervalMs || 0);
-      const lastRunAt = Number(job.lastRunAt || 0);
-      const createdAt = Date.parse(job.createdAt || "");
-      const dueAt = Number(job.runNowRequestedAt || 0) > 0 ? current : lastRunAt > 0 ? lastRunAt + intervalMs : job.immediate === false && Number.isFinite(createdAt) ? createdAt + intervalMs : current;
-      const dueIn = Math.max(0, dueAt - current);
+      const scheduling = describeJobScheduling(job, current);
       const flags = [isGoalJob(job) ? `goal:${goalStatusText(job)}` : undefined, job.paused ? "paused" : "active", Number(job.runNowRequestedAt || 0) > 0 ? "run-now" : undefined, job.safe ? "safe" : undefined, job.askNever ? "ask-never" : undefined, job.noOverlap ? "no-overlap" : undefined, job.checkpointOnly ? "checkpoint-only" : undefined, job.gitCheckpoint ? "git-checkpoint" : undefined].filter(Boolean).join(",");
-      return `${index + 1}. ${job.id}${job.name ? ` (${job.name})` : ""}: ${jobLabel(job)} | runs=${job.runCount || 0} | failures=${job.failureCount || 0} | due in ${durationToText(dueIn)} | ${flags}`;
+      return `${index + 1}. ${job.id}${job.name ? ` (${job.name})` : ""}: ${jobLabel(job)} | schedule=${scheduling.schedule} | state=${scheduling.state} | runs=${job.runCount || 0} | failures=${job.failureCount || 0} | ${flags}`;
     }) : ["No active loop jobs."];
     await toast2(client, jobs.length ? `${jobs.length} loop job(s).` : "No active loop jobs.", jobs.length ? "info" : "warning");
     await say2(client, sessionID, `OpenCode loop status:
@@ -1715,7 +1921,7 @@ function createLoopCommandHandlers(options = {}) {
   async function logsLoop(directory, client, sessionID) {
     let text = "No loop log found.";
     try {
-      text = (await readFile(path4.join(stateDir(directory), "loop.log"), "utf8")).trim().split(/\r?\n/).slice(-80).join(`
+      text = (await readFile(path7.join(stateDir(directory), "loop.log"), "utf8")).trim().split(/\r?\n/).slice(-80).join(`
 `) || text;
     } catch {}
     await say2(client, sessionID, `OpenCode loop logs:
@@ -1724,18 +1930,20 @@ function createLoopCommandHandlers(options = {}) {
   async function helpLoop(client, sessionID) {
     await say2(client, sessionID, [
       "OpenCode Loop help:",
-      "/loop 0s <prompt>                                Claude Code style auto-continue",
-      "/loop 5m --ask-never --safe <prompt>              interval autonomous prompt loop",
-      "/loop-command 200m /compact                       OpenCode slash-command loop, waits for idle",
-      "/loop-ask 1h did you run tests and tsc --noEmit?   scheduled question/check prompt",
-      "/loop-shell 10m npm test                           shell loop, waits for idle",
-      "/loop-goal finish the feature and keep tests green  experimental persistent goal mode",
-      '/loop-goal --check "npm run build" --check "npm test" --complete-when-checks-pass ship it',
-      "/loop-goal status | pause | resume | clear          manage experimental goals",
-      "/loop 200m --command /compact                     same as command loop",
-      '/loop 0s --verify "npm test" <prompt>            verify after each assistant turn',
-      "/loop 0s --prompt-file loop-prompt.md             load prompt from a file",
-      "/loop 0s --max-runtime 6h --max-failures 3 <task> stop safely after limits",
+      "/loop continue the project                           auto-continue forever whenever the session becomes idle",
+      "/loop idle continue the project                      explicit form of the same idle loop",
+      "/loop every 5m continue the project                  recurring timer; first run after 5m, always waits for idle",
+      "/loop after 5m continue the project                  one-shot delayed prompt; runs once when 5m has passed and session is idle",
+      "/loop 5m continue the project                        legacy compact form: starts on next idle, then every 5m",
+      "/loop 5m --no-now continue the project               legacy recurring form with first run delayed 5m",
+      "/loop-command 200m /compact                          OpenCode slash-command loop, waits for idle",
+      "/loop-ask 1h did you run tests and tsc --noEmit?      scheduled question/check prompt",
+      "/loop-shell 10m npm test                              shell loop, waits for idle",
+      "/loop-goal finish the feature and keep tests green    experimental persistent goal mode",
+      '/loop 0s --verify "npm test" <prompt>               verify after each assistant turn',
+      "/loop --prompt-file loop-prompt.md                    idle loop loading its prompt from a file",
+      "/loop 0s --max-runtime 6h --max-failures 3 <task>     stop safely after limits",
+      "Prompt-producing /loop jobs are blocked while dedicated /goal owns the same session; use another session or --allow-goal-overlap only intentionally.",
       "/loop-doctor | /loop-init | /loop-export"
     ].join(`
 `));
@@ -1760,22 +1968,36 @@ function createLoopCommandHandlers(options = {}) {
   }
   async function doctorLoop(directory, client, sessionID) {
     const state = await readState2(directory, sessionID);
-    await say2(client, sessionID, [
+    const persisted = await listPersistedLoopSessions2(directory, sessionID);
+    const otherSessions = persisted.filter((entry) => !entry.current && entry.enabled > 0);
+    const dedicatedGoal = await findDedicatedGoalForSession2(directory, sessionID);
+    const lines = [
       "OpenCode Loop doctor:",
       `- plugin: ${SERVICE2}`,
       `- project directory: ${directory}`,
       `- state directory: ${stateDir(directory)}`,
-      `- active jobs: ${(state.jobs || []).length}`,
+      `- current session: ${sessionID}`,
+      `- current-session jobs: ${(state.jobs || []).length}`,
+      `- dedicated /goal: ${dedicatedGoalSummary(dedicatedGoal)}`,
+      `- other persisted sessions with enabled jobs: ${otherSessions.length}`,
       `- node: ${runtimeVersion}`,
       `- platform: ${runtimePlatform}`,
-      "- smoke test: /loop 0s --max-runs 1 --dry-run continue from progress.md",
+      "- smoke test: /loop --max-runs 1 --dry-run continue from progress.md",
+      "- delayed smoke test: /loop after 5m --dry-run continue from progress.md",
+      "- recurring smoke test: /loop every 5m --dry-run continue from progress.md",
       "- experimental goal smoke test: /loop-goal --dry-run finish the current task and verify it"
-    ].join(`
+    ];
+    for (const entry of otherSessions.slice(0, 8)) {
+      lines.push(`- other session ${entry.sessionID}: jobs=${entry.jobs}, enabled=${entry.enabled}, never-ran=${entry.neverRan}`);
+    }
+    if (otherSessions.length > 8)
+      lines.push(`- ... ${otherSessions.length - 8} more persisted session(s)`);
+    await say2(client, sessionID, lines.join(`
 `));
   }
   async function initLoop(directory, client, sessionID, args) {
     const target = String(args || "").trim() || "progress.md";
-    const full = path4.resolve(directory, target);
+    const full = path7.resolve(directory, target);
     if (await pathExists2(full)) {
       await toast2(client, `${target} already exists.`, "warning");
       return;
@@ -1801,6 +2023,81 @@ function createLoopCommandHandlers(options = {}) {
   };
 }
 
+// src/source/core/schedule-syntax.js
+function removeBooleanFlag(input, flag) {
+  const pattern = new RegExp(`(^|\\s)${flag.replace(/[.*+?^${}()|[\\]\\]/g, "\\$&")}(?=\\s|$)`, "i");
+  const found = pattern.test(input);
+  return {
+    found,
+    value: String(input || "").replace(pattern, " ").replace(/\s+/g, " ").trim()
+  };
+}
+function firstToken(input) {
+  const match = String(input || "").trim().match(/^(\S+)(?:\s+([\s\S]*))?$/);
+  return match ? { token: match[1], rest: String(match[2] || "").trim() } : { token: "", rest: "" };
+}
+function inferredMode(intervalMs, maxRuns) {
+  if (Number(maxRuns || 0) === 1 && Number(intervalMs || 0) > 0)
+    return "once";
+  return Number(intervalMs || 0) === 0 ? "idle" : "interval";
+}
+function normalizeLoopScheduleArgs(raw, defaults = {}) {
+  const overlap = removeBooleanFlag(String(raw || "").trim(), "--allow-goal-overlap");
+  let input = overlap.value;
+  const nextDefaults = { ...defaults };
+  let scheduleMode = defaults.scheduleMode;
+  let scheduleSyntax = "legacy";
+  const first = firstToken(input);
+  const keyword = first.token.toLowerCase();
+  if (keyword === "idle") {
+    nextDefaults.intervalMs = 0;
+    nextDefaults.immediate = true;
+    scheduleMode = "idle";
+    scheduleSyntax = "idle";
+    input = first.rest;
+  } else if (keyword === "every" || keyword === "after" || keyword === "in") {
+    const duration = firstToken(first.rest);
+    const intervalMs = parseDuration(duration.token);
+    if (intervalMs === null) {
+      return {
+        ok: false,
+        error: `Invalid ${keyword} schedule. Example: /loop ${keyword === "every" ? "every" : "after"} 5m continue the project`
+      };
+    }
+    nextDefaults.intervalMs = intervalMs;
+    nextDefaults.immediate = false;
+    input = duration.rest;
+    if (keyword === "every") {
+      scheduleMode = intervalMs === 0 ? "idle" : "interval";
+      scheduleSyntax = "every";
+    } else {
+      nextDefaults.maxRuns = 1;
+      scheduleMode = "once";
+      scheduleSyntax = "after";
+    }
+  } else {
+    const duration = parseDuration(first.token);
+    if (duration !== null) {
+      scheduleMode = duration === 0 ? "idle" : "interval";
+    } else if (nextDefaults.intervalMs === undefined || nextDefaults.intervalMs === null) {
+      nextDefaults.intervalMs = 0;
+      nextDefaults.immediate = nextDefaults.immediate ?? true;
+      scheduleMode = "idle";
+      scheduleSyntax = "idle-shorthand";
+    } else {
+      scheduleMode = scheduleMode || inferredMode(nextDefaults.intervalMs, nextDefaults.maxRuns);
+    }
+  }
+  return {
+    ok: true,
+    args: input,
+    defaults: nextDefaults,
+    scheduleMode: scheduleMode || inferredMode(nextDefaults.intervalMs, nextDefaults.maxRuns),
+    scheduleSyntax,
+    allowGoalOverlap: overlap.found || defaults.allowGoalOverlap === true
+  };
+}
+
 // src/source/opencode/loop-registration.js
 var DEFAULT_GOAL_ACTIVE_RECOVERY_MS = 180000;
 var FALLBACK_ACTIVE_GUARD_MS = 45000;
@@ -1824,19 +2121,34 @@ function createLoopRegistration(options = {}) {
   const toast2 = requireFunction4(options.toast, "toast");
   const say2 = requireFunction4(options.say, "say");
   const parseLoopArgs2 = typeof options.parseLoopArgs === "function" ? options.parseLoopArgs : parseLoopArgs;
+  const normalizeLoopScheduleArgs2 = typeof options.normalizeLoopScheduleArgs === "function" ? options.normalizeLoopScheduleArgs : normalizeLoopScheduleArgs;
   const readState2 = typeof options.readState === "function" ? options.readState : readState;
   const writeState2 = typeof options.writeState === "function" ? options.writeState : writeState;
   const appendLoopLog2 = typeof options.appendLoopLog === "function" ? options.appendLoopLog : appendLoopLog;
   const normalizedModelRef2 = typeof options.normalizedModelRef === "function" ? options.normalizedModelRef : normalizedModelRef;
   const getSessionExecutionContext2 = typeof options.getSessionExecutionContext === "function" ? options.getSessionExecutionContext : getSessionExecutionContext;
+  const findDedicatedGoalForSession2 = typeof options.findDedicatedGoalForSession === "function" ? options.findDedicatedGoalForSession : findDedicatedGoalForSession;
   const configuredGuard = Number(options.defaultActiveGuardMs);
   const defaultActiveGuardMs = Number.isFinite(configuredGuard) && configuredGuard > 0 ? configuredGuard : FALLBACK_ACTIVE_GUARD_MS;
   async function addLoop(directory, client, sessionID, args, defaults = {}) {
-    const parsed = parseLoopArgs2(args, defaults);
+    const normalized = normalizeLoopScheduleArgs2(args, defaults);
+    if (!normalized.ok) {
+      await toast2(client, normalized.error, "warning");
+      return;
+    }
+    const parsed = parseLoopArgs2(normalized.args, normalized.defaults);
     if (!parsed.ok) {
       await toast2(client, parsed.error, "warning");
       return;
     }
+    parsed.job.scheduleMode = normalized.scheduleMode;
+    parsed.job.scheduleSyntax = normalized.scheduleSyntax;
+    parsed.job.allowGoalOverlap = normalized.allowGoalOverlap === true;
+    if (normalized.scheduleSyntax === "after") {
+      parsed.job.immediate = false;
+      parsed.job.maxRuns = 1;
+      parsed.job.lastRunAt = Date.parse(parsed.job.createdAt || "") || Date.now();
+    }
     const executionContext = getSessionExecutionContext2(sessionID) || { agent: "build" };
     parsed.job.agent = defaults.agent || executionContext.agent || "build";
     parsed.job.model = normalizedModelRef2(defaults.model) || executionContext.model;
@@ -1856,6 +2168,19 @@ function createLoopRegistration(options = {}) {
     if (!parsed.job.activeRecoveryMs) {
       parsed.job.activeRecoveryMs = isGoalJob(parsed.job) ? DEFAULT_GOAL_ACTIVE_RECOVERY_MS : Math.max(defaultActiveGuardMs, Math.min(90000, (parsed.job.intervalMs || 0) + 1e4));
     }
+    const promptProducing = actionKind(parsed.job.action, parsed.job) === "prompt";
+    if (promptProducing && !parsed.job.allowGoalOverlap) {
+      const dedicatedGoal = await findDedicatedGoalForSession2(directory, sessionID);
+      if (dedicatedGoalOwnsContinuation(dedicatedGoal)) {
+        await appendLoopLog2(directory, "goal-overlap-blocked", {
+          sessionID,
+          job: parsed.job.name || parsed.job.id,
+          goal: dedicatedGoal.id
+        });
+        await toast2(client, "Prompt loop not added: dedicated /goal already owns continuation in this session. Pause/finish the Goal, use another session, or pass --allow-goal-overlap intentionally.", "warning");
+        return;
+      }
+    }
     if (parsed.job.dryRun) {
       await toast2(client, `Loop dry run: ${jobLabel(parsed.job)}`, "info");
       await say2(client, sessionID, "OpenCode loop dry run:\n```json\n" + JSON.stringify(parsed.job, null, 2) + "\n```");
@@ -1883,7 +2208,13 @@ function createLoopRegistration(options = {}) {
     if (parsed.job.immediate)
       scheduleIdleWork(directory, client, sessionID);
     await toast2(client, `${replaced ? "Loop replaced" : "Loop added"}: ${jobLabel(parsed.job)}`, "success");
-    await appendLoopLog2(directory, replaced ? "replace" : "add", { sessionID, job: parsed.job.name || parsed.job.id, label: jobLabel(parsed.job) });
+    await appendLoopLog2(directory, replaced ? "replace" : "add", {
+      sessionID,
+      job: parsed.job.name || parsed.job.id,
+      label: jobLabel(parsed.job),
+      scheduleMode: parsed.job.scheduleMode,
+      scheduleSyntax: parsed.job.scheduleSyntax
+    });
   }
   return { addLoop };
 }
@@ -2000,6 +2331,37 @@ function clearSessionActivity(sessionID) {
   deleteSessionExecutionContext(sessionID);
 }
 
+// src/source/runtime/scheduler-diagnostics.js
+var DEFAULT_DEFERRAL_LOG_THROTTLE_MS = 30000;
+function createSchedulerDiagnostics(options = {}) {
+  const now2 = typeof options.now === "function" ? options.now : Date.now;
+  const appendLoopLog2 = typeof options.appendLoopLog === "function" ? options.appendLoopLog : async () => {};
+  const configured = Number(options.throttleMs);
+  const throttleMs = Number.isFinite(configured) && configured >= 0 ? configured : DEFAULT_DEFERRAL_LOG_THROTTLE_MS;
+  const lastLogged = new Map;
+  async function logDeferral(directory, sessionID, reason, extra = {}) {
+    const key = `${sessionID || "unknown"}:${reason || "deferred"}:${extra.source || "runtime"}`;
+    const current = now2();
+    const previous = Number(lastLogged.get(key) || 0);
+    if (previous > 0 && current - previous < throttleMs)
+      return false;
+    lastLogged.set(key, current);
+    await appendLoopLog2(directory, "deferred", {
+      sessionID,
+      reason,
+      ...extra
+    });
+    return true;
+  }
+  function clearSession(sessionID) {
+    const prefix = `${sessionID || "unknown"}:`;
+    for (const key of lastLogged.keys())
+      if (key.startsWith(prefix))
+        lastLogged.delete(key);
+  }
+  return { logDeferral, clearSession };
+}
+
 // src/source/runtime/scheduler.js
 var DEFAULT_IDLE_DEBOUNCE_MS = 1200;
 var DEFAULT_BUSY_RETRY_MS = 5000;
@@ -2007,37 +2369,6 @@ var DEFAULT_MIN_DUE_TIMER_MS = 250;
 var DEFAULT_MAX_DUE_TIMER_MS = 2147000000;
 var DEFAULT_HEARTBEAT_MS = 2500;
 var DEFAULT_SESSION_TTL_MS = 12 * 60 * 60 * 1000;
-function jobDueAt(job, current = now()) {
-  if (isGoalJob(job) && ["completed", "blocked", "cleared"].includes(job.goalStatus))
-    return Infinity;
-  if (!job.enabled || job.paused)
-    return Infinity;
-  if (job.maxRuns > 0 && (job.runCount || 0) >= job.maxRuns)
-    return Infinity;
-  if (Number(job.runNowRequestedAt || 0) > 0)
-    return current;
-  if (job.watchPaths?.length)
-    return Infinity;
-  const created = Date.parse(job.createdAt || "");
-  if (job.maxRuntimeMs > 0 && Number.isFinite(created) && current - created >= job.maxRuntimeMs)
-    return current;
-  if (job.intervalMs === 0)
-    return current;
-  if (!job.lastRunAt) {
-    if (job.immediate === false)
-      return (Number.isFinite(created) ? created : current) + (job.intervalMs || 0);
-    return current;
-  }
-  return job.lastRunAt + (job.intervalMs || 0);
-}
-function nextDueDelay(state, current = now()) {
-  let soonest = Infinity;
-  for (const job of state.jobs || [])
-    soonest = Math.min(soonest, jobDueAt(job, current));
-  if (!Number.isFinite(soonest))
-    return Infinity;
-  return Math.max(0, soonest - current);
-}
 function createSchedulerRuntime(options = {}) {
   const idleTimers = new Map;
   const dueTimers = new Map;
@@ -2065,6 +2396,7 @@ function createSchedulerRuntime(options = {}) {
     if (options.toast)
       await options.toast(client, message, level);
   };
+  const diagnostics = createSchedulerDiagnostics({ appendLoopLog: appendLog, now: clock, throttleMs: options.deferralLogThrottleMs });
   function stopHeartbeatIfIdle() {
     if (!knownSessions.size && heartbeatTimer) {
       clearIntervalFn(heartbeatTimer);
@@ -2112,11 +2444,13 @@ function createSchedulerRuntime(options = {}) {
       idleTimers.delete(sessionID);
       Promise.resolve().then(async () => {
         if (!await options.sessionIsIdle?.(client, sessionID, directory)) {
+          await diagnostics.logDeferral(directory, sessionID, "session-busy", { source: "idle", retryMs: busyRetryMs });
           await scheduleDueWork(directory, client, sessionID, busyRetryMs);
           return;
         }
         await options.finalizeActiveRun?.(directory, client, sessionID);
         if (!await options.sessionIsIdle?.(client, sessionID, directory)) {
+          await diagnostics.logDeferral(directory, sessionID, "session-busy-after-finalize", { source: "idle", retryMs: busyRetryMs });
           await scheduleDueWork(directory, client, sessionID, busyRetryMs);
           return;
         }
@@ -2165,11 +2499,13 @@ function createSchedulerRuntime(options = {}) {
       dueTimers.delete(sessionID);
       Promise.resolve().then(async () => {
         if (!await options.sessionIsIdle?.(client, sessionID, directory)) {
+          await diagnostics.logDeferral(directory, sessionID, "session-busy", { source: "due", retryMs: busyRetryMs });
           await scheduleDueWork(directory, client, sessionID, busyRetryMs);
           return;
         }
         await options.finalizeActiveRun?.(directory, client, sessionID);
         if (!await options.sessionIsIdle?.(client, sessionID, directory)) {
+          await diagnostics.logDeferral(directory, sessionID, "session-busy-after-finalize", { source: "due", retryMs: busyRetryMs });
           await scheduleDueWork(directory, client, sessionID, busyRetryMs);
           return;
         }
@@ -2189,6 +2525,7 @@ function createSchedulerRuntime(options = {}) {
     cancelIdleWork(sessionID);
     cancelDueWork(sessionID);
     stopWatchdog(sessionID);
+    diagnostics.clearSession(sessionID);
     knownSessions.delete(sessionID);
     stopHeartbeatIfIdle();
   }
@@ -2287,8 +2624,8 @@ ${item.output}`).join(`
 }
 
 // src/source/runtime/job-workspace.js
-import { promises as fs5 } from "fs";
-import path5 from "path";
+import { promises as fs7 } from "fs";
+import path8 from "path";
 var MAX_SCAN_FILES = 200;
 var MAX_SCAN_BYTES = 2000000;
 function requireFunction6(value, name) {
@@ -2323,7 +2660,7 @@ function createJobWorkspaceRuntime(options = {}) {
       return await buildGoalPrompt2(directory, job);
     const sections = [];
     if (job.promptFile) {
-      const text = await readSmallTextFile2(path5.resolve(directory, job.promptFile));
+      const text = await readSmallTextFile2(path8.resolve(directory, job.promptFile));
       if (text.trim())
         sections.push(`Instructions from ${job.promptFile}:
 ${text.trim()}`);
@@ -2333,7 +2670,7 @@ ${text.trim()}`);
     if (job.action)
       sections.push(decoratePrompt(job));
     for (const file of job.includeFiles || []) {
-      const text = await readSmallTextFile2(path5.resolve(directory, file), 80000);
+      const text = await readSmallTextFile2(path8.resolve(directory, file), 80000);
       if (text.trim())
         sections.push(`Context from ${file}:
 ${text.trim().slice(0, 20000)}`);
@@ -2365,7 +2702,7 @@ ${text.trim().slice(0, 20000)}`);
     const snapshot = {};
     for (const file of files || []) {
       try {
-        const stat = await fs5.stat(path5.resolve(directory, file));
+        const stat = await fs7.stat(path8.resolve(directory, file));
         snapshot[file] = `${stat.mtimeMs}:${stat.size}`;
       } catch {
         snapshot[file] = "missing";
@@ -2385,10 +2722,10 @@ ${text.trim().slice(0, 20000)}`);
   }
   async function fileContains(filePath, needle) {
     try {
-      const stat = await fs5.stat(filePath);
+      const stat = await fs7.stat(filePath);
       if (!stat.isFile() || stat.size > MAX_SCAN_BYTES)
         return false;
-      return (await fs5.readFile(filePath, "utf8")).includes(needle);
+      return (await fs7.readFile(filePath, "utf8")).includes(needle);
     } catch {
       return false;
     }
@@ -2396,9 +2733,9 @@ ${text.trim().slice(0, 20000)}`);
   async function untilReached(directory, job) {
     if (!job.until)
       return false;
-    const files = ["progress.md", "PROGRESS.md", "todo.md", "TODO.md", "todolist.md", "TODOLIST.md", path5.join(".opencode", "opencode-loop", "until.txt")];
+    const files = ["progress.md", "PROGRESS.md", "todo.md", "TODO.md", "todolist.md", "TODOLIST.md", path8.join(".opencode", "opencode-loop", "until.txt")];
     for (const file of files)
-      if (await fileContains(path5.resolve(directory, file), job.until))
+      if (await fileContains(path8.resolve(directory, file), job.until))
         return true;
     let scanned = 0;
     async function walk(current) {
@@ -2406,7 +2743,7 @@ ${text.trim().slice(0, 20000)}`);
         return false;
       let entries;
       try {
-        entries = await fs5.readdir(current, { withFileTypes: true });
+        entries = await fs7.readdir(current, { withFileTypes: true });
       } catch {
         return false;
       }
@@ -2415,7 +2752,7 @@ ${text.trim().slice(0, 20000)}`);
           return false;
         if ([".git", "node_modules", "dist", "build", ".next", "coverage"].includes(entry.name))
           continue;
-        const full = path5.join(current, entry.name);
+        const full = path8.join(current, entry.name);
         if (entry.isDirectory()) {
           if (await walk(full))
             return true;
@@ -2439,13 +2776,13 @@ ${text.trim().slice(0, 20000)}`);
     if (!status.stdout.trim())
       return;
     const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-    const checkpointDir = path5.join(stateDir(directory), "checkpoints", safeID(sessionID));
+    const checkpointDir = path8.join(stateDir(directory), "checkpoints", safeID(sessionID));
     await ensureDir(checkpointDir);
     const diff = await runProcess2("git", ["diff", "--binary"], directory, 120000);
     const staged = await runProcess2("git", ["diff", "--cached", "--binary"], directory, 120000);
     const prefix = `${timestamp}-${safeID(job.name || job.id)}`;
-    await fs5.writeFile(path5.join(checkpointDir, `${prefix}.status.txt`), status.stdout + status.stderr);
-    await fs5.writeFile(path5.join(checkpointDir, `${prefix}.patch`), `${diff.stdout}
+    await fs7.writeFile(path8.join(checkpointDir, `${prefix}.status.txt`), status.stdout + status.stderr);
+    await fs7.writeFile(path8.join(checkpointDir, `${prefix}.patch`), `${diff.stdout}
 ${staged.stdout}`);
     if (job.gitCheckpoint) {
       await runProcess2("git", ["add", "-A"], directory, 120000);
@@ -2463,9 +2800,6 @@ ${staged.stdout}`);
   };
 }
 
-// src/source/runtime/executor.js
-import path6 from "path";
-
 // src/source/runtime/session-status.js
 var DEFAULT_STALE_ACTIVE_RECOVERY_MS = 45000;
 var DEFAULT_SESSION_STATUS_CACHE_MS = 1500;
@@ -2587,6 +2921,25 @@ function createSessionStatusRuntime(options = {}) {
     const seenAt = sessionStatusSeenAt.get(sessionID) || 0;
     return cached === "idle" && seenAt > (active.startedAt || 0);
   }
+  async function recoverCompletedTailWithoutActiveRun(directory, client, sessionID, liveType, seenAt) {
+    if (activeRuns.has(sessionID))
+      return false;
+    if (liveType !== "busy" && liveType !== "retry")
+      return false;
+    if (!seenAt || now2() - seenAt < sessionStatusCacheMs)
+      return false;
+    const completion = await activeRunCompletionFromMessages2(directory, client, sessionID, { startedAt: 0 });
+    if (completion !== "completed")
+      return false;
+    markSessionStatus(sessionID, "idle");
+    await appendLoopLog2(directory, "status-message-idle-recovery", {
+      sessionID,
+      staleStatus: liveType,
+      statusSeenAt: seenAt,
+      staleForMs: Math.max(0, now2() - seenAt)
+    });
+    return true;
+  }
   async function sessionStatusType(client, sessionID, directory, options2 = {}) {
     if (hasActiveToolCalls(sessionID) || hasBusyDescendant(sessionID)) {
       markSessionStatus(sessionID, "busy");
@@ -2600,6 +2953,8 @@ function createSessionStatusRuntime(options = {}) {
       return cached;
     const live = await readLiveSessionStatus(client, sessionID, directory);
     if (live?.type) {
+      if (await recoverCompletedTailWithoutActiveRun(directory, client, sessionID, live.type, seenAt))
+        return "idle";
       if ((live.type === "busy" || live.type === "retry") && options2.recoverStaleActive !== false) {
         const active = activeRuns.get(sessionID);
         if (active) {
@@ -2751,166 +3106,101 @@ function createCompactionRuntime(options = {}) {
   };
 }
 
-// src/source/runtime/executor.js
-var DEFAULT_ACTIVE_GUARD_MS = 45000;
-var DEFAULT_BUSY_RETRY_MS2 = 5000;
+// src/source/runtime/action-dispatch.js
 function requireFunction7(value, label) {
   if (typeof value !== "function")
-    throw new TypeError(`createLoopExecutor requires ${label}`);
+    throw new TypeError(`createActionDispatcher requires ${label}`);
   return value;
 }
-function createLoopExecutor(options = {}) {
-  const workspace = options.workspace || {};
-  const goalPolicy = options.goalPolicy || {};
-  const scheduler = options.scheduler || {};
-  const buildPrompt = requireFunction7(workspace.buildPrompt, "workspace.buildPrompt");
-  const ensureBranch = requireFunction7(workspace.ensureBranch, "workspace.ensureBranch");
-  const watchChanged = requireFunction7(workspace.watchChanged, "workspace.watchChanged");
-  const untilReached = requireFunction7(workspace.untilReached, "workspace.untilReached");
-  const createCheckpoint = requireFunction7(workspace.createCheckpoint, "workspace.createCheckpoint");
-  const runGoalChecks = requireFunction7(goalPolicy.runGoalChecks, "goalPolicy.runGoalChecks");
-  const applyGoalNoProgressGuard = requireFunction7(goalPolicy.applyGoalNoProgressGuard, "goalPolicy.applyGoalNoProgressGuard");
-  const rememberSession = requireFunction7(scheduler.rememberSession, "scheduler.rememberSession");
-  const scheduleDueWork = requireFunction7(scheduler.scheduleDueWork, "scheduler.scheduleDueWork");
-  const now2 = typeof options.now === "function" ? options.now : now;
-  const readState2 = typeof options.readState === "function" ? options.readState : readState;
-  const writeState2 = typeof options.writeState === "function" ? options.writeState : writeState;
-  const pathExists2 = typeof options.pathExists === "function" ? options.pathExists : pathExists;
+function createActionDispatcher(options = {}) {
+  const buildPrompt = requireFunction7(options.buildPrompt, "buildPrompt");
+  const startCompaction = requireFunction7(options.compactionRuntime?.start, "compactionRuntime.start");
   const appendLoopLog2 = typeof options.appendLoopLog === "function" ? options.appendLoopLog : appendLoopLog;
-  const runShellCommand2 = typeof options.runShellCommand === "function" ? options.runShellCommand : runShellCommand;
-  const notifyJob2 = typeof options.notifyJob === "function" ? options.notifyJob : notifyJob;
-  const errorMessage = typeof options.errorMessage === "function" ? options.errorMessage : sdkErrorMessage;
   const sdkCall2 = typeof options.sdkCall === "function" ? options.sdkCall : sdkCall;
   const normalizedModelRef2 = typeof options.normalizedModelRef === "function" ? options.normalizedModelRef : normalizedModelRef;
   const fireSdk2 = typeof options.fireSdk === "function" ? options.fireSdk : fireSdk;
   const compactTuiCommandName2 = typeof options.compactTuiCommandName === "function" ? options.compactTuiCommandName : compactTuiCommandName;
-  const log2 = typeof options.log === "function" ? options.log : log;
   const toast2 = typeof options.toast === "function" ? options.toast : toast;
   const guardLoopOwnedUserMessage2 = typeof options.guardLoopOwnedUserMessage === "function" ? options.guardLoopOwnedUserMessage : guardLoopOwnedUserMessage;
-  const writeGoalReport2 = typeof options.writeGoalReport === "function" ? options.writeGoalReport : writeGoalReport;
   const dangerousShell2 = typeof options.dangerousShell === "function" ? options.dangerousShell : dangerousShell;
-  const activeGuardMs = Number.isFinite(Number(options.activeGuardMs)) && Number(options.activeGuardMs) > 0 ? Number(options.activeGuardMs) : DEFAULT_ACTIVE_GUARD_MS;
-  const busyRetryMs = Number.isFinite(Number(options.busyRetryMs)) && Number(options.busyRetryMs) > 0 ? Number(options.busyRetryMs) : DEFAULT_BUSY_RETRY_MS2;
-  const activeRuns = new Map;
-  const runLocks = new Map;
-  const statusRuntime = createSessionStatusRuntime({
-    activeRuns,
-    appendLoopLog: appendLoopLog2,
-    now: now2,
-    activeRunCompletionFromMessages: options.activeRunCompletionFromMessages,
-    staleActiveRecoveryMs: options.staleActiveRecoveryMs,
-    sessionStatusCacheMs: options.sessionStatusCacheMs
-  });
-  const {
-    updateSessionStatusFromEvent,
-    staleActiveRun,
-    canFinalizeActiveRun,
-    sessionIsIdle,
-    markSessionStatus,
-    clearSessionStatus
-  } = statusRuntime;
-  const compactionRuntime = createCompactionRuntime({
-    activeRuns,
-    finalizeActiveRun,
-    appendLoopLog: appendLoopLog2,
-    compactSession: options.compactSession,
-    log: log2,
-    errorMessage,
-    now: now2
-  });
-  function dueJobs(state, force = false) {
-    const current = now2();
-    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));
-  }
-  function clearActiveRun(sessionID) {
-    const active = activeRuns.get(sessionID);
-    if (active?.timer)
-      clearTimeout(active.timer);
-    compactionRuntime.clearForActiveRun(sessionID, active);
-    activeRuns.delete(sessionID);
-  }
-  function disposeSession(sessionID) {
-    clearActiveRun(sessionID);
-    runLocks.delete(sessionID);
-    compactionRuntime.clear(sessionID);
-    clearSessionStatus(sessionID);
-  }
-  async function recoverActiveDispatchFailure(directory, client, sessionID, jobId, runToken, error) {
-    const active = activeRuns.get(sessionID);
-    if (!active || active.jobId !== jobId || active.runToken !== runToken)
-      return false;
-    clearActiveRun(sessionID);
-    clearSessionStatus(sessionID);
-    const message = errorMessage(error);
-    const state = await readState2(directory, sessionID);
-    const job = (state.jobs || []).find((candidate) => candidate.id === jobId);
-    if (job) {
-      job.failureCount = (job.failureCount || 0) + 1;
-      job.lastFailureReason = "dispatch_failed";
-      job.lastDispatchFailure = message.slice(0, 4000);
-      job.lastDispatchFailureAt = now2();
-      if (job.maxFailures > 0 && job.failureCount >= job.maxFailures) {
-        job.paused = true;
-        await notifyJob2(directory, job, "dispatch_failed");
-      }
-      state.jobs = (state.jobs || []).map((candidate) => candidate.id === job.id ? job : candidate);
-      await writeState2(directory, sessionID, state);
+  async function fireAction(directory, client, sessionID, job) {
+    const action = String(job.action || "").trim();
+    const kind = actionKind(action, job);
+    const agent = job.agent || "build";
+    const model = normalizedModelRef2(job.model);
+    if (kind === "compact") {
+      const ok = await startCompaction(directory, client, sessionID, job.id, model, false);
+      return { startsAssistantTurn: ok, pause: !ok, reason: "compact_failed", compaction: ok };
     }
-    await appendLoopLog2(directory, "dispatch-error", { sessionID, job: job?.name || jobId, error: message });
-    await toast2(client, `Loop dispatch failed${job?.paused ? " and paused" : ""}: ${message}`, job?.paused ? "error" : "warning");
-    await scheduleDueWork(directory, client, sessionID, busyRetryMs);
-    return true;
-  }
-  async function finalizeActiveRun(directory, client, sessionID, finalizeOptions = {}) {
-    const active = activeRuns.get(sessionID);
-    if (!active)
-      return;
-    if (!await canFinalizeActiveRun(directory, client, sessionID, active, finalizeOptions))
-      return false;
-    const recoveredStale = staleActiveRun(sessionID);
-    if (active.compactionOnly) {
-      const pending = compactionRuntime.getPending(sessionID);
-      clearActiveRun(sessionID);
-      clearSessionStatus(sessionID);
-      await appendLoopLog2(directory, pending?.completedAt ? "compact-finished" : "compact-idle-fallback", {
-        sessionID,
-        job: active.job?.name || active.jobId,
-        startedAt: active.startedAt,
-        nativeEvent: Boolean(pending?.completedAt)
-      });
-      await scheduleDueWork(directory, client, sessionID);
-      return true;
+    if (kind === "command") {
+      const normalized = action.startsWith("/") ? action.slice(1) : action;
+      const [command, argumentsText] = splitFirst(normalized);
+      if (!command) {
+        await toast2(client, "Loop command action is empty. Example: /loop-command 200m /compact", "warning");
+        return { startsAssistantTurn: false, pause: true, reason: "empty_command" };
+      }
+      const tuiCommand = compactTuiCommandName2(command);
+      if (tuiCommand) {
+        guardLoopOwnedUserMessage2(sessionID);
+        const ok = await startCompaction(directory, client, sessionID, job.id, model, false);
+        return { startsAssistantTurn: ok, pause: !ok, reason: "compact_failed", compaction: ok };
+      }
+      guardLoopOwnedUserMessage2(sessionID);
+      const commandBody = { command, arguments: argumentsText, agent };
+      if (model)
+        commandBody.model = `${model.providerID}/${model.modelID}`;
+      await sdkCall2(client.session.command.bind(client.session), { path: { id: sessionID }, body: commandBody }, { path: { sessionID }, body: commandBody }, { sessionID, ...commandBody });
+      return { startsAssistantTurn: true };
     }
-    clearActiveRun(sessionID);
-    const state = await readState2(directory, sessionID);
-    let job = (state.jobs || []).find((candidate) => candidate.id === active.jobId);
-    if (!job)
-      return;
-    job.lastFinishedAt = now2();
-    if (recoveredStale) {
-      await appendLoopLog2(directory, "active-stale-recovery", {
-        sessionID,
-        job: job.name || job.id,
-        startedAt: active.startedAt
-      });
+    if (kind === "shell") {
+      const command = action.replace(/^[!$]\s*/, "").trim();
+      if (job.safe && dangerousShell2(command)) {
+        await toast2(client, `Blocked dangerous shell command in safe mode: ${command}`, "error");
+        await appendLoopLog2(directory, "blocked", { sessionID, job: job.name || job.id, command });
+        return { startsAssistantTurn: false, pause: true, reason: "safe_shell_blocked" };
+      }
+      guardLoopOwnedUserMessage2(sessionID);
+      const shellBody = { command, agent };
+      if (model)
+        shellBody.model = model;
+      const dispatch2 = fireSdk2(client, "session.shell", client.session.shell.bind(client.session), { path: { id: sessionID }, body: shellBody }, { path: { sessionID }, body: shellBody }, { sessionID, ...shellBody });
+      return { startsAssistantTurn: true, dispatch: dispatch2 };
     }
+    const prompt = await buildPrompt(directory, job);
+    const prefix = kind === "goal" ? "EXPERIMENTAL GOAL MODE CONTINUATION. Continue pursuing the active goal. Do not explain the /loop-goal command. Use the goal tools only when progress/completion/block state is real." : "AUTONOMOUS OPENCODE LOOP ITERATION. Continue the configured task now. Do not explain the /loop command. Do not search for documentation about this plugin. Do not create scheduler files. Do not ask questions. Make reasonable assumptions and work directly.";
+    const promptText = `${prefix}
+
+${prompt}`;
+    guardLoopOwnedUserMessage2(sessionID);
+    const promptBody = { agent, parts: [{ type: "text", text: promptText }] };
+    if (model)
+      promptBody.model = model;
+    const dispatch = fireSdk2(client, "session.prompt", client.session.prompt.bind(client.session), { path: { id: sessionID }, body: promptBody }, { path: { sessionID }, body: promptBody }, { sessionID, ...promptBody });
+    return { startsAssistantTurn: true, dispatch };
+  }
+  return { fireAction };
+}
+
+// src/source/runtime/run-finalization.js
+function requireFunction8(value, label) {
+  if (typeof value !== "function")
+    throw new TypeError(`createRunFinalizationRuntime requires ${label}`);
+  return value;
+}
+function createRunFinalizationRuntime(options = {}) {
+  const runGoalChecks = requireFunction8(options.runGoalChecks, "runGoalChecks");
+  const applyGoalNoProgressGuard = requireFunction8(options.applyGoalNoProgressGuard, "applyGoalNoProgressGuard");
+  const createCheckpoint = requireFunction8(options.createCheckpoint, "createCheckpoint");
+  const scheduleDueWork = requireFunction8(options.scheduleDueWork, "scheduleDueWork");
+  const now2 = typeof options.now === "function" ? options.now : now;
+  const writeState2 = typeof options.writeState === "function" ? options.writeState : writeState;
+  const appendLoopLog2 = typeof options.appendLoopLog === "function" ? options.appendLoopLog : appendLoopLog;
+  const runShellCommand2 = typeof options.runShellCommand === "function" ? options.runShellCommand : runShellCommand;
+  const notifyJob2 = typeof options.notifyJob === "function" ? options.notifyJob : notifyJob;
+  const toast2 = typeof options.toast === "function" ? options.toast : toast;
+  const writeGoalReport2 = typeof options.writeGoalReport === "function" ? options.writeGoalReport : writeGoalReport;
+  const dangerousShell2 = typeof options.dangerousShell === "function" ? options.dangerousShell : dangerousShell;
+  async function finalizeJob(directory, client, sessionID, state, job, previousJob) {
     if (job.verifyCommand) {
       const verify = await runShellCommand2(job.verifyCommand, directory, job.timeoutMs || 300000);
       job.lastVerifyAt = now2();
@@ -2971,7 +3261,7 @@ exit=` + postrun.code + `
     }
     if (isGoalJob(job)) {
       job = await runGoalChecks(directory, sessionID, job, client);
-      job = await applyGoalNoProgressGuard(directory, client, sessionID, job, active.job);
+      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 writeState2(directory, sessionID, state);
@@ -2979,63 +3269,272 @@ exit=` + postrun.code + `
       await writeGoalReport2(directory, sessionID, job);
     await createCheckpoint(directory, sessionID, job, client);
     await scheduleDueWork(directory, client, sessionID);
-    return true;
+    return job;
   }
-  async function fireAction(directory, client, sessionID, job) {
-    const action = String(job.action || "").trim();
-    const kind = actionKind(action, job);
-    const agent = job.agent || "build";
-    const model = normalizedModelRef2(job.model);
-    if (kind === "compact") {
-      const ok = await compactionRuntime.start(directory, client, sessionID, job.id, model, false);
-      return { startsAssistantTurn: ok, pause: !ok, reason: "compact_failed", compaction: ok };
+  return { finalizeJob };
+}
+
+// src/source/runtime/run-admission.js
+import path9 from "path";
+function requireFunction9(value, label) {
+  if (typeof value !== "function")
+    throw new TypeError(`createRunAdmissionRuntime requires ${label}`);
+  return value;
+}
+function createRunAdmissionRuntime(options = {}) {
+  const untilReached = requireFunction9(options.untilReached, "untilReached");
+  const scheduleDueWork = requireFunction9(options.scheduleDueWork, "scheduleDueWork");
+  const now2 = typeof options.now === "function" ? options.now : now;
+  const pathExists2 = typeof options.pathExists === "function" ? options.pathExists : pathExists;
+  const writeState2 = typeof options.writeState === "function" ? options.writeState : writeState;
+  const appendLoopLog2 = typeof options.appendLoopLog === "function" ? options.appendLoopLog : appendLoopLog;
+  const runShellCommand2 = typeof options.runShellCommand === "function" ? options.runShellCommand : runShellCommand;
+  const notifyJob2 = typeof options.notifyJob === "function" ? options.notifyJob : notifyJob;
+  const toast2 = typeof options.toast === "function" ? options.toast : toast;
+  const dangerousShell2 = typeof options.dangerousShell === "function" ? options.dangerousShell : dangerousShell;
+  function dueJobs2(state, force = false) {
+    return dueJobs(state, now2(), force);
+  }
+  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 writeState2(directory, sessionID, state);
+    await notifyJob2(directory, job, reason);
+    await toast2(client, message, "success");
+    if (logEvent)
+      await appendLoopLog2(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 && now2() - 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 (kind === "command") {
-      const normalized = action.startsWith("/") ? action.slice(1) : action;
-      const [command, argumentsText] = splitFirst(normalized);
-      if (!command) {
-        await toast2(client, "Loop command action is empty. Example: /loop-command 200m /compact", "warning");
-        return { startsAssistantTurn: false, pause: true, reason: "empty_command" };
+    if (job.stopFile && await pathExists2(path9.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 && dangerousShell2(job.preflightCommand)) {
+        if (runNowRequested)
+          delete job.runNowRequestedAt;
+        job.paused = true;
+        await writeState2(directory, sessionID, state);
+        await notifyJob2(directory, job, "preflight_blocked");
+        await toast2(client, "Preflight blocked in safe mode and loop paused: " + job.preflightCommand, "error");
+        await reschedule(directory, client, sessionID);
+        return { admitted: false, reason: "preflight_blocked" };
       }
-      const tuiCommand = compactTuiCommandName2(command);
-      if (tuiCommand) {
-        guardLoopOwnedUserMessage2(sessionID);
-        const ok = await compactionRuntime.start(directory, client, sessionID, job.id, model, false);
-        return { startsAssistantTurn: ok, pause: !ok, reason: "compact_failed", compaction: ok };
+      const preflight = await runShellCommand2(job.preflightCommand, directory, job.timeoutMs || 300000);
+      await appendLoopLog2(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 + `
+exit=` + preflight.code + `
+` + preflight.stdout + `
+` + preflight.stderr).slice(0, 4000);
+        state.jobs = (state.jobs || []).map((candidate) => candidate.id === job.id ? job : candidate);
+        await writeState2(directory, sessionID, state);
+        await notifyJob2(directory, job, "preflight_failed");
+        await toast2(client, "Preflight failed and loop paused: " + job.preflightCommand, "warning");
+        await reschedule(directory, client, sessionID);
+        return { admitted: false, reason: "preflight_failed" };
       }
-      guardLoopOwnedUserMessage2(sessionID);
-      const commandBody = { command, arguments: argumentsText, agent };
-      if (model)
-        commandBody.model = `${model.providerID}/${model.modelID}`;
-      await sdkCall2(client.session.command.bind(client.session), { path: { id: sessionID }, body: commandBody }, { path: { sessionID }, body: commandBody }, { sessionID, ...commandBody });
-      return { startsAssistantTurn: true };
     }
-    if (kind === "shell") {
-      const command = action.replace(/^[!$]\s*/, "").trim();
-      if (job.safe && dangerousShell2(command)) {
-        await toast2(client, `Blocked dangerous shell command in safe mode: ${command}`, "error");
-        await appendLoopLog2(directory, "blocked", { sessionID, job: job.name || job.id, command });
-        return { startsAssistantTurn: false, pause: true, reason: "safe_shell_blocked" };
+    return { admitted: true, job, runNowRequested };
+  }
+  return { dueJobs: dueJobs2, admitJob };
+}
+
+// src/source/runtime/executor.js
+var DEFAULT_ACTIVE_GUARD_MS = 45000;
+var DEFAULT_BUSY_RETRY_MS2 = 5000;
+function requireFunction10(value, label) {
+  if (typeof value !== "function")
+    throw new TypeError(`createLoopExecutor requires ${label}`);
+  return value;
+}
+function createLoopExecutor(options = {}) {
+  const workspace = options.workspace || {};
+  const goalPolicy = options.goalPolicy || {};
+  const scheduler = options.scheduler || {};
+  const buildPrompt = requireFunction10(workspace.buildPrompt, "workspace.buildPrompt");
+  const ensureBranch = requireFunction10(workspace.ensureBranch, "workspace.ensureBranch");
+  const watchChanged = requireFunction10(workspace.watchChanged, "workspace.watchChanged");
+  const untilReached = requireFunction10(workspace.untilReached, "workspace.untilReached");
+  const createCheckpoint = requireFunction10(workspace.createCheckpoint, "workspace.createCheckpoint");
+  const runGoalChecks = requireFunction10(goalPolicy.runGoalChecks, "goalPolicy.runGoalChecks");
+  const applyGoalNoProgressGuard = requireFunction10(goalPolicy.applyGoalNoProgressGuard, "goalPolicy.applyGoalNoProgressGuard");
+  const rememberSession = requireFunction10(scheduler.rememberSession, "scheduler.rememberSession");
+  const scheduleDueWork = requireFunction10(scheduler.scheduleDueWork, "scheduler.scheduleDueWork");
+  const now2 = typeof options.now === "function" ? options.now : now;
+  const readState2 = typeof options.readState === "function" ? options.readState : readState;
+  const writeState2 = typeof options.writeState === "function" ? options.writeState : writeState;
+  const appendLoopLog2 = typeof options.appendLoopLog === "function" ? options.appendLoopLog : appendLoopLog;
+  const runShellCommand2 = typeof options.runShellCommand === "function" ? options.runShellCommand : runShellCommand;
+  const notifyJob2 = typeof options.notifyJob === "function" ? options.notifyJob : notifyJob;
+  const errorMessage = typeof options.errorMessage === "function" ? options.errorMessage : sdkErrorMessage;
+  const fireSdk2 = typeof options.fireSdk === "function" ? options.fireSdk : fireSdk;
+  const log2 = typeof options.log === "function" ? options.log : log;
+  const toast2 = typeof options.toast === "function" ? options.toast : toast;
+  const dangerousShell2 = typeof options.dangerousShell === "function" ? options.dangerousShell : dangerousShell;
+  const activeGuardMs = Number.isFinite(Number(options.activeGuardMs)) && Number(options.activeGuardMs) > 0 ? Number(options.activeGuardMs) : DEFAULT_ACTIVE_GUARD_MS;
+  const busyRetryMs = Number.isFinite(Number(options.busyRetryMs)) && Number(options.busyRetryMs) > 0 ? Number(options.busyRetryMs) : DEFAULT_BUSY_RETRY_MS2;
+  const activeRuns = new Map;
+  const runLocks = new Map;
+  const statusRuntime = createSessionStatusRuntime({
+    activeRuns,
+    appendLoopLog: appendLoopLog2,
+    now: now2,
+    activeRunCompletionFromMessages: options.activeRunCompletionFromMessages,
+    staleActiveRecoveryMs: options.staleActiveRecoveryMs,
+    sessionStatusCacheMs: options.sessionStatusCacheMs
+  });
+  const {
+    updateSessionStatusFromEvent,
+    staleActiveRun,
+    canFinalizeActiveRun,
+    sessionIsIdle,
+    markSessionStatus,
+    clearSessionStatus
+  } = statusRuntime;
+  const compactionRuntime = createCompactionRuntime({
+    activeRuns,
+    finalizeActiveRun,
+    appendLoopLog: appendLoopLog2,
+    compactSession: options.compactSession,
+    log: log2,
+    errorMessage,
+    now: now2
+  });
+  const actionDispatcher = createActionDispatcher({
+    buildPrompt,
+    compactionRuntime,
+    appendLoopLog: appendLoopLog2,
+    sdkCall: options.sdkCall,
+    normalizedModelRef: options.normalizedModelRef,
+    fireSdk: options.fireSdk,
+    compactTuiCommandName: options.compactTuiCommandName,
+    toast: toast2,
+    guardLoopOwnedUserMessage: options.guardLoopOwnedUserMessage,
+    dangerousShell: dangerousShell2
+  });
+  const finalizationRuntime = createRunFinalizationRuntime({
+    runGoalChecks,
+    applyGoalNoProgressGuard,
+    createCheckpoint,
+    scheduleDueWork,
+    now: now2,
+    writeState: writeState2,
+    appendLoopLog: appendLoopLog2,
+    runShellCommand: runShellCommand2,
+    notifyJob: notifyJob2,
+    toast: toast2,
+    writeGoalReport: options.writeGoalReport,
+    dangerousShell: dangerousShell2
+  });
+  const admissionRuntime = createRunAdmissionRuntime({
+    untilReached,
+    scheduleDueWork,
+    now: now2,
+    pathExists: options.pathExists,
+    writeState: writeState2,
+    appendLoopLog: appendLoopLog2,
+    runShellCommand: runShellCommand2,
+    notifyJob: notifyJob2,
+    toast: toast2,
+    dangerousShell: dangerousShell2
+  });
+  const dueJobs2 = admissionRuntime.dueJobs;
+  function clearActiveRun(sessionID) {
+    const active = activeRuns.get(sessionID);
+    if (active?.timer)
+      clearTimeout(active.timer);
+    compactionRuntime.clearForActiveRun(sessionID, active);
+    activeRuns.delete(sessionID);
+  }
+  function disposeSession(sessionID) {
+    clearActiveRun(sessionID);
+    runLocks.delete(sessionID);
+    compactionRuntime.clear(sessionID);
+    clearSessionStatus(sessionID);
+  }
+  async function recoverActiveDispatchFailure(directory, client, sessionID, jobId, runToken, error) {
+    const active = activeRuns.get(sessionID);
+    if (!active || active.jobId !== jobId || active.runToken !== runToken)
+      return false;
+    clearActiveRun(sessionID);
+    clearSessionStatus(sessionID);
+    const message = errorMessage(error);
+    const state = await readState2(directory, sessionID);
+    const job = (state.jobs || []).find((candidate) => candidate.id === jobId);
+    if (job) {
+      job.failureCount = (job.failureCount || 0) + 1;
+      job.lastFailureReason = "dispatch_failed";
+      job.lastDispatchFailure = message.slice(0, 4000);
+      job.lastDispatchFailureAt = now2();
+      if (job.maxFailures > 0 && job.failureCount >= job.maxFailures) {
+        job.paused = true;
+        await notifyJob2(directory, job, "dispatch_failed");
       }
-      guardLoopOwnedUserMessage2(sessionID);
-      const shellBody = { command, agent };
-      if (model)
-        shellBody.model = model;
-      const dispatch2 = fireSdk2(client, "session.shell", client.session.shell.bind(client.session), { path: { id: sessionID }, body: shellBody }, { path: { sessionID }, body: shellBody }, { sessionID, ...shellBody });
-      return { startsAssistantTurn: true, dispatch: dispatch2 };
+      state.jobs = (state.jobs || []).map((candidate) => candidate.id === job.id ? job : candidate);
+      await writeState2(directory, sessionID, state);
     }
-    const prompt = await buildPrompt(directory, job);
-    const prefix = kind === "goal" ? "EXPERIMENTAL GOAL MODE CONTINUATION. Continue pursuing the active goal. Do not explain the /loop-goal command. Use the goal tools only when progress/completion/block state is real." : "AUTONOMOUS OPENCODE LOOP ITERATION. Continue the configured task now. Do not explain the /loop command. Do not search for documentation about this plugin. Do not create scheduler files. Do not ask questions. Make reasonable assumptions and work directly.";
-    const promptText = `${prefix}
-
-${prompt}`;
-    guardLoopOwnedUserMessage2(sessionID);
-    const promptBody = { agent, parts: [{ type: "text", text: promptText }] };
-    if (model)
-      promptBody.model = model;
-    const dispatch = fireSdk2(client, "session.prompt", client.session.prompt.bind(client.session), { path: { id: sessionID }, body: promptBody }, { path: { sessionID }, body: promptBody }, { sessionID, ...promptBody });
-    return { startsAssistantTurn: true, dispatch };
+    await appendLoopLog2(directory, "dispatch-error", { sessionID, job: job?.name || jobId, error: message });
+    await toast2(client, `Loop dispatch failed${job?.paused ? " and paused" : ""}: ${message}`, job?.paused ? "error" : "warning");
+    await scheduleDueWork(directory, client, sessionID, busyRetryMs);
+    return true;
+  }
+  async function finalizeActiveRun(directory, client, sessionID, finalizeOptions = {}) {
+    const active = activeRuns.get(sessionID);
+    if (!active)
+      return;
+    if (!await canFinalizeActiveRun(directory, client, sessionID, active, finalizeOptions))
+      return false;
+    const recoveredStale = staleActiveRun(sessionID);
+    if (active.compactionOnly) {
+      const pending = compactionRuntime.getPending(sessionID);
+      clearActiveRun(sessionID);
+      clearSessionStatus(sessionID);
+      await appendLoopLog2(directory, pending?.completedAt ? "compact-finished" : "compact-idle-fallback", {
+        sessionID,
+        job: active.job?.name || active.jobId,
+        startedAt: active.startedAt,
+        nativeEvent: Boolean(pending?.completedAt)
+      });
+      await scheduleDueWork(directory, client, sessionID);
+      return true;
+    }
+    clearActiveRun(sessionID);
+    const state = await readState2(directory, sessionID);
+    let job = (state.jobs || []).find((candidate) => candidate.id === active.jobId);
+    if (!job)
+      return;
+    job.lastFinishedAt = now2();
+    if (recoveredStale) {
+      await appendLoopLog2(directory, "active-stale-recovery", {
+        sessionID,
+        job: job.name || job.id,
+        startedAt: active.startedAt
+      });
+    }
+    await finalizationRuntime.finalizeJob(directory, client, sessionID, state, job, active.job);
+    return true;
   }
+  const fireAction = actionDispatcher.fireAction;
   async function maybeRunDueJobs(directory, client, sessionID, runOptions = {}) {
     rememberSession(directory, client, sessionID);
     const reschedule = async (minDelayMs = 0) => {
@@ -3070,74 +3569,18 @@ ${prompt}`;
           candidate.watchTriggered = true;
         }
       }
-      const due = dueJobs(state, Boolean(runOptions.force));
+      const due = dueJobs2(state, Boolean(runOptions.force));
       if (!due.length) {
         await writeState2(directory, sessionID, state);
         await reschedule();
         return;
       }
       job = due[0];
-      const runNowRequested = Number(job.runNowRequestedAt || 0) > 0;
-      if (job.maxRuntimeMs > 0 && now2() - Date.parse(job.createdAt || new Date().toISOString()) >= job.maxRuntimeMs) {
-        state.jobs = (state.jobs || []).filter((candidate) => candidate.id !== job.id);
-        await writeState2(directory, sessionID, state);
-        await notifyJob2(directory, job, "max_runtime_reached");
-        await toast2(client, `Loop stopped by --max-runtime: ${job.name || job.id}`, "success");
-        await appendLoopLog2(directory, "max-runtime", { sessionID, job: job.name || job.id });
-        await reschedule();
-        return;
-      }
-      if (job.stopFile && await pathExists2(path6.resolve(directory, job.stopFile))) {
-        state.jobs = (state.jobs || []).filter((candidate) => candidate.id !== job.id);
-        await writeState2(directory, sessionID, state);
-        await notifyJob2(directory, job, "stop_file");
-        await toast2(client, "Loop stopped by --stop-file: " + job.stopFile, "success");
-        await reschedule();
+      const admission = await admissionRuntime.admitJob(directory, client, sessionID, state, job);
+      if (!admission.admitted)
         return;
-      }
-      if (await untilReached(directory, job)) {
-        state.jobs = (state.jobs || []).filter((candidate) => candidate.id !== job.id);
-        await writeState2(directory, sessionID, state);
-        await notifyJob2(directory, job, "until_reached");
-        await toast2(client, `Loop stopped by --until: ${job.until}`, "success");
-        await reschedule();
-        return;
-      }
-      if (job.preflightCommand) {
-        if (job.safe && dangerousShell2(job.preflightCommand)) {
-          if (runNowRequested)
-            delete job.runNowRequestedAt;
-          job.paused = true;
-          await writeState2(directory, sessionID, state);
-          await notifyJob2(directory, job, "preflight_blocked");
-          await toast2(client, "Preflight blocked in safe mode and loop paused: " + job.preflightCommand, "error");
-          await reschedule();
-          return;
-        }
-        const preflight = await runShellCommand2(job.preflightCommand, directory, job.timeoutMs || 300000);
-        await appendLoopLog2(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 + `
-exit=` + preflight.code + `
-` + preflight.stdout + `
-` + preflight.stderr).slice(0, 4000);
-          state.jobs = (state.jobs || []).map((candidate) => candidate.id === job.id ? job : candidate);
-          await writeState2(directory, sessionID, state);
-          await notifyJob2(directory, job, "preflight_failed");
-          await toast2(client, "Preflight failed and loop paused: " + job.preflightCommand, "warning");
-          await reschedule();
-          return;
-        }
-      }
+      job = admission.job;
+      const runNowRequested = admission.runNowRequested;
       job = await ensureBranch(directory, job, client, sessionID);
       const compactResult = await compactionRuntime.maybeCompact(directory, client, sessionID, job);
       job = compactResult.job;
@@ -3233,7 +3676,7 @@ exit=` + preflight.code + `
     }
   }
   return {
-    dueJobs,
+    dueJobs: dueJobs2,
     clearActiveRun,
     disposeSession,
     recoverActiveDispatchFailure,
@@ -3254,7 +3697,7 @@ exit=` + preflight.code + `
 // src/source/runtime/goal-steering.js
 var DEFAULT_STEERING_SUPPRESSION_MS = 5 * 60000;
 var DEFAULT_SEEN_USER_MESSAGE_MS = 10 * 60000;
-function requireFunction8(value, label) {
+function requireFunction11(value, label) {
   if (typeof value !== "function")
     throw new TypeError(`createGoalSteeringRuntime requires ${label}`);
   return value;
@@ -3298,8 +3741,8 @@ function activeGoalJobs(state) {
   });
 }
 function createGoalSteeringRuntime(options = {}) {
-  const getActiveRun = requireFunction8(options.getActiveRun, "getActiveRun");
-  const clearActiveRun = requireFunction8(options.clearActiveRun, "clearActiveRun");
+  const getActiveRun = requireFunction11(options.getActiveRun, "getActiveRun");
+  const clearActiveRun = requireFunction11(options.clearActiveRun, "clearActiveRun");
   const isLoopOwnedUserMessage = typeof options.isLoopOwnedUserMessage === "function" ? options.isLoopOwnedUserMessage : () => false;
   const readState2 = typeof options.readState === "function" ? options.readState : readState;
   const appendLoopLog2 = typeof options.appendLoopLog === "function" ? options.appendLoopLog : appendLoopLog;
@@ -4138,6 +4581,6 @@ var OpenCodeLoopPlugin2 = async (input = {}) => {
 };
 var v1_default = OpenCodeLoopPlugin2;
 export {
-  v1_default as default,
-  OpenCodeLoopPlugin2 as OpenCodeLoopPlugin
+  OpenCodeLoopPlugin2 as OpenCodeLoopPlugin,
+  v1_default as default
 };