docs(cli): fix loop init flag example

`micro loop init` writes an autonomous improvement loop into any repository —
the same planner/builder/triage loop that maintains go-micro, generalized:

- planner (loop-planner.yml): keeps a ranked queue in .github/loop/PRIORITIES.md
- builder (loop-builder.yml): builds the top open item as a single-concern PR,
  auto-merged on green CI
- triage (loop-triage.yml): turns CI failures into scoped fix issues

plus .github/loop/NORTH_STAR.md (direction) and PRIORITIES.md (queue).

The agent adapter is mention-based, not hardcoded to Codex: `--agent @codex`
(or any @mention agent that responds on an issue and can run gh), `--token-secret`,
`--branch`, `--ci-workflow`, and cron flags are the whole config-vs-core boundary.
Templates use << >> delimiters so GitHub Actions' own ${{ }} expressions pass
through untouched. `micro loop verify` checks the wiring and flags the two things
the CLI can't: the token secret and branch protection (the green-CI gate).

Built inside go-micro with the config/core split already drawn, so the workflows
can later be extracted to a standalone reusable-workflows repo without a rewrite.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01CmdEY7pYmV5zzwCjNJ4ykL

.github/loop/NORTH_STAR.md

@@ -1,32 +0,0 @@
-# North Star
-
-The direction the loop aligns every increment to. Depth lives in
-[`internal/docs/THESIS.md`](../../internal/docs/THESIS.md); this is the short,
-operative version the planner and builder read each run.
-
-## Mission
-
-Make building an **agent** as easy as building a **service**, on one runtime.
-Go Micro is a holistic agent harness and service framework encapsulating the
-lifecycle of **services → agents → workflows** — pluggable, progressive, and
-AI-native by default.
-
-## Right now — developer adoption
-
-The framework's depth is strong; the **on-ramp** is the gap. Weight the developer
-experience — a walkable first-agent tutorial, discoverable examples, docs
-wayfinding, install friction, debugging, the 0→1 and 0→hero path — **at least as
-highly as internal hardening**. A developer succeeding on their first agent
-matters more right now than another conformance/observability/interop increment.
-Do not let the queue fill entirely with internal depth work.
-
-## Guardrails
-
-- One concern per PR; small and reversible.
-- The gate is green CI (`go build`, `go test`, `golangci-lint`, `make harness`),
-  not human review — keep the suite strong; the loop is only as good as its evaluator.
-- **Off-limits without a human** (surface as notes, never auto-merge): breaking
-  public-API changes, brand/positioning/marketing copy, new dependencies,
-  architectural rewrites, product-default changes with broad behavioral impact.
-- Stay on `claude/*` / `codex/*` branches; base PRs on `master`. See
-  [`CODEX.md`](../../CODEX.md) and [`internal/docs/CONTINUOUS_IMPROVEMENT.md`](../../internal/docs/CONTINUOUS_IMPROVEMENT.md).

.github/loop/prompts/builder.md

@@ -1,14 +0,0 @@
-<!--
-The BUILDER prompt — go-micro's continuous-improvement increment. Editable
-policy; the workflow prepends the agent @mention and substitutes __ISSUE__
-before posting. Keep __ISSUE__ literal.
--->
-Run one continuous-improvement increment per `internal/docs/CONTINUOUS_IMPROVEMENT.md`, aligned to the North Star in `.github/loop/NORTH_STAR.md` (the services → agents → workflows lifecycle, with developer adoption as the current goal).
-
-PICK THE WORK FROM THE QUEUE: read `.github/loop/PRIORITIES.md` and take the highest-ranked item whose linked issue is still OPEN — that is your task, and its issue number is the one you close. If `PRIORITIES.md` is missing or every listed item's issue is already closed, fall back to the single highest-value roadmap / open-issue / improvement-radar item yourself.
-
-Implement it, and VERIFY `go build ./...`, `go test ./...`, and `golangci-lint run ./...`.
-
-Open the PR YOURSELF from the shell — do NOT use the make_pr tool (in this environment it only records metadata and never creates a PR). Create a uniquely-named branch under the `codex/` prefix: `git switch -c codex/increment-__ISSUE__`, then `git push -u origin codex/increment-__ISSUE__`, then `gh pr create --base master --label codex --title "<title>" --body "<body; include 'Closes #<the priority issue you built>' so it leaves the queue, and 'Closes #__ISSUE__' for this run's tracker>"`. Finally enable auto-merge so GitHub merges it once CI is green: `gh pr merge --squash --auto --delete-branch`.
-
-One concern per PR. Stay out of breaking public API and brand/positioning copy — surface those as notes for the human instead.

.github/loop/prompts/coherence.md

