@doidor/agentrig 0.5.3

package/knowledge/PRINCIPLES.md

@@ -0,0 +1,106 @@
+# AgentRig — Principles of a successful agent harness
+
+> This is AgentRig's **canonical, editable** copy of the harness principles. Edit it freely;
+> `agentrig update` will carry your edits into any repo that uses AgentRig.
+> Synthesized from `infinity-microsoft/epichan`, `office-shared/fluent-agent`, and
+> `microsoft/fluentui`.
+
+A *harness* is the surrounding scaffolding (orchestration, prompts, skills, memory, evaluation)
+that lets autonomous coding agents reliably **triage → implement → review → judge → merge** with
+minimal human babysitting. AgentRig installs an opinionated harness into any repo, keeps context of
+what the repo is about, and ships a way to **evaluate the harness itself**.
+
+Each principle below names the concrete artifact(s) AgentRig installs and how the harness audit
+(`agentrig eval --static`) scores it.
+
+---
+
+## 1. Treat the workflow as an explicit state machine
+Every task moves through named states (`ingested → queued → implementing → reviewing → judging →
+ready_to_merge → merged → closed`) and every transition declares its trigger. The DAG is the
+contract; agents do not invent transitions and reviewers cannot skip gates.
+**Artifact:** `.agentrig/harness/state-machine.yml`.
+
+## 2. Specialize roles, vary models
+Route each state to a *role* (`triager`, `developer`, `reviewer`, `judge`), each with a short prompt
+and its own `model_tier`. Run the reviewer on a **different model than the developer** — single-model
+-bias mitigation matters more than any prompt tweak. The roster is extensible: add new agent types
+(`designer`, `security-reviewer`, …) by dropping a `<role>.{yml,md}` in and wiring a transition.
+**Artifact:** `.agentrig/agents/{triager,developer,reviewer,judge}.{yml,md}` (+ `README.md`) with
+distinct models.
+
+## 3. Externalize state in a system of record
+GitHub is the source of truth. Labels are the contract, not decoration. Pollers reconcile the
+engine against GitHub on a cadence; events drive reactive transitions. If the engine crashes,
+GitHub still tells you the truth. A **dashboard** surfaces the live picture: which tasks sit in which
+state (by label), who they're assigned to, plus harness score and eval status.
+**Artifact:** labels/state mapping in the state machine + MCP GitHub server +
+`.agentrig/dashboard/dashboard.mjs` (`agentrig dashboard`).
+
+## 4. Skills are procedural memory; rules are reflexes
+Skills (`SKILL.md` with YAML frontmatter for triggers, `allowed-tools`, `argument-hint`) encode
+*how to do one thing well*. They are composable, auto-discovered, tool-scoped, and mirrored across
+vendor surfaces (`.claude/`, `.copilot/`, `.agents/`, …). Rules are glob-scoped and auto-loaded
+when matching files are edited, with an explicit priority order.
+**Artifact:** `.agents/skills/*/SKILL.md`, `.agents/rules/*.md` + `README.md`.
+
+## 5. Self-verify before handoff
+After producing work, the implementing agent runs its own verification loop (build/test/visual)
+pinned to its own HEAD and decides between *iterate*, *continue*, or *self-park*. The reviewer is
+only invoked once the producer's loop has converged. Cap iteration attempts (N=3) and fall back.
+**Artifact:** `.agents/skills/self-verify/SKILL.md`.
+
+## 6. Independent, rubric-driven evaluation
+Score work on explicit axes with credit tiers (0 / 0.5 / 1.0), a mandatory **issue code** plus
+evidence whenever a score is < full, and a deterministic aggregator (never hand-edited JSON). This
+is how you tell whether a prompt change made the agent better or worse — and it is how you evaluate
+**the harness itself**.
+**Artifact:** `.agentrig/eval/` (RUBRIC.md, checks.json, scenarios, score.mjs, static-audit.mjs)
+and the `harness-eval` skill.
+
+## 7. Hermetic per-agent environments
+Each concurrent agent runs in its **own git worktree** so developers, reviewers, and judges never
+trip over each other's working trees or lockfiles. A repair script prunes stale worktree metadata
+before every add. Isolation is a hard prerequisite for multi-agent throughput.
+**Artifact:** `scripts/repair-worktrees.sh` + worktree guidance in the wiki.
+
+## 8. Continuous self-improvement: every mistake is a prompt bug
+Agents log new gotchas to a tiered memory (central committed wiki → local git-ignored wiki →
+session scratch). A `skill-improver` turns reviewer feedback into instruction-surface changes that
+must pass a **prevention test** ("would this new wording have changed the original failure?").
+Strict admission tests stop duplication from killing the wiki.
+**Artifact:** `.agents/wiki/` + `.agents/skills/skill-improver/SKILL.md`.
+
+## 9. Human-in-the-loop where reversibility is low
+Low-reversibility actions are recommend-then-apply: the agent surfaces proposed changes and waits
+for explicit `apply`/`approve`/`skip`. Certain labels are **human-only gates** the agent must never
+apply or even name. These are deliberate trust boundaries, not friction.
+**Artifact:** human-gate declarations in the state machine + rules.
+
+## 10. Hard limits and safety nets
+Set `max_review_iterations`, `max_diff_chars`, a token `runaway_cap`, and `pre_pr`/`pre_merge`
+hooks. Protected files require a human-override label. A recovery scan re-queues anything stuck too
+long. These caps keep an agent pool from melting the repo.
+**Artifact:** `limits:` block in `.agentrig/harness/state-machine.yml`.
+
+## 11. One canonical source, projected to every agent surface (local + remote)
+The harness keeps **one** source of truth (`AGENTS.md` + `.agents/rules/` + `.agents/skills/`) and
+**projects** it into each ecosystem's native discovery format so *any* agent benefits without
+lock-in — local CLIs **and** remote/cloud agents:
+- **GitHub Copilot (remote coding agent + IDE):** `.github/copilot-instructions.md`,
+  path-scoped `.github/instructions/*.instructions.md` (`applyTo` globs), and
+  `.github/workflows/copilot-setup-steps.yml` for the cloud agent's environment.
+- **Claude Code:** `CLAUDE.md`. **Cursor:** `.cursor/rules/*.mdc`. **OpenCode/Codex:** `AGENTS.md`.
+- **MCP** mirrored to each surface (`.mcp.json`, `.vscode/mcp.json`, `.github/copilot/mcp.json`).
+
+This is the meta-harness payoff: assign an issue to the web GitHub Copilot agent and it sees the same
+rules/setup/MCP as your local Copilot CLI, Claude Code, or Cursor. Projections regenerate from the
+source; never hand-edit the generated files.
+**Artifact:** the compiler (`agentrig compile`) + the projected files above; symlinked vendor dirs
+for skills.
+
+## 12. Instructions are the source of truth, not existing code
+A short, unmissable **Critical Rules** block at the top of `AGENTS.md` beats a 50-page contributing
+guide. Pair it with package-local AGENTS.md, golden-principles docs, and a directory map so an
+agent can answer "what should I do?" without spelunking. Legacy code is not the spec.
+**Artifact:** root `AGENTS.md` with a `Critical Rules` section + repo context.

