create-byan-agent 2.23.0 → 2.26.0

package/install/templates/.claude/skills/byan-benchmark/SKILL.md

@@ -0,0 +1,159 @@
+---
+name: byan-benchmark
+description: Orchestrating conductor for the native byan-benchmark engine. Detects a real decision fork (>=2 non-substitutable options that diverge on >=1 weighted criterion), runs the autonomous DATA-only matrix engine (.claude/workflows/byan-benchmark.js) via the Workflow tool, renders the compact 1-table best-first, and emits the BYAN-BENCH marker so the auto-benchmark Stop hook is satisfied. Invoke when you are about to present a choice between options, when the user says "benchmark X vs Y", "compare these approaches", "which option", or when the auto-benchmark doctrine arms on a fork.
+---
+
+# byan-benchmark - Conductor (gate outside, engine inside)
+
+You are the human-gated conductor for the native byan-benchmark workflow. The
+autonomous scoring runs in `.claude/workflows/byan-benchmark.js` (the in-CLI
+Workflow tool); YOU own the fork detection, the rendered table, the BYAN-BENCH
+marker, and any FD/strict state. This split is the Hybrid pattern: the engine is
+native and deterministic, the gate stays on a real main-thread turn where the
+BYAN hooks fire.
+
+## Why this skill exists
+
+A launched Workflow script is autonomous: it cannot pause to ask a human, the
+main-thread hooks (including the auto-benchmark Stop hook) do not fire inside it,
+and it must not mutate BYAN state on its own. So the script returns a DATA matrix;
+this skill turns that data into a rendered, gated decision and emits the marker.
+
+## Protocol
+
+### 1. Detect the fork + gates
+
+Apply the 2-gate trigger before launching anything:
+
+- **G1** - there are >=2 non-trivial, non-substitutable options.
+- **G2** - the options diverge on >=1 weighted criterion (if they are coherent
+  with the locked stack, there is nothing to benchmark).
+
+NEVER benchmark a y/n confirm, a destructive prompt (delete/drop/rm -rf/
+overwrite/force push/reset --hard), or a trivial ack. For the degenerate /
+obvious-default case, do NOT table it - emit the skip marker (see step 5b).
+
+Routing decides links BEFORE depth decides verbosity:
+- `scope: internal` (within the existing repo/stack) - NO external links,
+  coherence-first.
+- `scope: external` (a new dependency / vendor / standard) - sourcing allowed,
+  but a URL appears ONLY if WebFetch opened it THIS turn; otherwise `[UNVERIFIED]`.
+
+### 2. Run the engine (dual-path)
+
+Prefer the native script. If `.claude/workflows/byan-benchmark.js` exists, run it
+via the Workflow tool; otherwise fall back to the markdown workflow
+(`_byan/workflow/simple/bmb/byan-benchmark/workflow.md`). The programmatic
+resolver is `resolveWorkflow('byan-benchmark')` in
+`_byan/mcp/byan-mcp-server/lib/workflows-generator.js`.
+
+```
+Workflow({ name: 'byan-benchmark', args: {
+  question: '<the fork as a question>',
+  options:  [{ name: 'Option A', note: '...' }, { name: 'Option B', note: '...' }],
+  criteria: [{ name: 'C1 ...', weight: 2 }, { name: 'C2 ...', weight: 1 }],
+  judges:   [ /* optional opposed-lens panel; omit for a single neutral judge */ ],
+  domain:   'general | security | performance | compliance',
+  scope:    'internal | external'
+} })
+```
+
+The script runs RECON -> SOURCE -> JUDGE -> RECOMMEND and returns DATA only:
+
+```json
+{ "workflow": "byan-benchmark", "question": "...", "scope": "internal",
+  "domain": "general", "options": [...], "criteria": [...],
+  "matrix": [{ "option": "...", "cells": [{ "criterion": "...", "verdict": "...",
+               "level": "L2", "score": 8, "source": "...", "unverified": false }],
+             "total": 0 }],
+  "recommendation": { "best": "...", "line": "...", "confidence": "assertive|lean" },
+  "dissent": { "option": "...", "why": "..." },
+  "degenerate": false, "needsHumanGate": true }
+```
+
+### 3. (BYAN only, opt-in) enrich cells with byan_fc_check
+
+This step is BYAN-only - other platforms skip it. For each cell whose `verdict`
+is a HARD CLAIM (a factual assertion in security / performance / compliance, or
+any absolute), call the MCP tool to raise the cell's authority:
+
+```
+mcp__byan__byan_fc_check({ text: '<the cell claim>' })  ->  { level, score, ... }
+```
+
+Stamp the returned `{ level, score }` onto the cell's `level` column. This makes
+the Niv column an audited evidence level, not a self-graded one. Respect the
+strict-domain floors: a `security`/`performance` claim below L2, or a
+`compliance` claim below L1, stays flagged `[UNVERIFIED]`. Enrichment is opt-in;
+skip it for low-stakes internal forks to keep latency down.
+
+### 4. Render the compact 1-table (best-first)
+
+Render ONE compact table, ordered best-first, within the hard caps:
+
+- **<= 4 options**, **<= 4 criteria**, **<= 3 links**, **1 screen**.
+
+```
+| Option   | C1 ... | C2 ... | C3 ... | Niv |
+|----------|--------|--------|--------|-----|
+| A (best) | ...    | ...    | ...    | L2  |
+| B        | ...    | ...    | ...    | L4  |
+
+Reco: <recommendation.line>   (confidence: <assertive recommend X | lean X, low-confidence>)
+Dissent: <dissent.option> wins on <dissent.why>.
+```
+
+The confidence verb is load-bearing: `assertive` -> "recommend X"; `lean` ->
+"lean X (low-confidence)". A URL appears ONLY if WebFetch opened it this turn;
+otherwise tag the cell `[UNVERIFIED]` and cite from model-knowledge.
+
+### 5. Emit the BYAN-BENCH marker (satisfies the Stop hook)
+
+#### 5a. Real benchmark presented
+
+On the SAME turn that shows the table, emit the marker verbatim on a single
+line, IMMEDIATELY BEFORE the table (so it survives truncation):
+
+```
+<!-- BYAN-BENCH:done g1=<#options> g2=<#divergent-criteria> scope=<internal|external> conf=<assertive|lean> -->
+```
+
+`g1` >= 2 and `g2` >= 1 or the marker is invalid.
+
+#### 5b. Degenerate / deliberate skip
+
+If the engine returned `degenerate: true`, or the fork is an obvious-default /
+confirm / destructive / already-coherent case, do NOT table it - emit the skip
+marker instead (a positive signal that the fork was CONSIDERED and deliberately
+not tabled):
+
+```
+<!-- BYAN-BENCH:skip reason=<obvious-default|never-listed|escape-hatch|already-coherent> -->
+```
+
+### 6. Expanded form (named trigger)
+
+The default is the compact 1-table. If the user types `[bench:expand]`, render
+the expanded form: full per-judge scorecards, every cell's evidence and source,
+and the dissent rationale in full. Still emit the `done` marker.
+
+### 7. Record the run (only after the gate)
+
+After the user acts on the recommendation, if inside an FD or strict session,
+record the outcome through the `byan_fd_*` / `byan_strict_*` MCP tools so the
+audit trail stays in the MCP authority. Do NOT write FD/strict state files
+directly. The auto-benchmark miss-ledger
+(`_byan-output/benchmark-ledger.jsonl`) is appended by the Stop hook, not by
+this skill.
+
+## Invariants
+
+- The script returns DATA; THIS skill owns rendering, the marker, completion and
+  state. (Enforcement contract: see `docs/native-workflows-contract.md`.)
+- The human gate stays on a real main-thread turn, outside the script.
+- Dual-path: native `.js` preferred, markdown fallback. No silent downgrade.
+- No fabricated URL: `[UNVERIFIED]` unless WebFetch opened it this turn.
+- Strict-domain floors: security/performance L2+, compliance L1.
+- Escape-hatch respected: if `.byan-autobench/off` is present (or the
+  cross-session opt-out is set), the doctrine does not force a benchmark.
+- No emoji in outputs (IA-23). Comments/notes justify the WHY only (IA-24).