@@ -1,14 +0,0 @@
-<!--
-The COHERENCE prompt — go-micro's DevRel pass (public-surface coherence +
-CHANGELOG upkeep + changelog blog). Editable policy; the workflow prepends the
-agent @mention and substitutes __ISSUE__ before posting. Keep __ISSUE__ literal.
--->
-Act as DevRel for go-micro. Do these, in order.
-
-COHERENCE AUDIT. Audit the public surface — `README.md`, `internal/website/` (landing `index.html` + `docs/`), and the blog under `internal/website/blog/` — for coherence with the North Star in `.github/loop/NORTH_STAR.md` (an agent harness and service framework; the services → agents → workflows lifecycle). Look for: places where README / website / docs contradict each other, are stale, or describe behavior that has since changed (cross-check against the code and recently merged PRs); whether the README is crisp and leads with the harness positioning; and one to three genuinely blog-worthy items from recently shipped work.
-
-CHANGELOG UPKEEP (safe factual task — goes in the auto-merged PR). Keep `CHANGELOG.md` living, in Keep-a-Changelog format with newest content at the top under `## [Unreleased]`. Enumerate PRs merged to master since the last update (`gh pr list --state merged --base master --limit 60 --json number,title,mergedAt,labels`) and add a concise, user-facing entry for each genuine change not yet recorded under the right `### Added` / `### Changed` / `### Fixed` / `### Documentation` subheading — SKIP internal loop/CI/priorities-refresh churn. If a new `vX.Y.Z` tag was cut since the last run (`git fetch --tags --force`), rename `## [Unreleased]` to `## [X.Y.Z] - <Month YYYY>` and open a fresh empty `## [Unreleased]` above it. Do not invent entries.
-
-CHANGELOG BLOG POST (blog voice — do NOT auto-merge). If, and only if, enough user-facing work has accumulated since the last changelog post to be worth reading (roughly a week's worth; not a near-empty post every day), draft a short "What's new in Go Micro" post as the next-numbered file in `internal/website/blog/`, mirroring the latest post's frontmatter and prev-nav, and add an entry at the top of `internal/website/blog/index.html`. Base it strictly on the CHANGELOG.
-
-THEN: (A) post a findings report as a comment on this issue (#__ISSUE__) — what's aligned, what drifted, what you fixed, the CHANGELOG entries added, and whether you drafted a blog post (and why/why not). (B) Open ONE auto-merging PR for the SAFE factual work only — coherence/crispness fixes AND the CHANGELOG update (NOT brand/positioning rewrites, NOT the blog post): `git switch -c codex/coherence-__ISSUE__`, `git push -u origin codex/coherence-__ISSUE__`, `gh pr create --base master --label codex --title "<title>" --body "<summary, Closes #__ISSUE__>"`, then `gh pr merge --squash --auto --delete-branch`. (C) If you drafted a changelog blog post, open it as a SEPARATE PR (`codex/coherence-blog-__ISSUE__`, title prefixed `blog:`) and do NOT enable auto-merge — leave it for the human. Same for any brand/positioning copy. Do not use the make_pr tool.

.github/loop/prompts/planner.md

@@ -1,16 +0,0 @@
-<!--
-The PLANNER prompt — go-micro's "architect / founder lens". Editable policy;
-the workflow prepends the agent @mention and substitutes __ISSUE__ (this run's
-tracking issue) before posting. Keep __ISSUE__ literal.
--->
-Act as the architect — the founder lens — for go-micro, running continuously alongside the builders. Hold the whole picture: how the harness, the framework, and the developer UX fit together, what is in flight and what just merged, what to prioritize next, and what is missing or has drifted.
-
-(1) TRACK STATE — scan recently merged PRs and open `codex` PRs/issues to see what shipped and what is being built right now, so the queue reflects reality (drop done items, don't re-queue in-flight work).
-
-(2) ASSESS against the North Star in `.github/loop/NORTH_STAR.md` — lead with its Mission (*make building an agent as easy as building a service, on one runtime*) and re-derive alignment from the CANON: the blog under `internal/website/blog`, the `README`, and the website (read these, don't rely on the North Star alone), then `ROADMAP.md` (Now → Next → Later). Judge every priority against the mission: does it make the services → agents → workflows lifecycle simpler, more cohesive, and more operable? CURRENT GOAL — developer adoption: weight the on-ramp (walkable first-agent tutorial, discoverable examples, docs wayfinding, install friction, debugging, 0→1 and 0→hero) at least as highly as internal hardening; do not let the queue fill entirely with internal depth work. Look at coherence and seams across the core packages (agent, ai, flow, gateway/mcp, gateway/a2a, model, server, store, registry) and the dev inner loop (scaffold → run → chat → inspect → deploy). Flag drift in either direction: work drifting from the mission, or the North Star/website drifting from the lived story in the blog.
-
-(3) MAINTAIN THE QUEUE in `.github/loop/PRIORITIES.md` — a SINGLE ordered list, highest-value first, each item linking a scoped, CI-verifiable issue (#N); roadmap phase is the primary ordering, internal findings (cohesion gaps, DX friction, missing pieces) interleaved by value. For any prioritized gap with no issue, file one: `gh issue create --label codex --label enhancement --title "<scoped task>" --body "<goal, scope, acceptance criteria>"`.
-
-OUTPUT: post a concise assessment as a comment on this issue (#__ISSUE__) — what shipped, what's in flight, the top risks/gaps, and the reasoning behind the ranking. If the ranking actually changed, open ONE PR for `.github/loop/PRIORITIES.md`: `git switch -c codex/planner-__ISSUE__`, `git push -u origin codex/planner-__ISSUE__`, `gh pr create --base master --label codex --title "<title>" --body "<summary, Closes #__ISSUE__>"`, then `gh pr merge --squash --auto --delete-branch`. If the queue is already accurate, just close this issue (`gh issue close __ISSUE__`).
-
-Do NOT make breaking public-API or architectural changes yourself — surface those in the assessment as notes for the human, never as auto-merged changes. Open the PR yourself from the shell with `gh`; do not use the make_pr tool (it is a no-op stub).

.github/loop/prompts/triage.md

@@ -1,14 +0,0 @@
-<!--
-The TRIAGE prompt — go-micro's harness-failure feedback path. Editable policy;
-the workflow prepends the agent @mention and substitutes __ISSUE__ (this
-tracking issue) and __RUNURL__ (the failed run) before posting. Keep both literal.
--->
-Triage the failed provider-conformance harness run at __RUNURL__.
-
-Read the logs and root-cause each distinct failure. DEDUPE against open issues — if a failure matches an existing issue, comment "recurred" there instead of filing a duplicate.
-
-For each genuine, self-contained defect, file a scoped issue (`gh issue create --label codex --label enhancement --title "<scoped fix>" --body "<root cause, where, acceptance criteria>"`) so the increment loop builds it and the next harness run verifies it.
-
-IGNORE transient flakes — live-model latency, provider outages, rate limits, timeouts with no code cause. Anything needing a breaking or architectural change: file it as `needs-human` and describe it, rather than auto-queuing it as a routine fix.
-
-Close this issue (`gh issue close __ISSUE__`) when triage is done. Open any PR yourself from the shell with `gh`; do not use the make_pr tool.

.github/workflows/loop-architect.yml

@@ -0,0 +1,51 @@
+name: "Loop: Architect (Planner)"
+
+# Continuous high-altitude oversight of the whole framework and harness — the
+# "founder lens" of the autonomous loop (internal/docs/CONTINUOUS_IMPROVEMENT.md).
+# Where DevRel watches the public story and the increment loop ships code, the
+# architect watches the SYSTEM and runs alongside the builders: it tracks what is
+# in flight and what just merged, keeps the roadmap priorities live, and judges
+# cohesion (harness <-> framework <-> dev UX), missing pieces, and realignment.
+#
+# Its OUTPUT is the ranked queue in internal/docs/PRIORITIES.md plus an assessment
+# — NOT large refactors. Breaking public-API and architectural changes stay with
+# the human (see CONTINUOUS_IMPROVEMENT.md).
+#
+# Runs hourly, offset before the increment loop (:29) so it re-prioritizes and
+# THEN the loop builds the new top of the queue. Opens a fresh issue and
+# dispatches Codex via CODEX_TRIGGER_TOKEN.
+
+on:
+  workflow_dispatch: {}
+  schedule:
+    - cron: "59 * * * *" # hourly at :59, just before the :29 increment run (tunable)
+
+permissions:
+  issues: write
+
+concurrency:
+  group: architecture-review
+  cancel-in-progress: false
+
+jobs:
+  dispatch:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Open an architecture review issue and dispatch Codex
+        env:
+          GH_TOKEN: ${{ secrets.CODEX_TRIGGER_TOKEN || github.token }}
+          HAS_TRIGGER_TOKEN: ${{ secrets.CODEX_TRIGGER_TOKEN != '' }}
+          REPO: ${{ github.repository }}
+          RUN_NUMBER: ${{ github.run_number }}
+        run: |
+          if [ "$HAS_TRIGGER_TOKEN" != "true" ]; then
+            echo "CODEX_TRIGGER_TOKEN is not set — skipping (Codex ignores Actions-bot comments)."
+            exit 0
+          fi
+          ISSUE_URL=$(gh issue create --repo "$REPO" \
+            --title "Architecture review #$RUN_NUMBER" \
+            --body "Continuous architecture / harness oversight against the North Star in internal/docs/THESIS.md. Output: a re-ranked internal/docs/PRIORITIES.md (only if it changed) plus an assessment.")
+          ISSUE_NUM="${ISSUE_URL##*/}"
+          echo "Opened issue #$ISSUE_NUM — dispatching Codex (Architect)."
+          gh issue comment "$ISSUE_NUM" --repo "$REPO" --body \
+          "@codex Act as the architect — the founder lens — for go-micro, running continuously alongside the builders. Hold the whole picture: how the harness, the framework, and the developer UX fit together cohesively, what is in flight and what just merged, what to prioritize next on the roadmap, and what is missing or has drifted. Each run: (1) TRACK STATE — scan recently merged PRs and open codex PRs/issues to see what shipped and what is being built right now, so the queue reflects reality (drop done items, don't re-queue in-flight work). (2) ASSESS against the North Star in internal/docs/THESIS.md — lead with its Mission (*the problem we solve: make building an agent as easy as building a service, on one runtime*) and re-derive alignment from the CANON it names (the blog under internal/website/blog, the README, and the website — read these, don't rely on THESIS.md alone), then ROADMAP.md (Now → Next → Later). Judge every priority against the mission: does it make the services → agents → workflows lifecycle simpler, more cohesive, and more operable? CURRENT GOAL — DEVELOPER ADOPTION: the framework's depth is strong but its ON-RAMP is the gap, and the strategic priority right now is developer adoption / reviving real usage. Weight the developer on-ramp and DX — a walkable first-agent tutorial, discoverable examples, docs wayfinding/nav, install friction, debugging, the 0→1 and 0→hero experience — AT LEAST as highly as internal hardening. A developer succeeding on their first agent matters more right now than another conformance/observability/interop increment; do NOT let the queue fill entirely with internal depth work — keep open adoption/on-ramp items near the top. Look at coherence and seams across the core packages (agent, ai, flow, gateway/mcp, gateway/a2a, model, server, store, registry), the dev inner loop (scaffold → run → chat → inspect → deploy), missing pieces, duplication/drift, and realignment. Flag drift in EITHER direction: work drifting from the mission, or the North Star/website drifting from the lived story in the blog (which needs re-grounding in the canon). (3) MAINTAIN THE QUEUE in internal/docs/PRIORITIES.md — a SINGLE ordered list, highest-value first, each item linking a scoped CI-verifiable issue (#N); roadmap phase is the primary ordering, internal findings (cohesion gaps, DX friction, missing pieces) interleaved by value. For any prioritized gap that has no issue yet, file one: \`gh issue create --label codex --label enhancement --title \"<scoped task>\" --body \"<goal, scope, acceptance criteria>\"\`. OUTPUT: post a concise assessment as a comment on this issue (#$ISSUE_NUM) — what shipped, what's in flight, the top risks/gaps/missing pieces, and the reasoning behind the ranking. If the ranking actually changed, open ONE PR for PRIORITIES.md: \`git switch -c codex/architect-$ISSUE_NUM\`, \`git push -u origin codex/architect-$ISSUE_NUM\`, \`gh pr create --base master --label codex --title \"<title>\" --body \"<summary, Closes #$ISSUE_NUM>\"\`, then \`gh pr merge --squash --auto --delete-branch\`. If the queue is already accurate and correctly ranked, do NOT open a PR — just close this issue (\`gh issue close $ISSUE_NUM\`). Do NOT make breaking public-API or architectural changes yourself — surface those in the assessment as notes for the human, never as auto-merged changes. Do not use the make_pr tool (it is a no-op stub)."

.github/workflows/loop-builder.yml

@@ -1,60 +1,65 @@
-name: "Loop: Builder"
+name: "Loop: Builder (Generator)"
 
-# Generated by `micro loop init`. A dispatch role of the autonomous loop: on a
-# cadence it opens a fresh tracking issue and posts the instruction in
-# .github/loop/prompts/builder.md to the agent (@codex).
+# Durable backbone for the autonomous improvement loop
+# (see internal/docs/CONTINUOUS_IMPROVEMENT.md).
 #
-# The workflow is the MECHANISM; that prompt file is the editable POLICY —
-# change what this role does by editing the prompt, not this YAML. A FRESH
-# issue per run is deliberate: agents derive the PR branch name from the
-# triggering issue, so reusing one tracker collapses every run onto one branch.
+# A Claude Max subscription provides no API key for CI, so the loop is driven by
+# Codex rather than Claude Code: on a cadence this opens a fresh tracking issue and
+# posts an @codex instruction on it, and Codex runs one improvement increment, opens
+# a PR (git push + gh pr create — the make_pr tool is a no-op stub), and enables
+# GitHub auto-merge (gh pr merge --auto) so the PR lands once the required CI checks
+# pass. No separate merge sweep — branch protection + native auto-merge is the gate.
+# (See the per-issue rationale below.)
 #
-# Gated on CODEX_TRIGGER_TOKEN: the agent ignores @mentions from the
-# github-actions bot, so dispatch posts as a real user (a PAT). No token → no-op.
+# Codex does NOT respond to comments authored by the github-actions bot, so the
+# dispatch is GATED on a CODEX_TRIGGER_TOKEN secret (a PAT for a user account Codex
+# follows). Until that secret is set the workflow runs but no-ops — this avoids
+# piling up @codex comments that Codex silently ignores. The moment the secret is
+# added the loop activates with no further change.
+#
+# Each run opens a FRESH issue and dispatches Codex there, rather than re-commenting
+# on one tracker issue. Codex derives its PR branch name from the triggering issue's
+# context, so repeated dispatches on a single issue all collapse onto one branch name
+# (codex/github-mention-<that-issue-slug>) — the first increment opens a PR, the rest
+# collide on the occupied branch and silently fail to open one. A unique issue per
+# run gives each increment its own branch and a clean PR. The dispatch asks Codex to
+# "Closes #<issue>" so each tracking issue auto-closes when its PR merges.
 
 on:
   workflow_dispatch: {}
   schedule:
-    - cron: "29 * * * *"
+    - cron: "29 * * * *" # hourly, off-minute (tune as needed)
 
 permissions:
   issues: write
 
 concurrency:
-  group: loop-builder
+  group: continuous-improvement
   cancel-in-progress: false
 
 jobs:
   dispatch:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4 # needed to read the prompt file
-      - name: Dispatch builder
+      - name: Open a fresh increment issue and dispatch Codex
         env:
           GH_TOKEN: ${{ secrets.CODEX_TRIGGER_TOKEN || github.token }}
-          HAS_TOKEN: ${{ secrets.CODEX_TRIGGER_TOKEN != '' }}
+          HAS_TRIGGER_TOKEN: ${{ secrets.CODEX_TRIGGER_TOKEN != '' }}
           REPO: ${{ github.repository }}
           RUN_NUMBER: ${{ github.run_number }}
         run: |
-          if [ "$HAS_TOKEN" != "true" ]; then
-            echo "CODEX_TRIGGER_TOKEN is not set — skipping (the agent ignores bot @mentions)."
+          if [ "$HAS_TRIGGER_TOKEN" != "true" ]; then
+            echo "CODEX_TRIGGER_TOKEN is not set — skipping dispatch."
+            echo "Codex ignores comments from the github-actions bot, so posting now"
+            echo "would only create noise. Add a CODEX_TRIGGER_TOKEN secret (a PAT for"
+            echo "a user account Codex follows) to activate the loop."
             exit 0
           fi
-          PROMPT=".github/loop/prompts/builder.md"
-          if [ ! -f "$PROMPT" ]; then
-            echo "missing $PROMPT — run 'micro loop init'." >&2
-            exit 1
-          fi
+          # A unique issue per run → unique codex/ branch → no collisions.
           ISSUE_URL=$(gh issue create --repo "$REPO" \
-            --title "Loop: build increment #$RUN_NUMBER" \
-            --body "Autonomous builder pass. Direction: .github/loop/NORTH_STAR.md; queue: .github/loop/PRIORITIES.md.")
+            --title "Continuous improvement increment #$RUN_NUMBER" \
+            --body "Autonomous continuous-improvement increment. North Star: internal/docs/THESIS.md; charter: internal/docs/CONTINUOUS_IMPROVEMENT.md. Tracker: #3024.")
           ISSUE_NUM="${ISSUE_URL##*/}"
-          echo "Opened issue #$ISSUE_NUM — dispatching builder."
-          # The prompt file is the policy; strip its editorial <!-- --> header and
-          # substitute the tracking issue number (__ISSUE__) at runtime.
-          {
-            echo "@codex"
-            echo
-            sed -e '/<!--/,/-->/d' -e "s/__ISSUE__/$ISSUE_NUM/g" "$PROMPT"
-          } > "$RUNNER_TEMP/loop-body.md"
-          gh issue comment "$ISSUE_NUM" --repo "$REPO" --body-file "$RUNNER_TEMP/loop-body.md"
+          echo "Opened issue #$ISSUE_NUM — dispatching Codex."
+          gh issue comment "$ISSUE_NUM" --repo "$REPO" --body \
+          "@codex Run one continuous-improvement increment per internal/docs/CONTINUOUS_IMPROVEMENT.md, aligned to the North Star in internal/docs/THESIS.md (the holistic services → agents → workflows lifecycle). PICK THE WORK FROM THE QUEUE: read internal/docs/PRIORITIES.md and take the highest-ranked item whose linked issue is still OPEN — that is your task, and its issue number is the one you close. (If PRIORITIES.md is missing or every listed item's issue is already closed, fall back to picking the single highest-value roadmap/issue/improvement-radar item yourself.) Implement it, and verify \`go build ./...\`, \`go test ./...\`, and \`golangci-lint run ./...\`. Then open the PR YOURSELF from the shell — do NOT use the make_pr tool (in this environment it only records metadata and never creates a PR). Create a uniquely-named branch under the codex/ prefix and open the PR from it: \`git switch -c codex/increment-$ISSUE_NUM\`, then \`git push -u origin codex/increment-$ISSUE_NUM\`, then \`gh pr create --base master --label codex --title \"<title>\" --body \"<body; include 'Closes #<the priority issue you built>' so it leaves the queue, and 'Closes #$ISSUE_NUM' for this run's tracker>\"\`. Finally enable auto-merge so GitHub merges it once CI is green: \`gh pr merge --squash --auto --delete-branch\`. The gh CLI is installed and authenticated and origin points to $REPO. One concern per PR; stay out of brand/positioning copy and breaking public API."

.github/workflows/loop-coherence.yml

@@ -1,60 +0,0 @@
-name: "Loop: Coherence"
-
-# Generated by `micro loop init`. A dispatch role of the autonomous loop: on a
-# cadence it opens a fresh tracking issue and posts the instruction in
-# .github/loop/prompts/coherence.md to the agent (@codex).
-#
-# The workflow is the MECHANISM; that prompt file is the editable POLICY —
-# change what this role does by editing the prompt, not this YAML. A FRESH
-# issue per run is deliberate: agents derive the PR branch name from the
-# triggering issue, so reusing one tracker collapses every run onto one branch.
-#
-# Gated on CODEX_TRIGGER_TOKEN: the agent ignores @mentions from the
-# github-actions bot, so dispatch posts as a real user (a PAT). No token → no-op.
-
-on:
-  workflow_dispatch: {}
-  schedule:
-    - cron: "0 7 * * *"
-
-permissions:
-  issues: write
-
-concurrency:
-  group: loop-coherence
-  cancel-in-progress: false
-
-jobs:
-  dispatch:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4 # needed to read the prompt file
-      - name: Dispatch coherence
-        env:
-          GH_TOKEN: ${{ secrets.CODEX_TRIGGER_TOKEN || github.token }}
-          HAS_TOKEN: ${{ secrets.CODEX_TRIGGER_TOKEN != '' }}
-          REPO: ${{ github.repository }}
-          RUN_NUMBER: ${{ github.run_number }}
-        run: |
-          if [ "$HAS_TOKEN" != "true" ]; then
-            echo "CODEX_TRIGGER_TOKEN is not set — skipping (the agent ignores bot @mentions)."
-            exit 0
-          fi
-          PROMPT=".github/loop/prompts/coherence.md"
-          if [ ! -f "$PROMPT" ]; then
-            echo "missing $PROMPT — run 'micro loop init'." >&2
-            exit 1
-          fi
-          ISSUE_URL=$(gh issue create --repo "$REPO" \
-            --title "Loop: coherence review #$RUN_NUMBER" \
-            --body "Autonomous coherence pass. Direction: .github/loop/NORTH_STAR.md; queue: .github/loop/PRIORITIES.md.")
-          ISSUE_NUM="${ISSUE_URL##*/}"
-          echo "Opened issue #$ISSUE_NUM — dispatching coherence."
-          # The prompt file is the policy; strip its editorial <!-- --> header and
-          # substitute the tracking issue number (__ISSUE__) at runtime.
-          {
-            echo "@codex"
-            echo
-            sed -e '/<!--/,/-->/d' -e "s/__ISSUE__/$ISSUE_NUM/g" "$PROMPT"
-          } > "$RUNNER_TEMP/loop-body.md"
-          gh issue comment "$ISSUE_NUM" --repo "$REPO" --body-file "$RUNNER_TEMP/loop-body.md"

.github/workflows/loop-devrel.yml

@@ -0,0 +1,61 @@
+name: "Loop: DevRel"
+
+# Daily higher-altitude coherence pass over the PUBLIC surface — README,
+# website (landing + docs), and blog — part of the autonomous loop
+# (internal/docs/CONTINUOUS_IMPROVEMENT.md). The hourly increment loop ships
+# code; this keeps the story coherent: docs/website aligned, README crisp, and
+# a steady supply of things worth blogging about.
+#
+# It also keeps the CHANGELOG living: each run reconciles the `[Unreleased]`
+# section of CHANGELOG.md against what actually merged (rolling it into a dated
+# version heading whenever a new tag was cut), and — when enough has shipped —
+# drafts a "what's new" changelog blog post narrating it.
+#
+# Like the increment loop it opens a fresh issue and dispatches Codex via
+# CODEX_TRIGGER_TOKEN (Codex ignores Actions-bot comments). Autonomy boundary:
+# SAFE factual-alignment and crispness fixes — including CHANGELOG.md upkeep —
+# auto-merge; brand/positioning copy and the changelog blog post are opened as a
+# PR but left for the human to review/merge (blog voice stays with the human).
+
+on:
+  workflow_dispatch: {}
+  schedule:
+    - cron: "0 7 * * *" # daily, 07:00 UTC (tunable)
+
+permissions:
+  issues: write
+
+concurrency:
+  group: devrel-review
+  cancel-in-progress: false
+
+jobs:
+  dispatch:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Open a DevRel review issue and dispatch Codex
+        env:
+          GH_TOKEN: ${{ secrets.CODEX_TRIGGER_TOKEN || github.token }}
+          HAS_TRIGGER_TOKEN: ${{ secrets.CODEX_TRIGGER_TOKEN != '' }}
+          REPO: ${{ github.repository }}
+          RUN_NUMBER: ${{ github.run_number }}
+        run: |
+          if [ "$HAS_TRIGGER_TOKEN" != "true" ]; then
+            echo "CODEX_TRIGGER_TOKEN is not set — skipping (Codex ignores Actions-bot comments)."
+            exit 0
+          fi
+          ISSUE_URL=$(gh issue create --repo "$REPO" \
+            --title "DevRel coherence review #$RUN_NUMBER" \
+            --body "Daily DevRel / coherence pass over README, website (landing + docs), and the blog, plus CHANGELOG.md upkeep and a changelog blog post. North Star: internal/docs/THESIS.md.")
+          ISSUE_NUM="${ISSUE_URL##*/}"
+          echo "Opened issue #$ISSUE_NUM — dispatching Codex (DevRel)."
+          gh issue comment "$ISSUE_NUM" --repo "$REPO" --body \
+          "@codex Act as DevRel for go-micro. Do FOUR things this run.
+
+          COHERENCE AUDIT. Audit the PUBLIC surface — \`README.md\`, \`internal/website/\` (landing \`index.html\` + \`docs/\`), and the blog under \`internal/website/blog/\` — for coherence with the North Star in internal/docs/THESIS.md (an agent harness and service framework; the services → agents → workflows lifecycle). Look for: (1) places where README / website / docs contradict each other, are stale, or describe behavior that has since changed (cross-check against the code and recent merged PRs); (2) whether the README is crisp and leads with the harness positioning; (3) one to three genuinely blog-worthy items from recently shipped work.
+
+          CHANGELOG UPKEEP (this is a SAFE factual task — it goes in the auto-merged PR). Keep CHANGELOG.md living, in [Keep a Changelog](https://keepachangelog.com/) format with the newest content at the top under \`## [Unreleased]\`. (a) Enumerate PRs merged to master since the last CHANGELOG update — \`gh pr list --repo $REPO --state merged --base master --limit 60 --json number,title,mergedAt,labels\` — and compare against what CHANGELOG.md already lists. (b) For each genuinely user-facing change not yet recorded (new capability, behavior/API change, notable fix — SKIP purely internal loop/CI/priorities-refresh churn), add a concise entry under the right \`### Added\` / \`### Changed\` / \`### Fixed\` / \`### Documentation\` subheading of \`## [Unreleased]\`, phrased for a user (what it does, which package), not a commit subject. (c) If a new \`v6.MINOR.PATCH\` tag has been cut since the last run (\`git fetch --tags --force\`; compare the newest \`v6.*\` tag to the versions already in CHANGELOG.md), RENAME the current \`## [Unreleased]\` heading to \`## [MINOR.PATCH] - <Month YYYY>\` for that tag and open a fresh empty \`## [Unreleased]\` above it. Keep it accurate — do not invent entries; if nothing user-facing merged, leave [Unreleased] as-is.
+
+          CHANGELOG BLOG POST (blog voice — open a PR but do NOT auto-merge; leave it for the human). If — and only if — enough user-facing work has accumulated since the last changelog post to be worth reading (a meaningful batch, roughly a week's worth; do NOT post an almost-empty update every day), draft a short 'What's new in Go Micro' post that narrates what shipped in plain language (grouped by theme, linking the docs/examples, closing with install/upgrade). Create it as the next-numbered file in \`internal/website/blog/\` (find the highest N, use N+1), mirroring the frontmatter (layout/title/permalink/description) and the post-nav 'previous post' link of the latest existing post, and add an entry at the TOP of \`internal/website/blog/index.html\`. Base it strictly on the CHANGELOG — no speculation.
+
+          THEN do all of these: (A) post a concise findings report as a comment on this issue (#$ISSUE_NUM) — what is aligned, what drifted, what you fixed, the CHANGELOG entries you added, whether you drafted a changelog post (and why / why not), and any other blog ideas. (B) Open ONE auto-merging PR for the SAFE factual work only — coherence/crispness fixes AND the CHANGELOG.md update (NOT brand/marketing/positioning rewrites, NOT the blog post): \`git switch -c codex/devrel-$ISSUE_NUM\`, \`git push -u origin codex/devrel-$ISSUE_NUM\`, \`gh pr create --base master --label codex --title \"<title>\" --body \"<summary, including 'Closes #$ISSUE_NUM'>\"\`, then \`gh pr merge --squash --auto --delete-branch\`. (C) If you drafted a changelog blog post, open it as a SEPARATE PR on its own branch (\`codex/devrel-blog-$ISSUE_NUM\`) with a title prefixed 'blog:' and do NOT enable auto-merge — leave it open for the human to review and merge. Do the same (separate, non-auto-merged PR or just a report note) for any brand/positioning copy. Do not use the make_pr tool (it is a no-op stub). If you touch code, verify go build/test/golangci-lint. Stay out of breaking public-API changes."

.github/workflows/loop-planner.yml

@@ -1,60 +0,0 @@
-name: "Loop: Planner"
-
-# Generated by `micro loop init`. A dispatch role of the autonomous loop: on a
-# cadence it opens a fresh tracking issue and posts the instruction in
-# .github/loop/prompts/planner.md to the agent (@codex).
-#
-# The workflow is the MECHANISM; that prompt file is the editable POLICY —
-# change what this role does by editing the prompt, not this YAML. A FRESH
-# issue per run is deliberate: agents derive the PR branch name from the
-# triggering issue, so reusing one tracker collapses every run onto one branch.
-#
-# Gated on CODEX_TRIGGER_TOKEN: the agent ignores @mentions from the
-# github-actions bot, so dispatch posts as a real user (a PAT). No token → no-op.
-
-on:
-  workflow_dispatch: {}
-  schedule:
-    - cron: "59 * * * *"
-
-permissions:
-  issues: write
-
-concurrency:
-  group: loop-planner
-  cancel-in-progress: false
-
-jobs:
-  dispatch:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4 # needed to read the prompt file
-      - name: Dispatch planner
-        env:
-          GH_TOKEN: ${{ secrets.CODEX_TRIGGER_TOKEN || github.token }}
-          HAS_TOKEN: ${{ secrets.CODEX_TRIGGER_TOKEN != '' }}
-          REPO: ${{ github.repository }}
-          RUN_NUMBER: ${{ github.run_number }}
-        run: |
-          if [ "$HAS_TOKEN" != "true" ]; then
-            echo "CODEX_TRIGGER_TOKEN is not set — skipping (the agent ignores bot @mentions)."
-            exit 0
-          fi
-          PROMPT=".github/loop/prompts/planner.md"
-          if [ ! -f "$PROMPT" ]; then
-            echo "missing $PROMPT — run 'micro loop init'." >&2
-            exit 1
-          fi
-          ISSUE_URL=$(gh issue create --repo "$REPO" \
-            --title "Loop: planning review #$RUN_NUMBER" \
-            --body "Autonomous planner pass. Direction: .github/loop/NORTH_STAR.md; queue: .github/loop/PRIORITIES.md.")
-          ISSUE_NUM="${ISSUE_URL##*/}"
-          echo "Opened issue #$ISSUE_NUM — dispatching planner."
-          # The prompt file is the policy; strip its editorial <!-- --> header and
-          # substitute the tracking issue number (__ISSUE__) at runtime.
-          {
-            echo "@codex"
-            echo
-            sed -e '/<!--/,/-->/d' -e "s/__ISSUE__/$ISSUE_NUM/g" "$PROMPT"
-          } > "$RUNNER_TEMP/loop-body.md"
-          gh issue comment "$ISSUE_NUM" --repo "$REPO" --body-file "$RUNNER_TEMP/loop-body.md"

.github/workflows/loop-release.yml

@@ -1,17 +1,19 @@
-name: "Loop: Release"
+name: "Loop: Release (daily patch)"
 
-# Generated by `micro loop init`. Cuts the next PATCH tag
-# (vMAJOR.MINOR.PATCH+1) when the default branch has new commits
-# since the latest such tag, and pushes it with a PAT (CODEX_TRIGGER_TOKEN) so any
-# tag-triggered release workflow fires. Minor/major bumps stay with a human.
+# Keeps the installable framework tracking the loop's daily improvements. Once a
+# day, if master has new commits since the latest v6 tag, this cuts the next
+# PATCH release (v6.MINOR.PATCH+1) and pushes the tag — which triggers the
+# existing goreleaser workflow (release.yml, tag-triggered) to build the release,
+# binaries, and images.
 #
-# The tag MUST be pushed with a PAT, not the default GITHUB_TOKEN: a tag pushed
-# by GITHUB_TOKEN does not trigger other workflows (Actions blocks that recursion).
+# The tag is pushed with a PAT (CODEX_TRIGGER_TOKEN), NOT the default GITHUB_TOKEN:
+# a tag pushed by GITHUB_TOKEN would not trigger release.yml (Actions blocks that
+# recursion). Minor/major bumps stay with the human (notable / breaking releases).
 
 on:
   workflow_dispatch: {}
   schedule:
-    - cron: "0 23 * * *"
+    - cron: "0 23 * * *" # daily 23:00 UTC — captures the day's merges (tunable)
 
 permissions:
   contents: read
@@ -27,41 +29,47 @@ jobs:
       - uses: actions/checkout@v4
         with:
           fetch-depth: 0 # need full history + all tags
-          # Do NOT persist the default GITHUB_TOKEN as a git credential: it would
-          # be sent on the PAT push below and override it, so the tag push would
-          # authenticate as github-actions[bot] and 403. Letting the PAT in the
-          # push URL be the only credential is the whole point.
+          # Do NOT persist the default GITHUB_TOKEN as a git credential.
+          # actions/checkout otherwise sets an http.extraheader Authorization
+          # for github.com that is sent on ALL pushes — including our manual
+          # PAT push below — and overrides the PAT, so the tag push
+          # authenticates as github-actions[bot] and 403s (the job only has
+          # contents: read). With this off, the PAT embedded in the push URL
+          # is the only credential. (Fixes run 28554612450.)
           persist-credentials: false
-      - name: Cut the next patch tag if there are new commits
+      - name: Cut the next patch release if there are new commits
         env:
           RELEASE_TOKEN: ${{ secrets.CODEX_TRIGGER_TOKEN }}
           REPO: ${{ github.repository }}
         run: |
           if [ -z "$RELEASE_TOKEN" ]; then
             echo "CODEX_TRIGGER_TOKEN is not set — skipping."
+            echo "A tag pushed by the default GITHUB_TOKEN would not trigger the"
+            echo "goreleaser workflow, so a user PAT is required to cut releases."
             exit 0
           fi
           git fetch --tags --force
 
-          LATEST=$(git tag --list 'v*.*.*' --sort=-v:refname | head -1)
+          LATEST=$(git tag --list 'v6.*.*' --sort=-v:refname | head -1)
           if [ -z "$LATEST" ]; then
-            echo "no vMAJOR.MINOR.PATCH tag found — aborting so nothing weird gets tagged."
+            echo "no v6.x.x tag found — aborting so nothing weird gets tagged."
             exit 1
           fi
-          echo "latest tag: $LATEST"
+          echo "latest release tag: $LATEST"
 
           COUNT=$(git rev-list --count "$LATEST"..HEAD)
-          echo "commits since $LATEST: $COUNT"
+          echo "commits on HEAD since $LATEST: $COUNT"
           if [ "$COUNT" -eq 0 ]; then
-            echo "no new commits since $LATEST — no release."
+            echo "no new commits since $LATEST — no release today."
             exit 0
           fi
 
-          ver="${LATEST#v}"
-          major="${ver%%.*}"
-          rest="${ver#*.}"
-          minor="${rest%%.*}"
-          patch="${rest#*.}"
+          # Bump the patch: v6.MINOR.PATCH -> v6.MINOR.(PATCH+1)
+          ver="${LATEST#v}"          # 6.3.10
+          major="${ver%%.*}"         # 6
+          rest="${ver#*.}"           # 3.10
+          minor="${rest%%.*}"        # 3
+          patch="${rest#*.}"         # 10
           case "$major.$minor.$patch" in
             [0-9]*.[0-9]*.[0-9]*) ;;
             *) echo "unexpected tag shape: $LATEST" ; exit 1 ;;
@@ -69,8 +77,8 @@ jobs:
           NEXT="v${major}.${minor}.$((patch + 1))"
           echo "cutting: $NEXT ($COUNT commits since $LATEST)"
 
-          git config user.name "loop release bot"
-          git config user.email "noreply@users.noreply.github.com"
-          git tag -a "$NEXT" -m "Release $NEXT — automated patch ($COUNT commits since $LATEST)"
+          git config user.name "go-micro release bot"
+          git config user.email "noreply@go-micro.dev"
+          git tag -a "$NEXT" -m "Release $NEXT — automated daily patch ($COUNT commits since $LATEST)"
           git push "https://x-access-token:${RELEASE_TOKEN}@github.com/${REPO}.git" "$NEXT"
-          echo "Pushed $NEXT."
+          echo "Pushed $NEXT. goreleaser (release.yml) will build and publish it."

.github/workflows/loop-triage.yml

@@ -1,10 +1,19 @@
-name: "Loop: Triage"
+name: "Loop: Triage (Evaluator feedback)"
 
-# Generated by `micro loop init`. The feedback path of the evaluator: when the
-# CI workflow ("Harness (E2E)") fails on a non-PR run, dispatch the agent
-# (@codex) with the instruction in .github/loop/prompts/triage.md
-# to root-cause the failure and file scoped fix issues back into the queue — so
-# failures become fixes with no human in the middle. Gated on CODEX_TRIGGER_TOKEN.
+# Closes the autonomous loop's feedback path: when the live provider-conformance
+# harness fails, dispatch Codex to TRIAGE the failing run and file scoped, deduped
+# issues that the hourly increment loop then fixes — no human in the middle. It
+# only triages the scheduled/manual live run (not every push/PR mock run), dedupes
+# against open issues so hourly repeats don't spam, ignores transient flakes, and
+# ESCALATES anything needing a breaking/architectural change as needs-human rather
+# than auto-building it.
+#
+# Gated on CODEX_TRIGGER_TOKEN like the rest of the loop (Codex ignores comments
+# authored by the github-actions bot).
+#
+# Note: Codex is serial, so this competes with the hourly increment + architect
+# dispatches for the single task slot. If it saturates, lower the harness cadence
+# or gate this to a slower schedule.
 
 on:
   workflow_run:
@@ -15,42 +24,36 @@ permissions:
   issues: write
 
 concurrency:
-  group: loop-triage
+  group: harness-triage
   cancel-in-progress: false
 
 jobs:
   triage:
-    # Only real failures on branch pushes/schedules — not PR-run failures, which
-    # the PR author already sees.
-    if: ${{ github.event.workflow_run.conclusion == 'failure' && github.event.workflow_run.event != 'pull_request' }}
     runs-on: ubuntu-latest
+    # Only when the harness actually failed, and only for the scheduled or manual
+    # live run — never the per-push/PR mock run.
+    if: github.event.workflow_run.conclusion == 'failure' && (github.event.workflow_run.event == 'schedule' || github.event.workflow_run.event == 'workflow_dispatch')
     steps:
-      - uses: actions/checkout@v4 # needed to read the prompt file
-      - name: Dispatch triage
+      - name: Open a triage issue and dispatch Codex
         env:
           GH_TOKEN: ${{ secrets.CODEX_TRIGGER_TOKEN || github.token }}
-          HAS_TOKEN: ${{ secrets.CODEX_TRIGGER_TOKEN != '' }}
+          HAS_TRIGGER_TOKEN: ${{ secrets.CODEX_TRIGGER_TOKEN != '' }}
           REPO: ${{ github.repository }}
           RUN_ID: ${{ github.event.workflow_run.id }}
           RUN_URL: ${{ github.event.workflow_run.html_url }}
         run: |
-          if [ "$HAS_TOKEN" != "true" ]; then
-            echo "CODEX_TRIGGER_TOKEN is not set — skipping."
+          if [ "$HAS_TRIGGER_TOKEN" != "true" ]; then
+            echo "CODEX_TRIGGER_TOKEN is not set — skipping (Codex ignores Actions-bot comments)."
             exit 0
           fi
-          PROMPT=".github/loop/prompts/triage.md"
-          if [ ! -f "$PROMPT" ]; then
-            echo "missing $PROMPT — run 'micro loop init'." >&2
-            exit 1
-          fi
+          # Ensure the escalation label exists (idempotent).
+          gh label create needs-human --repo "$REPO" --color FBCA04 \
+            --description "Requires a human/architect decision (breaking or architectural)" --force || true
+
           ISSUE_URL=$(gh issue create --repo "$REPO" \
-            --title "Loop: triage failed run $RUN_ID" \
-            --body "The 'Harness (E2E)' workflow failed: $RUN_URL")
+            --title "Harness failure triage: run $RUN_ID" \
+            --body "Automated triage of a failed live provider-conformance harness run: $RUN_URL")
           ISSUE_NUM="${ISSUE_URL##*/}"
-          echo "Opened issue #$ISSUE_NUM — dispatching triage."
-          {
-            echo "@codex"
-            echo
-            sed -e '/<!--/,/-->/d' -e "s/__ISSUE__/$ISSUE_NUM/g" -e "s#__RUNURL__#$RUN_URL#g" "$PROMPT"
-          } > "$RUNNER_TEMP/loop-body.md"
-          gh issue comment "$ISSUE_NUM" --repo "$REPO" --body-file "$RUNNER_TEMP/loop-body.md"
+          echo "Opened triage issue #$ISSUE_NUM — dispatching Codex."
+          gh issue comment "$ISSUE_NUM" --repo "$REPO" --body \
+          "@codex Act as failure triage for the autonomous loop. The live provider-conformance harness failed: $RUN_URL (run id $RUN_ID). Do this, and do NOT change code or open a PR — triage only: (1) Read the failing logs (\`gh run view $RUN_ID --repo $REPO --log-failed\`) and the provider-conformance artifact/summary. (2) Root-cause each DISTINCT failure. (3) DEDUPE against existing work — list open issues (\`gh issue list --repo $REPO --label codex --state open --limit 100\`); if a matching issue already exists for a failure, add a one-line 'recurred in $RUN_URL' comment to it and do NOT open a duplicate. (4) For each genuine, self-contained, CI-verifiable defect that is NOT already tracked, open a scoped issue: \`gh issue create --repo $REPO --label codex --label enhancement --title \"<scoped task>\" --body \"<root cause, scope, acceptance criteria, and the failing run link>\"\` — the hourly increment loop will build it. (5) If a failure is transient/flaky and not a code defect (e.g. a live-model latency timeout or provider outage), note it in a comment and file NOTHING. (6) If a real fix would require a breaking public-API change or an architectural change, do NOT file it as an auto-buildable task — open an issue labeled \`needs-human\` describing it for the architect/human. When finished, close this triage issue (\`gh issue close $ISSUE_NUM\`)."

CHANGELOG.md

@@ -17,7 +17,7 @@ next version when it ships.
 ## [Unreleased]
 
 ### Added
-- **`micro loop`** — scaffold an autonomous improvement loop into any repository: GitHub Actions workflows dispatched to an @mention-driven coding agent, across up to five roles — `planner` (ranked queue), `builder` (top item as a single-concern PR, auto-merged on green CI), `triage` (CI failures → fix issues), and opt-in `coherence` (docs/CHANGELOG alignment) and `release` (daily patch tag). Each dispatch role's instruction lives in an editable `.github/loop/prompts/<role>.md` file — the workflow is the mechanism, the prompt is the policy — so a repo customizes behavior without forking the CLI. `micro loop init --roles …` writes it all; `micro loop verify` checks the wiring. This is the loop that maintains go-micro itself, generalized. (`cmd/micro/loop/`)
+- **`micro loop`** — scaffold an autonomous improvement loop into any repository: GitHub Actions workflows for a planner (keeps a ranked queue), builder (builds the top item as a single-concern PR, auto-merged on green CI), and triage (turns CI failures into fix issues), dispatched to an @mention-driven coding agent. `micro loop init` writes the workflows + `NORTH_STAR`/`PRIORITIES`; `micro loop verify` checks the wiring. This is the loop that maintains go-micro itself, generalized. (`cmd/micro/loop/`)
 
 ---
 

cmd/micro/README.md

@@ -638,35 +638,30 @@ micro loop init      # scaffold the loop into the current repo
 micro loop verify    # check a repo is wired correctly
 ```
 
-`micro loop init` writes the selected roles' workflows, their prompts, and a queue. Choose roles with `--roles` (default `planner,builder,triage`; `--roles all` for everything):
+`micro loop init` writes three workflows and a queue:
 
-| Role | Workflow | What it does |
-|------|----------|--------------|
-| Planner | `loop-planner.yml` | Keeps a ranked queue in `.github/loop/PRIORITIES.md` |
-| Builder | `loop-builder.yml` | Builds the top open item as a single-concern PR, auto-merged on green CI |
-| Triage | `loop-triage.yml` | Turns CI failures into scoped fix issues, back into the queue |
-| Coherence | `loop-coherence.yml` | Keeps README/docs/CHANGELOG aligned with the North Star *(opt-in)* |
-| Release | `loop-release.yml` | Cuts the next patch tag when the branch has new commits *(opt-in)* |
+| Role | File | What it does |
+|------|------|--------------|
+| Planner | `.github/workflows/loop-planner.yml` | Keeps a ranked queue in `.github/loop/PRIORITIES.md` |
+| Builder | `.github/workflows/loop-builder.yml` | Builds the top open item as a single-concern PR, auto-merged on green CI |
+| Triage | `.github/workflows/loop-triage.yml` | Turns CI failures into scoped fix issues, back into the queue |
 
-The workflows are the **mechanism**; each dispatch role's instruction is an editable file in `.github/loop/prompts/` — the **policy**. Edit those prompts (and `.github/loop/NORTH_STAR.md`) to steer the loop without touching the CLI. That split is what lets go-micro itself use `micro loop` while keeping its own richer prompts.
+Direction lives in `.github/loop/NORTH_STAR.md` — edit it to steer the loop.
 
 Common flags:
 
 ```bash
 micro loop init \
-  --roles all \
   --agent @codex \
   --token-secret LOOP_TOKEN \
   --branch main \
   --ci-workflow CI
 ```
 
-- `--roles`: which roles to scaffold (`planner,builder,triage`, or `all`)
 - `--agent`: how the workflows summon the agent (an `@mention`)
 - `--token-secret`: repo secret holding the driving user PAT
 - `--branch`: base branch for the loop's PRs
 - `--ci-workflow`: `name:` of the CI workflow triage watches
-- `--tag-prefix`: tag prefix the release role matches and bumps (default `v`)
 
 Two things the CLI can't do for you (and `micro loop verify` reminds you of):
 

cmd/micro/loop/loop.go

@@ -1,20 +1,12 @@
 // Package loop implements the 'micro loop' command, which scaffolds and
 // verifies an autonomous improvement loop for a repository.
 //
-// The loop is a set of GitHub Actions workflows that dispatch a coding agent by
-// @mention on a fresh tracking issue each run. It has up to five roles:
-//
-//	planner    keeps a ranked queue in .github/loop/PRIORITIES.md
-//	builder    builds the top open item as a single-concern PR (auto-merged on green CI)
-//	triage     turns CI failures into scoped fix issues back into the queue
-//	coherence  keeps README/docs/CHANGELOG aligned with the North Star (opt-in)
-//	release    cuts the next patch tag when the branch has new commits (opt-in)
-//
-// The workflows are the MECHANISM; each dispatch role's instruction lives in an
-// editable .github/loop/prompts/<role>.md file — the POLICY. That split is what
-// lets any repo (including go-micro itself) customize behavior by editing prompt
-// files rather than forking the CLI. `micro loop init` writes it all; `micro
-// loop verify` checks the wiring.
+// The loop is a set of GitHub Actions workflows — a planner that keeps a ranked
+// queue, a builder that builds the top item as a single-concern PR, and a triage
+// pass that turns CI failures into fix issues — that dispatch a coding agent by
+// @mention on a fresh tracking issue each run. `micro loop init` writes those
+// workflows (plus a NORTH_STAR and PRIORITIES queue) into a repo; `micro loop
+// verify` checks that a repo is wired correctly.
 package loop
 
 import (
@@ -24,7 +16,6 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
-	"sort"
 	"strings"
 	"text/template"
 
@@ -35,77 +26,49 @@ import (
 //go:embed templates/*
 var templatesFS embed.FS
 
-// config is the substitution surface for the templates — the whole config-vs-core
-// boundary. The workflows and prompts are the reusable core; these are what a
-// given repo tunes.
+// config is the substitution surface for the workflow templates. It is the
+// whole "config vs core" boundary: the workflows are the reusable core, these
+// fields are what a given repo tunes.
 type config struct {
-	// Shared.
 	DefaultBranch string // base branch for the loop's PRs (e.g. main)
 	AgentMention  string // how the workflows summon the agent (e.g. @codex)
 	TokenSecret   string // repo secret holding the user PAT that drives dispatch
 	CIWorkflow    string // name: of the CI workflow triage watches for failures
-
-	// Per-dispatch-role (set while rendering each one).
-	Role         string
-	WorkflowName string
-	IssueTitle   string
-	Group        string
-	Cron         string
-
-	// Release role.
-	TagPrefix   string // tag prefix to match/bump, e.g. "v"
-	ReleaseCron string
+	PlannerCron   string // cron for the planner
+	BuilderCron   string // cron for the builder
 }
 
-// dispatchRole is a cron-driven role rendered from templates/dispatch.yml.tmpl.
-type dispatchRole struct {
-	workflowName string
-	issueTitle   string
-	group        string
-	cronFlag     string
-	defaultCron  string
+// generated workflow files: template name -> destination (relative to repo root).
+var workflows = map[string]string{
+	"templates/loop-planner.yml.tmpl": ".github/workflows/loop-planner.yml",
+	"templates/loop-builder.yml.tmpl": ".github/workflows/loop-builder.yml",
+	"templates/loop-triage.yml.tmpl":  ".github/workflows/loop-triage.yml",
 }
 
-var dispatchRoles = map[string]dispatchRole{
-	"planner":   {"Loop: Planner", "Loop: planning review", "loop-planner", "planner-cron", "0 * * * *"},
-	"builder":   {"Loop: Builder", "Loop: build increment", "loop-builder", "builder-cron", "30 * * * *"},
-	"coherence": {"Loop: Coherence", "Loop: coherence review", "loop-coherence", "coherence-cron", "0 7 * * *"},
+// static (non-templated) docs: template name -> destination.
+var docs = map[string]string{
+	"templates/NORTH_STAR.md": ".github/loop/NORTH_STAR.md",
+	"templates/PRIORITIES.md": ".github/loop/PRIORITIES.md",
 }
 
-// allRoles is the full set, in a stable order, for --roles=all and help text.
-var allRoles = []string{"planner", "builder", "triage", "coherence", "release"}
-
-const (
-	promptDir = ".github/loop/prompts"
-	loopDir   = ".github/loop"
-	wfDir     = ".github/workflows"
-)
-
 func init() {
 	cmd.Register(&cli.Command{
 		Name:  "loop",
 		Usage: "Scaffold an autonomous improvement loop for a repository",
 		Description: `Set up a self-improving loop for a repo: GitHub Actions workflows that
-dispatch a coding agent to plan, build, triage, and (optionally) keep docs
-coherent and cut releases — gated by CI.
+dispatch a coding agent to plan, build, and triage — gated by CI.
 
-Roles (choose with --roles, default: planner,builder,triage):
-  planner    keeps a ranked queue in .github/loop/PRIORITIES.md
-  builder    builds the top open item as a single-concern PR (auto-merged on green CI)
-  triage     turns CI failures into scoped fix issues back into the queue
-  coherence  keeps README/docs/CHANGELOG aligned with the North Star
-  release    cuts the next patch tag when the branch has new commits
+The loop has three roles:
+  planner  keeps a ranked queue in .github/loop/PRIORITIES.md
+  builder  builds the top open item as a single-concern PR (auto-merged on green CI)
+  triage   turns CI failures into scoped fix issues back into the queue
 
-Each dispatch role's instruction is an editable file in .github/loop/prompts/ —
-edit those to steer behavior. Direction lives in .github/loop/NORTH_STAR.md.
+Direction lives in .github/loop/NORTH_STAR.md — edit it to steer the loop.
 
 Examples:
-  # Scaffold the default loop (planner, builder, triage)
+  # Scaffold the loop into the current repo
   micro loop init
 
-  # The full loop, all five roles
-  micro loop init --roles all
-
   # Customize the agent, token secret, base branch, and CI workflow name
   micro loop init --agent @codex --token-secret LOOP_TOKEN \
     --branch main --ci-workflow CI
@@ -115,19 +78,15 @@ Examples:
 		Subcommands: []*cli.Command{
 			{
 				Name:  "init",
-				Usage: "Scaffold the loop workflows, prompts, and queue into a repo",
+				Usage: "Scaffold the loop workflows and queue into a repo",
 				Flags: []cli.Flag{
 					&cli.StringFlag{Name: "dir", Usage: "Target repo directory", Value: "."},
-					&cli.StringFlag{Name: "roles", Usage: "Comma-separated roles, or 'all'", Value: "planner,builder,triage"},
 					&cli.StringFlag{Name: "branch", Usage: "Base branch for the loop's PRs (auto-detected if empty)"},
 					&cli.StringFlag{Name: "agent", Usage: "How the workflows summon the agent (an @mention)", Value: "@codex"},
 					&cli.StringFlag{Name: "token-secret", Usage: "Repo secret holding the user PAT that drives dispatch", Value: "LOOP_TOKEN"},
 					&cli.StringFlag{Name: "ci-workflow", Usage: "name: of the CI workflow triage watches for failures", Value: "CI"},
 					&cli.StringFlag{Name: "planner-cron", Usage: "Cron schedule for the planner", Value: "0 * * * *"},
 					&cli.StringFlag{Name: "builder-cron", Usage: "Cron schedule for the builder", Value: "30 * * * *"},
-					&cli.StringFlag{Name: "coherence-cron", Usage: "Cron schedule for the coherence role", Value: "0 7 * * *"},
-					&cli.StringFlag{Name: "release-cron", Usage: "Cron schedule for the release role", Value: "0 23 * * *"},
-					&cli.StringFlag{Name: "tag-prefix", Usage: "Tag prefix the release role matches and bumps", Value: "v"},
 					&cli.BoolFlag{Name: "force", Usage: "Overwrite existing loop files"},
 				},
 				Action: runInit,
@@ -144,18 +103,13 @@ Examples:
 
 func runInit(c *cli.Context) error {
 	dir := c.String("dir")
-	roles, err := parseRoles(c.String("roles"))
-	if err != nil {
-		return err
-	}
-
 	cfg := config{
 		DefaultBranch: c.String("branch"),
 		AgentMention:  strings.TrimSpace(c.String("agent")),
 		TokenSecret:   strings.TrimSpace(c.String("token-secret")),
 		CIWorkflow:    c.String("ci-workflow"),
-		TagPrefix:     c.String("tag-prefix"),
-		ReleaseCron:   c.String("release-cron"),
+		PlannerCron:   c.String("planner-cron"),
+		BuilderCron:   c.String("builder-cron"),
 	}
 	if cfg.DefaultBranch == "" {
 		cfg.DefaultBranch = detectDefaultBranch(dir)
@@ -164,187 +118,67 @@ func runInit(c *cli.Context) error {
 		cfg.AgentMention = "@" + cfg.AgentMention
 	}
 
-	crons := map[string]string{
-		"planner":   c.String("planner-cron"),
-		"builder":   c.String("builder-cron"),
-		"coherence": c.String("coherence-cron"),
-	}
-
-	if err := scaffold(dir, cfg, roles, crons, c.Bool("force")); err != nil {
+	if err := scaffold(dir, cfg, c.Bool("force")); err != nil {
 		return err
 	}
-	printNextSteps(cfg, roles)
+	printNextSteps(cfg)
 	return nil
 }
 
-// parseRoles resolves the --roles flag into a validated, stable-ordered set.
-func parseRoles(spec string) ([]string, error) {
-	if strings.TrimSpace(spec) == "all" {
-		return append([]string(nil), allRoles...), nil
+// scaffold renders the workflow templates and writes the loop files into dir.
+// Static docs (NORTH_STAR, PRIORITIES) are never clobbered even with force, so
+// re-running init can't wipe curated direction or a hand-tuned queue.
+func scaffold(dir string, cfg config, force bool) error {
+	for tmplName, dest := range workflows {
+		rendered, err := render(tmplName, cfg)
+		if err != nil {
+			return err
+		}
+		if err := writeFile(filepath.Join(dir, dest), rendered, force); err != nil {
+			return err
+		}
+		fmt.Printf("  wrote %s\n", dest)
 	}
-	want := map[string]bool{}
-	for _, r := range strings.Split(spec, ",") {
-		r = strings.TrimSpace(r)
-		if r == "" {
+
+	for tmplName, dest := range docs {
+		full := filepath.Join(dir, dest)
+		if fileExists(full) {
+			fmt.Printf("  kept  %s (already exists)\n", dest)
 			continue
 		}
-		if !isRole(r) {
-			return nil, fmt.Errorf("unknown role %q (valid: %s, or 'all')", r, strings.Join(allRoles, ", "))
+		b, err := templatesFS.ReadFile(tmplName)
+		if err != nil {
+			return err
 		}
-		want[r] = true
-	}
-	if len(want) == 0 {
-		return nil, fmt.Errorf("no roles selected")
-	}
-	var out []string
-	for _, r := range allRoles { // preserve canonical order
-		if want[r] {
-			out = append(out, r)
+		if err := writeFile(full, b, true); err != nil {
+			return err
 		}
+		fmt.Printf("  wrote %s\n", dest)
 	}
-	return out, nil
-}
-
-func isRole(r string) bool {
-	for _, x := range allRoles {
-		if x == r {
-			return true
-		}
-	}
-	return false
-}
-
-// scaffold renders the selected roles into dir. The split is deliberate:
-//   - Workflows are the MECHANISM — regenerated, and overwritten with --force.
-//   - Prompts, NORTH_STAR, and PRIORITIES are the POLICY — written once and
-//     never clobbered, even with --force, so re-running init to refresh the
-//     workflow mechanics can't wipe curated instructions, direction, or queue.
-func scaffold(dir string, cfg config, roles []string, crons map[string]string, force bool) error {
-	for _, role := range roles {
-		switch role {
-		case "triage":
-			if err := renderTo(dir, "templates/loop-triage.yml.tmpl", filepath.Join(wfDir, "loop-triage.yml"), cfg, force); err != nil {
-				return err
-			}
-			if err := renderKeep(dir, "templates/prompts/triage.md.tmpl", filepath.Join(promptDir, "triage.md"), cfg); err != nil {
-				return err
-			}
-		case "release":
-			if err := renderTo(dir, "templates/loop-release.yml.tmpl", filepath.Join(wfDir, "loop-release.yml"), cfg, force); err != nil {
-				return err
-			}
-		default: // dispatch roles
-			d := dispatchRoles[role]
-			rc := cfg
-			rc.Role = role
-			rc.WorkflowName = d.workflowName
-			rc.IssueTitle = d.issueTitle
-			rc.Group = d.group
-			rc.Cron = crons[role]
-			if rc.Cron == "" {
-				rc.Cron = d.defaultCron
-			}
-			if err := renderTo(dir, "templates/dispatch.yml.tmpl", filepath.Join(wfDir, "loop-"+role+".yml"), rc, force); err != nil {
-				return err
-			}
-			if err := renderKeep(dir, "templates/prompts/"+role+".md.tmpl", filepath.Join(promptDir, role+".md"), cfg); err != nil {
-				return err
-			}
-		}
-	}
-
-	// Direction + queue: policy, written once, never clobbered.
-	if err := renderKeep(dir, "templates/NORTH_STAR.md", filepath.Join(loopDir, "NORTH_STAR.md"), cfg); err != nil {
-		return err
-	}
-	return renderKeep(dir, "templates/PRIORITIES.md", filepath.Join(loopDir, "PRIORITIES.md"), cfg)
-}
-
-// renderTo renders a template with cfg and writes it to dir/dest (honoring force).
-func renderTo(dir, tmplName, dest string, cfg config, force bool) error {
-	rendered, err := render(tmplName, cfg)
-	if err != nil {
-		return err
-	}
-	if err := writeFile(filepath.Join(dir, dest), rendered, force); err != nil {
-		return err
-	}
-	fmt.Printf("  wrote %s\n", dest)
-	return nil
-}
-
-// renderKeep writes dir/dest only if it does not already exist — used for
-// policy files (prompts, North Star, queue) so re-running init never clobbers
-// customizations, regardless of --force.
-func renderKeep(dir, tmplName, dest string, cfg config) error {
-	full := filepath.Join(dir, dest)
-	if fileExists(full) {
-		fmt.Printf("  kept  %s (already exists)\n", dest)
-		return nil
-	}
-	rendered, err := render(tmplName, cfg)
-	if err != nil {
-		return err
-	}
-	if err := writeFile(full, rendered, true); err != nil {
-		return err
-	}
-	fmt.Printf("  wrote %s\n", dest)
 	return nil
 }
 
 // verifyState reports what's wrong with dir's loop setup: warnings are
 // non-fatal, missing are required files that aren't present.
 func verifyState(dir string) (warnings, missing []string) {
-	// A loop needs direction, a queue, and at least one role workflow.
-	for _, dest := range []string{filepath.Join(loopDir, "NORTH_STAR.md"), filepath.Join(loopDir, "PRIORITIES.md")} {
+	for _, dest := range workflows {
 		if !fileExists(filepath.Join(dir, dest)) {
 			missing = append(missing, dest)
 		}
 	}
-
-	present := presentLoopWorkflows(dir)
-	if len(present) == 0 {
-		missing = append(missing, wfDir+"/loop-*.yml (no role workflows found)")
-	}
-
-	// Every dispatch/triage role workflow needs its prompt file. (release has none.)
-	for _, role := range present {
-		if role == "release" {
-			continue
-		}
-		prompt := filepath.Join(promptDir, role+".md")
-		if !fileExists(filepath.Join(dir, prompt)) {
-			missing = append(missing, prompt+" (prompt for the loop-"+role+" workflow)")
+	for _, dest := range docs {
+		if !fileExists(filepath.Join(dir, dest)) {
+			missing = append(missing, dest)
 		}
 	}
-
-	// The loop is only as good as its gate.
+	// The loop is only as good as its gate: warn if there's no non-loop
+	// workflow to serve as CI.
 	if !hasCIWorkflow(dir) {
-		warnings = append(warnings, "no non-loop workflow found in "+wfDir+" — the loop needs a CI gate (build/test/lint) to merge safely")
+		warnings = append(warnings, "no non-loop workflow found in .github/workflows — the loop needs a CI gate (build/test/lint) to merge safely")
 	}
 	return warnings, missing
 }
 
-// presentLoopWorkflows returns the role names for which a loop-<role>.yml exists.
-func presentLoopWorkflows(dir string) []string {
-	entries, err := os.ReadDir(filepath.Join(dir, wfDir))
-	if err != nil {
-		return nil
-	}
-	var out []string
-	for _, e := range entries {
-		name := e.Name()
-		if !strings.HasPrefix(name, "loop-") {
-			continue
-		}
-		role := strings.TrimSuffix(strings.TrimSuffix(strings.TrimPrefix(name, "loop-"), ".yml"), ".yaml")
-		out = append(out, role)
-	}
-	sort.Strings(out)
-	return out
-}
-
 func runVerify(c *cli.Context) error {
 	dir := c.String("dir")
 	warnings, missing := verifyState(dir)
@@ -357,10 +191,10 @@ func runVerify(c *cli.Context) error {
 	}
 
 	if len(missing) > 0 {
-		return fmt.Errorf("loop is not fully scaffolded (%d item(s) missing) — run `micro loop init`", len(missing))
+		return fmt.Errorf("loop is not fully scaffolded (%d file(s) missing) — run `micro loop init`", len(missing))
 	}
 
-	fmt.Printf("  OK       loop is wired: %s\n", strings.Join(presentLoopWorkflows(dir), ", "))
+	fmt.Println("  OK       loop workflows and queue are present")
 	fmt.Println()
 	fmt.Println("Reminders the CLI can't check:")
 	fmt.Println("  • The token secret must be set in the repo (Settings → Secrets).")
@@ -408,7 +242,7 @@ func fileExists(path string) bool {
 // hasCIWorkflow reports whether .github/workflows holds any workflow that is
 // not one of the loop's own (i.e. a plausible CI gate).
 func hasCIWorkflow(dir string) bool {
-	entries, err := os.ReadDir(filepath.Join(dir, wfDir))
+	entries, err := os.ReadDir(filepath.Join(dir, ".github", "workflows"))
 	if err != nil {
 		return false
 	}
@@ -443,13 +277,12 @@ func detectDefaultBranch(dir string) string {
 	return "main"
 }
 
-func printNextSteps(cfg config, roles []string) {
+func printNextSteps(cfg config) {
 	fmt.Printf(`
-Loop scaffolded (%s). Next steps (the CLI can't do these for you):
+Loop scaffolded. Next steps (the CLI can't do these for you):
 
   1. Edit .github/loop/NORTH_STAR.md — the direction the loop aligns to.
      Seed .github/loop/PRIORITIES.md with a few real items.
-     Tune the per-role instructions in .github/loop/prompts/ if you like.
 
   2. Add a repo secret named %s: a fine-grained user PAT (contents + pull
      requests + issues write) for an account the agent (%s) responds to.
@@ -459,8 +292,9 @@ Loop scaffolded (%s). Next steps (the CLI can't do these for you):
      requires its checks with 0 approving reviews — that green-CI gate is
      what lets the builder auto-merge safely.
 
-  4. Commit these files, then trigger a run from the Actions tab.
+  4. Commit these files, then trigger a run:
+     Actions → "Loop: Planner" / "Loop: Builder" → Run workflow.
 
 Verify anytime with: micro loop verify
-`, strings.Join(roles, ", "), cfg.TokenSecret, cfg.AgentMention, cfg.CIWorkflow, cfg.DefaultBranch)
+`, cfg.TokenSecret, cfg.AgentMention, cfg.CIWorkflow, cfg.DefaultBranch)
 }

cmd/micro/loop/loop_test.go

@@ -7,248 +7,93 @@ import (
 	"testing"
 )
 
-var testCfg = config{
-	DefaultBranch: "main",
-	AgentMention:  "@codex",
-	TokenSecret:   "LOOP_TOKEN",
-	CIWorkflow:    "CI",
-	TagPrefix:     "v",
-	ReleaseCron:   "0 23 * * *",
-}
-
-var testCrons = map[string]string{"planner": "0 * * * *", "builder": "30 * * * *", "coherence": "0 7 * * *"}
-
-// renderable is every template a full scaffold touches, with the per-role config
-// applied the same way scaffold does.
-func renderCases() map[string]config {
-	cases := map[string]config{
-		"templates/loop-triage.yml.tmpl":      testCfg,
-		"templates/loop-release.yml.tmpl":     testCfg,
-		"templates/prompts/triage.md.tmpl":    testCfg,
-		"templates/prompts/planner.md.tmpl":   testCfg,
-		"templates/prompts/builder.md.tmpl":   testCfg,
-		"templates/prompts/coherence.md.tmpl": testCfg,
+func TestRenderProducesValidPlaceholderFreeYAML(t *testing.T) {
+	cfg := config{
+		DefaultBranch: "main",
+		AgentMention:  "@codex",
+		TokenSecret:   "LOOP_TOKEN",
+		CIWorkflow:    "CI",
+		PlannerCron:   "0 * * * *",
+		BuilderCron:   "30 * * * *",
 	}
-	for role, d := range dispatchRoles {
-		rc := testCfg
-		rc.Role, rc.WorkflowName, rc.IssueTitle, rc.Group, rc.Cron = role, d.workflowName, d.issueTitle, d.group, d.defaultCron
-		cases["dispatch:"+role] = rc
-	}
-	return cases
-}
 
-func TestRenderIsPlaceholderFreeAndKeepsGHAExpressions(t *testing.T) {
-	for name, cfg := range renderCases() {
-		tmplName := name
-		if strings.HasPrefix(name, "dispatch:") {
-			tmplName = "templates/dispatch.yml.tmpl"
-		}
+	for tmplName := range workflows {
 		rendered, err := render(tmplName, cfg)
 		if err != nil {
-			t.Fatalf("render %s: %v", name, err)
+			t.Fatalf("render %s: %v", tmplName, err)
 		}
 		s := string(rendered)
 
-		// No unresolved substitution delimiters remain in any template.
+		// No unresolved substitution delimiters should remain...
 		if strings.Contains(s, "<<") || strings.Contains(s, ">>") {
-			t.Errorf("%s still contains << >> placeholders", name)
+			t.Errorf("%s still contains << >> placeholders after render", tmplName)
 		}
-	}
-}
-
-func TestBaseBranchSubstitutedIntoPrompts(t *testing.T) {
-	// The base branch appears in the PR-opening instructions of these prompts.
-	for _, p := range []string{"planner", "builder", "coherence"} {
-		s := mustRender(t, "templates/prompts/"+p+".md.tmpl", testCfg)
-		if !strings.Contains(s, "--base main") {
-			t.Errorf("%s prompt missing substituted base branch", p)
-		}
-	}
-}
-
-func TestWorkflowTemplatesPreserveGHAAndAreStructural(t *testing.T) {
-	// Only the workflow YAML templates (not the markdown prompts).
-	wf := map[string]config{
-		"templates/loop-triage.yml.tmpl":  testCfg,
-		"templates/loop-release.yml.tmpl": testCfg,
-	}
-	for role, d := range dispatchRoles {
-		rc := testCfg
-		rc.Role, rc.WorkflowName, rc.IssueTitle, rc.Group, rc.Cron = role, d.workflowName, d.issueTitle, d.group, d.defaultCron
-		wf["dispatch:"+role] = rc
-	}
-	for name, cfg := range wf {
-		tmplName := name
-		if strings.HasPrefix(name, "dispatch:") {
-			tmplName = "templates/dispatch.yml.tmpl"
-		}
-		s := mustRender(t, tmplName, cfg)
+		// ...but GitHub Actions' own ${{ }} expressions must survive verbatim.
 		if !strings.Contains(s, "${{ secrets.LOOP_TOKEN") {
-			t.Errorf("%s lost its ${{ secrets.LOOP_TOKEN }} expression", name)
+			t.Errorf("%s lost its ${{ secrets.LOOP_TOKEN }} expression", tmplName)
 		}
+		// The configured values must be substituted in.
+		if !strings.Contains(s, "@codex") {
+			t.Errorf("%s missing agent mention", tmplName)
+		}
+		// Structural sanity: a workflow needs these top-level keys.
 		for _, key := range []string{"name:", "on:", "jobs:"} {
 			if !strings.Contains(s, key) {
-				t.Errorf("%s missing top-level %q", name, key)
+				t.Errorf("%s missing top-level %q", tmplName, key)
 			}
 		}
 	}
 }
 
-func TestDispatchWorkflowsStripPromptComments(t *testing.T) {
-	// The posted body must not include the prompt's editorial <!-- --> header;
-	// the workflow strips it. Guard the sed directive in both dispatch paths.
-	rc := testCfg
-	d := dispatchRoles["planner"]
-	rc.Role, rc.WorkflowName, rc.IssueTitle, rc.Group, rc.Cron = "planner", d.workflowName, d.issueTitle, d.group, d.defaultCron
-	for _, tc := range []struct {
-		name, tmpl string
-		cfg        config
-	}{
-		{"dispatch", "templates/dispatch.yml.tmpl", rc},
-		{"triage", "templates/loop-triage.yml.tmpl", testCfg},
-	} {
-		s := mustRender(t, tc.tmpl, tc.cfg)
-		if !strings.Contains(s, `/<!--/,/-->/d`) {
-			t.Errorf("%s workflow does not strip prompt HTML comments before posting", tc.name)
-		}
-	}
-}
-
-func TestPromptsLeaveRuntimeTokensLiteral(t *testing.T) {
-	// __ISSUE__ must survive render (the workflow substitutes it at runtime).
-	for _, p := range []string{"planner", "builder", "coherence", "triage"} {
-		s := mustRender(t, "templates/prompts/"+p+".md.tmpl", testCfg)
-		if !strings.Contains(s, "__ISSUE__") {
-			t.Errorf("%s prompt lost its __ISSUE__ runtime token", p)
-		}
-	}
-	// triage additionally uses __RUNURL__.
-	if s := mustRender(t, "templates/prompts/triage.md.tmpl", testCfg); !strings.Contains(s, "__RUNURL__") {
-		t.Error("triage prompt lost its __RUNURL__ runtime token")
-	}
-}
-
-func TestScaffoldAllRolesWritesEverything(t *testing.T) {
+func TestInitThenVerify(t *testing.T) {
 	dir := t.TempDir()
-	mustWrite(t, filepath.Join(dir, wfDir, "ci.yml"), "name: CI\n")
+	// A non-loop workflow so verify's CI-gate check passes.
+	mustWrite(t, filepath.Join(dir, ".github/workflows/ci.yml"), "name: CI\n")
 
-	roles := []string{"planner", "builder", "triage", "coherence", "release"}
-	if err := scaffold(dir, testCfg, roles, testCrons, false); err != nil {
+	if err := scaffold(dir, config{
+		DefaultBranch: "main",
+		AgentMention:  "@codex",
+		TokenSecret:   "LOOP_TOKEN",
+		CIWorkflow:    "CI",
+		PlannerCron:   "0 * * * *",
+		BuilderCron:   "30 * * * *",
+	}, false); err != nil {
 		t.Fatalf("scaffold: %v", err)
 	}
 
-	wantWorkflows := []string{"loop-planner.yml", "loop-builder.yml", "loop-triage.yml", "loop-coherence.yml", "loop-release.yml"}
-	for _, w := range wantWorkflows {
-		if !fileExists(filepath.Join(dir, wfDir, w)) {
-			t.Errorf("expected %s", w)
+	for _, dest := range workflows {
+		if !fileExists(filepath.Join(dir, dest)) {
+			t.Errorf("expected %s to be written", dest)
 		}
 	}
-	// Dispatch + triage roles have prompts; release does not.
-	for _, p := range []string{"planner.md", "builder.md", "triage.md", "coherence.md"} {
-		if !fileExists(filepath.Join(dir, promptDir, p)) {
-			t.Errorf("expected prompt %s", p)
+	for _, dest := range docs {
+		if !fileExists(filepath.Join(dir, dest)) {
+			t.Errorf("expected %s to be written", dest)
 		}
 	}
-	if fileExists(filepath.Join(dir, promptDir, "release.md")) {
-		t.Error("release should not have a prompt")
-	}
-	if _, missing := verifyState(dir); len(missing) != 0 {
-		t.Errorf("verify reported missing after full scaffold: %v", missing)
+
+	// A second scaffold without --force must fail on an existing workflow.
+	if err := scaffold(dir, config{DefaultBranch: "main", AgentMention: "@codex", TokenSecret: "LOOP_TOKEN", CIWorkflow: "CI", PlannerCron: "0 * * * *", BuilderCron: "30 * * * *"}, false); err == nil {
+		t.Error("expected second scaffold without --force to fail")
 	}
 }
 
-func TestScaffoldDefaultRolesOmitsOptional(t *testing.T) {
+func TestVerifyMissingFilesFails(t *testing.T) {
 	dir := t.TempDir()
-	if err := scaffold(dir, testCfg, []string{"planner", "builder", "triage"}, testCrons, false); err != nil {
+	if _, missing := verifyState(dir); len(missing) == 0 {
+		t.Error("expected missing files in an empty dir")
+	}
+}
+
+func TestVerifyWarnsWithoutCIGate(t *testing.T) {
+	dir := t.TempDir()
+	if err := scaffold(dir, config{DefaultBranch: "main", AgentMention: "@codex", TokenSecret: "LOOP_TOKEN", CIWorkflow: "CI", PlannerCron: "0 * * * *", BuilderCron: "30 * * * *"}, false); err != nil {
 		t.Fatalf("scaffold: %v", err)
 	}
-	if fileExists(filepath.Join(dir, wfDir, "loop-coherence.yml")) {
-		t.Error("coherence should not be written by default")
+	// Only loop-* workflows exist → no CI gate.
+	if hasCIWorkflow(dir) {
+		t.Error("expected no CI gate when only loop-* workflows are present")
 	}
-	if fileExists(filepath.Join(dir, wfDir, "loop-release.yml")) {
-		t.Error("release should not be written by default")
-	}
-}
-
-func TestReinitForceKeepsPromptsRefreshesWorkflows(t *testing.T) {
-	dir := t.TempDir()
-	roles := []string{"planner", "builder", "triage"}
-	if err := scaffold(dir, testCfg, roles, testCrons, false); err != nil {
-		t.Fatalf("scaffold: %v", err)
-	}
-
-	// Customize a prompt and edit direction/queue, as a real user would.
-	customPrompt := filepath.Join(dir, promptDir, "builder.md")
-	mustWrite(t, customPrompt, "MY CUSTOM BUILDER POLICY")
-	northStar := filepath.Join(dir, loopDir, "NORTH_STAR.md")
-	mustWrite(t, northStar, "MY MISSION")
-
-	// Re-run with --force to refresh workflow mechanics.
-	if err := scaffold(dir, testCfg, roles, testCrons, true); err != nil {
-		t.Fatalf("re-scaffold --force: %v", err)
-	}
-
-	// Policy (prompt, North Star) must survive --force untouched.
-	if b, _ := os.ReadFile(customPrompt); string(b) != "MY CUSTOM BUILDER POLICY" {
-		t.Errorf("--force clobbered a customized prompt: %q", b)
-	}
-	if b, _ := os.ReadFile(northStar); string(b) != "MY MISSION" {
-		t.Errorf("--force clobbered the North Star: %q", b)
-	}
-	// Mechanism (workflow) must be regenerated (present and non-empty).
-	if b, _ := os.ReadFile(filepath.Join(dir, wfDir, "loop-builder.yml")); !strings.Contains(string(b), "Loop: Builder") {
-		t.Error("--force did not refresh the workflow")
-	}
-}
-
-func TestParseRoles(t *testing.T) {
-	if got, err := parseRoles("all"); err != nil || len(got) != len(allRoles) {
-		t.Errorf("all => %v, %v", got, err)
-	}
-	// Canonical order preserved regardless of input order.
-	got, err := parseRoles("release,planner")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if strings.Join(got, ",") != "planner,release" {
-		t.Errorf("expected canonical order planner,release; got %v", got)
-	}
-	if _, err := parseRoles("bogus"); err == nil {
-		t.Error("expected error for unknown role")
-	}
-	if _, err := parseRoles(""); err == nil {
-		t.Error("expected error for empty roles")
-	}
-}
-
-func TestVerifyMissingPromptFails(t *testing.T) {
-	dir := t.TempDir()
-	if err := scaffold(dir, testCfg, []string{"planner", "builder", "triage"}, testCrons, false); err != nil {
-		t.Fatalf("scaffold: %v", err)
-	}
-	// Delete a prompt → verify must flag it.
-	if err := os.Remove(filepath.Join(dir, promptDir, "builder.md")); err != nil {
-		t.Fatal(err)
-	}
-	_, missing := verifyState(dir)
-	found := false
-	for _, m := range missing {
-		if strings.Contains(m, "builder.md") {
-			found = true
-		}
-	}
-	if !found {
-		t.Errorf("expected verify to flag the missing builder prompt; got %v", missing)
-	}
-}
-
-func mustRender(t *testing.T, tmplName string, cfg config) string {
-	t.Helper()
-	b, err := render(tmplName, cfg)
-	if err != nil {
-		t.Fatalf("render %s: %v", tmplName, err)
-	}
-	return string(b)
 }
 
 func mustWrite(t *testing.T, path, content string) {

cmd/micro/loop/templates/dispatch.yml.tmpl

@@ -1,60 +0,0 @@
-name: "<< .WorkflowName >>"
-
-# Generated by `micro loop init`. A dispatch role of the autonomous loop: on a
-# cadence it opens a fresh tracking issue and posts the instruction in
-# .github/loop/prompts/<< .Role >>.md to the agent (<< .AgentMention >>).
-#
-# The workflow is the MECHANISM; that prompt file is the editable POLICY —
-# change what this role does by editing the prompt, not this YAML. A FRESH
-# issue per run is deliberate: agents derive the PR branch name from the
-# triggering issue, so reusing one tracker collapses every run onto one branch.
-#
-# Gated on << .TokenSecret >>: the agent ignores @mentions from the
-# github-actions bot, so dispatch posts as a real user (a PAT). No token → no-op.
-
-on:
-  workflow_dispatch: {}
-  schedule:
-    - cron: "<< .Cron >>"
-
-permissions:
-  issues: write
-
-concurrency:
-  group: << .Group >>
-  cancel-in-progress: false
-
-jobs:
-  dispatch:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4 # needed to read the prompt file
-      - name: Dispatch << .Role >>
-        env:
-          GH_TOKEN: ${{ secrets.<< .TokenSecret >> || github.token }}
-          HAS_TOKEN: ${{ secrets.<< .TokenSecret >> != '' }}
-          REPO: ${{ github.repository }}
-          RUN_NUMBER: ${{ github.run_number }}
-        run: |
-          if [ "$HAS_TOKEN" != "true" ]; then
-            echo "<< .TokenSecret >> is not set — skipping (the agent ignores bot @mentions)."
-            exit 0
-          fi
-          PROMPT=".github/loop/prompts/<< .Role >>.md"
-          if [ ! -f "$PROMPT" ]; then
-            echo "missing $PROMPT — run 'micro loop init'." >&2
-            exit 1
-          fi
-          ISSUE_URL=$(gh issue create --repo "$REPO" \
-            --title "<< .IssueTitle >> #$RUN_NUMBER" \
-            --body "Autonomous << .Role >> pass. Direction: .github/loop/NORTH_STAR.md; queue: .github/loop/PRIORITIES.md.")
-          ISSUE_NUM="${ISSUE_URL##*/}"
-          echo "Opened issue #$ISSUE_NUM — dispatching << .Role >>."
-          # The prompt file is the policy; strip its editorial <!-- --> header and
-          # substitute the tracking issue number (__ISSUE__) at runtime.
-          {
-            echo "<< .AgentMention >>"
-            echo
-            sed -e '/<!--/,/-->/d' -e "s/__ISSUE__/$ISSUE_NUM/g" "$PROMPT"
-          } > "$RUNNER_TEMP/loop-body.md"
-          gh issue comment "$ISSUE_NUM" --repo "$REPO" --body-file "$RUNNER_TEMP/loop-body.md"

cmd/micro/loop/templates/loop-builder.yml.tmpl

@@ -0,0 +1,46 @@
+name: "Loop: Builder"
+
+# Generated by `micro loop init`. The GENERATOR of the loop: each run it opens a
+# fresh tracking issue and dispatches the agent to build the top open item from
+# .github/loop/PRIORITIES.md as a single-concern PR, then enables native
+# auto-merge so the PR lands once the required CI checks pass. Branch protection
+# (required checks, 0 approvals) is the gate — there is no merge sweep.
+#
+# A FRESH issue per run is deliberate: agents derive the PR branch name from the
+# triggering issue, so reusing one tracker collapses every run onto one branch
+# and only the first PR opens. Gated on << .TokenSecret >> (see loop-planner.yml).
+
+on:
+  workflow_dispatch: {}
+  schedule:
+    - cron: "<< .BuilderCron >>"
+
+permissions:
+  issues: write
+
+concurrency:
+  group: loop-builder
+  cancel-in-progress: false
+
+jobs:
+  dispatch:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Open an increment issue and dispatch the agent
+        env:
+          GH_TOKEN: ${{ secrets.<< .TokenSecret >> || github.token }}
+          HAS_TOKEN: ${{ secrets.<< .TokenSecret >> != '' }}
+          REPO: ${{ github.repository }}
+          RUN_NUMBER: ${{ github.run_number }}
+        run: |
+          if [ "$HAS_TOKEN" != "true" ]; then
+            echo "<< .TokenSecret >> is not set — skipping (see loop-planner.yml)."
+            exit 0
+          fi
+          ISSUE_URL=$(gh issue create --repo "$REPO" \
+            --title "Loop: build increment #$RUN_NUMBER" \
+            --body "Autonomous build increment. Direction: .github/loop/NORTH_STAR.md. Queue: .github/loop/PRIORITIES.md.")
+          ISSUE_NUM="${ISSUE_URL##*/}"
+          echo "Opened issue #$ISSUE_NUM — dispatching the builder."
+          gh issue comment "$ISSUE_NUM" --repo "$REPO" --body \
+          "<< .AgentMention >> Build one increment for this repository, aligned to .github/loop/NORTH_STAR.md. PICK THE WORK: take the highest-ranked item in .github/loop/PRIORITIES.md whose linked issue is still OPEN — that is your task and its issue is the one you close. If the queue is empty or every item's issue is closed, pick the single highest-value improvement yourself. Implement it, then VERIFY the project builds, tests, and lints (use the commands documented in the README or the CI workflow). Open the PR YOURSELF from the shell — do NOT use a make_pr tool (it may be a no-op stub): \`git switch -c loop/increment-$ISSUE_NUM\`, \`git push -u origin loop/increment-$ISSUE_NUM\`, \`gh pr create --base << .DefaultBranch >> --title \"<title>\" --body \"<body; include 'Closes #<the item's issue>' so it leaves the queue, and 'Closes #$ISSUE_NUM' for this tracker>\"\`, then \`gh pr merge --squash --auto --delete-branch\` so it lands on green CI. One concern per PR; stay out of breaking public API and brand/positioning copy."

cmd/micro/loop/templates/loop-planner.yml.tmpl

@@ -0,0 +1,48 @@
+name: "Loop: Planner"
+
+# Generated by `micro loop init`. Part of an autonomous improvement loop:
+# a PLANNER (this file) keeps a ranked queue, a BUILDER builds the top item,
+# and CI + a TRIAGE pass are the evaluator. The loop dispatches a coding agent
+# by @mention on a fresh tracking issue each run.
+#
+# Gated on the << .TokenSecret >> secret: the agent ignores @mentions from the
+# github-actions bot, so the dispatch must post as a real user (a PAT). Until
+# that secret is set the workflow runs but no-ops. Direction lives in
+# .github/loop/NORTH_STAR.md; the ranked queue in .github/loop/PRIORITIES.md.
+
+on:
+  workflow_dispatch: {}
+  schedule:
+    - cron: "<< .PlannerCron >>"
+
+permissions:
+  issues: write
+
+concurrency:
+  group: loop-planner
+  cancel-in-progress: false
+
+jobs:
+  dispatch:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Open a planning issue and dispatch the agent
+        env:
+          GH_TOKEN: ${{ secrets.<< .TokenSecret >> || github.token }}
+          HAS_TOKEN: ${{ secrets.<< .TokenSecret >> != '' }}
+          REPO: ${{ github.repository }}
+          RUN_NUMBER: ${{ github.run_number }}
+        run: |
+          if [ "$HAS_TOKEN" != "true" ]; then
+            echo "<< .TokenSecret >> is not set — skipping."
+            echo "The agent ignores @mentions from the github-actions bot, so a"
+            echo "user PAT is required. Add a << .TokenSecret >> secret to activate."
+            exit 0
+          fi
+          ISSUE_URL=$(gh issue create --repo "$REPO" \
+            --title "Loop: planning review #$RUN_NUMBER" \
+            --body "Autonomous planning pass. Direction: .github/loop/NORTH_STAR.md. Queue: .github/loop/PRIORITIES.md.")
+          ISSUE_NUM="${ISSUE_URL##*/}"
+          echo "Opened issue #$ISSUE_NUM — dispatching the planner."
+          gh issue comment "$ISSUE_NUM" --repo "$REPO" --body \
+          "<< .AgentMention >> Act as the planner for this repository. (1) Read .github/loop/NORTH_STAR.md for direction, then assess current state — recently merged PRs and open issues — so the queue reflects reality (drop done items, don't re-queue in-flight work). (2) Maintain a SINGLE ranked queue in .github/loop/PRIORITIES.md, highest-value first, each item linking a scoped, CI-verifiable issue (#N). For any prioritized gap with no issue, file one: \`gh issue create --title \"<scoped task>\" --body \"<goal, scope, acceptance criteria>\"\`. (3) If the ranking actually changed, open ONE PR for PRIORITIES.md: \`git switch -c loop/planner-$ISSUE_NUM\`, \`git push -u origin loop/planner-$ISSUE_NUM\`, \`gh pr create --base << .DefaultBranch >> --title \"<title>\" --body \"<summary, Closes #$ISSUE_NUM>\"\`, then \`gh pr merge --squash --auto --delete-branch\`. If the queue is already accurate, just close this issue (\`gh issue close $ISSUE_NUM\`). Do NOT make breaking or architectural changes yourself — surface those as notes for a human. Open the PR yourself from the shell with gh; do not use a make_pr tool."

cmd/micro/loop/templates/loop-release.yml.tmpl

@@ -1,76 +0,0 @@
-name: "Loop: Release"
-
-# Generated by `micro loop init`. Cuts the next PATCH tag
-# (<< .TagPrefix >>MAJOR.MINOR.PATCH+1) when the default branch has new commits
-# since the latest such tag, and pushes it with a PAT (<< .TokenSecret >>) so any
-# tag-triggered release workflow fires. Minor/major bumps stay with a human.
-#
-# The tag MUST be pushed with a PAT, not the default GITHUB_TOKEN: a tag pushed
-# by GITHUB_TOKEN does not trigger other workflows (Actions blocks that recursion).
-
-on:
-  workflow_dispatch: {}
-  schedule:
-    - cron: "<< .ReleaseCron >>"
-
-permissions:
-  contents: read
-
-concurrency:
-  group: loop-release
-  cancel-in-progress: false
-
-jobs:
-  release:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0 # need full history + all tags
-          # Do NOT persist the default GITHUB_TOKEN as a git credential: it would
-          # be sent on the PAT push below and override it, so the tag push would
-          # authenticate as github-actions[bot] and 403. Letting the PAT in the
-          # push URL be the only credential is the whole point.
-          persist-credentials: false
-      - name: Cut the next patch tag if there are new commits
-        env:
-          RELEASE_TOKEN: ${{ secrets.<< .TokenSecret >> }}
-          REPO: ${{ github.repository }}
-        run: |
-          if [ -z "$RELEASE_TOKEN" ]; then
-            echo "<< .TokenSecret >> is not set — skipping."
-            exit 0
-          fi
-          git fetch --tags --force
-
-          LATEST=$(git tag --list '<< .TagPrefix >>*.*.*' --sort=-v:refname | head -1)
-          if [ -z "$LATEST" ]; then
-            echo "no << .TagPrefix >>MAJOR.MINOR.PATCH tag found — aborting so nothing weird gets tagged."
-            exit 1
-          fi
-          echo "latest tag: $LATEST"
-
-          COUNT=$(git rev-list --count "$LATEST"..HEAD)
-          echo "commits since $LATEST: $COUNT"
-          if [ "$COUNT" -eq 0 ]; then
-            echo "no new commits since $LATEST — no release."
-            exit 0
-          fi
-
-          ver="${LATEST#<< .TagPrefix >>}"
-          major="${ver%%.*}"
-          rest="${ver#*.}"
-          minor="${rest%%.*}"
-          patch="${rest#*.}"
-          case "$major.$minor.$patch" in
-            [0-9]*.[0-9]*.[0-9]*) ;;
-            *) echo "unexpected tag shape: $LATEST" ; exit 1 ;;
-          esac
-          NEXT="<< .TagPrefix >>${major}.${minor}.$((patch + 1))"
-          echo "cutting: $NEXT ($COUNT commits since $LATEST)"
-
-          git config user.name "loop release bot"
-          git config user.email "noreply@users.noreply.github.com"
-          git tag -a "$NEXT" -m "Release $NEXT — automated patch ($COUNT commits since $LATEST)"
-          git push "https://x-access-token:${RELEASE_TOKEN}@github.com/${REPO}.git" "$NEXT"
-          echo "Pushed $NEXT."

cmd/micro/loop/templates/loop-triage.yml.tmpl

@@ -1,10 +1,10 @@
 name: "Loop: Triage"
 
 # Generated by `micro loop init`. The feedback path of the evaluator: when the
-# CI workflow ("<< .CIWorkflow >>") fails on a non-PR run, dispatch the agent
-# (<< .AgentMention >>) with the instruction in .github/loop/prompts/triage.md
-# to root-cause the failure and file scoped fix issues back into the queue — so
-# failures become fixes with no human in the middle. Gated on << .TokenSecret >>.
+# CI workflow ("<< .CIWorkflow >>") fails on a non-PR run, this dispatches the
+# agent to root-cause the failure and file scoped fix issues back into the
+# planner's queue — so failures become fixes with no human in the middle, short
+# of a decision that is genuinely a human's. Gated on << .TokenSecret >>.
 
 on:
   workflow_run:
@@ -25,8 +25,7 @@ jobs:
     if: ${{ github.event.workflow_run.conclusion == 'failure' && github.event.workflow_run.event != 'pull_request' }}
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4 # needed to read the prompt file
-      - name: Dispatch triage
+      - name: File a triage issue and dispatch the agent
         env:
           GH_TOKEN: ${{ secrets.<< .TokenSecret >> || github.token }}
           HAS_TOKEN: ${{ secrets.<< .TokenSecret >> != '' }}
@@ -35,22 +34,13 @@ jobs:
           RUN_URL: ${{ github.event.workflow_run.html_url }}
         run: |
           if [ "$HAS_TOKEN" != "true" ]; then
-            echo "<< .TokenSecret >> is not set — skipping."
+            echo "<< .TokenSecret >> is not set — skipping (see loop-planner.yml)."
             exit 0
           fi
-          PROMPT=".github/loop/prompts/triage.md"
-          if [ ! -f "$PROMPT" ]; then
-            echo "missing $PROMPT — run 'micro loop init'." >&2
-            exit 1
-          fi
           ISSUE_URL=$(gh issue create --repo "$REPO" \
             --title "Loop: triage failed run $RUN_ID" \
             --body "The '<< .CIWorkflow >>' workflow failed: $RUN_URL")
           ISSUE_NUM="${ISSUE_URL##*/}"
           echo "Opened issue #$ISSUE_NUM — dispatching triage."
-          {
-            echo "<< .AgentMention >>"
-            echo
-            sed -e '/<!--/,/-->/d' -e "s/__ISSUE__/$ISSUE_NUM/g" -e "s#__RUNURL__#$RUN_URL#g" "$PROMPT"
-          } > "$RUNNER_TEMP/loop-body.md"
-          gh issue comment "$ISSUE_NUM" --repo "$REPO" --body-file "$RUNNER_TEMP/loop-body.md"
+          gh issue comment "$ISSUE_NUM" --repo "$REPO" --body \
+          "<< .AgentMention >> Triage the failed CI run at $RUN_URL. Read the logs and root-cause each distinct failure. DEDUPE against open issues — if a failure matches an existing issue, comment 'recurred' there instead of filing a duplicate. For each genuine, self-contained defect, file a scoped issue (\`gh issue create --title \"<scoped fix>\" --body \"<root cause, where, acceptance>\"\`) so the planner/builder can pick it up and the next CI run verifies it. IGNORE transient flakes (network blips, provider outages, timeouts with no code cause). Anything needing a breaking or architectural change: label it needs-human and describe it — do NOT auto-file it as a routine fix. Close this issue (\`gh issue close $ISSUE_NUM\`) when triage is done."

cmd/micro/loop/templates/prompts/builder.md.tmpl

@@ -1,14 +0,0 @@
-<!--
-The BUILDER prompt — the editable policy for the builder role. The workflow
-prepends the agent @mention and substitutes __ISSUE__ before posting. Keep
-__ISSUE__ literal.
--->
-Build one increment for this repository, aligned to `.github/loop/NORTH_STAR.md`.
-
-PICK THE WORK: take the highest-ranked item in `.github/loop/PRIORITIES.md` whose linked issue is still OPEN — that is your task, and its issue is the one you close. If the queue is empty or every item's issue is closed, pick the single highest-value improvement yourself.
-
-Implement it, then VERIFY the project builds, tests, and lints (use the commands documented in the README or the CI workflow).
-
-Open the PR YOURSELF from the shell — do NOT use a make_pr tool (it may be a no-op stub): `git switch -c loop/increment-__ISSUE__`, `git push -u origin loop/increment-__ISSUE__`, `gh pr create --base << .DefaultBranch >> --title "<title>" --body "<body; include 'Closes #<the item's issue>' so it leaves the queue, and 'Closes #__ISSUE__' for this run's tracker>"`, then `gh pr merge --squash --auto --delete-branch` so it lands once CI is green.
-
-One concern per PR. Stay out of breaking public API changes and brand/positioning copy — surface those as notes for a human instead.

cmd/micro/loop/templates/prompts/coherence.md.tmpl

@@ -1,14 +0,0 @@
-<!--
-The COHERENCE (DevRel) prompt — the editable policy for the coherence role. The
-workflow prepends the agent @mention and substitutes __ISSUE__ before posting.
-Keep __ISSUE__ literal.
--->
-Act as DevRel for this repository — keep the public story coherent and honest.
-
-Audit the public surface — `README`, docs, and any website/blog — for coherence with `.github/loop/NORTH_STAR.md`: places that contradict each other, are stale, or describe behavior that has since changed (cross-check against the code and recently merged PRs). If the repo keeps a `CHANGELOG.md`, reconcile its `[Unreleased]` section against what actually merged.
-
-SAFE factual-alignment and crispness fixes (and the CHANGELOG upkeep): open ONE PR and auto-merge it — `git switch -c loop/coherence-__ISSUE__`, `git push -u origin loop/coherence-__ISSUE__`, `gh pr create --base << .DefaultBranch >> --title "<title>" --body "<summary, Closes #__ISSUE__>"`, then `gh pr merge --squash --auto --delete-branch`.
-
-Brand / positioning / marketing copy and any opinion blog posts are NOT auto-merge material — the public voice stays with a human. Describe them in a comment on this issue, or open a PR WITHOUT enabling auto-merge, and leave it for review.
-
-Post a short findings report as a comment on this issue (#__ISSUE__): what's aligned, what drifted, what you fixed. Open PRs yourself from the shell with `gh`; do not use a make_pr tool.

cmd/micro/loop/templates/prompts/planner.md.tmpl

@@ -1,15 +0,0 @@
-<!--
-The PLANNER prompt. This file is the editable policy for the planner role —
-change what the planner does by editing this text. The workflow prepends the
-agent @mention and substitutes __ISSUE__ (this run's tracking issue) before
-posting it. Keep __ISSUE__ literal.
--->
-Act as the planner for this repository.
-
-(1) Read `.github/loop/NORTH_STAR.md` for direction, then scan recently merged PRs and open issues so the queue reflects reality — drop done items, don't re-queue work already in flight.
-
-(2) Maintain a SINGLE ranked queue in `.github/loop/PRIORITIES.md`, highest-value first, each item linking a scoped, CI-verifiable issue (#N). For any prioritized gap that has no issue, file one: `gh issue create --title "<scoped task>" --body "<goal, scope, acceptance criteria>"`.
-
-(3) If the ranking actually changed, open ONE PR for `PRIORITIES.md`: `git switch -c loop/planner-__ISSUE__`, `git push -u origin loop/planner-__ISSUE__`, `gh pr create --base << .DefaultBranch >> --title "<title>" --body "<summary, Closes #__ISSUE__>"`, then `gh pr merge --squash --auto --delete-branch`. If the queue is already accurate, just close this issue (`gh issue close __ISSUE__`).
-
-Do NOT make breaking or architectural changes yourself — surface those as notes for a human. Open the PR yourself from the shell with `gh`; do not use a make_pr tool (it may be a no-op stub).

cmd/micro/loop/templates/prompts/triage.md.tmpl

@@ -1,14 +0,0 @@
-<!--
-The TRIAGE prompt — the editable policy for the triage role. The workflow
-prepends the agent @mention and substitutes __ISSUE__ (this tracking issue) and
-__RUNURL__ (the failed CI run) before posting. Keep both literal.
--->
-Triage the failed CI run at __RUNURL__.
-
-Read the logs and root-cause each distinct failure. DEDUPE against open issues — if a failure matches an existing issue, comment "recurred" there instead of filing a duplicate.
-
-For each genuine, self-contained defect, file a scoped issue (`gh issue create --title "<scoped fix>" --body "<root cause, where, acceptance criteria>"`) so the planner/builder can pick it up and the next CI run verifies it.
-
-IGNORE transient flakes — network blips, provider outages, timeouts with no code cause. Anything needing a breaking or architectural change: label it `needs-human` and describe it, rather than auto-filing it as a routine fix.
-
-Close this issue (`gh issue close __ISSUE__`) when triage is done.

internal/docs/CONTINUOUS_IMPROVEMENT.md

@@ -19,27 +19,17 @@ Actions instead of subagents. Each role is a workflow:
 
 | Role | Workflow (action name) | What it does |
 |------|------------------------|--------------|
-| **Planner** | `loop-planner.yml` — *Loop: Planner* | Tracks live state, prioritizes the roadmap + an internal scan, and maintains the ranked queue in [`.github/loop/PRIORITIES.md`](../../.github/loop/PRIORITIES.md). Decides *what*. |
+| **Planner** | `loop-architect.yml` — *Loop: Architect (Planner)* | Tracks live state, prioritizes the roadmap + an internal scan, and maintains the ranked queue in [`PRIORITIES.md`](PRIORITIES.md). Decides *what*. |
 | **Generator** | `loop-builder.yml` — *Loop: Builder (Generator)* | Builds the top open queue item as a single-concern PR (via Codex) and self-merges on green CI. Does the work. |
 | **Evaluator** | `harness.yml` — *Harness (E2E)*, plus the CI gate (`tests.yaml`, `lint.yaml`) | Grades every change: the mock harness + unit/lint on each push/PR, and real-model conformance hourly. A *separate* grader — never the generator judging itself. |
 | **Evaluator → feedback** | `loop-triage.yml` — *Loop: Triage (Evaluator feedback)* | On harness failure, root-causes, dedupes, and files scoped fix issues back into the planner's queue. The hill-climbing feedback path. |
-| **Coherence** | `loop-coherence.yml` — *Loop: Coherence* | Keeps README/website/docs/blog aligned with the North Star, keeps `CHANGELOG.md` living (reconciling `[Unreleased]` against merged PRs and rolling it into version headings as tags cut), and drafts the changelog blog post. |
+| **Coherence** | `loop-devrel.yml` — *Loop: DevRel* | Keeps README/website/docs/blog aligned with the North Star, keeps `CHANGELOG.md` living (reconciling `[Unreleased]` against merged PRs and rolling it into version headings as tags cut), and drafts the changelog blog post. |
 | **Release** | `loop-release.yml` — *Loop: Release (daily patch)* | Cuts a daily patch tag when master has new commits, so the *installable* framework tracks the loop's improvements (triggers `release.yml`/goreleaser). Minor/major bumps stay with the human. |
 
 Generation is separated from evaluation on purpose: an agent grading its own work
 reliably over-rates it, so **CI and the harness — not the builder — are the gate**.
 The human sets direction and owns the calls that need taste (see Guardrails).
 
-> **Go Micro dogfoods its own tool.** These `.github/workflows/loop-*.yml` files
-> are generated by [`micro loop`](../../cmd/micro/loop) (`micro loop init --roles all`).
-> The workflows are the *mechanism*; each role's instruction is the editable
-> *policy* in [`.github/loop/prompts/`](../../.github/loop/prompts), and the
-> direction/queue live in [`.github/loop/NORTH_STAR.md`](../../.github/loop/NORTH_STAR.md)
-> and [`.github/loop/PRIORITIES.md`](../../.github/loop/PRIORITIES.md). To change
-> what a role does, edit its prompt — not the YAML. Re-run `micro loop init
-> --roles all --force` to regenerate the workflow mechanics (it won't clobber the
-> North Star, queue, or prompts).
-
 ## Autonomy
 
 Full autonomy, **no approval gates**. Each increment: Claude Code picks the work,
@@ -157,7 +147,7 @@ The hourly loop ships increments; two periodic passes keep the *whole* heading i
 the right direction. Both use the same mechanism (fresh issue → `@codex` →
 output) but produce direction and coherence, not just code.
 
-- **Coherence (DevRel) — daily** (`.github/workflows/loop-coherence.yml`, prompt `.github/loop/prompts/coherence.md`). Audits the public
+- **DevRel — daily** (`.github/workflows/loop-devrel.yml`). Audits the public
   surface (README, website landing + docs, blog) for coherence with the North
   Star, README crispness, and blog-worthy material. It also keeps `CHANGELOG.md`
   living: each run reconciles the `[Unreleased]` section against the PRs that
@@ -170,12 +160,12 @@ output) but produce direction and coherence, not just code.
   the `CHANGELOG.md` upkeep* — auto-merge like any increment; brand/positioning
   copy and the changelog blog post are opened as a PR (or surfaced in the report)
   and left for the human to review/merge — blog voice stays with the human.
-- **Planner (Architect) — continuous (hourly)** (`.github/workflows/loop-planner.yml`, prompt `.github/loop/prompts/planner.md`).
+- **Architect — continuous (hourly)** (`.github/workflows/loop-architect.yml`).
   The *founder lens*, running alongside the builders. Each run it **tracks live
   state** (what just merged, what's in flight), **prioritizes the roadmap**
   (`ROADMAP.md`, Now → Next → Later) against an internal scan (lifecycle gaps, API
   coherence and seams, dev-UX friction, missing pieces, drift/realignment), and
-  **maintains the ranked queue** in [`.github/loop/PRIORITIES.md`](../../.github/loop/PRIORITIES.md) — re-ranking
+  **maintains the ranked queue** in [`PRIORITIES.md`](PRIORITIES.md) — re-ranking
   to reflect reality, backing each top item with a scoped issue, and posting an
   assessment. It runs at `:59`, just before the `:29` increment, so it
   re-prioritizes and *then* the loop builds the new top. **Its output is the

internal/docs/PRIORITIES.md

@@ -21,10 +21,10 @@ changes, architectural rewrites. Those go to the human.
 
 ## Work queue (ranked)
 
-1. **Make the universe A2A reachability check deterministic** ([#3653](https://github.com/micro/go-micro/issues/3653)) — PR #3669 closed the duplicate concierge-notification defect, leaving the final universe A2A smoke as the highest-value Now-phase adoption and interop blocker. Gateway reachability should prove agents can be called across A2A without timing out or creating extra side effects, because the 0→hero proof depends on services → agents → workflows being boring under recovery.
-2. **Make the examples index a walkable first-agent map** ([#3671](https://github.com/micro/go-micro/issues/3671)) — recent README/docs work surfaced the first-agent on-ramp, and blog #33 sharpened the dogfooded loop story; the next adoption gap is example wayfinding. A newcomer should be able to move from first service to first agent to first workflow from the examples surface without stitching together README, website docs, and directories by hand.
-3. **Expose `fallback_echo` during A2A streaming fallback conformance** ([#3560](https://github.com/micro/go-micro/issues/3560)) — this remains the next scoped Now-phase interop/conformance gap: it protects the A2A streaming promise developers see in the README and site by ensuring the non-native streaming fallback path receives the tool surface, while staying behind the immediate on-ramp and universe smoke blockers.
-4. **Parse multi-event A2A SSE fallback responses in the harness** ([#3662](https://github.com/micro/go-micro/issues/3662)) — once the fallback tool path succeeds, the harness must accept legitimate multi-event `message/stream` responses instead of concatenating valid SSE events into invalid JSON. This is a small CI-verifiable harness fix that keeps cross-provider streaming conformance focused on real gateway failures rather than parser brittleness.
+1. **Make the first-agent on-ramp discoverable from README and website navigation** ([#3640](https://github.com/micro/go-micro/issues/3640)) — the install and first-run smoke contract shipped in #3635, but adoption still depends on a new developer finding the next step without already knowing the guide names. Put the walkable path from install/scaffold to first agent, chat/inspect, and 0→hero in the README/site wayfinding so the verified harness becomes lived DX rather than hidden depth.
+2. **Make plan/delegate live-provider conformance avoid duplicate task side effects** ([#3626](https://github.com/micro/go-micro/issues/3626)) — atlascloud still has an open Now-phase trust gap where plan/delegate created duplicate launch tasks and missed the delegated notification. This remains the highest open runtime fix because plan/delegate is the bridge from agent reasoning to service side effects; developers cannot trust the services → agents lifecycle if a model can replay tool calls and leave handoff pending.
+3. **Make universe checkout conformance send exactly one concierge notification** ([#3633](https://github.com/micro/go-micro/issues/3633)) — the newest live-provider scan found the durable checkout/universe path resuming correctly but notifying the buyer twice. Rank it next because durable workflows are the 0→hero proof, and resume idempotency must be boring before deeper observability or future interop work matters.
+4. **Expose `fallback_echo` during A2A streaming fallback conformance** ([#3560](https://github.com/micro/go-micro/issues/3560)) — this remains the next scoped Now-phase interop/conformance gap: it protects the A2A streaming promise developers see in the README and site by ensuring the non-native streaming fallback path still receives the tool surface, without letting protocol depth outrank the on-ramp or side-effect safety.
 5. **Propagate agent run cancellation and deadlines through model and tool calls** ([#3544](https://github.com/micro/go-micro/issues/3544)) — the highest-value remaining Now-phase resilience gap after the live-provider side-effect fixes is predictable failure semantics across agent runs, model calls, tool calls, plan/delegate, and flow handoffs. Tool retries and live-provider deadline tuning are in place; the lifecycle still needs cancellation/deadline propagation so work fails safely instead of becoming opaque loops.
 6. **Emit OpenTelemetry spans for agent run timelines** ([#3525](https://github.com/micro/go-micro/issues/3525)) — recent work made runs inspectable, correlated trace metadata through scheduled dispatch, verified restart resume, added opt-in tool retries, hardened provider conformance, and fixed provider-emitted text tool calls. The next Next-phase step is to turn that RunInfo foundation into standard OTel spans for agent runs, model calls, tool calls, checkpoint/resume, cancellation/deadlines, and failures.
 7. **Add an AP2 mandate layer over A2A and x402** ([#3552](https://github.com/micro/go-micro/issues/3552)) — this is a forward interop investment, not a Now-phase blocker: Go Micro already has A2A agents and x402 paid tools, so a small signed-mandate foundation can keep agent payments aligned with the open-protocol story without pulling the queue away from adoption, resilience, or observability. Keep it additive and opt-in while the AP2/FIDO work settles.

internal/harness/plan-delegate/main.go

@@ -54,64 +54,24 @@ type ListResponse struct {
 }
 
 type TaskService struct {
-	mu      sync.Mutex
-	tasks   []*Task
-	byTitle map[string]*Task
-	nextID  int
+	mu     sync.Mutex
+	tasks  []*Task
+	nextID int
 }
 
-// Add creates a new task with the given title. Replayed live-model tool calls
-// are idempotent by launch task title so the conformance harness proves exactly
-// one durable side effect per intended task even if a provider resends a call.
+// Add creates a new task with the given title.
 // @example {"title": "Design"}
 func (s *TaskService) Add(ctx context.Context, req *AddRequest, rsp *AddResponse) error {
 	s.mu.Lock()
 	defer s.mu.Unlock()
-	if s.byTitle == nil {
-		s.byTitle = map[string]*Task{}
-	}
-	key := launchTaskKey(req.Title)
-	if t := s.byTitle[key]; t != nil {
-		rsp.Task = t
-		fmt.Printf("    \033[32m[task]\033[0m reused %s %q\n", t.ID, t.Title)
-		return nil
-	}
 	s.nextID++
-	t := &Task{ID: fmt.Sprintf("task-%d", s.nextID), Title: canonicalLaunchTitle(req.Title)}
+	t := &Task{ID: fmt.Sprintf("task-%d", s.nextID), Title: req.Title}
 	s.tasks = append(s.tasks, t)
-	s.byTitle[key] = t
 	rsp.Task = t
 	fmt.Printf("    \033[32m[task]\033[0m created %s %q\n", t.ID, t.Title)
 	return nil
 }
 
-func launchTaskKey(title string) string {
-	s := strings.ToLower(strings.TrimSpace(title))
-	switch {
-	case strings.Contains(s, "design"):
-		return "design"
-	case strings.Contains(s, "build"):
-		return "build"
-	case strings.Contains(s, "ship"):
-		return "ship"
-	default:
-		return s
-	}
-}
-
-func canonicalLaunchTitle(title string) string {
-	switch launchTaskKey(title) {
-	case "design":
-		return "Design"
-	case "build":
-		return "Build"
-	case "ship":
-		return "Ship"
-	default:
-		return strings.TrimSpace(title)
-	}
-}
-
 // List returns all tasks.
 // @example {}
 func (s *TaskService) List(ctx context.Context, req *ListRequest, rsp *ListResponse) error {
@@ -135,29 +95,17 @@ type SendResponse struct {
 	Sent bool `json:"sent"`
 }
 type NotifyService struct {
-	mu     sync.Mutex
-	sent   int
-	bySend map[string]bool
+	mu   sync.Mutex
+	sent int
 }
 
-// Send delivers a notification message to a recipient. Duplicate delivery
-// attempts for the same recipient/message are treated as successful replays
-// without producing another side effect.
+// Send delivers a notification message to a recipient.
 // @example {"to": "owner@acme.com", "message": "ready"}
 func (s *NotifyService) Send(ctx context.Context, req *SendRequest, rsp *SendResponse) error {
 	s.mu.Lock()
-	if s.bySend == nil {
-		s.bySend = map[string]bool{}
-	}
-	key := strings.ToLower(strings.TrimSpace(req.To)) + "\x00" + strings.ToLower(strings.TrimSpace(req.Message))
-	if !s.bySend[key] {
-		s.bySend[key] = true
-		s.sent++
-		fmt.Printf("    \033[35m[notify]\033[0m 📨 to=%s message=%q\n", req.To, req.Message)
-	} else {
-		fmt.Printf("    \033[35m[notify]\033[0m reused to=%s message=%q\n", req.To, req.Message)
-	}
+	s.sent++
 	s.mu.Unlock()
+	fmt.Printf("    \033[35m[notify]\033[0m 📨 to=%s message=%q\n", req.To, req.Message)
 	rsp.Sent = true
 	return nil
 }
@@ -333,7 +281,7 @@ func runPlanDelegate(provider string) error {
 		agent.Name("conductor"),
 		agent.Address("127.0.0.1:0"),
 		agent.Services("task"),
-		agent.Prompt("You coordinate launch work. Plan first, create exactly one Design task, one Build task, and one Ship task, then delegate exactly one readiness notification to the \"comms\" agent. Do not create duplicate tasks and do not send notifications yourself."),
+		agent.Prompt("You coordinate launch work. Plan first, create tasks, and delegate notifications to the \"comms\" agent."),
 		agent.Provider(provider), agent.APIKey(apiKey),
 		agent.WithRegistry(reg), agent.WithClient(cl), agent.WithStore(mem),
 		agent.WithCheckpoint(conductorCheckpoint),

internal/harness/plan-delegate/main_test.go

@@ -219,35 +219,3 @@ func TestZeroToHeroContract(t *testing.T) {
 		t.Fatalf("0→hero harness: %v", err)
 	}
 }
-
-func TestTaskServiceAddIsIdempotentForLaunchTitles(t *testing.T) {
-	svc := new(TaskService)
-	for _, title := range []string{"Design", "design task", "Build", "Build launch task", "Ship", "ship readiness"} {
-		var rsp AddResponse
-		if err := svc.Add(context.Background(), &AddRequest{Title: title}, &rsp); err != nil {
-			t.Fatalf("Add(%q): %v", title, err)
-		}
-		if rsp.Task == nil {
-			t.Fatalf("Add(%q) returned nil task", title)
-		}
-	}
-	if got := svc.count(); got != 3 {
-		t.Fatalf("task count = %d, want 3 after duplicate launch-title replays", got)
-	}
-}
-
-func TestNotifyServiceSendIsIdempotentForDuplicateDelivery(t *testing.T) {
-	svc := new(NotifyService)
-	for i := 0; i < 3; i++ {
-		var rsp SendResponse
-		if err := svc.Send(context.Background(), &SendRequest{To: "owner@acme.com", Message: "The launch plan is ready"}, &rsp); err != nil {
-			t.Fatalf("Send attempt %d: %v", i+1, err)
-		}
-		if !rsp.Sent {
-			t.Fatalf("Send attempt %d reported Sent=false", i+1)
-		}
-	}
-	if got := svc.count(); got != 1 {
-		t.Fatalf("notify count = %d, want 1 after duplicate delivery replays", got)
-	}
-}

internal/harness/universe/main.go

@@ -117,22 +117,18 @@ type Notify struct {
 // Send delivers a notification.
 // @example {"to": "buyer@acme.com", "message": "Your order is confirmed"}
 func (s *Notify) Send(_ context.Context, req *SendRequest, rsp *SendResponse) error {
-	keys := notificationDedupeKeys(req)
+	key := req.To + "\x00" + req.Message
 	s.mu.Lock()
 	if s.seen == nil {
 		s.seen = make(map[string]struct{})
 	}
-	for _, key := range keys {
-		if _, ok := s.seen[key]; ok {
-			s.mu.Unlock()
-			fmt.Printf("    \033[35m[notify]\033[0m 📨 duplicate suppressed to=%s %q\n", req.To, req.Message)
-			rsp.Sent = true
-			return nil
-		}
-	}
-	for _, key := range keys {
-		s.seen[key] = struct{}{}
+	if _, ok := s.seen[key]; ok {
+		s.mu.Unlock()
+		fmt.Printf("    \033[35m[notify]\033[0m 📨 duplicate suppressed to=%s %q\n", req.To, req.Message)
+		rsp.Sent = true
+		return nil
 	}
+	s.seen[key] = struct{}{}
 	s.mu.Unlock()
 
 	atomic.AddInt64(&s.sent, 1)
@@ -141,21 +137,6 @@ func (s *Notify) Send(_ context.Context, req *SendRequest, rsp *SendResponse) er
 	return nil
 }
 
-func notificationDedupeKeys(req *SendRequest) []string {
-	keys := []string{req.To + "\x00" + req.Message}
-	message := strings.ToLower(req.Message)
-	if strings.Contains(message, "confirm") {
-		// Live models occasionally emit equivalent confirmation copy more than
-		// once while a resumed checkout is completing (for example, a concise
-		// "order-1 confirmed" followed by a fuller buyer-facing sentence). The
-		// harness has one checkout order, so treat confirmation messages to the
-		// same buyer as the same side effect while preserving exact-message
-		// idempotency for all other notifications.
-		keys = append(keys, req.To+"\x00confirmation")
-	}
-	return keys
-}
-
 func dispatchNotifyStep(agentName string, ntf *Notify) flow.StepFunc {
 	dispatch := flow.Dispatch(agentName)
 	return func(ctx context.Context, in flow.State) (flow.State, error) {

internal/harness/universe/main_test.go

@@ -68,25 +68,3 @@ func TestNotifyStepCompletesAfterObservedSideEffectTimeout(t *testing.T) {
 		t.Fatalf("notifications sent after duplicate = %d, want 1", got)
 	}
 }
-
-func TestNotifySuppressesEquivalentConfirmationMessages(t *testing.T) {
-	ntf := new(Notify)
-	ctx := context.Background()
-
-	for _, req := range []*SendRequest{
-		{To: "buyer@acme.com", Message: "Your order order-1 has been confirmed."},
-		{To: "buyer@acme.com", Message: "order-1 confirmed"},
-	} {
-		var rsp SendResponse
-		if err := ntf.Send(ctx, req, &rsp); err != nil {
-			t.Fatalf("send notification %q: %v", req.Message, err)
-		}
-		if !rsp.Sent {
-			t.Fatalf("send notification %q did not report sent", req.Message)
-		}
-	}
-
-	if got := atomic.LoadInt64(&ntf.sent); got != 1 {
-		t.Fatalf("equivalent confirmation notifications sent = %d, want 1", got)
-	}
-}

internal/website/blog/33.md

@@ -1,108 +0,0 @@
----
-layout: blog
-title: "The Loop, Shipped: Introducing micro loop"
-permalink: /blog/33
-description: "The autonomous loop that builds Go Micro is now a command. micro loop init drops a planner, builder, triage, coherence, and release pipeline into any repository — GitHub Actions as the runtime, editable prompt files as the policy. And Go Micro now runs on it."
----
-
-# The Loop, Shipped: Introducing `micro loop`
-
-*July 2, 2026 • By the Go Micro Team*
-
-A few weeks ago we wrote [How Go Micro Builds Itself](/blog/31): a loop of two AI agents — Codex writing scoped increments, Claude Code orchestrating and reviewing, a human setting direction — kept honest by CI. It was our own thesis, *an agent operating a system*, pointed at the repository that defines the thesis.
-
-People asked the obvious question: **can I run that on my repo?**
-
-Now you can. `micro loop init` drops the whole pipeline into any repository, and — the part that makes it real rather than aspirational — Go Micro itself now runs on it. The workflows that maintain this project are generated by the same command we're shipping to you.
-
-## It's not a binary. It's CI plus prompts.
-
-The first thing to understand is what the loop *is*, physically, because it's not what people expect. There is almost no program here. The loop is a handful of GitHub Actions workflows and a few Markdown files. **GitHub Actions is the runtime.** Nothing compiled sits in a server "running the loop."
-
-So `micro loop` the command is not the loop. It's a scaffolder. `micro loop init` writes the workflows and the prompts into your repo and exits. From then on, GitHub runs everything on a schedule.
-
-That reframing is the whole design:
-
-- **The workflows are the *mechanism*** — open a fresh tracking issue, summon an agent, let it open a PR, merge on green CI. This is generic. It's the same for every repo.
-- **The prompt files are the *policy*** — what the agent is actually told to do. These live in `.github/loop/prompts/<role>.md`, and they're yours to edit.
-
-Separating the two is what lets a tool be both general and specific. The mechanics never change; the instructions are entirely under your control. You steer the loop by editing prose, not YAML.
-
-## The five roles
-
-A full loop has five roles, each a workflow that dispatches an agent (or, for release, just cuts a tag):
-
-| Role | What it does |
-|------|--------------|
-| **planner** | Reads your direction, scans what merged and what's open, and maintains a ranked queue in `.github/loop/PRIORITIES.md`. Decides *what*. |
-| **builder** | Takes the top open item from the queue, implements it as a single-concern PR, and enables auto-merge so it lands the moment CI is green. Does the work. |
-| **triage** | When CI fails on a branch, root-causes the failure and files scoped fix issues back into the queue. The feedback path. |
-| **coherence** | Keeps README, docs, and `CHANGELOG.md` aligned with your North Star; drafts release notes. Optional. |
-| **release** | Cuts the next patch tag when the branch has new commits, so the installable artifact tracks the loop. Optional. |
-
-This is the [planner / generator / evaluator](https://www.anthropic.com/engineering/harness-design-long-running-apps) shape of a long-running agent harness, distributed across GitHub Actions instead of subagents. Generation is deliberately separated from evaluation: an agent grading its own work reliably over-rates it, so **CI — not the builder — is the gate.**
-
-## Quickstart
-
-```bash
-micro loop init            # planner, builder, triage
-micro loop init --roles all # add coherence + release
-micro loop verify          # check the wiring
-```
-
-`init` writes the workflows, a `NORTH_STAR.md` (your direction) and `PRIORITIES.md` (your queue), and the per-role prompt files. Then there are exactly two things the CLI can't do for you — and `micro loop verify` reminds you of both:
-
-1. **Add a token secret.** The agent ignores `@mentions` from the `github-actions` bot, so dispatch has to post as a real user via a personal access token stored as a repo secret. Until it's set, the workflows deliberately no-op.
-2. **Set branch protection.** Require your CI checks with **zero** approving reviews, so the builder's auto-merge lands PRs the instant CI is green. That green-CI gate is the loop's only safety mechanism — which means it's worth saying plainly: **the loop is only as good as your tests.**
-
-Edit `.github/loop/NORTH_STAR.md` to point it, tune the prompts if you like, commit, and it's running.
-
-## The decisions that matter (and the things that broke)
-
-Building this taught us that the hard part of an autonomous loop isn't the agent — it's the wiring around it. A few decisions are load-bearing, and we learned most of them by getting them wrong first.
-
-**Agent-agnostic by `@mention`.** The dispatch summons an agent by mentioning it on an issue (`@codex` by default; `--agent` to change it). Any coding agent that responds to an issue mention and can run `gh` fits. The mechanics don't care which one.
-
-**A fresh issue every run.** Agents derive their PR branch name from the triggering issue. Reuse one tracker issue and every run collapses onto a single branch name — the first PR opens, the rest silently collide and never appear. A unique issue per run gives each increment a clean branch. We found this the way you'd expect: a loop that looked healthy but quietly stopped producing PRs.
-
-**Bots can't summon bots.** Codex ignores comments authored by `github-actions[bot]`, so the dispatch has to post as a user. That's the whole reason the token secret exists, and why the loop no-ops without it rather than pile up ignored comments.
-
-**Don't let checkout clobber your token.** Our nightly release action once failed to push a tag with a permission error — despite having a valid token — because `actions/checkout` persists the default `GITHUB_TOKEN` as a git credential that overrode the personal token on the push. The generated release workflow ships with that fix baked in (`persist-credentials: false`), so it can't bite you.
-
-None of these are exotic. They're exactly the papercuts you'd hit assembling this yourself over a week, and they're the reason a scaffolder earns its place: the defaults encode the lessons.
-
-## Go Micro runs on it
-
-Here's the part we care about most. This repository's loop is no longer hand-written. We ran `micro loop init --roles all` on Go Micro itself, moved our queue and direction into `.github/loop/`, and preserved our own richer instructions — the architect's founder-lens prompt, the adoption steer, the harness-failure triage, the changelog pass — as the editable prompt files. Behavior is identical; only the mechanism is now generated.
-
-We proved it end to end before writing this. The planner fired, opened a fresh tracking issue as the token user, and posted its full instruction to Codex — clean, correctly addressed, picked up within seconds. The loop that will help maintain the post you're reading is the loop this post is about.
-
-That's the honesty test for a dogfooded tool: if we wouldn't run it on our own main branch, we shouldn't ask you to run it on yours.
-
-## What it is not
-
-It would be easy to oversell this, so let's be clear about the edges.
-
-- **It is not a replacement for judgment.** The generated prompts keep an explicit off-limits list — breaking public APIs, positioning and brand copy, new dependencies, architectural rewrites. Those get surfaced to a human, never auto-merged. Taste stays with you.
-- **It is only as good as your gate.** Point it at a repo with weak CI and it will happily merge weak work. The evaluator *is* the safety model. Invest there first.
-- **It spends tokens and pushes commits.** This is real automation with real effects. Start with the three-role default, watch it, and add `coherence` and `release` once you trust it.
-- **It's early.** The mechanics are solid and battle-tested on this repo, but this is version one. The next steps are more agent adapters and, eventually, a standalone home so the workflows can be reused directly.
-
-## The shape of the thing
-
-Go Micro's premise is that when an agent has to operate inside a real system, it *is* a distributed system — services, state, retries, observability — and the simplest place to build it is the runtime where your services already live. `micro loop` is that premise turned back on the repository: an agent, operating a system, where the system is the codebase itself.
-
-You've read about how Go Micro builds itself. Now you can point the same loop at your own repo:
-
-```bash
-micro loop init
-```
-
----
-
-*Go Micro is an open source agent harness and service framework for Go. [Star us on GitHub](https://github.com/micro/go-micro).*
-
-<div class="post-nav">
-  <div><a href="/blog/32">&larr; An Agent Is a Service: Where Agent Frameworks Are Going</a></div>
-  <div><a href="/blog/">All Posts</a></div>
-</div>

internal/website/blog/index.html

@@ -11,13 +11,6 @@ permalink: /blog/
 
 <div class="posts">
 
-  <article style="margin-bottom: 2rem; padding-bottom: 1.5rem; border-bottom: 1px solid #e5e5e5;">
-    <h2 style="margin: 0 0 0.5rem;"><a href="/blog/33">The Loop, Shipped: Introducing micro loop</a></h2>
-    <p class="meta" style="color: #666; font-size: 0.85rem;">July 2, 2026</p>
-    <p>The autonomous loop that builds Go Micro is now a command. <code>micro loop init</code> drops a planner, builder, triage, coherence, and release pipeline into any repository — GitHub Actions as the runtime, editable prompt files as the policy — and Go Micro now runs on it.</p>
-    <a href="/blog/33">Read more &rarr;</a>
-  </article>
-
   <article style="margin-bottom: 2rem; padding-bottom: 1.5rem; border-bottom: 1px solid #e5e5e5;">
     <h2 style="margin: 0 0 0.5rem;"><a href="/blog/32">An Agent Is a Service: Where Agent Frameworks Are Going</a></h2>
     <p class="meta" style="color: #666; font-size: 0.85rem;">June 30, 2026</p>

internal/website/docs/quickstart.md

@@ -37,16 +37,8 @@ curl -X POST http://localhost:8080/api/helloworld/Helloworld.Call \
 
 ## Next Steps
 
-You now have the service half of the services → agents → workflows lifecycle running locally. Keep the on-ramp going in this order:
-
-1. **[Your First Agent](guides/your-first-agent.html)** - turn this service into an agent-callable tool, chat with it, and learn the `micro agent preflight` → `micro run` → `micro chat` loop.
-2. **[Debugging your agent](guides/debugging-agents.html)** - inspect service registration, tool calls, run history, memory, provider failures, and flow handoffs when the agent does something surprising.
-3. **[0→hero Reference](guides/zero-to-hero.html)** - walk the maintained scaffold → run → chat → inspect → deploy dry-run path that proves services, agents, and workflows together.
-
-After that first-agent path, branch out to:
-
 - **[Full Tutorial](getting-started.html)** - In-depth guide
-- **[Examples](examples/)** - Runnable examples mapped to services, agents, and workflows
+- **[Examples](examples/)** - Learn by example
 - **[API Reference](https://pkg.go.dev/go-micro.dev/v6)** - Complete API docs
 - **[Deployment](deployment.html)** - Deploy to production