create-byan-agent 2.39.0 → 2.42.0

package/install/templates/.claude/rules/native-workflows.md

@@ -26,16 +26,24 @@ A native workflow script mutates FD/strict state only through the `byan_fd_*` /
 
 Each `agent()` leaf runs on the session model unless the call sets `opts.model`.
 The tiering decision lives in one place — `_byan/mcp/byan-mcp-server/lib/native-tiers.js`
-(tier vocabulary, leaf classifier, model map). The doctrine is binary: a pure
-EXPLORATION leaf (read/load/parse/detect) may downgrade to `model: 'haiku'`;
-implementation / verification / analysis leaves OMIT `opts.model` and inherit the
-session model (no pin-up to opus).
+(tier vocabulary, leaf classifier, model map). Three tiers:
+
+- **cheap (`model: 'haiku'`)** — a pure EXPLORATION leaf (read/load/parse/detect).
+- **balanced (`model: 'sonnet'`)** — MECHANICAL verification, opt-in ONLY through
+  the `mech-` label prefix (`mech-validate-json`): a binary, judgment-free check
+  (JSON parses, schema matches, lint passes). Semantic/adversarial verification
+  is NOT mechanical and stays deep. The prefix is an authoring declaration the
+  linter holds the script to: a `mech-` leaf without `model: 'sonnet'` is a hard
+  violation (`mechanical-without-model` / `mechanical-below-tier`).
+- **deep (OMIT `opts.model`)** — implementation / verification / analysis leaves
+  inherit the session model (no pin-up to opus).
 
 The linter splits the two directions:
 
-- **Floor (HARD, blocks the commit)** — a downgrade model on a PROTECTED leaf, or
-  a pin-up, is a contract violation (`modelRoutingViolations`). This is the
-  STRICT-2 No Downgrade net.
+- **Floor (HARD, blocks the commit)** — a downgrade model on a PROTECTED leaf, a
+  pin-up, or a half-applied `mech-` opt-in is a contract violation
+  (`modelRoutingViolations` + `mechanicalLabelViolations`). This is the STRICT-2
+  No Downgrade net.
 - **Ceiling (ADVISORY, non-blocking)** — an exploration-labelled leaf that runs
   deep is *reported* (`byan-lint-workflows.js --advise`), not forced. `classifyLeaf`
   is permissive: many exploration-labelled leaves legitimately stay deep because
@@ -43,6 +51,24 @@ The linter splits the two directions:
   consumed verbatim downstream. The human owns that per-leaf call. Forcing haiku
   on them would be the very downgrade the floor forbids.
 
+## Ad-hoc scripts — the tier gate hook
+
+The repo linter only sees committed files. An AD-HOC script (written inline for
+one run) crosses exactly one chokepoint before it executes: the Workflow tool
+invocation. `.claude/hooks/tier-script-guard.js` (PreToolUse, matcher `Workflow`)
+runs the same analysis there via `lib/tier-script.js` and DENIES ONCE when
+exploration/`mech-` leaves carry no tier — with the exact leaf list to fix. The
+`// BYAN-TIER: reviewed` comment marker acknowledges deliberate deep choices; an
+identical resubmission passes (deny-once by design); registry (name-only)
+invocations pass untouched. Every decision lands in
+`_byan-output/tier-ledger.jsonl` with a per-model histogram — the measurement
+basis for token gains. Escape hatch: `touch .byan-tier/off`.
+
+Authoring flow: BEFORE writing a script, call `byan_dispatch` with
+`{ leaves: [{ label, nature? }] }` (batch mode) to get the `opts.model` per leaf;
+write `model:` only where non-null. Standalone report:
+`node _byan/mcp/byan-mcp-server/bin/byan-tier-script.js <file> [--json]`.
+
 A per-leaf "effort" knob is not available: the native `agent()` / Agent API exposes
 only `model`, so model tier is the sole token lever. Effort-by-complexity reduces
 to model-by-complexity.

package/install/templates/.claude/settings.json

@@ -6,15 +6,15 @@
         "hooks": [
           {
             "type": "command",
-            "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/inject-soul.js"
+            "command": "p=\"$CLAUDE_PROJECT_DIR/.claude/hooks/inject-soul.js\"; [ -f \"$p\" ] || exit 0; exec node \"$p\""
           },
           {
             "type": "command",
-            "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/inject-tao.js"
+            "command": "p=\"$CLAUDE_PROJECT_DIR/.claude/hooks/inject-tao.js\"; [ -f \"$p\" ] || exit 0; exec node \"$p\""
           },
           {
             "type": "command",
-            "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/soul-memory-check.js"
+            "command": "p=\"$CLAUDE_PROJECT_DIR/.claude/hooks/soul-memory-check.js\"; [ -f \"$p\" ] || exit 0; exec node \"$p\""
           }
         ]
       }
