autoloop/20260425T065551Z/w3/5 5.q api server disconnect snapshot persistence

README.md

@@ -2,188 +2,195 @@
   <img src="assets/gormes-agent-logo.png" alt="GORMES-AGENT" width="600">
 </p>
 
-<p align="center">
-  <strong>A Go-native runtime for AI agents — one binary, no Python, no virtualenvs.</strong><br>
-  Built to fix the reliability and deployment problems that break Python-stack agents in production.
-</p>
+# GORMES-AGENT
 
-<p align="center">
-  <em>Early-stage. Built for developers who care about reliability over polish.</em>
-</p>
+A Go-native runtime for AI agents.
+
+A single static binary for the Gormes runtime surface. No Python inside the shipped binary. No virtualenvs.
+
+Built to fix the reliability and deployment problems that break Python-stack agents in production.
+
+**Early-stage. Not production-ready yet.** Live turns still need a Hermes-compatible backend while the Go-native brain is being built.
 
 <p align="center">
   <a href="https://docs.gormes.ai/"><img src="https://img.shields.io/badge/Docs-docs.gormes.ai-FFD700?style=for-the-badge" alt="Documentation"></a>
   <a href="https://github.com/TrebuchetDynamics/gormes-agent"><img src="https://img.shields.io/badge/GitHub-TrebuchetDynamics%2Fgormes--agent-181717?style=for-the-badge&logo=github&logoColor=white" alt="GitHub"></a>
-  <a href="https://github.com/TrebuchetDynamics/gormes-agent/blob/main/LICENSE"><img src="https://img.shields.io/badge/License-MIT-green?style=for-the-badge" alt="License: MIT"></a>
+  <img src="https://img.shields.io/badge/License-MIT-green?style=for-the-badge" alt="License: MIT">
 </p>
 
 ---
 
