@bybrawe/opencode-loop 0.5.28 → 0.5.29

package/src/index.js

@@ -1,7 +1,5 @@
 // @bun
 // src/source/legacy-v1.js
-import { promises as fs3 } from "fs";
-import path3 from "path";
 import { tool } from "@opencode-ai/plugin/tool";
 
 // src/source/core/args.js
@@ -376,110 +374,10 @@ function parseLoopArgs(raw, defaults = {}) {
   return { ok: true, job };
 }
 
-// src/source/core/jobs.js
-function presetDefaults(name) {
-  if (name === "loop-compact")
-    return { intervalMs: parseDuration("200m"), action: "/compact", kind: "compact", name: "compact", immediate: false };
-  if (name === "loop-command" || name === "loop-cmd")
-    return { intervalMs: 0, kind: "command", name: "command", immediate: false };
-  if (name === "loop-prompt")
-    return { intervalMs: 0, kind: "prompt", name: "prompt", immediate: true };
-  if (name === "loop-ask")
-    return { intervalMs: 0, kind: "prompt", name: "ask", immediate: false };
-  if (name === "loop-shell")
-    return { intervalMs: 0, kind: "shell", name: "shell", immediate: false };
-  if (name === "loop-testfix")
-    return { intervalMs: 0, name: "testfix", safe: true, askNever: true, verifyCommand: "npm test", testfixPreset: true, action: "Run the project tests. Fix failures. Re-run the tests. Test command hint: npm test" };
-  if (name === "loop-progress")
-    return { intervalMs: 0, name: "progress", safe: true, askNever: true, progressFile: "progress.md", action: "Read progress.md and continue the next unfinished TODO. Mark completed TODOs with [x]. Add useful TODOs when you discover them." };
-  if (name === "loop-safe-dev")
-    return { intervalMs: 0, name: "safe-dev", safe: true, askNever: true, noOverlap: true, checkpointOnly: true, batch: 5, progressFile: "progress.md", action: "Develop the project from progress.md. Work in small safe batches. Mark completed TODOs with [x]. Add new ideas to progress.md. Run tests/lint/build if available." };
-  return { intervalMs: 0, name: "dev", askNever: true, progressFile: "progress.md", action: "Continue developing the project from progress.md. Mark completed TODOs with [x]. Add new ideas to progress.md. Run tests/lint/build if available." };
-}
-function jobLabel(job) {
-  const title = job.name ? `${job.name}: ` : "";
-  const kind = job.kind ? ` [${job.kind}]` : "";
-  const limit = job.maxRuns > 0 ? `, max ${job.maxRuns}` : "";
-  const runtime = job.maxRuntimeMs > 0 ? `, runtime ${durationToText(job.maxRuntimeMs)}` : "";
-  const timeout = job.timeoutMs > 0 ? `, timeout ${durationToText(job.timeoutMs)}` : "";
-  const compact = job.compactEveryRuns > 0 ? `, compact every ${job.compactEveryRuns} runs` : job.compactEveryMs > 0 ? `, compact every ${durationToText(job.compactEveryMs)}` : "";
-  const verify = job.verifyCommand ? ", verify" : "";
-  const preflight = job.preflightCommand ? ", preflight" : "";
-  const failures = job.maxFailures > 0 ? `, max failures ${job.maxFailures}` : "";
-  const noProgress = isGoalJob(job) && (job.maxNoProgress ?? DEFAULT_GOAL_MAX_NO_PROGRESS) > 0 ? `, max no-progress ${job.maxNoProgress ?? DEFAULT_GOAL_MAX_NO_PROGRESS}` : "";
-  const stopFile = job.stopFile ? ", stop-file" : "";
-  const watch = job.watchPaths?.length ? `, watch ${job.watchPaths.join(",")}` : "";
-  const paused = job.paused ? ", paused" : "";
-  return `${title}${durationToText(job.intervalMs)}${kind} -> ${job.action || `[prompt-file: ${job.promptFile}]`}${limit}${runtime}${timeout}${compact}${verify}${preflight}${failures}${noProgress}${stopFile}${watch}${paused}`;
-}
-function matchJob(job, target, index) {
-  const text = String(target || "").trim();
-  if (!text || text.toLowerCase() === "all")
-    return true;
-  return job.id === text || job.name === text || String(index + 1) === text;
-}
-function actionKind(action, job = {}) {
-  const text = String(action || "").trim();
-  const forced = String(job.kind || "").trim().toLowerCase();
-  if (forced === "compact")
-    return "compact";
-  if (forced === "goal")
-    return "goal";
-  if (text === "/compact" || text === "/summarize")
-    return "compact";
-  if (forced === "prompt" || forced === "ask")
-    return "prompt";
-  if (forced === "command" || forced === "cmd" || forced === "slash")
-    return "command";
-  if (forced === "shell")
-    return "shell";
-  if (text.startsWith("/"))
-    return "command";
-  if (text.startsWith("!") || text.startsWith("$"))
-    return "shell";
-  return "prompt";
-}
-function decoratePrompt(job) {
-  const additions = [];
-  if (job.progressFile)
-    additions.push(`Use ${job.progressFile} as the main progress/TODO state file. Read it before choosing the next task and update it after work.`);
-  if (job.lastVerifyFailure)
-    additions.push("Previous verify command failed. Fix this before moving on. Failure summary: " + String(job.lastVerifyFailure).slice(0, 1200));
-  if (job.askNever)
-    additions.push("Do not ask the user questions. Make reasonable assumptions and continue. Only write a short BLOCKED note if truly blocked.");
-  if (job.safe)
-    additions.push("Safety rules: do not run destructive commands such as git reset, git clean, rm -rf, del /s, rmdir /s, force push, production deploys, production migrations, terraform destroy, or deleting user data. If such an action seems needed, write a BLOCKED note instead.");
-  if (job.batch > 0)
-    additions.push(`Batch rule: in this run, work on at most ${job.batch} unfinished TODO item(s). Mark completed items with [x].`);
-  if (job.quiet)
-    additions.push("Keep replies short. Summarize only what changed, tests run, and next step.");
-  if (job.testCommand)
-    additions.push(`After making changes, run this test/check command if applicable: ${job.testCommand}. If it fails, fix the failure and try again.`);
-  if (job.checkpointOnly || job.gitCheckpoint)
-    additions.push("Keep changes incremental and easy to review because the loop will create a checkpoint after the run.");
-  if (!additions.length)
-    return job.action;
-  return `${job.action}
-
-OpenCode loop instructions:
-- ${additions.join(`
-- `)}`;
-}
-function isGoalJob(job) {
-  return String(job?.kind || "").toLowerCase() === "goal";
-}
-function goalStatusText(job) {
-  const status = job?.goalStatus || (isGoalJob(job) ? "active" : "");
-  if (!status)
-    return "";
-  if (status === "completed")
-    return "completed";
-  if (status === "blocked")
-    return "blocked";
-  if (job?.paused)
-    return "paused";
-  return status;
-}
+// src/source/core/process.js
+import { promises as fs2 } from "fs";
+import path2 from "path";
+import { spawn } from "child_process";
 
 // src/source/core/state.js
 import { promises as fs } from "fs";
@@ -699,9 +597,6 @@ async function removeState(directory, sessionID) {
 }
 
 // src/source/core/process.js