@@ -25,23 +25,27 @@
         "hooks": [
           {
             "type": "command",
-            "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/inject-voice-anchor.js"
+            "command": "p=\"$CLAUDE_PROJECT_DIR/.claude/hooks/inject-voice-anchor.js\"; [ -f \"$p\" ] || exit 0; exec node \"$p\""
           },
           {
             "type": "command",
-            "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/inject-delivery-default.js"
+            "command": "p=\"$CLAUDE_PROJECT_DIR/.claude/hooks/inject-delivery-default.js\"; [ -f \"$p\" ] || exit 0; exec node \"$p\""
           },
           {
             "type": "command",
-            "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/soul-memory-triggers.js"
+            "command": "p=\"$CLAUDE_PROJECT_DIR/.claude/hooks/soul-memory-triggers.js\"; [ -f \"$p\" ] || exit 0; exec node \"$p\""
           },
           {
             "type": "command",
-            "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/fd-phase-guard.js"
+            "command": "p=\"$CLAUDE_PROJECT_DIR/.claude/hooks/fd-phase-guard.js\"; [ -f \"$p\" ] || exit 0; exec node \"$p\""
           },
           {
             "type": "command",
-            "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/strict-context-inject.js"
+            "command": "p=\"$CLAUDE_PROJECT_DIR/.claude/hooks/strict-context-inject.js\"; [ -f \"$p\" ] || exit 0; exec node \"$p\""
+          },
+          {
+            "type": "command",
+            "command": "p=\"$CLAUDE_PROJECT_DIR/.claude/hooks/codex-autodelegate.js\"; [ -f \"$p\" ] || exit 0; exec node \"$p\""
           }
         ]
       }
@@ -52,35 +56,35 @@
         "hooks": [
           {
             "type": "command",
-            "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/mantra-validate.js"
+            "command": "p=\"$CLAUDE_PROJECT_DIR/.claude/hooks/mantra-validate.js\"; [ -f \"$p\" ] || exit 0; exec node \"$p\""
           },
           {
             "type": "command",
-            "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/fact-check-claims.js"
+            "command": "p=\"$CLAUDE_PROJECT_DIR/.claude/hooks/fact-check-claims.js\"; [ -f \"$p\" ] || exit 0; exec node \"$p\""
           },
           {
             "type": "command",
-            "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/fd-response-check.js"
+            "command": "p=\"$CLAUDE_PROJECT_DIR/.claude/hooks/fd-response-check.js\"; [ -f \"$p\" ] || exit 0; exec node \"$p\""
           },
           {
             "type": "command",
-            "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/stage-to-byan.js"
+            "command": "p=\"$CLAUDE_PROJECT_DIR/.claude/hooks/stage-to-byan.js\"; [ -f \"$p\" ] || exit 0; exec node \"$p\""
           },
           {
             "type": "command",
-            "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/strict-stop-guard.js"
+            "command": "p=\"$CLAUDE_PROJECT_DIR/.claude/hooks/strict-stop-guard.js\"; [ -f \"$p\" ] || exit 0; exec node \"$p\""
           },
           {
             "type": "command",
-            "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/autobench-stop-guard.js"
+            "command": "p=\"$CLAUDE_PROJECT_DIR/.claude/hooks/autobench-stop-guard.js\"; [ -f \"$p\" ] || exit 0; exec node \"$p\""
           },
           {
             "type": "command",
-            "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/punt-guard.js"
+            "command": "p=\"$CLAUDE_PROJECT_DIR/.claude/hooks/punt-guard.js\"; [ -f \"$p\" ] || exit 0; exec node \"$p\""
           },
           {
             "type": "command",
-            "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/drain-advisory.js"
+            "command": "p=\"$CLAUDE_PROJECT_DIR/.claude/hooks/drain-advisory.js\"; [ -f \"$p\" ] || exit 0; exec node \"$p\""
           }
         ]
       }