package/knowledge/manifest.json

@@ -0,0 +1,247 @@
+{
+  "$schema": "agentrig-manifest/1",
+  "knowledgeVersion": "0.3.3",
+  "description": "Declares which best-practice artifacts AgentRig installs into a target repo and where. `src` is relative to the knowledge/ root; `dest` is relative to the target repo root. `kind`: file | dir | template. Templates contain {{PLACEHOLDERS}} the agent fills from its investigation; deterministic installs substitute known values and leave the rest for the agent.",
+  "artifacts": [
+    {
+      "id": "agents-md",
+      "principle": 12,
+      "src": "templates/AGENTS.md",
+      "dest": "AGENTS.md",
+      "kind": "template",
+      "merge": "markers"
+    },
+    {
+      "id": "principles",
+      "principle": 12,
+      "src": "PRINCIPLES.md",
+      "dest": ".agentrig/PRINCIPLES.md",
+      "kind": "file"
+    },
+    {
+      "id": "agents-package-example",
+      "principle": 12,
+      "src": "templates/AGENTS.package.example.md",
+      "dest": ".agentrig/AGENTS.package.example.md",
+      "kind": "file"
+    },
+    {
+      "id": "state-machine",
+      "principle": 1,
+      "src": "templates/harness/state-machine.yml",
+      "dest": ".agentrig/harness/state-machine.yml",
+      "kind": "file",
+      "refresh": "preserve"
+    },
+    {
+      "id": "orchestration",
+      "principle": 1,
+      "src": "templates/harness/ORCHESTRATION.md",
+      "dest": ".agentrig/harness/ORCHESTRATION.md",
+      "kind": "file"
+    },
+    {
+      "id": "role-developer-yml",
+      "principle": 2,
+      "src": "templates/agents/developer.yml",
+      "dest": ".agentrig/agents/developer.yml",
+      "kind": "file",
+      "refresh": "preserve"
+    },
+    {
+      "id": "role-developer-md",
+      "principle": 2,
+      "src": "templates/agents/developer.md",
+      "dest": ".agentrig/agents/developer.md",
+      "kind": "file",
+      "refresh": "preserve"
+    },
+    {
+      "id": "role-reviewer-yml",
+      "principle": 2,
+      "src": "templates/agents/reviewer.yml",
+      "dest": ".agentrig/agents/reviewer.yml",
+      "kind": "file",
+      "refresh": "preserve"
+    },
+    {
+      "id": "role-reviewer-md",
+      "principle": 2,
+      "src": "templates/agents/reviewer.md",
+      "dest": ".agentrig/agents/reviewer.md",
+      "kind": "file",
+      "refresh": "preserve"
+    },
+    {
+      "id": "role-judge-yml",
+      "principle": 2,
+      "src": "templates/agents/judge.yml",
+      "dest": ".agentrig/agents/judge.yml",
+      "kind": "file",
+      "refresh": "preserve"
+    },
+    {
+      "id": "role-judge-md",
+      "principle": 2,
+      "src": "templates/agents/judge.md",
+      "dest": ".agentrig/agents/judge.md",
+      "kind": "file",
+      "refresh": "preserve"
+    },
+    {
+      "id": "role-triager-yml",
+      "principle": 2,
+      "src": "templates/agents/triager.yml",
+      "dest": ".agentrig/agents/triager.yml",
+      "kind": "file",
+      "refresh": "preserve"
+    },
+    {
+      "id": "role-triager-md",
+      "principle": 2,
+      "src": "templates/agents/triager.md",
+      "dest": ".agentrig/agents/triager.md",
+      "kind": "file",
+      "refresh": "preserve"
+    },
+    {
+      "id": "roles-readme",
+      "principle": 2,
+      "src": "templates/agents/README.md",
+      "dest": ".agentrig/agents/README.md",
+      "kind": "file",
+      "refresh": "preserve"
+    },
+    {
+      "id": "skill-self-verify",
+      "principle": 5,
+      "src": "templates/skills/self-verify",
+      "dest": ".agents/skills/self-verify",
+      "kind": "dir"
+    },
+    {
+      "id": "skill-fix-ci",
+      "principle": 4,
+      "src": "templates/skills/fix-ci",
+      "dest": ".agents/skills/fix-ci",
+      "kind": "dir"
+    },
+    {
+      "id": "skill-skill-improver",
+      "principle": 8,
+      "src": "templates/skills/skill-improver",
+      "dest": ".agents/skills/skill-improver",
+      "kind": "dir"
+    },
+    {
+      "id": "skill-harness-eval",
+      "principle": 6,
+      "src": "templates/skills/harness-eval",
+      "dest": ".agents/skills/harness-eval",
+      "kind": "dir"
+    },
+    {
+      "id": "skill-verify-loop",
+      "principle": 5,
+      "src": "templates/skills/verify-loop",
+      "dest": ".agents/skills/verify-loop",
+      "kind": "dir"
+    },
+    {
+      "id": "skill-authoring",
+      "principle": 4,
+      "src": "templates/skills/skill-authoring",
+      "dest": ".agents/skills/skill-authoring",
+      "kind": "dir"
+    },
+    {
+      "id": "rules",
+      "principle": 4,
+      "src": "templates/rules",
+      "dest": ".agents/rules",
+      "kind": "dir"
+    },
+    {
+      "id": "wiki",
+      "principle": 8,
+      "src": "templates/wiki",
+      "dest": ".agents/wiki",
+      "kind": "dir"
+    },
+    {
+      "id": "mcp",
+      "principle": 11,
+      "src": "templates/mcp/mcp.json",
+      "dest": ".mcp.json",
+      "kind": "file",
+      "refresh": "preserve"
+    },
+    {
+      "id": "worktree-script",
+      "principle": 7,
+      "src": "templates/scripts/repair-worktrees.sh",
+      "dest": "scripts/repair-worktrees.sh",
+      "kind": "file",
+      "mode": "0755"
+    },
+    {
+      "id": "eval-rubric",
+      "principle": 6,
+      "src": "templates/eval/RUBRIC.md",
+      "dest": ".agentrig/eval/RUBRIC.md",
+      "kind": "file"
+    },
+    {
+      "id": "eval-axes",
+      "principle": 6,
+      "src": "templates/eval/axes.json",
+      "dest": ".agentrig/eval/axes.json",
+      "kind": "file"
+    },
+    {
+      "id": "eval-checks",
+      "principle": 6,
+      "src": "templates/eval/checks.json",
+      "dest": ".agentrig/eval/checks.json",
+      "kind": "file"
+    },
+    {
+      "id": "eval-static-audit",
+      "principle": 6,
+      "src": "templates/eval/static-audit.mjs",
+      "dest": ".agentrig/eval/static-audit.mjs",
+      "kind": "file",
+      "mode": "0755"
+    },
+    {
+      "id": "eval-score",
+      "principle": 6,
+      "src": "templates/eval/score.mjs",
+      "dest": ".agentrig/eval/score.mjs",
+      "kind": "file",
+      "mode": "0755"
+    },
+    {
+      "id": "eval-scenarios",
+      "principle": 6,
+      "src": "templates/eval/scenarios",
+      "dest": ".agentrig/eval/scenarios",
+      "kind": "dir"
+    },
+    {
+      "id": "eval-sandbox",
+      "principle": 6,
+      "src": "templates/eval/sandbox",
+      "dest": ".agentrig/eval/sandbox",
+      "kind": "dir"
+    },
+    {
+      "id": "dashboard",
+      "principle": 3,
+      "src": "templates/dashboard/dashboard.mjs",
+      "dest": ".agentrig/dashboard/dashboard.mjs",
+      "kind": "file",
+      "mode": "0755"
+    }
+  ]
+}