package/install/templates/.claude/skills/byan-byan/SKILL.md

@@ -79,17 +79,18 @@ Never call `byan_update_apply` without explicit user consent. That tool returns
 - **Visibility** : the `tool-transparency` hook already writes per-tool entries to `_byan-output/tool-log.jsonl`. Every sub-task you spawn must be visible there.
 - **Exit gate** : user sees the diff and says "ok build".
 
-### Phase 6 — REVIEW
-- **Who** : Quinn (QA) — role-play or delegate to `bmad-bmm-quinn` subagent. Pre-flight humain before VALIDATE.
-- **Goal** : detect false-positives qualitatively before the machine runs. REVIEW is qualitatif; VALIDATE is quantitatif.
+### Phase 6 — REVIEW (qualitative pre-flight + tiered adversarial second pair of eyes)
+- **Who** : Quinn (`bmad-bmm-quinn`) for the qualitative pass, every time. PLUS an adversarial second reviewer that is NOT the BUILD author — `bmad-compliance` — spawned TIERED by dispatch (step 2), not on a trivial edit. The reviewer must differ from the author (no self-review).
+- **Goal** : a real second opinion before the machine runs. REVIEW is qualitatif + adversarial ; VALIDATE is quantitatif.
 - **Protocol** :
-  1. Load expected VALIDATE criteria : planned tests from BUILD, MantraValidator targets, mantra-risk per change type.
-  2. Inspect the diff : readability, naming, side effects, coverage per branch, comments justified (POURQUOI), zero emoji.
-  3. Cross-check planned tests vs implemented tests. Cross-check mantra risks vs actual code.
-  4. Output `{ status: "ready-for-validate" | "needs-rework", findings: [...] }` and persist via `byan_fd_update({ patch: { review_findings: [...] } })`.
+  1. **Quinn pass** : inspect the diff — readability, naming, side effects, coverage per branch, comments justified (POURQUOI), zero emoji. Cross-check planned vs implemented tests and mantra risks per change type.
+  2. **Tier the compliance review** on the dispatch signal : spawn `bmad-compliance` when the feature's `byan_dispatch` score >= 15 OR it touches a strict domain (security / performance / compliance). Below that, skip it (Ockham + token budget) and note `compliance: skipped-trivial`.
+  3. **Open the review** (when tiered in) : `byan_review_request({ task_id: <feature-id | commit sha>, author: <BUILD agent name>, artifact_paths: [<changed files>], description: <one line> })`. Pick a reviewer that differs from the author : `byan_review_pick_reviewer({ author: <BUILD agent> })` ; fall back to `bmad-compliance` if it returns the author or null.
+  4. **Spawn the reviewer** via the Agent tool (`subagent_type: "bmad-compliance"`, model inherited). Prompt it to apply its lenses (security hygiene, fact-check, mantras) and to CALL `byan_review_verdict` to persist `{ approve | changes | block }` with `must_fix`.
+  5. Output `{ status: "ready-for-validate" | "needs-rework", findings: [...], compliance: <verdict | "skipped-trivial"> }` and persist via `byan_fd_update({ patch: { review_findings: [...] } })`.
 - **Exit gate** :