-> 🚧 **Under construction.** Hermes is no longer required. The Go-native runtime that replaces it is still being wired up — **Gormes is not yet usable end-to-end**. Memory and Brain phases are in active development. Expect rough edges; expect the API to change. See [Build State](#build-state) below for what works today and what doesn't.
-
----
-
 ## Quick Start
 
-> The installer is the source-of-truth for trying Gormes locally. The TUI runs and the gateway adapters stream, but the agent loop is incomplete — install today to follow along, not to deploy.
+Try the local TUI and diagnostics first.
 
-**Linux / macOS / Termux:**
+### Unix (Linux / macOS / Termux)
 
 ```bash
 curl -fsSL https://gormes.ai/install.sh | sh
-gormes
+gormes --offline
+gormes doctor --offline
 ```
 
-**Windows (PowerShell):**
+### Windows (PowerShell)
 
 ```powershell
 irm https://gormes.ai/install.ps1 | iex
-gormes
+gormes --offline
+gormes doctor --offline
 ```
 
-The installer auto-installs `git` and Go 1.25+ when missing (apt/dnf/pacman/brew/pkg
-on Unix, winget/choco on Windows, with a managed go.dev fallback on either) and
-keeps a managed checkout under `~/.gormes` (or `%LOCALAPPDATA%\gormes`). Rerun
-the same command to update — local edits in the managed checkout are autostashed
-and reapplied. No Python, no virtualenv, no dependency drift.
+The installer manages a source checkout under `~/.gormes/gormes-agent` or `%LOCALAPPDATA%\gormes\gormes-agent`, installs Git and Go when missing where possible, builds `gormes`, and updates in place on rerun.
 
----
+For live turns today, start a Hermes-compatible backend and run `gormes` without `--offline`:
 
-## What Gormes Is
+```bash
+API_SERVER_ENABLED=true hermes gateway start
+gormes
+```
 
-Gormes is a Go-native rewrite of [Hermes Agent](https://github.com/NousResearch/hermes-agent)'s runtime infrastructure. It started as an independent Go port of ideas and architecture from Hermes-Agent, with upstream Git history preserved for attribution, and is being rebuilt around a single static binary and Gormes-native runtime boundaries.
+---
 
-**Gormes solves an operations problem, not an AI problem.** The thesis isn't "smarter agents." It's agents that survive deployment, don't crash mid-stream, and don't break when a Python dependency drifts on a host you SSH into six months from now.
+## Core Features
 
-Hermes is no longer a runtime dependency. The Go-native pieces that replace it are still being built — see the build state below.
+- **Single static binary** - current Gormes build is ~17.7 MB, stripped, static, and zero-CGO.
+- **No Gormes runtime drift** - the Go binary you test is the Go binary you run.
+- **Stream resilience** - Route-B reconnect treats dropped SSE streams as recoverable.
+- **Local validation** - `gormes doctor --offline` catches tool and config issues before runtime.
+- **Multi-platform gateway** - Telegram and Discord ship on the shared gateway; Slack, WhatsApp, and WeChat are active.
+- **Isolated subagents** - bounded parallel workstreams with durable job metadata.
+- **Goncho memory layer** - Honcho-style peer context, search, profiles, and diagnostics inside the Gormes binary.
 
 ---
 
 ## Why Gormes Exists
 
-> **Gormes is not about smarter agents.**
->
-> It's about agents that:
-> - don't fail to install
-> - don't drift between environments
-> - don't crash after six hours
-> - don't lose work on dropped connections
+Gormes is not about smarter agents.
+
+It is about agents that:
+
+- do not fail to install
+- do not drift between environments
+- do not crash mid-run
+- do not lose work on dropped connections
 
-### Why Hermes-stack agents break in production
+### Why Python-stack agents break
 
 - Python environments drift between dev, staging, and prod.
-- npm and Nix builds break silently on host package skew.
-- Multi-process Python orchestration crashes or hangs under load.
-- SSE streams drop on flaky networks and kill long-running agents.
-- Debugging a single failure spans Python, Node, and OS runtimes.
+- npm and Nix builds break on host package skew.
+- Multi-process orchestration crashes or hangs under load.
+- SSE streams drop and kill long-running turns.
+- Debugging spans Python, Node, shell, and OS runtimes.
 
-### How Gormes fixes it
+Gormes fixes this by:
 
-| Problem | Gormes |
-|---|---|
-| **Broken installs** | Single ~17.7 MB static binary |
-| **Runtime drift** | Pure Go. No `pip`, no `npm`, no `activate` |
-| **Process crashes** | One runtime, one process tree |
-| **Dropped SSE streams** | Route-B auto-reconnect, no lost responses |
-| **3am debugging** | `gormes doctor --offline` validates locally first |
+- Single static binary -> fewer broken installs
+- Pure Go runtime surfaces -> no `pip`, no `npm`, no `activate`
+- Route-B reconnect -> dropped streams become recoverable events
+- Local doctor checks -> issues fail before tokens burn
+- In-binary memory and gateway seams -> less cross-runtime debugging
 
 ---
 
-## Who Gormes Is For
+## Build State
 
-- **Operators of long-running agents** — you need agents that survive restarts, network blips, and host upgrades, not just impressive demos.
-- **Developers tired of Python/Nix/npm breakage** — you're tired of an agent that worked yesterday breaking today because a transitive dep ticked over.
-- **Builders who want one binary that just runs** — you'd rather `scp` one file to a Termux session or Alpine VPS than reproduce a virtualenv.
+Gormes is a strangler-fig rewrite of Hermes-Agent, with upstream Git history preserved for attribution.
 
----
+Today:
 
-## Build State
+- Dashboard: shipping
+- Gateway: partial
+- Memory: active
+- Brain: not complete
+- Live turns: still require a Hermes-compatible backend
+
+Next milestone:
 
-Gormes is a **strangler-fig rewrite**. Each phase ships a self-contained surface in Go and removes the corresponding Python surface from the runtime. Today the dashboard, gateway, and most of the memory layer are working in Go. The brain — the agent loop itself — is not.
+- Fully Go-native agent runtime with no Hermes backend requirement.
 
-| Phase | Status | What's in scope |
-|---|---|---|
-| **Phase 1** — The Dashboard | shipping | Go-native TUI, render mailbox, settings surfaces |
-| **Phase 2** — The Gateway | partial | Telegram + Discord shipping; Slack/WhatsApp/WeChat in progress |
-| **Phase 3** — The Black Box (Memory) | active | SQLite + FTS5 lattice, ontological graph, neural recall |
-| **Phase 4** — The Brain Transplant | active | Native prompt building, agent orchestration in Go |
-| **Phase 5** — The Final Purge | planned | Last Python tool scripts ported; 100% Go runtime |
-| **Phase 6** — The Learning Loop | planned | Self-improvement loop |
+Full progress: [docs.gormes.ai/building-gormes/architecture_plan](https://docs.gormes.ai/building-gormes/architecture_plan/)
+
+<details>
+<summary>Generated phase rollup</summary>
 
 <!-- PROGRESS:START kind=readme-rollup -->
 | Phase | Status | Shipped |
 |-------|--------|---------|
 | Phase 1 — The Dashboard | ✅ | 3/3 subphases |
 | Phase 2 — The Gateway | 🔨 | 12/19 subphases |
-| Phase 3 — The Black Box (Memory) | 🔨 | 11/14 subphases |
+| Phase 3 — The Black Box (Memory) | 🔨 | 12/14 subphases |
 | Phase 4 — The Brain Transplant | 🔨 | 0/8 subphases |
 | Phase 5 — The Final Purge | 🔨 | 1/18 subphases |
 | Phase 6 — The Learning Loop (Soul) | ⏳ | 0/6 subphases |
 | Phase 7 — Paused Channel Backlog | 🔨 | 2/5 subphases |
 <!-- PROGRESS:END -->
 
-Full item-level checklist and stats: **[docs.gormes.ai/building-gormes/architecture_plan](https://docs.gormes.ai/building-gormes/architecture_plan/)**
+</details>
 
 ---
 
-## Core Features
+## Goncho (Honcho -> Go)
+
+Gormes includes Goncho: an in-binary Go port of Honcho's peer-centric memory and context model.
+
+Goncho is not a sidecar, second database, or loopback service. It runs inside the Gormes binary on the same SQLite memory substrate and exposes Honcho-compatible tools:
+
+- `honcho_profile`
+- `honcho_search`
+- `honcho_context`
+- `honcho_chat`
+- `honcho_reasoning`
+- `honcho_conclude`
 
-- **Single Static Binary** — Zero CGO. ~17.7 MB. Deploy to Termux, Alpine, a fresh VPS — it runs. No Python, no virtualenv, no Nix.
-- **No Runtime Drift** — Pure Go. The binary you tested is the binary that deploys.
-- **Streams That Don't Drop** — Route-B reconnect treats SSE drops as recoverable, not fatal. Your agent doesn't lose work to a flaky network.
-- **Local Validation** — `gormes doctor --offline` checks tool schemas before you burn tokens.
-- **Multi-Platform Gateway** — Telegram and Discord run through the shared gateway today; Slack shared-runtime wiring, WhatsApp, and WeChat are the active channel priorities while the other adapters sit in Phase 7.
-- **Scheduled Automations** — Built-in cron scheduler delivering to any platform.
-- **Isolated Subagents** — Parallel workstreams with bounded memory and controlled execution.
+This gives Gormes a local memory layer for peer profiles, session context, retrieval, conclusions, queue status, and degraded-mode diagnostics.
+
+Docs: [Goncho Honcho Memory](https://docs.gormes.ai/building-gormes/goncho_honcho_memory/)
+
+---
+
+## Who Gormes Is For
+
+- **Operators of long-running agents** - systems that must survive restarts, flaky networks, and host changes.
+- **Developers tired of Python/Nix/npm breakage** - environments that worked yesterday and fail today.
+- **Builders who want one deployable artifact** - ship a Go binary instead of reconstructing a runtime.
 
 ---
 
-## Common Commands
+## Basic Usage
 
 ```bash
-gormes                  # Start the TUI
-gormes model            # Choose your LLM provider
-gormes tools            # Configure enabled tools
-gormes gateway          # Start the messaging gateway
-gormes setup            # Run the full setup wizard
-gormes doctor           # Validate local tool wiring
-gormes claw migrate     # Migrate from OpenClaw
+gormes --offline
 ```
 
-📖 **[Full documentation →](https://docs.gormes.ai/)**
+Use `gormes` without `--offline` when a Hermes-compatible backend is running.
+
+More commands: [cmd/README.md](cmd/README.md)
 
 ---
 
 ## Documentation
 
-| Resource | Link |
-|----------|------|
-| **Quick Start** | [docs.gormes.ai/getting-started/quickstart](https://docs.gormes.ai/getting-started/quickstart) |
-| **CLI Reference** | [docs.gormes.ai/reference/cli-commands](https://docs.gormes.ai/reference/cli-commands) |
-| **Architecture** | [docs.gormes.ai/developer-guide/architecture](https://docs.gormes.ai/developer-guide/architecture) |
-| **Roadmap** | [Full architecture plan + checklist](https://docs.gormes.ai/building-gormes/architecture_plan/) |
+- [Quickstart](https://docs.gormes.ai/using-gormes/quickstart/)
+- [Install](https://docs.gormes.ai/using-gormes/install/)
+- [Configuration](https://docs.gormes.ai/using-gormes/configuration/)
+- [Core systems](https://docs.gormes.ai/building-gormes/core-systems/)
+- [Architecture plan](https://docs.gormes.ai/building-gormes/architecture_plan/)
+- [Goncho Honcho Memory](https://docs.gormes.ai/building-gormes/goncho_honcho_memory/)
 
 ---
 
 ## Contributing
 
-Contributions are welcome. If you have ideas for new features, integrations, documentation improvements, or fixes, open an issue or submit a pull request.
-
-Start here:
-
-- [CONTRIBUTING.md](CONTRIBUTING.md) for repository contribution guidelines and PR workflow
-- [Gormes developer docs](https://docs.gormes.ai/developer-guide/contributing) for setup and project-specific context
-
-Quick start:
+Contributions are welcome. Build the binary and run the offline UI first:
 
 ```bash
 git clone https://github.com/TrebuchetDynamics/gormes-agent.git
 cd gormes-agent
 make build
-./bin/gormes
+./bin/gormes --offline
 ```
 
-Join the discussion and help shape the future of Gormes.
+Contributor roadmap: [Building Gormes](https://docs.gormes.ai/building-gormes/)
 
 ---
 

cmd/architecture-planner-loop/main_test.go

@@ -160,6 +160,7 @@ func writeCommandFixture(t *testing.T) string {
 	t.Helper()
 
 	root := t.TempDir()
+	t.Setenv("PROGRESS_JSON", filepath.Join(root, "docs", "content", "building-gormes", "architecture_plan", "progress.json"))
 	writeCommandFile(t, filepath.Join(root, "docs", "content", "building-gormes", "architecture_plan", "progress.json"), `{
   "phases": {
     "2": {

cmd/autoloop/README.md

@@ -62,6 +62,14 @@ Useful environment variables:
   unbounded run.
 - `PRIORITY_BOOST`: comma-separated subphase IDs to pull ahead of equally ready
   work. Defaults to the active priority channels: `2.B.3,2.B.4,2.B.10,2.B.11`.
+- `POST_PROMOTION_VERIFY_COMMANDS`: override the mandatory post-promotion
+  full-suite gate. Separate shell commands with `;;` or newlines. Defaults to
+  `go test ./... -count=1`, `www.gormes.ai` Go tests, progress validation,
+  autoloop dry-run, and the site Playwright e2e suite.
+- `POST_PROMOTION_REPAIR`: enable or disable the automatic repair backend after
+  a failed post-promotion gate. Defaults to enabled.
+- `POST_PROMOTION_REPAIR_ATTEMPTS`: number of repair attempts before the run is
+  recorded as failed. Defaults to `1`.
 
 ## Worker isolation and promotion
 
@@ -93,6 +101,11 @@ finished branches in worker order. The flow per worker is:
    <commit>`. If push or `gh` fails, autoloop still attempts the same local
    cherry-pick fallback. Clean successful/no-change worktrees are removed;
    failed worktrees stay in `$RUN_ROOT/worktrees/` for inspection.
+7. After all worker promotions land, run the mandatory post-promotion full-suite
+   gate before emitting `run_completed` or `health_updated`. A gate failure
+   emits `post_promotion_verify_failed`, starts one repair backend by default,
+   requires the repair to leave the checkout clean, reruns the full suite, and
+   records final health only after the gate passes.
 
 Each promotion attempt emits a `worker_promoted` or `worker_promotion_failed`
 ledger event so the audit's `productivity` metric reflects work that actually

cmd/autoloop/main.go

@@ -268,7 +268,18 @@ func dashIfEmpty(value string) string {
 
 func autoloopEnv() map[string]string {
 	env := map[string]string{}
-	for _, key := range []string{"PROGRESS_JSON", "RUN_ROOT", "BACKEND", "MODE", "MAX_AGENTS", "MAX_PHASE", "PRIORITY_BOOST"} {
+	for _, key := range []string{
+		"PROGRESS_JSON",
+		"RUN_ROOT",
+		"BACKEND",
+		"MODE",
+		"MAX_AGENTS",
+		"MAX_PHASE",
+		"PRIORITY_BOOST",
+		"POST_PROMOTION_VERIFY_COMMANDS",
+		"POST_PROMOTION_REPAIR",
+		"POST_PROMOTION_REPAIR_ATTEMPTS",
+	} {
 		env[key] = os.Getenv(key)
 	}
 

cmd/gormes/goncho.go

@@ -565,7 +565,7 @@ func formatGonchoDoctorReport(report gonchoDoctorReport) string {
 		b.WriteString("\n")
 	}
 
-	b.WriteString("Queue status (observability only; not synchronization)\n")
+	b.WriteString("Queue status (observability/debugging only; not synchronization; do not wait for empty queue)\n")
 	fmt.Fprintf(&b, "extractor_worker_health: %s\n", report.QueueStatus.Extractor.WorkerHealth)
 	fmt.Fprintf(&b, "extractor_queue_depth: %d\n", report.QueueStatus.Extractor.QueueDepth)
 	fmt.Fprintf(&b, "extractor_dead_letters: %d\n", report.QueueStatus.Extractor.DeadLetterCount)

cmd/gormes/goncho_doctor_test.go

@@ -39,7 +39,7 @@ func TestGonchoDoctorCommand_TextZeroStateReportsOperatorLadder(t *testing.T) {
 		"honcho_context",
 		"Context dry-run",
 		"No stored representation for operator:diagnostic.",
-		"Queue status (observability only; not synchronization)",
+		"Queue status (observability/debugging only; not synchronization; do not wait for empty queue)",
 		"extractor_queue_depth: 0",
 		"representation: total=0 pending=0 in_progress=0 completed=0",
 		"summary: total=0 pending=0 in_progress=0 completed=0",

cmd/gormes/memory.go

@@ -82,7 +82,7 @@ func formatExtractorStatus(status memory.ExtractorStatus) string {
 
 func formatGonchoQueueStatus(status goncho.QueueStatus) string {
 	var b strings.Builder
-	b.WriteString("Goncho queue status (observability only; not synchronization)\n")
+	b.WriteString("Goncho queue status (observability/debugging only; not synchronization; do not wait for empty queue)\n")
 	for _, taskType := range goncho.QueueTaskTypes {
 		counts := status.WorkUnits[taskType]
 		b.WriteString(fmt.Sprintf("%s: total=%d pending=%d in_progress=%d completed=%d\n",

cmd/gormes/memory_test.go

@@ -84,7 +84,7 @@ func TestMemoryStatusCommand_PrintsGonchoQueueZeroState(t *testing.T) {
 
 	out := stdout.String()
 	for _, want := range []string{
-		"Goncho queue status (observability only; not synchronization)",
+		"Goncho queue status (observability/debugging only; not synchronization; do not wait for empty queue)",
 		"representation: total=0 pending=0 in_progress=0 completed=0",
 		"summary: total=0 pending=0 in_progress=0 completed=0",
 		"dream: total=0 pending=0 in_progress=0 completed=0",

docs/content/building-gormes/_index.md

@@ -70,6 +70,12 @@ Worker execution is isolated: `cmd/autoloop` creates a git worktree under
 `RUN_ROOT/worktrees` for each selected row, runs the backend there, and rejects
 committed paths outside that row's `write_scope` before promotion.
 
+Final run health is gated after promotion. Once worker commits are integrated,
+`cmd/autoloop` runs the mandatory full-suite post-promotion verification before
+it emits `run_completed` or `health_updated`. If the suite fails, autoloop runs
+one backend repair attempt by default, requires the checkout to be clean, reruns
+the suite, and records final health only after the repaired integration passes.
+
 ## Contributor path
 
 Use the planning docs in this order: