Merge pull request #3 from ashlrai/feat/v5-open-fleet

v5 Open Fleet — polyglot, self-improving, conducted fleet (M50-M57, incl. v4)

Author: masonwyatt23

.claude/commands/goal.md

@@ -0,0 +1,23 @@
+---
+description: Create, plan, and advance an ashlr goal — sandboxed, proposal-only, routed across the polyglot backend fleet (M55).
+argument-hint: "<objective>" [--project <repo>] [--allow-cloud]
+---
+
+Run the ashlr **goal conductor** for this objective:
+
+$ARGUMENTS
+
+Execute it:
+
+```bash
+ashlr goal $ARGUMENTS
+```
+
+`ashlr goal` creates a goal, plans it into milestones, and advances the next
+milestone as a **sandboxed, proposal-only** run — routed across the polyglot
+backend roster (local · Hermes · Claude · Codex · NVIDIA NIMs · Kimi K2.7 · …) by
+capability and trust tier. **Nothing is applied to the working tree or `main`** —
+the run files a PENDING proposal.
+
+After it completes, summarize the proposal that was filed and remind the user to
+review it with `ashlr inbox`. The kill-switch (`~/.ashlr/KILL`) halts everything.

.claude/commands/loop.md

@@ -0,0 +1,20 @@
+---
+description: Run the autonomous ashlr fleet over every enrolled repo — one tick or continuous, proposal-only (M55).
+argument-hint: [--watch] [--dry-run]
+---
+
+Run the ashlr **fleet conductor**:
+
+```bash
+ashlr loop $ARGUMENTS
+```
+
+`ashlr loop` renders the live control plane (per-backend throughput, queue depth,
+quota, merges-to-`main` today) and then runs the autonomous fleet over every
+enrolled repo: it discovers work, routes each item across the polyglot roster by
+trust tier, runs it **sandboxed**, and files **PENDING proposals** — nothing is
+applied by default. Default is a single tick; pass `--watch` for the continuous
+loop, `--dry-run` to plan without dispatching.
+
+It respects the kill-switch (`~/.ashlr/KILL`) and the daily budget. After it runs,
+report the fleet status and any proposals filed (review via `ashlr inbox`).

CHANGELOG.md

@@ -18,6 +18,52 @@ hub (M1–M20). Entries below detail each milestone; dates are merge dates into
   Milestones M34–M40, thirteen new team safety invariants, registered as a
   living ashlr goal. ROADMAP and contracts README updated to point at it.
 
+## [3.0.0] — 2026-06-17 — v3-Weapon · v4-Foundry · v5-Open-Fleet (M41–M60)
+
+A major leap: local models became an engineering weapon, then a fleet of
+backends that builds and maintains the ecosystem autonomously — proposal-only,
+trust-gated, contained. Same safety floor; zero new runtime deps.
+
+### v3-Weapon (M41–M44)
+- Adaptive, model-sized prompts; the sandboxed engineering tool surface
+  (write/edit/bash confined to a worktree, diffs → inbox, never the live tree);
+  the verify→repair loop; and `ashlr eval` proving the local uplift.
+
+### v4-Foundry (M45–M49)
+- `runEngineSandboxed`: run an external agent CLI inside a throwaway git
+  worktree, sever git push, capture ONLY the scrubbed diff as a PENDING
+  proposal, trust-tagged `{engineModel, engineTier}`.
+- Backend router + rate/quota scheduler; the tiered-trust merge-to-`main` gate
+  with HMAC-signed provenance (M47.1); the 24/7 fleet supervisor; the fleet
+  control plane (`ashlr fleet status/pause/resume` + `#fleet` web view).
+
+### v5-Open-Fleet (M50–M60)
+- **M50** declarative engine registry (adding a backend is config-only) + a real
+  OpenAI-compatible API client (Hermes, OpenCode, NVIDIA NIMs, Kimi K2.7 …);
+  existing engines reproduce byte-identical argv.
+- **M51** tri-tier trust (`local | mid | frontier`); authority never leaks
+  upward (`frontier→main`, `mid→branch`, `local→proposal-only`).
+- **M52** OS-level confinement (macOS `sandbox-exec` read-jail + egress gate)
+  closing v4's read-residual.
+- **M53** fleet intelligence — learned routing, budget-breach tier cascade,
+  per-run cost-anomaly holds (all proposal-only).
+- **M54** self-improving fleet — a never-weaken guard (refuses any diff that
+  deletes/weakens a safety test) + a green-flag-off-AND-on self-eval harness.
+- **M55** the conductor — `ashlr goal` + `ashlr loop` + Claude Code `/goal`
+  `/loop`.
+- **M56** `mid→branch` auto-apply (verified mid-tier opens a PR, never `main`),
+  behind a separate default-off `midToBranch` flag.
+- **M57** `cfg.foundry` example + `docs/FOUNDRY-CONFIG.md`.
+- **M58/M60** two reference plugins (scanner + template) seeding the ecosystem.
+- **M59** `ashlr fleet init` (config bootstrap) + typed `cfg.foundry.intelligence`.
+
+### Safety
+Everything can reach `main` — but only a frontier merge-authority model, fully
+verified, with valid HMAC provenance. Auto-merge (main and mid→branch) is
+DEFAULT OFF. Kill-switch (`~/.ashlr/KILL`) halts every backend.
+
+---
+
 ## [2.2.0] — 2026-06-12 — v2.2 "Agent-Native Ecosystem" (M31–M33)
 
 Makes ashlr's intelligence first-class INSIDE agent sessions — CLI-first, with