package/knowledge/templates/AGENTS.md

@@ -0,0 +1,66 @@
+# {{REPO_NAME}} — Agent instructions
+
+> Managed in part by [AgentRig](https://github.com/). Sections between AgentRig markers are
+> refreshed by `agentrig update`; edit outside the markers (and the repo-specific context) freely.
+
+## Critical Rules (read first, every time)
+<!-- AGENTRIG:critical-rules:start -->
+1. **Instructions are the source of truth, not existing code.** This repo may contain legacy
+   patterns that predate current standards. When code and these instructions disagree, follow the
+   instructions and flag the discrepancy.
+2. **Self-verify before handoff.** Run the project's build/test/lint and the `self-verify` skill
+   before you mark work ready. Never hand a red build to a reviewer.
+3. **Never skip a state-machine gate** (`.agentrig/harness/state-machine.yml`) and never apply a
+   human-only label. Low-reversibility actions are recommend-then-apply.
+4. **Respect hard limits** (diff size, review iterations, token cap) declared in the state machine.
+5. **Every mistake is a prompt bug.** When you hit a gotcha, record it in `.agents/wiki/` and, if a
+   skill or rule should have prevented it, run `skill-improver`.
+<!-- AGENTRIG:critical-rules:end -->
+
+## What this repository is
+<!-- AGENTRIG:context:start -->
+{{REPO_SUMMARY}}
+
+See `.agentrig/context.md` for the full, agent-authored investigation of this repository.
+<!-- AGENTRIG:context:end -->
+
+## How to build, test, and lint
+<!-- AGENTRIG:commands:start -->
+- **Install:** `{{INSTALL_CMD}}`
+- **Build:** `{{BUILD_CMD}}`
+- **Test:** `{{TEST_CMD}}`
+- **Lint:** `{{LINT_CMD}}`
+<!-- AGENTRIG:commands:end -->
+
+## Directory map
+<!-- AGENTRIG:dirmap:start -->
+{{DIRECTORY_MAP}}
+<!-- AGENTRIG:dirmap:end -->
+
+## The harness
+<!-- AGENTRIG:harness:start -->
+- **Workflow / state machine:** `.agentrig/harness/state-machine.yml`
+- **Agent roles & models:** `.agentrig/agents/` (triager, developer, reviewer, judge — each on a
+  varied model; reviewer differs from developer on purpose). See `.agentrig/agents/README.md` to add
+  new agent types.
+- **Skills (procedural memory):** `.agents/skills/`
+<!-- AGENTRIG:skills-inventory:start -->
+{{SKILLS_INVENTORY}}
+<!-- AGENTRIG:skills-inventory:end -->
+- **Rules (reflexes, glob-scoped):** `.agents/rules/`
+- **Memory / wiki:** `.agents/wiki/` (see `index.md` for what belongs where)
+- **Tooling (MCP):** `.mcp.json`
+- **Agent surfaces (compiled):** `agentrig compile` projects this file + `.agents/rules/` into every
+  agent's native format — `.github/copilot-instructions.md` & `.github/instructions/` (Copilot, web +
+  IDE), `CLAUDE.md` (Claude Code), `.cursor/rules/` (Cursor), `.vscode/mcp.json`, and
+  `.github/workflows/copilot-setup-steps.yml`. Edit the source here, not the generated files.
+- **Surfaces:** `.claude` / `.copilot` / `.opencode` / `.codex` symlink to `.agents` so any vendor CLI
+  sees the same skills/rules/wiki.
+- **Orchestration contract:** `.agentrig/harness/ORCHESTRATION.md`
+- **Dashboard:** `agentrig dashboard` (or `node .agentrig/dashboard/dashboard.mjs`) — agent roster,
+  live GitHub tasks per harness label, harness score, and eval status. `--html` for a web view.
+- **Evaluate the harness itself:** `agentrig eval --static` or `node .agentrig/eval/static-audit.mjs`;
+  see `.agentrig/eval/RUBRIC.md`.
+- **Package-local instructions:** drop an `AGENTS.md` in a subpackage to add scope-specific rules;
+  it augments this root file. See `.agentrig/AGENTS.package.example.md`.
+<!-- AGENTRIG:harness:end -->