-import { promises as fs2 } from "fs";
-import path2 from "path";
-import { spawn } from "child_process";
 async function appendLoopLog(directory, line, extra = {}) {
   try {
     await ensureDir(stateDir(directory));
@@ -771,12 +666,12 @@ async function notifyJob(directory, job, reason) {
 }
 
 // src/source/opencode/sdk.js
-function sdkError2(result) {
+function sdkError(result) {
   if (!result || typeof result !== "object")
     return;
   return result.error || result.error === null ? result.error : undefined;
 }
-function sdkData2(result) {
+function sdkData(result) {
   if (!result || typeof result !== "object")
     return result;
   return Object.prototype.hasOwnProperty.call(result, "data") ? result.data : result;
@@ -806,9 +701,9 @@ async function sdkCall(method, ...argsList) {
       continue;
     try {
       const result = await method(args);
-      const error = sdkError2(result);
+      const error = sdkError(result);
       if (!error)
-        return sdkData2(result);
+        return sdkData(result);
       firstError = firstError || new Error(sdkErrorMessage(error));
     } catch (error) {
       firstError = firstError || error;
@@ -866,64 +761,8 @@ function deleteSessionExecutionContext(sessionID) {
   sessionExecutionContexts.delete(sessionID);
 }
 
-// src/source/legacy-v1.js
+// src/source/opencode/host.js
 var SERVICE = "opencode-loop";
-var DEFAULT_ACTIVE_GUARD_MS = 45000;
-var STALE_ACTIVE_RECOVERY_MS = 45000;
-var IDLE_DEBOUNCE_MS = 1200;
-var BUSY_RETRY_MS = 5000;
-var SESSION_STATUS_CACHE_MS = 1500;
-var MIN_DUE_TIMER_MS = 250;
-var MAX_DUE_TIMER_MS = 2147000000;
-var HEARTBEAT_MS = 2500;
-var MAX_SCAN_FILES = 200;
-var MAX_SCAN_BYTES = 2000000;
-var GOAL_REPORT_DIR = "goals";
-var GOAL_PROMPT_PREFIX = "EXPERIMENTAL OPENCODE GOAL MODE ITERATION";
-var DEFAULT_GOAL_ACTIVE_RECOVERY_MS = 180000;
-var LOOP_OWNED_USER_MESSAGE_GUARD_MS = 1e4;
-var LOOP_OWNED_USER_MESSAGE_RETENTION_MS = 10 * 60000;
-var activeRuns = new Map;
-var handledCommands = new Map;
-var handledCommandEvents = new Map;
-var loopOwnedUserMessageGuards = new Map;
-var idleTimers = new Map;
-var dueTimers = new Map;
-var watchdogTimers = new Map;
-var runLocks = new Map;
-var knownSessions = new Map;
-var activeToolCalls = new Map;
-var sessionParents = new Map;
-var heartbeatTimer;
-var sessionStatuses = new Map;
-var sessionStatusSeenAt = new Map;
-var loopCompactionRequests = new Map;
-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 fireSdk(client, label, method, ...argsList) {
   const pending = Promise.resolve().then(() => sdkCall(method, ...argsList));
   pending.catch((error) => {
@@ -1036,6 +875,11 @@ async function toast(client, message, variant = "info") {
     await sdkCall(client.tui.showToast.bind(client.tui), { body: { message, variant } }, { message, variant });
   } catch {}
 }
+
+// src/source/opencode/messages.js
+var LOOP_OWNED_USER_MESSAGE_GUARD_MS = 1e4;
+var LOOP_OWNED_USER_MESSAGE_RETENTION_MS = 10 * 60000;
+var loopOwnedUserMessageGuards = new Map;
 function guardLoopOwnedUserMessage(sessionID) {
   if (!sessionID)
     return;
@@ -1065,9 +909,10 @@ function loopOwnedUserMessageGuardActive(sessionID, messageID) {
   if (id && entry.messageIDs.has(id))
     return true;
   if ((entry.pending || 0) > 0 && (entry.until || 0) >= now()) {
+    if (!id)
+      return true;
     entry.pending -= 1;
-    if (id)
-      entry.messageIDs.set(id, now() + LOOP_OWNED_USER_MESSAGE_RETENTION_MS);
+    entry.messageIDs.set(id, now() + LOOP_OWNED_USER_MESSAGE_RETENTION_MS);
     loopOwnedUserMessageGuards.set(sessionID, entry);
     return true;
   }
@@ -1081,25 +926,49 @@ async function say(client, sessionID, text) {
     await sdkCall(client.session.prompt.bind(client.session), { path: { id: sessionID }, body: { noReply: true, parts: [{ type: "text", text }] } }, { path: { sessionID }, body: { noReply: true, parts: [{ type: "text", text }] } }, { sessionID, noReply: true, parts: [{ type: "text", text }] });
   } catch {}
 }
+function clearLoopOwnedUserMessageGuard(sessionID) {
+  loopOwnedUserMessageGuards.delete(sessionID);
+}
+
+// src/source/opencode/commands.js
+var COMMAND_DEDUPE_MS = 30000;
+var handledCommands = new Map;
+var handledCommandEvents = new Map;
+function normalizeArgsForKey(args) {
+  if (args === undefined || args === null)
+    return "";
+  if (typeof args === "string")
+    return args.trim().replace(/\s+/g, " ");
+  if (Array.isArray(args))
+    return args.map(normalizeArgsForKey).join(" ").trim().replace(/\s+/g, " ");
+  try {
+    return JSON.stringify(args);
+  } catch {
+    return String(args);
+  }
+}
 function commandKey(sessionID, name, args) {
   return `${sessionID || "no-session"}:${name || ""}:${normalizeArgsForKey(args)}`;
 }
+function commandEventKey(sessionID, messageID) {
+  return `${sessionID || "no-session"}:event:${messageID || "no-message"}`;
+}
 function markHandled(sessionID, name, args) {
   const key = commandKey(sessionID, name, args);
   const previous = handledCommands.get(key);
-  const pending = previous && now() - previous.time < 30000 ? previous.pending + 1 : 1;
+  const pending = previous && now() - previous.time < COMMAND_DEDUPE_MS ? previous.pending + 1 : 1;
   handledCommands.set(key, { time: now(), pending });
   for (const [entryKey, entry] of handledCommands.entries())
-    if (now() - entry.time > 30000)
+    if (now() - entry.time > COMMAND_DEDUPE_MS)
       handledCommands.delete(entryKey);
   for (const [entryKey, time] of handledCommandEvents.entries())
-    if (now() - time > 30000)
+    if (now() - time > COMMAND_DEDUPE_MS)
       handledCommandEvents.delete(entryKey);
 }
 function consumeHandled(sessionID, name, args) {
   const key = commandKey(sessionID, name, args);
   const entry = handledCommands.get(key);
-  if (!entry || now() - entry.time >= 30000) {
+  if (!entry || now() - entry.time >= COMMAND_DEDUPE_MS) {
     handledCommands.delete(key);
     return false;
   }
@@ -1109,8 +978,23 @@ function consumeHandled(sessionID, name, args) {
     handledCommands.set(key, { time: entry.time, pending: entry.pending - 1 });
   return true;
 }
-function commandEventKey(sessionID, messageID) {
-  return `${sessionID || "no-session"}:event:${messageID || "no-message"}`;
+function hasHandledCommandEvent(sessionID, messageID) {
+  return handledCommandEvents.has(commandEventKey(sessionID, messageID));
+}
+function markHandledCommandEvent(sessionID, messageID) {
+  handledCommandEvents.set(commandEventKey(sessionID, messageID), now());
+}
+function forgetHandledCommandEvent(sessionID, messageID) {
+  handledCommandEvents.delete(commandEventKey(sessionID, messageID));
+}
+function clearCommandLifecycle(sessionID) {
+  const prefix = `${sessionID}:`;
+  for (const key of handledCommands.keys())
+    if (key.startsWith(prefix))
+      handledCommands.delete(key);
+  for (const key of handledCommandEvents.keys())
+    if (key.startsWith(prefix))
+      handledCommandEvents.delete(key);
 }
 function commandName(name) {
   return String(name || "");
@@ -1121,19 +1005,6 @@ function isPreset(name) {
 function isLoopCommandName(name) {
   return name === "loop" || name === "loop-stop" || name === "loop-remove" || name === "loop-clear" || name === "loop-status" || name === "loop-logs" || name === "loop-help" || name === "loop-now" || name === "loop-pause" || name === "loop-resume" || name === "loop-doctor" || name === "loop-init" || name === "loop-export" || name === "loop-goal" || name === "loop-goal-status" || name === "loop-goal-pause" || name === "loop-goal-resume" || name === "loop-goal-clear" || name === "loop-goal-done" || name === "loop-goal-complete" || name === "loop-goal-blocked" || isPreset(name);
 }
-function normalizeArgsForKey(args) {
-  if (args === undefined || args === null)
-    return "";
-  if (typeof args === "string")
-    return args.trim().replace(/\s+/g, " ");
-  if (Array.isArray(args))
-    return args.map(normalizeArgsForKey).join(" ").trim().replace(/\s+/g, " ");
-  try {
-    return JSON.stringify(args);
-  } catch {
-    return String(args);
-  }
-}
 function commandArgsText(args) {
   if (args === undefined || args === null)
     return "";
@@ -1149,184 +1020,222 @@ function commandArgsText(args) {
   }
   return String(args);
 }
-function rememberSession(directory, client, sessionID) {
-  if (!sessionID)
-    return;
-  knownSessions.set(sessionID, { directory, client, seenAt: now() });
-  startHeartbeat();
+
+// src/source/core/jobs.js
+function presetDefaults(name) {
+  if (name === "loop-compact")
+    return { intervalMs: parseDuration("200m"), action: "/compact", kind: "compact", name: "compact", immediate: false };
+  if (name === "loop-command" || name === "loop-cmd")
+    return { intervalMs: 0, kind: "command", name: "command", immediate: false };
+  if (name === "loop-prompt")
+    return { intervalMs: 0, kind: "prompt", name: "prompt", immediate: true };
+  if (name === "loop-ask")
+    return { intervalMs: 0, kind: "prompt", name: "ask", immediate: false };
+  if (name === "loop-shell")
+    return { intervalMs: 0, kind: "shell", name: "shell", immediate: false };
+  if (name === "loop-testfix")
+    return { intervalMs: 0, name: "testfix", safe: true, askNever: true, verifyCommand: "npm test", testfixPreset: true, action: "Run the project tests. Fix failures. Re-run the tests. Test command hint: npm test" };
+  if (name === "loop-progress")
+    return { intervalMs: 0, name: "progress", safe: true, askNever: true, progressFile: "progress.md", action: "Read progress.md and continue the next unfinished TODO. Mark completed TODOs with [x]. Add useful TODOs when you discover them." };
+  if (name === "loop-safe-dev")
+    return { intervalMs: 0, name: "safe-dev", safe: true, askNever: true, noOverlap: true, checkpointOnly: true, batch: 5, progressFile: "progress.md", action: "Develop the project from progress.md. Work in small safe batches. Mark completed TODOs with [x]. Add new ideas to progress.md. Run tests/lint/build if available." };
+  return { intervalMs: 0, name: "dev", askNever: true, progressFile: "progress.md", action: "Continue developing the project from progress.md. Mark completed TODOs with [x]. Add new ideas to progress.md. Run tests/lint/build if available." };
 }
-function hasActiveToolCalls(sessionID) {
-  return (activeToolCalls.get(sessionID)?.size || 0) > 0;
+function jobLabel(job) {
+  const title = job.name ? `${job.name}: ` : "";
+  const kind = job.kind ? ` [${job.kind}]` : "";
+  const limit = job.maxRuns > 0 ? `, max ${job.maxRuns}` : "";
+  const runtime = job.maxRuntimeMs > 0 ? `, runtime ${durationToText(job.maxRuntimeMs)}` : "";
+  const timeout = job.timeoutMs > 0 ? `, timeout ${durationToText(job.timeoutMs)}` : "";
+  const compact = job.compactEveryRuns > 0 ? `, compact every ${job.compactEveryRuns} runs` : job.compactEveryMs > 0 ? `, compact every ${durationToText(job.compactEveryMs)}` : "";
+  const verify = job.verifyCommand ? ", verify" : "";
+  const preflight = job.preflightCommand ? ", preflight" : "";
+  const failures = job.maxFailures > 0 ? `, max failures ${job.maxFailures}` : "";
+  const noProgress = isGoalJob(job) && (job.maxNoProgress ?? DEFAULT_GOAL_MAX_NO_PROGRESS) > 0 ? `, max no-progress ${job.maxNoProgress ?? DEFAULT_GOAL_MAX_NO_PROGRESS}` : "";
+  const stopFile = job.stopFile ? ", stop-file" : "";
+  const watch = job.watchPaths?.length ? `, watch ${job.watchPaths.join(",")}` : "";
+  const paused = job.paused ? ", paused" : "";
+  return `${title}${durationToText(job.intervalMs)}${kind} -> ${job.action || `[prompt-file: ${job.promptFile}]`}${limit}${runtime}${timeout}${compact}${verify}${preflight}${failures}${noProgress}${stopFile}${watch}${paused}`;
 }
-function markToolCallActive(input) {
-  const sessionID = input?.sessionID;
-  const callID = input?.callID;
-  if (typeof sessionID !== "string" || typeof callID !== "string")
-    return;
-  const calls = activeToolCalls.get(sessionID) || new Set;
-  calls.add(callID);
-  activeToolCalls.set(sessionID, calls);
-  sessionStatuses.set(sessionID, "busy");
-  sessionStatusSeenAt.set(sessionID, now());
+function matchJob(job, target, index) {
+  const text = String(target || "").trim();
+  if (!text || text.toLowerCase() === "all")
+    return true;
+  return job.id === text || job.name === text || String(index + 1) === text;
 }
-function markToolCallFinished(input) {
-  const sessionID = input?.sessionID;
-  const callID = input?.callID;
-  if (typeof sessionID !== "string" || typeof callID !== "string")
-    return;
-  const calls = activeToolCalls.get(sessionID);
-  if (!calls)
-    return;
-  calls.delete(callID);
-  if (!calls.size)
-    activeToolCalls.delete(sessionID);
-}
-function updateSessionRelationship(info, removed = false) {
-  const sessionID = info?.id;
-  if (typeof sessionID !== "string")
-    return;
-  if (removed || typeof info?.parentID !== "string")
-    sessionParents.delete(sessionID);
-  else
-    sessionParents.set(sessionID, info.parentID);
-  if (!removed)
-    updateSessionExecutionContext(info);
-  else
-    deleteSessionExecutionContext(sessionID);
-}
-function updateSessionRelationshipFromEvent(event) {
-  if (!["session.created", "session.updated", "session.deleted"].includes(event?.type))
-    return;
-  updateSessionRelationship(event?.properties?.info, event.type === "session.deleted");
-}
-function isDescendantSession(sessionID, ancestorID) {
-  const visited = new Set;
-  let current = sessionID;
-  while (sessionParents.has(current) && !visited.has(current)) {
-    visited.add(current);
-    current = sessionParents.get(current);
-    if (current === ancestorID)
-      return true;
-  }
-  return false;
+function actionKind(action, job = {}) {
+  const text = String(action || "").trim();
+  const forced = String(job.kind || "").trim().toLowerCase();
+  if (forced === "compact")
+    return "compact";
+  if (forced === "goal")
+    return "goal";
+  if (text === "/compact" || text === "/summarize")
+    return "compact";
+  if (forced === "prompt" || forced === "ask")
+    return "prompt";
+  if (forced === "command" || forced === "cmd" || forced === "slash")
+    return "command";
+  if (forced === "shell")
+    return "shell";
+  if (text.startsWith("/"))
+    return "command";
+  if (text.startsWith("!") || text.startsWith("$"))
+    return "shell";
+  return "prompt";
 }
-function hasBusyDescendant(sessionID) {
-  for (const childID of sessionParents.keys()) {
-    if (!isDescendantSession(childID, sessionID))
-      continue;
-    const status = sessionStatuses.get(childID);
-    if (status === "busy" || status === "retry" || hasActiveToolCalls(childID))
-      return true;
-  }
-  return false;
+function decoratePrompt(job) {
+  const additions = [];
+  if (job.progressFile)
+    additions.push(`Use ${job.progressFile} as the main progress/TODO state file. Read it before choosing the next task and update it after work.`);
+  if (job.lastVerifyFailure)
+    additions.push("Previous verify command failed. Fix this before moving on. Failure summary: " + String(job.lastVerifyFailure).slice(0, 1200));
+  if (job.askNever)
+    additions.push("Do not ask the user questions. Make reasonable assumptions and continue. Only write a short BLOCKED note if truly blocked.");
+  if (job.safe)
+    additions.push("Safety rules: do not run destructive commands such as git reset, git clean, rm -rf, del /s, rmdir /s, force push, production deploys, production migrations, terraform destroy, or deleting user data. If such an action seems needed, write a BLOCKED note instead.");
+  if (job.batch > 0)
+    additions.push(`Batch rule: in this run, work on at most ${job.batch} unfinished TODO item(s). Mark completed items with [x].`);
+  if (job.quiet)
+    additions.push("Keep replies short. Summarize only what changed, tests run, and next step.");
+  if (job.testCommand)
+    additions.push(`After making changes, run this test/check command if applicable: ${job.testCommand}. If it fails, fix the failure and try again.`);
+  if (job.checkpointOnly || job.gitCheckpoint)
+    additions.push("Keep changes incremental and easy to review because the loop will create a checkpoint after the run.");
+  if (!additions.length)
+    return job.action;
+  return `${job.action}
+
+OpenCode loop instructions:
+- ${additions.join(`
+- `)}`;
 }
-async function refreshSessionRelationships(client, directory) {
-  if (!client?.session?.list)
-    return;
-  try {
-    const sessions = await sdkCall(client.session.list.bind(client.session), { query: { directory } }, { directory }, {});
-    if (Array.isArray(sessions))
-      for (const info of sessions)
-        updateSessionRelationship(info);
-  } catch {}
+function isGoalJob(job) {
+  return String(job?.kind || "").toLowerCase() === "goal";
 }
-function updateToolActivityFromEvent(event) {
-  const props = event?.properties || {};
-  if (event?.type === "message.part.updated") {
-    const part = props.part;
-    if (part?.type !== "tool")
-      return;
-    const sessionID = part.sessionID || props.sessionID;
-    if (["pending", "running"].includes(part.state?.status)) {
-      markToolCallActive({ sessionID, callID: part.callID });
-    }
-    if (["completed", "error"].includes(part.state?.status)) {
-      const identifiers = [...new Set([part.callID, part.id].filter((value) => typeof value === "string"))];
-      for (const callID of identifiers)
-        markToolCallFinished({ sessionID, callID });
-    }
-    return;
-  }
-  const started = ["session.next.shell.started", "session.next.tool.called"].includes(event?.type);
-  const finished = ["session.next.shell.ended", "session.next.tool.success", "session.next.tool.failed"].includes(event?.type);
-  if (started)
-    markToolCallActive(props);
-  if (finished)
-    markToolCallFinished(props);
+function goalStatusText(job) {
+  const status = job?.goalStatus || (isGoalJob(job) ? "active" : "");
+  if (!status)
+    return "";
+  if (status === "completed")
+    return "completed";
+  if (status === "blocked")
+    return "blocked";
+  if (job?.paused)
+    return "paused";
+  return status;
 }
-function startHeartbeat() {
-  if (heartbeatTimer)
-    return;
-  heartbeatTimer = setInterval(() => {
-    for (const [sessionID, info] of [...knownSessions.entries()]) {
-      if (!info || now() - (info.seenAt || 0) > 12 * 60 * 60 * 1000) {
-        knownSessions.delete(sessionID);
-        continue;
-      }
-      Promise.resolve().then(async () => {
-        await finalizeActiveRun(info.directory, info.client, sessionID, { requireIdle: true, forceStale: true });
-        await maybeRunDueJobs(info.directory, info.client, sessionID, { heartbeat: true });
-      }).catch((error) => appendLoopLog(info.directory, "heartbeat-error", { sessionID, error: sdkErrorMessage(error) }).catch(() => {}));
-    }
-    if (!knownSessions.size && heartbeatTimer) {
-      clearInterval(heartbeatTimer);
-      heartbeatTimer = undefined;
+
+// src/source/opencode/command-router.js
+var HANDLER_NAMES = [
+  "addGoal",
+  "statusGoal",
+  "pauseGoal",
+  "resumeGoal",
+  "clearGoal",
+  "completeGoalCommand",
+  "blockGoalCommand",
+  "addLoop",
+  "stopLoop",
+  "statusLoop",
+  "logsLoop",
+  "helpLoop",
+  "runNow",
+  "updateJobState",
+  "doctorLoop",
+  "initLoop",
+  "exportLoop"
+];
+function requireFunction(value, name) {
+  if (typeof value !== "function")
+    throw new TypeError(`createCommandRouter requires ${name}`);
+  return value;
+}
+function createCommandRouter(options = {}) {
+  const rememberSession = requireFunction(options.rememberSession, "rememberSession");
+  const captureSessionExecutionContext2 = typeof options.captureSessionExecutionContext === "function" ? options.captureSessionExecutionContext : captureSessionExecutionContext;
+  const guardLoopOwnedUserMessage2 = typeof options.guardLoopOwnedUserMessage === "function" ? options.guardLoopOwnedUserMessage : guardLoopOwnedUserMessage;
+  const handlers = {};
+  for (const name of HANDLER_NAMES)
+    handlers[name] = requireFunction(options.handlers?.[name], `handlers.${name}`);
+  return async function handleCommand(directory, client, input, fallbackName, fallbackArgs, output, source = "before") {
+    const name = commandName(input?.command ?? input?.name ?? fallbackName);
+    const sessionID = input?.sessionID;
+    const args = commandArgsText(input?.arguments ?? fallbackArgs ?? "");
+    if (!sessionID || !name)
+      return false;
+    rememberSession(directory, client, sessionID);
+    if (isLoopCommandName(name))
+      await captureSessionExecutionContext2(client, sessionID);
+    if (source === "event") {
+      if (consumeHandled(sessionID, name, args))
+        return true;
+      if (hasHandledCommandEvent(sessionID, input?.messageID))
+        return true;
+      markHandledCommandEvent(sessionID, input?.messageID);
+    } else {
+      markHandled(sessionID, name, args);
     }
-  }, HEARTBEAT_MS);
-}
-function disposeRuntime(directory, client) {
-  const sessions = [...knownSessions.entries()].filter(([, info]) => info?.directory === directory && info?.client === client).map(([sessionID]) => sessionID);
-  for (const sessionID of sessions) {
-    clearActiveRun(sessionID);
-    const idle = idleTimers.get(sessionID);
-    if (idle)
-      clearTimeout(idle);
-    const due = dueTimers.get(sessionID);
-    if (due)
-      clearTimeout(due);
-    const watchdog = watchdogTimers.get(sessionID);
-    if (watchdog)
-      clearInterval(watchdog);
-    idleTimers.delete(sessionID);
-    dueTimers.delete(sessionID);
-    watchdogTimers.delete(sessionID);
-    runLocks.delete(sessionID);
-    knownSessions.delete(sessionID);
-    loopOwnedUserMessageGuards.delete(sessionID);
-    activeToolCalls.delete(sessionID);
-    sessionParents.delete(sessionID);
-    sessionStatuses.delete(sessionID);
-    sessionStatusSeenAt.delete(sessionID);
-    deleteSessionExecutionContext(sessionID);
-    loopCompactionRequests.delete(sessionID);
-    for (const key of handledCommands.keys())
-      if (key.startsWith(`${sessionID}:`))
-        handledCommands.delete(key);
-    for (const key of handledCommandEvents.keys())
-      if (key.startsWith(`${sessionID}:`))
-        handledCommandEvents.delete(key);
-  }
-  if (!knownSessions.size && heartbeatTimer) {
-    clearInterval(heartbeatTimer);
-    heartbeatTimer = undefined;
-  }
-}
-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));
+    if (isLoopCommandName(name))
+      guardLoopOwnedUserMessage2(sessionID);
+    const handled = () => {
+      if (output && typeof output === "object")
+        output.noReply = true;
+      return true;
+    };
+    if (name === "loop-goal")
+      return await handlers.addGoal(directory, client, sessionID, args), handled();
+    if (name === "loop-goal-status")
+      return await handlers.statusGoal(directory, client, sessionID), handled();
+    if (name === "loop-goal-pause")
+      return await handlers.pauseGoal(directory, client, sessionID, args), handled();
+    if (name === "loop-goal-resume")
+      return await handlers.resumeGoal(directory, client, sessionID, args), handled();
+    if (name === "loop-goal-clear")
+      return await handlers.clearGoal(directory, client, sessionID, args), handled();
+    if (name === "loop-goal-done" || name === "loop-goal-complete")
+      return await handlers.completeGoalCommand(directory, client, sessionID, args), handled();
+    if (name === "loop-goal-blocked")
+      return await handlers.blockGoalCommand(directory, client, sessionID, args), handled();
+    if (name === "loop")
+      return await handlers.addLoop(directory, client, sessionID, args), handled();
+    if (isPreset(name))
+      return await handlers.addLoop(directory, client, sessionID, args, presetDefaults(name, args)), handled();
+    if (name === "loop-stop" || name === "loop-remove")
+      return await handlers.stopLoop(directory, client, sessionID, args), handled();
+    if (name === "loop-clear")
+      return await handlers.stopLoop(directory, client, sessionID, "all"), handled();
+    if (name === "loop-status")
+      return await handlers.statusLoop(directory, client, sessionID), handled();
+    if (name === "loop-logs")
+      return await handlers.logsLoop(directory, client, sessionID), handled();
+    if (name === "loop-help")
+      return await handlers.helpLoop(client, sessionID), handled();
+    if (name === "loop-now")
+      return await handlers.runNow(directory, client, sessionID, args), handled();
+    if (name === "loop-pause")
+      return await handlers.updateJobState(directory, client, sessionID, args, (job) => ({ ...job, paused: true }), "Paused"), handled();
+    if (name === "loop-resume")
+      return await handlers.updateJobState(directory, client, sessionID, args, (job) => ({ ...job, paused: false, lastRunAt: 0 }), "Resumed"), handled();
+    if (name === "loop-doctor")
+      return await handlers.doctorLoop(directory, client, sessionID), handled();
+    if (name === "loop-init")
+      return await handlers.initLoop(directory, client, sessionID, args), handled();
+    if (name === "loop-export")
+      return await handlers.exportLoop(directory, client, sessionID), handled();
+    if (source === "event")
+      forgetHandledCommandEvent(sessionID, input?.messageID);
+    else
+      consumeHandled(sessionID, name, args);
+    return false;
+  };
 }
+
+// src/source/runtime/goal-runtime.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:
@@ -1407,583 +1316,57 @@ ${sections.join(`
 
 `)}`;
 }
-async function buildPrompt(directory, job) {
-  if (isGoalJob(job))
-    return await buildGoalPrompt(directory, job);
-  const sections = [];
-  if (job.promptFile) {
-    const text = await readSmallTextFile(path3.resolve(directory, job.promptFile));
-    if (text.trim())
-      sections.push(`Instructions from ${job.promptFile}:
-${text.trim()}`);
-    else
-      sections.push(`Prompt file ${job.promptFile} was requested but could not be read. Continue from the regular action instead.`);
+function goalReportPath(directory, sessionID, job) {
+  return path3.join(stateDir(directory), GOAL_REPORT_DIR, `${safeID(sessionID)}-${safeID(job.name || job.id)}.md`);
+}
+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.action)
-    sections.push(decoratePrompt(job));
-  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)}`);
+  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 sections.join(`
-
----
-
-`) || 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, 1e4);
-  if (inRepo.code !== 0) {
-    job.branchDone = true;
-    return job;
-  }
-  let result = await runProcess("git", ["switch", branch], directory, 30000);
-  if (result.code !== 0)
-    result = await runProcess("git", ["switch", "-c", branch], directory, 30000);
-  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 maybeCompact(directory, client, sessionID, job) {
-  const dueRuns = job.compactEveryRuns > 0 && (job.runCount || 0) > 0 && (job.runCount || 0) % job.compactEveryRuns === 0 && job.lastCompactRunCount !== job.runCount;
-  const dueTime = job.compactEveryMs > 0 && (!job.lastCompactAt || now() - job.lastCompactAt >= job.compactEveryMs);
-  if (!dueRuns && !dueTime)
-    return { job, started: false };
-  beginLoopCompaction(sessionID, job.id, true);
-  if (await compactSession(directory, client, sessionID, job.model)) {
-    job.lastCompactAt = now();
-    job.lastCompactRunCount = job.runCount || 0;
-    return { job, started: true };
-  }
-  loopCompactionRequests.delete(sessionID);
-  return { job, started: false };
-}
-async function snapshotPaths(directory, files) {
-  const snapshot = {};
-  for (const file of files || []) {
-    try {
-      const stat = await fs3.stat(path3.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 fs3.stat(filePath);
-    if (!stat.isFile() || stat.size > MAX_SCAN_BYTES)
-      return false;
-    return (await fs3.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", path3.join(".opencode", "opencode-loop", "until.txt")];
-  for (const file of files)
-    if (await fileContains(path3.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 fs3.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 = path3.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, 1e4);
-  if (inRepo.code !== 0)
-    return;
-  const status = await runProcess("git", ["status", "--short"], directory, 30000);
-  if (!status.stdout.trim())
-    return;
-  const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-  const checkpointDir = path3.join(stateDir(directory), "checkpoints", safeID(sessionID));
-  await ensureDir(checkpointDir);
-  const diff = await runProcess("git", ["diff", "--binary"], directory, 120000);
-  const staged = await runProcess("git", ["diff", "--cached", "--binary"], directory, 120000);
-  const prefix = `${timestamp}-${safeID(job.name || job.id)}`;
-  await fs3.writeFile(path3.join(checkpointDir, `${prefix}.status.txt`), status.stdout + status.stderr);
-  await fs3.writeFile(path3.join(checkpointDir, `${prefix}.patch`), `${diff.stdout}
-${staged.stdout}`);
-  if (job.gitCheckpoint) {
-    await runProcess("git", ["add", "-A"], directory, 120000);
-    await runProcess("git", ["commit", "-m", `chore: opencode loop checkpoint ${timestamp}`], directory, 120000);
-  }
-  await toast(client, `Loop checkpoint saved: ${prefix}`, "success");
-}
-function updateSessionStatusFromEvent(event) {
-  const sessionID = event?.properties?.sessionID;
-  if (typeof sessionID !== "string")
-    return;
-  if (event?.type === "session.idle") {
-    sessionStatuses.set(sessionID, "idle");
-    sessionStatusSeenAt.set(sessionID, now());
-    return { sessionID, idle: true };
-  }
-  if (event?.type === "session.status") {
-    const status = event?.properties?.status;
-    const type = status && typeof status === "object" ? status.type : undefined;
-    if (typeof type === "string") {
-      sessionStatuses.set(sessionID, type);
-      sessionStatusSeenAt.set(sessionID, now());
-    }
-    return { sessionID, idle: type === "idle" };
-  }
-  return;
-}
-function userInterruptSessionFromEvent(event) {
-  if (!["message.updated", "message.created"].includes(String(event?.type || "")))
-    return;
-  const props = event?.properties || {};
-  const info = props.info || props.message || props;
-  const role = info?.role;
-  const sessionID = info?.sessionID || props.sessionID;
-  const messageID = info?.id || props.messageID;
-  if (role !== "user" || typeof sessionID !== "string")
-    return;
-  if (loopOwnedUserMessageGuardActive(sessionID, messageID))
-    return;
-  return sessionID;
-}
-async function pauseGoalsForUserInterrupt(directory, client, sessionID) {
-  const state = await readState(directory, sessionID);
-  const interruptedAt = now();
-  let count = 0;
-  state.jobs = (state.jobs || []).map((job) => {
-    if (!isGoalJob(job) || job.paused || job.enabled === false || ["completed", "blocked", "cleared"].includes(job.goalStatus))
-      return job;
-    count++;
-    return {
-      ...job,
-      paused: true,
-      lastUserInterruptAt: interruptedAt,
-      goalInterruptedReason: "Paused because the user sent a new message while the experimental goal was active."
-    };
-  });
-  if (!count)
-    return false;
-  await writeState(directory, sessionID, state);
-  await toast(client, `Paused ${count} experimental goal(s) because a new user message arrived. Resume with /loop-goal-resume.`, "warning");
-  await appendLoopLog(directory, "goal-user-interrupt", { sessionID, count });
-  await scheduleDueWork(directory, client, sessionID);
-  return true;
-}
-function staleActiveRun(sessionID) {
-  const active = activeRuns.get(sessionID);
-  if (!active)
-    return false;
-  const age = now() - (active.startedAt || 0);
-  const configured = Number(active.job?.staleActiveRecoveryMs || active.job?.activeRecoveryMs || 0);
-  const threshold = Number.isFinite(configured) && configured > 0 ? configured : STALE_ACTIVE_RECOVERY_MS;
-  return age >= threshold;
-}
-async function canFinalizeActiveRun(directory, client, sessionID, active, options = {}) {
-  if (hasActiveToolCalls(sessionID) || hasBusyDescendant(sessionID))
-    return false;
-  if (!options.requireIdle && !options.forceStale)
-    return true;
-  const completion = options.forceStale ? await activeRunCompletionFromMessages(directory, client, sessionID, active) : undefined;
-  if (completion === "completed")
-    return true;
-  if (!options.requireIdle)
-    return completion === "unknown" && staleActiveRun(sessionID);
-  const live = await readLiveSessionStatus(client, sessionID, directory);
-  if (live?.type === "idle")
-    return true;
-  if (live?.type) {
-    if ((live.type === "busy" || live.type === "retry") && options.forceStale && completion === "unknown" && staleActiveRun(sessionID))
-      return true;
-    return false;
-  }
-  if (options.forceStale && completion === "unknown" && staleActiveRun(sessionID))
-    return true;
-  const cached = sessionStatuses.get(sessionID);
-  const seenAt = sessionStatusSeenAt.get(sessionID) || 0;
-  return cached === "idle" && seenAt > (active.startedAt || 0);
-}
-async function readLiveSessionStatus(client, sessionID, directory) {
-  const argsList = [];
-  if (directory)
-    argsList.push({ query: { directory } }, { directory }, { workspace: directory });
-  argsList.push({});
-  for (const args of argsList) {
-    try {
-      const result = await client.session.status(args);
-      const error = sdkError(result);
-      if (error)
-        continue;
-      const data = sdkData(result);
-      if (!data || typeof data !== "object" || Array.isArray(data))
-        continue;
-      const observedAt = now();
-      for (const [observedSessionID, observedStatus] of Object.entries(data)) {
-        const observedType = observedStatus && typeof observedStatus === "object" ? observedStatus.type : undefined;
-        if (typeof observedType !== "string")
-          continue;
-        sessionStatuses.set(observedSessionID, observedType);
-        sessionStatusSeenAt.set(observedSessionID, observedAt);
-      }
-      for (const childID of sessionParents.keys()) {
-        if (!isDescendantSession(childID, sessionID) || data[childID])
-          continue;
-        sessionStatuses.set(childID, "idle");
-        sessionStatusSeenAt.set(childID, observedAt);
-      }
-      if (hasBusyDescendant(sessionID))
-        return { type: "busy", source: "descendant" };
-      const status = data?.[sessionID];
-      const type = status && typeof status === "object" ? status.type : undefined;
-      if (typeof type === "string")
-        return { type, source: "sdk" };
-      return { type: "idle", source: "sdk" };
-    } catch {}
-  }
-  return;
-}
-async function sessionStatusType(client, sessionID, directory, options = {}) {
-  if (hasActiveToolCalls(sessionID) || hasBusyDescendant(sessionID)) {
-    sessionStatuses.set(sessionID, "busy");
-    sessionStatusSeenAt.set(sessionID, now());
-    return "busy";
-  }
-  const cached = sessionStatuses.get(sessionID);
-  const seenAt = sessionStatusSeenAt.get(sessionID) || 0;
-  if (cached === "idle")
-    return cached;
-  if (cached && now() - seenAt < SESSION_STATUS_CACHE_MS)
-    return cached;
-  const live = await readLiveSessionStatus(client, sessionID, directory);
-  if (live?.type) {
-    if ((live.type === "busy" || live.type === "retry") && options.recoverStaleActive !== false) {
-      const active = activeRuns.get(sessionID);
-      if (active) {
-        const completion = await activeRunCompletionFromMessages(directory, client, sessionID, active);
-        if (completion === "completed" || completion === "unknown" && staleActiveRun(sessionID)) {
-          sessionStatuses.set(sessionID, "idle");
-          sessionStatusSeenAt.set(sessionID, now());
-          await appendLoopLog(directory, completion === "completed" ? "status-message-complete-recovery" : "status-stale-recovery", {
-            sessionID,
-            job: active.job?.name || active.jobId,
-            startedAt: active.startedAt
-          });
-          return "idle";
-        }
-      }
-    }
-    sessionStatuses.set(sessionID, live.type);
-    sessionStatusSeenAt.set(sessionID, now());
-    return live.type;
-  }
-  const fallback = activeRuns.has(sessionID) && !staleActiveRun(sessionID) ? "busy" : "idle";
-  sessionStatuses.set(sessionID, fallback);
-  sessionStatusSeenAt.set(sessionID, now());
-  return fallback;
-}
-async function sessionIsIdle(client, sessionID, directory, options = {}) {
-  return await sessionStatusType(client, sessionID, directory, options) === "idle";
-}
-function scheduleIdleWork(directory, client, sessionID) {
-  const previous = idleTimers.get(sessionID);
-  if (previous)
-    clearTimeout(previous);
-  const timer = setTimeout(() => {
-    idleTimers.delete(sessionID);
-    Promise.resolve().then(async () => {
-      if (!await sessionIsIdle(client, sessionID, directory)) {
-        await scheduleDueWork(directory, client, sessionID, BUSY_RETRY_MS);
-        return;
-      }
-      await finalizeActiveRun(directory, client, sessionID);
-      if (!await sessionIsIdle(client, sessionID, directory)) {
-        await scheduleDueWork(directory, client, sessionID, BUSY_RETRY_MS);
-        return;
-      }
-      await maybeRunDueJobs(directory, client, sessionID);
-    }).catch((error) => {
-      toast(client, `Loop idle handler failed: ${sdkErrorMessage(error)}`, "error").catch(() => {});
-      appendLoopLog(directory, "idle-error", { sessionID, error: sdkErrorMessage(error) }).catch(() => {});
-    });
-  }, IDLE_DEBOUNCE_MS);
-  idleTimers.set(sessionID, timer);
-}
-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 (job.watchPaths?.length)
-    return Infinity;
-  const created = Date.parse(job.createdAt || new Date().toISOString());
-  if (job.maxRuntimeMs > 0 && current - created >= job.maxRuntimeMs)
-    return current;
-  if (job.intervalMs === 0)
-    return current;
-  if (!job.lastRunAt)
-    return current;
-  return job.lastRunAt + (job.intervalMs || 0);
-}
-function nextDueDelay(state) {
-  const 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);
-}
-async function startWatchdog(directory, client, sessionID) {
-  if (watchdogTimers.has(sessionID))
-    return;
-  const timer = setInterval(() => {
-    Promise.resolve().then(async () => {
-      const state = await readState(directory, sessionID);
-      const delay2 = nextDueDelay(state);
-      const hasJobs = (state.jobs || []).some((job) => job.enabled !== false && !job.paused && (!isGoalJob(job) || !["completed", "blocked", "cleared"].includes(job.goalStatus)));
-      if (!hasJobs || !Number.isFinite(delay2)) {
-        const existing = watchdogTimers.get(sessionID);
-        if (existing)
-          clearInterval(existing);
-        watchdogTimers.delete(sessionID);
-        return;
-      }
-      if (delay2 <= 0)
-        await maybeRunDueJobs(directory, client, sessionID);
-      else
-        await scheduleDueWork(directory, client, sessionID);
-    }).catch((error) => appendLoopLog(directory, "watchdog-error", { sessionID, error: sdkErrorMessage(error) }).catch(() => {}));
-  }, Math.max(1000, BUSY_RETRY_MS));
-  watchdogTimers.set(sessionID, timer);
-}
-function stopWatchdog(sessionID) {
-  const timer = watchdogTimers.get(sessionID);
-  if (timer)
-    clearInterval(timer);
-  watchdogTimers.delete(sessionID);
-}
-async function scheduleDueWork(directory, client, sessionID, minDelayMs = 0) {
-  const previous = dueTimers.get(sessionID);
-  if (previous)
-    clearTimeout(previous);
-  const state = await readState(directory, sessionID);
-  const delay2 = nextDueDelay(state);
-  if (!Number.isFinite(delay2)) {
-    dueTimers.delete(sessionID);
-    return;
-  }
-  const wait = Math.min(Math.max(delay2, minDelayMs, MIN_DUE_TIMER_MS), MAX_DUE_TIMER_MS);
-  const timer = setTimeout(() => {
-    dueTimers.delete(sessionID);
-    Promise.resolve().then(async () => {
-      if (!await sessionIsIdle(client, sessionID, directory)) {
-        await scheduleDueWork(directory, client, sessionID, BUSY_RETRY_MS);
-        return;
-      }
-      await finalizeActiveRun(directory, client, sessionID);
-      if (!await sessionIsIdle(client, sessionID, directory)) {
-        await scheduleDueWork(directory, client, sessionID, BUSY_RETRY_MS);
-        return;
-      }
-      await maybeRunDueJobs(directory, client, sessionID);
-    }).catch((error) => {
-      toast(client, `Loop due timer failed: ${sdkErrorMessage(error)}`, "error").catch(() => {});
-      appendLoopLog(directory, "due-timer-error", { sessionID, error: sdkErrorMessage(error) }).catch(() => {});
-    });
-  }, wait);
-  dueTimers.set(sessionID, timer);
-  await startWatchdog(directory, client, sessionID);
-}
-function dueJobs(state, force = false) {
-  const current = now();
-  return (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 (force)
-      return true;
-    if (job.watchPaths?.length)
-      return job.watchTriggered === true;
-    return job.intervalMs === 0 || !job.lastRunAt || current - job.lastRunAt >= job.intervalMs;
-  });
-}
-function clearActiveRun(sessionID) {
-  const active = activeRuns.get(sessionID);
-  if (active?.timer)
-    clearTimeout(active.timer);
-  const compact = loopCompactionRequests.get(sessionID);
-  if (!compact || !active || compact.jobId === active.jobId)
-    loopCompactionRequests.delete(sessionID);
-  activeRuns.delete(sessionID);
-}
-function beginLoopCompaction(sessionID, jobId, resumeAfter = false) {
-  loopCompactionRequests.set(sessionID, {
-    jobId,
-    resumeAfter,
-    requestedAt: now(),
-    startedAt: 0,
-    completedAt: 0
-  });
-}
-async function noteLoopCompactionStarted(directory, sessionID) {
-  const pending = loopCompactionRequests.get(sessionID);
-  if (!pending)
-    return false;
-  if (!pending.startedAt) {
-    pending.startedAt = now();
-    loopCompactionRequests.set(sessionID, pending);
-    await appendLoopLog(directory, "compact-started", { sessionID, job: pending.jobId, resumeAfter: pending.resumeAfter });
-  }
-  return true;
-}
-async function finalizeLoopCompaction(directory, client, sessionID) {
-  const pending = loopCompactionRequests.get(sessionID);
-  const active = activeRuns.get(sessionID);
-  if (!pending || !active || pending.jobId !== active.jobId)
-    return false;
-  return await finalizeActiveRun(directory, client, sessionID);
-}
-async function noteLoopCompactionCompleted(directory, client, sessionID) {
-  const pending = loopCompactionRequests.get(sessionID);
-  if (!pending)
-    return false;
-  pending.completedAt = now();
-  loopCompactionRequests.set(sessionID, pending);
-  await appendLoopLog(directory, "compact-event", { sessionID, job: pending.jobId, resumeAfter: pending.resumeAfter });
-  const timer = setTimeout(() => {
-    finalizeLoopCompaction(directory, client, sessionID).catch((error) => log(client, "error", "compaction finalization failed", { error: sdkErrorMessage(error) }));
-  }, 0);
-  timer.unref?.();
-  return true;
-}
-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);
-  sessionStatuses.delete(sessionID);
-  sessionStatusSeenAt.delete(sessionID);
-  const message = sdkErrorMessage(error);
-  const state = await readState(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 = now();
-    if (job.maxFailures > 0 && job.failureCount >= job.maxFailures) {
-      job.paused = true;
-      await notifyJob(directory, job, "dispatch_failed");
-    }
-    state.jobs = (state.jobs || []).map((candidate) => candidate.id === job.id ? job : candidate);
-    await writeState(directory, sessionID, state);
-  }
-  await appendLoopLog(directory, "dispatch-error", { sessionID, job: job?.name || jobId, error: message });
-  await toast(client, `Loop dispatch failed${job?.paused ? " and paused" : ""}: ${message}`, job?.paused ? "error" : "warning");
-  await scheduleDueWork(directory, client, sessionID, BUSY_RETRY_MS);
-  return true;
-}
-function goalReportPath(directory, sessionID, job) {
-  return path3.join(stateDir(directory), GOAL_REPORT_DIR, `${safeID(sessionID)}-${safeID(job.name || job.id)}.md`);
-}
-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(`
-`);
+  return lines.join(`
+`);
 }
 async function writeGoalReport(directory, sessionID, job) {
   if (!isGoalJob(job))
@@ -2023,16 +1406,6 @@ function goalChecksPassed(job) {
 function goalRequiresPassingChecks(job) {
   return job?.goalRequireChecksPass !== false && Array.isArray(job?.goalChecks) && job.goalChecks.length > 0;
 }
-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}` };
-}
 function goalProgressSnapshot(job) {
   return {
     status: job?.goalStatus || "",
@@ -2059,28 +1432,15 @@ function goalMadeMeaningfulProgress(beforeJob, afterJob) {
     return true;
   return false;
 }
-async function applyGoalNoProgressGuard(directory, client, sessionID, job, beforeJob) {
-  if (!isGoalJob(job) || ["completed", "blocked"].includes(job.goalStatus) || job.paused || job.enabled === false)
-    return job;
-  const limit = Number(job.maxNoProgress ?? DEFAULT_GOAL_MAX_NO_PROGRESS);
-  if (!Number.isFinite(limit) || limit <= 0)
-    return job;
-  if (goalMadeMeaningfulProgress(beforeJob, job)) {
-    job.noProgressCount = 0;
-    job.lastProgressAt = now();
-    return job;
-  }
-  job.noProgressCount = (job.noProgressCount || 0) + 1;
-  job.lastNoProgressAt = now();
-  await appendLoopLog(directory, "goal-no-progress", { sessionID, job: job.name || job.id, count: job.noProgressCount, limit });
-  if (job.noProgressCount >= limit) {
-    job.paused = true;
-    job.goalNoProgressPausedAt = now();
-    job.goalNoProgressReason = `Paused after ${job.noProgressCount} turn(s) without recorded progress. Resume with /loop-goal-resume after adjusting the goal or evidence.`;
-    await toast(client, job.goalNoProgressReason, "warning");
-    await appendLoopLog(directory, "goal-no-progress-paused", { sessionID, job: job.name || job.id, count: job.noProgressCount, limit });
-  }
-  return job;
+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}` };
 }
 async function setGoalComplete(directory, sessionID, args = {}) {
   const state = await readState(directory, sessionID);
@@ -2149,694 +1509,2064 @@ async function setGoalProgress(directory, sessionID, args = {}) {
   await appendLoopLog(directory, "goal-progress", { sessionID, job: job.name || job.id, summary: item.summary });
   return { ok: true, job, message: `Goal progress recorded: ${item.summary}` };
 }
-async function runGoalChecks(directory, sessionID, job, client) {
-  if (!isGoalJob(job) || !job.goalChecks?.length || ["completed", "blocked"].includes(job.goalStatus))
-    return job;
-  const results = [];
-  for (const command of job.goalChecks) {
-    if (job.safe && dangerousShell(command)) {
-      results.push({ command, code: -1, output: "Blocked dangerous command in safe mode." });
-      continue;
+
+// src/source/opencode/goal-commands.js
+function requireFunction2(value, name) {
+  if (typeof value !== "function")
+    throw new TypeError(`createGoalCommandHandlers requires ${name}`);
+  return value;
+}
+function createGoalCommandHandlers(options = {}) {
+  const addLoop = requireFunction2(options.addLoop, "addLoop");
+  const scheduleDueWork = requireFunction2(options.scheduleDueWork, "scheduleDueWork");
+  const scheduleIdleWork = requireFunction2(options.scheduleIdleWork, "scheduleIdleWork");
+  const toast2 = requireFunction2(options.toast, "toast");
+  const say2 = requireFunction2(options.say, "say");
+  const readState2 = typeof options.readState === "function" ? options.readState : readState;
+  const writeState2 = typeof options.writeState === "function" ? options.writeState : writeState;
+  const setGoalComplete2 = typeof options.setGoalComplete === "function" ? options.setGoalComplete : setGoalComplete;
+  const setGoalBlocked2 = typeof options.setGoalBlocked === "function" ? options.setGoalBlocked : setGoalBlocked;
+  async function statusGoal(directory, client, sessionID) {
+    const state = await readState2(directory, sessionID);
+    const goals = (state.jobs || []).filter(isGoalJob);
+    const lines = goals.length ? goals.map((job, index) => {
+      const status = goalStatusText(job);
+      const checks = job.goalChecks?.length ? ` | checks=${job.goalChecks.length}` : "";
+      const acceptance = job.goalAcceptance?.length ? ` | acceptance=${job.goalAcceptance.length}` : "";
+      const progress = job.goalProgress?.length ? ` | progress=${job.goalProgress.length}` : "";
+      const noProgress = (job.maxNoProgress ?? DEFAULT_GOAL_MAX_NO_PROGRESS) > 0 ? ` | no-progress=${job.noProgressCount || 0}/${job.maxNoProgress ?? DEFAULT_GOAL_MAX_NO_PROGRESS}` : "";
+      const rejected = job.goalCompletionRejectedReason ? " | completion-rejected" : "";
+      return `${index + 1}. ${job.id}${job.name ? ` (${job.name})` : ""}: ${status} | turns=${job.runCount || 0} | objective=${String(job.action || job.goalFile || "").slice(0, 220)}${checks}${acceptance}${progress}${noProgress}${rejected}`;
+    }) : ["No experimental goal jobs."];
+    await toast2(client, goals.length ? `${goals.length} experimental goal(s).` : "No experimental goal jobs.", goals.length ? "info" : "warning");
+    await say2(client, sessionID, `OpenCode Loop experimental goal status:
+` + lines.join(`
+`));
+  }
+  async function pauseGoal(directory, client, sessionID, args) {
+    const target = String(args || "").trim() || "goal";
+    const state = await readState2(directory, sessionID);
+    let count = 0;
+    state.jobs = (state.jobs || []).map((job, index) => isGoalJob(job) && matchJob(job, target, index) ? (count++, { ...job, paused: true }) : job);
+    await writeState2(directory, sessionID, state);
+    await scheduleDueWork(directory, client, sessionID);
+    await toast2(client, `Paused ${count} experimental goal(s).`, count ? "success" : "warning");
+  }
+  async function resumeGoal(directory, client, sessionID, args) {
+    const target = String(args || "").trim() || "goal";
+    const state = await readState2(directory, sessionID);
+    let count = 0;
+    state.jobs = (state.jobs || []).map((job, index) => {
+      if (!isGoalJob(job) || !matchJob(job, target, index))
+        return job;
+      count++;
+      return { ...job, paused: false, enabled: true, goalStatus: job.goalStatus === "blocked" ? "active" : job.goalStatus || "active", lastRunAt: 0, noProgressCount: 0, goalNoProgressReason: "", goalInterruptedReason: "" };
+    });
+    await writeState2(directory, sessionID, state);
+    await toast2(client, `Resumed ${count} experimental goal(s).`, count ? "success" : "warning");
+    if (count) {
+      await scheduleDueWork(directory, client, sessionID);
+      scheduleIdleWork(directory, client, sessionID);
     }
-    const result = await runShellCommand(command, directory, job.timeoutMs || 300000);
-    results.push({ command, code: result.code, output: (result.stdout + `
-` + result.stderr).slice(0, 1200) });
   }
-  job.lastGoalCheckAt = now();
-  job.lastGoalChecks = results;
-  const allPassed = results.length > 0 && results.every((item) => item.code === 0);
-  if (allPassed) {
-    job.goalChecksPassedAt = now();
-    job.failureCount = 0;
-    await toast(client, "Goal checks passed.", "success");
-    if (job.goalCompleteWhenChecksPass) {
-      job.goalStatus = "completed";
-      job.enabled = false;
+  async function clearGoal(directory, client, sessionID, args) {
+    const target = String(args || "").trim();
+    const state = await readState2(directory, sessionID);
+    const before = state.jobs.length;
+    state.jobs = (state.jobs || []).filter((job, index) => !isGoalJob(job) || target && !matchJob(job, target, index));
+    await writeState2(directory, sessionID, state);
+    await scheduleDueWork(directory, client, sessionID);
+    await toast2(client, `Cleared ${before - state.jobs.length} experimental goal(s).`, before !== state.jobs.length ? "success" : "warning");
+  }
+  async function completeGoalCommand(directory, client, sessionID, args) {
+    const result = await setGoalComplete2(directory, sessionID, { summary: String(args || "").trim() || "Goal manually marked complete.", evidence: "Marked complete by /loop-goal-done.", manual: true });
+    await toast2(client, result.message, result.ok ? "success" : "warning");
+  }
+  async function blockGoalCommand(directory, client, sessionID, args) {
+    const result = await setGoalBlocked2(directory, sessionID, { reason: String(args || "").trim() || "Goal manually marked blocked.", needed: "User input or manual intervention." });
+    await toast2(client, result.message, "warning");
+  }
+  async function addGoal(directory, client, sessionID, args) {
+    const text = String(args || "").trim();
+    const [maybeCommand, rest] = splitFirst(text);
+    const sub = maybeCommand.toLowerCase();
+    if (!text || sub === "status")
+      return await statusGoal(directory, client, sessionID);
+    if (sub === "pause")
+      return await pauseGoal(directory, client, sessionID, rest);
+    if (sub === "resume")
+      return await resumeGoal(directory, client, sessionID, rest);
+    if (["clear", "remove", "stop"].includes(sub))
+      return await clearGoal(directory, client, sessionID, rest);
+    if (["done", "complete", "completed"].includes(sub))
+      return await completeGoalCommand(directory, client, sessionID, rest);
+    if (["blocked", "block"].includes(sub))
+      return await blockGoalCommand(directory, client, sessionID, rest);
+    return await addLoop(directory, client, sessionID, text, { intervalMs: 0, kind: "goal", name: "goal", immediate: true, safe: true, askNever: true, noOverlap: true, goalStatus: "active" });
+  }
+  return {
+    addGoal,
+    statusGoal,
+    pauseGoal,
+    resumeGoal,
+    clearGoal,
+    completeGoalCommand,
+    blockGoalCommand
+  };
+}
+
+// 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.
+
+## 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;
+  const writeState2 = typeof options.writeState === "function" ? options.writeState : writeState;
+  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 runtimeVersion = options.runtimeVersion || process.version;
+  const runtimePlatform = options.runtimePlatform || process.platform;
+  async function stopLoop(directory, client, sessionID, args) {
+    const target = String(args || "").trim();
+    if (!target || target.toLowerCase() === "all") {
+      await removeState2(directory, sessionID);
+      clearActiveRun(sessionID);
+      cancelDueWork(sessionID);
+      stopWatchdog(sessionID);
+      await toast2(client, "All loops stopped for this session.", "success");
+      return;
+    }
+    const state = await readState2(directory, sessionID);
+    const before = state.jobs.length;
+    state.jobs = state.jobs.filter((job, index) => !matchJob(job, target, index));
+    await writeState2(directory, sessionID, state);
+    await scheduleDueWork(directory, client, sessionID);
+    await toast2(client, `Stopped ${before - state.jobs.length} loop(s).`, "success");
+  }
+  async function updateJobState(directory, client, sessionID, args, updater, message) {
+    const target = String(args || "").trim() || "all";
+    const state = await readState2(directory, sessionID);
+    let count = 0;
+    state.jobs = (state.jobs || []).map((job, index) => matchJob(job, target, index) ? (count++, updater(job)) : job);
+    await writeState2(directory, sessionID, state);
+    await scheduleDueWork(directory, client, sessionID);
+    await toast2(client, `${message}: ${count} loop(s).`, count ? "success" : "warning");
+  }
+  async function statusLoop(directory, client, sessionID) {
+    const state = await readState2(directory, sessionID);
+    const jobs = state.jobs || [];
+    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 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}`;
+    }) : ["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:
+` + lines.join(`
+`));
+  }
+  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;
+    } catch {}
+    await say2(client, sessionID, `OpenCode loop logs:
+` + text);
+  }
+  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-doctor | /loop-init | /loop-export"
+    ].join(`
+`));
+  }
+  async function runNow(directory, client, sessionID, args) {
+    const target = String(args || "").trim() || "all";
+    const state = await readState2(directory, sessionID);
+    const requestedAt = Math.max(1, Number(now2()) || Date.now());
+    let count = 0;
+    for (const [index, job] of (state.jobs || []).entries()) {
+      if (!matchJob(job, target, index))
+        continue;
+      job.lastRunAt = 0;
+      job.paused = false;
+      job.runNowRequestedAt = requestedAt;
+      count += 1;
+    }
+    await writeState2(directory, sessionID, state);
+    await toast2(client, `Marked ${count} loop job(s) due now.`, count ? "success" : "warning");
+    if (count)
+      await scheduleDueWork(directory, client, sessionID);
+  }
+  async function doctorLoop(directory, client, sessionID) {
+    const state = await readState2(directory, sessionID);
+    await say2(client, sessionID, [
+      "OpenCode Loop doctor:",
+      `- plugin: ${SERVICE2}`,
+      `- project directory: ${directory}`,
+      `- state directory: ${stateDir(directory)}`,
+      `- active jobs: ${(state.jobs || []).length}`,
+      `- node: ${runtimeVersion}`,
+      `- platform: ${runtimePlatform}`,
+      "- smoke test: /loop 0s --max-runs 1 --dry-run continue from progress.md",
+      "- experimental goal smoke test: /loop-goal --dry-run finish the current task and verify it"
+    ].join(`
+`));
+  }
+  async function initLoop(directory, client, sessionID, args) {
+    const target = String(args || "").trim() || "progress.md";
+    const full = path4.resolve(directory, target);
+    if (await pathExists2(full)) {
+      await toast2(client, `${target} already exists.`, "warning");
+      return;
+    }
+    await writeFile(full, DEFAULT_PROGRESS_MD, "utf8");
+    await toast2(client, `Created ${target}.`, "success");
+    await appendLoopLog2(directory, "init", { sessionID, file: target });
+  }
+  async function exportLoop(directory, client, sessionID) {
+    const state = await readState2(directory, sessionID);
+    await say2(client, sessionID, "OpenCode loop state export:\n```json\n" + JSON.stringify(state, null, 2) + "\n```");
+  }
+  return {
+    stopLoop,
+    updateJobState,
+    statusLoop,
+    logsLoop,
+    helpLoop,
+    runNow,
+    doctorLoop,
+    initLoop,
+    exportLoop
+  };
+}
+
+// src/source/opencode/loop-registration.js
+var DEFAULT_GOAL_ACTIVE_RECOVERY_MS = 180000;
+var FALLBACK_ACTIVE_GUARD_MS = 45000;
+function requireFunction4(value, name) {
+  if (typeof value !== "function")
+    throw new TypeError(`createLoopRegistration requires ${name}`);
+  return value;
+}
+function normalizeActionForCompare(value) {
+  return String(value || "").replace(/\s+/g, " ").trim();
+}
+function sameLoopDefinition(a, b) {
+  if (!a || !b)
+    return false;
+  return (a.name || "") === (b.name || "") && Number(a.intervalMs || 0) === Number(b.intervalMs || 0) && normalizeActionForCompare(a.action) === normalizeActionForCompare(b.action) && normalizeActionForCompare(a.kind) === normalizeActionForCompare(b.kind) && normalizeActionForCompare(a.promptFile) === normalizeActionForCompare(b.promptFile);
+}
+function createLoopRegistration(options = {}) {
+  const snapshotPaths = requireFunction4(options.snapshotPaths, "snapshotPaths");
+  const scheduleDueWork = requireFunction4(options.scheduleDueWork, "scheduleDueWork");
+  const scheduleIdleWork = requireFunction4(options.scheduleIdleWork, "scheduleIdleWork");
+  const toast2 = requireFunction4(options.toast, "toast");
+  const say2 = requireFunction4(options.say, "say");
+  const parseLoopArgs2 = typeof options.parseLoopArgs === "function" ? options.parseLoopArgs : parseLoopArgs;
+  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 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);
+    if (!parsed.ok) {
+      await toast2(client, parsed.error, "warning");
+      return;
+    }
+    const executionContext = getSessionExecutionContext2(sessionID) || { agent: "build" };
+    parsed.job.agent = defaults.agent || executionContext.agent || "build";
+    parsed.job.model = normalizedModelRef2(defaults.model) || executionContext.model;
+    if (defaults.testfixPreset) {
+      const defaultCommand = String(defaults.verifyCommand || "npm test");
+      const parsedAction = String(parsed.job.action || "").trim();
+      const usedDefaultAction = parsedAction === String(defaults.action || "").trim();
+      if (!usedDefaultAction && parsed.job.verifyCommand === defaults.verifyCommand) {
+        parsed.job.verifyCommand = parsedAction;
+        parsed.job.action = `Run the project tests. Fix failures. Re-run the tests. Test command hint: ${parsedAction}`;
+      } else if (usedDefaultAction && parsed.job.verifyCommand !== defaults.verifyCommand) {
+        parsed.job.action = `Run the project tests. Fix failures. Re-run the tests. Test command hint: ${parsed.job.verifyCommand || defaultCommand}`;
+      }
+    }
+    if (parsed.job.watchPaths.length)
+      parsed.job.watchSnapshot = await snapshotPaths(directory, parsed.job.watchPaths);
+    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));
+    }
+    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```");
+      return;
+    }
+    const state = await readState2(directory, sessionID);
+    const jobs = Array.isArray(state.jobs) ? state.jobs : [];
+    let replaced = false;
+    if (!parsed.job.multi) {
+      const targetName = parsed.job.name || "default";
+      parsed.job.name = targetName;
+      state.jobs = jobs.filter((existing) => {
+        const existingName = existing.name || "default";
+        const shouldReplace = existingName === targetName || sameLoopDefinition(existing, parsed.job);
+        if (shouldReplace)
+          replaced = true;
+        return !shouldReplace;
+      });
+    } else {
+      state.jobs = jobs;
+    }
+    state.jobs.push(parsed.job);
+    await writeState2(directory, sessionID, state);
+    await scheduleDueWork(directory, client, sessionID);
+    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) });
+  }
+  return { addLoop };
+}
+
+// src/source/runtime/session-activity.js
+var activeToolCalls = new Map;
+var sessionParents = new Map;
+var sessionStatuses = new Map;
+var sessionStatusSeenAt = new Map;
+function hasActiveToolCalls(sessionID) {
+  return (activeToolCalls.get(sessionID)?.size || 0) > 0;
+}
+function markToolCallActive(input) {
+  const sessionID = input?.sessionID;
+  const callID = input?.callID;
+  if (typeof sessionID !== "string" || typeof callID !== "string")
+    return;
+  const calls = activeToolCalls.get(sessionID) || new Set;
+  calls.add(callID);
+  activeToolCalls.set(sessionID, calls);
+  sessionStatuses.set(sessionID, "busy");
+  sessionStatusSeenAt.set(sessionID, now());
+}
+function markToolCallFinished(input) {
+  const sessionID = input?.sessionID;
+  const callID = input?.callID;
+  if (typeof sessionID !== "string" || typeof callID !== "string")
+    return;
+  const calls = activeToolCalls.get(sessionID);
+  if (!calls)
+    return;
+  calls.delete(callID);
+  if (!calls.size)
+    activeToolCalls.delete(sessionID);
+}
+function updateSessionRelationship(info, removed = false) {
+  const sessionID = info?.id;
+  if (typeof sessionID !== "string")
+    return;
+  if (removed || typeof info?.parentID !== "string")
+    sessionParents.delete(sessionID);
+  else
+    sessionParents.set(sessionID, info.parentID);
+  if (!removed)
+    updateSessionExecutionContext(info);
+  else
+    deleteSessionExecutionContext(sessionID);
+}
+function updateSessionRelationshipFromEvent(event) {
+  if (!["session.created", "session.updated", "session.deleted"].includes(event?.type))
+    return;
+  updateSessionRelationship(event?.properties?.info, event.type === "session.deleted");
+}
+function isDescendantSession(sessionID, ancestorID) {
+  const visited = new Set;
+  let current = sessionID;
+  while (sessionParents.has(current) && !visited.has(current)) {
+    visited.add(current);
+    current = sessionParents.get(current);
+    if (current === ancestorID)
+      return true;
+  }
+  return false;
+}
+function hasBusyDescendant(sessionID) {
+  for (const childID of sessionParents.keys()) {
+    if (!isDescendantSession(childID, sessionID))
+      continue;
+    const status = sessionStatuses.get(childID);
+    if (status === "busy" || status === "retry" || hasActiveToolCalls(childID))
+      return true;
+  }
+  return false;
+}
+async function refreshSessionRelationships(client, directory) {
+  if (!client?.session?.list)
+    return;
+  try {
+    const sessions = await sdkCall(client.session.list.bind(client.session), { query: { directory } }, { directory }, {});
+    if (Array.isArray(sessions))
+      for (const info of sessions)
+        updateSessionRelationship(info);
+  } catch {}
+}
+function updateToolActivityFromEvent(event) {
+  const props = event?.properties || {};
+  if (event?.type === "message.part.updated") {
+    const part = props.part;
+    if (part?.type !== "tool")
+      return;
+    const sessionID = part.sessionID || props.sessionID;
+    if (["pending", "running"].includes(part.state?.status)) {
+      markToolCallActive({ sessionID, callID: part.callID });
+    }
+    if (["completed", "error"].includes(part.state?.status)) {
+      const identifiers = [...new Set([part.callID, part.id].filter((value) => typeof value === "string"))];
+      for (const callID of identifiers)
+        markToolCallFinished({ sessionID, callID });
+    }
+    return;
+  }
+  const started = ["session.next.shell.started", "session.next.tool.called"].includes(event?.type);
+  const finished = ["session.next.shell.ended", "session.next.tool.success", "session.next.tool.failed"].includes(event?.type);
+  if (started)
+    markToolCallActive(props);
+  if (finished)
+    markToolCallFinished(props);
+}
+function clearSessionActivity(sessionID) {
+  activeToolCalls.delete(sessionID);
+  sessionParents.delete(sessionID);
+  sessionStatuses.delete(sessionID);
+  sessionStatusSeenAt.delete(sessionID);
+  deleteSessionExecutionContext(sessionID);
+}
+
+// src/source/runtime/scheduler.js
+var DEFAULT_IDLE_DEBOUNCE_MS = 1200;
+var DEFAULT_BUSY_RETRY_MS = 5000;
+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;
+  const watchdogTimers = new Map;
+  const knownSessions = new Map;
+  let heartbeatTimer;
+  const clock = options.now || now;
+  const readStateFn = options.readState || readState;
+  const setTimeoutFn = options.setTimeout || setTimeout;
+  const clearTimeoutFn = options.clearTimeout || clearTimeout;
+  const setIntervalFn = options.setInterval || setInterval;
+  const clearIntervalFn = options.clearInterval || clearInterval;
+  const idleDebounceMs = options.idleDebounceMs ?? DEFAULT_IDLE_DEBOUNCE_MS;
+  const busyRetryMs = options.busyRetryMs ?? DEFAULT_BUSY_RETRY_MS;
+  const minDueTimerMs = options.minDueTimerMs ?? DEFAULT_MIN_DUE_TIMER_MS;
+  const maxDueTimerMs = options.maxDueTimerMs ?? DEFAULT_MAX_DUE_TIMER_MS;
+  const heartbeatMs = options.heartbeatMs ?? DEFAULT_HEARTBEAT_MS;
+  const sessionTtlMs = options.sessionTtlMs ?? DEFAULT_SESSION_TTL_MS;
+  const errorMessage = (error) => options.errorMessage ? options.errorMessage(error) : error instanceof Error ? error.message : String(error || "unknown error");
+  const appendLog = async (directory, event, extra) => {
+    if (options.appendLoopLog)
+      await options.appendLoopLog(directory, event, extra);
+  };
+  const toast2 = async (client, message, level) => {
+    if (options.toast)
+      await options.toast(client, message, level);
+  };
+  function stopHeartbeatIfIdle() {
+    if (!knownSessions.size && heartbeatTimer) {
+      clearIntervalFn(heartbeatTimer);
+      heartbeatTimer = undefined;
+    }
+  }
+  function startHeartbeat() {
+    if (heartbeatTimer)
+      return;
+    heartbeatTimer = setIntervalFn(() => {
+      for (const [sessionID, info] of [...knownSessions.entries()]) {
+        if (!info || clock() - (info.seenAt || 0) > sessionTtlMs) {
+          knownSessions.delete(sessionID);
+          continue;
+        }
+        Promise.resolve().then(async () => {
+          await options.finalizeActiveRun?.(info.directory, info.client, sessionID, { requireIdle: true, forceStale: true });
+          await options.maybeRunDueJobs?.(info.directory, info.client, sessionID, { heartbeat: true });
+        }).catch((error) => appendLog(info.directory, "heartbeat-error", { sessionID, error: errorMessage(error) }).catch(() => {}));
+      }
+      stopHeartbeatIfIdle();
+    }, heartbeatMs);
+  }
+  function rememberSession(directory, client, sessionID) {
+    if (!sessionID)
+      return;
+    knownSessions.set(sessionID, { directory, client, seenAt: clock() });
+    startHeartbeat();
+  }
+  function cancelIdleWork(sessionID) {
+    const timer = idleTimers.get(sessionID);
+    if (timer)
+      clearTimeoutFn(timer);
+    idleTimers.delete(sessionID);
+  }
+  function cancelDueWork(sessionID) {
+    const timer = dueTimers.get(sessionID);
+    if (timer)
+      clearTimeoutFn(timer);
+    dueTimers.delete(sessionID);
+  }
+  function scheduleIdleWork(directory, client, sessionID) {
+    cancelIdleWork(sessionID);
+    const timer = setTimeoutFn(() => {
+      idleTimers.delete(sessionID);
+      Promise.resolve().then(async () => {
+        if (!await options.sessionIsIdle?.(client, sessionID, directory)) {
+          await scheduleDueWork(directory, client, sessionID, busyRetryMs);
+          return;
+        }
+        await options.finalizeActiveRun?.(directory, client, sessionID);
+        if (!await options.sessionIsIdle?.(client, sessionID, directory)) {
+          await scheduleDueWork(directory, client, sessionID, busyRetryMs);
+          return;
+        }
+        await options.maybeRunDueJobs?.(directory, client, sessionID);
+      }).catch((error) => {
+        toast2(client, `Loop idle handler failed: ${errorMessage(error)}`, "error").catch(() => {});
+        appendLog(directory, "idle-error", { sessionID, error: errorMessage(error) }).catch(() => {});
+      });
+    }, idleDebounceMs);
+    idleTimers.set(sessionID, timer);
+  }
+  async function startWatchdog(directory, client, sessionID) {
+    if (watchdogTimers.has(sessionID))
+      return;
+    const timer = setIntervalFn(() => {
+      Promise.resolve().then(async () => {
+        const state = await readStateFn(directory, sessionID);
+        const delay2 = nextDueDelay(state, clock());
+        const hasJobs = (state.jobs || []).some((job) => job.enabled !== false && !job.paused && (!isGoalJob(job) || !["completed", "blocked", "cleared"].includes(job.goalStatus)));
+        if (!hasJobs || !Number.isFinite(delay2)) {
+          stopWatchdog(sessionID);
+          return;
+        }
+        if (delay2 <= 0)
+          await options.maybeRunDueJobs?.(directory, client, sessionID);
+        else
+          await scheduleDueWork(directory, client, sessionID);
+      }).catch((error) => appendLog(directory, "watchdog-error", { sessionID, error: errorMessage(error) }).catch(() => {}));
+    }, Math.max(1000, busyRetryMs));
+    watchdogTimers.set(sessionID, timer);
+  }
+  function stopWatchdog(sessionID) {
+    const timer = watchdogTimers.get(sessionID);
+    if (timer)
+      clearIntervalFn(timer);
+    watchdogTimers.delete(sessionID);
+  }
+  async function scheduleDueWork(directory, client, sessionID, minDelayMs = 0) {
+    cancelDueWork(sessionID);
+    const state = await readStateFn(directory, sessionID);
+    const delay2 = nextDueDelay(state, clock());
+    if (!Number.isFinite(delay2))
+      return;
+    const wait = Math.min(Math.max(delay2, minDelayMs, minDueTimerMs), maxDueTimerMs);
+    const timer = setTimeoutFn(() => {
+      dueTimers.delete(sessionID);
+      Promise.resolve().then(async () => {
+        if (!await options.sessionIsIdle?.(client, sessionID, directory)) {
+          await scheduleDueWork(directory, client, sessionID, busyRetryMs);
+          return;
+        }
+        await options.finalizeActiveRun?.(directory, client, sessionID);
+        if (!await options.sessionIsIdle?.(client, sessionID, directory)) {
+          await scheduleDueWork(directory, client, sessionID, busyRetryMs);
+          return;
+        }
+        await options.maybeRunDueJobs?.(directory, client, sessionID);
+      }).catch((error) => {
+        toast2(client, `Loop due timer failed: ${errorMessage(error)}`, "error").catch(() => {});
+        appendLog(directory, "due-timer-error", { sessionID, error: errorMessage(error) }).catch(() => {});
+      });
+    }, wait);
+    dueTimers.set(sessionID, timer);
+    await startWatchdog(directory, client, sessionID);
+  }
+  function sessionIDsForHost(directory, client) {
+    return [...knownSessions.entries()].filter(([, info]) => info?.directory === directory && info?.client === client).map(([sessionID]) => sessionID);
+  }
+  function clearSessionScheduling(sessionID) {
+    cancelIdleWork(sessionID);
+    cancelDueWork(sessionID);
+    stopWatchdog(sessionID);
+    knownSessions.delete(sessionID);
+    stopHeartbeatIfIdle();
+  }
+  return {
+    rememberSession,
+    scheduleIdleWork,
+    scheduleDueWork,
+    startWatchdog,
+    stopWatchdog,
+    cancelIdleWork,
+    cancelDueWork,
+    sessionIDsForHost,
+    clearSessionScheduling,
+    knownSessionCount: () => knownSessions.size
+  };
+}
+
+// src/source/runtime/goal-policy.js
+function requireFunction5(value, name) {
+  if (typeof value !== "function")
+    throw new TypeError(`createGoalExecutionPolicy requires ${name}`);
+  return value;
+}
+function createGoalExecutionPolicy(options = {}) {
+  const runShellCommand2 = requireFunction5(options.runShellCommand, "runShellCommand");
+  const dangerousShell = requireFunction5(options.dangerousShell, "dangerousShell");
+  const toast2 = requireFunction5(options.toast, "toast");
+  const now2 = typeof options.now === "function" ? options.now : now;
+  const appendLoopLog2 = typeof options.appendLoopLog === "function" ? options.appendLoopLog : appendLoopLog;
+  async function applyGoalNoProgressGuard(directory, client, sessionID, job, beforeJob) {
+    if (!isGoalJob(job) || ["completed", "blocked"].includes(job.goalStatus) || job.paused || job.enabled === false)
+      return job;
+    const limit = Number(job.maxNoProgress ?? DEFAULT_GOAL_MAX_NO_PROGRESS);
+    if (!Number.isFinite(limit) || limit <= 0)
+      return job;
+    if (goalMadeMeaningfulProgress(beforeJob, job)) {
+      job.noProgressCount = 0;
+      job.lastProgressAt = now2();
+      return job;
+    }
+    job.noProgressCount = (job.noProgressCount || 0) + 1;
+    job.lastNoProgressAt = now2();
+    await appendLoopLog2(directory, "goal-no-progress", { sessionID, job: job.name || job.id, count: job.noProgressCount, limit });
+    if (job.noProgressCount >= limit) {
       job.paused = true;
-      job.goalCompletedAt = now();
-      job.goalSummary = job.goalSummary || "All configured goal checks passed.";
-      job.goalEvidence = results.map((item) => `${item.command}: exit ${item.code}`).join(`
+      job.goalNoProgressPausedAt = now2();
+      job.goalNoProgressReason = `Paused after ${job.noProgressCount} turn(s) without recorded progress. Resume with /loop-goal-resume after adjusting the goal or evidence.`;
+      await toast2(client, job.goalNoProgressReason, "warning");
+      await appendLoopLog2(directory, "goal-no-progress-paused", { sessionID, job: job.name || job.id, count: job.noProgressCount, limit });
+    }
+    return job;
+  }
+  async function runGoalChecks(directory, sessionID, job, client) {
+    if (!isGoalJob(job) || !job.goalChecks?.length || ["completed", "blocked"].includes(job.goalStatus))
+      return job;
+    const results = [];
+    for (const command of job.goalChecks) {
+      if (job.safe && dangerousShell(command)) {
+        results.push({ command, code: -1, output: "Blocked dangerous command in safe mode." });
+        continue;
+      }
+      const result = await runShellCommand2(command, directory, job.timeoutMs || 300000);
+      results.push({ command, code: result.code, output: (result.stdout + `
+` + result.stderr).slice(0, 1200) });
+    }
+    job.lastGoalCheckAt = now2();
+    job.lastGoalChecks = results;
+    const allPassed = results.length > 0 && results.every((item) => item.code === 0);
+    if (allPassed) {
+      job.goalChecksPassedAt = now2();
+      job.failureCount = 0;
+      await toast2(client, "Goal checks passed.", "success");
+      if (job.goalCompleteWhenChecksPass) {
+        job.goalStatus = "completed";
+        job.enabled = false;
+        job.paused = true;
+        job.goalCompletedAt = now2();
+        job.goalSummary = job.goalSummary || "All configured goal checks passed.";
+        job.goalEvidence = results.map((item) => `${item.command}: exit ${item.code}`).join(`
 `);
-      await appendLoopLog(directory, "goal-auto-complete", { sessionID, job: job.name || job.id });
+        await appendLoopLog2(directory, "goal-auto-complete", { sessionID, job: job.name || job.id });
+      }
+    } else {
+      job.failureCount = (job.failureCount || 0) + 1;
+      job.lastVerifyFailure = results.map((item) => `${item.command}
+exit=${item.code}
+${item.output}`).join(`
+
+`).slice(0, 4000);
+      await toast2(client, "Goal checks still failing; goal will continue on next idle turn.", "warning");
+    }
+    await appendLoopLog2(directory, "goal-checks", { sessionID, job: job.name || job.id, results: results.map((item) => ({ command: item.command, code: item.code })) });
+    return job;
+  }
+  return { runGoalChecks, applyGoalNoProgressGuard };
+}
+
+// src/source/runtime/job-workspace.js
+import { promises as fs5 } from "fs";
+import path5 from "path";
+var MAX_SCAN_FILES = 200;
+var MAX_SCAN_BYTES = 2000000;
+function requireFunction6(value, name) {
+  if (typeof value !== "function")
+    throw new TypeError(`createJobWorkspaceRuntime requires ${name}`);
+  return value;
+}
+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));
+}
+function createJobWorkspaceRuntime(options = {}) {
+  const toast2 = requireFunction6(options.toast, "toast");
+  const runProcess2 = typeof options.runProcess === "function" ? options.runProcess : runProcess;
+  const appendLoopLog2 = typeof options.appendLoopLog === "function" ? options.appendLoopLog : appendLoopLog;
+  const readSmallTextFile2 = typeof options.readSmallTextFile === "function" ? options.readSmallTextFile : readSmallTextFile;
+  const buildGoalPrompt2 = typeof options.buildGoalPrompt === "function" ? options.buildGoalPrompt : buildGoalPrompt;
+  async function buildPrompt(directory, job) {
+    if (isGoalJob(job))
+      return await buildGoalPrompt2(directory, job);
+    const sections = [];
+    if (job.promptFile) {
+      const text = await readSmallTextFile2(path5.resolve(directory, job.promptFile));
+      if (text.trim())
+        sections.push(`Instructions from ${job.promptFile}:
+${text.trim()}`);
+      else
+        sections.push(`Prompt file ${job.promptFile} was requested but could not be read. Continue from the regular action instead.`);
     }
-  } else {
-    job.failureCount = (job.failureCount || 0) + 1;
-    job.lastVerifyFailure = results.map((item) => `${item.command}
-exit=${item.code}
-${item.output}`).join(`
+    if (job.action)
+      sections.push(decoratePrompt(job));
+    for (const file of job.includeFiles || []) {
+      const text = await readSmallTextFile2(path5.resolve(directory, file), 80000);
+      if (text.trim())
+        sections.push(`Context from ${file}:
+${text.trim().slice(0, 20000)}`);
+    }
+    return sections.join(`
 
-`).slice(0, 4000);
-    await toast(client, "Goal checks still failing; goal will continue on next idle turn.", "warning");
+---
+
+`) || decoratePrompt(job);
+  }
+  async function ensureBranch(directory, job, client, sessionID) {
+    if (!job.branch || job.branchDone)
+      return job;
+    const branch = safeID(job.branch);
+    const inRepo = await runProcess2("git", ["rev-parse", "--is-inside-work-tree"], directory, 1e4);
+    if (inRepo.code !== 0) {
+      job.branchDone = true;
+      return job;
+    }
+    let result = await runProcess2("git", ["switch", branch], directory, 30000);
+    if (result.code !== 0)
+      result = await runProcess2("git", ["switch", "-c", branch], directory, 30000);
+    job.branchDone = true;
+    await toast2(client, result.code === 0 ? `Loop branch active: ${branch}` : `Could not switch/create branch: ${branch}`, result.code === 0 ? "success" : "warning");
+    await appendLoopLog2(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 fs5.stat(path5.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 fs5.stat(filePath);
+      if (!stat.isFile() || stat.size > MAX_SCAN_BYTES)
+        return false;
+      return (await fs5.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", path5.join(".opencode", "opencode-loop", "until.txt")];
+    for (const file of files)
+      if (await fileContains(path5.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 fs5.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 = path5.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 runProcess2("git", ["rev-parse", "--is-inside-work-tree"], directory, 1e4);
+    if (inRepo.code !== 0)
+      return;
+    const status = await runProcess2("git", ["status", "--short"], directory, 30000);
+    if (!status.stdout.trim())
+      return;
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const checkpointDir = path5.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}
+${staged.stdout}`);
+    if (job.gitCheckpoint) {
+      await runProcess2("git", ["add", "-A"], directory, 120000);
+      await runProcess2("git", ["commit", "-m", `chore: opencode loop checkpoint ${timestamp}`], directory, 120000);
+    }
+    await toast2(client, `Loop checkpoint saved: ${prefix}`, "success");
   }
-  await appendLoopLog(directory, "goal-checks", { sessionID, job: job.name || job.id, results: results.map((item) => ({ command: item.command, code: item.code })) });
-  return job;
+  return {
+    buildPrompt,
+    ensureBranch,
+    snapshotPaths,
+    watchChanged,
+    untilReached,
+    createCheckpoint
+  };
 }
-async function finalizeActiveRun(directory, client, sessionID, options = {}) {
-  const active = activeRuns.get(sessionID);
-  if (!active)
-    return;
-  if (!await canFinalizeActiveRun(directory, client, sessionID, active, options))
-    return false;
-  const recoveredStale = staleActiveRun(sessionID);
-  if (active.compactionOnly) {
-    const pending = loopCompactionRequests.get(sessionID);
-    clearActiveRun(sessionID);
+
+// 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;
+function positiveNumber(value, fallback) {
+  const number = Number(value);
+  return Number.isFinite(number) && number > 0 ? number : fallback;
+}
+function nonNegativeNumber(value, fallback) {
+  const number = Number(value);
+  return Number.isFinite(number) && number >= 0 ? number : fallback;
+}
+function createSessionStatusRuntime(options = {}) {
+  const activeRuns = options.activeRuns;
+  if (!(activeRuns instanceof Map))
+    throw new TypeError("createSessionStatusRuntime requires activeRuns Map");
+  const now2 = typeof options.now === "function" ? options.now : now;
+  const appendLoopLog2 = typeof options.appendLoopLog === "function" ? options.appendLoopLog : appendLoopLog;
+  const activeRunCompletionFromMessages2 = typeof options.activeRunCompletionFromMessages === "function" ? options.activeRunCompletionFromMessages : activeRunCompletionFromMessages;
+  const staleActiveRecoveryMs = positiveNumber(options.staleActiveRecoveryMs, DEFAULT_STALE_ACTIVE_RECOVERY_MS);
+  const sessionStatusCacheMs = nonNegativeNumber(options.sessionStatusCacheMs, DEFAULT_SESSION_STATUS_CACHE_MS);
+  function markSessionStatus(sessionID, type, observedAt = now2()) {
+    if (typeof sessionID !== "string" || typeof type !== "string")
+      return false;
+    sessionStatuses.set(sessionID, type);
+    sessionStatusSeenAt.set(sessionID, observedAt);
+    return true;
+  }
+  function clearSessionStatus(sessionID) {
     sessionStatuses.delete(sessionID);
     sessionStatusSeenAt.delete(sessionID);
-    await appendLoopLog(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 readState(directory, sessionID);
-  let job = (state.jobs || []).find((candidate) => candidate.id === active.jobId);
-  if (!job)
+  function updateSessionStatusFromEvent(event) {
+    const sessionID = event?.properties?.sessionID;
+    if (typeof sessionID !== "string")
+      return;
+    if (event?.type === "session.idle") {
+      markSessionStatus(sessionID, "idle");
+      return { sessionID, idle: true };
+    }
+    if (event?.type === "session.status") {
+      const status = event?.properties?.status;
+      const type = status && typeof status === "object" ? status.type : undefined;
+      if (typeof type === "string")
+        markSessionStatus(sessionID, type);
+      return { sessionID, idle: type === "idle" };
+    }
     return;
-  job.lastFinishedAt = now();
-  if (recoveredStale)
-    await appendLoopLog(directory, "active-stale-recovery", { sessionID, job: job.name || job.id, startedAt: active.startedAt });
-  if (job.verifyCommand) {
-    const verify = await runShellCommand(job.verifyCommand, directory, job.timeoutMs || 300000);
-    job.lastVerifyAt = now();
-    job.lastVerifyCode = verify.code;
-    if (verify.code === 0) {
-      job.failureCount = 0;
-      job.lastVerifyFailure = "";
-      await toast(client, "Loop verify passed: " + job.verifyCommand, "success");
-    } else {
-      job.failureCount = (job.failureCount || 0) + 1;
-      job.lastVerifyFailure = (job.verifyCommand + `
-exit=` + verify.code + `
-` + verify.stdout + `
-` + verify.stderr).slice(0, 4000);
-      await toast(client, "Loop verify failed: " + job.verifyCommand, "warning");
-      if (job.pauseOnVerifyFail || job.maxFailures > 0 && job.failureCount >= job.maxFailures) {
-        job.paused = true;
-        await notifyJob(directory, job, "verify_failed");
-      }
+  }
+  function staleActiveRun(sessionID) {
+    const active = activeRuns.get(sessionID);
+    if (!active)
+      return false;
+    const age = now2() - (active.startedAt || 0);
+    const configured = Number(active.job?.staleActiveRecoveryMs || active.job?.activeRecoveryMs || 0);
+    const threshold = Number.isFinite(configured) && configured > 0 ? configured : staleActiveRecoveryMs;
+    return age >= threshold;
+  }
+  async function readLiveSessionStatus(client, sessionID, directory) {
+    const statusMethod = client?.session?.status;
+    if (typeof statusMethod !== "function")
+      return;
+    const argsList = [];
+    if (directory)
+      argsList.push({ query: { directory } }, { directory }, { workspace: directory });
+    argsList.push({});
+    for (const args of argsList) {
+      try {
+        const result = await statusMethod.call(client.session, args);
+        const error = sdkError(result);
+        if (error)
+          continue;
+        const data = sdkData(result);
+        if (!data || typeof data !== "object" || Array.isArray(data))
+          continue;
+        const observedAt = now2();
+        for (const [observedSessionID, observedStatus] of Object.entries(data)) {
+          const observedType = observedStatus && typeof observedStatus === "object" ? observedStatus.type : undefined;
+          if (typeof observedType !== "string")
+            continue;
+          markSessionStatus(observedSessionID, observedType, observedAt);
+        }
+        for (const childID of sessionParents.keys()) {
+          if (!isDescendantSession(childID, sessionID) || data[childID])
+            continue;
+          markSessionStatus(childID, "idle", observedAt);
+        }
+        if (hasBusyDescendant(sessionID))
+          return { type: "busy", source: "descendant" };
+        const status = data?.[sessionID];
+        const type = status && typeof status === "object" ? status.type : undefined;
+        if (typeof type === "string")
+          return { type, source: "sdk" };
+        return { type: "idle", source: "sdk" };
+      } catch {}
     }
-    await appendLoopLog(directory, "verify", { sessionID, job: job.name || job.id, command: job.verifyCommand, code: verify.code, failures: job.failureCount || 0 });
+    return;
   }
-  if (job.postrunCommand) {
-    if (job.safe && dangerousShell(job.postrunCommand))
-      await appendLoopLog(directory, "postrun-blocked", { sessionID, job: job.name || job.id, command: job.postrunCommand });
-    else {
-      const postrun = await runShellCommand(job.postrunCommand, directory, job.timeoutMs || 300000);
-      job.lastPostrunCode = postrun.code;
-      job.lastPostrunAt = now();
-      if (postrun.code !== 0) {
-        job.failureCount = (job.failureCount || 0) + 1;
-        job.lastPostrunFailure = (job.postrunCommand + `
-exit=` + postrun.code + `
-` + postrun.stdout + `
-` + postrun.stderr).slice(0, 4000);
-        if (job.maxFailures > 0 && job.failureCount >= job.maxFailures) {
-          job.paused = true;
-          await notifyJob(directory, job, "postrun_failed");
+  async function canFinalizeActiveRun(directory, client, sessionID, active, options2 = {}) {
+    if (hasActiveToolCalls(sessionID) || hasBusyDescendant(sessionID))
+      return false;
+    if (!options2.requireIdle && !options2.forceStale)
+      return true;
+    const completion = options2.forceStale ? await activeRunCompletionFromMessages2(directory, client, sessionID, active) : undefined;
+    if (completion === "completed")
+      return true;
+    if (!options2.requireIdle)
+      return completion === "unknown" && staleActiveRun(sessionID);
+    const live = await readLiveSessionStatus(client, sessionID, directory);
+    if (live?.type === "idle")
+      return true;
+    if (live?.type) {
+      if ((live.type === "busy" || live.type === "retry") && options2.forceStale && completion === "unknown" && staleActiveRun(sessionID))
+        return true;
+      return false;
+    }
+    if (options2.forceStale && completion === "unknown" && staleActiveRun(sessionID))
+      return true;
+    const cached = sessionStatuses.get(sessionID);
+    const seenAt = sessionStatusSeenAt.get(sessionID) || 0;
+    return cached === "idle" && seenAt > (active.startedAt || 0);
+  }
+  async function sessionStatusType(client, sessionID, directory, options2 = {}) {
+    if (hasActiveToolCalls(sessionID) || hasBusyDescendant(sessionID)) {
+      markSessionStatus(sessionID, "busy");
+      return "busy";
+    }
+    const cached = sessionStatuses.get(sessionID);
+    const seenAt = sessionStatusSeenAt.get(sessionID) || 0;
+    if (cached === "idle")
+      return cached;
+    if (cached && now2() - seenAt < sessionStatusCacheMs)
+      return cached;
+    const live = await readLiveSessionStatus(client, sessionID, directory);
+    if (live?.type) {
+      if ((live.type === "busy" || live.type === "retry") && options2.recoverStaleActive !== false) {
+        const active = activeRuns.get(sessionID);
+        if (active) {
+          const completion = await activeRunCompletionFromMessages2(directory, client, sessionID, active);
+          if (completion === "completed" || completion === "unknown" && staleActiveRun(sessionID)) {
+            markSessionStatus(sessionID, "idle");
+            await appendLoopLog2(directory, completion === "completed" ? "status-message-complete-recovery" : "status-stale-recovery", {
+              sessionID,
+              job: active.job?.name || active.jobId,
+              startedAt: active.startedAt
+            });
+            return "idle";
+          }
         }
       }
-      await appendLoopLog(directory, "postrun", { sessionID, job: job.name || job.id, command: job.postrunCommand, code: postrun.code });
+      markSessionStatus(sessionID, live.type);
+      return live.type;
     }
+    const fallback = activeRuns.has(sessionID) && !staleActiveRun(sessionID) ? "busy" : "idle";
+    markSessionStatus(sessionID, fallback);
+    return fallback;
   }
-  if (isGoalJob(job)) {
-    job = await runGoalChecks(directory, sessionID, job, client);
-    job = await applyGoalNoProgressGuard(directory, client, sessionID, job, active.job);
+  async function sessionIsIdle(client, sessionID, directory, options2 = {}) {
+    return await sessionStatusType(client, sessionID, directory, options2) === "idle";
   }
-  state.jobs = (state.jobs || []).map((candidate) => candidate.id === job.id ? job : candidate).filter((candidate) => candidate.enabled !== false || isGoalJob(candidate));
-  await writeState(directory, sessionID, state);
-  if (isGoalJob(job))
-    await writeGoalReport(directory, sessionID, job);
-  await createCheckpoint(directory, sessionID, job, client);
-  await scheduleDueWork(directory, client, sessionID);
-  return true;
+  return {
+    markSessionStatus,
+    clearSessionStatus,
+    updateSessionStatusFromEvent,
+    staleActiveRun,
+    canFinalizeActiveRun,
+    readLiveSessionStatus,
+    sessionStatusType,
+    sessionIsIdle
+  };
 }
-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 = normalizedModelRef(job.model);
-  if (kind === "compact") {
-    beginLoopCompaction(sessionID, job.id, false);
-    const ok = await compactSession(directory, client, sessionID, model);
+
+// src/source/runtime/compaction.js
+function createCompactionRuntime(options = {}) {
+  const activeRuns = options.activeRuns;
+  if (!(activeRuns instanceof Map))
+    throw new TypeError("createCompactionRuntime requires activeRuns Map");
+  if (typeof options.finalizeActiveRun !== "function")
+    throw new TypeError("createCompactionRuntime requires finalizeActiveRun");
+  const now2 = typeof options.now === "function" ? options.now : now;
+  const appendLoopLog2 = typeof options.appendLoopLog === "function" ? options.appendLoopLog : appendLoopLog;
+  const compactSession2 = typeof options.compactSession === "function" ? options.compactSession : compactSession;
+  const log2 = typeof options.log === "function" ? options.log : log;
+  const errorMessage = typeof options.errorMessage === "function" ? options.errorMessage : sdkErrorMessage;
+  const finalizeActiveRun = options.finalizeActiveRun;
+  const requests = new Map;
+  function begin(sessionID, jobId, resumeAfter = false) {
+    if (typeof sessionID !== "string" || typeof jobId !== "string")
+      return;
+    const request = {
+      jobId,
+      resumeAfter: Boolean(resumeAfter),
+      requestedAt: now2(),
+      startedAt: 0,
+      completedAt: 0
+    };
+    requests.set(sessionID, request);
+    return request;
+  }
+  function getPending(sessionID) {
+    return requests.get(sessionID);
+  }
+  function clear(sessionID) {
+    return requests.delete(sessionID);
+  }
+  function clearForActiveRun(sessionID, active) {
+    const pending = requests.get(sessionID);
+    if (!pending || !active || pending.jobId === active.jobId)
+      requests.delete(sessionID);
+  }
+  function isCompleted(sessionID, jobId) {
+    const pending = requests.get(sessionID);
+    return Boolean(pending && pending.jobId === jobId && pending.completedAt);
+  }
+  async function start(directory, client, sessionID, jobId, model, resumeAfter = false) {
+    begin(sessionID, jobId, resumeAfter);
+    const ok = await compactSession2(directory, client, sessionID, model);
     if (!ok)
-      loopCompactionRequests.delete(sessionID);
-    return { startsAssistantTurn: ok, pause: !ok, reason: "compact_failed", compaction: ok };
-  }
-  if (kind === "command") {
-    const normalized = action.startsWith("/") ? action.slice(1) : action;
-    const [command, argumentsText] = splitFirst(normalized);
-    if (!command) {
-      await toast(client, "Loop command action is empty. Example: /loop-command 200m /compact", "warning");
-      return { startsAssistantTurn: false, pause: true, reason: "empty_command" };
-    }
-    const tuiCommand = compactTuiCommandName(command);
-    if (tuiCommand) {
-      guardLoopOwnedUserMessage(sessionID);
-      beginLoopCompaction(sessionID, job.id, false);
-      const ok = await compactSession(directory, client, sessionID, model);
-      if (!ok)
-        loopCompactionRequests.delete(sessionID);
-      return { startsAssistantTurn: ok, pause: !ok, reason: "compact_failed", compaction: ok };
+      clear(sessionID);
+    return ok;
+  }
+  async function maybeCompact(directory, client, sessionID, job) {
+    const dueRuns = job.compactEveryRuns > 0 && (job.runCount || 0) > 0 && (job.runCount || 0) % job.compactEveryRuns === 0 && job.lastCompactRunCount !== job.runCount;
+    const dueTime = job.compactEveryMs > 0 && (!job.lastCompactAt || now2() - job.lastCompactAt >= job.compactEveryMs);
+    if (!dueRuns && !dueTime)
+      return { job, started: false };
+    if (await start(directory, client, sessionID, job.id, job.model, true)) {
+      job.lastCompactAt = now2();
+      job.lastCompactRunCount = job.runCount || 0;
+      return { job, started: true };
     }
-    guardLoopOwnedUserMessage(sessionID);
-    const commandBody = { command, arguments: argumentsText, agent };
-    if (model)
-      commandBody.model = `${model.providerID}/${model.modelID}`;
-    await sdkCall(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 && dangerousShell(command)) {
-      await toast(client, `Blocked dangerous shell command in safe mode: ${command}`, "error");
-      await appendLoopLog(directory, "blocked", { sessionID, job: job.name || job.id, command });
-      return { startsAssistantTurn: false, pause: true, reason: "safe_shell_blocked" };
-    }
-    guardLoopOwnedUserMessage(sessionID);
-    const shellBody = { command, agent };
-    if (model)
-      shellBody.model = model;
-    const dispatch2 = fireSdk(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 };
+    return { job, started: false };
   }
-  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}`;
-  guardLoopOwnedUserMessage(sessionID);
-  const promptBody = { agent, parts: [{ type: "text", text: promptText }] };
-  if (model)
-    promptBody.model = model;
-  const dispatch = fireSdk(client, "session.prompt", client.session.prompt.bind(client.session), { path: { id: sessionID }, body: promptBody }, { path: { sessionID }, body: promptBody }, { sessionID, ...promptBody });
-  return { startsAssistantTurn: true, dispatch };
-}
-async function maybeRunDueJobs(directory, client, sessionID, options = {}) {
-  rememberSession(directory, client, sessionID);
-  const reschedule = async (minDelayMs = 0) => {
-    await scheduleDueWork(directory, client, sessionID, minDelayMs);
+  async function noteStarted(directory, sessionID) {
+    const pending = requests.get(sessionID);
+    if (!pending)
+      return false;
+    if (!pending.startedAt) {
+      pending.startedAt = now2();
+      requests.set(sessionID, pending);
+      await appendLoopLog2(directory, "compact-started", {
+        sessionID,
+        job: pending.jobId,
+        resumeAfter: pending.resumeAfter
+      });
+    }
+    return true;
+  }
+  async function finalize(directory, client, sessionID) {
+    const pending = requests.get(sessionID);
+    const active = activeRuns.get(sessionID);
+    if (!pending || !active || pending.jobId !== active.jobId)
+      return false;
+    return await finalizeActiveRun(directory, client, sessionID);
+  }
+  async function noteCompleted(directory, client, sessionID) {
+    const pending = requests.get(sessionID);
+    if (!pending)
+      return false;
+    pending.completedAt = now2();
+    requests.set(sessionID, pending);
+    await appendLoopLog2(directory, "compact-event", {
+      sessionID,
+      job: pending.jobId,
+      resumeAfter: pending.resumeAfter
+    });
+    const timer = setTimeout(() => {
+      finalize(directory, client, sessionID).catch((error) => log2(client, "error", "compaction finalization failed", { error: errorMessage(error) }));
+    }, 0);
+    timer.unref?.();
+    return true;
+  }
+  return {
+    begin,
+    getPending,
+    clear,
+    clearForActiveRun,
+    isCompleted,
+    start,
+    maybeCompact,
+    noteStarted,
+    finalize,
+    noteCompleted
   };
-  if (runLocks.has(sessionID)) {
-    await reschedule(BUSY_RETRY_MS);
-    return;
+}
+
+// src/source/runtime/executor.js
+var DEFAULT_ACTIVE_GUARD_MS = 45000;
+var DEFAULT_BUSY_RETRY_MS2 = 5000;
+function requireFunction7(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 = 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;
+  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));
   }
-  runLocks.set(sessionID, now());
-  let job;
-  try {
-    await finalizeActiveRun(directory, client, sessionID, { requireIdle: true, forceStale: true });
-    if (!await sessionIsIdle(client, sessionID, directory)) {
-      if (options.force)
-        await toast(client, "Loop queued: session is busy; it will run on the next idle check.", "info");
-      await reschedule(BUSY_RETRY_MS);
-      return;
+  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);
     }
+    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);
-    const activeAge = active ? now() - (active.startedAt || 0) : 0;
-    const activeGuard = active?.job?.timeoutMs || active?.job?.activeRecoveryMs || DEFAULT_ACTIVE_GUARD_MS;
-    if (active && active.job?.noOverlap !== false && activeAge < activeGuard) {
-      await reschedule(BUSY_RETRY_MS);
+    if (!active)
       return;
-    }
-    if (active && activeAge >= activeGuard)
+    if (!await canFinalizeActiveRun(directory, client, sessionID, active, finalizeOptions))
+      return false;
+    const recoveredStale = staleActiveRun(sessionID);
+    if (active.compactionOnly) {
+      const pending = compactionRuntime.getPending(sessionID);
       clearActiveRun(sessionID);
-    const state = await readState(directory, sessionID);
-    for (const candidate of state.jobs || []) {
-      if (candidate.watchPaths?.length && !candidate.paused && candidate.enabled && await watchChanged(directory, candidate))
-        candidate.watchTriggered = true;
-    }
-    const due = dueJobs(state, options.force);
-    if (!due.length) {
-      await writeState(directory, sessionID, state);
-      await reschedule();
-      return;
+      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;
     }
-    job = due[0];
-    if (job.maxRuntimeMs > 0 && now() - Date.parse(job.createdAt || new Date().toISOString()) >= job.maxRuntimeMs) {
-      state.jobs = (state.jobs || []).filter((candidate) => candidate.id !== job.id);
-      await writeState(directory, sessionID, state);
-      await notifyJob(directory, job, "max_runtime_reached");
-      await toast(client, `Loop stopped by --max-runtime: ${job.name || job.id}`, "success");
-      await appendLoopLog(directory, "max-runtime", { sessionID, job: job.name || job.id });
-      await reschedule();
+    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 (job.stopFile && await pathExists(path3.resolve(directory, job.stopFile))) {
-      state.jobs = (state.jobs || []).filter((candidate) => candidate.id !== job.id);
-      await writeState(directory, sessionID, state);
-      await notifyJob(directory, job, "stop_file");
-      await toast(client, "Loop stopped by --stop-file: " + job.stopFile, "success");
-      await reschedule();
-      return;
+    if (job.verifyCommand) {
+      const verify = await runShellCommand2(job.verifyCommand, directory, job.timeoutMs || 300000);
+      job.lastVerifyAt = now2();
+      job.lastVerifyCode = verify.code;
+      if (verify.code === 0) {
+        job.failureCount = 0;
+        job.lastVerifyFailure = "";
+        await toast2(client, "Loop verify passed: " + job.verifyCommand, "success");
+      } else {
+        job.failureCount = (job.failureCount || 0) + 1;
+        job.lastVerifyFailure = (job.verifyCommand + `
+exit=` + verify.code + `
+` + verify.stdout + `
+` + verify.stderr).slice(0, 4000);
+        await toast2(client, "Loop verify failed: " + job.verifyCommand, "warning");
+        if (job.pauseOnVerifyFail || job.maxFailures > 0 && job.failureCount >= job.maxFailures) {
+          job.paused = true;
+          await notifyJob2(directory, job, "verify_failed");
+        }
+      }
+      await appendLoopLog2(directory, "verify", {
+        sessionID,
+        job: job.name || job.id,
+        command: job.verifyCommand,
+        code: verify.code,
+        failures: job.failureCount || 0
+      });
     }
-    if (await untilReached(directory, job)) {
-      state.jobs = (state.jobs || []).filter((candidate) => candidate.id !== job.id);
-      await writeState(directory, sessionID, state);
-      await notifyJob(directory, job, "until_reached");
-      await toast(client, `Loop stopped by --until: ${job.until}`, "success");
-      await reschedule();
+    if (job.postrunCommand) {
+      if (job.safe && dangerousShell2(job.postrunCommand)) {
+        await appendLoopLog2(directory, "postrun-blocked", {
+          sessionID,
+          job: job.name || job.id,
+          command: job.postrunCommand
+        });
+      } else {
+        const postrun = await runShellCommand2(job.postrunCommand, directory, job.timeoutMs || 300000);
+        job.lastPostrunCode = postrun.code;
+        job.lastPostrunAt = now2();
+        if (postrun.code !== 0) {
+          job.failureCount = (job.failureCount || 0) + 1;
+          job.lastPostrunFailure = (job.postrunCommand + `
+exit=` + postrun.code + `
+` + postrun.stdout + `
+` + postrun.stderr).slice(0, 4000);
+          if (job.maxFailures > 0 && job.failureCount >= job.maxFailures) {
+            job.paused = true;
+            await notifyJob2(directory, job, "postrun_failed");
+          }
+        }
+        await appendLoopLog2(directory, "postrun", {
+          sessionID,
+          job: job.name || job.id,
+          command: job.postrunCommand,
+          code: postrun.code
+        });
+      }
+    }
+    if (isGoalJob(job)) {
+      job = await runGoalChecks(directory, sessionID, job, client);
+      job = await applyGoalNoProgressGuard(directory, client, sessionID, job, active.job);
+    }
+    state.jobs = (state.jobs || []).map((candidate) => candidate.id === job.id ? job : candidate).filter((candidate) => candidate.enabled !== false || isGoalJob(candidate));
+    await writeState2(directory, sessionID, state);
+    if (isGoalJob(job))
+      await writeGoalReport2(directory, sessionID, job);
+    await createCheckpoint(directory, sessionID, job, client);
+    await scheduleDueWork(directory, client, sessionID);
+    return true;
+  }
+  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 };
+    }
+    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 compactionRuntime.start(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 };
+    }
+    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 };
+  }
+  async function maybeRunDueJobs(directory, client, sessionID, runOptions = {}) {
+    rememberSession(directory, client, sessionID);
+    const reschedule = async (minDelayMs = 0) => {
+      await scheduleDueWork(directory, client, sessionID, minDelayMs);
+    };
+    if (runLocks.has(sessionID)) {
+      await reschedule(busyRetryMs);
       return;
     }
-    if (job.preflightCommand) {
-      if (job.safe && dangerousShell(job.preflightCommand)) {
-        job.paused = true;
-        await writeState(directory, sessionID, state);
-        await notifyJob(directory, job, "preflight_blocked");
-        await toast(client, "Preflight blocked in safe mode and loop paused: " + job.preflightCommand, "error");
+    runLocks.set(sessionID, now2());
+    let job;
+    try {
+      await finalizeActiveRun(directory, client, sessionID, { requireIdle: true, forceStale: true });
+      if (!await sessionIsIdle(client, sessionID, directory)) {
+        if (runOptions.force)
+          await toast2(client, "Loop queued: session is busy; it will run on the next idle check.", "info");
+        await reschedule(busyRetryMs);
+        return;
+      }
+      const active = activeRuns.get(sessionID);
+      const activeAge = active ? now2() - (active.startedAt || 0) : 0;
+      const activeGuard = active?.job?.timeoutMs || active?.job?.activeRecoveryMs || activeGuardMs;
+      if (active && active.job?.noOverlap !== false && activeAge < activeGuard) {
+        await reschedule(busyRetryMs);
+        return;
+      }
+      if (active && activeAge >= activeGuard)
+        clearActiveRun(sessionID);
+      const state = await readState2(directory, sessionID);
+      for (const candidate of state.jobs || []) {
+        if (candidate.watchPaths?.length && !candidate.paused && candidate.enabled && await watchChanged(directory, candidate)) {
+          candidate.watchTriggered = true;
+        }
+      }
+      const due = dueJobs(state, Boolean(runOptions.force));
+      if (!due.length) {
+        await writeState2(directory, sessionID, state);
         await reschedule();
         return;
       }
-      const preflight = await runShellCommand(job.preflightCommand, directory, job.timeoutMs || 300000);
-      await appendLoopLog(directory, "preflight", { sessionID, job: job.name || job.id, command: job.preflightCommand, code: preflight.code });
-      if (preflight.code !== 0) {
-        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 writeState(directory, sessionID, state);
-        await notifyJob(directory, job, "preflight_failed");
-        await toast(client, "Preflight failed and loop paused: " + job.preflightCommand, "warning");
+      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;
       }
-    }
-    job = await ensureBranch(directory, job, client, sessionID);
-    const compactResult = await maybeCompact(directory, client, sessionID, job);
-    job = compactResult.job;
-    if (compactResult.started) {
-      state.jobs = (state.jobs || []).map((candidate) => candidate.id === job.id ? job : candidate);
-      await writeState(directory, sessionID, state);
-      let timer;
-      if (job.timeoutMs > 0)
-        timer = setTimeout(() => {
-          fireSdk(client, "session.abort", client.session.abort.bind(client.session), { path: { id: sessionID }, body: {} }, { path: { sessionID }, body: {} }, { sessionID });
-          toast(client, `Loop compact timeout fired: ${job.name || job.id}`, "warning").catch(() => {});
-        }, job.timeoutMs);
-      const runToken = `${job.id}:compact:${now().toString(36)}:${Math.random().toString(16).slice(2)}`;
-      activeRuns.set(sessionID, { jobId: job.id, job, startedAt: now(), timer, runToken, compactionOnly: true });
-      const pending = loopCompactionRequests.get(sessionID);
-      if (pending?.jobId === job.id && pending.completedAt) {
-        await finalizeLoopCompaction(directory, client, sessionID);
+      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();
         return;
       }
-      sessionStatuses.set(sessionID, "busy");
-      sessionStatusSeenAt.set(sessionID, now());
-      await reschedule(BUSY_RETRY_MS);
-      return;
-    }
-    job.watchTriggered = false;
-    job.lastRunAt = now();
-    job.runCount = (job.runCount || 0) + 1;
-    if (job.maxRuns > 0 && job.runCount >= job.maxRuns) {
-      job.enabled = false;
-      await notifyJob(directory, job, "max_runs_reached");
-    }
-    state.jobs = (state.jobs || []).map((candidate) => candidate.id === job.id ? job : candidate);
-    await writeState(directory, sessionID, state);
-    await appendLoopLog(directory, "run", { sessionID, job: job.name || job.id, runCount: job.runCount });
-    await toast(client, `Loop running: ${job.name || job.id}`, "info");
-    try {
-      const result = await fireAction(directory, client, sessionID, job);
-      if (!result.startsAssistantTurn) {
-        const fresh = await readState(directory, sessionID);
-        if (result.pause) {
-          fresh.jobs = (fresh.jobs || []).map((candidate) => candidate.id === job.id ? {
-            ...candidate,
-            paused: true,
-            failureCount: (candidate.failureCount || 0) + 1,
-            lastFailureReason: result.reason || "action_did_not_start"
-          } : candidate);
-        }
-        fresh.jobs = (fresh.jobs || []).filter((candidate) => candidate.enabled !== false || isGoalJob(candidate));
-        await writeState(directory, sessionID, fresh);
+      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;
       }
-      let timer;
-      if (job.timeoutMs > 0)
-        timer = setTimeout(() => {
-          fireSdk(client, "session.abort", client.session.abort.bind(client.session), { path: { id: sessionID }, body: {} }, { path: { sessionID }, body: {} }, { sessionID });
-          toast(client, `Loop timeout fired: ${job.name || job.id}`, "warning").catch(() => {});
-        }, job.timeoutMs);
-      const runToken = `${job.id}:${now().toString(36)}:${Math.random().toString(16).slice(2)}`;
-      activeRuns.set(sessionID, { jobId: job.id, job, startedAt: now(), timer, runToken, compactionAction: result.compaction === true });
-      if (result.compaction) {
-        const pending = loopCompactionRequests.get(sessionID);
-        if (pending?.jobId === job.id && pending.completedAt) {
-          await finalizeLoopCompaction(directory, client, sessionID);
+      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 = await ensureBranch(directory, job, client, sessionID);
+      const compactResult = await compactionRuntime.maybeCompact(directory, client, sessionID, job);
+      job = compactResult.job;
+      if (compactResult.started) {
+        state.jobs = (state.jobs || []).map((candidate) => candidate.id === job.id ? job : candidate);
+        await writeState2(directory, sessionID, state);
+        let timer;
+        if (job.timeoutMs > 0) {
+          timer = setTimeout(() => {
+            fireSdk2(client, "session.abort", client.session.abort.bind(client.session), { path: { id: sessionID }, body: {} }, { path: { sessionID }, body: {} }, { sessionID });
+            toast2(client, `Loop compact timeout fired: ${job.name || job.id}`, "warning").catch(() => {});
+          }, job.timeoutMs);
+        }
+        const runToken = `${job.id}:compact:${now2().toString(36)}:${Math.random().toString(16).slice(2)}`;
+        activeRuns.set(sessionID, { jobId: job.id, job, startedAt: now2(), timer, runToken, compactionOnly: true });
+        if (compactionRuntime.isCompleted(sessionID, job.id)) {
+          await compactionRuntime.finalize(directory, client, sessionID);
+          return;
+        }
+        markSessionStatus(sessionID, "busy");
+        await reschedule(busyRetryMs);
+        return;
+      }
+      if (runNowRequested)
+        delete job.runNowRequestedAt;
+      job.watchTriggered = false;
+      job.lastRunAt = now2();
+      job.runCount = (job.runCount || 0) + 1;
+      if (job.maxRuns > 0 && job.runCount >= job.maxRuns) {
+        job.enabled = false;
+        await notifyJob2(directory, job, "max_runs_reached");
+      }
+      state.jobs = (state.jobs || []).map((candidate) => candidate.id === job.id ? job : candidate);
+      await writeState2(directory, sessionID, state);
+      await appendLoopLog2(directory, "run", { sessionID, job: job.name || job.id, runCount: job.runCount });
+      await toast2(client, `Loop running: ${job.name || job.id}`, "info");
+      try {
+        const result = await fireAction(directory, client, sessionID, job);
+        if (!result.startsAssistantTurn) {
+          const fresh = await readState2(directory, sessionID);
+          if (result.pause) {
+            fresh.jobs = (fresh.jobs || []).map((candidate) => candidate.id === job.id ? {
+              ...candidate,
+              paused: true,
+              failureCount: (candidate.failureCount || 0) + 1,
+              lastFailureReason: result.reason || "action_did_not_start"
+            } : candidate);
+          }
+          fresh.jobs = (fresh.jobs || []).filter((candidate) => candidate.enabled !== false || isGoalJob(candidate));
+          await writeState2(directory, sessionID, fresh);
+          await reschedule();
           return;
         }
-      }
-      if (result.dispatch) {
-        result.dispatch.catch((error) => {
-          recoverActiveDispatchFailure(directory, client, sessionID, job.id, runToken, error).catch((recoveryError) => log(client, "error", "dispatch recovery failed", { error: sdkErrorMessage(recoveryError) }));
+        let timer;
+        if (job.timeoutMs > 0) {
+          timer = setTimeout(() => {
+            fireSdk2(client, "session.abort", client.session.abort.bind(client.session), { path: { id: sessionID }, body: {} }, { path: { sessionID }, body: {} }, { sessionID });
+            toast2(client, `Loop timeout fired: ${job.name || job.id}`, "warning").catch(() => {});
+          }, job.timeoutMs);
+        }
+        const runToken = `${job.id}:${now2().toString(36)}:${Math.random().toString(16).slice(2)}`;
+        activeRuns.set(sessionID, {
+          jobId: job.id,
+          job,
+          startedAt: now2(),
+          timer,
+          runToken,
+          compactionAction: result.compaction === true
+        });
+        if (result.compaction && compactionRuntime.isCompleted(sessionID, job.id)) {
+          await compactionRuntime.finalize(directory, client, sessionID);
+          return;
+        }
+        if (result.dispatch) {
+          result.dispatch.catch((error) => {
+            recoverActiveDispatchFailure(directory, client, sessionID, job.id, runToken, error).catch((recoveryError) => log2(client, "error", "dispatch recovery failed", { error: errorMessage(recoveryError) }));
+          });
+        }
+        markSessionStatus(sessionID, "busy");
+        await reschedule(busyRetryMs);
+      } catch (error) {
+        clearActiveRun(sessionID);
+        await toast2(client, `Loop job failed: ${error instanceof Error ? error.message : String(error)}`, "error");
+        await appendLoopLog2(directory, "error", {
+          sessionID,
+          job: job?.name || job?.id,
+          error: error instanceof Error ? error.message : String(error)
         });
+        await reschedule(busyRetryMs);
       }
-      sessionStatuses.set(sessionID, "busy");
-      sessionStatusSeenAt.set(sessionID, now());
-      await reschedule(BUSY_RETRY_MS);
-    } catch (error) {
-      clearActiveRun(sessionID);
-      await toast(client, `Loop job failed: ${error instanceof Error ? error.message : String(error)}`, "error");
-      await appendLoopLog(directory, "error", { sessionID, job: job?.name || job?.id, error: error instanceof Error ? error.message : String(error) });
-      await reschedule(BUSY_RETRY_MS);
+    } finally {
+      runLocks.delete(sessionID);
     }
-  } finally {
-    runLocks.delete(sessionID);
   }
+  return {
+    dueJobs,
+    clearActiveRun,
+    disposeSession,
+    recoverActiveDispatchFailure,
+    finalizeActiveRun,
+    fireAction,
+    maybeRunDueJobs,
+    sessionIsIdle,
+    updateSessionStatusFromEvent,
+    markSessionStatus,
+    clearSessionStatus,
+    noteLoopCompactionStarted: compactionRuntime.noteStarted,
+    noteLoopCompactionCompleted: compactionRuntime.noteCompleted,
+    getActiveRun: (sessionID) => activeRuns.get(sessionID),
+    isRunLocked: (sessionID) => runLocks.has(sessionID)
+  };
 }
-function normalizeActionForCompare(value) {
-  return String(value || "").replace(/\s+/g, " ").trim();
+
+// 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) {
+  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;
+  const props = event?.properties || {};
+  return props.info || props.message || props;
 }
-function sameLoopDefinition(a, b) {
-  if (!a || !b)
-    return false;
-  return (a.name || "") === (b.name || "") && Number(a.intervalMs || 0) === Number(b.intervalMs || 0) && normalizeActionForCompare(a.action) === normalizeActionForCompare(b.action) && normalizeActionForCompare(a.kind) === normalizeActionForCompare(b.kind) && normalizeActionForCompare(a.promptFile) === normalizeActionForCompare(b.promptFile);
+function userMessageFromEvent(event) {
+  const info = messageInfo(event);
+  if (!info || info.role !== "user")
+    return;
+  const props = event?.properties || {};
+  const sessionID = info.sessionID || props.sessionID;
+  if (typeof sessionID !== "string" || !sessionID)
+    return;
+  const messageID = typeof (info.id || props.messageID) === "string" ? info.id || props.messageID : "";
+  return { sessionID, messageID };
 }
-async function addLoop(directory, client, sessionID, args, defaults = {}) {
-  const parsed = parseLoopArgs(args, defaults);
-  if (!parsed.ok) {
-    await toast(client, parsed.error, "warning");
+function assistantMessageFromEvent(event) {
+  const info = messageInfo(event);
+  if (!info || info.role !== "assistant")
     return;
-  }
-  const executionContext = getSessionExecutionContext(sessionID) || { agent: "build" };
-  parsed.job.agent = defaults.agent || executionContext.agent || "build";
-  parsed.job.model = normalizedModelRef(defaults.model) || executionContext.model;
-  if (defaults.testfixPreset) {
-    const defaultCommand = String(defaults.verifyCommand || "npm test");
-    const parsedAction = String(parsed.job.action || "").trim();
-    const usedDefaultAction = parsedAction === String(defaults.action || "").trim();
-    if (!usedDefaultAction && parsed.job.verifyCommand === defaults.verifyCommand) {
-      parsed.job.verifyCommand = parsedAction;
-      parsed.job.action = `Run the project tests. Fix failures. Re-run the tests. Test command hint: ${parsedAction}`;
-    } else if (usedDefaultAction && parsed.job.verifyCommand !== defaults.verifyCommand) {
-      parsed.job.action = `Run the project tests. Fix failures. Re-run the tests. Test command hint: ${parsed.job.verifyCommand || defaultCommand}`;
-    }
-  }
-  if (parsed.job.watchPaths.length)
-    parsed.job.watchSnapshot = await snapshotPaths(directory, parsed.job.watchPaths);
-  if (!parsed.job.activeRecoveryMs) {
-    parsed.job.activeRecoveryMs = isGoalJob(parsed.job) ? DEFAULT_GOAL_ACTIVE_RECOVERY_MS : Math.max(DEFAULT_ACTIVE_GUARD_MS, Math.min(90000, (parsed.job.intervalMs || 0) + 1e4));
-  }
-  if (parsed.job.dryRun) {
-    await toast(client, `Loop dry run: ${jobLabel(parsed.job)}`, "info");
-    await say(client, sessionID, "OpenCode loop dry run:\n```json\n" + JSON.stringify(parsed.job, null, 2) + "\n```");
+  const props = event?.properties || {};
+  const sessionID = info.sessionID || props.sessionID;
+  if (typeof sessionID !== "string" || !sessionID)
     return;
+  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);
+  });
+}
+function createGoalSteeringRuntime(options = {}) {
+  const getActiveRun = requireFunction8(options.getActiveRun, "getActiveRun");
+  const clearActiveRun = requireFunction8(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;
+  const fireSdk2 = typeof options.fireSdk === "function" ? options.fireSdk : fireSdk;
+  const now2 = typeof options.now === "function" ? options.now : now;
+  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;
+    if (entry.expiresAt <= now2()) {
+      pendingSteering.delete(sessionID);
+      return;
+    }
+    return entry;
   }
-  const state = await readState(directory, sessionID);
-  const jobs = Array.isArray(state.jobs) ? state.jobs : [];
-  let replaced = false;
-  if (!parsed.job.multi) {
-    const targetName = parsed.job.name || "default";
-    parsed.job.name = targetName;
-    state.jobs = jobs.filter((existing) => {
-      const existingName = existing.name || "default";
-      const shouldReplace = existingName === targetName || sameLoopDefinition(existing, parsed.job);
-      if (shouldReplace)
-        replaced = true;
-      return !shouldReplace;
-    });
-  } else {
-    state.jobs = jobs;
+  function shouldSuppressIdle(sessionID) {
+    return Boolean(pendingForSession(sessionID));
   }
-  state.jobs.push(parsed.job);
-  await writeState(directory, sessionID, state);
-  await scheduleDueWork(directory, client, sessionID);
-  if (parsed.job.immediate)
-    scheduleIdleWork(directory, client, sessionID);
-  await toast(client, `${replaced ? "Loop replaced" : "Loop added"}: ${jobLabel(parsed.job)}`, "success");
-  await appendLoopLog(directory, replaced ? "replace" : "add", { sessionID, job: parsed.job.name || parsed.job.id, label: jobLabel(parsed.job) });
-}
-async function stopLoop(directory, client, sessionID, args) {
-  const target = String(args || "").trim();
-  if (!target || target.toLowerCase() === "all") {
-    await removeState(directory, sessionID);
-    clearActiveRun(sessionID);
-    const due = dueTimers.get(sessionID);
-    if (due)
-      clearTimeout(due);
-    dueTimers.delete(sessionID);
-    stopWatchdog(sessionID);
-    await toast(client, "All loops stopped for this session.", "success");
-    return;
+  function seenKey(sessionID, messageID) {
+    return messageID ? `${sessionID}\x00${messageID}` : "";
   }
-  const state = await readState(directory, sessionID);
-  const before = state.jobs.length;
-  state.jobs = state.jobs.filter((job, index) => !matchJob(job, target, index));
-  await writeState(directory, sessionID, state);
-  await scheduleDueWork(directory, client, sessionID);
-  await toast(client, `Stopped ${before - state.jobs.length} loop(s).`, "success");
-}
-async function updateJobState(directory, client, sessionID, args, updater, message) {
-  const target = String(args || "").trim() || "all";
-  const state = await readState(directory, sessionID);
-  let count = 0;
-  state.jobs = (state.jobs || []).map((job, index) => matchJob(job, target, index) ? (count++, updater(job)) : job);
-  await writeState(directory, sessionID, state);
-  await scheduleDueWork(directory, client, sessionID);
-  await toast(client, `${message}: ${count} loop(s).`, count ? "success" : "warning");
-}
-async function statusGoal(directory, client, sessionID) {
-  const state = await readState(directory, sessionID);
-  const goals = (state.jobs || []).filter(isGoalJob);
-  const lines = goals.length ? goals.map((job, index) => {
-    const status = goalStatusText(job);
-    const checks = job.goalChecks?.length ? ` | checks=${job.goalChecks.length}` : "";
-    const acceptance = job.goalAcceptance?.length ? ` | acceptance=${job.goalAcceptance.length}` : "";
-    const progress = job.goalProgress?.length ? ` | progress=${job.goalProgress.length}` : "";
-    const noProgress = (job.maxNoProgress ?? DEFAULT_GOAL_MAX_NO_PROGRESS) > 0 ? ` | no-progress=${job.noProgressCount || 0}/${job.maxNoProgress ?? DEFAULT_GOAL_MAX_NO_PROGRESS}` : "";
-    const rejected = job.goalCompletionRejectedReason ? " | completion-rejected" : "";
-    return `${index + 1}. ${job.id}${job.name ? ` (${job.name})` : ""}: ${status} | turns=${job.runCount || 0} | objective=${String(job.action || job.goalFile || "").slice(0, 220)}${checks}${acceptance}${progress}${noProgress}${rejected}`;
-  }) : ["No experimental goal jobs."];
-  await toast(client, goals.length ? `${goals.length} experimental goal(s).` : "No experimental goal jobs.", goals.length ? "info" : "warning");
-  await say(client, sessionID, `OpenCode Loop experimental goal status:
-` + lines.join(`
-`));
-}
-async function pauseGoal(directory, client, sessionID, args) {
-  const target = String(args || "").trim() || "goal";
-  const state = await readState(directory, sessionID);
-  let count = 0;
-  state.jobs = (state.jobs || []).map((job, index) => isGoalJob(job) && matchJob(job, target, index) ? (count++, { ...job, paused: true }) : job);
-  await writeState(directory, sessionID, state);
-  await scheduleDueWork(directory, client, sessionID);
-  await toast(client, `Paused ${count} experimental goal(s).`, count ? "success" : "warning");
-}
-async function resumeGoal(directory, client, sessionID, args) {
-  const target = String(args || "").trim() || "goal";
-  const state = await readState(directory, sessionID);
-  let count = 0;
-  state.jobs = (state.jobs || []).map((job, index) => {
-    if (!isGoalJob(job) || !matchJob(job, target, index))
-      return job;
-    count++;
-    return { ...job, paused: false, enabled: true, goalStatus: job.goalStatus === "blocked" ? "active" : job.goalStatus || "active", lastRunAt: 0, noProgressCount: 0, goalNoProgressReason: "", goalInterruptedReason: "" };
-  });
-  await writeState(directory, sessionID, state);
-  await toast(client, `Resumed ${count} experimental goal(s).`, count ? "success" : "warning");
-  if (count) {
-    await scheduleDueWork(directory, client, sessionID);
-    scheduleIdleWork(directory, client, sessionID);
+  function alreadyHandled(sessionID, messageID) {
+    const key = seenKey(sessionID, messageID);
+    if (!key)
+      return false;
+    const expiresAt = seenUserMessages.get(key);
+    if (!expiresAt)
+      return false;
+    if (expiresAt <= now2()) {
+      seenUserMessages.delete(key);
+      return false;
+    }
+    return true;
   }
-}
-async function clearGoal(directory, client, sessionID, args) {
-  const target = String(args || "").trim();
-  const state = await readState(directory, sessionID);
-  const before = state.jobs.length;
-  state.jobs = (state.jobs || []).filter((job, index) => !isGoalJob(job) || target && !matchJob(job, target, index));
-  await writeState(directory, sessionID, state);
-  await scheduleDueWork(directory, client, sessionID);
-  await toast(client, `Cleared ${before - state.jobs.length} experimental goal(s).`, before !== state.jobs.length ? "success" : "warning");
-}
-async function completeGoalCommand(directory, client, sessionID, args) {
-  const result = await setGoalComplete(directory, sessionID, { summary: String(args || "").trim() || "Goal manually marked complete.", evidence: "Marked complete by /loop-goal-done.", manual: true });
-  await toast(client, result.message, result.ok ? "success" : "warning");
-}
-async function blockGoalCommand(directory, client, sessionID, args) {
-  const result = await setGoalBlocked(directory, sessionID, { reason: String(args || "").trim() || "Goal manually marked blocked.", needed: "User input or manual intervention." });
-  await toast(client, result.message, result.ok ? "warning" : "warning");
-}
-async function addGoal(directory, client, sessionID, args) {
-  const text = String(args || "").trim();
-  const [maybeCommand, rest] = splitFirst(text);
-  const sub = maybeCommand.toLowerCase();
-  if (!text || sub === "status")
-    return await statusGoal(directory, client, sessionID);
-  if (sub === "pause")
-    return await pauseGoal(directory, client, sessionID, rest);
-  if (sub === "resume")
-    return await resumeGoal(directory, client, sessionID, rest);
-  if (["clear", "remove", "stop"].includes(sub))
-    return await clearGoal(directory, client, sessionID, rest);
-  if (["done", "complete", "completed"].includes(sub))
-    return await completeGoalCommand(directory, client, sessionID, rest);
-  if (["blocked", "block"].includes(sub))
-    return await blockGoalCommand(directory, client, sessionID, rest);
-  return await addLoop(directory, client, sessionID, text, { intervalMs: 0, kind: "goal", name: "goal", immediate: true, safe: true, askNever: true, noOverlap: true, goalStatus: "active" });
-}
-async function statusLoop(directory, client, sessionID) {
-  const state = await readState(directory, sessionID);
-  const jobs = state.jobs || [];
-  const lines = jobs.length ? jobs.map((job, index) => {
-    const dueIn = Math.max(0, job.intervalMs - (now() - (job.lastRunAt || 0)));
-    const flags = [isGoalJob(job) ? `goal:${goalStatusText(job)}` : undefined, job.paused ? "paused" : "active", 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}`;
-  }) : ["No active loop jobs."];
-  await toast(client, jobs.length ? `${jobs.length} loop job(s).` : "No active loop jobs.", jobs.length ? "info" : "warning");
-  await say(client, sessionID, `OpenCode loop status:
-` + lines.join(`
-`));
-}
-async function logsLoop(directory, client, sessionID) {
-  let text = "No loop log found.";
-  try {
-    text = (await fs3.readFile(path3.join(stateDir(directory), "loop.log"), "utf8")).trim().split(/\r?\n/).slice(-80).join(`
-`) || text;
-  } catch {}
-  await say(client, sessionID, `OpenCode loop logs:
-` + text);
-}
-async function helpLoop(client, sessionID) {
-  await say(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-doctor | /loop-init | /loop-export"
-  ].join(`
-`));
-}
-async function runNow(directory, client, sessionID, args) {
-  const target = String(args || "").trim() || "all";
-  const state = await readState(directory, sessionID);
-  let count = 0;
-  for (const [index, job] of (state.jobs || []).entries())
-    if (matchJob(job, target, index)) {
-      job.lastRunAt = 0;
-      job.paused = false;
-      count++;
+  function rememberHandled(sessionID, messageID) {
+    const key = seenKey(sessionID, messageID);
+    if (!key)
+      return;
+    const current = now2();
+    seenUserMessages.set(key, current + seenUserMessageMs);
+    for (const [candidate, expiresAt] of seenUserMessages.entries()) {
+      if (expiresAt <= current)
+        seenUserMessages.delete(candidate);
     }
-  await writeState(directory, sessionID, state);
-  await toast(client, `Marked ${count} loop job(s) due now.`, count ? "success" : "warning");
-  await maybeRunDueJobs(directory, client, sessionID, { force: true });
-}
-async function doctorLoop(directory, client, sessionID) {
-  const state = await readState(directory, sessionID);
-  await say(client, sessionID, [
-    "OpenCode Loop doctor:",
-    `- plugin: ${SERVICE}`,
-    `- project directory: ${directory}`,
-    `- state directory: ${stateDir(directory)}`,
-    `- active jobs: ${(state.jobs || []).length}`,
-    `- node: ${process.version}`,
-    `- platform: ${process.platform}`,
-    "- smoke test: /loop 0s --max-runs 1 --dry-run continue from progress.md",
-    "- experimental goal smoke test: /loop-goal --dry-run finish the current task and verify it"
-  ].join(`
-`));
+  }
+  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;
+    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 readState2(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: now2(),
+        expiresAt: now2() + suppressionMs
+      });
+      try {
+        await fireSdk2(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 appendLoopLog2(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;
+    return await handleUserMessage(directory, client, user);
+  }
+  function clearSession(sessionID) {
+    pendingSteering.delete(sessionID);
+    const prefix = `${sessionID}\x00`;
+    for (const key of seenUserMessages.keys())
+      if (key.startsWith(prefix))
+        seenUserMessages.delete(key);
+  }
+  return {
+    handleUserMessage,
+    handleEvent,
+    observeAssistantMessage,
+    shouldSuppressIdle,
+    hasPendingSteering: shouldSuppressIdle,
+    pendingForSession,
+    clearSession
+  };
 }
-async function initLoop(directory, client, sessionID, args) {
-  const target = String(args || "").trim() || "progress.md";
-  const full = path3.resolve(directory, target);
-  if (await pathExists(full)) {
-    await toast(client, `${target} already exists.`, "warning");
+
+// src/source/legacy-v1.js
+var DEFAULT_ACTIVE_GUARD_MS2 = 45000;
+var workspaceRuntime = createJobWorkspaceRuntime({ toast });
+var { snapshotPaths } = workspaceRuntime;
+var goalPolicy = createGoalExecutionPolicy({ runShellCommand, dangerousShell, toast, appendLoopLog, now });
+var schedulerRuntime;
+var goalSteeringRuntime;
+var schedulerBridge = {
+  rememberSession: (...args) => schedulerRuntime.rememberSession(...args),
+  scheduleDueWork: (...args) => schedulerRuntime.scheduleDueWork(...args)
+};
+var executorRuntime = createLoopExecutor({
+  workspace: workspaceRuntime,
+  goalPolicy,
+  scheduler: schedulerBridge,
+  toast,
+  log,
+  appendLoopLog,
+  errorMessage: sdkErrorMessage,
+  now
+});
+var {
+  clearActiveRun,
+  finalizeActiveRun,
+  maybeRunDueJobs: runDueJobs,
+  sessionIsIdle,
+  updateSessionStatusFromEvent,
+  noteLoopCompactionStarted,
+  noteLoopCompactionCompleted
+} = executorRuntime;
+async function maybeRunDueJobs(directory, client, sessionID, runOptions) {
+  if (goalSteeringRuntime?.shouldSuppressIdle(sessionID))
     return;
+  return await runDueJobs(directory, client, sessionID, runOptions);
+}
+schedulerRuntime = createSchedulerRuntime({
+  sessionIsIdle,
+  finalizeActiveRun,
+  maybeRunDueJobs,
+  appendLoopLog,
+  toast,
+  errorMessage: sdkErrorMessage
+});
+var { rememberSession, scheduleIdleWork, scheduleDueWork, stopWatchdog, cancelDueWork } = schedulerRuntime;
+goalSteeringRuntime = createGoalSteeringRuntime({
+  getActiveRun: executorRuntime.getActiveRun,
+  clearActiveRun,
+  isLoopOwnedUserMessage: loopOwnedUserMessageGuardActive,
+  appendLoopLog,
+  now
+});
+var { addLoop } = createLoopRegistration({
+  snapshotPaths,
+  scheduleDueWork,
+  scheduleIdleWork,
+  toast,
+  say,
+  defaultActiveGuardMs: DEFAULT_ACTIVE_GUARD_MS2
+});
+var {
+  addGoal,
+  statusGoal,
+  pauseGoal,
+  resumeGoal,
+  clearGoal,
+  completeGoalCommand,
+  blockGoalCommand
+} = createGoalCommandHandlers({
+  addLoop,
+  scheduleDueWork,
+  scheduleIdleWork,
+  toast,
+  say
+});
+var {
+  stopLoop,
+  updateJobState,
+  statusLoop,
+  logsLoop,
+  helpLoop,
+  runNow,
+  doctorLoop,
+  initLoop,
+  exportLoop
+} = createLoopCommandHandlers({
+  clearActiveRun,
+  cancelDueWork,
+  stopWatchdog,
+  scheduleDueWork,
+  maybeRunDueJobs,
+  toast,
+  say,
+  now
+});
+var handleCommand = createCommandRouter({
+  rememberSession,
+  handlers: {
+    addGoal,
+    statusGoal,
+    pauseGoal,
+    resumeGoal,
+    clearGoal,
+    completeGoalCommand,
+    blockGoalCommand,
+    addLoop,
+    stopLoop,
+    statusLoop,
+    logsLoop,
+    helpLoop,
+    runNow,
+    updateJobState,
+    doctorLoop,
+    initLoop,
+    exportLoop
   }
-  await fs3.writeFile(full, DEFAULT_PROGRESS_MD, "utf8");
-  await toast(client, `Created ${target}.`, "success");
-  await appendLoopLog(directory, "init", { sessionID, file: target });
-}
-async function exportLoop(directory, client, sessionID) {
-  const state = await readState(directory, sessionID);
-  await say(client, sessionID, "OpenCode loop state export:\n```json\n" + JSON.stringify(state, null, 2) + "\n```");
-}
-async function handleCommand(directory, client, input, fallbackName, fallbackArgs, output, source = "before") {
-  const name = commandName(input?.command ?? input?.name ?? fallbackName);
-  const sessionID = input?.sessionID;
-  const args = commandArgsText(input?.arguments ?? fallbackArgs ?? "");
-  if (!sessionID || !name)
-    return false;
-  rememberSession(directory, client, sessionID);
-  if (isLoopCommandName(name))
-    await captureSessionExecutionContext(client, sessionID);
-  if (source === "event") {
-    if (consumeHandled(sessionID, name, args))
-      return true;
-    const eventKey = commandEventKey(sessionID, input?.messageID);
-    if (handledCommandEvents.has(eventKey))
-      return true;
-    handledCommandEvents.set(eventKey, now());
-  } else {
-    markHandled(sessionID, name, args);
+});
+function disposeRuntime(directory, client) {
+  const sessions = schedulerRuntime.sessionIDsForHost(directory, client);
+  for (const sessionID of sessions) {
+    executorRuntime.disposeSession(sessionID);
+    schedulerRuntime.clearSessionScheduling(sessionID);
+    goalSteeringRuntime.clearSession(sessionID);
+    clearLoopOwnedUserMessageGuard(sessionID);
+    clearSessionActivity(sessionID);
+    clearCommandLifecycle(sessionID);
   }
-  if (isLoopCommandName(name))
-    guardLoopOwnedUserMessage(sessionID);
-  const handled = () => {
-    if (output && typeof output === "object")
-      output.noReply = true;
-    return true;
+}
+function steeringToolRejection(sessionID) {
+  if (!goalSteeringRuntime.hasPendingSteering(sessionID))
+    return;
+  return {
+    title: "Goal steering pending",
+    output: "Goal lifecycle update deferred because queued user steering is pending. The experimental Goal remains active and unchanged."
   };
-  if (name === "loop-goal")
-    return await addGoal(directory, client, sessionID, args), handled();
-  if (name === "loop-goal-status")
-    return await statusGoal(directory, client, sessionID), handled();
-  if (name === "loop-goal-pause")
-    return await pauseGoal(directory, client, sessionID, args), handled();
-  if (name === "loop-goal-resume")
-    return await resumeGoal(directory, client, sessionID, args), handled();
-  if (name === "loop-goal-clear")
-    return await clearGoal(directory, client, sessionID, args), handled();
-  if (name === "loop-goal-done" || name === "loop-goal-complete")
-    return await completeGoalCommand(directory, client, sessionID, args), handled();
-  if (name === "loop-goal-blocked")
-    return await blockGoalCommand(directory, client, sessionID, args), handled();
-  if (name === "loop")
-    return await addLoop(directory, client, sessionID, args), handled();
-  if (isPreset(name))
-    return await addLoop(directory, client, sessionID, args, presetDefaults(name, args)), handled();
-  if (name === "loop-stop" || name === "loop-remove")
-    return await stopLoop(directory, client, sessionID, args), handled();
-  if (name === "loop-clear")
-    return await stopLoop(directory, client, sessionID, "all"), handled();
-  if (name === "loop-status")
-    return await statusLoop(directory, client, sessionID), handled();
-  if (name === "loop-logs")
-    return await logsLoop(directory, client, sessionID), handled();
-  if (name === "loop-help")
-    return await helpLoop(client, sessionID), handled();
-  if (name === "loop-now")
-    return await runNow(directory, client, sessionID, args), handled();
-  if (name === "loop-pause")
-    return await updateJobState(directory, client, sessionID, args, (job) => ({ ...job, paused: true }), "Paused"), handled();
-  if (name === "loop-resume")
-    return await updateJobState(directory, client, sessionID, args, (job) => ({ ...job, paused: false, lastRunAt: 0 }), "Resumed"), handled();
-  if (name === "loop-doctor")
-    return await doctorLoop(directory, client, sessionID), handled();
-  if (name === "loop-init")
-    return await initLoop(directory, client, sessionID, args), handled();
-  if (name === "loop-export")
-    return await exportLoop(directory, client, sessionID), handled();
-  if (source === "event")
-    handledCommandEvents.delete(commandEventKey(sessionID, input?.messageID));
-  else
-    consumeHandled(sessionID, name, args);
-  return false;
 }
 function goalTools(defaultDirectory) {
   return {
@@ -2847,6 +3577,9 @@ function goalTools(defaultDirectory) {
         evidence: tool.schema.string().describe("Concrete evidence that the goal is complete, such as commands run, passing checks, files changed, and important results.")
       },
       execute: async (args, context) => {
+        const steering = steeringToolRejection(context.sessionID);
+        if (steering)
+          return steering;
         const result = await setGoalComplete(context.directory || defaultDirectory, context.sessionID, args);
         return { title: result.ok ? "Goal completed" : result.rejected ? "Goal completion rejected" : "Goal not found", output: result.message };
       }
@@ -2858,6 +3591,9 @@ function goalTools(defaultDirectory) {
         needed: tool.schema.string().describe("What user input, credential, decision, or manual action is needed to continue.")
       },
       execute: async (args, context) => {
+        const steering = steeringToolRejection(context.sessionID);
+        if (steering)
+          return steering;
         const result = await setGoalBlocked(context.directory || defaultDirectory, context.sessionID, args);
         return { title: result.ok ? "Goal blocked" : "Goal not found", output: result.message };
       }
@@ -2869,6 +3605,9 @@ function goalTools(defaultDirectory) {
         next: tool.schema.string().describe("The next step toward completing the goal.")
       },
       execute: async (args, context) => {
+        const steering = steeringToolRejection(context.sessionID);
+        if (steering)
+          return steering;
         const result = await setGoalProgress(context.directory || defaultDirectory, context.sessionID, args);
         return { title: result.ok ? "Goal progress" : "Goal not found", output: result.message };
       }
@@ -2889,6 +3628,14 @@ var OpenCodeLoopPlugin = async ({ client, directory }) => {
     "command.execute.before": async (input, output) => {
       await handleCommand(directory, client, input, undefined, undefined, output);
     },
+    "chat.message": async (input) => {
+      const steering = await goalSteeringRuntime.handleUserMessage(directory, client, {
+        sessionID: input?.sessionID,
+        messageID: input?.messageID
+      });
+      if (steering?.handled && steering.sessionID)
+        rememberSession(directory, client, steering.sessionID);
+    },
     "tool.execute.before": async (input) => {
       markToolCallActive(input);
     },
@@ -2909,21 +3656,420 @@ var OpenCodeLoopPlugin = async ({ client, directory }) => {
         const props = event.properties || {};
         await handleCommand(directory, client, props, props.name, props.arguments, undefined, "event");
       }
-      const interruptedSessionID = userInterruptSessionFromEvent(event);
-      if (interruptedSessionID) {
-        rememberSession(directory, client, interruptedSessionID);
-        await pauseGoalsForUserInterrupt(directory, client, interruptedSessionID);
-      }
+      const steering = await goalSteeringRuntime.handleEvent(directory, client, event);
+      if (steering?.handled && steering.sessionID)
+        rememberSession(directory, client, steering.sessionID);
       const statusUpdate = updateSessionStatusFromEvent(event);
       if (statusUpdate?.sessionID)
         rememberSession(directory, client, statusUpdate.sessionID);
-      if (statusUpdate?.idle)
+      if (statusUpdate?.idle && !goalSteeringRuntime.shouldSuppressIdle(statusUpdate.sessionID)) {
         scheduleIdleWork(directory, client, statusUpdate.sessionID);
+      }
     }
   };
 };
 var legacy_v1_default = OpenCodeLoopPlugin;
 
+// src/source/runtime/session-registry.js
+var DEFAULT_SESSION_STALE_MS = 12 * 60 * 60 * 1000;
+function sessionKey(sessionID) {
+  return String(sessionID || "").trim();
+}
+function createSessionRegistry({ now: now2 = Date.now, staleAfterMs = DEFAULT_SESSION_STALE_MS } = {}) {
+  if (typeof now2 !== "function")
+    throw new TypeError("session registry requires a clock function");
+  if (!Number.isFinite(staleAfterMs) || staleAfterMs < 0)
+    throw new TypeError("session registry requires a non-negative staleAfterMs");
+  const sessions = new Map;
+  function observeExternal(sessionID, runtime) {
+    const key = sessionKey(sessionID);
+    if (!key)
+      throw new TypeError("session registry requires a session ID");
+    const seenAt = Number(now2());
+    if (!Number.isFinite(seenAt))
+      throw new TypeError("session registry clock must return a finite number");
+    const entry = Object.freeze({ sessionID: key, runtime, seenAt });
+    sessions.set(key, entry);
+    return entry;
+  }
+  function peek(sessionID) {
+    return sessions.get(sessionKey(sessionID));
+  }
+  function remove(sessionID, expectedRuntime) {
+    const key = sessionKey(sessionID);
+    const current = sessions.get(key);
+    if (!current)
+      return false;
+    if (arguments.length > 1 && current.runtime !== expectedRuntime)
+      return false;
+    return sessions.delete(key);
+  }
+  function pruneStale(at = now2()) {
+    const timestamp = Number(at);
+    if (!Number.isFinite(timestamp))
+      throw new TypeError("session registry prune time must be finite");
+    const removed = [];
+    for (const [key, entry] of sessions) {
+      if (timestamp - entry.seenAt < staleAfterMs)
+        continue;
+      sessions.delete(key);
+      removed.push(key);
+    }
+    return removed;
+  }
+  function entries() {
+    return [...sessions.values()];
+  }
+  return Object.freeze({
+    observeExternal,
+    peek,
+    remove,
+    pruneStale,
+    entries
+  });
+}
+
+// src/source/runtime/scope.js
+function createRuntimeScope() {
+  const controller = new AbortController;
+  const cleanups = new Set;
+  let disposed = false;
+  function track(cleanup) {
+    if (typeof cleanup !== "function")
+      throw new TypeError("runtime scope cleanup must be a function");
+    if (disposed) {
+      cleanup();
+      return () => false;
+    }
+    const entry = { cleanup };
+    cleanups.add(entry);
+    let tracked = true;
+    return () => {
+      if (!tracked)
+        return false;
+      tracked = false;
+      return cleanups.delete(entry);
+    };
+  }
+  function guard(callback) {
+    if (typeof callback !== "function")
+      throw new TypeError("runtime scope guard requires a function");
+    return function(...args) {
+      if (disposed)
+        return;
+      return callback.apply(this, args);
+    };
+  }
+  function dispose(reason) {
+    if (disposed)
+      return false;
+    disposed = true;
+    controller.abort(reason);
+    const errors = [];
+    for (const entry of [...cleanups].reverse()) {
+      cleanups.delete(entry);
+      try {
+        entry.cleanup();
+      } catch (error) {
+        errors.push(error);
+      }
+    }
+    if (errors.length)
+      throw new AggregateError(errors, "runtime scope cleanup failed");
+    return true;
+  }
+  return Object.freeze({
+    signal: controller.signal,
+    isActive: () => !disposed,
+    track,
+    guard,
+    dispose
+  });
+}
+
+// src/source/runtime/timers.js
+function createOwnedTimer(scope, callback, delay2, repeat, api, ref) {
+  if (!scope?.isActive?.())
+    return;
+  let active = true;
+  let release;
+  let handle;
+  const invoke = scope.guard((...args) => {
+    if (!active)
+      return;
+    if (!repeat) {
+      active = false;
+      release?.();
+    }
+    callback(...args);
+  });
+  handle = repeat ? api.setInterval(invoke, delay2) : api.setTimeout(invoke, delay2);
+  release = scope.track(() => {
+    if (repeat)
+      api.clearInterval(handle);
+    else
+      api.clearTimeout(handle);
+  });
+  if (!ref)
+    handle?.unref?.();
+  return Object.freeze({
+    handle,
+    cancel() {
+      if (!active)
+        return false;
+      active = false;
+      if (repeat)
+        api.clearInterval(handle);
+      else
+        api.clearTimeout(handle);
+      release();
+      return true;
+    }
+  });
+}
+function createRuntimeTimers(scope, api = globalThis) {
+  return Object.freeze({
+    timeout(callback, delay2, options = {}) {
+      return createOwnedTimer(scope, callback, delay2, false, api, options.ref !== false);
+    },
+    interval(callback, delay2, options = {}) {
+      return createOwnedTimer(scope, callback, delay2, true, api, options.ref !== false);
+    }
+  });
+}
+
+// src/source/runtime/session-manager.js
+function defaultRuntimeFactory({ sessionID, timerAPI }) {
+  const scope = createRuntimeScope();
+  return Object.freeze({
+    sessionID,
+    scope,
+    timers: createRuntimeTimers(scope, timerAPI),
+    dispose: (reason) => scope.dispose(reason)
+  });
+}
+function validateRuntime(runtime, sessionID) {
+  if (!runtime || runtime.sessionID !== sessionID)
+    throw new TypeError("session runtime factory must preserve the session ID");
+  if (typeof runtime?.scope?.isActive !== "function")
+    throw new TypeError("session runtime factory must provide an active scope");
+  if (typeof runtime.dispose !== "function")
+    throw new TypeError("session runtime factory must provide dispose()");
+  return runtime;
+}
+function createSessionRuntimeManager({
+  now: now2 = Date.now,
+  staleAfterMs = DEFAULT_SESSION_STALE_MS,
+  timerAPI = globalThis,
+  runtimeFactory = defaultRuntimeFactory
+} = {}) {
+  if (typeof runtimeFactory !== "function")
+    throw new TypeError("session runtime manager requires a runtime factory");
+  const registry = createSessionRegistry({ now: now2, staleAfterMs });
+  let disposed = false;
+  function observeExternal(sessionID) {
+    if (disposed)
+      throw new Error("session runtime manager is disposed");
+    const key = String(sessionID || "").trim();
+    if (!key)
+      throw new TypeError("session runtime manager requires a session ID");
+    const current = registry.peek(key);
+    const runtime = current?.runtime?.scope?.isActive?.() ? current.runtime : validateRuntime(runtimeFactory({ sessionID: key, timerAPI }), key);
+    registry.observeExternal(key, runtime);
+    return runtime;
+  }
+  function peek(sessionID) {
+    return registry.peek(sessionID)?.runtime;
+  }
+  function entries() {
+    return registry.entries();
+  }
+  function remove(sessionID, { expectedRuntime, reason } = {}) {
+    const current = registry.peek(sessionID);
+    if (!current)
+      return false;
+    if (expectedRuntime !== undefined && current.runtime !== expectedRuntime)
+      return false;
+    if (!registry.remove(sessionID, current.runtime))
+      return false;
+    current.runtime.dispose(reason);
+    return true;
+  }
+  function pruneStale(at = now2()) {
+    const before = new Map(registry.entries().map((entry) => [entry.sessionID, entry.runtime]));
+    const removed = registry.pruneStale(at);
+    const errors = [];
+    for (const sessionID of removed) {
+      try {
+        before.get(sessionID)?.dispose("stale-session");
+      } catch (error) {
+        errors.push(error);
+      }
+    }
+    if (errors.length)
+      throw new AggregateError(errors, "stale session cleanup failed");
+    return removed;
+  }
+  function dispose(reason) {
+    if (disposed)
+      return false;
+    disposed = true;
+    const errors = [];
+    for (const entry of registry.entries()) {
+      registry.remove(entry.sessionID, entry.runtime);
+      try {
+        entry.runtime.dispose(reason);
+      } catch (error) {
+        errors.push(error);
+      }
+    }
+    if (errors.length)
+      throw new AggregateError(errors, "session runtime manager cleanup failed");
+    return true;
+  }
+  return Object.freeze({
+    observeExternal,
+    peek,
+    entries,
+    remove,
+    pruneStale,
+    dispose
+  });
+}
+
+// src/source/runtime/events.js
+function record(value) {
+  return value && typeof value === "object" ? value : undefined;
+}
+function text(value) {
+  return typeof value === "string" && value.trim() ? value : undefined;
+}
+function envelope(input) {
+  const outer = record(input);
+  if (!outer)
+    return;
+  const payload = record(outer.payload);
+  if (payload && text(payload.type)) {
+    return { directory: text(outer.directory), event: payload };
+  }
+  const wrappedEvent = record(outer.event);
+  if (wrappedEvent && text(wrappedEvent.type)) {
+    return { directory: text(outer.directory), event: wrappedEvent };
+  }
+  if (!text(outer.type))
+    return;
+  return { directory: undefined, event: outer };
+}
+function freezeEvent(value) {
+  return Object.freeze(value);
+}
+function normalizeOpenCodeEvent(input) {
+  const parsed = envelope(input);
+  if (!parsed)
+    return;
+  const { directory, event } = parsed;
+  const properties = record(event.properties) || {};
+  if (event.type === "session.status") {
+    const sessionID = text(properties.sessionID);
+    const status = text(record(properties.status)?.type);
+    if (!sessionID || !status)
+      return;
+    return freezeEvent({ kind: "session", action: "status", sessionID, directory, status });
+  }
+  if (event.type === "session.idle" || event.type === "session.compacted") {
+    const sessionID = text(properties.sessionID);
+    if (!sessionID)
+      return;
+    return freezeEvent({
+      kind: "session",
+      action: event.type === "session.idle" ? "idle" : "compacted",
+      sessionID,
+      directory
+    });
+  }
+  if (event.type === "session.created" || event.type === "session.updated" || event.type === "session.deleted") {
+    const info = record(properties.info);
+    const sessionID = text(info?.id);
+    if (!sessionID)
+      return;
+    return freezeEvent({
+      kind: "session",
+      action: event.type.slice("session.".length),
+      sessionID,
+      directory: directory || text(info?.directory),
+      parentID: text(info?.parentID)
+    });
+  }
+  if (event.type === "session.error") {
+    const sessionID = text(properties.sessionID);
+    if (!sessionID)
+      return;
+    return freezeEvent({ kind: "session", action: "error", sessionID, directory });
+  }
+  if (event.type === "message.updated") {
+    const info = record(properties.info);
+    const sessionID = text(info?.sessionID);
+    const messageID = text(info?.id);
+    const role = text(info?.role);
+    if (!sessionID || !messageID || !role)
+      return;
+    const time = record(info?.time);
+    return freezeEvent({
+      kind: "message",
+      action: "updated",
+      sessionID,
+      directory,
+      messageID,
+      role,
+      completedAt: Number.isFinite(time?.completed) ? time.completed : undefined,
+      finish: text(info?.finish)
+    });
+  }
+  if (event.type === "command.executed") {
+    const sessionID = text(properties.sessionID);
+    const name = text(properties.name);
+    if (!sessionID || !name)
+      return;
+    return freezeEvent({
+      kind: "command",
+      action: "executed",
+      sessionID,
+      directory,
+      name,
+      arguments: typeof properties.arguments === "string" ? properties.arguments : "",
+      messageID: text(properties.messageID)
+    });
+  }
+  if (event.type === "server.instance.disposed") {
+    const disposedDirectory = directory || text(properties.directory);
+    if (!disposedDirectory)
+      return;
+    return freezeEvent({ kind: "server", action: "disposed", directory: disposedDirectory });
+  }
+  return;
+}
+
+// src/source/runtime/observer.js
+function observeRuntimeEvent(manager, input) {
+  const event = normalizeOpenCodeEvent(input);
+  if (!event || !manager)
+    return event;
+  try {
+    if (event.kind === "server" && event.action === "disposed") {
+      manager.dispose?.("server-disposed");
+      return event;
+    }
+    if (!event.sessionID)
+      return event;
+    if (event.kind === "session" && event.action === "deleted") {
+      manager.remove?.(event.sessionID, { reason: "session-deleted" });
+      return event;
+    }
+    manager.observeExternal?.(event.sessionID);
+  } catch {}
+  return event;
+}
+
 // src/source/v1.js
 var clientGenerations = new WeakMap;
 function reserveClientGeneration(client, directory) {
@@ -2967,13 +4113,24 @@ var OpenCodeLoopPlugin2 = async (input = {}) => {
   const legacyDispose = typeof hooks?.dispose === "function" ? hooks.dispose.bind(hooks) : undefined;
   if (!legacyDispose)
     return hooks;
+  const runtimeManager = createSessionRuntimeManager();
+  const legacyEvent = typeof hooks?.event === "function" ? hooks.event.bind(hooks) : undefined;
   let disposed = false;
   return {
     ...hooks,
+    ...legacyEvent ? {
+      event: async (payload) => {
+        observeRuntimeEvent(runtimeManager, payload);
+        return await legacyEvent(payload);
+      }
+    } : {},
     dispose: async () => {
       if (disposed)
         return;
       disposed = true;
+      try {
+        runtimeManager.dispose("plugin-disposed");
+      } catch {}
       await legacyDispose();
       scheduleLegacyCleanup(legacyDispose, isCurrentGeneration);
     }