# Changelog

## 0.5.37

Dedicated Goal tool-isolation release.

- Detect a persisted dedicated @bybrawe/opencode-goal Goal before any experimental `opencode_loop_goal_*` lifecycle tool can mutate Loop Goal state.
- Fail closed when a dedicated Goal owns the session and explicitly direct the model to `opencode_goal_progress`, `opencode_goal_wait_for_user`, `opencode_goal_blocked`, or `opencode_goal_complete` instead of returning a misleading experimental-Goal result.
- Mark the Loop lifecycle tools as experimental `/loop-goal`-only in their model-visible descriptions, preventing the exact blocker-tool collision reproduced by the long Loto Diyarı session.
- Keep modular source and the committed single-file stable bundle byte-for-byte synchronized with the Bun build output.
- Add coexistence smoke coverage for blocked, progress, and completion collisions; exact feature-head CI, Dedicated Goal Coexistence, and Single-file Bundle Gate pass across the required host/platform lanes.

## 0.5.36

Empty-turn fail-safe release.

- Distinguish a completed assistant message from a meaningful completed Loop turn instead of treating a timestamp-only blank reply as success.
- Count non-empty assistant text and tool/file/patch/artifact activity anywhere in the logical run as meaningful work, including tool-only runs with a blank final assistant tail.
- Refund a completed-but-empty logical run so it does not consume `runCount`, `--max-runs`, or normal success finalization/checkpoint behavior.
- Persist consecutive empty-turn state across reloads, retry one empty completion with bounded delay, then pause safely after the second consecutive empty turn with a visible warning instead of injecting prompts forever.
- Recover stale host `busy` state for already-completed empty turns so the fail-safe can finalize them rather than leaving the Loop stuck between busy and due states.
- Keep release metadata automation compatible with the README's `Current stable release` marker so future release prep does not fail on the documented format.
- Add focused regressions for blank/whitespace replies, tool activity, max-run refund/re-enable, bounded retry, fail-safe pause, successful streak reset, and generated-bundle parity; full Ubuntu/Windows CI, real-host, Goal coexistence, lifecycle, and single-file bundle gates are green on the feature head.

## 0.5.35

- Treat OpenCode `session.status=retry` as authoritative provider ownership: retry and unreadable status can no longer age into idle and cause an overlapping Loop turn; a genuinely completed current assistant message can still release stale retry safely.
- Recover transient Loop-owned network/provider failures with bounded exponential backoff (5s to 60s), refund failed infrastructure attempts from `runCount`/`lastRunAt`, re-enable jobs that only hit `--max-runs` because of the failed attempt, and keep infrastructure failures separate from ordinary `failureCount`.
- Add a two-minute watchdog for an explicitly stuck OpenCode retry, scoped only to a Loop-owned active turn: abort that owned retry, refund the logical run, and reschedule with backoff without touching unrelated foreground/user work. Successful normal turns reset the consecutive network-backoff counter.
- Preserve plain `/loop devam et` as intentionally unlimited, while explicit completion-bounded idle loops such as `bitene kadar`, `projeyi bitir`, and `until done` now auto-pause only after two consecutive current assistant replies both report verified completion and no remaining work. Replies naming next/remaining work reset the terminal signal.
- Make Turkish terminal/no-work detection Unicode-safe, expand outage/terminal regressions, keep the generated single-file stable bundle synchronized with modular source, and document retry, backoff, watchdog, and completion-bounded scheduling behavior in `docs/SCHEDULING.md`.

## 0.5.34