@@ -91,15 +95,24 @@
         "hooks": [
           {
             "type": "command",
-            "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/tool-transparency.js"
+            "command": "p=\"$CLAUDE_PROJECT_DIR/.claude/hooks/tool-transparency.js\"; [ -f \"$p\" ] || exit 0; exec node \"$p\""
           },
           {
             "type": "command",
-            "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/fact-check-absolutes.js"
+            "command": "p=\"$CLAUDE_PROJECT_DIR/.claude/hooks/fact-check-absolutes.js\"; [ -f \"$p\" ] || exit 0; exec node \"$p\""
           },
           {
             "type": "command",
-            "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/strict-scope-guard.js"
+            "command": "p=\"$CLAUDE_PROJECT_DIR/.claude/hooks/strict-scope-guard.js\"; [ -f \"$p\" ] || exit 0; exec node \"$p\""
+          }
+        ]
+      },
+      {
+        "matcher": "Workflow",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "p=\"$CLAUDE_PROJECT_DIR/.claude/hooks/tier-script-guard.js\"; [ -f \"$p\" ] || exit 0; exec node \"$p\""
           }
         ]
       }
@@ -110,11 +123,11 @@
         "hooks": [
           {
             "type": "command",
-            "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/tool-failure-guard.js"
+            "command": "p=\"$CLAUDE_PROJECT_DIR/.claude/hooks/tool-failure-guard.js\"; [ -f \"$p\" ] || exit 0; exec node \"$p\""
           },
           {
             "type": "command",
-            "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/leantime-fd-sync.js"
+            "command": "p=\"$CLAUDE_PROJECT_DIR/.claude/hooks/leantime-fd-sync.js\"; [ -f \"$p\" ] || exit 0; exec node \"$p\""
           }
         ]
       }
@@ -125,7 +138,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/pre-compact-save.js"
+            "command": "p=\"$CLAUDE_PROJECT_DIR/.claude/hooks/pre-compact-save.js\"; [ -f \"$p\" ] || exit 0; exec node \"$p\""
           }
         ]
       }

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

@@ -18,6 +18,20 @@ Invoke this protocol when the user :
 
 If the user request is a simple question or chat, stay out of FD — respond normally.
 
+## 1.25. Claude/Codex handoff import trigger
+
+When the user says `importe depuis claude` or `importe depuis codex`, handle it
+before starting a new FD cycle:
+
+1. Run `byan-handoff latest --from <requested source> --prompt`.
+2. Use the generated prompt as resume context, inspect the listed files, then
+   continue the current work.
+
+If no matching handoff exists, say that no handoff from that source was found and
+offer `byan-handoff latest --prompt` as the fallback only if the user accepts
+resuming from the newest handoff across all sources. Do not rely on native
+Claude/Codex memory as the source of truth.
+
 ## 1.5. Freshness check (silent, once per session)
 
 Before responding to the user's first activation message in a session, call the MCP tool `byan_update_check` once. It is read-only and cheap (single npm registry lookup, 5s timeout, no side effects).
@@ -64,9 +78,14 @@ Never call `byan_update_apply` without explicit user consent. That tool returns
     - **Score ≥ 40** → main-thread (heavy) or delegate to `byan-hermes-dispatch`
   - **Model tier** (WHICH model), from the task NATURE — not its size (`byan_dispatch` returns it as `model`, via native-tiers, the single source of truth) :
     - nature `exploration` (load/read/scan/list/parse/fetch...) → `haiku`
+    - nature `mechanical` (binary judgment-free checks : JSON parses, schema matches, lint passes — label prefix `mech-`, explicit opt-in only) → `sonnet`
     - nature `implementation` / `verification` / `analysis` / unknown → deep = **inherit the session model**