-  - `ready-for-validate` → advance to VALIDATE.
-  - `needs-rework` → short-circuit to REFACTOR (skip VALIDATE this cycle).
+  - `ready-for-validate` (Quinn clean AND compliance `approve` or `skipped-trivial`) → advance to VALIDATE.
+  - `needs-rework` (Quinn finds rework OR compliance returns `changes` / `block`) → short-circuit to REFACTOR with the `must_fix` items (skip VALIDATE this cycle).
 
 ### Phase 7 — VALIDATE
 - **Who** : MantraValidator + jest/node test + `byan-fact-check` skill. No human judgement, only numbers.
@@ -125,6 +126,65 @@ Never call `byan_update_apply` without explicit user consent. That tool returns
 - **Exit gate** : all `blocking_issues` resolved → advance back to BUILD (loop). The state machine explicitly allows REFACTOR → BUILD as the only backward transition.
 - **Guard-rail** : 3 consecutive BUILD→REVIEW→VALIDATE→REFACTOR cycles without convergence → propose retour to PRUNE (mal cadré) or ABORTED.
 
+## 2.5. Leantime project sync (one-way FD → board)
+
+Leantime (self-hosted project management) is an optional external board. When
+`LEANTIME_API_URL` + `LEANTIME_API_TOKEN` are configured (injected via `.mcp.json`
+`${...}`), the FD lifecycle is mirrored onto Leantime in ONE direction — FD drives
+the board ; the board does not drive FD. When the pair is absent, the sync is off
+and every FD phase proceeds unchanged.
+
+### Automatic — the `leantime-fd-sync` hook (primary path)
+
+You do NOT call `byan_leantime_*` by hand. A `PostToolUse` hook
+(`.claude/hooks/leantime-fd-sync.js`, registered in `.claude/settings.json`) fires
+after `byan_fd_advance` / `byan_fd_update` and mirrors the board for you:
+
+| FD event | Board effect |
+|----------|--------------|
+| project_context set (DISCOVERY) | create-or-fetch the Leantime project (+ assign the human when `LEANTIME_ASSIGN_USER_ID` is set) |
+| backlog set, DISPATCH onward | one task per backlog feature, in `todo` |
+| BUILD | tasks → `doing` |
+| REVIEW needs-rework / VALIDATE KO | tasks → `blocked` |
+| VALIDATE OK | tasks → `review` |
+| DOC | tasks → `review` |
+| COMPLETED | all tasks → `done` |
+| ABORTED | board left verbatim (no move) |
+
+The hook is best-effort and bounded : it exits 0 in every path (a sync issue does
+not block the turn), no-ops when Leantime is off, self-heals a dropped call on the
+next phase event, and surfaces a one-line breadcrumb only on a real failure
+(`non_json` / `timeout` / `http_*` / `rpc_error`). It logs every attempt to
+`.byan-leantime/sync.jsonl`. Columns resolve to the project's configured status
+ids at call time (per-project), with a conservative fallback.
+
+### State-coupling + idempotence
+
+The hook does not read or write `fd-state.json` ; it reads the fd-state the MCP
+tool echoes, and keeps the Leantime id map in the gitignored sidecar
+`.byan-leantime/map.json` (keyed by `fd_id` : `{ projectId, tasks:{<F-id>:taskId},
+lastColumn }`). The sidecar is the single idempotence ledger : a project/task is
+created only when its id is absent, so a REFACTOR loop re-builds without spawning
+a duplicate. `lib/leantime-sync.js` is the only Leantime client ;
+`lib/leantime-fd-core.js` is the pure decision core ; the hook is the I/O shell.
+
+### Manual fallback
+
+If the hook is removed from `.claude/settings.json`, the same fire points can be
+driven by hand via the `byan_leantime_*` tools at each phase event. Full usage
+guide : `docs/leantime-integration.md`.
+
+### Reading the result (do not lie about a failed sync)
+
+Each call returns `{ ok, synced, reason? }`. Surface a non-synced result in one
+line rather than pretending the board moved :
+- `no_base` / `no_token` → sync is off ; mention it once, proceed.
+- `non_json` → `LEANTIME_API_URL` points at the Leantime UI host, not the
+  `/api/jsonrpc` backend (the wrong-host lesson). Fix the env, do not read the
+  HTML as an empty board.
+- `timeout` / `http_<status>` / `rpc_error` → transient or wire issue ; the FD
+  phase still advances, the move can be retried at the next phase event.
+
 ## 3. Session state
 
 A FD cycle in progress is tracked in `_byan-output/fd-state.json` :
