@bybrawe/opencode-loop 0.5.1 → 0.5.6

package/commands/loop-ask.md

@@ -0,0 +1,5 @@
+---
+description: Schedule a recurring prompt/question. Usage: /loop-ask 1h did you run tests?
+---
+
+Loop ask scheduler received. The OpenCode Loop plugin handles this recurring prompt locally. Do not explain this command, do not search the web, do not create scheduler files, and do not run extra shell commands because of this command.

package/commands/loop-cmd.md

@@ -0,0 +1,5 @@
+---
+description: Alias for /loop-command. Usage: /loop-cmd 200m /compact
+---
+
+Loop command scheduler received. The OpenCode Loop plugin handles this slash-command schedule locally. Do not explain this command, do not search the web, do not create scheduler files, and do not run extra shell commands because of this command.

package/commands/loop-command.md

@@ -0,0 +1,5 @@
+---
+description: Schedule an OpenCode slash command loop. Usage: /loop-command 200m /compact
+---
+
+Loop command scheduler received. The OpenCode Loop plugin handles this slash-command schedule locally. Do not explain this command, do not search the web, do not create scheduler files, and do not run extra shell commands because of this command.

package/commands/loop-prompt.md

@@ -0,0 +1,5 @@
+---
+description: Schedule a recurring prompt loop. Usage: /loop-prompt 1h continue the project
+---
+
+Loop prompt scheduler received. The OpenCode Loop plugin handles this recurring prompt locally. Do not explain this command, do not search the web, do not create scheduler files, and do not run extra shell commands because of this command.

package/commands/loop-shell.md

@@ -0,0 +1,5 @@
+---
+description: Schedule a recurring shell command. Usage: /loop-shell 10m npm test
+---
+
+Loop shell scheduler received. The OpenCode Loop plugin handles this shell schedule locally. Do not explain this command, do not search the web, do not create scheduler files, and do not run extra shell commands because of this command.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bybrawe/opencode-loop",
-  "version": "0.5.1",
+  "version": "0.5.6",
   "description": "Claude Code style /loop command and background daemon for OpenCode: auto-continue, progress.md TODO automation, compact scheduling, verification, checkpoints, and safe autonomous coding loops.",
   "type": "module",
   "main": "src/index.js",
@@ -57,5 +57,8 @@
   "bin": {
     "opencode-loop": "./scripts/install-node.mjs",
     "opencode-loopd": "./scripts/loopd.mjs"
+  },
+  "publishConfig": {
+    "access": "public"
   }
 }

package/src/index.js

@@ -5,11 +5,14 @@ import { spawn } from "node:child_process"
 const SERVICE = "opencode-loop"
 const STATE_DIR = ".opencode/opencode-loop"
 const DEFAULT_ACTIVE_GUARD_MS = 60_000
+const IDLE_DEBOUNCE_MS = 1_200
 const MAX_SCAN_FILES = 200
 const MAX_SCAN_BYTES = 2_000_000
 
 const activeRuns = new Map()
 const handledCommands = new Map()