-    - Keep protected work (verify/analysis/implement) off haiku regardless of size ; no pin-up to opus. Pass an explicit `nature` to `byan_dispatch` when you know it.
-  - **Inside native workflow scripts** (`.claude/workflows/*.js`) the SAME tiering applies per `agent()` leaf via `opts.model`, enforced by the workflow linter as a FLOOR not a ceiling : `modelRoutingViolations` HARD-blocks a downgrade on a protected leaf (or a pin-up) ; an exploration-labelled leaf left deep is a NON-blocking ADVISORY (`byan-lint-workflows.js --advise`), since many such leaves bear a gate/classification/exact-conversion and must stay deep — the human owns that call. No per-leaf effort knob exists (the API exposes only `model`), so effort-by-complexity reduces to model-by-complexity.
+    - Keep protected work (verify/analysis/implement) off haiku/sonnet regardless of size ; no pin-up to opus. Pass an explicit `nature` to `byan_dispatch` when you know it.
+  - **Inside native workflow scripts** (`.claude/workflows/*.js` OR ad-hoc) the SAME tiering applies per `agent()` leaf via `opts.model`, enforced as a FLOOR not a ceiling on TWO nets :
+    - **Repo linter** (committed scripts, pre-commit) : `modelRoutingViolations` HARD-blocks a downgrade on a protected leaf, a pin-up, or a half-applied `mech-` opt-in (`mechanical-without-model` / `mechanical-below-tier`) ; an exploration-labelled leaf left deep is a NON-blocking ADVISORY (`byan-lint-workflows.js --advise`), since many such leaves bear a gate/classification/exact-conversion and must stay deep — the human owns that call.
+    - **Tier gate hook** (EVERY Workflow invocation, inline or scriptPath) : `tier-script-guard.js` (PreToolUse) runs the same analysis (`lib/tier-script.js`) and DENIES ONCE when exploration/`mech-` leaves have no tier, with the exact leaf list to fix. Acknowledge deliberate deep choices with the `// BYAN-TIER: reviewed` comment marker ; an identical resubmission passes (deny-once by design, no trap). Every decision lands in `_byan-output/tier-ledger.jsonl` (the measurement basis for token gains). Escape hatch : `.byan-tier/off`.
+    - **Authoring aid** : BEFORE writing a script, call `byan_dispatch` with `{ leaves: [{ label, nature? }] }` (batch mode) to get the `opts.model` per leaf ; write `model:` only where non-null. Report with `node _byan/mcp/byan-mcp-server/bin/byan-tier-script.js <file> [--json]`.
+    - No per-leaf effort knob exists (the API exposes only `model`), so effort-by-complexity reduces to model-by-complexity.
 - **Output** : a table `{ feature → specialist → model → strategy → estimated_tokens }`.
 - **If no specialist matches** : halt. Ask user whether to run INT (agent recruitment) first. Do NOT fallback silently to general-purpose.
 - **Exit gate** : user validates the mapping.

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

@@ -19,3 +19,10 @@ description: "OpenCode/Codex integration specialist for BYAN skills Role: OpenCo
 - Validate .codex/prompts/ structure
 - Test skill detection before deployment
 - Handle Codex-specific terminology (skills not agents)
+- When the user says `importe depuis claude` or `importe depuis codex`, run
+  `byan-handoff latest --from <requested source> --prompt`, then resume from
+  the generated prompt after inspecting the listed files. If none matches,
+  report that no handoff from that source exists and offer
+  `byan-handoff latest --prompt` as fallback only if the user accepts resuming
+  from the newest handoff across all sources. Native Claude/Codex memory is not
+  the source of truth.

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

@@ -55,7 +55,9 @@ Call the `byan_dispatch` MCP tool with `{ task: <goal>, parallelizable: <bool>,
   - `main-thread` — do it inline, no delegation
   - `agent-subagent-worktree` — spawn Agent tool with isolation worktree
   - `mcp-worker` — spawn Agent tool, no worktree
-- **model** (WHICH model), from the task NATURE via native-tiers, not its size : `haiku` (exploration only) or `null` = deep (inherit the session model). Pass an explicit `nature` (`exploration`/`implementation`/`verification`/`analysis`) when you know it; protected natures stay off haiku.
+- **model** (WHICH model), from the task NATURE via native-tiers, not its size : `haiku` (exploration), `sonnet` (mechanical — explicit binary judgment-free checks only), or `null` = deep (inherit the session model). Pass an explicit `nature` (`exploration`/`mechanical`/`implementation`/`verification`/`analysis`) when you know it; protected natures stay off haiku/sonnet.
+
+**Batch mode (workflow authoring)** : before WRITING a workflow script, call `byan_dispatch` with `{ leaves: [{ label, nature? }, ...] }` — it returns the `opts.model` value per leaf from the same source of truth. Write `model:` only where it is non-null. The `tier-script-guard` PreToolUse hook gates every Workflow invocation against this contract (deny-once with the exact leaf list; acknowledge deliberate deep choices with the `// BYAN-TIER: reviewed` comment marker).
 
 ### 4. Spawn the work
 

package/install/templates/.claude/workflows/sprint-planning.js

@@ -6,7 +6,7 @@ export const meta = {
     { title: 'STRUCTURE', detail: 'build the ordered development_status map: epic, its stories, its retrospective' },
     { title: 'DETECT', detail: 'intelligent per-story status detection, never downgrade an existing status' },
     { title: 'GENERATE', detail: 'write sprint-status.yaml with metadata as comments AND as parseable fields' },
-    { title: 'VALIDATE', detail: 'coverage + legal-status + YAML checks, then count totals and report' },
+    { title: 'VALIDATE', detail: 'coverage + legal-status + YAML checks, then count totals and report', model: 'sonnet' },
   ],
 }
 
