create-byan-agent 2.25.0 → 2.27.0

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-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`

package/install/templates/.claude/workflows/byan-benchmark.js

@@ -0,0 +1,328 @@
+export const meta = {
+  name: 'byan-benchmark',
+  description: 'DATA-only benchmark engine: given a fork (>=2 options) + weighted criteria + optional judge panel, returns a scored options-x-criteria matrix, a best-first recommendation, and the dissenting view. Reusable for ANY decision fork. The human gate + the rendered table live in the orchestrating skill.',
+  phases: [
+    { title: 'RECON', detail: 'parse options+criteria from args' },
+    { title: 'SOURCE', detail: 'gather evidence per option (model-knowledge default; WebFetch only strict-domain/volatile)' },
+    { title: 'JUDGE', detail: 'score each cell against weighted criteria via the judge panel' },
+    { title: 'RECOMMEND', detail: 'rank best-first + capture dissent' },
+  ],
+};
+
+// ---------------------------------------------------------------------------
+// FD / STRICT STATE CONTRACT  (re-asserted inline - enforcement-bridge F3).
+//
+// The in-CLI Workflow tool runs this script OUTSIDE the conversation turn, so
+// BYAN's main-thread hooks (strict-scope-guard, strict-stop-guard,
+// fd-phase-guard, the autobench Stop hook) DO NOT fire here. This script
+// therefore:
+//   - NEVER imports/requires _byan/.../lib/fd-state.js or the strict-mode lib
+//     (enforced by byan-lint-workflows.js).
+//   - returns DATA only. The orchestrating skill (.claude/skills/byan-benchmark)
+//     is the human-gated conductor; IT renders the table, emits the BYAN-BENCH
+//     marker, and records FD/strict state via the byan_fd_* / byan_strict_* MCP
+//     tools AT the gate.
+// No timestamp / id / RNG is generated in-script: ids and clock-bearing values
+// arrive via the args global, keeping the script deterministic and resumable
+// (the launch validator scans raw text for any wall-clock or RNG primitive).
+// ---------------------------------------------------------------------------
+
+// Strict-domain evidence floors (mirrors .claude/rules/fact-check.md). A claim in
+// these domains must reach at least this proof level or it is flagged unverified.
+// Encoded as data so the JUDGE leaf is told the exact floor for the domain.
+const STRICT_FLOORS = { security: 'L2', performance: 'L2', compliance: 'L1' };
+
+// The 5-level evidence rubric as WRITTEN text, passed verbatim to the JUDGE leaf
+// so every cell's Niv (level) is graded against the same scale the doctrine uses.
+const EVIDENCE_RUBRIC = [
+  'L1 (95%): official spec - RFC, W3C, ECMAScript, POSIX, vendor canonical doc.',
+  'L2 (80%): reproducible benchmark, CVE reference, official product docs.',
+  'L3 (65%): peer-reviewed article, recognised technical book.',
+  'L4 (50%): community consensus (e.g. StackOverflow > 1000 votes).',
+  'L5 (20%): opinion or personal experience.',
+].join(' ');
+
+const RECON_SCHEMA = {
+  type: 'object',
+  required: ['options', 'criteria'],
+  properties: {
+    fork: { type: 'string', description: 'one-line restatement of the decision fork' },
+    options: {
+      type: 'array',
+      description: 'the >=2 candidate options, normalised',
+      items: {
+        type: 'object',
+        required: ['name'],
+        properties: { name: { type: 'string' }, note: { type: 'string' } },
+      },
+    },
+    criteria: {
+      type: 'array',
+      description: 'the weighted criteria the options are scored against',
+      items: {
+        type: 'object',
+        required: ['name', 'weight'],
+        properties: { name: { type: 'string' }, weight: { type: 'number' } },
+      },
+    },
+    valid: { type: 'boolean', description: 'true only if >=2 options and >=1 criterion' },
+    reason: { type: 'string', description: 'when invalid, why (degenerate fork -> skip)' },
+  },
+};
+
+const EVIDENCE_SCHEMA = {
+  type: 'object',
+  required: ['option', 'evidence'],
+  properties: {
+    option: { type: 'string' },
+    evidence: {
+      type: 'array',
+      description: 'one evidence note per criterion for this option',
+      items: {
+        type: 'object',
+        required: ['criterion', 'claim', 'unverified'],
+        properties: {
+          criterion: { type: 'string' },
+          claim: { type: 'string', description: 'the factual basis for this option on this criterion' },
+          source: { type: 'string', description: 'model-knowledge by default; a URL ONLY if WebFetch opened it THIS turn' },
+          unverified: { type: 'boolean', description: 'true when no live source was opened (tag [UNVERIFIED])' },
+        },
+      },
+    },
+  },
+};
+
+const JUDGE_SCHEMA = {
+  type: 'object',
+  required: ['judge', 'scores'],
+  properties: {
+    judge: { type: 'string' },
+    scores: {
+      type: 'array',
+      description: 'for EACH option: a cell per criterion with score, evidence level and the weighted total',
+      items: {
+        type: 'object',
+        required: ['option', 'cells', 'weightedTotal'],
+        properties: {
+          option: { type: 'string' },
+          cells: {
+            type: 'array',
+            items: {
+              type: 'object',
+              required: ['criterion', 'verdict', 'level', 'score', 'unverified'],
+              properties: {
+                criterion: { type: 'string' },
+                verdict: { type: 'string', description: 'short qualitative verdict for this cell' },
+                level: { type: 'string', description: 'evidence level L1..L5 per the rubric' },
+                score: { type: 'number', description: '1-10 raw score for this option on this criterion' },
+                source: { type: 'string' },
+                unverified: { type: 'boolean' },
+              },
+            },
+          },
+          weightedTotal: { type: 'number', description: 'sum of score*weight across criteria' },
+        },
+      },
+    },
+  },
+};
+
+const RECOMMEND_SCHEMA = {
+  type: 'object',
+  required: ['matrix', 'recommendation', 'dissent'],
+  properties: {
+    matrix: {
+      type: 'array',
+      description: 'consolidated one row per option, best-first',
+      items: {
+        type: 'object',
+        required: ['option', 'cells', 'total'],
+        properties: {
+          option: { type: 'string' },
+          cells: {
+            type: 'array',
+            items: {
+              type: 'object',
+              required: ['criterion', 'verdict', 'level', 'score'],
+              properties: {
+                criterion: { type: 'string' },
+                verdict: { type: 'string' },
+                level: { type: 'string' },
+                score: { type: 'number' },
+                source: { type: 'string' },
+                unverified: { type: 'boolean' },
+              },
+            },
+          },
+          total: { type: 'number' },
+        },
+      },
+    },
+    recommendation: {
+      type: 'object',
+      required: ['best', 'line', 'confidence'],
+      properties: {
+        best: { type: 'string', description: 'the winning option name' },
+        line: { type: 'string', description: 'one best-first recommendation line' },
+        confidence: { type: 'string', enum: ['assertive', 'lean'], description: 'assertive=recommend; lean=low-confidence' },
+      },
+    },
+    dissent: {
+      type: 'object',
+      required: ['option', 'why'],
+      properties: {
+        option: { type: 'string', description: 'the runner-up a reasonable judge would defend' },
+        why: { type: 'string', description: 'the criterion on which the runner-up wins' },
+      },
+    },
+  },
+};
+
+// ---- Args contract (read-only via the args global; deterministic fallbacks) ----
+// args.question : the fork stated as a question (string)
+// args.options  : array of { name, ... }  (>=2 for a real benchmark)
+// args.criteria : array of { name, weight } (>=1)
+// args.judges   : optional reusable panel [{ key, lens, weighting }]; default single neutral judge
+// args.domain   : drives strict floors (security/performance/compliance)
+// args.scope    : 'internal' | 'external' (internal -> no external links, coherence-first)
+const A = (typeof args !== 'undefined' && args) || {};
+const QUESTION = A.question || 'unspecified decision fork';
+const RAW_OPTIONS = Array.isArray(A.options) ? A.options : [];
+const RAW_CRITERIA = Array.isArray(A.criteria) ? A.criteria : [];
+const DOMAIN = A.domain || 'general';
+const SCOPE = A.scope === 'external' ? 'external' : 'internal';
+const FLOOR = STRICT_FLOORS[DOMAIN] || null;
+// Default to a single neutral judge so the engine works without a panel; a caller
+// can pass an opposed-lens panel to get a multi-judge consensus instead.
+const JUDGES = (Array.isArray(A.judges) && A.judges.length)
+  ? A.judges
+  : [{ key: 'neutral', lens: 'balanced reviewer', weighting: 'Apply each criterion weight as given; no lens bias.' }];
+
+const optionsBlob = JSON.stringify(RAW_OPTIONS, null, 2);
+const criteriaBlob = JSON.stringify(RAW_CRITERIA, null, 2);
+
+phase('RECON');
+// EXPLORATION leaf: parse + normalise the fork. Labelled 'parse-options' so the
+// linter classifies it as exploration and the haiku downgrade is permitted.
+const recon = await agent(
+  `You are the RECON leaf of byan-benchmark. Parse and normalise this decision fork.\n` +
+    `QUESTION: ${QUESTION}\n` +
+    `RAW OPTIONS: ${optionsBlob}\n` +
+    `RAW CRITERIA: ${criteriaBlob}\n` +
+    `Normalise options to [{name, note?}] and criteria to [{name, weight}] (default weight 1 when missing). ` +
+    `Set valid=true ONLY if there are >=2 distinct, non-substitutable options AND >=1 criterion; ` +
+    `otherwise valid=false with a reason (a degenerate/obvious-default fork should be skipped, not tabled).`,
+  { label: 'parse-options', phase: 'RECON', schema: RECON_SCHEMA, model: 'haiku' }
+);
+
+const options = (recon && Array.isArray(recon.options) && recon.options.length)
+  ? recon.options
+  : RAW_OPTIONS;
+const criteria = (recon && Array.isArray(recon.criteria) && recon.criteria.length)
+  ? recon.criteria
+  : RAW_CRITERIA;
+const degenerate = !(recon && recon.valid) || options.length < 2 || criteria.length < 1;
+
+if (degenerate) {
+  // Collapse the degenerate case: a fork with <2 real options or no criterion is
+  // not benchmarkable. Return DATA telling the skill to emit a BYAN-BENCH:skip.
+  log(`degenerate fork: ${recon && recon.reason ? recon.reason : 'fewer than 2 options or no criteria'}`);
+  return {
+    workflow: 'byan-benchmark',
+    question: QUESTION,
+    scope: SCOPE,
+    domain: DOMAIN,
+    options,
+    criteria,
+    matrix: [],
+    recommendation: null,
+    dissent: null,
+    degenerate: true,
+    skipReason: recon && recon.reason ? recon.reason : 'obvious-default',
+    needsHumanGate: true,
+  };
+}
+
+phase('SOURCE');
+// EXPLORATION leaves: gather evidence per option. One leaf per option, run in
+// parallel. Labelled 'fetch-evidence:<option>' -> exploration -> haiku allowed.
+// Sourcing is routing-driven: internal scope stays on model-knowledge (no links),
+// external scope may cite a source, but a URL appears ONLY if WebFetch opened it
+// THIS turn - otherwise the claim is tagged unverified.
+const sourcingRule = SCOPE === 'internal'
+  ? 'INTERNAL scope: stay on model-knowledge, do NOT emit external links, prefer coherence with the existing stack. Tag every claim unverified=true unless it is a self-evident property of the option.'
+  : `EXTERNAL scope: model-knowledge is the default. A URL may appear ONLY if you actually opened it with WebFetch THIS turn; otherwise set unverified=true and cite from model-knowledge. Strict domain "${DOMAIN}"${FLOOR ? ` requires evidence floor ${FLOOR}` : ''}.`;
+
+const evidence = await parallel(options.map((opt) => () =>
+  agent(
+    `You are a SOURCE leaf of byan-benchmark for ONE option.\n` +
+      `OPTION: ${JSON.stringify(opt)}\n` +
+      `CRITERIA: ${criteriaBlob}\n` +
+      `${sourcingRule}\n` +
+      `Produce one evidence note per criterion: the factual basis for this option on that criterion. ` +
+      `Be concrete and honest; do not inflate. Return the EVIDENCE schema for this single option.`,
+    { label: `fetch-evidence:${opt.name}`, phase: 'SOURCE', schema: EVIDENCE_SCHEMA, model: 'haiku' }
+  )
+));
+const evidenceClean = evidence.filter(Boolean);
+log(`Sourced ${evidenceClean.length}/${options.length} options (scope=${SCOPE})`);
+const evidenceBlob = JSON.stringify(evidenceClean, null, 2);
+
+phase('JUDGE');
+// ANALYSIS leaves: score every cell against the weighted criteria. One leaf per
+// judge (reusable panel). Labelled 'judge-score:<judge>' -> ANALYSIS -> DEEP, so
+// opts.model is OMITTED (these leaves inherit the session model, never downgrade).
+const judgeResults = await parallel(JUDGES.map((j) => () =>
+  agent(
+    `You are JUDGE "${j.key}" (lens: ${j.lens}) of byan-benchmark. Score ALL options objectively, then apply YOUR weighting.\n` +
+      `FORK: ${QUESTION}\n` +
+      `OPTIONS: ${optionsBlob}\n` +
+      `CRITERIA (each has a weight): ${criteriaBlob}\n` +
+      `EVIDENCE gathered per option: ${evidenceBlob}\n` +
+      `EVIDENCE RUBRIC (grade each cell's level against this): ${EVIDENCE_RUBRIC}\n` +
+      `${FLOOR ? `STRICT FLOOR for domain "${DOMAIN}": a cell below ${FLOOR} must be flagged unverified=true.` : ''}\n` +
+      `YOUR WEIGHTING: ${j.weighting}\n` +
+      `For each option, produce a cell per criterion: a short verdict, an evidence level (L1..L5), a 1-10 score, ` +
+      `the source (or model-knowledge), and unverified (true if no live source was opened). ` +
+      `Compute weightedTotal = sum(score * weight) across criteria. Return the JUDGE schema.`,
+    { label: `judge-score:${j.key}`, phase: 'JUDGE', schema: JUDGE_SCHEMA }
+  )
+));
+const judgeClean = judgeResults.filter(Boolean);
+log(`Judges scored: ${judgeClean.length}/${JUDGES.length}`);
+const judgeBlob = JSON.stringify(judgeClean, null, 2);
+
+phase('RECOMMEND');
+// ANALYSIS leaf: consolidate judges, rank best-first, capture dissent. Labelled
+// 'recommend-rank' -> ANALYSIS -> DEEP (opts.model OMITTED). Confidence is a VERB
+// choice: assertive when the gap and evidence are solid, lean when low-confidence.
+const verdict = await agent(
+  `You are the RECOMMEND leaf of byan-benchmark. Consolidate the judges into ONE decision.\n` +
+    `FORK: ${QUESTION}\n` +
+    `OPTIONS: ${optionsBlob}\n` +
+    `CRITERIA: ${criteriaBlob}\n` +
+    `JUDGES' SCORECARDS: ${judgeBlob}\n` +
+    `Build a consolidated matrix: one row per option (best-first by combined weightedTotal), each cell carrying ` +
+    `criterion, verdict, level, score, source and unverified. ` +
+    `Recommend the best option with a one-line best-first reco. Set confidence="assertive" only when the winner ` +
+    `clearly leads and its key cells are not unverified; otherwise confidence="lean" (low-confidence, hedge the verb). ` +
+    `Capture the dissent: the runner-up a reasonable judge would defend and the criterion on which it wins. ` +
+    `Return the RECOMMEND schema.`,
+  { label: 'recommend-rank', phase: 'RECOMMEND', schema: RECOMMEND_SCHEMA }
+);
+
+// Return DATA only. The skill renders the compact 1-table, emits the BYAN-BENCH
+// marker, and (in BYAN) optionally enriches cells via byan_fc_check at the gate.
+return {
+  workflow: 'byan-benchmark',
+  question: QUESTION,
+  scope: SCOPE,
+  domain: DOMAIN,
+  options,
+  criteria,
+  matrix: (verdict && verdict.matrix) || [],
+  recommendation: (verdict && verdict.recommendation) || null,
+  dissent: (verdict && verdict.dissent) || null,
+  degenerate: false,
+  needsHumanGate: true,
+};

