@bybrawe/opencode-loop 0.5.4 → 0.5.6

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## 0.5.6
+
+- Added clearer README examples for prompt loops, scheduled question loops, OpenCode slash-command loops, shell loops, first-run timing, and idle-safe behavior.
+- Stabilized `/loop-command 200m /compact` by routing `/compact` and `/summarize` through OpenCode TUI compact handling instead of treating them as custom prompt commands.
+- Clarified that command loops wait for idle and should be used for slash commands such as `/compact`.
+- Kept fallback compatibility with older SDK-style calls where possible.
+
+## 0.5.5
+
+- Added explicit loop action types for prompt loops, scheduled question/check loops, OpenCode slash-command loops, and shell-command loops.
+- Added `/loop-command` and `/loop-cmd` for scheduled OpenCode commands such as `/compact`. These wait for the first interval by default and run only when OpenCode is idle.
+- Added `/loop-ask` for recurring check prompts such as “did you run tests, tsc --noEmit, and build?” It waits for the first interval by default.
+- Added `/loop-prompt` to force prompt mode.
+- Added `/loop-shell` for recurring shell commands.
+- Added `/loop` type flags: `--prompt`, `--ask`, `--command`, `--cmd`, `--slash`, `--shell`, and `--compact`.
+- Clarified README examples for scheduled `/compact`, hourly quality checks, and idle-safe timing.
+- Added `publishConfig.access=public` and normalized npm bin paths.
+
 ## 0.5.4
 
 - Fixed compatibility with recent OpenCode SDK/TUI call shapes.

package/README.md

@@ -11,7 +11,7 @@ NPM package name: **@bybrawe/opencode-loop**
 
 ## Current status
 
-**v0.5.4 fixes the recent OpenCode update compatibility issue.** OpenCode Loop has been updated for the current OpenCode SDK/TUI call shape and idle/status behavior. The TUI loop now waits for the session to become idle, debounces idle events, and avoids starting a new run while OpenCode is still busy or queued.
+**v0.5.6 fixes the recent OpenCode update compatibility issue and adds clear loop action types.** OpenCode Loop has been updated for the current OpenCode SDK/TUI call shape and idle/status behavior. The TUI loop waits for the session to become idle, debounces idle events, and avoids starting a new run while OpenCode is still busy or queued. It now separates prompt loops, scheduled question loops, OpenCode slash-command loops, shell loops, and compact loops so commands like `/compact` are not sent as normal chat text.
 
 The known update-related symptoms from older builds are fixed:
 
@@ -19,6 +19,7 @@ The known update-related symptoms from older builds are fixed:
 - a loop job is replaced but does not fire after OpenCode becomes idle
 - repeated `/loop` commands create confusing queued turns
 - prompt, shell, or toast calls silently fail after OpenCode SDK changes
+- `/compact` accidentally being treated as a normal agent prompt
 - intermittent `Tool execution aborted` behavior caused by triggering a new turn too early
 
 The TUI loop is still intentionally session-bound: it runs while OpenCode is open and the current session emits status/idle events. For long-running background work after closing the terminal or OpenCode, use `opencode-loopd`.
@@ -78,7 +79,7 @@ OpenCode Loop is designed for developers searching for:
 - **Failure control** with `--max-failures` and `--pause-on-verify-fail`.
 - **Runtime control** with `--max-runtime 6h`.
 - **Run limit support** with `--max-runs`.
-- **Sleep-before-first-run support** with `--sleep-first`.
+- **Wait-before-first-run support** with `--no-now` for TUI loops and `--sleep-first` for daemon mode.
 - **Checkpoints** with `--checkpoint-only` or `--git-checkpoint`.
 - **Safe mode** with `--safe` and prompt-level destructive command warnings.
 - **Branch setup** with `--branch ai-loop`.
@@ -263,34 +264,92 @@ If the commands do not appear:
 
 ## Quick start
 
+### The 5 examples most people need
+
+Auto-continue every time OpenCode finishes a turn:
+
 ```text
 /loop 0s continue from progress.md and implement the next unfinished TODO
 ```
 
-This is the closest behavior to a Claude Code CLI style loop: every time OpenCode becomes idle, the loop can send the next continuation prompt.
+Run now, then continue every 1 minute when OpenCode is idle:
+
+```text
+/loop 1m continue the project
+```
 
-A safer development loop:
+Wait 1 minute before the first run, then continue every 1 minute when idle:
 
 ```text
-/loop 0s --name dev --ask-never --safe --no-overlap --batch 5 --compact-every 200m --checkpoint-only --progress-file progress.md Treat progress.md as the main project state file. Continue with the next unfinished TODO, implement it, mark completed items with [x], add useful follow-up TODOs when you discover them, run tests/lint/build when available, and keep going while work remains.
+/loop 1m --no-now continue the project
 ```
 
-Periodic compact:
+Run OpenCode compact every 200 minutes, but only when OpenCode is idle:
 
 ```text
-/loop 200m --name compact --no-now /compact
+/loop-command 200m /compact
 ```
 