@@ -236,7 +236,7 @@ const validation = await agent(
     `- validYaml: the file parses as YAML.\n` +
     `Count totals: epicCount, storyCount, epicsInProgress, storiesDone. ` +
     `passed = true only if ALL six checks hold; otherwise list specific failures.`,
-  { label: 'validate-and-report', phase: 'VALIDATE', schema: VALIDATE_SCHEMA }
+  { label: 'mech-validate-status', phase: 'VALIDATE', schema: VALIDATE_SCHEMA, model: 'sonnet' }
 )
 
 // Single top-level return — DATA only. The orchestrating skill presents this at

package/install/templates/.claude/workflows/testarch-trace.js

@@ -6,7 +6,7 @@ export const meta = {
     { title: 'DISCOVER_TESTS' },
     { title: 'MAP_CRITERIA' },
     { title: 'ANALYZE_GAPS' },
-    { title: 'GATE_DECISION' }
+    { title: 'GATE_DECISION', model: 'sonnet' }
   ]
 }
 
@@ -260,8 +260,9 @@ const gate = await agent(
     'Return the deterministic decision, the rationale string, and the gate criteria (p0 met?, overall status MET/PARTIAL/NOT MET).'
   ].join(' '),
   {
-    label: 'gate-decision',
+    label: 'mech-gate-decision',
     phase: 'GATE_DECISION',
+    model: 'sonnet',
     schema: {
       type: 'object',
       required: ['decision', 'rationale', 'gateCriteria'],

package/install/templates/.codex/skills/byan/SKILL.md

@@ -0,0 +1,77 @@
+---
+name: byan
+description: BYAN local project skill. Use when working in the BYAN repo, invoking BYAN agents/workflows/commands, enforcing BYAN Strict Mode, or needing the portable BYAN filesystem map.
+---
+
+# BYAN Local Skill
+
+Use this skill when the user asks for BYAN behavior, mentions BYAN/BMAD, asks to
+run an agent or workflow from this repo, or works on the BYAN platform itself.
+
+## Source Of Truth
+
+BYAN's portable core lives in this repository. Do not treat native assistant
+memory, generated caches, or platform-specific projections as authoritative.
+
+Read `_byan/INDEX.md` first to find agents, workflows, commands, and project
+artefacts. Avoid broad filesystem scans unless the index is missing, stale, or
+insufficient for the requested task.
+
+Core references:
+
+- `_byan/INDEX.md` — filesystem map for BYAN agents, workflows, commands, and projects.
+- `AGENTS.md` — Codex adapter for BYAN Strict Mode and delivery defaults.
+- `.claude/rules/portable-core.md` — portable-core doctrine: `_byan/` and
+  `_byan-output/` are the source of truth; native platform features are
+  write-through accelerators.
+- `_byan/agent/byan/byan.md` — BYAN core meta-agent when the task requires the
+  full BYAN persona and FD workflow.
+
+## Strict Mode
+
+When BYAN Strict Mode is active, follow the audit protocol before delivery:
+
+1. Lock scope with `byan_strict_lock_scope` before building.
+2. Build the locked scope without silent downgrade.
+3. Run at least three `byan_strict_self_verify` passes against the original
+   request and acceptance criteria.
+4. Call `byan_strict_complete` only after the final pass is `ok`.
+
+Surface gaps explicitly. Do not round skipped tests, blocked tools, or partial
+work up to done.
+
+## Working Rules
+
+- Prefer BYAN's local manifests and `_byan/INDEX.md` over filesystem wandering.
+- Keep Codex-specific material under `.codex/` or installed Codex skills under
+  `$CODEX_HOME/skills` / `~/.codex/skills`.
+- Use existing BYAN agents and workflows instead of inventing parallel
+  conventions.
+- If a public surface changes, update the matching doc, manifest, template, or
+  generated projection when applicable.
+- Preserve BYAN's no-emoji convention in code, commits, docs, and prompts.
+
+## Claude/Codex Handoff Import
+
+When the user says `importe depuis claude` or `importe depuis codex`, handle it
+without asking for more context if a matching handoff exists:
+
+1. Run `byan-handoff latest --from <requested source> --prompt`.
+2. Treat the generated prompt as the resume context, inspect the listed files,
+   then continue the work.
+
+If no matching handoff exists, say that no handoff from that source was found and
+offer `byan-handoff latest --prompt` as the fallback only if the user accepts
+resuming from the newest handoff across all sources. Do not rely on native
+Claude/Codex memory as the source of truth.
+
+## Installed Bundles In This Repo
+
+Prebuilt Codex skill bundles are available under `dist/skill-bundles/`, including:
+
+- `byan-byan.zip` — full BYAN FD/meta-agent skill.
+- `byan-strict.zip` — strict scope-lock and audit protocol.
+- `byan-codex.zip` — Codex/OpenCode integration specialist.
+
+Use those bundles when the user asks for a specific packaged BYAN skill. Use this
+local `byan` skill as the general repo-aware entrypoint.

package/install/templates/_byan/INDEX.md

@@ -3,7 +3,7 @@
 > Carte du systeme de fichiers BYAN. Genere automatiquement — ne pas editer a la main.
 > Source : `_byan/_config/*-manifest.csv` + scan `_byan/projet/`. Regenerer : `byan-build-index`.
 
-## Agents (26)
+## Agents (28)
 
 ### bmb
 - `agent-builder` — Agent Building Expert — `_byan/agent/agent-builder/agent-builder.md`
@@ -18,6 +18,8 @@
 - `architect` — Architect — `_byan/agent/architect/architect.md`
 - `dev` — Developer Agent — `_byan/agent/dev/dev.md`
 - `expert-merise-agile` — Expert Merise Agile - Assistant de Conception & Rédaction — `_byan/agent/expert-merise-agile/expert-merise-agile.md`
+- `jimmy` — Spécialiste Documentation Technique & Processus Internes — `_byan/agent/jimmy/jimmy.md`
+- `mike` — Gestionnaire de Projet — Spécialiste Leantime — `_byan/agent/mike/mike.md`
 - `pm` — Product Manager — `_byan/agent/pm/pm.md`
 - `quick-flow-solo-dev` — Quick Flow Solo Dev — `_byan/agent/quick-flow-solo-dev/quick-flow-solo-dev.md`
 - `quinn` — QA Engineer — `_byan/agent/quinn/quinn.md`
@@ -41,10 +43,11 @@
 ### tea
 - `tea` — Master Test Architect and Quality Advisor — `_byan/agent/tea/tea.md`
 
-## Workflows (45)
+## Workflows (47)
 
 ### bmb
 - `agent` — Tri-modal workflow for creating, editing, and validating BMAD Core compliant agents — `_byan/workflow/simple/agent/workflow.md`
+- `byan-benchmark` — DATA-only benchmark engine for any decision fork: options x weighted-criteria matrix + best-first reco + dissent — `_byan/workflow/simple/bmb/byan-benchmark/workflow.md`
 - `module` — Quad-modal workflow for creating BMAD modules (Brief + Create + Edit + Validate) — `_byan/workflow/simple/module/workflow.md`
 - `turbo-whisper-configure` — Configure Turbo Whisper API, hotkeys, and preferences — `_byan/workflow/simple/turbo-whisper/configure-workflow.md`
 - `turbo-whisper-docker-setup` — Setup self-hosted faster-whisper-server with Docker for privacy and cost-free transcription — `_byan/workflow/simple/turbo-whisper/docker-setup-workflow.md`
@@ -86,6 +89,7 @@
 ### core
 - `brainstorming` — Facilitate interactive brainstorming sessions using diverse creative techniques and ideation methods — `_byan/workflow/simple/brainstorming/workflow.md`
 - `party-mode` — Orchestrates group discussions between all installed BMAD agents, enabling natural multi-agent conversations — `_byan/workflow/simple/party-mode/workflow.md`
+- `project-handoff` — Export/import portable Markdown project state between Claude Code and Codex — `_byan/workflow/simple/byan/project-handoff-workflow.md`
 
 ### tea
 - `teach-me-testing` — Multi-session learning companion that teaches testing progressively through 7 structured sessions with state persistence — `_byan/workflow/simple/testarch/teach-me-testing/workflow.md`

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

@@ -45,4 +45,4 @@ name,description,module,path
 "turbo-whisper-docker-setup","Setup self-hosted faster-whisper-server with Docker for privacy and cost-free transcription","bmb","_byan/workflow/simple/turbo-whisper/docker-setup-workflow.md"
 "turbo-whisper-integrate","Integrate Turbo Whisper with GitHub Copilot CLI, Claude Code, and Codex platforms","bmb","_byan/workflow/simple/turbo-whisper/integrate-workflow.md"
 "byan-benchmark","DATA-only benchmark engine for any decision fork: options x weighted-criteria matrix + best-first reco + dissent","bmb","_byan/workflow/simple/bmb/byan-benchmark/workflow.md"
-
+"project-handoff","Export/import portable Markdown project state between Claude Code and Codex","core","_byan/workflow/simple/byan/project-handoff-workflow.md"

package/install/templates/_byan/mcp/byan-mcp-server/bin/byan-tier-script.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import { analyzeScript, formatGateReason } from '../lib/tier-script.js';
+
+// Per-script tiering report — works on ANY workflow script text: a committed
+// .claude/workflows/*.js, an ad-hoc script persisted under the session dir, or
+// a draft. One verdict per statically-labelled leaf against native-tiers.
+//
+// Exit codes (hook/CI friendly): 0 clean or acknowledged, 1 tier gaps,
+// 2 violations (violations dominate gaps).
+// Usage: node bin/byan-tier-script.js <script-file> [--json]
+
+const args = process.argv.slice(2);
+const jsonMode = args.includes('--json');
+const file = args.find((a) => !a.startsWith('--'));
+
+if (!file) {
+  process.stderr.write('usage: byan-tier-script <script-file> [--json]\n');
+  process.exit(2);
+}
+
+let src;
+try {
+  src = fs.readFileSync(file, 'utf8');
+} catch (e) {
+  process.stderr.write(`[byan-tier-script] cannot read ${file}: ${e.message}\n`);
+  process.exit(2);
+}
+
+const analysis = analyzeScript(src);
+
+if (jsonMode) {
+  process.stdout.write(JSON.stringify(analysis, null, 2) + '\n');
+} else {
+  process.stdout.write(
+    `[byan-tier-script] ${file}: ${analysis.agentCalls} agent() call(s), ` +
+    `${analysis.leaves.length} labelled leaf/leaves, ` +
+    `${analysis.gaps.length} gap(s), ${analysis.violations.length} violation(s)` +
+    `${analysis.acknowledged ? ', acknowledged (BYAN-TIER: reviewed)' : ''}\n`
+  );
+  for (const l of analysis.leaves) {
+    const model = l.model === null ? '(inherit)' : l.model;
+    process.stdout.write(`  ${l.verdict.padEnd(12)} ${l.label} [${l.class}] model=${model} expected=${l.expectedModel ?? '(inherit)'}\n`);
+  }
+  if (analysis.gaps.length || analysis.violations.length) {
+    process.stdout.write(formatGateReason(analysis) + '\n');
+  }
+}
+
+if (analysis.acknowledged) process.exit(0);
+if (analysis.violations.length) process.exit(2);
+process.exit(analysis.gaps.length ? 1 : 0);

package/install/templates/_byan/mcp/byan-mcp-server/lib/dispatch.js

@@ -73,3 +73,25 @@ export function dispatch({ task, complexity, parallelizable, nature } = {}) {
     reasoning: `${strategyReason}. ${tierReason}.`,
   };
 }
+
+// Batch tiering — the authoring aid for workflow scripts. The author passes the
+// planned leaves BEFORE writing the script and gets the opts.model value per
+// leaf from the same source of truth (native-tiers). No strategy axis here:
+// the leaves all run inside one Workflow invocation, so WHERE they run is the
+// script's concern, only WHICH model each deserves is answered. An explicit
+// valid nature wins; otherwise the label classifies; a miss stays protected
+// (implementation -> deep -> null), same conservative path as dispatch().
+export function dispatchBatch(leaves) {
+  if (!Array.isArray(leaves)) return [];
+  return leaves.map((leaf) => {
+    const { label, nature } = leaf && typeof leaf === 'object' ? leaf : {};
+    const leafType = VALID_NATURES.has(nature) ? nature : classifyLeaf({ label: label || '' });
+    const tier = tierFor(leafType);
+    return {
+      label: label || '',
+      nature: leafType,
+      tier,
+      model: TIER_MODEL[tier],
+    };
+  });
+}

package/install/templates/_byan/mcp/byan-mcp-server/lib/native-tiers.js

@@ -28,7 +28,8 @@ export const TIERS = Object.freeze({ CHEAP: 'cheap', BALANCED: 'balanced', DEEP:
 // session runs (Opus by default, but Sonnet if the user chose Sonnet). We never
 // PIN UP — pinning a leaf to a fixed high tier would override the user's session
 // choice and could silently DOWNGRADE a Sonnet/Opus session's heavy leaf. Only
-// cheap/balanced carry a value, and only exploration leaves ever get one.
+// cheap/balanced carry a value: exploration leaves get cheap, explicit mech-
+// leaves get balanced, nothing else ever gets one.
 //
 // Values are the harness model-selection aliases (same set as the Agent tool:
 // 'haiku' | 'sonnet' | 'opus'). They are version-independent. If a future
@@ -36,15 +37,26 @@ export const TIERS = Object.freeze({ CHEAP: 'cheap', BALANCED: 'balanced', DEEP:
 // flags every script literal that drifts from it, so the fan-out stays bounded.
 export const TIER_MODEL = Object.freeze({ cheap: 'haiku', balanced: 'sonnet', deep: null });
 
-// Leaf task-type taxonomy. EXPLORATION is the only downgrade-safe class; the
-// other three are protected (never downgraded).
+// Leaf task-type taxonomy. EXPLORATION and MECHANICAL are the two
+// downgrade-safe classes; the other three are protected (never downgraded).
+// MECHANICAL is verification whose outcome is binary and judgment-free (JSON
+// parses, schema matches, lint passes, a test suite exits 0) — it earns the
+// balanced tier. Semantic/adversarial verification stays VERIFICATION (deep).
 export const LEAF_TYPES = Object.freeze({
   EXPLORATION: 'exploration',
+  MECHANICAL: 'mechanical',
   IMPLEMENTATION: 'implementation',
   VERIFICATION: 'verification',
   ANALYSIS: 'analysis',
 });
 
+// MECHANICAL is opt-in ONLY, through this label prefix ('mech-validate-json').
+// No keyword fuzziness: 'validate-json' without the prefix stays VERIFICATION
+// (protected). The prefix is an explicit authoring act — the author asserts
+// "this check is binary and judgment-free", and the linter can then hold the
+// script to it (a mech- leaf must carry model: 'sonnet', nothing else).
+export const MECHANICAL_PREFIX = 'mech-';
+
 // Label keyword sets, matched as substrings on the leaf LABEL (not the prompt —
 // see classifyLeaf). Protected sets are checked first so any protected signal
 // beats an exploration signal (conservative: when in doubt, do not downgrade).
@@ -73,6 +85,9 @@ function matchesAny(text, keywords) {
 export function classifyLeaf(leaf) {
   const label = String((leaf && leaf.label) || '').toLowerCase();
   if (!label) return LEAF_TYPES.IMPLEMENTATION;
+  // Explicit opt-in beats every keyword class: 'mech-validate-json' contains a
+  // verification keyword, but the author's declared intent is the signal.
+  if (label.startsWith(MECHANICAL_PREFIX)) return LEAF_TYPES.MECHANICAL;
   if (matchesAny(label, VERIFICATION_KEYWORDS)) return LEAF_TYPES.VERIFICATION;
   if (matchesAny(label, ANALYSIS_KEYWORDS)) return LEAF_TYPES.ANALYSIS;
   if (matchesAny(label, IMPLEMENTATION_KEYWORDS)) return LEAF_TYPES.IMPLEMENTATION;
@@ -80,13 +95,15 @@ export function classifyLeaf(leaf) {
   return LEAF_TYPES.IMPLEMENTATION;
 }
 
-// tierFor(taskType) -> a TIERS value. Conservative auto-routing: only EXPLORATION
-// is downgraded (cheap); every other type stays deep. BALANCED is part of the
-// vocabulary but is never auto-assigned — it exists for an explicit, manual
-// opt-in on a leaf an author judges mid-weight. Automation only ever picks
-// cheap or deep.
+// tierFor(taskType) -> a TIERS value. Conservative auto-routing: EXPLORATION
+// downgrades to cheap, MECHANICAL to balanced, every other type stays deep.
+// BALANCED is reachable ONLY through the explicit mech- label opt-in (see
+// MECHANICAL_PREFIX) — never through keyword classification — so automation
+// still cannot land it on judgment-bearing work.
 export function tierFor(taskType) {
-  return taskType === LEAF_TYPES.EXPLORATION ? TIERS.CHEAP : TIERS.DEEP;
+  if (taskType === LEAF_TYPES.EXPLORATION) return TIERS.CHEAP;
+  if (taskType === LEAF_TYPES.MECHANICAL) return TIERS.BALANCED;
+  return TIERS.DEEP;
 }
 
 // modelForLeaf({ label }) -> the opts.model value to write (a string) or null