package/install/templates/.githooks/pre-commit

@@ -100,6 +100,38 @@ if [ -f "$STUB_SYNC" ]; then
   fi
 fi
 
+# Remote-safe connector surface gate — the remote MCP Org Connector
+# (server-http.js) exposes only REMOTE_SAFE_TOOLS. This gate blocks a commit if
+# that allowlist ever contains an fs-local / stateful / write tool, which on a
+# shared multi-tenant connector host would read or mutate the wrong disk or
+# cross-tenant state. No-op if the linter is absent.
+REMOTE_LINT="_byan/mcp/byan-mcp-server/bin/byan-lint-remote-safe.js"
+if [ -f "$REMOTE_LINT" ]; then
+  if ! node "$REMOTE_LINT"; then
+    echo ""
+    echo "Commit blocked : the remote-safe MCP tool allowlist contains an unsafe tool."
+    echo "Remove it from REMOTE_SAFE_TOOLS in server.js, or bypass with"
+    echo "'git commit --no-verify' (emergency only)."
+    exit 1
+  fi
+fi
+
+# Skill-bundle drift gate — the org-publishable skill bundles derive from the
+# live .claude/skills/ SKILL.md files; skill-bundles-manifest.json is the
+# committed drift ledger. This gate blocks a commit where a SKILL.md changed
+# without rebuilding the bundles (stale org publish). Re-run the bundler then
+# restage the manifest. No-op if the tool is absent.
+SKILL_BUNDLER="_byan/mcp/byan-mcp-server/bin/byan-build-skill-bundles.js"
+if [ -f "$SKILL_BUNDLER" ]; then
+  if ! node "$SKILL_BUNDLER" --check; then
+    echo ""
+    echo "Commit blocked : skill bundles are out of sync with .claude/skills/."
+    echo "Re-run 'node $SKILL_BUNDLER' then restage skill-bundles-manifest.json,"
+    echo "or bypass with 'git commit --no-verify' (emergency only)."
+    exit 1
+  fi
+fi
+
 if [ ! -f "$VALIDATOR" ]; then
   exit 0
 fi

