jonah-fleet 1.0.0

package/schema.json

@@ -0,0 +1,49 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "JonahFleetManifest",
+  "description": "Configuration manifest for Jonah Fleet autonomous agents",
+  "type": "object",
+  "properties": {
+    "$schema": {
+      "type": "string"
+    },
+    "version": {
+      "type": "string",
+      "description": "The pinned fleet version or semver range"
+    },
+    "preset": {
+      "type": "string",
+      "enum": ["minimal", "standard", "full", "custom"],
+      "default": "standard",
+      "description": "Selected routine bundle preset"
+    },
+    "routines": {
+      "type": "object",
+      "properties": {
+        "autowork": { "type": "boolean" },
+        "peer-review": { "type": "boolean" },
+        "optimizer": { "type": "boolean" },
+        "issues-housekeeping": { "type": "boolean" },
+        "dependency-update-security-check": { "type": "boolean" },
+        "product-planning": { "type": "boolean" }
+      },
+      "additionalProperties": false,
+      "description": "Granular routine toggles"
+    },
+    "skills": {
+      "type": "array",
+      "items": { "type": "string" },
+      "description": "List of core engineering skills to install/sync"
+    },
+    "autoUpdate": {
+      "type": "object",
+      "properties": {
+        "enabled": { "type": "boolean", "default": true },
+        "channel": { "type": "string", "enum": ["stable", "latest"], "default": "stable" }
+      },
+      "additionalProperties": false
+    }
+  },
+  "required": ["version", "preset", "routines", "skills"],
+  "additionalProperties": false
+}

package/templates/docs/AGENTS.template.md

@@ -0,0 +1,54 @@
+# AGENTS.md (also GEMINI.md & CLAUDE.md)
+
+## Project Overview
+
+{Brief 1-2 paragraph description of the project, core capabilities, and target users.}
+
+## Tech Stack
+
+- **Framework / Language**: {e.g. Next.js 15, TypeScript strict mode, Python 3.12, Go 1.23}
+- **Backend / Database**: {e.g. PostgreSQL, Supabase, SQLite, Redis}
+- **Styling / UI**: {e.g. Tailwind CSS, Radix UI, CSS Modules}
+- **Testing**: {e.g. Vitest, Playwright, Jest, pytest}
+- **Deployment**: {e.g. Vercel, Cloudflare, Docker, AWS}
+- **Package Manager**: {e.g. npm, pnpm, yarn, uv, pip}
+
+## Development Workflows
+
+```bash
+npm run dev          # Start local development server
+npm run build        # Production build
+npm run lint         # ESLint / static linter
+npm run type-check   # Type verification (tsc --noEmit)
+npm test             # Run test suite
+```
+
+## Project Structure
+
+```
+src/
+  app/            # App routes and views
+  components/     # UI components
+  lib/            # Domain logic and helpers
+tests/            # Test suites
+.agents/          # Local agent skills and configuration
+.github/prompts/  # Autonomous agent routines (managed by jonah-fleet)
+```
+
+## Key Architecture Patterns
+
+- **Separation of Concerns**: Keep business logic pure and isolated from UI rendering and framework adapters.
+- **Error Handling**: Validate inputs at server and module boundaries. Return explicit structured errors.
+- **Testing Philosophy**: Write regression unit tests for every bug fix and integration tests for key workflows.
+
+## Conventions
+
+- **Language**: All code, comments, commit messages, and PR titles must be written in **English**.
+- **Changelog**: Append user-facing changes to `CHANGELOG.md` under today's date section.
+- **Antigravity Run Footer**: Every GitHub comment, issue edit, and PR description posted by automated Actions must end with `_Generated by [Antigravity](${GITHUB_SERVER_URL}/${GITHUB_REPOSITORY}/actions/runs/${GITHUB_RUN_ID})_`.
+
+## Security Guidelines
+
+- Auth boundaries required for all sensitive mutations.
+- Never commit credentials, tokens, or secret keys to version control.
+- Validate request inputs and sanitize outputs.

package/templates/prompts/ORCHESTRATION.md