+const idleTimers = new Map()
+const sessionStatuses = new Map()
 
 const DEFAULT_PROGRESS_MD = `# Progress
 
@@ -146,7 +149,7 @@ function parseLoopArgs(raw, defaults = {}) {
     } else if (first) {
       const parsedDuration = parseDuration(first)
       if (parsedDuration !== null) intervalMs = parsedDuration
-      else if (intervalMs === null) return { ok: false, error: "Usage: /loop 0s <prompt> | /loop 5m <prompt> | /loop 200m /compact | /loop 10m !npm test | /loop --watch progress.md <prompt>" }
+      else if (intervalMs === null) return { ok: false, error: "Usage: /loop 0s <prompt> | /loop 5m <prompt> | /loop-command 200m /compact | /loop-shell 10m npm test | /loop --watch progress.md <prompt>" }
       else rest = input
     }
   }
@@ -157,6 +160,7 @@ function parseLoopArgs(raw, defaults = {}) {
     id: `${now().toString(36)}-${Math.random().toString(16).slice(2, 8)}`,
     name: defaults.name,
     action: defaults.action || "",
+    kind: defaults.kind || undefined,
     intervalMs,
     immediate: defaults.immediate ?? true,
     maxRuns: defaults.maxRuns ?? 0,
@@ -215,6 +219,13 @@ function parseLoopArgs(raw, defaults = {}) {
   ;[found, rest] = takeFlag(rest, "--dry-run"); if (found) job.dryRun = true
   ;[found, rest] = takeFlag(rest, "--multi"); if (found) job.multi = true
   ;[found, rest] = takeFlag(rest, "--replace"); if (found) job.multi = false
+  ;[found, rest] = takeFlag(rest, "--prompt"); if (found) job.kind = "prompt"
+  ;[found, rest] = takeFlag(rest, "--ask"); if (found) job.kind = "prompt"
+  ;[found, rest] = takeFlag(rest, "--command"); if (found) job.kind = "command"
+  ;[found, rest] = takeFlag(rest, "--cmd"); if (found) job.kind = "command"
+  ;[found, rest] = takeFlag(rest, "--slash"); if (found) job.kind = "command"
+  ;[found, rest] = takeFlag(rest, "--shell"); if (found) job.kind = "shell"
+  ;[found, rest] = takeFlag(rest, "--compact"); if (found) job.kind = "compact"
 
   ;[value, rest] = takeFlagValue(rest, "--name"); if (value !== undefined) job.name = value.trim()
   ;[value, rest] = takeFlagValue(rest, "--max-runs"); if (value !== undefined) job.maxRuns = parsePositiveInt(value, 0)
@@ -273,11 +284,112 @@ async function writeState(directory, sessionID, state) {
 
 async function removeState(directory, sessionID) { try { await fs.unlink(statePath(directory, sessionID)) } catch {} }
 
+function sdkError(result) {
+  if (!result || typeof result !== "object") return undefined
+  return result.error || result.error === null ? result.error : undefined
+}
+
+function sdkData(result) {
+  if (!result || typeof result !== "object") return result
+  return Object.prototype.hasOwnProperty.call(result, "data") ? result.data : result
+}
+
+function sdkErrorMessage(error) {
+  if (!error) return "unknown SDK error"
+  if (error instanceof Error) return error.message
+  if (typeof error === "string") return error
+  if (typeof error === "object") {
+    if (typeof error.message === "string") return error.message
+    if (typeof error.name === "string") return error.name
+    try { return JSON.stringify(error).slice(0, 400) } catch {}
+  }
+  return String(error)
+}
+
+async function sdkCall(method, modernArgs, legacyArgs) {
+  let firstError
+  try {
+    const result = await method(modernArgs)
+    const error = sdkError(result)
+    if (!error) return sdkData(result)
+    firstError = new Error(sdkErrorMessage(error))
+  } catch (error) {
+    firstError = error
+  }
+  if (legacyArgs !== undefined) {
+    try {
+      const result = await method(legacyArgs)
+      const error = sdkError(result)
+      if (!error) return sdkData(result)
+      throw new Error(sdkErrorMessage(error))
+    } catch (error) {
+      throw error
+    }
+  }
+  throw firstError
+}
+
+function fireSdk(client, label, method, modernArgs, legacyArgs) {
+  Promise.resolve()
+    .then(() => sdkCall(method, modernArgs, legacyArgs))
+    .catch((error) => log(client, "warn", `${label} failed`, { error: sdkErrorMessage(error) }))
+}
+
+async function executeTuiCommand(client, command) {
+  if (!client?.tui?.executeCommand) throw new Error("client.tui.executeCommand is not available")
+  return await sdkCall(
+    client.tui.executeCommand.bind(client.tui),
+    { command },
+    { body: { command } },
+  )
+}
+
+function compactTuiCommandName(command = "compact") {
+  const normalized = String(command || "compact").replace(/^\/+/, "").trim().toLowerCase()
+  if (normalized === "compact" || normalized === "summarize") return "session.compact"
+  return undefined
+}
+
+async function compactSession(client, sessionID) {
+  try {
+    await executeTuiCommand(client, "session.compact")
+    return true
+  } catch (error) {
+    await log(client, "warn", "tui session.compact failed", { error: sdkErrorMessage(error) })
+  }
+  try {
+    await sdkCall(client.session.summarize.bind(client.session), { sessionID }, { path: { id: sessionID }, body: {} })
+    return true
+  } catch (error) {
+    await log(client, "warn", "session.summarize fallback failed", { error: sdkErrorMessage(error) })
+  }
+  await toast(client, "Could not run /compact from loop. Check OpenCode version and active TUI session.", "error")
+  return false
+}
+
 async function log(client, level, message, extra) {
-  try { await client.app.log({ body: extra === undefined ? { service: SERVICE, level, message } : { service: SERVICE, level, message, extra } }) } catch {}
+  try {
+    await sdkCall(
+      client.app.log.bind(client.app),
+      extra === undefined ? { service: SERVICE, level, message } : { service: SERVICE, level, message, extra },
+      { body: extra === undefined ? { service: SERVICE, level, message } : { service: SERVICE, level, message, extra } },
+    )
+  } catch {}
+}
+
+async function toast(client, message, variant = "info") {
+  try { await sdkCall(client.tui.showToast.bind(client.tui), { message, variant }, { body: { message, variant } }) } catch {}
+}
+
+async function say(client, sessionID, text) {
+  try {
+    await sdkCall(
+      client.session.prompt.bind(client.session),
+      { sessionID, noReply: true, parts: [{ type: "text", text }] },
+      { path: { id: sessionID }, body: { noReply: true, parts: [{ type: "text", text }] } },
+    )
+  } catch {}
 }
-async function toast(client, message, variant = "info") { try { await client.tui.showToast({ body: { message, variant } }) } catch {} }
-async function say(client, sessionID, text) { try { await client.session.prompt({ path: { id: sessionID }, body: { noReply: true, parts: [{ type: "text", text }] } }) } catch {} }
 
 function commandKey(sessionID, name, args) { return `${sessionID || "no-session"}:${name || ""}:${args || ""}` }
 function markHandled(sessionID, name, args) {
@@ -290,13 +402,17 @@ function wasHandled(sessionID, name, args) {
 }
 
 function commandName(name) { return String(name || "") }
-function isPreset(name) { return ["loop-dev", "loop-testfix", "loop-compact", "loop-progress", "loop-safe-dev"].includes(name) }
+function isPreset(name) { return ["loop-dev", "loop-testfix", "loop-compact", "loop-progress", "loop-safe-dev", "loop-command", "loop-cmd", "loop-prompt", "loop-ask", "loop-shell"].includes(name) }
 function presetDefaults(name, args) {
   const [maybeDuration, rest] = splitFirst(args)
   const parsed = parseDuration(maybeDuration)
   const intervalMs = parsed === null ? 0 : parsed
   const extra = parsed === null ? String(args || "").trim() : rest
-  if (name === "loop-compact") return { intervalMs: intervalMs || parseDuration("200m"), action: extra || "/compact", name: "compact", immediate: false }
+  if (name === "loop-compact") return { intervalMs: intervalMs || parseDuration("200m"), action: extra || "/compact", kind: "compact", name: "compact", immediate: false }
+  if (name === "loop-command" || name === "loop-cmd") return { intervalMs, action: extra, kind: "command", name: "command", immediate: false }
+  if (name === "loop-prompt") return { intervalMs, action: extra, kind: "prompt", name: "prompt", immediate: true }
+  if (name === "loop-ask") return { intervalMs, action: extra, kind: "prompt", name: "ask", immediate: false }
+  if (name === "loop-shell") return { intervalMs, action: extra, kind: "shell", name: "shell", immediate: false }
   if (name === "loop-testfix") return { intervalMs, name: "testfix", safe: true, askNever: true, verifyCommand: extra || "npm test", action: `Run the project tests. Fix failures. Re-run the tests. Test command hint: ${extra || "npm test"}` }
   if (name === "loop-progress") return { intervalMs, name: "progress", safe: true, askNever: true, progressFile: "progress.md", action: extra || "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, name: "safe-dev", safe: true, askNever: true, noOverlap: true, checkpointOnly: true, batch: 5, progressFile: "progress.md", action: extra || "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." }
@@ -305,6 +421,7 @@ function presetDefaults(name, args) {
 
 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)}` : ""
