chore: release v0.5.0

Author: chriswritescode-dev

.gitignore

@@ -4,3 +4,5 @@ node_modules/
 .pnpm-store/
 .DS_Store
 graph/
+.forge-tmp/
+.tmp/

AGENTS.md

@@ -20,10 +20,16 @@ The following skills are bundled with the plugin and auto-installed to `~/.confi
 
 Source files are in `skills/` directory.
 
+## Bundled Prompts
+
+Agent and command prompts are bundled in `src/prompts/` and auto-installed to `~/.config/opencode/forge/prompts/` on first run. User edits take precedence and are preserved; unedited bundled files are refreshed when the bundled content changes (tracked via a content-hash manifest under `~/.config/opencode/forge/manifests/`). Section-summary markers in `agents/auditor-loop-addendum.md` must match `SECTION_SUMMARY_START_MARKER`/`SECTION_SUMMARY_END_MARKER` in `src/utils/section-summary.ts`.
+
 ## Project Conventions
 
 - All commits must be meaningful and follow conventional commit standards
 - No emojis in commit messages
 - Always check for existing patterns before adding new code
 - Functions should be single responsibility and reusable
 - Remove dead code to keep the codebase clean
+- `src/dashboard/app/` is the source of truth for the dashboard UI; `src/dashboard/app-bundle.ts` is an auto-generated artifact regenerated by `pnpm build` (do not hand-edit). A source-hash drift test (`test/dashboard/app-bundle.test.ts`) guards against committing stale bundles.
+- The dashboard app uses `solid-js/html` (buildless). Gotchas, enforced by `test/dashboard/app-dom.test.ts` (happy-dom): never use `<${Show}>`/`<${For}>` component syntax (it mis-parses closing tags — use ternary thunks + `createMemo` + `.map()`); every `html` template needs a real root element (a body that is only `${...}` emits invalid code); reactive regions must be `${() => ...}` inside an element, and the root component returns a single wrapper element. DOM tests run in the `dom` project of `vitest.workspace.ts` (happy-dom + browser resolve conditions); the rest run in the `node` project.

README.md

@@ -0,0 +1,2 @@
+*
+!dind-entrypoint.sh

bunfig.toml

@@ -0,0 +1,102 @@
+FROM debian:bookworm-slim
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    ca-certificates \
+    curl \
+    git \
+    jq \
+    python3 \
+    ripgrep \
+    unzip \
+    && rm -rf /var/lib/apt/lists/*
+
+RUN curl -fsSL https://deb.nodesource.com/setup_24.x | bash - \
+    && apt-get install -y --no-install-recommends nodejs \
+    && rm -rf /var/lib/apt/lists/*
+
+# pnpm via corepack, pinned and pre-activated into a world-readable/writable
+# cache so the container can run as an arbitrary host UID without downloading
+# pnpm at runtime.
+ENV COREPACK_HOME=/opt/corepack \
+    COREPACK_ENABLE_DOWNLOAD_PROMPT=0
+RUN corepack enable \
+    && corepack prepare pnpm@10.28.1 --activate \
+    && chmod -R 0777 /opt/corepack
+
+# bun installed to a world-accessible location. The default installer targets
+# /root/.bun, which is unreadable (mode 0700) when the container runs as a
+# non-root host UID.
+ENV BUN_INSTALL=/opt/bun
+RUN curl -fsSL https://bun.sh/install | bash \
+    && ln -sf /opt/bun/bin/bun /usr/local/bin/bun \
+    && ln -sf /opt/bun/bin/bun /usr/local/bin/bunx \
+    && chmod -R a+rX /opt/bun
+
+# uv installed to a world-accessible location for the same reason as bun.
+ENV UV_INSTALL_DIR=/usr/local/bin
+RUN curl -fsSL https://astral.sh/uv/install.sh | bash \
+    && chmod a+rx /usr/local/bin/uv /usr/local/bin/uvx
+
+# The container runs as root (required by the nested Docker daemon), but HOME and every
+# tool cache/store are pinned to fixed, world-writable paths so the layout is stable
+# regardless of the executing UID.
+#
+# npm_config_store_dir pins pnpm's content-addressable store to a container-internal
+# path. Without it, pnpm places the store on the project filesystem (the bind-mounted
+# /workspace), which floods the host file watcher and is slow over the macOS bind mount.
+ENV HOME=/home/forge \
+    XDG_CACHE_HOME=/home/forge/.cache \
+    XDG_DATA_HOME=/home/forge/.local/share \
+    PNPM_HOME=/home/forge/.local/share/pnpm \
+    npm_config_cache=/home/forge/.npm \
+    npm_config_store_dir=/home/forge/.local/share/pnpm/store
+RUN useradd -m -u 1000 forge \
+    && mkdir -p /home/forge/.cache /home/forge/.local/share/pnpm/store /home/forge/.npm \
+    && chmod -R 0777 /home/forge
+
+# fallow CLI — dead-code analysis tool — installed globally with the same pnpm
+# setup used by the rest of the sandbox image. Binaries are linked into
+# /usr/local/bin so they are on PATH for arbitrary container UIDs.
+#
+# The trailing chmod is load-bearing: this global install runs as root and populates the
+# pnpm store (store/v10/{files,index,projects}) with root-owned 0755 dirs, AFTER the earlier
+# `chmod -R 0777 /home/forge`. Because the container runs as root but agent commands run as the
+# host UID via `docker exec --user`, that UID could not write into the root-owned store and
+# `pnpm install` failed with EACCES when registering the project — which previously drove the
+# agent to relocate the store onto the bind-mounted /workspace (huge, slow file transfers).
+# Re-asserting 0777 here, as the last build step that touches /home/forge, keeps the store
+# writable by any exec UID. Any future build step that runs pnpm as root must do the same.
+RUN corepack pnpm add -g fallow@2.101.0 --global-bin-dir /usr/local/bin \
+    && chmod -R 0777 /home/forge
+
+# Docker Engine (daemon + CLI + buildx + compose) from Docker's official apt
+# repository. This enables Docker-in-Docker: when the container is launched with
+# FORGE_DIND=1 (privileged), the entrypoint starts a nested, isolated dockerd so
+# loops can build and run containers for end-to-end tests. iptables is required
+# by dockerd for container networking; debian bookworm uses the nft backend.
+RUN install -m0755 -d /etc/apt/keyrings \
+    && curl -fsSL https://download.docker.com/linux/debian/gpg -o /etc/apt/keyrings/docker.asc \
+    && chmod a+r /etc/apt/keyrings/docker.asc \
+    && echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/debian bookworm stable" > /etc/apt/sources.list.d/docker.list \
+    && apt-get update \
+    && apt-get install -y --no-install-recommends \
+        docker-ce \
+        docker-ce-cli \
+        containerd.io \
+        docker-buildx-plugin \
+        docker-compose-plugin \
+        iptables \
+    && rm -rf /var/lib/apt/lists/*
+
+# Allow git to operate on the bind-mounted workspace regardless of owner UID.
+RUN git config --system --add safe.directory '*'
+
+# Entrypoint conditionally boots the nested Docker daemon before handing off to
+# the container command. When FORGE_DIND is unset/0 it is a transparent passthrough,
+# so non-DinD loops pay no runtime cost.
+COPY dind-entrypoint.sh /usr/local/bin/dind-entrypoint.sh
+RUN chmod 0755 /usr/local/bin/dind-entrypoint.sh
+
+WORKDIR /workspace
+ENTRYPOINT ["/usr/local/bin/dind-entrypoint.sh"]
+CMD ["sleep", "infinity"]

container/.dockerignore

@@ -0,0 +1,79 @@
+#!/bin/sh
+# Forge sandbox entrypoint.
+#
+# When FORGE_DIND=1 (set by the sandbox manager for Docker-in-Docker loops, which
+# also launch the container as --privileged --init), this boots a nested, isolated
+# Docker daemon so the loop can build and run containers for end-to-end tests. The
+# nested daemon stores its data under /var/lib/docker, which the manager backs with
+# an anonymous volume so overlay2 works inside the privileged container.
+#
+# When FORGE_DIND is unset or 0 this is a transparent passthrough: the container
+# command runs unchanged and no daemon is started, so worktree-only and non-DinD
+# sandbox loops pay no cost.
+set -e
+
+# Resolve the dockerd `--group` argument so the daemon socket is owned by the host GID's
+# group from creation. The container runs as root, but the agent's shell commands run as the
+# host UID (docker exec --user) so worktree files are host-owned; giving the socket that GID
+# lets the non-root user reach dockerd without a post-start chmod (which dockerd resets,
+# causing a race). When FORGE_HOST_GID is unset, commands run as root and need no group.
+resolve_socket_group_arg() {
+  [ -n "${FORGE_HOST_GID:-}" ] || return 0
+  group_name=$(getent group "$FORGE_HOST_GID" 2>/dev/null | cut -d: -f1)
+  if [ -z "$group_name" ]; then
+    groupadd -g "$FORGE_HOST_GID" forgehost 2>/dev/null || true
+    group_name=$(getent group "$FORGE_HOST_GID" 2>/dev/null | cut -d: -f1)
+  fi
+  [ -n "$group_name" ] && printf -- '--group %s' "$group_name"
+}
+
+# Guarantee the in-container exec user can reach the daemon socket. Agent shell commands run as
+# the host UID:GID via `docker exec --user` (not root), so the socket must be group-accessible to
+# that GID. dockerd is started with `--group` when FORGE_HOST_GID is known, but this runs only
+# AFTER the daemon is confirmed ready, so it is race-free (the startup race the `--group` arg
+# avoids is doing this while dockerd is still applying socket perms). It self-heals cases where the
+# group did not take, and falls back to a world-accessible socket when the GID is unknown — safe
+# because the container is per-loop, isolated, and already --privileged, so anyone who can exec in
+# is already root-capable.
+ensure_socket_access() {
+  sock=/var/run/docker.sock
+  [ -S "$sock" ] || return 0
+  if [ -n "${FORGE_HOST_GID:-}" ] \
+    && chgrp "$FORGE_HOST_GID" "$sock" 2>/dev/null \
+    && chmod g+rw "$sock" 2>/dev/null; then
+    echo "forge-dind: docker socket group set to GID $FORGE_HOST_GID" >&2
+    return 0
+  fi
+  # GID unknown or chgrp failed: make the socket reachable by any exec UID/GID.
+  chmod 666 "$sock" 2>/dev/null || true
+  echo "forge-dind: docker socket made world-accessible (no usable FORGE_HOST_GID)" >&2
+}
+
+start_dockerd() {
+  echo "forge-dind: starting nested Docker daemon" >&2
+  group_arg=$(resolve_socket_group_arg)
+  # Run detached; logs go to a file so failures are inspectable via docker exec.
+  # shellcheck disable=SC2086
+  dockerd $group_arg >/var/log/dockerd.log 2>&1 &
+
+  # Wait for the daemon to accept API calls. Bounded so a broken daemon does not
+  # hang the loop indefinitely; the loop's own tooling can still retry afterwards.
+  tries=0
+  until docker version >/dev/null 2>&1; do
+    tries=$((tries + 1))
+    if [ "$tries" -ge 60 ]; then
+      echo "forge-dind: dockerd did not become ready within 60s" >&2
+      tail -n 50 /var/log/dockerd.log >&2 2>/dev/null || true
+      return 0
+    fi
+    sleep 1
+  done
+  echo "forge-dind: nested Docker daemon ready" >&2
+  ensure_socket_access
+}
+
+if [ "${FORGE_DIND:-0}" = "1" ]; then
+  start_dockerd
+fi
+
+exec "$@"

container/Dockerfile

@@ -0,0 +1,46 @@
+# Agents and Slash Commands
+
+Forge installs agent definitions and slash commands through the server plugin config hook.
+
+See also: [Tools](tools.md), [Configuration](configuration.md), [Loop System](loop-system.md).
+
+## Agents
+
+| Agent | Mode | Description |
+|---|---|---|
+| `code` | `all` | Primary implementation agent. |
+| `architect` | `primary` | Read-only planning agent. Produces marked plans for approval and execution. |
+| `auditor` | `subagent` | Read-only code review agent for convention-aware reviews. |
+| `auditor-loop` | `primary`, hidden | Internal auditor used by loop audit sessions. |
+
+Source: [`src/agents/index.ts`](../src/agents/index.ts), [`src/agents/auditor.ts`](../src/agents/auditor.ts).
+
+## Auditor restrictions
+
+The auditor agents are read-only. They cannot use file-modifying tools or loop-management tools.
+
+Excluded tools:
+
+- `apply_patch`
+- `edit`
+- `write`
+- `multiedit`
+- `plan`
+- `plan_exit`
+- `execute-plan`
+- `loop-cancel`
+- `loop-status`
+
+Source: [`AUDITOR_TOOL_EXCLUDES`](../src/agents/auditor.ts).
+
+## Slash Commands
+
+| Command | Description | Agent | Subtask |
+|---|---|---|---|
+| `/review` | Run a code review. | `auditor` | yes |
+| `/review-plan` | Review a completed implementation against its original plan. | `auditor` | yes |
+| `/execute-plan` | Start an iterative development loop in a worktree (or launch the plan in a fresh standalone session with `mode: new-session`). | `code` | no |
+| `/loop-status` | Check status of all active loops. | `code` | no |
+| `/loop-cancel` | Cancel the active loop. | `code` | no |
+
+Source: [`buildPluginCommands()`](../src/config.ts).