Monastery v0.2.2-alpha

The LLM finishes what it starts

Two fixes born from a field report of tasks dying mid-way.

Edit recovery now completes the task

When a SEARCH/REPLACE edit failed to match, Monastery's recovery ladder repaired and applied it — then went silent. The model never learned its edit landed, so every remaining step of the task was abandoned. Recovery now refreshes the live preview and hands the conversation back to the model with a note that the files are current, so it finishes the job. (With auto-continue off, you're told how to resume instead.)

Response discipline (learned from a deep-dive into bolt.diy)

The system context now carries the completeness rules that make bolt.diy reliable, adapted to Monastery's hybrid edit protocol:

• Plan the entire request first, then emit all file changes in a single response — never "continue later".
• Prefer complete-file blocks over SEARCH/REPLACE for small or mostly-changed files — full contents always apply; anchors can miss. This directly reduces "no SEARCH text matched" failures at the source.
• No placeholder ellipses; minimal prose.

Monastery keeps its token-efficient SEARCH/REPLACE for large files and its three-stage recovery ladder — both ahead of bolt.diy's whole-files-only, no-auto-recovery approach — now with the loop actually closed.

Also

• Project deletion fixed: deleting a previously-deployed project failed with a FOREIGN KEY error (deployment-tracking rows weren't cleaned up) and left a half-deleted project. Cleanup is now atomic (DB first, directory after) and includes deployment records — previously stuck projects heal on the next delete click.

Monastery v0.2.1-alpha

Deploy anywhere, route automatically

The headline: deployment identity now lives in your repo, and Cloudflare tunnel routing configures itself.

Deployment

• Deploy manifest (.monastery/deploy.json): a committed identity file per project — stable deploy id, pinned host port, domain, tunnel ids (never secrets). Redeploys from any Monastery instance adopt the existing platform app instead of creating duplicates; legacy deployments migrate automatically.
• Cloudflare routing automation: connect Cloudflare in Settings → Hosting (API token) and deploys with a domain get their tunnel Public Hostname + proxied DNS record created via the API — no more Zero Trust dashboard steps. Failures fall back to clear manual instructions and never break the deploy.
• Per-service tunnel tokens: save one connector token per platform (Dokploy/Coolify) in Settings → Hosting; deploys use them automatically.
• Redeploys converge config: port mappings and domains are re-synced on every redeploy (previously only the Dockerfile — a drifted port mapping was permanent).
• Honest port UI: the wizard now says which container port will really be used (nginx-served builds are always 80) instead of letting a stale Port field produce a dead mapping.
• One tunnel now cleanly serves many sites/domains — documented in docs/COOLIFY_DEPLOYMENT.md, with the service URL shown even when the tunnel toggle is off.
• Fixed: git push to a new forge repo now pushes only the selected project (previously the entire data directory); create-repo-and-push is surfaced in Source & Ship.

Models

• Per-endpoint model listing with a picker in the LLM menu (choice persists; chip shows endpoint · model), plus Custom model entry for endpoints that can't list.
• Lenient /v1/models parsing (DeepSeek's responses parse now) and the hardcoded deepseek-chat fallback is gone — no model means a clear message, not a doomed request.

Chat & agents

• Per-file diff cards: AI edits render as expandable diffs (+/− counts) right in the chat.
• Live preview opens by default and auto-refreshes as files land.
• @read/@search and recovery steps render as compact activity rows.
• Leaked native tool-call markup (e.g. DeepSeek DSML) is stripped, blocked via the system prompt, and read intents are rescued so turns don't stall.
• Hermes fixes: SSE keep-alive ends the ~100s tunnel-idle 'network error' drops; file tree refreshes after every agent run; a clear warning when Hermes wrote to an un-bridged workspace; git-bridge pattern documented for Hermes on a separate machine.

UI

• Soft card layout: panes float on the page background with gutters — no ruled dividers; fixed top-bar menu stacking; 11px type floor.
• Preview route no longer 400s on symlinked data dirs; missing index.html shows a friendly placeholder.

Monastery v0.2.0-alpha

UX architecture overhaul

The UI has been restructured around one home per concern, so features stop accumulating as extra buttons and toggles.

Highlights

• Chat header now owns sessions (switcher + new session) and the active task chip.
• Tasks (Plan → Implement → Verify → Review) live in a right-side drawer opened from the task chip, instead of a panel stacked above the chat.
• Source & Ship drawer replaces the scattered git controls: branch status with changed files, Pull, Commit & Push, the snapshot timeline with one-click restore, and the deploy entry point.
• Settings is a full-screen sectioned view (Models, Hermes Agent, Git Forges, Hosting) with deep links; connecting a platform lives only here — the Self-Host Wizard is now Platform → Configure → Deploy.
• Composer gets a registry-driven "+ Context" popover (skills like Pocketbase appear automatically), an explicit Chat/Agent mode selector, and a roles popover.
• Ctrl+K command palette: every action plus quick-open for project files.
• The code editor has its own visibility toggle, independent of the file-tree sidebar.

Under the hood

• App.tsx decomposed (1,900 → ~650 lines): chat orchestration, editor tabs, and the editor pane are separate modules.
• Shared UI primitives (modal, styled confirm/prompt/notice dialogs, connection form/card, status badge) replace native browser dialogs and four hand-rolled connection forms.
• Fixed: the git-forge Test button gave no feedback; the Agents tab's Open Settings button did nothing; placeholder Terminal/Diff preview tabs removed.
• Docker builds now version as v0.2.x-alpha with tag-based auto-increment.

Monastery v0.1.4-alpha

Delineator release before 0.2.0-alpha

Monastery v0.1.2-alpha

Release Date: 2026-06-26

The second alpha. If v0.1.0 gave Monastery a brain — LLMs, chat, projects, Git — then v0.1.2 gives
it hands: it can now deploy what you build to your own infrastructure, dispatch agentic work to
Hermes, and read its own deployment failures and try to fix them. Still very much alpha: the
deployment paths depend heavily on your own homelab setup and you'll occasionally coach the LLM
through a build — but the core loop of prompt → build → ship to your own boxes now runs end to end.

🚀 Self-Hosting & Deployment (new)

The headline of this release: a Self-Host Wizard that takes a Monastery project, commits it to
your Git forge, and builds + deploys it on your own platform.

Coolify

• One-click deploy via the Coolify API (Dockerfile build pack)
• Clone-at-build Dockerfiles — the image clones your repo at build time, so deploys work with
  IP / .local / self-signed hosts that Coolify's normal Git validation rejects
• Smarter server selection — de-prioritizes the built-in localhost server so apps land on your real
  VPS, with a graceful fallback when a project has no deployment server
• Deployment persistence (tracks the app UUID) for redeploy-in-place and 404 self-heal
• Base64 Dockerfile payloads and SSH/Git URL parsing fixes

Dokploy

• Full git-based deploy over Dokploy's tRPC API (create → save git provider → build type → deploy)
• Container port auto-detected from the Dockerfile EXPOSE and applied before deploy
• Fixes for auth, endpoint URLs, the dashboard link, the saveGitProvider schema, and the
  committed-Dockerfile flow (resolves "Github Provider not found" / "select-a-container")

Cloudflare Tunnel (both platforms)

• Optional auto-wired cloudflared sidecar — paste a tunnel token and Monastery deploys the
  connector for you
• Apps are published on a stable high host port for LAN + tunnel reachability; point your Cloudflare
  Public Hostname at the returned http://127.0.0.1:<port> service URL

Pocketbase backend (initial)

• Configure one shared Pocketbase instance in Settings; the wizard injects POCKETBASE_URL
  (build-time and runtime) into deployed apps
• A toggle-gated instruction set teaches the connected LLM how to build against Pocketbase
  (JS SDK usage, auth, collections) only when you're building a database-backed app

🔧 Deployment Monitoring & AI Auto-Fix (new)

• Pull a failed deployment's build log straight into chat with one click
• The connected LLM diagnoses the failure and applies fixes to your project files — then redeploy
• Graceful fallback: when a platform can't serve the remote build log (a known upstream Dokploy
  limitation, issue #4687), the LLM proactively reviews your Dockerfile/config instead of dead-ending

🤖 AI Agents — Hermes Integration (new)

• Connect an external Hermes agent in Settings → Hermes Agent (proxied via POST /api/hermes/run)
• Agent mode toggle routes your chat through the agent instead of the raw LLM
• Agent roles — Architect, Coder, Reviewer, Tester, Documenter, Deployer — as a selectable lens
  over your messages, multi-select capped at 2
• Hardened tool-call handling that surfaces Hermes's tool steps inline
• Shared-workspace docs so Hermes's own file writes show up in your Monastery project

⚡ Smarter Streaming

• Auto-continue — responses cut off by the model's output-token cap resume automatically
  (capped, abort-aware, and toggleable), so long generations finish without manual clicking
• Token usage shown per response when the endpoint reports it, accumulated across continuations
• Provider-aware response handling and token caps (local Ollama vs cloud) to stop premature cut-offs
• Fixes for runaway continuation loops and SSE stream parsing

🗂️ Workspace & Editor

• Create and delete files and directories directly from the sidebar
• File/folder uploads and drag-and-drop in the file tree
• SVG rendering in the preview pane

🎨 UI & Polish

• Consolidated chat toolbar — Auto-continue / Pocketbase / Agent-mode toggles collapsed onto a
  single compact row, with agent roles revealed inline when Agent mode is on
• Refreshed branding and LLM "thinking" animation
• Numerous compile and stability fixes across the Rust backend and React UI

---

⚠️ Alpha caveats: deployment behavior depends heavily on your Coolify/Dokploy setup (remote vs.
local build servers, tunnels, registries), and you should expect to occasionally guide the LLM
through a build fix. Back up anything you care about before pointing Monastery at it.

---

Full Changelog: v0.1.0-alpha...v0.1.2-alpha

v0.1.0-alpha

Monastery v0.1.0-alpha

Release Date: 2026-06-17

The inaugural alpha release of Monastery — a self-hosted sanctuary for AI-assisted coding. Connect your LLMs, manage projects with Git, deploy to your own infrastructure, and dispatch specialized AI agents - expect little from this initial offering.

---

Core Platform

Multi-LLM Support

• Connect any OpenAI-compatible endpoint (Ollama, vLLM, DeepSeek, OpenAI, Groq, etc.)
• Add, validate, and manage multiple endpoints in Settings
• Auto-select active endpoint; mark favorites
• Local endpoint detection with "local" badge

Chat Interface

• Real-time SSE streaming with markdown rendering
• Code block syntax highlighting with copy buttons
• File attachment support (images, code files)
• Auto-apply AI-generated code blocks to project files
• Shell command detection and execution
• Reasoning window — collapsible panel showing LLM thinking/reasoning tokens, capped at ~12 rows, scrollable
• Stop/interrupt generation mid-stream
• Welcome screen with suggested prompts

Project Management

• Multi-project support with SQLite persistence
• File tree explorer in sidebar
• Multi-tab code editor (Monaco-based, custom Monastery dark theme)
• File read/write via backend API
• Preview pane for live output

Session Persistence

• Chat sessions tied to projects
• Create, switch, and delete sessions
• Message history stored in SQLite via backend

---

Git Integration

Four Git forges supported with full CRUD + test workflow:

Forge	Type	Setup
GitHub	Cloud	API key (repo scope)
GitLab	Cloud / Self-hosted	API key (api, read_user)
Forgejo	Self-hosted	URL + API key
Gitea	Self-hosted	URL + API key

Features

• Wizard-style connection setup with token guide links
• Browse repositories with branch selection
• Clone repos as new Monastery projects
• Push projects to new repos on any forge
• Git status display (branch, ahead/behind, changed files)
• Auto-commit with snapshot creation before push

---

Agent System

Six built-in specialized AI agents, each with a tuned system prompt:

Agent	Icon	Role
Architect	🏗️	Plans project structure, chooses patterns
Coder	💻	Writes and edits code files
Reviewer	🔍	Code review — bugs, security, anti-patterns
Tester	🧪	Writes unit/integration tests
Documenter	📝	README, API docs, inline comments
Deployer	🚀	Dockerfile generation, deployment config

Invocation Methods

• Chat quick-actions — collapsible button row above chat input (toggle with Agents header)
• Editor toolbar — Explain / Refactor / Add Tests buttons dispatch Reviewer, Coder, and Tester with current file context
• Natural language — ask the main chat to use an agent

How It Works

1. Agent receives its system prompt + full project context (capped at 200KB)
2. LLM streams response via SSE with reasoning support
3. Response appears as live-streamed assistant message in chat

---

Self-Host Deployment

Hosting Services (Settings)

Connect to your self-hosted infrastructure:

Service	Type	Use
Dokploy	PaaS	Deploy apps, databases, Docker containers
Coolify	PaaS	Vercel/Netlify alternative for self-hosted
Pocketbase	Backend	Database, auth, file storage

Each service card shows connection status:

• ⚠ Not Verified — saved but not validated
• ✓ Connected — validated successfully
• ✗ Failed — error with message

Self-Host Wizard (Ctrl+Shift+D)

One-click deployment modal:

• Auto-detects connected platforms and database backends
• Framework detection from package.json (Next.js, Vite, React, Vue, Express, Fastify, Node)
• Auto-generates optimized multi-stage Dockerfile if none exists
• Creates application on Dokploy or Coolify
• Triggers deployment and returns dashboard URL
• Configurable app name and port

---

Snapshot Version Control

• Create named snapshots of entire project state
• Auto-snapshots before git commits
• List, view, diff, and restore snapshots
• Revert to any snapshot from chat markers

---

Sidebar

Four-tab collapsible left panel:

Tab	Content
Files	Project file tree with sync status indicators
Sessions	Chat history with create/delete
Agents	6 built-in agents with descriptions, tool badges, and idle status
Integrations	Live status of LLM endpoints, Git forges, and Hosting Services with count badges

---

Settings Modal

Three-tab configuration center:

Tab	Content
LLM Endpoints	Add/validate/delete OpenAI-compatible endpoints
Git Forges	Connect GitHub, GitLab, Forgejo, Gitea
Hosting Services	Connect Dokploy, Coolify, Pocketbase

---

Architecture

┌──────────────────────────────────────────────────┐
│                   Browser (React + Vite)          │
│  ┌─────────┐ ┌──────────┐ ┌───────────────────┐  │
│  │ Chat    │ │ Editor   │ │ Preview           │  │
│  │ +Agents │ │ +Toolbar │ │                   │  │
│  └─────────┘ └──────────┘ └───────────────────┘  │
│  ┌────────────────────────────────────────────┐  │
│  │ Sidebar (Files/Sessions/Agents/Integrations)│  │
│  └────────────────────────────────────────────┘  │
└────────────────────┬─────────────────────────────┘
                     │ REST + SSE
┌────────────────────▼─────────────────────────────┐
│              Rust Backend (Axum)                  │
│  ┌──────────┐ ┌────────┐ ┌───────────────────┐   │
│  │ Chat     │ │ Agents │ │ Deploy (Coolify/   │   │
│  │ Stream   │ │ Run    │ │ Dokploy)           │   │
│  └──────────┘ └────────┘ └───────────────────┘   │
│  ┌──────────┐ ┌────────┐ ┌───────────────────┐   │
│  │ Git      │ │Hosting │ │ Snapshots         │   │
│  │ Forges   │ │Services│ │                   │   │
│  └──────────┘ └────────┘ └───────────────────┘   │
│  ┌──────────────────────────────────────────┐    │
│  │ SQLite (endpoints, projects, sessions,    │    │
│  │  git_connections, hosting_connections)    │    │
│  └──────────────────────────────────────────┘    │
└──────────────────────────────────────────────────┘

Tech Stack

• Frontend: React 18, TypeScript, Vite, Tailwind CSS, Zustand, SWR, Monaco Editor
• Backend: Rust, Axum, SQLx, async-openai, reqwest
• Database: SQLite
• Streaming: Server-Sent Events (SSE) with reasoning support
• Container: Docker Compose

---

What's Next (v0.2.0)

• External agent support (Hermes, Open Claw)
• Deployment progress streaming in wizard
• Environment variable management for deployments
• Pocketbase schema auto-generation
• Agent pipeline orchestration (chain agents together)
• Multi-model agent support (use different LLMs per agent)

---

Documentation

• README.md — Project overview and quick start
• ARCHITECTURE.md — High-level architecture
• PROJECT_VISION.md — Design philosophy
• docs/AGENTS.md — Agent system documentation
• docs/SELF_HOST_WIZARD_PLAN.md — Deployment wizard plan
• packages/web-ui/README.md — Frontend documentation