@@ -0,0 +1,97 @@
+# Orchestration Model (Symphony Alignment)
+
+How agent routines in this repository are dispatched, claimed, and reconciled — plus the single-source-of-truth definitions the routine prompts point at (Stale-claim, Log delivery fallback, Measurement issues). Extracted from `AGENTS.md` so this agent-system reference stays out of every session's auto-loaded context; `AGENTS.md` keeps the invariants and points here.
+
+**Read this when** you need the claim protocol, the stale-claim conditions, the log-push rules, or the measurement-issue protocol — i.e. most Autowork, Peer Review, Analytics Review, and Issues Housekeeping runs.
+
+This project's automation is a GitHub-native instance of the pattern formalized for orchestrating coding agents against an issue tracker. There is **no long-running orchestrator daemon**; the roles map onto GitHub primitives:
+
+| Concept | Implementation in this repo |
+|---|---|
+| `WORKFLOW.md` (repo-owned config + prompt templates) | `AGENTS.md` (aliased as `GEMINI.md`/`CLAUDE.md`) + `.github/prompts/*.md` |
+| Orchestrator (poll, dispatch, reconcile) | GitHub Actions triggers + scheduled routine sessions |
+| Issue tracker | GitHub Issues |
+| Agent runner | An ephemeral agent session (Antigravity CLI `agy`) in an isolated fresh clone |
+| Tracker is reader/scheduler; mutations happen via agent tools | Routines only schedule; the agent session makes every GitHub write |
+
+Dispatch is both **scheduled** and **event-driven**. All routines run as ephemeral agent sessions via **Antigravity CLI (`agy`)** powered by **Gemini 3.7 Flash (High reasoning)**. The routine suite is calibrated to operate within a **strict 70% weekly token ceiling across all routines combined**, supervised by `optimizer.md`:
+- **Scheduled cron sweeps**: Autowork runs periodically (`autowork-cron.yml`), complemented by prompt optimization (`prompt-optimizer-cron.yml`), issues housekeeping (`issues-housekeeping-cron.yml`), and dependency security checks (`dependency-check-cron.yml`).
+- **Event-driven triggers**: GitHub Actions workflows fire routines on events so work starts within seconds instead of waiting for scheduled ticks:
+  - `trigger-review-routine.yml` fires Peer Review when a PR is marked ready for review (with debounce on rapid pushes).
+  - `trigger-autowork-on-merge.yml` fires Autowork in **Targeted mode** when a PR merges to `main` and unblocks the next unit of chained work.
+  - `trigger-autowork-on-bug.yml` fires Autowork when an issue becomes a high-priority bug.
+
+Both autowork triggers pass the target issue via environment variables (`ISSUE_NUMBER`, `ISSUE_URL`), putting autowork.md into **Targeted mode** (working the named issue ahead of Phase 1 convergence). Single-flight per issue is strictly enforced across both scheduled and event-driven runs.
+
+Invariants deliberately upheld from this spec:
+
+- **Single-flight per issue** — at most one run works an issue at a time, enforced by the autowork claim protocol (assign → read-back → earliest-timestamp tiebreak). For **umbrella** issues, single-flight is maintained at the *child-issue* level so slices progress cleanly.
+- **Recover dead-run claims** — a crashed run's orphaned claim is released back to the pool rather than starving the issue, both opportunistically during candidate selection and periodically via issues housekeeping.
+- **Reader/writer separation** — the routine that authors a PR never merges it; the Peer Review routine is the sole merge authority for **product** PRs. (Operational log-only PRs are exempt; see Log delivery fallback.)
+- **Warm-Context Review Synchronization** — Autowork maintains an active warm session during implementation, polling for Peer Review's verdict. When Peer Review bounces a PR to draft with findings, Autowork immediately detects the draft state in-session, applies fixes directly to its warm working tree, and re-marks the PR ready—re-firing Peer Review for Round N+1 without cold-start overhead.
+
+---
+
+## Stale-Claim Definition
+
+Single source of truth for both autowork candidate reclamation and housekeeping sweeps. An assigned issue is a *stale claim* (a dead autowork run's orphaned reservation, safe to release) only when **all** of these hold:
+
+1. **It is an autowork claim, not a manual one.** The issue carries a `🔒 Claimed by autowork run …` comment. An assigned issue with **no** such comment is never stale; leave it alone (it may be a person working manually).
+2. **No live work exists.** There is **no open PR** referencing the issue (`Closes #N`). An open PR is live, recoverable work that autowork Phase 1 owns — never reclaim it, at any age.
+3. **The claim is old.** The most recent `🔒 Claimed by autowork run …` comment's GitHub creation time (`created_at`) is **more than 6 hours** ago. Measure age from that `created_at` only — never the issue's `updated_at`.
+
+**Releasing a stale claim is a destructive write and MUST be guarded:**
+- **Re-read immediately before writing.** Re-read the issue (`issue_read`) right before the unassign and re-confirm conditions 1–3 still hold. If any no longer holds, abort the release and move on.
+- **Remove only the named dead owner.** Unassign that specific login; never blindly clear all assignees.
+
+---
+
+## Routine Matching & Invocation
+
+**Identify the applicable routine at the start of every conversation, before doing any work:**
+
+1. **Explicit invocation** — if the incoming prompt names a routine or was fired by a GitHub Actions workflow that references one, follow that routine's instruction file immediately.
+2. **Content match** — compare the task against the routine table below. When matching an interactive request from a human, name the matched routine and confirm before proceeding.
+3. **No match** — follow the general Working Practices, PR Workflow, and documentation rules with no routine-specific constraints.
+
+| Routine | File | Applies when the conversation is about... |
+|---|---|---|
+| Autowork | `.github/prompts/autowork.md` | Converging on open work: addressing PR review comments, closing issues whose PRs merged, then claiming and implementing the highest-priority unclaimed issue |
+| Peer Review | `.github/prompts/peer-review.md` | Reviewing a pull request (a named PR or scan mode) and merging it or leaving findings and bouncing to draft |
+| Prompt Optimizer | `.github/prompts/optimizer.md` | Diagnosing failures, inefficiency, token anomalies, and analyzing resolved bugs to propose prompt/test/workflow fixes and upstream contributions |
+| Issues Housekeeping | `.github/prompts/issues-housekeeping.md` | Sweeping open issues for staleness, duplicates, label drift, priority accuracy, and orphaned claims |
+| Dependency Update & Security Check | `.github/prompts/dependency-update-security-check.md` | Checking dependencies for updates and known vulnerabilities, opening actionable PRs |
+| Product Planning | `.github/prompts/product-planning.md` | Turning roadmap priorities into staged issues (`/to-tickets`) and formal PRDs (`/to-spec`) |
+
+---
+
+## Engineering Skills Integration
+
+The routines invoke specialized engineering skills at key workflow checkpoints:
+
+- **Autowork (`autowork.md`)**:
+  - `/diagnosing-bugs`: In Targeted mode or for `bug` issues — establishes reproduction feedback loop before patching.
+  - `/domain-modeling` & `/codebase-design`: Consults domain context and establishes deep module interfaces.
+  - `/tdd`: Drives red-green-refactor test-first implementation for each issue.
+  - `/code-review`: Evaluates Standards (`AGENTS.md`) and Spec (`## Tasks`) during pre-ready self-audit.
+  - `/resolving-merge-conflicts`: Resolves merge collisions by intent against primary sources when syncing with `origin/main`.
+- **Peer Review (`peer-review.md`)**:
+  - `/code-review`: Drives multi-angle diff evaluation along Standards and Spec axes.
+  - `/resolving-merge-conflicts`: Resolves merge conflicts mechanically before squash-merging.
+- **Issues Housekeeping (`issues-housekeeping.md`)**:
+  - `/triage`: Evaluates incoming issues into canonical roles.
+- **Product Planning (`product-planning.md`)**:
+  - `/domain-modeling`: Pressure-tests proposals and records domain terms / ADRs.
+  - `/to-spec`: Authors formal PRDs for larger proposals.
+  - `/to-tickets`: Decomposes approved epics/proposals into dependency-linked issues.
+- **Prompt Optimizer (`optimizer.md`)**:
+  - `/writing-for-agents`: Drafts crisp, token-efficient prompt and rule updates.
+
+---
+
+## Log Delivery Fallback
+
+Single source of truth for every routine's Logging section:
+1. **Direct commit to `main` is default**: For operational run logs under `.github/prompts/logs/**`, commit directly to `main` via GitHub API or git push.
+2. **Draft PR fallback**: If direct push fails, commit the log to a dedicated, fresh branch and open a draft PR carrying only the log files.
+3. **Automated landing**: `auto-merge-log-prs.yml` or `issues-housekeeping.md` lands accumulated log PRs. Draft log PRs are never reviewed by Peer Review and do not count toward Autowork's backpressure limits.

package/templates/prompts/_prompt-template.md

@@ -0,0 +1,43 @@
+# {Routine Name}
+
+## Objective
+
+{One paragraph describing the goal. Be specific about scope — what is IN and OUT.}
+
+## Definition of Done
+
+The run is SUCCESS only if ALL of these are true:
+
+- [ ] {Concrete, binary criterion 1}
+- [ ] {Concrete, binary criterion 2}
+- [ ] {Concrete, binary criterion 3}
+
+If any criterion cannot be met, stop immediately and log FAILURE with the reason.
+
+## Constraints
+
+- **Max iterations**: {N} — after {N} tool call rounds without completing the Definition of Done, STOP. Log FAILURE with category `token_limit`. Do not retry the same failing approach.
+- **Max scope**: {scope limit, e.g. "one issue per run", "one PR per run"}. Do not expand scope mid-run.
+- **No speculative work**: only take actions directly required by the Definition of Done. Do not refactor adjacent code, open bonus issues, or add improvements not requested.
+- **Language Requirement**: All GitHub issue titles, descriptions, task checklists, and comments MUST be written in **English**.
+- **Session link footer**: sign every GitHub post with the Antigravity run footer (`_Generated by [Antigravity](${GITHUB_SERVER_URL}/${GITHUB_REPOSITORY}/actions/runs/${GITHUB_RUN_ID})_`).
+
+## Negative examples (DO NOT do these)
+
+- {Example of a wasteful pattern, e.g. "Do not re-read files you already read in this run"}
+- {Example of scope creep, e.g. "Do not fix lint warnings unrelated to the task"}
+- {Example of token burn, e.g. "Do not retry a failing API call more than twice"}
+
+## Instructions
+
+{The actual task instructions go here — step by step.}
+
+## Logging
+
+After completing (SUCCESS or FAILURE), write a log file to `.github/prompts/logs/{routine-name}/{timestamp}.md` following the schema in `.github/prompts/logs/_template.md`. Include:
+- The prompt SHA (run `git rev-parse --short HEAD:.github/prompts/{routine-name}.md`)
+- Every Definition of Done criterion with YES/NO and evidence
+- Full execution trace with tool calls
+- If FAILURE: root cause, category, and suggested fix
+
+**Important**: Commit the log file directly to `main` and push — explicitly permitted for files under `.github/prompts/logs/**`. Follow the Log delivery fallback in `ORCHESTRATION.md` if direct push fails.

package/templates/prompts/autowork.md

@@ -0,0 +1,125 @@
+# Autowork
+
+## Objective
+
+This routine runs in two modes, decided in Step 0. In **Scan mode** (a scheduled run, no issue named): converge on existing open work before starting anything new — priority order (1) address review comments on open PRs, (2) close issues whose PRs are merged, (3) only then pick a new issue. In **Targeted mode** (fired with a specific issue in the payload): work *that* issue as the run's objective, **ahead of** the convergence steps above — the fire exists to start its issue immediately, so an unrelated pending PR does not preempt it (Step 0.5); fall back to the Scan flow only if the target is ineligible. Either way, at most one issue may be **implemented** (code written, branch pushed) per run — the sole exception is batching up to 3 same-recipe slices of a single *umbrella* issue into one child issue + PR (step 12a); that batch is still one concern, not a second issue. Evaluating a candidate and finding it infeasible does not count as "working" it: in Scan mode, step 12's infeasible-continuation cap lets a run evaluate up to 3 candidates for feasibility before it must stop, so a single blocked issue can't consume an entire run without any other progress being attempted.
+
+## Definition of Done
+
+This routine runs in two modes (Step 0): **Targeted** (a fire named an issue) and **Scan** (scheduled / no issue named). In **Targeted mode**, the run is SUCCESS if you claimed and implemented the target issue to a pushed draft PR (or documented why it is infeasible and released the claim, or ended via step 13's **collision bail** — a competing open PR discovered immediately before opening yours: branch pushed, claim comment annotated, no unassign, no second PR) — or, when the target was *ineligible* (closed / has an open PR / claimed by a live run), you fell back to the Scan flow and met the Scan criteria below.
+
+In **Scan mode**, the run is SUCCESS only if ALL of these are true:
+
+- [ ] Checked all open PRs for unresolved or unaddressed review comments and pushed fixes for any that are actionable
+- [ ] Closed any issues whose corresponding PRs are all merged
+- [ ] If no open PRs needed attention: picked the highest-priority *unclaimed* issue (P1 > P2 > P3); if it turned out to be already-done (step 10 — all its PRs merged), closed it and moved on to the next-priority candidate rather than stopping there; otherwise **claimed it before starting work** (see the Claim protocol), and either implemented a fix and **opened a draft pull request on GitHub via `gh pr create --draft`** or left a comment explaining why autonomous completion is blocked and released the claim, then repeated candidate selection for the next-priority issue per step 12's infeasible-continuation cap
+- [ ] If an issue was implemented: successfully opened a draft pull request on GitHub via `gh pr create --draft` referencing the issue (`Closes #N`) in its body, verified the PR exists (a returned PR URL is mandatory), updated the issue's `## Tasks` checkboxes (`- [ ]` → `- [x]`) for every deliverable the PR ships, marked the PR ready for review (`gh pr ready <PR>`), and executed step 15's in-session review wait (never stop at merely pushing the branch or editing the issue; a pushed branch with no open PR on GitHub is a fatal invariant violation and must be logged as FAILURE)
+- [ ] Did not open a new PR while any existing PR by this routine has unaddressed review comments (a finding you have replied to with a rationale counts as *addressed*, even if the thread is still technically unresolved) — **Targeted mode is exempt**
+- [ ] Never worked an issue that was already actively claimed (assigned) by another live run, and confirmed sole ownership of the claim before writing any code — reclaiming a *stale* claim (a dead run's orphaned assignment, per step 10a) is permitted
+- [ ] If work was an umbrella slice/batch (step 12a): the child issue created for it carries the required Summary/Tasks/Why/Complexity template and exactly one type/size/priority label, and the `🧭 Decomposition plan` markers were left `🔍 in review` until the child PR merges
+
+If any criterion cannot be met, stop immediately and log FAILURE with the reason.
+
+## Constraints
+
+- **Max iterations**: 65 — after 65 tool call rounds without completing the Definition of Done, STOP. Log FAILURE with category `token_limit`. Do not retry the same failing approach.
+- **Max scope**: at most one issue may be **implemented** per run. Do not pick up a second, unrelated issue to implement after finishing (or abandoning mid-implementation) the first. (Umbrella slice batching up to 3 slices per step 12a is allowed).
+- **No mid-run context switch**: priorities are evaluated ONCE, at the start of the run (Phase 1 → Phase 2). Finish the issue you started; the next run's Phase 1 will pick up newly surfaced work.
+- **No speculative work**: only take actions directly required by the Definition of Done. Do not refactor adjacent code, open bonus issues, or add improvements not requested by the issue.
+- **Single-flight per issue**: multiple autowork runs can execute concurrently. An issue is a shared resource — never begin implementing one without first claiming it (see the Claim protocol in Phase 2).
+- **Language Requirement**: All GitHub issue titles, descriptions, task checklists, and comments MUST be written in **English**.
+- **Session link footer**: sign every GitHub post (issue comments, PR comments, PR descriptions) with the Antigravity run footer (`_Generated by [Antigravity](${GITHUB_SERVER_URL}/${GITHUB_REPOSITORY}/actions/runs/${GITHUB_RUN_ID})_`). Inline review-thread line comments are exempt.
+
+## Negative examples (DO NOT do these)
+
+- Do not address a subset of review findings and stop — handle ALL findings in one run before stopping or marking the PR as ready.
+- Do not mark a PR as ready for review without first re-fetching review threads *and PR-level comments* and confirming every finding matching step 2's trust & noise rules has been handled.
+- Do not strand a PR in draft because you disagree with a finding — reply with your rationale, mark the PR ready, and let peer-review re-evaluate.
+- Do not push a branch and stop without running `gh pr create --draft` to actually open the pull request — a pushed branch with no open PR cannot be picked up by the peer-review routine.
+- Do not open a new PR if you already have 3+ open PRs — converge before creating more (**Scan mode only**; Targeted mode is exempt).
+- Do not *implement* multiple *unrelated* issues in a single run.
+- Do not close an issue just because it is old — only close if the work is done and PRs are merged.
+- Do not attempt an issue that requires environment secrets, manual testing, or external service setup — mark it as infeasible with a comment.
+- Do not start implementing an issue before claiming it (both assignment AND claim comment).
+- Do not mark a PR ready while its `mergeable_state` is `dirty` — resolve merge conflicts first.
+
+## Instructions
+
+### Step 0: Determine Targeted vs Scan mode (before Phase 1)
+
+This routine runs in two modes, decided here before any other work:
+- **Targeted mode** — an environment variable `$ISSUE_NUMBER` (or explicit issue payload) names a target issue. Work *that* issue as the run's objective, **ahead of** Phase 1 convergence and the normal priority scan.
+- **Scan mode** — no issue is named (a scheduled cron run). Run Phase 1, then select an issue by priority in Phase 2.
+
+Check if `$ISSUE_NUMBER` environment variable is set (or scan invocation text for `#<number>` / `/issues/<number>`):
+- **Found one → Targeted mode.** Record it as this run's target issue and proceed to Step 0.5.
+- **None found → Scan mode.** Proceed as a scheduled run: Phase 1, then normal priority selection in Phase 2.
+
+### Step 0.5: Targeted mode — work the target issue first (only when Step 0 found one)
+
+a. **Read the target issue and check eligibility.** Eligible = open, unassigned or reclaimable stale claim, no open PR (`Closes #N`), and not carrying `needs-human` or `needs-design`.
+   - **Ineligible** → fall back to Phase 1 and run the normal Scan flow.
+b. **Eligible → claim, then implement.** Call `get_me` once to learn your own login (step 7), reclaim stale claim if applicable (step 10a), run Claim protocol (step 11), evaluate and implement per steps 12–13, open draft PR, and run in-session review wait (step 15).
+
+### Phase 1: Converge on open work (Scan mode; skipped in Targeted mode)
+
+1. List all open PRs authored by this routine.
+2. For each open PR, fetch ALL review threads and PR-level comments. Filter for actionable findings matching trust & noise rules (author login matching `get_me`, non-noise). Address every single one in this run — push fixes for actionable findings, reply to clarifying questions, and comment on deferred items.
+3. For PRs where you have addressed all findings:
+3a. **Pre-ready self-audit** (run before marking ready):
+   - **Automated review passes**: run `/code-review` (evaluating along Standards in `AGENTS.md` and Spec in the issue's `## Tasks`) and security review over the diff. Fix what they flag.
+   - **Repository conventions scan**: read and verify all rules and conventions specified in `AGENTS.md` (or `CLAUDE.md`/`GEMINI.md`), project-level skills in `.agents/skills/`, and project documentation.
+   - **Documentation accuracy**: update relevant docs (`ARCHITECTURE.md`, `CODEMAP.md`, `API.md`, `CHANGELOG.md` if maintained by repo).
+   - **Build & type-check verification**: run the repository's test, type-check, and lint commands from `AGENTS.md` (e.g. `npm test`, `npm run type-check`, `npm run lint`, `pytest`, `cargo test`). Confirm zero errors and zero test failures.
+   - **Clean-merge gate**: verify `git merge-tree origin/main HEAD` reports no conflicts.
+   Only mark the PR ready after passing every check above.
+3b. **Ping-pong cap**: If this same PR has bounced between draft and ready 3 or more times over the same substantive finding, stop re-marking it ready. Post a comment summarizing the disagreement for human resolution and leave the PR in draft.
+4. Check open issues that have linked merged PRs — close them.
+5. If any PR was updated in this phase, STOP — run is SUCCESS.
+
+### Phase 2: New work (only if Phase 1 had nothing to do)
+
+6. Count open PRs authored by automated sessions representing live reviewable work (excluding log-only PRs). If 3 or more non-log PRs are open, STOP — run is SUCCESS with "Too many open PRs, converging first".
+7. Call `get_me` once to learn your own GitHub account (`login`).
+8. List open issues sorted by priority labels (P1 > P2 > P3). Within the same priority tier, order by type (`bug`/`security` before others), then oldest first. Skip assigned issues (unless stale claim per `ORCHESTRATION.md`), issues with open PRs, issues labeled `needs-human` or `needs-design`, and issues under cross-run cooldown.
+9. If no eligible candidate exists, STOP — run is SUCCESS with "No unclaimed work available".
+10. If the candidate should be closed already (work done, PRs merged), close it and return to step 8.
+10a. **Stale-claim reclamation:** If candidate is a stale claim per `ORCHESTRATION.md`, re-read immediately before writing, unassign the dead owner, post reclamation comment, and proceed to claim.
+11. **Claim protocol:**
+    a. Re-read candidate issue immediately before claiming (`issue_read`). If assigned, abort and pick next candidate.
+    b. Claim atomically: assign yourself (`login` from step 7) AND post claim comment `🔒 Claimed by autowork run {timestamp}`.
+    c. Confirm sole ownership by counting `🔒 Claimed by autowork run` comments. Earliest `created_at` wins. If you lost the race, leave assignee as is, annotate your comment, and pick next candidate.
+12. Evaluate whether the claimed issue can be completed autonomously:
+    - Confirm your `🔒` claim comment is present on the issue.
+    - Read the issue description, linked code, and comment thread.
+    - If bug: use `/diagnosing-bugs` to establish reproduction test before fixing.
+    - If large/complex: use `/domain-modeling` and `/codebase-design`.
+    - If infeasible: comment explaining blocker, release claim (unassign), and select next candidate (up to 3 infeasible evaluations per run). If permanent blocker on 2nd strike, apply `needs-human` label and tag repo owner.
+12a. **Umbrella-issue handoff + batching:** If candidate is an umbrella epic:
+    - Read `🧭 Decomposition plan` comment (or create if first run).
+    - Pick next slice(s), batching up to 3 same-recipe slices into one child issue + PR.
+    - Create and claim child issue first, then update plan marker to `🚧 in progress — child #M`, release umbrella claim, and implement against child.
+13. **Implementation & PR creation:**
+    - Branch from freshly fetched `origin/main` with descriptive name (e.g. `feat/...` or `fix/...`).
+    - Drive implementation via `/tdd` (red-green-refactor).
+    - Run repository tests and verification.
+    - Check for competing open PRs immediately before creating PR. If collision, bail cleanly.
+    - Open draft PR via `gh pr create --draft --head <branch> --base main --title "<title>" --body "<body referencing Closes #N>"`.
+    - Verify PR URL returned. Update issue `## Tasks` checkboxes.
+    - Mark PR ready (`gh pr ready <PR>`).
+14. If run aborts before opening PR, release claim (unassign).
+15. **In-Session Peer Review Wait & Immediate Convergence (Warm Context):**
+    - Poll PR status for up to 10–12 minutes.
+    - If merged: record terminal SUCCESS and exit cleanly.
+    - If bounced to draft with findings: fetch review comments, apply fixes in active worktree, run tests, push fix commit, re-mark ready (`gh pr ready <PR>`), and complete run.
+    - If timeout (>12m): exit cleanly; scheduled cron will handle subsequent rounds.
+
+## Logging
+
+After completing (SUCCESS or FAILURE), write a log file to `.github/prompts/logs/autowork/{timestamp}.md` following the schema in `.github/prompts/logs/_template.md`. Include:
+- The prompt SHA (run `git rev-parse --short HEAD:.github/prompts/autowork.md`)
+- Every Definition of Done criterion with YES/NO and evidence
+- Full execution trace with tool calls
+- If FAILURE: root cause, category, and suggested fix
+
+**Important**: Commit the log file directly to `main` and push — explicitly permitted for files under `.github/prompts/logs/**`. Follow the Log delivery fallback in `ORCHESTRATION.md` if direct push fails.

package/templates/prompts/dependency-update-security-check.md

@@ -0,0 +1,44 @@
+# Dependency Update & Security Check
+
+## Objective
+
+Check all dependencies for available updates and known security vulnerabilities, report findings grouped by severity, and create or update GitHub issues for actionable items. Security vulnerabilities are highest priority — a vulnerability is actionable even when the affected dependency is not outdated (e.g. a transitive dependency, or an advisory with no fix released yet).
+
+## Definition of Done
+
+The run is SUCCESS only if ALL of these are true:
+
+- [ ] Ran the project package manager's outdated check (`npm outdated`, `pip list --outdated`, `cargo outdated`, etc.) and collected outdated dependencies
+- [ ] Ran dependency security audit (`npm audit`, `pip-audit`, `cargo audit`, etc.) and collected known vulnerabilities (including transitive dependencies)
+- [ ] For each outdated dependency, determined: current vs latest version, update type (major/minor/patch), breaking changes, and security advisories
+- [ ] For each vulnerability, determined: affected package, severity, direct vs transitive, and fixed version availability
+- [ ] Created or updated a GitHub issue for each vulnerability and each major update
+- [ ] If everything is up to date and no vulnerabilities were found, logged SUCCESS with "All dependencies current, no known vulnerabilities"
+
+If any criterion cannot be met, stop immediately and log FAILURE with the reason.
+
+## Constraints
+
+- **Max iterations**: 30 — after 30 tool call rounds without completing Definition of Done, STOP. Log FAILURE with category `token_limit`.
+- **Max scope**: report and issue creation only. Do not open code PRs in this routine.
+- **No speculative work**: check dependencies declared in the project's manifest files (`package.json`, `pyproject.toml`, `Cargo.toml`).
+- **Language Requirement**: All GitHub issue titles, descriptions, task checklists, and comments MUST be written in **English**.
+
+## Instructions
+
+1. Run the outdated dependencies check for the repository's package manager.
+2. Run the security audit command to check for known CVEs/GHSA vulnerabilities across direct and transitive dependencies.
+3. For each outdated package, check current vs latest version and note breaking changes for major bumps.
+4. For each vulnerability, extract severity, package name, and remediation version.
+5. Search existing open issues before creating new ones to prevent duplicate tracking.
+6. Create or update issues with clear labels: `security` and `priority/P1` for known CVEs; `dependencies` and `priority/P3` for non-security major updates.
+7. If all dependencies are current and no vulnerabilities exist, confirm clean status.
+
+## Logging
+
+After completing (SUCCESS or FAILURE), write a log file to `.github/prompts/logs/dependency-update-security-check/{timestamp}.md` following the schema in `.github/prompts/logs/_template.md`. Include:
+- Prompt SHA
+- Tally of audited dependencies and security findings
+- List of created or updated issues
+
+**Important**: Commit the log file directly to `main` and push. Follow the Log delivery fallback in `ORCHESTRATION.md` if direct push fails.

package/templates/prompts/issues-housekeeping.md

@@ -0,0 +1,55 @@
+# Issues Housekeeping
+
+## Objective
+
+Sweep all open issues for staleness, duplicates, batch-consolidation opportunities (sets of small related issues addressable together), label drift, priority accuracy, dependency status, and orphaned autowork claims, and land any accumulated draft log-only PRs. Fix what can be fixed and post a summary of changes made.
+
+## Definition of Done
+
+The run is SUCCESS only if ALL of these are true:
+
+- [ ] All open issues have been scanned
+- [ ] Priority review completed: P1s re-evaluated, quick-win promotions considered, priority rubric enforced
+- [ ] Duplicate & batch-consolidation check completed: overlapping issues closed with cross-references, small related issues consolidated
+- [ ] Stale / obsolete check completed: premise-obsolete issues closed, idle issues resolved
+- [ ] Label audit completed: every open issue has consistent type, size, and priority labels
+- [ ] Dependency check completed: issues with `## Dependencies` verified against blocker status
+- [ ] Orphaned-claim sweep completed: stale autowork claims (per `ORCHESTRATION.md`) released back to the unclaimed pool
+- [ ] Draft log-only PR sweep completed: open draft PRs whose changed files are entirely under `.github/prompts/logs/**` undrafted and squash-merged
+- [ ] Summary posted listing all changes made
+
+If any criterion cannot be met, stop immediately and log FAILURE with the reason.
+
+## Constraints
+
+- **Max iterations**: 40 — after 40 tool call rounds without completing Definition of Done, STOP. Log FAILURE with category `token_limit`.
+- **Max scope**: housekeeping only. Do not implement code fixes or open feature PRs.
+- **No speculative work**: only modify issue metadata (labels, status, comments, releasing stale assignees) and land draft log-only PRs.
+- **Language Requirement**: All GitHub issue titles, descriptions, task checklists, and comments MUST be written in **English**.
+
+## Instructions
+
+### Phase 1: Quick Recovery & Clearing
+
+1. **Draft log-only PR sweep**: Undraft and squash-merge open draft PRs whose diffs are entirely under `.github/prompts/logs/**`.
+2. **Orphaned-claim sweep**: Sweep assigned issues. If an issue meets the 3 stale-claim conditions in `ORCHESTRATION.md` (autowork claim comment, no open PR, comment > 6 hours old), re-read immediately before writing, unassign the dead owner, and post a release comment.
+
+### Phase 2: Backlog Hygiene
+
+3. **Priority review**: Check open P1/P2/P3 issues. Promote critical bugs or unblocked items; demote items that lack immediate priority.
+4. **Duplicate & consolidation check**: Identify duplicate issues; close duplicates with cross-references. Consolidate small, related micro-tasks into batch issues.
+5. **Premise-obsolete & stale check**: If an issue's premise was resolved by already-merged PRs or recent refactors, close as completed with evidence.
+6. **Label audit**: Ensure open issues carry standard role labels (`needs-triage`, `ready-for-agent`, `needs-human`, etc.). Use `/triage` if classifying incoming issues.
+
+### Phase 3: Summary
+
+7. Post a summary comment or log recording all actions taken (priority shifts, closed duplicates, released claims, landed log PRs).
+
+## Logging
+
+After completing (SUCCESS or FAILURE), write a log file to `.github/prompts/logs/issues-housekeeping/{timestamp}.md` following the schema in `.github/prompts/logs/_template.md`. Include:
+- Prompt SHA
+- Tally of issues audited, claims released, PRs merged
+- List of closed or modified issues
+
+**Important**: Commit the log file directly to `main` and push. Follow the Log delivery fallback in `ORCHESTRATION.md` if direct push fails.

package/templates/prompts/optimizer.md

@@ -0,0 +1,72 @@
+# Prompt Optimizer
+
+## Objective
+
+Scan recent agent run logs and closed issues, diagnose four classes of problem — **failures** (runs that logged FAILURE), **inefficiency** (runs burning excessive iterations or multi-loop PRs), **token consumption & cost anomalies** (runs trending toward weekly budget ceilings), and **preventable bugs & defect avoidance** (analyzing resolved bugs to determine root causes and authoring/review prevention checks) — and propose targeted prompt, template, test, and workflow fixes via pull requests.
+
+Additionally, this routine acts as the **Upstream Evolution Bridge**: when a prompt improvement solves a generic orchestrator pattern (benefiting all fleet-connected projects), it proposes the fix upstream to the `jonah-fleet` repository (`juliendurandeu/jonah-fleet`).
+
+## Definition of Done
+
+The run is SUCCESS if ALL of these are true:
+
+- [ ] All log files from the incremental window in `.github/prompts/logs/` have been scanned
+- [ ] Every FAILURE log has been categorized and analyzed
+- [ ] Inefficiency and review loops per PR have been computed across SUCCESS logs
+- [ ] Closed bug issues and merged bug-fix PRs in the window have been analyzed for systemic root causes
+- [ ] For each fixable pattern:
+  - If project-specific: opened a local PR with a prompt, template, or test fix and marked ready for review
+  - If generic/fleet-wide: opened an upstream PR against `juliendurandeu/jonah-fleet` (or flagged via `npx jonah-fleet contribute`)
+- [ ] Every PR links a tracking issue via `Closes #N`
+- [ ] If no issues or optimization patterns are found, logged SUCCESS with "No issues to address"
+
+If any criterion cannot be met, stop immediately and log FAILURE with the reason.
+
+## Constraints
+
+- **Max iterations**: 30 — stop after 30 tool call rounds.
+- **Max scope**: one PR per identified problem. Do not bundle unrelated fixes.
+- **No speculative work**: only fix patterns evidenced by logs, closed bug issues, or reviewer findings.
+- **Language Requirement**: All GitHub issue titles, descriptions, task checklists, and comments MUST be written in **English**.
+
+## Instructions
+
+### 0. Establish the incremental scan boundary
+
+1. Check `.github/prompts/logs/optimizer/` for the most recent optimizer log.
+2. Extract the timestamp as the scan boundary (or last 7 days if first run).
+
+### 1. Collect signals & analyze logs
+
+1. Scan in-window log files in `.github/prompts/logs/*/`.
+2. Extract failure categories: `prompt_unclear`, `data_issue`, `token_limit`, `infeasible_task`.
+3. Compute efficiency metrics: PRs with 3+ review rounds, high iteration usage.
+4. Analyze resolved bugs for missing checks in authoring (`autowork.md`) or review (`peer-review.md`).
+
+### 2. Formulate preventative improvements
+
+Translate findings into concrete preventative improvements:
+- Enhance pre-ready checklist in `autowork.md`
+- Add automated verification tests or invariant checks
+- Clarify ambiguous prompt instructions
+
+### 3. Open Fix PR (Local or Upstream Bridge)
+
+- **Local Improvement**: If the fix touches repository-specific rules, local docs, or custom tests:
+  - Branch from `origin/main`, apply changes, and open PR via `gh pr create --draft`.
+  - Link tracking issue and mark ready for review (`gh pr ready <PR>`).
+- **Generic / Fleet Improvement**: If the fix improves core prompt orchestration, claim protocols, or universal error handling:
+  - Open a PR against upstream `juliendurandeu/jonah-fleet` using the GitHub CLI:
+    ```bash
+    npx jonah-fleet contribute --title "fix(prompt): <description>" --body "<evidence from local run logs>"
+    ```
+    or branch and open a PR against upstream `juliendurandeu/jonah-fleet`.
+
+## Logging
+
+After completing (SUCCESS or FAILURE), write a log file to `.github/prompts/logs/optimizer/{timestamp}.md` following the schema in `.github/prompts/logs/_template.md`. Include:
+- Prompt SHA
+- Analyzed logs count and identified patterns
+- PRs opened (local or upstream)
+
+**Important**: Commit the log file directly to `main` and push. Follow the Log delivery fallback in `ORCHESTRATION.md` if direct push fails.