@@ -134,9 +194,9 @@ A FD cycle in progress is tracked in `_byan-output/fd-state.json` :
   "phase": "DISCOVERY | BRAINSTORM | PRUNE | DISPATCH | BUILD | REVIEW | VALIDATE | REFACTOR | DOC | COMPLETED | ABORTED",
   "started_at": "<iso>",
   "feature_name": "<slug>",
-  "project_context": { "name": "...", "slug": "...", "domain": "...", "stack": "...", "summary": "...", "source": "mcp|local" },
+  "project_context": { "name": "...", "slug": "...", "domain": "...", "stack": "...", "summary": "...", "source": "mcp|local", "leantime": { "projectId": 0 } },
   "raw_ideas": [],
-  "backlog": [ { "id": "F1", "title": "...", "priority": "P1|P2|P3", "status": "pending|building|done|skipped" } ],
+  "backlog": [ { "id": "F1", "title": "...", "priority": "P1|P2|P3", "status": "pending|building|done|skipped", "leantime": { "taskId": 0 } } ],
   "dispatch_table": [],
   "commits": [],
   "review_findings": [ { "status": "ready-for-validate|needs-rework", "items": [...] } ],
@@ -166,9 +226,10 @@ Use the MCP tools `byan_fd_start`, `byan_fd_advance`, `byan_fd_status`, `byan_fd
 | DISCOVERY (project identification, MCP first) | BYAN (this skill) |
 | BRAINSTORM, PRUNE, DISPATCH, VALIDATE | BYAN (this skill) |
 | BUILD execution per feature | `byan-hermes-dispatch` |
-| REVIEW (qualitative pre-flight) | Quinn (`bmad-bmm-quinn`) or BYAN role-play |
+| REVIEW (qualitative pre-flight) | Quinn (`bmad-bmm-quinn`) ; tiered adversarial gate `bmad-compliance` (dispatch >= 15 or strict domain) via `byan_review_request` |
 | REFACTOR (corrective loop to BUILD) | Same agent/worker that did BUILD |
 | DOC (CHANGELOG, README, manifests) | Paige (`bmad-bmm-tech-writer`) or BYAN role-play |
+| Leantime sync (one-way FD → board, fire points at phase events) | BYAN fires `byan_leantime_*` ; `lib/leantime-sync.js` is the only Leantime client (see section 2.5) |
 | Parallel team of specialists | `byan-orchestrate` (extends hermes for N-role) |
 | Persona / voice | Soul + Tao (loaded by SessionStart hook) |
 | Transparency | `tool-transparency` PreToolUse hook |

package/install/templates/.claude/skills/byan-fact-check/SKILL.md

@@ -84,7 +84,7 @@ node bin/byan-v2-cli.js fc sheet [session-id]
 ## Agent dedie
 
 ```