- Make plain `/loop <prompt>` the ergonomic unlimited idle-continuation form: when the assistant stops and the session is safely idle, Loop sends the prompt again. Add explicit `idle`, recurring `every <duration>`, and one-shot `after/in <duration>` schedule grammar while preserving legacy duration-first commands.
- Treat short continuation prompts such as `continue`, `keep going`, and `devam et` as continuation of the current repository/conversation, with guidance to inspect relevant files, TODO/progress state, recent changes, and git status before choosing the next unfinished step.
- Fix the pre-first-run stale OpenCode `busy/retry` failure mode that could leave an enabled immediate Loop at `runCount=0`: recover only when the latest assistant tail is actually completed and no active tool or busy child session exists.
- Add throttled busy-deferral logging, schedule/state detail in `/loop-status`, and cross-session persisted-job diagnostics in `/loop-doctor` so due work explains why it is waiting instead of leaving only an `add` log record.
- Prevent prompt-producing Loop jobs from competing with an active dedicated `/goal` continuation owner in the same session by default; advanced users can opt in explicitly with `--allow-goal-overlap`.
- Centralize due/admission semantics in a shared schedule-policy runtime and split schedule syntax, continuation guidance, scheduler diagnostics, companion-Goal detection, and Loop diagnostics into focused modules. Keep the committed single-file stable bundle synchronized and add a permanent Bundle Gate check that fails when `src/index.js` is stale.
- Rewrite the scheduling documentation, add `docs/SCHEDULING.md`, and extend real OpenCode host coverage so Ubuntu and Windows prove a durationless `/loop --max-runs 3 devam et` performs exactly three autonomous turns and stops at the configured limit.

## 0.5.33

- Complete the post-0.5.32 stable V1 source decomposition by extracting action dispatch, run admission, and post-turn finalization from the executor into focused runtime modules while preserving scheduler behavior and dependency-injection compatibility.
- Split experimental Loop Goal prompt rendering, report writing, and evidence/progress decision helpers into dedicated modules while preserving the existing source facade and runtime state schema.
- Regenerate the committed single-file stable plugin from the modular source tree and keep Linux/Windows real-host, compatibility, generated-bundle, and lifecycle gates green throughout the refactor.
- Add direct regression coverage for the extracted admission/finalization paths; this release is intended to be behavior-preserving with no user-visible command changes.

## 0.5.32

- Hide the tool-denied `opencode-loop-local` acknowledgement agent from the normal primary-agent cycle by installing it as a hidden subagent while keeping Loop slash commands explicitly bound to it.
- Add `--without-loop-goals` so Loop installs/updates can omit the packaged experimental `/loop-goal*` command files without removing normal Loop commands, Loop runtime state, or the separate OpenCode Goals plugin.
- Keep backward compatibility by installing the older Loop Goal command surface by default; the new opt-out composes with `--with-goals` for a cleaner `/loop` + dedicated `/goal` setup.
- Add deterministic installer coverage for hidden-agent metadata, default legacy-command compatibility, clean command-surface opt-out, and combined Loop + Goals installation.

## 0.5.31

- Add best-effort experimental OpenCode 2 runtime logging in the existing JSON-lines `loop.log` format, tagged with `v2: true`, plus experimental `/loop-logs` diagnostics for recent V2 records. Logging remains non-critical and does not change the stable OpenCode 1.x support claim.
- Keep an already-installed `@bybrawe/opencode-goal` companion current when Loop is installed/updated by delegating to Goals' own `@latest` installer. Add `--with-goals` for an explicit combined install and `--loop-only` to suppress companion network work; Loop uninstall never removes Goals.
- Add deterministic cross-platform companion-installer coverage for package/local/managed-command detection, JSONC comment false positives, opt-out, explicit failure semantics, help output, and best-effort automatic refresh behavior.
- Keep release metadata internally consistent by synchronizing the package-lock root `bin` map with `package.json` while preparing releases.

## 0.5.30

- Harden npm publishing so a one-shot release publishes the immutable trigger SHA, verifies that commit belongs to `main`, serializes releases, confirms the package is readable from npm, and tags exactly the published snapshot.
- Extend the experimental OpenCode 2 command registry with read-only `/loop-export`, `/loop-help`, and `/loop-doctor` diagnostics.
- Keep OpenCode 2 diagnostics conservative: help advertises only implemented V2 behavior, doctor reports local runtime/state information, and full stable-plugin parity remains explicitly unclaimed.
- Expand V2 lifecycle, real `@next` command-registry, general CI, and generated-bundle gates around the new diagnostics and release-safety contracts.

## 0.5.29