package/knowledge/templates/AGENTS.package.example.md

@@ -0,0 +1,19 @@
+# <package name> — Agent instructions (package-local)
+
+> Drop a file like this at the root of a subpackage/subtree. It **augments** the repo-root
+> `AGENTS.md` with scope-specific guidance; it does not replace the root Critical Rules.
+
+## Scope
+Applies to everything under this directory.
+
+## What this package is
+One or two sentences: purpose, public surface, who depends on it.
+
+## Local rules
+- Build/test/lint commands specific to this package, if they differ from the root.
+- Conventions that only apply here (naming, layering, allowed dependencies).
+- Files/areas to treat as protected or generated.
+
+## Pointers
+- Root policy: `/AGENTS.md`
+- Path-scoped reflexes: add a glob-scoped rule under `.agents/rules/` instead of repeating it here.

package/knowledge/templates/agents/README.md

@@ -0,0 +1,33 @@
+# Agent roles (principle 2 — specialize roles, vary models)
+
+The harness routes each state of the workflow to a **specialized agent type**, each with its own
+short prompt and its own model. Running different roles on **different models** is deliberate:
+single-model-bias mitigation surfaces problems no single model would catch alone.
+
+## Roster (installed by default)
+
+| Role | File | Default model | Drives state |
+|------|------|---------------|--------------|
+| **triager**  | `triager.{yml,md}`  | `gpt-5-mini` (low)        | `ingested → queued` |
+| **developer**| `developer.{yml,md}`| `claude-sonnet-4.5` (high)| `queued → implementing → reviewing` |
+| **reviewer** | `reviewer.{yml,md}` | `gpt-5` (high)            | `reviewing` |
+| **judge**    | `judge.{yml,md}`    | `claude-opus-4.5` (high)  | `judging → ready_to_merge` |
+
+> Keep the **reviewer on a different model family than the developer**. The audit
+> (`agentrig eval --static`) checks for this.
+
+## Each role has two files
+- `<role>.yml` — declarative config: `role`, `model`, `model_tier`, `allowed_tools`, and the
+  `prompt` path. Skills are auto-discovered from `.agents/skills/`, so no skill list is needed.
+- `<role>.md` — the role's short prompt (keep it to a few imperative lines).
+
+## Adding a new agent type
+1. Create `agents/<role>.yml` and `agents/<role>.md`. Pick a model that differs from adjacent roles
+   in the pipeline.
+2. Wire the role into `.agentrig/harness/state-machine.yml` by giving a transition
+   `trigger: agent` and `role: <role>`.
+3. If the role needs a new procedure, add a skill under `.agents/skills/`.
+
+Example roles you might add: `designer` (visual/UX work), `security-reviewer`, `release-manager`,
+`docs-writer`. The pipeline is yours to extend — the state machine is the contract that keeps it
+coherent.