-Test-fix loop:
+Ask a recurring check question every hour:
 
 ```text
-/loop 0s --name testfix --ask-never --safe --verify "npm test" Continue from progress.md. If tests fail, analyze the failure, fix it, and run the tests again.
+/loop-ask 1h did you run tests, tsc --noEmit, and build? If not, run them and fix any error.
+```
+
+Run a real shell command every 10 minutes when idle:
+
+```text
+/loop-shell 10m npm test
+```
+
+### What “when idle” means
+
+OpenCode Loop is idle-safe. It does **not** intentionally start a new agent turn while OpenCode is already busy.
+
+Example:
+
+```text
+/loop 5m continue the project
+```
+
+If 5 minutes pass while OpenCode is still working, the job becomes due but waits. As soon as OpenCode becomes idle, the loop sends the prompt. This avoids queued turns, aborted tools, and overlapping responses.
+
+### Prompt loops vs command loops
+
+Use a prompt loop when you want to ask or instruct the agent:
+
+```text
+/loop 1h check if tests, tsc --noEmit, and build pass. If not, fix them.
+```
+
+Use a command loop when the action starts with `/` and should be executed as an OpenCode command:
+
+```text
+/loop-command 200m /compact
+```
+
+Do not use this for compacting:
+
+```text
+/loop 200m /compact
+```
+
+That can look like a chat prompt in older versions or unclear setups. Prefer `/loop-command 200m /compact` or the shortcut below:
+
+```text
+/loop-compact 200m
+```
+
+### Safer development loop
+
+```text
+/loop 0s --name dev --ask-never --safe --no-overlap --batch 5 --compact-every 200m --checkpoint-only --progress-file progress.md Treat progress.md as the main project state file. Continue with the next unfinished TODO, implement it, mark completed items with [x], add useful follow-up TODOs when you discover them, run tests/lint/build when available, and keep going while work remains.
 ```
 
-Shell command loop:
+### Test-fix loop
 
 ```text
-/loop 10m --name tests --safe !npm test
+/loop 0s --name testfix --ask-never --safe --verify "npm test" Continue from progress.md. If tests fail, analyze the failure, fix it, and run the tests again.
 ```
 
 ## Background daemon
@@ -388,7 +447,12 @@ Use `--name` to manage separate named loops, or `--multi` when you intentionally
 
 | Command | Purpose |
 |---|---|
-| `/loop <interval> <action>` | Add an idle/interval loop job |
+| `/loop <interval> <prompt>` | Add an idle/interval prompt loop |
+| `/loop-command <interval> <slash-command>` | Schedule an OpenCode slash command such as `/compact` |
+| `/loop-cmd <interval> <slash-command>` | Alias for `/loop-command` |
+| `/loop-ask <interval> <prompt/question>` | Schedule a recurring question/check prompt; first run waits for the interval by default |
+| `/loop-prompt <interval> <prompt>` | Force prompt mode, even when you want explicit prompt-loop naming |
+| `/loop-shell <interval> <shell-command>` | Schedule a shell command loop |
 | `/loop-help` | Show usage help inside OpenCode |
 | `/loop-status` | Show active loop jobs |
 | `/loop-logs` | Show recent loop log entries |
@@ -423,6 +487,27 @@ Use `--name` to manage separate named loops, or `--multi` when you intentionally
 
 The plugin is **idle-driven**. It checks jobs when OpenCode becomes idle, so it avoids intentionally starting a second agent turn on top of an active one.
 
+If the interval expires while OpenCode is busy, the loop becomes due and waits. It runs on the next idle event.
+
+## Loop types
+
+OpenCode Loop has separate types for prompts, OpenCode slash commands, and shell commands. This matters because `/compact` should be executed as an OpenCode command, not sent to the agent as text.
+
+| Type | Use | Example | First run |
+|---|---|---|---|
+| Prompt loop | Ask or instruct the agent repeatedly | `/loop 1h check whether tests, tsc --noEmit, and build pass` | Now by default |
+| Scheduled question | Ask/check on a timer | `/loop-ask 1h did you run tests and build?` | After the interval by default |
+| Slash-command loop | Run OpenCode commands like `/compact` | `/loop-command 200m /compact` | After the interval by default |
+| Shell loop | Run real terminal commands | `/loop-shell 10m npm test` | After the interval by default |
+
+You can still force the type on `/loop`:
+
+```text
+/loop 200m --command /compact
+/loop 10m --shell npm test
+/loop 1h --prompt did you run tests, tsc --noEmit, and build?
+```
+
 ## Actions
 
 ### Prompt action
@@ -459,18 +544,40 @@ Do not run destructive commands, force pushes, production deploys, or database r
 
 ### Slash command action
 
+Use `/loop-command` when the action should be executed as an OpenCode command instead of sent to the agent as text.
+
 ```text
-/loop 200m /compact
-/loop 15m /review current changes
+/loop-command 200m /compact
+/loop-command 15m /review current changes
+```
+
+`/compact` and `/summarize` are treated specially and routed to OpenCode's TUI compact action. Custom command templates such as `/review` are routed through OpenCode's session command API. If OpenCode is busy when the interval expires, the command waits and runs when the session becomes idle.
+
+Equivalent forced type on `/loop`:
+
+```text
+/loop 200m --command /compact
 ```
 