- Fix `--no-now` first-run semantics end to end: delayed jobs now wait until `createdAt + interval`, and stable `/loop-status` reports that first due time correctly instead of showing the job as immediately due.
- Add experimental OpenCode 2 parity for native `/loop-status` and target-specific `/loop-now`, including real host command registration, idle-safe run-now persistence, target priority, `noReply` status output, and deterministic lifecycle coverage.
- Make stable `/loop-now <target>` truly target-specific across busy retries and avoid unrelated due jobs; persist a one-shot run-now marker, prioritize the requested job, and consume it only when dispatch begins.
- Defer stable `/loop-now` execution to the idle-safe scheduler instead of dispatching re-entrantly from `command.execute.before`, fixing a Windows real-host race where the command acknowledgement turn could supersede the requested autonomous prompt.
- Strengthen release confidence with Ubuntu/Windows real-host target canaries, generated-bundle synchronization, Bundle Gate coverage for host-canary changes, and bounded scheduler-state waits in comprehensive Windows regressions.

## 0.5.28

- Preserve experimental `/loop-goal` across ordinary queued user steering: preempt only the in-flight Goal turn, run the foreground user turn first, keep the Goal active/unpaused, then resume autonomous Goal work. Gate heartbeat, due, and watchdog dispatch while steering is pending, reject stale Goal lifecycle mutations, and cover the behavior with real OpenCode host canaries on Ubuntu and Windows for both source and freshly rebuilt bundles.
- Complete the planned V1 modularization by extracting command routing/handlers, Loop registration, session activity/status, scheduling, Goal runtime/policy/steering, job workspace, compaction, and executor responsibilities into focused testable modules while keeping `legacy-v1.js` as the composition root.
- Expand the experimental OpenCode 2 runtime with idle-safe interval prompt loops, Loop control commands, ordinary slash-command transport, lifecycle cleanup, and real-host adapter/activation contracts. Correct V2 command transport to use the host `command` field rather than the optional message `id` field. Stable package compatibility remains `@opencode-ai/plugin >=1.4.0 <2`; this release does not claim stable OpenCode 2 parity.
- Harden the Goal steering host canary cold bootstrap from 45 seconds to a bounded 90 seconds and include the OpenCode server log when bootstrap still fails, without weakening the steering assertions.

## 0.5.27

- Rebase stale Loop state snapshots against the latest persisted job state before writing, preventing scheduler bookkeeping from erasing unrelated user pause/resume or other state changes.
- Add a deterministic concurrency regression that forces overlapping state reads/writes and proves a concurrent user pause survives a stale scheduler update.
- Harden `opencode-loopd` by pinning one exact OpenCode session across iterations instead of resolving `--continue` on every run; a fresh daemon session is created and then pinned when no existing session is available.
- Add per-run daemon timeouts (30 minutes by default, configurable with `--timeout`; `0s` disables) and timeout exit code 124, including descendant-process termination.
- Add daemon regressions for session pinning, timeout termination, and scheduled-task timeout propagation.
- Add a real OpenCode host canary that proves a three-run `/loop` performs exactly three autonomous turns on Ubuntu and Windows.
- Narrow the OpenCode plugin peer range to `>=1.4.0 <2` so a future breaking 2.x release is not treated as automatically compatible.

## 0.5.26

- Added an explicit npm-based OpenCode installation path: `npm install -g @bybrawe/opencode-loop@latest` followed by `opencode-loop`.
- Clarified that project-local `npm install @bybrawe/opencode-loop` alone does not perform the OpenCode installer step.
- Documented update and uninstall flows for both `npx` and global npm installation methods.
- Added matching npm installation instructions for the recommended dedicated `@bybrawe/opencode-goal` plugin.

## 0.5.25

- Added safe `--uninstall` support to the Loop installer while preserving unrelated OpenCode configuration and project Loop state.
- Reworked README installation/removal guidance and moved install/update instructions to the top.
- Documented coexistence with OpenCode Goals and recommends the dedicated Goals plugin for stronger persistent Goal contracts and host-verified completion.
- Warned against driving the same session/work simultaneously with Loop's experimental `/loop-goal` and the dedicated `/goal` continuation system.