-@fact-checker   # Agent Copilot CLI dedie
+@fact-checker   # Agent dedie
 [FC]            # Sous-menu dans l'agent @byan
 ```
 

package/install/templates/.claude/skills/byan-hermes-dispatch/SKILL.md

@@ -28,7 +28,6 @@ Match keywords against the routing table below. Pick the single best match. If n
 | create module, new module | module-builder (Morgan) | |
 | create workflow, new workflow | workflow-builder (Wendy) | |
 | npm, publish, package | rachid | |
-| copilot integration | marc | |
 | optimize tokens, reduce size | carmack | |
 | product brief, prd, requirements | pm (John) | |
 | architecture, design system, tech stack | architect (Winston) | |
@@ -83,11 +82,11 @@ For any spawned strategy : pass `model` to the Agent tool when it is non-null; o
 
 ### 5. Specialist stub path lookup
 
-Resolve the specialist name to its agent file :
+Resolve the specialist name to its agent (Claude-native, in priority order) :
 
-- First try : `.github/agents/<name>.md` or `.github/agents/bmad-agent-<name>.md`
-- Fallback : search `agent-manifest.csv` in `_byan/_config/` or `.github/copilot/_config/`
-- If the specialist has been generated as a skill (F0.3), prefer invoking the skill directly via `/byan-<specialist-name>` instead of the Agent tool.
+- First try the skill : if the specialist exists as a skill, invoke it directly via `/byan-<specialist-name>` (preferred over the Agent tool).
+- Else the Claude subagent stub : `.claude/agents/bmad-<name>.md`, spawned via the Agent tool with `subagent_type`.
+- Fallback : resolve the role from `agent-manifest.csv` in `_byan/_config/`.
 
 ### 6. Report back
 
@@ -105,7 +104,7 @@ No flourish. No "I have successfully…". Just the table.
 
 ## Parallel mode (N tasks)
 
-If the user (or calling agent) provides N independent subtasks and `parallelizable: true`, use the **party-mode-native** workflow (`_byan/core/workflows/party-mode-native/workflow.md`) instead of dispatching one-by-one :
+If the user (or calling agent) provides N independent subtasks and `parallelizable: true`, use the **party-mode-native** workflow (`_byan/workflow/simple/party-mode-native/workflow.md`) instead of dispatching one-by-one :
 
 1. Call `coordination.initSession` to register the roles.
 2. Dispatch all N Agent tool calls **in one message**.

package/install/templates/.claude/skills/byan-insight/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: byan-insight
+description: Harvest the native Claude Code outcome trails (tool-log, strict-audit gaps, suitability ledger, ELO) into a GATED self-improvement digest for BYAN. Invoke when the user asks "what did this session teach BYAN", "insight digest", "self-improvement", "qu'est-ce que BYAN a appris", or wants to review recurring gaps / routing outcomes / tool health before deciding what to improve. Observe and propose; the human ratifies each change.
+---
+
+# BYAN Insight Loop (gated self-improvement)
+
+BYAN already has advisory learning surfaces (ELO trust, the suitability ledger,
+soul-memory) and the native Claude Code hooks already leave outcome trails on
+disk. This skill closes the loop: it READS those trails, aggregates them into a
+digest, and surfaces GATED proposals. It does not modify a behavior surface.
+
+## The one hard rule: observe and propose, do not silently self-modify
+
+An agent that rewrote its own routing, personas, or mantra thresholds on a
+heuristic would be the exact silent-downgrade BYAN exists to prevent. So this
+loop stops at a PROPOSAL. Applying a change (a routing tweak, a new checklist
+item, a persona edit) stays a human decision — ideally run as its own FD. The
+advisory data (ELO, suitability) is read-only here; behavior surfaces are left
+to the human gate.
+
+## Protocol
+
+1. **Harvest.** Call the MCP tool `byan_insight_digest` (read-only, no args). It
+   returns `{ gated: true, digest, render }` where `digest` is
+   `{ toolHealth, recurringGaps, routingOutcomes, eloTrends, proposals }`.
+   - `toolHealth` : call count, failure rate, top failing tools, output-token cost
+     (from `_byan-output/tool-log.jsonl`).
+   - `recurringGaps` : clustered self-verify gap themes with counts (from
+     `.byan-strict/audit.log`) — what BYAN keeps missing.
+   - `routingOutcomes` : per cheap-model x leaf keep-rate (from the suitability
+     ledger) — where a downgrade is proven good or bad.
+   - `eloTrends` : per-domain trust rating.
+   - `proposals` : conservative, GATED suggestions (each `gated: true`).
+2. **Present.** Show the `render` text, then the proposals as a numbered list.
+   Make explicit that nothing has been applied.
+3. **Gate.** For each proposal the user accepts, run the change as its own scoped
+   work (a short FD for a behavior change; a direct edit for a doc/checklist).
+   Do not auto-apply a proposal.
+
+## CLI equivalent
+
+```
+node _byan/mcp/byan-mcp-server/bin/byan-insight-digest.js [--root <dir>] [--json]
+```
+
+Prints the human-readable digest, or the raw JSON with `--json`. Self-disables
+(empty digest) when the trails are absent, so a fresh checkout is not an error.
+
+## What it deliberately leaves alone
+
+- It does not call `byan_elo_record` / `byan_suitability_record` for you (those
+  stay where the outcome actually happens, e.g. a VALIDATE pass).
+- It does not edit `lib/dispatch.js`, `native-tiers.js`, a persona, or the mantra
+  thresholds. Those are behavior surfaces; a proposal names them, a human
+  changes them.

package/install/templates/.claude/skills/byan-orchestrate/SKILL.md

@@ -40,7 +40,7 @@ Use this a priori mapping — override only if the task clearly needs more :
 | analyst, pm, sm, ux-designer, tech-writer, brainstorming-coach, storyteller | sonnet | Text structuring, not deep reasoning |
 | dev, quick-flow-solo-dev | sonnet | Code generation, mid complexity |
 | architect, quinn, tea, creative-problem-solver | opus | Deep reasoning, trade-offs |
-| carmack, rachid, marc, patnote | haiku | Narrow mechanical tasks |
+| carmack, rachid, patnote | haiku | Narrow mechanical tasks |
 
 Then call `byan_dispatch` with each role's goal (and `nature` when known). Use its `score` for the STRATEGY only (score < 15 → inline, no subagent ; 15-39 → subagent/worker ; ≥ 40 → keep the heavy role in the main thread) and its nature-based `model` as the tier signal. The score sets WHERE the role runs, not WHICH model — keep protected roles (verify/analysis/implement) off haiku regardless of size, and avoid pinning a role up to opus on size alone. The per-role table above is the a-priori floor; `byan_dispatch`'s nature `model` refines it.
 
@@ -69,19 +69,25 @@ Group roles by `parallelizable_with` graph. For each parallel cluster :
 
 - If cluster has N > 1 roles AND all use `agent-subagent-worktree` strategy → use the **party-mode-native** workflow : `coordination.initSession(roles, …)`, then dispatch all Agent tool calls in a single message.
 - If cluster has N = 1 OR strategy = `main-thread` → execute inline in the current turn.
+
+On a 2+ role spawn, open the shared board for visibility (the kanban family is built for exactly this) : after `coordination.initSession`, call `byan_kanban_create({ sessionId: <the party-mode session id> })`, then once per role `byan_kanban_add({ sessionId, card: { id: <role>, title: <role> } })`. The card `id` is the ROLE NAME — unique per role, and the key the move step references; do NOT reuse the session id (the cards share one board, ids must differ). A multi-agent run without a board is invisible to the user.
 - If strategy = `mcp-worker` → spawn an Agent tool call WITHOUT worktree (faster boot, single-turn) ; set the Agent's model to the role's nature-based `model` (haiku for exploration, omit otherwise to inherit the session model).
 
 For each Agent tool call, the prompt must start with :
 ```
 You are acting as the <role> BMAD agent. Load your persona from