package/install/templates/.mcp.json.tmpl

@@ -2,10 +2,7 @@
   "mcpServers": {
     "byan": {
       "command": "node",
-      "args": ["{{PROJECT_ROOT}}/_byan/mcp/byan-mcp-server/server.js"],
-      "env": {
-        "BYAN_API_URL": "http://localhost:3737"
-      }
+      "args": ["{{PROJECT_ROOT}}/_byan/mcp/byan-mcp-server/server.js"]
     }
   }
 }

package/install/templates/_byan/_config/agent-manifest.csv

@@ -21,7 +21,7 @@ name,displayName,title,icon,role,identity,communicationStyle,principles,module,p
 "storyteller","Sophia","Master Storyteller","📖","Expert Storytelling Guide + Narrative Strategist","Master storyteller with 50+ years across journalism, screenwriting, and brand narratives. Expert in emotional psychology and audience engagement.","Speaks like a bard weaving an epic tale - flowery, whimsical, every sentence enraptures and draws you deeper","Powerful narratives leverage timeless human truths. Find the authentic story. Make the abstract concrete through vivid details.","cis","_byan/agent/storyteller/storyteller.md"
 expert-merise-agile,"Expert Merise","Expert Merise Agile - Assistant de Conception & Rédaction","📐","Expert Merise Agile","Spécialiste Merise qui guide rédaction cahiers des charges et conception MCD/MCT. Zero Trust mindset: utilisateur se trompe jusqu'à preuve du contraire.","Direct, concis, constructif. Challenge systématique mais pédagogique.","Zero Trust (IA-1) • Challenge Before Confirm (IA-16) • Ockham's Razor (#37) • Data Dictionary First (#33) • MCD⇄MCT Validation (#34)","bmm","_byan/agent/expert-merise-agile/expert-merise-agile.md"
 "drawio","DrawIO","Expert Diagrammes Draw.io","📐","Expert en Création de Diagrammes Techniques","Spécialiste des diagrammes techniques via serveur MCP draw.io. Maîtrise architecture, UML, Merise, BPMN, et diagrammes métier.","Professionnel et précis, comme un architecte technique. Explique les choix de design.","- Clarté Avant Tout - Simplicité: Ockham's Razor - Standards: Respecte conventions UML et notations métier","bmb","_byan/agent/drawio/drawio.md"