## 0.5.24

- Cross-check stale OpenCode `busy`/`retry` status against the chronological session tail and only recover early when the latest assistant message has a real `time.completed`; an explicitly unfinished assistant tail is never force-finalized.
- Track scheduled compaction through OpenCode's native `experimental.session.compacting` hook and `session.compacted` event, while retaining idle/status fallbacks for older hosts.
- Serialize `--compact-every` as its own compaction phase so the next loop prompt/shell action cannot overlap an in-progress compaction; older hosts that only report idle also finalize this phase without running normal verify/postrun hooks.
- Fix headless/server compact fallback for current OpenCode by supplying the required `providerID`, `modelID`, and `auto: false` payload to `session.summarize`.
- Add deterministic regressions for completed-vs-running assistant tails, native compaction completion, compact/action serialization, and current summarize payloads.

## 0.5.23

- Track non-blocking `session.prompt` and `session.shell` dispatch promises instead of treating every fire-and-forget request as successfully started.
- Recover a rejected scheduler dispatch immediately: clear only the matching active run token, invalidate cached busy status, persist the failure, honor `--max-failures`, and reschedule through the normal scheduler path.
- Never replay a rejected prompt automatically; this avoids duplicate turns when OpenCode status/events are delayed or multiple instances are involved.
- Added a deterministic regression test for delayed prompt rejection and verified the error remains observable in plugin logs.

## 0.5.22

- Hardened compatibility with current OpenCode 1.18.15 while preserving the existing `>=1.4.0` peer range.
- Handled loop commands now also set `output.noReply = true`; OpenCode 1.18.x safely ignores the unknown field, while hosts that add the proposed `noReply` hook support can skip the acknowledgement model turn automatically.
- Added Bun runtime loading coverage so CI exercises the runtime OpenCode actually uses to load plugins, not only Node syntax/tests.
- Added explicit minimum-peer coverage against `@opencode-ai/plugin@1.4.0` and scheduled testing against the latest published OpenCode plugin package.
- Kept the v0.5.21 server-plugin acknowledgement fallback for current OpenCode versions where `command.execute.before` cannot cancel the prompt turn.

## 0.5.21

- Verified server-plugin compatibility against OpenCode 1.18.15 and updated the development plugin dependency accordingly.
- Stopped clearing `command.execute.before` output parts. Current OpenCode still creates a command prompt turn for server-plugin slash commands, so control commands keep the valid tool-denied `opencode-loop-local` acknowledgement instead of producing an empty message.
- Prefer the current `session.compact` TUI command value while retaining `session_compact` and `session.summarize` as compatibility fallbacks.
- Fixed the comprehensive preflight failure test to use a cross-platform shell-safe Node expression.
- Added Ubuntu and Windows pull-request CI, and hardened npm publishing with full tests, tag/version verification, and `npm pack --dry-run`.
- Retained the v0.5.20 Windows state-write retry hardening and deterministic EPERM/partial-read regressions.

## 0.5.20

- Fixed Windows TUI loop state writes failing with `EPERM` / `EEXIST` when renaming a project-local `*.tmp` over an existing session state file. Heartbeat and due-timer updates no longer drop jobs when antivirus, IDE indexers, or OpenCode snapshots briefly lock the destination.
- Write atomic state payloads under the OS temp directory first, then replace the target with rename plus a copy/unlink fallback and short retries, so project trees no longer accumulate `opencode-loop/*.tmp` files that OpenCode tried to git-snapshot.

## 0.5.19

- Made the asynchronous goal prompt smoke test wait for the observable SDK call instead of assuming a single event-loop tick is always sufficient under load.

## 0.5.18