README.md

@@ -580,6 +580,7 @@ Self-heal is always bounded (never loops), opt-out (`ASHLR_NO_HEAL=1`), and neve
 | **Portfolio intelligence (v2)** | `ashlr knowledge build/impact/graph` · `ashlr ask` · `ashlr reflect` · `ashlr health` · `ashlr digest` |
 | **Cloud-ready seams (v2)** | `ashlr seams` |
 | **Harden & prove (v2.1)** | `ashlr verify-safety` · `ashlr sandbox gc` · `ashlr audit` · `ashlr preflight` · `ashlr onboard` · `ashlr demo` |
+| **Local Weapon (v3)** | `ashlr run --engineer [--bash]` · `ashlr eval` · adaptive prompts (`models.adaptivePrompts`) |
 | **Maintain** | `ashlr update` |
 
 It is **local-first by design**. Index, config, runs, rollups, and memory all live under `~/.ashlr/`. Agent runs default to local models and refuse to touch a cloud endpoint unless you explicitly opt in. Telemetry is metadata-only; secrets flow through Phantom, never through the hub.
@@ -643,7 +644,7 @@ Runs stream progress live to stderr (task starts, model deltas, tool calls, retr
 | `ashlr run show <id>` | Print the full `RunState` for a past run. |
 | `ashlr runs [--json]` | List all past runs, newest first. |
 
-Key flags: `--budget N` · `--max-steps N` · `--parallel N` · `--engine builtin|ashlrcode|aw|claude` · `--stream / --no-stream` · `--allow-cloud` · `--no-memory` · `--no-capture` · `--resume <id>`.
+Key flags: `--budget N` · `--max-steps N` · `--parallel N` · `--engine builtin|ashlrcode|aw|claude` · `--engineer [--bash]` (sandboxed engineering tools → inbox; see [Local Weapon](#local-weapon-v3--make-local-models-genuinely-capable)) · `--stream / --no-stream` · `--allow-cloud` · `--no-memory` · `--no-capture` · `--resume <id>`.
 
 ```sh
 ashlr run "Summarize the last 5 commits and flag risky changes"
@@ -693,6 +694,61 @@ ashlr models start            # best-effort start of an installed-but-idle Ollam
 Local savings (est):  $0.42   |   Cloud would-have-been: $0.47   |   Projected 30d: $0.18
 ```
 
+### Local Weapon (v3) — make local models genuinely capable
+
+v3 is a focused push to close the quality gap between local models (Ollama / LM Studio) and the cloud, without ever leaving your machine. Four shipped pieces — all opt-in, all bounded.
+
+#### Adaptive prompts (M41)
+
+A model-adaptive, layered system-prompt suite. ashlr auto-detects a per-model profile from the model name (size band + coder/general/small) and tunes **prompt verbosity, ReAct step cap, and sampling temperature** to fit the model actually serving the task — a 1.5B chat model and a 32B coder get very different scaffolding. Off by default; opt-in.
+
+```sh
+ashlr config set models.adaptivePrompts true   # config opt-in (default: false)
+ASHLR_ADAPTIVE_PROMPTS=1 ashlr run "<goal>"     # env opt-in (overrides config)
+```
+
+With the flag off the harness uses its legacy prompts and step cap unchanged — the whole suite is additive and gated.
+
+#### Engineering tool surface (M42)
+
+Give the local agent **real, sandboxed engineering tools** — read / glob / grep / write / edit — confined to a throwaway git worktree. The agent never touches your live working tree: the resulting diff is routed to the Approval Inbox as a PENDING proposal, exactly like every other outward action.
+
+```sh
+ashlr run "<goal>" --engineer          # sandboxed read/glob/grep/write/edit → inbox
+ashlr run "<goal>" --engineer --bash   # also allow sandboxed command/test execution
+ashlr inbox                            # review the proposed diff; nothing applies until you approve
+```
+
+Requires the repo to be **enrolled** (`ashlr enroll add <repo>`) and the kill switch off. Off by default.
+
+**Security posture** (structurally enforced):
+
+- **Kill-switch gated** — every mutating tool is REFUSED when `~/.ashlr/KILL` is set; checked first, cannot be bypassed.
+- **Workspace-boundary + enrollment enforced** — writes resolve only inside the sandbox worktree of an enrolled repo; paths outside the boundary are refused.
+- **Secret-scrubbed output** — tool output is secret-scrubbed before it reaches the model or any store.
+- **Diffs to inbox, never the live tree** — `write`/`edit` produce a proposal; approval is human-only via `ashlr inbox approve` (there is no agent-reachable apply path).
+- **Double opt-in for bash** — `--bash` is local code execution and requires `--engineer` **and** `--bash` together; it too is kill-switch gated and confined to the sandbox.
+
+#### Verify→repair loop (M43)
+
+After each task the agent runs the repo's detected typecheck / test / lint commands and feeds any failures back into a bounded repair pass. This generalizes the prior single retry into a loop — bounded by `--max-steps` and the run budget, so it can never spin without limit. Tune the headroom via the run budget flags (`--budget` / `--max-steps`).
+
+#### Eval harness (M44)
+
+Measure the local-model uplift on your own machine. `ashlr eval` runs a fixed fixture set through the agent loop twice per fixture — adaptive prompts **OFF** then **ON** — and reports steps-to-done, done count, and tokens for each.
+
+```sh
+ashlr eval                       # full fixture set, table output
+ashlr eval --limit 3             # only the first 3 fixtures
+ashlr eval --budget 8000 --json  # per-run token budget; machine-readable output
+```
+
+Needs a local model running (Ollama / LM Studio). When none is reachable it **skips gracefully** — prints a hint and exits 0, never an error.
+
+#### Cross-platform
+
+ashlr runs on **macOS, Linux, and Windows**. The engineering tools resolve the platform shell at runtime (e.g. `cmd.exe` on Windows, so `npm.cmd` / `npx.cmd` shims resolve via `PATHEXT`), and the local-model providers (Ollama / LM Studio) are plain HTTP, so no platform-specific runtime is required.
+
 ### Observe
 
 ```sh
@@ -803,7 +859,8 @@ ashlr telemetry test     # emit a synthetic test span; reports ok/fail
 
 ## Requirements
 
-- **macOS** · **Node.js 22+** · `~/.local/bin` on your `PATH`
+- **macOS, Linux, or Windows** · **Node.js 22+** · `~/.local/bin` on your `PATH` (POSIX)
+- The engineering tools (M42) resolve the platform shell at runtime (`cmd.exe` on Windows); the local-model providers are HTTP-based, so no platform-specific runtime is required.
 - Optional: [Ollama](https://ollama.com) or [LM Studio](https://lmstudio.ai) for local agent runs; [`phantom`](https://github.com/nicholasgasior/phantom) for secrets management; [Raycast](https://raycast.com) for the extension.
 
 ---