package/knowledge/templates/agents/developer.md

@@ -0,0 +1,7 @@
+You are the **developer**. Implement the smallest correct change that fully satisfies the task.
+
+- Follow `AGENTS.md` Critical Rules and the glob-scoped rules in `.agents/rules/`.
+- Run `self-verify` (build + test + lint) before requesting review. Iterate up to 3 times; if still
+  red, self-park with a clear note rather than handing a broken diff to the reviewer.
+- Keep the diff under the `max_diff_chars` limit. Split work if it grows larger.
+- Log any new gotcha to `.agents/wiki/`.

package/knowledge/templates/agents/developer.yml

@@ -0,0 +1,7 @@
+# Developer role (principle 2). Implements the change in the `implementing` state.
+role: developer
+model: claude-sonnet-4.5
+model_tier: high
+# Skills are auto-discovered from .agents/skills; no explicit list needed.
+allowed_tools: [read, write, edit, bash, grep, glob]
+prompt: agents/developer.md

package/knowledge/templates/agents/judge.md

@@ -0,0 +1,6 @@
+You are the **judge**. Score the completed work against `.agentrig/eval/RUBRIC.md`.
+
+- Use credit tiers 0 / 0.5 / 1.0. Any score < 1.0 REQUIRES an issue code and one line of evidence.
+- Save results with `.agentrig/eval/score.mjs` (never hand-edit the JSON).
+- Pass to `ready_to_merge` only if the aggregate clears the threshold; otherwise return to
+  `implementing` with the failing axes.