-.github/agents/bmad-agent-<role>.md (read it first, then respond in
+.claude/agents/bmad-<role>.md (read it first, then respond in
 character). Task: <goal>. Deliverables: <list>. Report back as JSON
 with status/summary/files_changed per the party-mode-native contract.
 ```
 
 ### 5. Aggregate and report
 
-After all subagents return (or inline roles finish), read each `agent-<role>.json` via `coordination.readAgentReport`, then write `summary.md` via `coordination.writeSummary`. Report to the user :
+After all subagents return (or inline roles finish), read each `agent-<role>.json` via `coordination.readAgentReport` (report contract : `{ status: ok|partial|failed, summary, files_changed, next_steps }`). Then, for EACH returned role (post all of them — an `ok` post writes an empty `blockers` array, which resets that role's streak ; skipping `ok` roles breaks the streak math) :
+- Post its standup : `byan_standup_post({ sessionId, agent: <role>, did: <report.summary>, blockers: <report.status is 'failed' or 'partial' ? [report.summary] : []>, next: <(report.next_steps || []).join('; ')> })`. The report contract has NO `blockers` field — synthesize it from a non-`ok` status (an `ok` role posts `[]`).
+- Move its card : `byan_kanban_move({ sessionId, cardId: <role>, toColumn: <report ok ? 'review' : 'blocked'>, blocker_reason: <report ok ? omit : report.summary> })`. `cardId` is the role name set at add time. Use `review`, not `done`, on success — the human gate owns completion; `done` is the user's call, not the orchestrator self-certifying.
+
+Then surface stuck roles : `byan_standup_blocked({ sessionId, minStreak: 1 })` — `minStreak: 1` because the aggregate posts exactly one stand-up per role, so a single `blocked`/`failed`/`partial` report should flag (a 2-in-a-row streak is unreachable in a single pass). If it returns flagged roles, raise them in the report. Finally write `summary.md` via `coordination.writeSummary` and report to the user :
 
 | Role | Model | Strategy | Tokens spent | Outcome |
 |------|-------|----------|--------------|---------|
@@ -98,3 +104,5 @@ Total tokens : 34900. Deliverable : <link to aggregated output>.
 - **Never default to opus.** Opus is opt-in via high complexity score or explicit role mapping. Default = sonnet, upgrade only with justification in the plan.
 - **Never parallel-spawn roles that write to the same paths.** If file scopes overlap, serialize them even if `parallelizable_with` suggests otherwise.
 - **Never ship a plan without `estimated_tokens` per role.** Budget visibility is the whole point.
+- **Open the board on every 2+ role spawn.** `byan_kanban_create` + a card per role ; a multi-agent run without a board hides the work from the user.
+- **Post every role's standup at aggregate, `ok` included.** Posting only failed roles breaks the blocked-streak reset and re-hides a stuck agent — the exact silence this wiring removes.

package/install/templates/.claude/skills/byan-strict/SKILL.md

@@ -24,7 +24,10 @@ complete. Downgrading the scope is the failure this mode exists to prevent.
 
 1. **Lock the scope** with `byan_strict_lock_scope` before building. Provide a
    verbatim restatement of the request and testable `acceptanceCriteria`. The
-   locked scope is the contract.
+   locked scope is the contract. When one technical domain clearly dominates the
+   task, also pass `domain` (e.g. security, performance, javascript) — a
+   successful completion then feeds one VALIDATED tick to the ELO loop. Explicit
+   only; omit when no single domain is clear.
 2. **Build the full scope.** Do not substitute an MVP, a stub, or a simplified
    version. If a part cannot be done, surface it as a gap — do not cut silently.
 3. **Self-verify at least 3 times** with

package/install/templates/.claude/workflows/INDEX.md

@@ -22,8 +22,9 @@
 - `testarch-test-review` — native — source `_byan/workflow/simple/testarch/test-review/workflow.yaml`
 - `testarch-trace` — native — source `_byan/workflow/simple/testarch/trace/workflow.yaml`
 
-## pipeline (9)
+## pipeline (10)
 
+- `byan-benchmark` — native — source `_byan/workflow/simple/bmb/byan-benchmark/workflow.md`
 - `check-implementation-readiness` — native — source `_byan/workflow/simple/3-solutioning/check-implementation-readiness/workflow.md`
 - `code-review` — native — source `_byan/workflow/simple/4-implementation/code-review/workflow.yaml`
 - `create-excalidraw-dataflow` — native — source `_byan/workflow/simple/excalidraw-diagrams/create-dataflow/workflow.yaml`