@@ -315,7 +432,7 @@ function jobLabel(job) {
   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)} -> ${job.action || `[prompt-file: ${job.promptFile}]`}${limit}${runtime}${timeout}${compact}${verify}${preflight}${failures}${stopFile}${watch}${paused}`
+  return `${title}${durationToText(job.intervalMs)}${kind} -> ${job.action || `[prompt-file: ${job.promptFile}]`}${limit}${runtime}${timeout}${compact}${verify}${preflight}${failures}${stopFile}${watch}${paused}`
 }
 
 function matchJob(job, target, index) {
@@ -376,9 +493,14 @@ function dangerousShell(command) {
   return [/\brm\s+-rf\b/, /\bgit\s+reset\b/, /\bgit\s+clean\b/, /\bgit\s+push\b/, /\bdel\s+\/s\b/, /\brmdir\s+\/s\b/, /\bformat\b/, /\bterraform\s+destroy\b/, /\bkubectl\s+delete\b/, /\bdeploy\b.*\bproduction\b/].some((pattern) => pattern.test(text))
 }
 
-function actionKind(action) {
+function actionKind(action, job = {}) {
   const text = String(action || "").trim()
+  const forced = String(job.kind || "").trim().toLowerCase()
+  if (forced === "compact") return "compact"
   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"
@@ -430,11 +552,10 @@ async function maybeCompact(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
-  try {
-    await client.session.summarize({ path: { id: sessionID }, body: {} })
+  if (await compactSession(client, sessionID)) {
     job.lastCompactAt = now()
     job.lastCompactRunCount = job.runCount || 0
-  } catch {}
+  }
   return job
 }
 
@@ -508,14 +629,62 @@ async function createCheckpoint(directory, sessionID, job, client) {
   await toast(client, `Loop checkpoint saved: ${prefix}`, "success")
 }
 
-function getIdleSessionID(event) {
+function updateSessionStatusFromEvent(event) {
   const sessionID = event?.properties?.sessionID
-  if (event?.type === "session.idle" && typeof sessionID === "string") return sessionID
-  const status = event?.properties?.status
-  if (event?.type === "session.status" && typeof sessionID === "string" && status && typeof status === "object" && status.type === "idle") return sessionID
+  if (typeof sessionID !== "string") return undefined
+  if (event?.type === "session.idle") {
+    sessionStatuses.set(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") sessionStatuses.set(sessionID, type)
+    return { sessionID, idle: type === "idle" }
+  }
   return undefined
 }
 
+async function sessionStatusType(client, sessionID) {
+  const cached = sessionStatuses.get(sessionID)
+  if (cached && cached !== "idle") return cached
+  try {
+    const data = await sdkCall(client.session.status.bind(client.session), {}, undefined)
+    const status = data?.[sessionID]
+    const type = status && typeof status === "object" ? status.type : undefined
+    if (typeof type === "string") {
+      sessionStatuses.set(sessionID, type)
+      return type
+    }
+  } catch {}
+  sessionStatuses.set(sessionID, "idle")
+  return "idle"
+}
+
+async function sessionIsIdle(client, sessionID) {
+  return await sessionStatusType(client, sessionID) === "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)) return
+        await finalizeActiveRun(directory, client, sessionID)
+        if (!await sessionIsIdle(client, sessionID)) 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 dueJobs(state, force = false) {
   const current = now()
   return (state.jobs || []).filter((job) => {
@@ -588,32 +757,46 @@ async function finalizeActiveRun(directory, client, sessionID) {
 
 async function fireAction(directory, client, sessionID, job) {
   const action = String(job.action || "").trim()
-  const kind = actionKind(action)
+  const kind = actionKind(action, job)
   if (kind === "compact") {
-    await client.session.summarize({ path: { id: sessionID }, body: {} })
-    return { startsAssistantTurn: false }
+    const ok = await compactSession(client, sessionID)
+    return { startsAssistantTurn: ok }
   }
   if (kind === "command") {
-    const [command, argumentsText] = splitFirst(action.slice(1))
-    client.session.command({ path: { id: sessionID }, body: { command, arguments: argumentsText } }).catch(() => {})
+    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 }
+    }
+    const tuiCommand = compactTuiCommandName(command)
+    if (tuiCommand) {
+      await executeTuiCommand(client, tuiCommand)
+      return { startsAssistantTurn: true }
+    }
+    await sdkCall(client.session.command.bind(client.session), { sessionID, command, arguments: argumentsText }, { path: { id: sessionID }, body: { command, arguments: argumentsText } })
     return { startsAssistantTurn: true }
   }
   if (kind === "shell") {
-    const command = action.slice(1).trim()
+    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 }
     }
-    client.session.shell({ path: { id: sessionID }, body: { command } }).catch(() => {})
+    fireSdk(client, "session.shell", client.session.shell.bind(client.session), { sessionID, command }, { path: { id: sessionID }, body: { command } })
     return { startsAssistantTurn: true }
   }
   const prompt = await buildPrompt(directory, job)
-  client.session.prompt({ path: { id: sessionID }, body: { parts: [{ type: "text", text: `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.\n\n${prompt}` }] } }).catch(() => {})
+  fireSdk(client, "session.prompt", client.session.prompt.bind(client.session), { sessionID, parts: [{ type: "text", text: `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.\n\n${prompt}` }] }, { path: { id: sessionID }, body: { parts: [{ type: "text", text: `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.\n\n${prompt}` }] } })
   return { startsAssistantTurn: true }
 }
 
 async function maybeRunDueJobs(directory, client, sessionID, options = {}) {
+  if (!await sessionIsIdle(client, sessionID)) {
+    if (options.force) await toast(client, "Loop queued: session is busy; it will run on the next idle event.", "info")
+    return
+  }
   const active = activeRuns.get(sessionID)
   if (active && active.job?.noOverlap !== false && now() - active.startedAt < (active.job?.timeoutMs || DEFAULT_ACTIVE_GUARD_MS)) return
 
@@ -692,7 +875,7 @@ async function maybeRunDueJobs(directory, client, sessionID, options = {}) {
     }
     if (result.startsAssistantTurn) {
       let timer
-      if (job.timeoutMs > 0) timer = setTimeout(() => { client.session.abort?.({ path: { id: sessionID }, body: {} }).catch(() => {}); toast(client, `Loop timeout fired: ${job.name || job.id}`, "warning").catch(() => {}) }, job.timeoutMs)
+      if (job.timeoutMs > 0) timer = setTimeout(() => { fireSdk(client, "session.abort", client.session.abort.bind(client.session), { sessionID }, { path: { id: sessionID }, body: {} }); toast(client, `Loop timeout fired: ${job.name || job.id}`, "warning").catch(() => {}) }, job.timeoutMs)
       activeRuns.set(sessionID, { jobId: job.id, job, startedAt: now(), timer })
     }
   } catch (error) {
@@ -711,6 +894,7 @@ function sameLoopDefinition(a, b) {
   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)
 }
 
@@ -741,6 +925,7 @@ async function addLoop(directory, client, sessionID, args, defaults = {}) {
 
   state.jobs.push(parsed.job)
   await writeState(directory, sessionID, state)
+  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) })
 }
@@ -786,9 +971,11 @@ 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 loop",
-    "/loop 200m --no-now /compact                      compact/summarize loop",
-    "/loop 10m !npm test                               shell loop",
+    "/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 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",
@@ -834,7 +1021,7 @@ async function exportLoop(directory, client, 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) {
+async function handleCommand(directory, client, input, fallbackName, fallbackArgs, output) {
   const name = commandName(input?.command ?? input?.name ?? fallbackName)
   const sessionID = input?.sessionID
   const args = input?.arguments ?? fallbackArgs ?? ""
@@ -842,19 +1029,27 @@ async function handleCommand(directory, client, input, fallbackName, fallbackArg
   if (wasHandled(sessionID, name, args)) return true
   markHandled(sessionID, name, args)
 
-  if (name === "loop") return await addLoop(directory, client, sessionID, args), true
-  if (isPreset(name)) return await addLoop(directory, client, sessionID, args, presetDefaults(name, args)), true
-  if (name === "loop-stop" || name === "loop-remove") return await stopLoop(directory, client, sessionID, args), true
-  if (name === "loop-clear") return await stopLoop(directory, client, sessionID, "all"), true
-  if (name === "loop-status") return await statusLoop(directory, client, sessionID), true
-  if (name === "loop-logs") return await logsLoop(directory, client, sessionID), true
-  if (name === "loop-help") return await helpLoop(client, sessionID), true
-  if (name === "loop-now") return await runNow(directory, client, sessionID, args), true
-  if (name === "loop-pause") return await updateJobState(directory, client, sessionID, args, (job) => ({ ...job, paused: true }), "Paused"), true
-  if (name === "loop-resume") return await updateJobState(directory, client, sessionID, args, (job) => ({ ...job, paused: false, lastRunAt: 0 }), "Resumed"), true
-  if (name === "loop-doctor") return await doctorLoop(directory, client, sessionID), true
-  if (name === "loop-init") return await initLoop(directory, client, sessionID, args), true
-  if (name === "loop-export") return await exportLoop(directory, client, sessionID), true
+  const handled = () => {
+    if (output && Array.isArray(output.parts)) {
+      output.parts.length = 0
+      output.parts.push({ type: "text", text: "OpenCode Loop command was handled by the local plugin. Do not explain this command; continue only when the loop injects its next task." })
+    }
+    return true
+  }
+
+  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()
   handledCommands.delete(commandKey(sessionID, name, args))
   return false
 }
@@ -862,17 +1057,14 @@ async function handleCommand(directory, client, input, fallbackName, fallbackArg
 export const OpenCodeLoopPlugin = async ({ client, directory }) => {
   await log(client, "info", "Plugin initialized", { directory })
   return {
-    "command.execute.before": async (input) => { await handleCommand(directory, client, input) },
+    "command.execute.before": async (input, output) => { await handleCommand(directory, client, input, undefined, undefined, output) },
     event: async ({ event }) => {
       if (event.type === "command.executed") {
         const props = event.properties || {}
         await handleCommand(directory, client, props, props.name, props.arguments)
       }
-      const idleSessionID = getIdleSessionID(event)
-      if (idleSessionID) {
-        await finalizeActiveRun(directory, client, idleSessionID)
-        await maybeRunDueJobs(directory, client, idleSessionID)
-      }
+      const statusUpdate = updateSessionStatusFromEvent(event)
+      if (statusUpdate?.idle) scheduleIdleWork(directory, client, statusUpdate.sessionID)
     },
   }
 }