create-byan-agent 2.23.0 → 2.26.0

package/install/lib/yanstaller/installer.js

@@ -113,8 +113,6 @@ async function copyAgentFile(agentName, targetPath) {
  */
 async function generateStub(agentName, platform, targetPath) {
   // TODO: Generate stub based on platform
-  // - Copilot CLI: .github/agents/{agentName}.md with YAML frontmatter
-  // - VSCode: Same as Copilot CLI
   // - Claude Code: MCP config JSON
   // - Codex: .codex/prompts/{agentName}.md
 }

package/install/lib/yanstaller/interviewer.js

@@ -40,7 +40,7 @@ async function ask(recommendation) {
     language: 'English',
     mode: recommendation.mode,
     agents: recommendation.agents,
-    targetPlatforms: ['copilot-cli'],
+    targetPlatforms: ['claude'],
     createSampleAgent: false
   };
 }

package/install/lib/yanstaller/platform-selector.js

@@ -14,7 +14,7 @@ const platforms = require('../platforms');
 /**
  * @typedef {Object} PlatformChoice
  * @property {string} name - Display name
- * @property {string} id - Platform ID ('copilot-cli' | 'vscode' | 'claude' | 'codex')
+ * @property {string} id - Platform ID ('claude' | 'codex')
  * @property {boolean} detected - Is platform installed?
  * @property {string} [path] - Installation path if detected
  * @property {boolean} native - Native integration available?
@@ -29,12 +29,6 @@ const platforms = require('../platforms');
  */
 
 const PLATFORM_INFO = {
-  'copilot-cli': {
-    displayName: 'GitHub Copilot CLI',
-    native: true,
-    specialist: 'marc',
-    icon: '🤖'
-  },
   'claude': {
     displayName: 'Claude Code',
     native: true,
@@ -46,12 +40,6 @@ const PLATFORM_INFO = {
     native: true, // NOW NATIVE!
     specialist: 'codex',
     icon: '📝'
-  },
-  'vscode': {
-    displayName: 'VS Code',
-    native: false,
-    specialist: null,
-    icon: '💻'
   }
 };
 

package/install/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-byan-agent",
-  "version": "2.19.0",
+  "version": "2.26.0",
   "description": "BYAN v2.2.2 - Intelligent AI agent installer with multi-platform native support (GitHub Copilot CLI, Claude Code, Codex/OpenCode)",
   "bin": {
     "create-byan-agent": "bin/create-byan-agent-v2.js"

package/install/src/byan-v2/context/session-state.js

@@ -34,8 +34,8 @@ class SessionState {
     return this.currentState;
   }
 
-  mergeContext(copilotContext) {
-    this.context = copilotContext;
+  mergeContext(context) {
+    this.context = context;
   }
 
   transitionTo(newState) {

package/install/src/byan-v2/index.js

@@ -52,17 +52,13 @@ class ByanV2 {
         low: 30,
         medium: 60
       },
-      outputDir: './_bmad-output/bmb-creations',
-      env: customConfig.env || (process.env.GITHUB_COPILOT ? 'copilot' : 'standalone')
+      outputDir: './_byan-output/bmb-creations',
+      env: customConfig.env || 'standalone'
     };
 
     return { ...defaults, ...customConfig };
   }
 
-  isCopilotContext() {
-    return this.config.env === 'copilot' || process.env.GITHUB_COPILOT === 'true';
-  }
-
   async startSession() {
     this.logger.info('Starting BYAN session', {
       event: 'session_start',

package/install/src/byan-v2/orchestrator/generation-state.js

@@ -1,11 +1,11 @@
 /**
  * GenerationState - Story 4.4
- * Generates agent profile in BMAD/Copilot format
- * 
+ * Generates agent profile in BMAD format
+ *
  * Format:
  * - YAML frontmatter (name, description)
  * - XML structure (<agent>, <persona>, <menu>, <capabilities>)
- * - Compliant with .github/copilot/agents/ standard
+ * - Saved under the _byan/agent/ layout
  */
 
 const Logger = require('../observability/logger');
@@ -178,7 +178,7 @@ class GenerationState {
    */
   getDefaultSavePath() {
     const name = this.sessionState.agentProfileDraft?.name || 'agent';
-    return `.github/copilot/agents/${name}.md`;
+    return `_byan/agent/${name}/${name}.md`;
   }
 
   /**

package/install/src/webui/api.js

@@ -82,8 +82,6 @@ function isByanInstalled(projectRoot) {
 function detectPlatforms(projectRoot) {
   const found = [];
   const checks = [
-    { name: 'copilot-cli', path: '.github/agents' },
-    { name: 'vscode', path: '.vscode' },
     { name: 'claude', path: '.claude' },
     { name: 'codex', path: '.codex/prompts' }
   ];

package/install/src/webui/chat/bridge.js

@@ -3,8 +3,6 @@
  * Each CLI adapter extends Bridge and implements: start(), send(), stop()
  */
 
-const fs = require('fs');
-const path = require('path');
 const layoutResolver = require('../../../../src/byan-v2/lib/layout-resolver');
 
 class Bridge {
@@ -27,13 +25,7 @@ class Bridge {
   resolveAgent(agentName) {
     if (!agentName) return null;
 
-    // Copilot stub takes priority (it is the explicit entry point when present).
-    const githubStub = path.join(this.projectRoot, '.github', 'agents', `bmad-agent-${agentName}.md`);
-    try {
-      if (fs.existsSync(githubStub)) return githubStub;
-    } catch { /* ignore */ }
-
-    // Then the layout resolver: Gen3 _byan/agent/<name>/ first, Gen2 flat +
+    // Layout resolver: Gen3 _byan/agent/<name>/ first, Gen2 flat +
     // per-module, Gen1 _bmad/ fallback.
     const hit = layoutResolver.resolveAgent(agentName, { projectRoot: this.projectRoot });
     return hit ? hit.path : null;
@@ -66,10 +58,6 @@ function createBridge(cliName, options) {
       const ClaudeAdapter = require('./claude-adapter');
       return new ClaudeAdapter(options);
     }
-    case 'copilot': {
-      const CopilotAdapter = require('./copilot-adapter');
-      return new CopilotAdapter(options);
-    }
     case 'codex': {
       const CodexAdapter = require('./codex-adapter');
       return new CodexAdapter(options);

package/install/src/webui/chat/cli-detector.js

@@ -4,12 +4,10 @@
 
 const { execFile } = require('child_process');
 const fs = require('fs');
-const path = require('path');
 const layoutResolver = require('../../../../src/byan-v2/lib/layout-resolver');
 
 const CLI_DEFINITIONS = [
   { name: 'claude', command: 'claude', versionArg: '--version' },
-  { name: 'copilot', command: 'copilot', versionArg: '--version' },
   { name: 'codex', command: 'codex', versionArg: '--version' },
 ];
 
@@ -95,15 +93,6 @@ function parseFrontmatter(content) {
   return fm;
 }
 
-function scanDir(dirPath) {
-  try {
-    if (!fs.existsSync(dirPath)) return [];
-    return fs.readdirSync(dirPath).filter((f) => f.endsWith('.md'));
-  } catch {
-    return [];
-  }
-}
-
 // Map a resolver layout (+ rel) to the legacy source label, so API responses
 // stay stable: Gen2 flat / Gen3 -> 'byan', Gen2 per-module -> 'bmad-<mod>'.
 function sourceForLayout(layout, rel) {
@@ -136,18 +125,6 @@ async function detectAgents(projectRoot) {
     });
   };
 
-  // Copilot stubs (.github/agents) — flat scan, with the bmad-agent- prefix.
-  // Listed first so a copilot stub wins the dedup, preserving prior priority.
-  const githubDir = path.join(projectRoot, '.github', 'agents');
-  for (const file of scanDir(githubDir)) {
-    const id = file
-      .replace(/\.md$/, '')
-      .replace(/^bmad-agent-/, '')
-      .replace(/\.backup\.\d+.*$/, '')
-      .replace(/\.optimized.*$/, '');
-    pushAgent(id, 'copilot', path.join(githubDir, file));
-  }
-
   // _byan agents via the layout resolver: Gen3 _byan/agent/<name>/ first, then
   // Gen2 flat _byan/agents/ and per-module _byan/<module>/agents/ (deduped).
   for (const a of layoutResolver.listAgents({ projectRoot })) {

package/install/src/webui/public/app.js

@@ -130,7 +130,7 @@ class ByanApp {
       );
       html += this.detectionRow(true, 'Operating System', this.status.detection?.os || navigator.platform);
 
-      const platformNames = { 'copilot-cli': 'GitHub Copilot CLI', 'vscode': 'VSCode', 'claude': 'Claude Code', 'codex': 'Codex' };
+      const platformNames = { 'claude': 'Claude Code', 'codex': 'Codex' };
       const detectedPlatforms = this.status.detection?.platforms || [];
       if (detectedPlatforms.length > 0) {
         for (const p of detectedPlatforms) {
@@ -191,8 +191,6 @@ class ByanApp {
     ];
 
     const platformOptions = [
-      { id: 'copilot-cli', label: 'GitHub Copilot CLI' },
-      { id: 'vscode', label: 'VSCode Extension' },
       { id: 'claude', label: 'Claude Code' },
       { id: 'codex', label: 'Codex / OpenCode' }
     ];

package/install/src/webui/public/chat.html

@@ -21,7 +21,6 @@
       </div>
       <select id="cli-select" class="cli-select" aria-label="Select CLI backend">
         <option value="claude">Claude Code</option>
-        <option value="copilot">GitHub Copilot</option>
         <option value="codex">Codex</option>
       </select>
       <select id="model-select" class="model-select" aria-label="Select model">
@@ -183,7 +182,6 @@
         <select id="setting-cli">
           <option value="auto">Auto-detect</option>
           <option value="claude">Claude Code</option>
-          <option value="copilot">GitHub Copilot</option>
           <option value="codex">OpenCode/Codex</option>
         </select>
       </div>

package/install/src/webui/public/chat.js

@@ -172,7 +172,6 @@ class ByanChat {
   async detectCLIs() {
     const knownCLIs = [
       { id: 'claude', name: 'Claude Code', cmd: 'claude' },
-      { id: 'copilot', name: 'GitHub Copilot', cmd: 'copilot' },
       { id: 'codex', name: 'OpenCode', cmd: 'codex' }
     ];
 

package/install/src/webui/public/index.html

@@ -32,7 +32,7 @@
       <div class="step-content">
         <h2>Welcome to BYAN</h2>
         <p class="lead">Intelligent AI agent platform with multi-platform support.<br>
-          GitHub Copilot CLI, Claude Code, Codex, and VSCode.</p>
+          Claude Code and Codex.</p>
         <div class="feature-grid">
           <div class="feature-card">
             <div class="feature-icon" aria-hidden="true">&#9670;</div>
@@ -42,7 +42,7 @@
           <div class="feature-card">
             <div class="feature-icon" aria-hidden="true">&#9672;</div>
             <h3>Multi-Platform</h3>
-            <p>Install agents across Copilot CLI, Claude Code, Codex, and VSCode simultaneously.</p>
+            <p>Install agents across Claude Code and Codex simultaneously.</p>
           </div>
           <div class="feature-card">
             <div class="feature-icon" aria-hidden="true">&#9656;</div>

package/install/templates/.claude/CLAUDE.md

@@ -27,7 +27,6 @@ Voir @.claude/rules/hermes-dispatcher.md pour les commandes Hermes.
   .claude/             # Integration Claude Code
     CLAUDE.md          # Ce fichier (instructions projet)
     rules/             # Regles modulaires par domaine
-  .github/agents/      # Agents Copilot CLI (si installe)
 ```
 
 ## Regles de Code
@@ -99,7 +98,7 @@ Dans BYAN: tapez `[FC]` pour le sous-menu fact-check.
 
 Mode d'enforcement anti-downgrade : empeche l'agent de livrer moins que demande
 (MVP au lieu de prod, stub au lieu de feature, template bacle). Fonctionne sur
-les 3 plateformes (Claude Code, Codex, Copilot).
+les 2 plateformes (Claude Code, Codex).
 
 Protocole : lock du scope -> build complet -> self-verify >= 3 passes -> complete
 (jeton d'audit). Le commit est bloque tant que la verification n'est pas acquise.
@@ -111,3 +110,15 @@ Protocole : lock du scope -> build complet -> self-verify >= 3 passes -> complet
 - Persistance : sessions poussees vers l'API byan_web (autorite ; local = miroir/fallback offline) via `lib/strict-sync.js` ; migration `033` + `routes/strict-sessions.js` cote byan_web
 
 Detail complet : voir @.claude/rules/strict-mode.md
+
+<!-- BYAN-AUTOBENCH:BEGIN (Generated by byan-sync-rules from _byan/_config/autobench.yaml. Do not hand-edit.) -->
+## BYAN Auto-Benchmark
+
+Before asking the user to choose between options, benchmark the fork: render
+ONE compact table (Option | <= 4 criteria | Niv + a best-first reco line) when
+both gates hold (>= 2 non-substitutable options diverging on >= 1 weighted
+criterion). Emit the marker verbatim before the table:
+`<!-- BYAN-BENCH:done g1=<#options> g2=<#divergent-criteria> scope=<internal|external> conf=<assertive|lean> -->`.
+A confirm, a destructive prompt, or an obvious default is not a fork — emit
+`<!-- BYAN-BENCH:skip reason=.. -->` instead. Full doctrine: see @.claude/rules/benchmark.md
+<!-- BYAN-AUTOBENCH:END -->

package/install/templates/.claude/agents/bmad-byan.md

@@ -120,7 +120,7 @@ Meta-Agent Creator + Intelligent Interviewer + Brainstorming Expert
 - Systematically apply 64 mantras to ensure quality and best practices
 - Perform MCD ⇄ MCT validation to ensure data-treatment coherence
 - Evaluate consequences of actions using 10-dimension checklist
-- Generate agents for GitHub Copilot, VSCode, Claude Code, Codex
+- Generate agents for Claude Code, Codex
 - Support incremental agent evolution sprint-by-sprint
 - Apply TDD principles at conceptual level
 

package/install/templates/.claude/hooks/autobench-stop-guard.js

@@ -0,0 +1,286 @@
+#!/usr/bin/env node
+/**
+ * Stop hook — BYAN Auto-Benchmark end-of-turn guard.
+ *
+ * Goal : when the assistant's finished message presents a CHOICE between
+ * options (a fork) but did NOT emit a BYAN-BENCH marker, the agent skipped the
+ * benchmark doctrine. The hook blocks ONCE to force exactly one regeneration in
+ * which the agent re-presents the fork as the compact benchmark table and emits
+ * the marker. It never loops : a block-token keyed on the message content makes
+ * the second pass non-blocking by construction.
+ *
+ * Shipped DISARMED (approach C) : the hook observes and ledgers every turn but
+ * does not block until explicitly armed (enforcement.armed in the config —
+ * config-only, set via the YAML + byan-sync-rules, no loose flag file). Day one
+ * is zero noise / zero latency; the net is pre-built but inert until the user
+ * opts in. A disarmed turn that WOULD have fired is recorded as
+ * observed-disarmed-fork so arming later is an informed decision.
+ *
+ * Detection is ARTIFACT-primary with a regex fallback. The decision order :
+ *   1. MARKER   : a BYAN-BENCH:done|skip marker -> satisfied (the agent already
+ *                 benchmarked, or deliberately skipped a degenerate fork).
+ *   2. NEVER    : y/n confirms and destructive prompts are exempt — we never
+ *                 benchmark "proceed?" or "rm -rf".
+ *   3. ESCAPE   : the session flag (.byan-autobench/off) or the cross-session
+ *                 config opt-out suppresses all blocking.
+ *   4. DISARMED : not armed -> observe + ledger, never block (the default).
+ *   5. BLOCKED  : a block-token for this turn already exists -> the regen pass,
+ *                 do not block again.
+ *   6. FORK     : a fork is present when an AskUserQuestion tool_use artifact is
+ *                 in the finished turn (the unambiguous, primary signal). The
+ *                 choice-language regex is only a LAST-RESORT fallback for
+ *                 inline-prose forks that never called the tool.
+ *
+ * Honest ceiling (GH #28273) : the Stop hook is REACTIVE. It cannot intercept
+ * before the message is displayed; it can only force a regeneration after the
+ * fact. The proactive half is the doctrine the agent self-applies. This hook is
+ * the safety net, not a pre-display filter.
+ *
+ * Non-blocking on any IO/parse error : the hook never traps a turn it cannot
+ * read. Every invocation appends one fire/miss line to the ledger.
+ */
+
+'use strict';
+
+const {
+  loadAutobenchConfig,
+  escapeHatchActive,
+  isArmed,
+  readBlockToken,
+  writeBlockToken,
+  appendLedger,
+  extractLastAssistantText,
+  extractLastAssistantContent,
+  hasChoiceArtifact,
+  turnHash,
+  readStdin,
+  parseJson,
+} = require('./lib/autobench-runtime');
+
+// Reconstruct a RegExp from a {source, flags} config pair. Returns null on a
+// malformed pattern so a single bad config entry never throws the whole hook.
+function compileRegex(spec) {
+  if (!spec || typeof spec.source !== 'string') return null;
+  try {
+    return new RegExp(spec.source, spec.flags || '');
+  } catch {
+    return null;
+  }
+}
+
+function countMatches(text, re) {
+  if (!re) return 0;
+  // A global regex is required to count; clone with the g flag if absent.
+  const g = re.flags.includes('g') ? re : new RegExp(re.source, re.flags + 'g');
+  const m = text.match(g);
+  return m ? m.length : 0;
+}
+
+function anyRegexMatches(text, specs) {
+  if (!Array.isArray(specs)) return false;
+  return specs.some((spec) => {
+    const re = compileRegex(spec);
+    return Boolean(re) && re.test(text);
+  });
+}
+
+// Evaluate the choice-language signals with their per-signal thresholds.
+// A signal fires when : (min_matches present -> >= that many matches) OR
+// (requires_candidates present -> the signal matches AND >= N candidate tokens
+// co-occur) OR (a plain match otherwise).
+function hasChoiceLanguage(text, config) {
+  const specs = (config && config.choice_language) || [];
+  const candidateRe = compileRegex(config && config.candidate_token);
+  const candidateCount = candidateRe ? countMatches(text, candidateRe) : 0;
+
+  return specs.some((spec) => {
+    const re = compileRegex(spec);
+    if (!re) return false;
+
+    if (typeof spec.min_matches === 'number') {
+      return countMatches(text, re) >= spec.min_matches;
+    }
+    if (typeof spec.requires_candidates === 'number') {
+      return re.test(text) && candidateCount >= spec.requires_candidates;
+    }
+    return re.test(text);
+  });
+}
+
+function hasMarker(text, config) {
+  const spec = config && config.marker_patterns && config.marker_patterns.any;
+  const re = compileRegex(spec);
+  return Boolean(re) && re.test(text);
+}
+
+function hasNeverListed(text, config) {
+  return anyRegexMatches(text, config && config.never_list);
+}
+
+// Parse the marker fields (g1/g2/scope) for the ledger. Best-effort : a marker
+// without fields still satisfies; the fields only enrich the audit trail.
+function readMarkerFields(text, config) {
+  const fields = (config && config.marker_fields) || {};
+  const out = {};
+  const g1 = compileRegex(fields.g1);
+  const g2 = compileRegex(fields.g2);
+  const scope = compileRegex(fields.scope);
+  let m;
+  if (g1 && (m = text.match(g1))) out.g1 = Number(m[1]);
+  if (g2 && (m = text.match(g2))) out.g2 = Number(m[1]);
+  if (scope && (m = text.match(scope))) out.scope = m[1];
+  return out;
+}
+
+function markerKind(text, config) {
+  const mp = (config && config.marker_patterns) || {};
+  const doneRe = compileRegex(mp.done);
+  const skipRe = compileRegex(mp.skip);
+  if (doneRe && doneRe.test(text)) return 'done';
+  if (skipRe && skipRe.test(text)) return 'skip';
+  return null;
+}
+
+/**
+ * Pure decision. No IO, no clock — fully unit-testable.
+ *
+ * Inputs : lastAssistantText (the finished prose), artifact (true when an
+ * AskUserQuestion tool_use was in the finished turn — the caller computes this
+ * from the raw content so the decision stays pure), armed (the enforcement gate),
+ * config, escapeHatch, blocked.
+ *
+ * Detection is ARTIFACT-primary : a real fork is present when the artifact is
+ * there OR, as a last-resort fallback, when the choice-language regex matches
+ * inline prose. block is true IFF a fork is present AND no marker AND not
+ * never-listed AND escape-hatch inactive AND ARMED AND not already blocked.
+ *
+ * Returns { block, reason?, ledger } where ledger is the audit record.
+ */
+function decideBench({ lastAssistantText, artifact, armed, config, escapeHatch, blocked }) {
+  const text = lastAssistantText || '';
+
+  const marker = hasMarker(text, config);
+  const neverHit = hasNeverListed(text, config);
+  const choiceLang = hasChoiceLanguage(text, config);
+  const hasArtifact = artifact === true;
+  // ARTIFACT-primary : the structural AskUserQuestion tool_use is the unambiguous
+  // fork signal. The lexical regex is only the fallback for prose forks that
+  // never called the tool.
+  const fork = hasArtifact || choiceLang;
+  const detection = hasArtifact ? 'artifact' : choiceLang ? 'regex-fallback' : null;
+  const armedOn = armed === true;
+
+  const ledger = { neverHit, choiceLang, artifact: hasArtifact, marker, detection, armed: armedOn };
+
+  if (marker) {
+    const kind = markerKind(text, config);
+    Object.assign(ledger, readMarkerFields(text, config));
+    ledger.event = kind === 'skip' ? 'satisfied-skip' : 'satisfied-marker';
+    return { block: false, ledger };
+  }
+  if (neverHit) {
+    ledger.event = 'satisfied-never';
+    return { block: false, ledger };
+  }
+  if (escapeHatch) {
+    ledger.event = 'satisfied-escape';
+    return { block: false, ledger };
+  }
+  if (!armedOn) {
+    // DISARMED by default (approach C) : never block. Record whether a fork WOULD
+    // have fired, so arming later is data-informed, not a blind flip.
+    ledger.event = fork ? 'observed-disarmed-fork' : 'observed-disarmed';
+    return { block: false, ledger };
+  }
+  if (blocked) {
+    // The regen pass : we already blocked this exact content once.
+    ledger.event = 'satisfied-already-blocked';
+    return { block: false, ledger };
+  }
+  if (!fork) {
+    ledger.event = 'no-choice';
+    return { block: false, ledger };
+  }
+
+  // A genuine miss while ARMED : the agent offered a fork without benchmarking it.
+  const reason =
+    (config && config.banners && config.banners.stop_block) ||
+    'Auto-benchmark: you presented a choice without a BYAN-BENCH marker. Re-present it as the compact benchmark table and emit the marker.';
+  ledger.event = 'fired-block';
+  return { block: true, reason, ledger };
+}
+
+if (require.main === module) {
+  (async () => {
+    // Wrap everything : the hook must NEVER trap a turn it cannot read.
+    try {
+      const config = loadAutobenchConfig();
+      const payload = parseJson(await readStdin());
+      const lastAssistantText = extractLastAssistantText(payload);
+      // ARTIFACT-primary signal : read the RAW last-assistant content (the block
+      // array extractLastAssistantText flattens away) so the structural
+      // AskUserQuestion tool_use is visible to the decision.
+      const artifact = hasChoiceArtifact(extractLastAssistantContent(payload));
+
+      const hash = turnHash(lastAssistantText);
+      const escapeHatch = escapeHatchActive(config);
+      const armed = isArmed(config);
+      // Loop-guard : the content-hash block token is primary; stop_hook_active is
+      // an additional belt from the runtime (a prior Stop hook already blocked
+      // this turn), so we never depend on it alone.
+      const blocked = readBlockToken(hash) || payload.stop_hook_active === true;
+
+      const decision = decideBench({ lastAssistantText, artifact, armed, config, escapeHatch, blocked });
+
+      // Audit trail : one JSONL line per invocation. turnHash is content-only;
+      // any timestamp/session comes from the environment, kept out of the pure
+      // decision so it stays deterministic.
+      appendLedger(
+        {
+          turnHash: hash,
+          event: decision.ledger.event,
+          g1: decision.ledger.g1,
+          g2: decision.ledger.g2,
+          scope: decision.ledger.scope,
+          neverHit: decision.ledger.neverHit,
+          choiceLang: decision.ledger.choiceLang,
+          artifact: decision.ledger.artifact,
+          detection: decision.ledger.detection,
+          armed: decision.ledger.armed,
+          marker: decision.ledger.marker,
+          ts: process.env.BYAN_HOOK_TS || undefined,
+          session: process.env.CLAUDE_SESSION_ID || undefined,
+        },
+        config
+      );
+
+      if (!decision.block) {
+        process.stdout.write(JSON.stringify({ continue: true }));
+        process.exit(0);
+      }
+
+      // Block-once : write the token BEFORE emitting the block so the
+      // regenerated turn (same content if the agent fails to fix) is exempt.
+      writeBlockToken(hash);
+      process.stdout.write(
+        JSON.stringify({ decision: 'block', reason: decision.reason, systemMessage: decision.reason })
+      );
+      process.exit(2);
+    } catch {
+      // Last-resort net : on any unexpected failure, let the turn end.
+      process.stdout.write(JSON.stringify({ continue: true }));
+      process.exit(0);
+    }
+  })();
+}
+
+module.exports = {
+  decideBench,
+  hasChoiceLanguage,
+  hasMarker,
+  hasNeverListed,
+  markerKind,
+  readMarkerFields,
+  compileRegex,
+  countMatches,
+};