- Fixed package-based installs loading stale OpenCode cache entries after npm had installed a newer release. The installer now pins an existing package config entry to its exact installed version while preserving JSONC comments.
- Fixed Goal Mode mistaking delayed updates for its own scheduler-created user message as a real user interruption. Loop-owned message IDs remain recognized without hiding a distinct user message.
- Added a dedicated `opencode-loopd` regression suite for literal argument passing, BOM prompt files, model/agent forwarding, finite-run exit codes, invalid options, and Windows scheduled-task lifecycle behavior.
- Made finite daemon runs propagate OpenCode failures instead of reporting exit code 0, and reject invalid `--max-runs` values and missing project directories.
- Added `--model` and `--agent` forwarding to daemon and scheduled-task runs.
- Fixed Windows Task Scheduler installation failing when `/TR` exceeded its 261-character limit. Scheduled tasks now use a short launcher plus a task-specific JSON config under the local app-data directory, and uninstall removes both artifacts.
- Made Task Scheduler command launch failures return a nonzero exit code instead of silently succeeding.
- Added non-mutating `--help` and `--version` handling to the `opencode-loop` installer CLI.

## 0.5.17

- Prevented OpenCode project bootstrap deadlocks by deferring local SDK logging and session discovery until after plugin hooks are returned.
- Added a tool-denied `opencode-loop-local` command agent for all 30 slash commands, preventing local status/control commands from spawning tools or background subagents; scheduled work restores the normal agent/model context.
- Made the installer detect package-based plugin configuration in JSON or JSONC and remove duplicate local plugin copies instead of loading two schedulers.
- Fixed watched jobs so file changes actually trigger them, while unchanged paths remain dormant.
- Fixed preset parsing for explicit `0s`, flag-only presets, and custom `/loop-testfix` commands.
- Fixed command-event deduplication so compatibility events are suppressed without swallowing intentional repeated commands.
- Hardened safe shell detection for PowerShell and `rm` variants, removed the `npm run format` false positive, and paused invalid synchronous actions instead of retrying them indefinitely.
- Added comprehensive parser, preset, lifecycle, watch, safety, routing, goal, installer, JSONC, and initialization regression coverage.

## 0.5.16

- Treat active OpenCode tools, shell calls, and foreground or background subtasks as busy even if the parent session receives an idle/status event while they are still running.
- Prevent stale active-run recovery from finalizing a loop turn while any tracked tool call remains active.
- Added regression coverage proving that a due loop waits for long-running tools and background child sessions, then resumes only after that work finishes and the parent session becomes idle.

## 0.5.15

- Hardened experimental Goal Mode completion: agent tool completion now requires concrete evidence instead of accepting empty or generic claims.
- Required configured goal `--check` commands to pass before agent-tool completion, unless the user explicitly opts out or manually marks the goal done.
- Added a no-progress guard for goals. Goals pause after 3 turns without recorded meaningful progress by default, configurable with `--max-no-progress`.
- Paused active goals when a real user message arrives, so new user intent wins before the next automatic continuation.
- Preferred the OpenCode plugin SDK's `{ body }`, `{ path: { id }, body }`, and `{ query }` argument shapes while keeping flat and older path-key fallbacks.
- Added the resolved working directory and workspace-relative path rules to Goal Mode prompts so agents do not accidentally target filesystem-root paths.
- Increased Goal Mode's default active-turn recovery window to 3 minutes so slow model/tool turns are not finalized as stale after 20 seconds.
- Added plugin disposal cleanup for heartbeat, idle, due, watchdog, and active-run timers.
- Added an automated smoke test for SDK call order, Goal Mode prompts, evidence rejection, and successful completion state.
- Updated local installers to create or update config `package.json` with `@opencode-ai/plugin`, needed by local `.ts` plugins that import `tool()`.
- Updated Goal Mode status/report output and README guidance for the new guards.

## 0.5.14

- Guarded active-run finalization so heartbeat and retry checks do not treat a still-running assistant turn as finished.
- Made loop state writes atomic and backed up corrupt state files before falling back to an empty state.
- Changed `opencode-loopd` to pass prompts as process arguments instead of shell strings, preserving quotes in inline prompts.
- Stripped UTF-8 BOMs from daemon prompt files before sending them to OpenCode.
- Removed the package plugin entry from the example config to avoid duplicate loading after the recommended local installer path.

## 0.5.13

