create-byan-agent 2.25.0 → 2.26.0

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

@@ -9,7 +9,6 @@ import yaml from 'js-yaml';
 //   - .claude/skills/byan-strict/SKILL.md            (owned, full-file)
 //   - .claude/hooks/lib/strict-config.json           (owned, full-file)
 //   - AGENTS.md                                       (upsert block, Codex)
-//   - .github/copilot-instructions.md                 (upsert block, Copilot)
 //
 // Owned files are rewritten wholesale (they carry a generated-by header).
 // Shared files get a block upserted between BYAN-STRICT markers, leaving the
@@ -19,6 +18,10 @@ const BEGIN = 'BYAN-STRICT:BEGIN';
 const END = 'BYAN-STRICT:END';
 const DEFAULT_CONFIG_REL = path.join('_byan', '_config', 'strict-mode.yaml');
 
+const AUTOBENCH_BEGIN = 'BYAN-AUTOBENCH:BEGIN';
+const AUTOBENCH_END = 'BYAN-AUTOBENCH:END';
+const AUTOBENCH_CONFIG_REL = path.join('_byan', '_config', 'autobench.yaml');
+
 export function resolveRoot(projectRoot) {
   return projectRoot || process.env.CLAUDE_PROJECT_DIR || process.cwd();
 }
@@ -39,6 +42,31 @@ export function loadConfig({ projectRoot, configPath } = {}) {
   return cfg;
 }
 
+// Loads and validates the auto-benchmark source of truth. Mirrors loadConfig:
+// throws on a missing file, a non-object parse, an empty mantras list, or a
+// missing doctrine brick — so a malformed YAML fails the generator loudly
+// rather than emitting a half-rendered pointer block.
+export function loadAutobenchConfig({ projectRoot, configPath } = {}) {
+  const root = resolveRoot(projectRoot);
+  const file = configPath || path.join(root, AUTOBENCH_CONFIG_REL);
+  if (!fs.existsSync(file)) {
+    throw new Error(`autobench config not found at ${file}`);
+  }
+  const cfg = yaml.load(fs.readFileSync(file, 'utf8'));
+  if (!cfg || typeof cfg !== 'object') {
+    throw new Error(`autobench config at ${file} did not parse to an object`);
+  }
+  if (!Array.isArray(cfg.mantras) || cfg.mantras.length === 0) {
+    throw new Error('autobench config must define a non-empty mantras list');
+  }
+  for (const brick of ['trigger', 'scaler', 'format']) {
+    if (!cfg[brick] || typeof cfg[brick] !== 'object') {
+      throw new Error(`autobench config must define the '${brick}' brick`);
+    }
+  }
+  return cfg;
+}
+
 // ---------------------------------------------------------------------------
 // Renderers — pure functions config -> string.
 // ---------------------------------------------------------------------------