-`/compact` and `/summarize` map to OpenCode session summarization.
+For most users, the clearer form is preferred:
+
+```text
+/loop-command 200m /compact
+```
 
 ### Shell action
 
+Use `/loop-shell` for real terminal commands.
+
+```text
+/loop-shell 10m npm test
+/loop-shell 30m pnpm lint
+```
+
+Equivalent forced type on `/loop`:
+
 ```text
-/loop 10m !npm test
-/loop 30m $pnpm lint
+/loop 10m --shell npm test
 ```
 
 Shell actions starting with `!` or `$` run through the OpenCode shell tool.
@@ -692,10 +799,17 @@ Parse and preview a loop without saving it.
 
 ### `--now` and `--no-now`
 
-By default a new loop is due immediately. Use `--no-now` to wait for the first interval.
+By default `/loop` prompt jobs are due immediately. Use `--no-now` to wait for the first interval.
+
+```text
+/loop 1h --no-now did you run tests, tsc --noEmit, and build?
+```
+
+Command-style shortcuts such as `/loop-command`, `/loop-ask`, and `/loop-shell` wait for the first interval by default. Use `--now` if you want them to run immediately too.
 
 ```text
-/loop 200m --no-now /compact
+/loop-command 200m /compact
+/loop-command 200m --now /compact
 ```
 
 ## Recommended recipes
@@ -727,9 +841,19 @@ opencode-loopd --project . --every 5m --prompt-file loop-prompt.md
 ### Compact loop
 
 ```text
-/loop 200m --name compact --no-now /compact
+/loop-command 200m /compact
 ```
 
+This compacts every 200 minutes when OpenCode is idle. It does not interrupt an active agent turn.
+
+### Scheduled quality-check question
+
+```text
+/loop-ask 1h did you run tests, tsc --noEmit, and build? If not, run them now and fix errors.
+```
+
+This asks the agent every hour when idle. If the hour passes while the agent is working, the question waits and is sent after the current turn finishes.
+
 ### Prompt file loop
 
 ```text
@@ -833,6 +957,21 @@ Improve the application in small safe steps.
 
 ## Changelog highlights
 
+### v0.5.6
+
+- Added clearer README examples for prompt loops, scheduled question loops, command loops, shell loops, first-run timing, and idle-safe behavior.
+- Stabilized `/loop-command 200m /compact` by routing compact/summarize through OpenCode TUI compact handling instead of treating it as a custom prompt command.
+- Clarified that command loops wait for idle and should be used for slash commands such as `/compact`.
+
+## v0.5.5
+
+- Added explicit loop action types: prompt, scheduled question, OpenCode slash command, and shell command.
+- Added `/loop-command` / `/loop-cmd` for commands such as `/compact`; these wait for the first interval by default.
+- Added `/loop-ask` for recurring checks such as “did you run tests, tsc --noEmit, and build?”; it waits for the first interval by default.
+- Added `/loop-shell` for recurring shell commands.
+- Added `--prompt`, `--ask`, `--command`, `--cmd`, `--slash`, `--shell`, and `--compact` type flags for `/loop`.
+- Clarified idle behavior: if a job becomes due while OpenCode is busy, it waits and runs on the next idle event.
+
 ### v0.5.4
 
 - Fixed compatibility with recent OpenCode SDK/TUI call shapes.

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.4",
+  "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",
@@ -55,7 +55,10 @@
     "@opencode-ai/plugin": ">=1.4.0"
   },
   "bin": {
-    "opencode-loop": "scripts/install-node.mjs",
-    "opencode-loopd": "scripts/loopd.mjs"
+    "opencode-loop": "./scripts/install-node.mjs",
+    "opencode-loopd": "./scripts/loopd.mjs"
+  },
+  "publishConfig": {
+    "access": "public"
   }
 }

package/src/index.js

@@ -149,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
     }
   }
@@ -160,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,
@@ -218,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)
@@ -327,6 +335,38 @@ function fireSdk(client, label, 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 sdkCall(
@@ -362,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." }
@@ -377,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)}` : ""
@@ -387,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) {
@@ -448,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"
@@ -502,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 sdkCall(client.session.summarize.bind(client.session), { sessionID }, { path: { id: sessionID }, body: {} })
+  if (await compactSession(client, sessionID)) {
     job.lastCompactAt = now()
     job.lastCompactRunCount = job.runCount || 0
-  } catch {}
+  }
   return job
 }
 
@@ -708,18 +757,28 @@ 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 sdkCall(client.session.summarize.bind(client.session), { sessionID }, { 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))
-    fireSdk(client, "session.command", client.session.command.bind(client.session), { sessionID, command, arguments: argumentsText }, { path: { id: sessionID }, body: { command, arguments: argumentsText } })
+    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 })
@@ -835,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)
 }
 
@@ -911,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",