- Wrapped experimental goal tools with `tool()` and Zod schemas for current OpenCode tool validation.
- Added `@opencode-ai/plugin` as a dev dependency so fresh clones can resolve the tool helper during local development.

## 0.5.12

- Fixed local plugin installs to write `opencode-loop.ts`, matching OpenCode local plugin discovery.
- Removed stale `opencode-loop.js` local plugin copies during install to avoid duplicate or outdated local plugin loads.
- Made the PowerShell source installer honor `OPENCODE_CONFIG_DIR`, matching the npm and shell installers.
- Fixed `opencode-loopd` to pass the prompt to `opencode run` as the positional message instead of the non-existent `--prompt` flag.
- Added a short retry backoff for failing `opencode-loopd --every 0s` runs.
- Normalized command arguments from array/object forms so `opencode run --command loop ...` can schedule jobs like TUI slash commands.
- Stripped whole-argument quote wrappers before parsing loop durations, fixing quoted `opencode run --command loop "1h ..."` invocations.
- Fixed a goal finalization reassignment so the generated local TypeScript plugin parses under Bun.
- Fixed the Windows Task Scheduler helper script path used by `opencode-loopd install-task`.
- Tried current OpenCode SDK `{ path, body }` and `{ query }` argument shapes before older fallback shapes.

## 0.5.11

- Added a watchdog loop in addition to one-shot due timers, so recurring jobs keep checking due work even if OpenCode misses an idle event or a due timeout gets effectively stuck behind a stale busy state.
- Added stronger stale-active-run recovery. If a plugin-injected run is still marked active after the recovery window, the scheduler treats it as finished, finalizes it, and continues without waiting for another manual command such as `/loop-status`.
- Refreshed session status with workspace-aware calls before trusting cached busy/retry state.
- Kept `/compact` routing from v0.5.9: `session_compact` first, then `session.compact`, then summarize fallback.
- This targets the observed case where `/loop 1m ...` only continued after manually running `/loop-status`.

## 0.5.9

- Fixed stale-busy recovery for TUI sessions. Cached `busy` / `retry` status is now short-lived, so due jobs no longer get stuck at `due in every idle` after `/loop-status` or other short custom-command turns.
- Improved due-timer behavior when OpenCode misses or delays the final idle event after a command turn.
- Fixed `/compact` routing for current OpenCode TUI builds by trying `session_compact` first, then `session.compact`, then the session summarize fallback.
- Kept the command markdown templates short; OpenCode still creates a tiny `OK` turn for custom commands because markdown commands are prompt templates.

## 0.5.8

- Added a real due timer for TUI loop jobs, so delayed jobs can wake without waiting for another OpenCode event.
- Fixed `/loop 1m --no-now ...` style jobs so the first delayed run can fire on time when OpenCode is idle.
- Fixed scheduled action types such as `/loop-ask`, `/loop-command`, and `/loop-shell` so 0s and delayed jobs are scheduled even when their default mode is `--no-now`.
- Added busy retry behavior: if a due timer expires while OpenCode is busy, the job waits and retries instead of interrupting the active turn.
- Reschedules due timers after add, stop, pause, resume, run completion, goal pause/resume/clear, and post-run verification.
- Shortened command markdown templates so unavoidable custom command turns reply `OK` instead of producing misleading status text.
- Kept Experimental Goal Mode marked experimental.

## 0.5.7

- Added experimental Goal Mode with `/loop-goal <objective>`.
- Added goal lifecycle commands: `/loop-goal-status`, `/loop-goal-pause`, `/loop-goal-resume`, `/loop-goal-clear`, `/loop-goal-done`, and `/loop-goal-blocked`.
- Added local goal tools exposed to the agent: `opencode_loop_goal_complete`, `opencode_loop_goal_blocked`, and `opencode_loop_goal_progress`.
- Added goal acceptance criteria with repeated `--acceptance` / `--success` flags.
- Added post-turn goal check commands with repeated `--check` flags.
- Added `--complete-when-checks-pass` for goals that should automatically stop once all configured checks pass.
- Added `--max-turns` alias for goal run limits.
- Added goal reports under `.opencode/opencode-loop/goals/` and optional `--evidence-file`.
- Updated README with simple examples explaining prompt loops, command loops, shell loops, scheduled checks, and experimental persistent goals.