-"turbo-whisper-integration","Turbo Whisper Voice Integration","Voice Dictation Integration Specialist","🎤","Voice Dictation Integration Specialist","Expert in Turbo Whisper integration for BMAD platform. Seamlessly connects voice dictation with GitHub Copilot CLI, Claude Code, and Codex. Enables hands-free interaction with AI agents. Cross-platform specialist (Linux/macOS/Windows). Prioritizes self-hosted solutions for privacy and cost efficiency.","Balanced approach - educational during setup and concise for experienced users. Uses technical precision without jargon overload. Always confirms OS and platform before suggesting commands.","Challenge Before Confirm - Validate OS, platform, requirements | Ockham's Razor - Simplest setup | Fail Fast - Detect issues early | Consequences Awareness - Test all platforms | Privacy First - Self-hosted priority","bmb","_byan/agent/turbo-whisper-integration/turbo-whisper-integration.md"
+"turbo-whisper-integration","Turbo Whisper Voice Integration","Voice Dictation Integration Specialist","🎤","Voice Dictation Integration Specialist","Expert in Turbo Whisper integration for BMAD platform. Seamlessly connects voice dictation with Claude Code, and Codex. Enables hands-free interaction with AI agents. Cross-platform specialist (Linux/macOS/Windows). Prioritizes self-hosted solutions for privacy and cost efficiency.","Balanced approach - educational during setup and concise for experienced users. Uses technical precision without jargon overload. Always confirms OS and platform before suggesting commands.","Challenge Before Confirm - Validate OS, platform, requirements | Ockham's Razor - Simplest setup | Fail Fast - Detect issues early | Consequences Awareness - Test all platforms | Privacy First - Self-hosted priority","bmb","_byan/agent/turbo-whisper-integration/turbo-whisper-integration.md"
 "skeptic","The Skeptic","Scientific Claim Challenger and Epistemic Guard","[?]","Epistemic Guard + Fact-Check Specialist","Methodical challenger of all claims. Applies 3-step verification (Source / Proof type / Reproducible). Specializes in auditing documents for unsourced assertions, computing Trust Scores, and verifying reasoning chains with multiplicative confidence propagation.","Cold, methodical, impeccably polite. Speaks in structured CLAIM/CHALLENGE/VERDICT blocks. Uses Socratic method — questions before conclusions. Never hostile, always rigorous.","Challenge Before Confirm | Extraordinary claims require extraordinary evidence | Descartes Doubt | No URL generation | Strict-domain LEVEL-2 minimum","core","_byan/agent/skeptic/skeptic.md"
 "forgeron","Le Forgeron","Revelateur d ames","","Revelateur d ames — Soul Forger","Expert en interview psychologique profonde pour extraire l ame du createur depuis ses experiences de vie. Detecte emotions, valeurs, blessures fondatrices. Genere creator-soul.md et agent soul files. Calme, patient, utilise le silence comme outil.","Calme, patient, minimal, profond. Questions rares mais chaque une compte. Utilise le silence. Reflete sans projeter.","Ne jamais interpreter a la place du createur | Ne jamais precipiter | Emotions = donnees de navigation | Preuve avant sentence","bmb","_byan/agent/forgeron/forgeron.md"
 "tao","Tao","Le Tao — Directeur de Voix des Agents","道","Voice Director — Soul to Expression Bridge","Transforme les valeurs abstraites du soul.md en directives vocales concretes : tics de langage, registre, signatures verbales, vocabulaire interdit. Forge le tao.md de chaque agent. Garantit l anti-uniformite : chaque agent sonne unique.","Calme, precis, chirurgical. L oreille absolue pour les voix. Detecte le generique a la premiere phrase. Concret : jamais de regle sans exemple.","Derivation tracable : chaque tic nait d une valeur d ame | Anti-uniformite : deux agents ne sonnent jamais pareil | Exemple obligatoire | La voix sert l ame pas l inverse","core","_byan/agent/tao/tao.md"