@@ -46,6 +74,9 @@ export function loadConfig({ projectRoot, configPath } = {}) {
 const GENERATED_NOTE =
   'Generated by byan-sync-rules from _byan/_config/strict-mode.yaml. Do not hand-edit.';
 
+const AUTOBENCH_GENERATED_NOTE =
+  'Generated by byan-sync-rules from _byan/_config/autobench.yaml. Do not hand-edit.';
+
 export function renderStrictConfig(cfg) {
   return {
     _generated_by: 'byan-sync-rules',
@@ -125,7 +156,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 ${cfg.self_verify.min_passes} times** with
@@ -160,19 +194,84 @@ Hard mantras:
 ${mantraLines(cfg)}`;
 }
 
-export function renderCopilotBlock(cfg) {
-  // Copilot has no blocking mechanism; this is injection-only guidance.
-  return `## BYAN Strict Mode
-
-${cfg.injection.context_banner.trim()}
-
-Use the \`byan\` MCP strict tools to lock scope, self-verify (>= ${cfg.self_verify.min_passes} passes),
-and complete. The pre-commit gate is the final net: a commit without a fresh,
-matching audit token is rejected.
+// Maps the enriched cfg.hooks section to the EXACT runtime shape read by
+// autobench-stop-guard.js. Every key and every {source, flags} pair structure
+// must stay in sync with what compileRegex / hasChoiceLanguage / hasMarker /
+// hasNeverListed / readMarkerFields / escapeHatchActive / ledgerPath consume.
+//
+// This is the function that closes the single-source-of-truth gap: before it
+// existed, autobench-config.json was hand-authored and the YAML toggle
+// (escape_hatch.disabled) was never propagated to the runtime file.
+export function renderAutobenchConfig(cfg) {
+  const h = cfg.hooks;
+  const mp = h.marker_patterns;
+  const mf = h.marker_fields;
+  const eh = h.escape_hatch;
 
-Hard mantras:
+  return {
+    _generated_by: 'byan-sync-rules',
+    _note:
+      'Runtime subset read by autobench-stop-guard.js. Edit _byan/_config/autobench.yaml and regenerate; do not hand-edit. Regexes are {source, flags} pairs reconstructed into RegExp at load time.',
+    version: cfg.version,
+    marker_patterns: {
+      any: { source: mp.any.source, flags: mp.any.flags },
+      done: { source: mp.done.source, flags: mp.done.flags },
+      skip: { source: mp.skip.source, flags: mp.skip.flags },
+    },
+    marker_fields: {
+      g1: { source: mf.g1.source, flags: mf.g1.flags },
+      g2: { source: mf.g2.source, flags: mf.g2.flags },
+      scope: { source: mf.scope.source, flags: mf.scope.flags },
+    },
+    never_list: h.never_list.map((entry) => ({ source: entry.source, flags: entry.flags })),
+    choice_language: h.choice_language.map((entry) => {
+      const out = { source: entry.source, flags: entry.flags };
+      // Preserve optional threshold fields only when present; omitting them
+      // keeps the config lean and matches the runtime's typeof checks.
+      if (typeof entry.min_matches === 'number') out.min_matches = entry.min_matches;
+      if (typeof entry.requires_candidates === 'number') out.requires_candidates = entry.requires_candidates;
+      return out;
+    }),
+    candidate_token: { source: h.candidate_token.source, flags: h.candidate_token.flags },
+    escape_hatch: {
+      // session_flag is read by autobench-runtime.js but not stored in
+      // config.json (the runtime hardcodes the path). Carry only the two
+      // fields the runtime actually reads from config.json.
+      session_flag: eh.session_flag,
+      disabled: eh.disabled,
+    },
+    enforcement: {
+      // Disarmed-by-default (approach C): the Stop hook observes and ledgers but
+      // does not block until armed. Arming is config-only (armed: true in the
+      // YAML); there is no loose flag file, so a stray file cannot silently arm a
+      // machine. Defaulting armed to false keeps an older source inert by default.
+      armed: Boolean(h.enforcement && h.enforcement.armed === true),
+    },
+    ledger: {
+      path: h.ledger_path,
+    },
+    banners: {
+      stop_block: h.stop_block,
+    },
+  };
+}
 
-${mantraLines(cfg)}`;
+// The lean auto-benchmark pointer block. One shared block for both
+// platform files (CLAUDE.md / AGENTS.md): names the
+// feature, states the marker one-liner the agent must emit, and points to the
+// full doctrine. Kept short on purpose — CLAUDE.md stays lean via pointers, and
+// the full rule lives in .claude/rules/benchmark.md (owned, authored elsewhere).
+export function renderAutobenchPointerBlock(cfg) {
+  const name = (cfg.name || 'BYAN Auto-Benchmark').trim();
+  return `## ${name}
+
+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`;
 }
 
 // ---------------------------------------------------------------------------
@@ -191,11 +290,29 @@ function writeIfChanged(filePath, content) {
   return existing === null ? 'created' : 'updated';
 }
 
+// Escapes a marker string for safe embedding in a RegExp source. Markers are
+// authored as plain identifiers today, but a literal-safe regex keeps the
+// generalized signature robust if a future marker carries a regex metacharacter.
+function escapeRegex(s) {
+  return String(s).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
 // Insert or replace a block delimited by HTML-comment markers. Preserves
 // everything outside the markers. If the file does not exist, creates it with
 // just the block.
-export function upsertBlock({ filePath, block }) {
-  const wrapped = `<!-- ${BEGIN} (${GENERATED_NOTE}) -->\n${block}\n<!-- ${END} -->`;
+//
+// markers defaults to the module-level STRICT pair so every existing strict
+// callsite keeps working unchanged. Passing a distinct pair (e.g. the
+// AUTOBENCH markers) scopes the replace-regex to that pair only, so a STRICT
+// block and an AUTOBENCH block coexist in one file without clobbering each
+// other.
+export function upsertBlock({
+  filePath,
+  block,
+  markers = { begin: BEGIN, end: END },
+  note = GENERATED_NOTE,
+}) {
+  const wrapped = `<!-- ${markers.begin} (${note}) -->\n${block}\n<!-- ${markers.end} -->`;
   const existing = fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf8') : null;
 
   if (existing === null) {
@@ -205,7 +322,7 @@ export function upsertBlock({ filePath, block }) {
   }
 
   const re = new RegExp(
-    `<!-- ${BEGIN}[\\s\\S]*?${END} -->`,
+    `<!-- ${escapeRegex(markers.begin)}[\\s\\S]*?${escapeRegex(markers.end)} -->`,
     'm'
   );
   let next;
@@ -216,7 +333,7 @@ export function upsertBlock({ filePath, block }) {
   }
   if (next === existing) return 'unchanged';
   fs.writeFileSync(filePath, next);
-  return existing.includes(BEGIN) ? 'updated' : 'appended';
+  return existing.includes(markers.begin) ? 'updated' : 'appended';
 }
 
 // ---------------------------------------------------------------------------
@@ -241,12 +358,6 @@ export function syncRules({ projectRoot, configPath } = {}) {
   const agentsPath = path.join(root, 'AGENTS.md');
   report['AGENTS.md'] = upsertBlock({ filePath: agentsPath, block: renderAgentsBlock(cfg) });
 
-  const copilotPath = path.join(root, '.github', 'copilot-instructions.md');
-  report['.github/copilot-instructions.md'] = upsertBlock({
-    filePath: copilotPath,
-    block: renderCopilotBlock(cfg),
-  });
-
   const mantrasPath = path.join(root, 'src', 'byan-v2', 'data', 'strict-mantras.json');
   if (fs.existsSync(path.dirname(mantrasPath))) {
     report['src/byan-v2/data/strict-mantras.json'] = writeIfChanged(
@@ -258,4 +369,42 @@ export function syncRules({ projectRoot, configPath } = {}) {
   return report;
 }
 
+// Auto-benchmark orchestrator. Kept SEPARATE from syncRules so the strict
+// generator stays untouched and independently testable. Upserts the lean
+// pointer block into the three platform files and writes the runtime config
+// that the Stop hook reads. The config write closes the single-source-of-truth
+// gap: escape_hatch.disabled toggled in the YAML now reaches the runtime file.
+// Returns a {file: action} report like syncRules.
+export function syncAutobench({ projectRoot, configPath } = {}) {
+  const root = resolveRoot(projectRoot);
+  const cfg = loadAutobenchConfig({ projectRoot: root, configPath });
+
+  const report = {};
+  const block = renderAutobenchPointerBlock(cfg);
+  const markers = { begin: AUTOBENCH_BEGIN, end: AUTOBENCH_END };
+
+  // CLAUDE.md uses the lean pointer convention (.claude/CLAUDE.md holds the
+  // other rule pointers: strict, fact-check, ELO). AGENTS.md (Codex) is the
+  // other cross-platform mechanism target.
+  const targets = {
+    '.claude/CLAUDE.md': path.join(root, '.claude', 'CLAUDE.md'),
+    'AGENTS.md': path.join(root, 'AGENTS.md'),
+  };
+
+  for (const [rel, filePath] of Object.entries(targets)) {
+    report[rel] = upsertBlock({ filePath, block, markers, note: AUTOBENCH_GENERATED_NOTE });
+  }
+
+  // Write the runtime config that autobench-stop-guard.js reads. Mirrors the
+  // strict pattern (syncRules writes strict-config.json from strict-mode.yaml).
+  const autobenchCfgPath = path.join(root, '.claude', 'hooks', 'lib', 'autobench-config.json');
+  report['.claude/hooks/lib/autobench-config.json'] = writeIfChanged(
+    autobenchCfgPath,
+    JSON.stringify(renderAutobenchConfig(cfg), null, 2) + '\n'
+  );
+
+  return report;
+}
+
 export const MARKERS = { BEGIN, END };
+export const AUTOBENCH_MARKERS = { BEGIN: AUTOBENCH_BEGIN, END: AUTOBENCH_END };

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

@@ -47,6 +47,7 @@ export const PORTABLE = {
     'create-excalidraw-dataflow',
     'create-excalidraw-flowchart',
     'create-excalidraw-wireframe',
+    'byan-benchmark',
   ],
 };
 

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

@@ -11,9 +11,8 @@ import {
 import { dispatch } from './lib/dispatch.js';
 import { harvest as harvestInsights, renderDigest as renderInsightDigest } from './lib/insight-harvest.js';
 import { appendOutcome } from './lib/outcome-buffer.js';
-import { validateForLog } from './lib/advisory-autofeed.js';
+import { validateForLog, eloOutcomeForStrictComplete } from './lib/advisory-autofeed.js';
 import { readSoul, appendSoulMemory } from './lib/soul.js';
-import { listSessions, readSessionEvents, searchSessions } from './lib/copilot.js';
 import {
   start as fdStart,
   status as fdStatus,
@@ -72,6 +71,17 @@ import {
   syncEnabled as strictSyncEnabled,
   resolveProjectId as strictResolveProjectId,
 } from './lib/strict-sync.js';
+import {
+  syncEnabled as leantimeEnabled,
+  rpc as leantimeRpc,
+  ensureProject as leantimeEnsureProject,
+  createTask as leantimeCreateTask,
+  moveTask as leantimeMoveTask,
+  assignTask as leantimeAssignTask,
+  getTask as leantimeGetTask,
+  getBoard as leantimeGetBoard,
+  METHODS as LEANTIME_METHODS,
+} from './lib/leantime-sync.js';
 
 // Compact view of a best-effort strict-sync result for tool responses.
 function syncResult(sync) {
@@ -113,6 +123,14 @@ function requireToken() {
   }
 }
 
+// Leantime uses its OWN env pair (LEANTIME_API_URL/LEANTIME_API_TOKEN), kept
+// distinct from BYAN_API_URL so the two backends never get crossed.
+function requireLeantime() {
+  if (!process.env.LEANTIME_API_URL || !process.env.LEANTIME_API_TOKEN) {
+    throw new Error('LEANTIME_API_URL + LEANTIME_API_TOKEN env vars are required for byan_leantime_* tools.');
+  }
+}
+
 async function apiRequest(path, options = {}) {
   const url = `${BYAN_API_URL}${path}`;
   const headers = {
@@ -407,39 +425,6 @@ const tools = [
       additionalProperties: false,
     },
   },
-  {
-    name: 'byan_copilot_sessions',
-    description:
-      'List GitHub Copilot CLI sessions stored locally at ~/.copilot/session-state/. Returns sessionId, start/end time, cwd, branch, agent name, message and tool call counts. Sorted most-recent-first. Use to discover past Copilot CLI conversations for reference or import.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        limit: { type: 'number', description: 'Max sessions to return (default 20).' },
-        sinceIso: { type: 'string', description: 'ISO timestamp filter — only sessions started after this.' },
-        cwdFilter: { type: 'string', description: 'Substring match on session cwd (e.g. "byan_web").' },
-      },
-      additionalProperties: false,
-    },
-  },
-  {
-    name: 'byan_copilot_session_events',
-    description:
-      'Read events of a specific Copilot CLI session (events.jsonl). Optionally filter by event type (user.message, assistant.message, tool.execution_start, etc.). Useful to inspect the flow of a past session.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        sessionId: { type: 'string', description: 'Session UUID from byan_copilot_sessions.' },
-        types: {
-          type: 'array',
-          items: { type: 'string' },
-          description: 'Filter to these event types only.',
-        },
-        limit: { type: 'number', description: 'Max events (default 200).' },
-      },
-      required: ['sessionId'],
-      additionalProperties: false,
-    },
-  },
   {
     name: 'byan_fd_start',
     description:
@@ -597,6 +582,10 @@ const tools = [
           items: { type: 'string' },
           description: 'Glob patterns of paths the agent may modify.',
         },
+        domain: {
+          type: 'string',
+          description: 'Optional explicit ELO domain (e.g. security, performance, javascript). When set, a successful byan_strict_complete feeds one VALIDATED outcome to the ELO learning loop. Recorded verbatim (your explicit input, never inferred from text); omit to feed nothing.',
+        },
         force: { type: 'boolean', description: 'Relock with different scope.' },
         projectId: {
           type: 'string',
@@ -658,7 +647,7 @@ const tools = [
   {
     name: 'byan_strict_suggest',
     description:
-      'Check whether a piece of text (user request, feature name) signals a production-grade deliverable that should be built under strict mode. Reads activation keywords from _byan/_config/strict-mode.yaml. Returns { suggested, matched, message }. Use on any platform (Codex/Copilot have no in-session hook) to decide whether to lock strict mode.',
+      'Check whether a piece of text (user request, feature name) signals a production-grade deliverable that should be built under strict mode. Reads activation keywords from _byan/_config/strict-mode.yaml. Returns { suggested, matched, message }. Use on any platform (Codex has no in-session hook) to decide whether to lock strict mode.',
     inputSchema: {
       type: 'object',
       properties: {
@@ -848,25 +837,6 @@ const tools = [
       additionalProperties: false,
     },
   },
-  {
-    name: 'byan_copilot_search',
-    description:
-      'Full-text search across all Copilot CLI sessions. Finds messages (user + assistant by default) containing the query string. Returns sessionId + timestamp + excerpt. Use to recall past discussions without knowing which session they were in.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        query: { type: 'string', description: 'Substring to search for (case-insensitive).' },
-        types: {
-          type: 'array',
-          items: { type: 'string' },
-          description: 'Event types to scan (default: user.message, assistant.message).',
-        },
-        limit: { type: 'number', description: 'Max matches (default 50).' },
-      },
-      required: ['query'],
-      additionalProperties: false,
-    },
-  },
 
   // ─── Projects ─────────────────────────────────────────────────────────
   {
@@ -1198,6 +1168,101 @@ const tools = [
       additionalProperties: false,
     },
   },
+
+  // ─── Leantime (project-management mirror) ─────────────────────────────
+  // Client-side automation of the self-hosted Leantime JSON-RPC API. Used by
+  // the FD workflow to create a project + a task per feature and move task
+  // status across phases. Needs LEANTIME_API_URL + LEANTIME_API_TOKEN.
+  {
+    name: 'byan_leantime_ping',
+    description:
+      'Healthcheck the Leantime integration: reports api_url, token presence, and (if configured) whether the JSON-RPC API is reachable. Surfaces the wrong-host guard (HTML instead of JSON). No required args.',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+  },
+  {
+    name: 'byan_leantime_project_ensure',
+    description:
+      'Idempotent create-or-fetch of a Leantime project from the FD project_context. Matches an existing project by name first (no duplicate on FD re-run). Returns { id, created }. Requires LEANTIME_API_*.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        name: { type: 'string', description: 'Project name (defaults to slug).' },
+        slug: { type: 'string', description: 'Project slug (fallback name).' },
+        clientId: { type: 'number', description: 'Owning Leantime client id. Resolved if omitted.' },
+        details: { type: 'string', description: 'Optional project description.' },
+      },
+      additionalProperties: false,
+    },
+  },
+  {
+    name: 'byan_leantime_task_create',
+    description:
+      'Create one Leantime task (ticket) from an FD backlog item. Returns the new task id to store back in fd-state (caller owns idempotency: create only if the item has no leantime_task_id). Requires LEANTIME_API_*.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        projectId: { type: 'number', description: 'Leantime project id.' },
+        headline: { type: 'string', description: 'Task title.' },
+        description: { type: 'string' },
+        status: { type: 'number', description: 'Leantime status id (optional).' },
+        priority: { type: 'number' },
+        editorId: { type: 'number', description: 'Assignee/editor user id.' },
+        tags: { type: 'string' },
+        type: { type: 'string', description: "Ticket type, default 'task'." },
+      },
+      required: ['projectId', 'headline'],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: 'byan_leantime_task_move',
+    description:
+      'Move a Leantime task to a lifecycle column (todo|doing|blocked|review|done). Resolves the column to the project status id, then updates the ticket. Requires LEANTIME_API_*.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        taskId: { type: 'number', description: 'Leantime ticket id.' },
+        projectId: { type: 'number', description: 'Project id (for status resolution).' },
+        column: { type: 'string', enum: ['todo', 'doing', 'blocked', 'review', 'done'] },
+        status: { type: 'number', description: 'Explicit status id (bypasses column resolution).' },
+      },
+      required: ['taskId'],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: 'byan_leantime_task_assign',
+    description: 'Set the assignee/editor of a Leantime task. Requires LEANTIME_API_*.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        taskId: { type: 'number', description: 'Leantime ticket id.' },
+        editorId: { type: 'number', description: 'Assignee/editor user id.' },
+      },
+      required: ['taskId', 'editorId'],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: 'byan_leantime_task_get',
+    description: 'Fetch a single Leantime task by id. Requires LEANTIME_API_*.',
+    inputSchema: {
+      type: 'object',
+      properties: { taskId: { type: 'number', description: 'Leantime ticket id.' } },
+      required: ['taskId'],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: 'byan_leantime_board_get',
+    description: "List a Leantime project's tasks grouped by lifecycle column. Requires LEANTIME_API_*.",
+    inputSchema: {
+      type: 'object',
+      properties: { projectId: { type: 'number', description: 'Leantime project id.' } },
+      required: ['projectId'],
+      additionalProperties: false,
+    },
+  },
 ];
 
 const server = new Server(
@@ -1340,33 +1405,6 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
     }
 
-    if (name === 'byan_copilot_sessions') {
-      const result = listSessions({
-        limit: args.limit,
-        sinceIso: args.sinceIso,
-        cwdFilter: args.cwdFilter,
-      });
-      return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
-    }
-
-    if (name === 'byan_copilot_session_events') {
-      const result = readSessionEvents({
-        sessionId: args.sessionId,
-        types: args.types,
-        limit: args.limit,
-      });
-      return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
-    }
-
-    if (name === 'byan_copilot_search') {
-      const result = searchSessions({
-        query: args.query,
-        types: args.types,
-        limit: args.limit,
-      });
-      return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
-    }
-
     if (name === 'byan_fd_start') {
       const state = fdStart({ featureName: args.featureName, force: args.force, strict: args.strict });
       return { content: [{ type: 'text', text: JSON.stringify(state, null, 2) }] };
@@ -1446,6 +1484,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         scopeText: args.scopeText,
         acceptanceCriteria: args.acceptanceCriteria,
         allowedPaths: args.allowedPaths,
+        domain: args.domain,
         force: args.force,
       });
       const st = strictGetStatus();
@@ -1490,6 +1529,18 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     if (name === 'byan_strict_complete') {
       const r = strictComplete();
       const st = strictGetStatus();
+      // C3 learning loop: a completed strict session with an EXPLICIT ELO domain
+      // is a VALIDATED outcome. eloOutcomeForStrictComplete builds the line (the
+      // SAME helper the test exercises, so handler and test cannot drift); we
+      // append it to the buffer drain-advisory drains. The domain is the user's
+      // explicit lock_scope input, never inferred. Best-effort: a feed failure
+      // must not break completion.
+      try {
+        const eloLine = eloOutcomeForStrictComplete(r);
+        if (eloLine) appendOutcome(eloLine, { rootDir: process.env.CLAUDE_PROJECT_DIR || process.cwd() });
+      } catch {
+        // the learning feed must not break completion.
+      }
       const sync = await strictPushComplete({
         sessionId: st.strict_session_id,
         auditToken: r.audit_token,
@@ -1846,6 +1897,78 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       return { content: [{ type: 'text', text: JSON.stringify(instructions, null, 2) }] };
     }
 
+    // ─── Leantime tools ───────────────────────────────────────────────
+    if (name === 'byan_leantime_ping') {
+      const status = {
+        api_url: process.env.LEANTIME_API_URL || null,
+        token_configured: Boolean(process.env.LEANTIME_API_TOKEN),
+        assign_user_configured: Boolean(process.env.LEANTIME_ASSIGN_USER_ID),
+        enabled: leantimeEnabled(),
+      };
+      if (status.enabled) {
+        const probe = await leantimeRpc(LEANTIME_METHODS.getAllProjects, {});
+        status.reachable = probe.ok;
+        if (!probe.ok) status.reason = probe.reason;
+        if (probe.hint) status.hint = probe.hint;
+      }
+      return { content: [{ type: 'text', text: JSON.stringify(status, null, 2) }] };
+    }
+
+    if (name === 'byan_leantime_project_ensure') {
+      requireLeantime();
+      const r = await leantimeEnsureProject({
+        name: args.name,
+        slug: args.slug,
+        clientId: args.clientId,
+        details: args.details,
+      });
+      return { content: [{ type: 'text', text: JSON.stringify(r, null, 2) }] };
+    }
+
+    if (name === 'byan_leantime_task_create') {
+      requireLeantime();
+      const r = await leantimeCreateTask({
+        projectId: args.projectId,
+        headline: args.headline,
+        description: args.description,
+        status: args.status,
+        priority: args.priority,
+        editorId: args.editorId,
+        tags: args.tags,
+        ...(args.type !== undefined ? { type: args.type } : {}),
+      });
+      return { content: [{ type: 'text', text: JSON.stringify(r, null, 2) }] };
+    }
+
+    if (name === 'byan_leantime_task_move') {
+      requireLeantime();
+      const r = await leantimeMoveTask({
+        taskId: args.taskId,
+        projectId: args.projectId,
+        column: args.column,
+        status: args.status,
+      });
+      return { content: [{ type: 'text', text: JSON.stringify(r, null, 2) }] };
+    }
+
+    if (name === 'byan_leantime_task_assign') {
+      requireLeantime();
+      const r = await leantimeAssignTask({ taskId: args.taskId, editorId: args.editorId });
+      return { content: [{ type: 'text', text: JSON.stringify(r, null, 2) }] };
+    }
+
+    if (name === 'byan_leantime_task_get') {
+      requireLeantime();
+      const r = await leantimeGetTask({ taskId: args.taskId });
+      return { content: [{ type: 'text', text: JSON.stringify(r, null, 2) }] };
+    }
+
+    if (name === 'byan_leantime_board_get') {
+      requireLeantime();
+      const r = await leantimeGetBoard({ projectId: args.projectId });
+      return { content: [{ type: 'text', text: JSON.stringify(r, null, 2) }] };
+    }
+
     throw new Error(`Unknown tool: ${name}`);
   } catch (err) {
     return {