## 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.
- Updated session prompt, shell, and toast calls for current OpenCode while keeping backwards-compatible fallbacks.
- Added `session.status` idle gating and debounce so loop runs wait for OpenCode to become idle and do not stack on busy/queued turns.
- Improved runtime logging for prompt/shell/toast failures.
- Fixed the known update-related symptoms where `/loop` could appear queued, stay at `runs=0`, or only work intermittently after OpenCode updates.

## 0.5.0

- Added `opencode-loopd` background daemon for long-running loops outside the OpenCode TUI.
- Added `opencode-loopd install-task` and `opencode-loopd uninstall-task` helpers for Windows Task Scheduler.
- Updated README to clearly explain the difference between session-bound TUI loops and background daemon loops.
- Added npm bin entry for `opencode-loopd`.
- Updated package check script to validate the daemon script.

## 0.4.4

- Made the npm install path the primary README installation method now that the package is published as `@bybrawe/opencode-loop`.
- Clarified that `npx -y @bybrawe/opencode-loop` installs both the plugin file and `/loop-*` command markdown files.
- Moved the OpenCode `plugin` array config to an optional/advanced section because config-only loading may not install slash command markdown files.
- Removed maintainer/publish-oriented instructions from the user-facing install flow.


## 0.4.3

- Fixed duplicate loop creation by making /loop replace/upsert the default loop instead of appending duplicate jobs.
- Added --multi for users who intentionally want multiple independent loops in one session.
- Added --replace as an explicit alias for the default upsert behavior.
- Made command markdown files no-op/silent so the model is less likely to explain the command or create scheduler files.
- Hardened the continuation prompt to avoid scheduling, documentation search, and command explanation loops.
- Clarified that the plugin is session/TUI-bound and does not keep running after OpenCode, the terminal, or the machine disconnects.

## 0.4.2

- Changed npm package name to scoped package `@bybrawe/opencode-loop`.
- Fixed README npm/OpenCode config examples to use `"plugin": ["@bybrawe/opencode-loop"]`.
- Added an npm `bin` installer so `npx -y @bybrawe/opencode-loop` can copy plugin and command files into the OpenCode config directory.
- Clarified that `opencode-loop` and `@bybrawe/opencode-loop` are different npm package names.

## 0.4.1

- Fixed installation docs for GitHub/local installs.
- Clarified that `plugin`: [`opencode-loop`] only works after npm publishing.
- Added manual global install and project-local install instructions.
- Added verification and troubleshooting steps for `/loop-help` and `/loop-doctor`.

## 0.4.0

- Public repository metadata updated for `ByBrawe/opencode-loop`.
- Package renamed to `opencode-loop`.
- README rewritten in English for public GitHub discovery and SEO.
- Added `--prompt-file` for long reusable prompts.
- Added `--include-file` for extra context files.
- Added `--max-runtime` for total runtime limits.
- Added `--max-failures` and `--pause-on-verify-fail` for failure control.
- Added `--postrun` and `--notify` hooks.
- Added `--dry-run` preview mode.
- Added `/loop-doctor`, `/loop-init`, and `/loop-export` commands.
- Improved max-runs finalization so the final run can still verify/checkpoint.
- Improved state cleanup for non-assistant actions such as `/compact`.
- Kept all examples project-neutral and English.

## 0.3.1

- Converted public examples to English.
- Removed private/project-specific language from README.
- Added public `progress.md` workflow examples.

## 0.3.0

- Added SEO-oriented README for OpenCode loop / Claude Code style loop use cases.
- Added `/loop-help` and `/loop-logs`.
- Added `--verify`, `--preflight`, `--stop-file`, and `--progress-file`.

## 0.2.0

- Added max runs, timeout, until, compact scheduling, tests, checkpoints, branch setup, safe mode, batch mode, quiet mode, ask-never mode, watch mode, and preset commands.

## 0.1.0

- Initial local OpenCode loop plugin.