package/knowledge/templates/agents/judge.yml

@@ -0,0 +1,6 @@
+# Judge role (principle 2, 6). Independent, rubric-driven scoring before merge.
+role: judge
+model: claude-opus-4.5
+model_tier: high
+allowed_tools: [read, grep, glob, bash]
+prompt: agents/judge.md

package/knowledge/templates/agents/reviewer.md

@@ -0,0 +1,6 @@
+You are the **reviewer**, running a different model than the developer on purpose.
+
+- Review only the diff. Surface bugs, security issues, and logic errors — never style nits.
+- Score with confidence per category; refuse to surface low-signal comments.
+- If you request changes, return to `implementing` with a concrete, testable reason.
+- You may not apply human-only labels (see the state machine).

package/knowledge/templates/agents/reviewer.yml

@@ -0,0 +1,7 @@
+# Reviewer role (principle 2). Deliberately a DIFFERENT model family than the developer
+# to mitigate single-model bias — divergent verdicts surface problems neither model alone catches.
+role: reviewer
+model: gpt-5
+model_tier: high
+allowed_tools: [read, grep, glob, bash]
+prompt: agents/reviewer.md

package/knowledge/templates/agents/triager.md

@@ -0,0 +1,8 @@
+You are the **triager**. Turn a freshly `ingested` task into a well-formed `queued` one.
+
+- Read the issue/task and the repo context (`.agentrig/context.md`).
+- Recommend labels, an assignee/role, and a size estimate. Surface them as a proposal table and
+  **wait for explicit apply/approve** — never apply human-only labels (see the state machine).
+- Confirm the task is actionable (clear acceptance criteria). If not, ask for clarification rather
+  than queueing ambiguous work.
+- When approved, move the task to `queued`.

package/knowledge/templates/agents/triager.yml

@@ -0,0 +1,8 @@
+# Triager role (principle 2, 9). Moves `ingested` tasks to `queued`: recommend labels/assignees,
+# size the work, and gate on human approval for low-reversibility calls. Uses a fast, cheap model
+# on purpose — triage is high-volume and should not burn a premium tier.
+role: triager
+model: gpt-5-mini
+model_tier: low
+allowed_tools: [read, grep, glob, bash]
+prompt: agents/triager.md