create-byan-agent 2.23.0 → 2.26.0

package/install/templates/.claude/hooks/drain-advisory.js

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+// drain-advisory.js — Stop hook. At the end of each assistant turn, drain the
+// outcome buffer into BYAN's ADVISORY ledgers (ELO trust, suitability). This is the
+// automatic half of the closed learning loop: outcomes logged during the turn (via
+// byan_outcome_log) are recorded with NO agent action. Behavior surfaces (routing /
+// personas / mantras) are never touched — only advisory data is written.
+//
+// STRICTLY non-blocking. All work is wrapped in try/catch; the hook ALWAYS emits
+// {continue:true} and exits 0, and never throws or exits 2. An advisory feed must
+// never break a turn (the stage-to-byan.js contract: "staging must never break the
+// session"). Idempotent via a line cursor, so a re-fired Stop (stop_hook_active)
+// records nothing new.
+//
+// ESM/CJS: this hook is CommonJS. The ELO engine is CJS (require). The pure libs and
+// the suitability store are ESM under a type:module package, reached via dynamic
+// import() with a file:// URL.
+
+const path = require('path');
+const { pathToFileURL } = require('url');
+
+function readStdin() {
+  return new Promise((resolve) => {
+    if (process.stdin.isTTY) return resolve('');
+    let data = '';
+    process.stdin.on('data', (c) => (data += c));
+    process.stdin.on('end', () => resolve(data));
+    process.stdin.on('error', () => resolve(data));
+  });
+}
+
+function done() {
+  process.stdout.write(JSON.stringify({ continue: true }));
+  process.exit(0);
+}
+
+(async () => {
+  try {
+    await readStdin(); // the Stop payload is not needed — we drain disk state
+    const root = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+    const esm = (rel) => import(pathToFileURL(path.join(root, rel)).href);
+
+    const af = await esm('_byan/mcp/byan-mcp-server/lib/advisory-autofeed.js');
+    const buf = await esm('_byan/mcp/byan-mcp-server/lib/outcome-buffer.js');
+
+    const outcomes = af.parseOutcomes(buf.readBuffer({ rootDir: root }));
+    const cursor = buf.readCursor({ rootDir: root });
+    const { pending, newCursor } = af.planDrain(outcomes, cursor);
+    if (!pending.length) return done();
+
+    let eloEngine = null;
+    let suitability = null;
+    for (const o of pending) {
+      const rec = af.classifyOutcome(o);
+      if (!rec) continue;
+      try {
+        if (rec.kind === 'elo') {
+          if (!eloEngine) {
+            const EloEngine = require(path.join(root, 'src', 'byan-v2', 'elo', 'index.js'));
+            eloEngine = new EloEngine({
+              storagePath: path.join(root, '_byan', 'memoire', 'elo-profile.json'),
+            });
+          }
+          eloEngine.recordResult(rec.domain, rec.result);
+        } else if (rec.kind === 'suitability') {
+          if (!suitability) {
+            suitability = await esm('_byan/mcp/byan-mcp-server/lib/suitability-store.js');
+          }
+          suitability.record({
+            model: rec.model,
+            leafId: rec.leafId,
+            success: rec.success,
+            source: 'autofeed',
+            projectRoot: root,
+          });
+        }
+      } catch {
+        // one bad record must not abort the drain or block the turn
+      }
+    }
+    buf.writeCursor(newCursor, { rootDir: root });
+  } catch {
+    // any failure degrades silently — the feed is housekeeping, never a blocker
+  }
+  done();
+})();

package/install/templates/.claude/hooks/fact-check-absolutes.js

@@ -16,33 +16,8 @@
  * (not documentation).
  */
 
-const fs = require('fs');
 const path = require('path');
-
-const ABSOLUTES = [
-  /\btoujours\b/i,
-  /\bjamais\b/i,
-  /\bforc[eé]ment\b/i,
-  /\bobviously\b/i,
-  /\balways\b/i,
-  /\bnever\b/i,
-  /\bclearly\b/i,
-  /\bundoubtedly\b/i,
-  /\bfaster than\b/i,
-  /\bbetter than\b/i,
-  /\bplus rapide que\b/i,
-  /\bmeilleur que\b/i,
-];
-
-const SOURCE_MARKERS = [
-  /\bRFC\s*\d+/i,
-  /\bCVE-\d{4}-\d+/i,
-  /https?:\/\//,
-  /\[CLAIM\s+L[1-5]\]/i,
-  /\[FACT\s+USER-VERIFIED/i,
-  /\bsource\s*:/i,
-  /_byan\/knowledge\/sources\.md/,
-];
+const { stripNonClaimZones, findUnsourced } = require('./lib/fact-check-core');
 
 const DOC_EXTS = ['.md', '.mdx', '.rst', '.txt'];
 
@@ -65,24 +40,6 @@ function isExemptPath(filePath) {
   return EXEMPT_PATH_PATTERNS.some((re) => re.test(filePath));
 }
 
-// Strip content that cannot be a claim :
-//   - fenced code blocks ``` ... ```
-//   - inline backticks `...`
-//   - block quotes (lines starting with >)
-//   - regex / array syntax that contains the word as a token
-function stripNonClaimZones(text) {
-  if (!text) return '';
-  return text
-    // Fenced code blocks
-    .replace(/```[\s\S]*?```/g, '')
-    // Inline code
-    .replace(/`[^`\n]+`/g, '')
-    // Markdown block quotes
-    .replace(/^> .*$/gm, '')
-    // Lines that look like list of patterns (e.g. "- toujours")
-    .replace(/^[\s-]*['"]?\b(toujours|jamais|forc[eé]ment|obviously|always|never|clearly|undoubtedly)\b['"]?/gim, '');
-}
-
 function readStdin() {
   return new Promise((resolve) => {
     if (process.stdin.isTTY) return resolve('');
@@ -107,23 +64,6 @@ function extractText(toolName, input) {
   return '';
 }
 
-function findUnsourced(text) {
-  if (!text) return null;
-  for (const re of ABSOLUTES) {
-    const match = text.match(re);
-    if (!match) continue;
-    const idx = match.index || 0;
-    const windowStart = Math.max(0, idx - 240);
-    const windowEnd = Math.min(text.length, idx + match[0].length + 240);
-    const ctx = text.slice(windowStart, windowEnd);
-    const hasSource = SOURCE_MARKERS.some((sm) => sm.test(ctx));
-    if (!hasSource) {
-      return { absolute: match[0], context: text.slice(Math.max(0, idx - 80), idx + 80) };
-    }
-  }
-  return null;
-}
-
 (async () => {
   const raw = await readStdin();
   let payload = {};

package/install/templates/.claude/hooks/fact-check-claims.js

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+/**
+ * Stop hook — fact-check conversation claims (non-blocking).
+ *
+ * The PreToolUse twin (fact-check-absolutes.js) only fires when the agent
+ * WRITES an unsourced absolute into a doc file. This hook covers the other,
+ * more frequent surface : an unsourced absolute spoken in the assistant's
+ * final turn text. It NUDGES (systemMessage, continue) and never blocks —
+ * spoken claims are noisier than written docs, so a block would trap
+ * legitimate hypotheses/quotes. Same detection engine (fact-check-core).
+ */
+
+'use strict';
+
+const { stripNonClaimZones, findUnsourced } = require('./lib/fact-check-core');
+const { extractLastAssistantText } = require('./lib/transcript-read');
+
+function readStdin() {
+  return new Promise((resolve) => {
+    if (process.stdin.isTTY) return resolve('');
+    let data = '';
+    process.stdin.on('data', (c) => (data += c));
+    process.stdin.on('end', () => resolve(data));
+    process.stdin.on('error', () => resolve(data));
+  });
+}
+
+// Pure decision — no IO. Returns { nudge:false } or { nudge:true, absolute, context }.
+function decideClaim({ lastAssistantText }) {
+  const text = stripNonClaimZones(lastAssistantText || '');
+  const hit = findUnsourced(text);
+  if (!hit) return { nudge: false };
+  return { nudge: true, absolute: hit.absolute, context: hit.context };
+}
+
+function nudgeMessage(hit) {
+  return [
+    `BYAN fact-check : unsourced absolute "${hit.absolute}" in this turn.`,
+    `Context : ...${hit.context}...`,
+    `Consider a source (RFC, CVE, URL, [CLAIM L<n>]) or hedge ("often", "in my tests", "tends to"). Advisory — not blocking.`,
+  ].join('\n');
+}
+
+if (require.main === module) {
+  (async () => {
+    let payload = {};
+    try {
+      const raw = await readStdin();
+      payload = raw ? JSON.parse(raw) : {};
+    } catch {
+      payload = {};
+    }
+
+    let decision = { nudge: false };
+    try {
+      decision = decideClaim({ lastAssistantText: extractLastAssistantText(payload) });
+    } catch {
+      decision = { nudge: false };
+    }
+
+    if (decision.nudge) {
+      process.stdout.write(JSON.stringify({ systemMessage: nudgeMessage(decision), continue: true }));
+    } else {
+      process.stdout.write(JSON.stringify({ continue: true }));
+    }
+  })();
+}
+
+module.exports = { decideClaim, nudgeMessage };

package/install/templates/.claude/hooks/fd-response-check.js

@@ -15,6 +15,10 @@
 
 const fs = require('fs');
 const path = require('path');
+// Shared transcript reader — the real Stop payload has no inline transcript
+// (last_assistant_message + transcript_path JSONL). Without it this hook read an
+// empty turn and never enforced the [FD:PHASE] header live.
+const { extractLastAssistantText } = require('./lib/transcript-read');
 
 const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
 const statePath = path.join(projectDir, '_byan-output', 'fd-state.json');
@@ -38,55 +42,42 @@ function readState() {
   }
 }
 
-function extractLastAssistantText(payload) {
-  if (!payload || typeof payload !== 'object') return '';
-  const tx = payload.transcript || payload.messages || [];
-  if (!Array.isArray(tx)) return '';
-  for (let i = tx.length - 1; i >= 0; i--) {
-    const m = tx[i];
-    if (m && m.role === 'assistant') {
-      if (typeof m.content === 'string') return m.content;
-      if (Array.isArray(m.content)) {
-        return m.content
-          .map((c) => (typeof c === 'object' && c.text ? c.text : ''))
-          .join(' ');
-      }
-    }
-  }
-  return '';
-}
+// Pure decision : returns { block, reason? }. No IO — unit-testable.
+function decideFdResponse({ state, lastAssistantText }) {
+  if (!state || ['COMPLETED', 'ABORTED'].includes(state.phase)) return { block: false };
 
-(async () => {
-  const state = readState();
-  if (!state || ['COMPLETED', 'ABORTED'].includes(state.phase)) {
-    process.stdout.write(JSON.stringify({ continue: true }));
-    process.exit(0);
-  }
+  const expected = `[FD:${state.phase}]`;
+  const text = lastAssistantText || '';
+  // Empty text (cannot read the turn) degrades to allow — never trap a turn we
+  // cannot inspect. A present header satisfies.
+  if (!text || text.includes(expected)) return { block: false };
 
-  const raw = await readStdin();
-  let payload = {};
-  try {
-    payload = raw ? JSON.parse(raw) : {};
-  } catch {
-    payload = {};
-  }
+  const reason = `FD active (phase=${state.phase}) but your last response did not include the required header "${expected}". Reformulate your answer starting with ${expected} to confirm you are operating in the correct phase. If you wanted to exit or change phase, call byan_fd_advance first.`;
+  return { block: true, reason };
+}
 
-  const text = extractLastAssistantText(payload);
-  const expected = `[FD:${state.phase}]`;
+if (require.main === module) {
+  (async () => {
+    const state = readState();
+    const raw = await readStdin();
+    let payload = {};
+    try {
+      payload = raw ? JSON.parse(raw) : {};
+    } catch {
+      payload = {};
+    }
 
-  if (!text || text.includes(expected)) {
-    process.stdout.write(JSON.stringify({ continue: true }));
-    process.exit(0);
-  }
+    const decision = decideFdResponse({ state, lastAssistantText: extractLastAssistantText(payload) });
+    if (!decision.block) {
+      process.stdout.write(JSON.stringify({ continue: true }));
+      process.exit(0);
+    }
 
-  const reason = `FD active (phase=${state.phase}) but your last response did not include the required header "${expected}". Reformulate your answer starting with ${expected} to confirm you are operating in the correct phase. If you wanted to exit or change phase, call byan_fd_advance first.`;
+    process.stdout.write(
+      JSON.stringify({ decision: 'block', reason: decision.reason, systemMessage: decision.reason })
+    );
+    process.exit(2);
+  })();
+}
 
-  process.stdout.write(
-    JSON.stringify({
-      decision: 'block',
-      reason,
-      systemMessage: reason,
-    })
-  );
-  process.exit(2);
-})();
+module.exports = { decideFdResponse, extractLastAssistantText };

package/install/templates/.claude/hooks/inject-soul.js

@@ -1,7 +1,14 @@
 #!/usr/bin/env node
 /**
- * SessionStart hook — loads BYAN soul/tao/soul-memory and injects them
- * into the session's initial context via additionalContext.
+ * SessionStart hook — loads BYAN soul + soul-memory and injects them into
+ * the session's initial context via additionalContext. Tao is intentionally
+ * NOT bundled here: inject-tao.js injects the full tao on every
+ * UserPromptSubmit (including the first), so duplicating it at SessionStart
+ * would double-spend ~15 KB per session for no gain.
+ *
+ * Also resets the per-session mid-session-nudge one-shot marker so the
+ * soul-memory-triggers nudge is per-session (not per-lifetime). Without
+ * this reset the one-shot marker, once written, silences the nudge forever.
  *
  * Safe: missing files are skipped silently, script always exits 0.
  */
@@ -9,44 +16,76 @@
 const fs = require('fs');
 const path = require('path');
 
-const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
-
 // Gen3 puts BYAN's soul files under _byan/agent/byan/; Gen2 keeps them at the
 // _byan/ root. Prefer Gen3 when present, fall back to Gen2 (self-contained so
 // the hook never depends on a require that could fail).
-function soulFile(label) {
+function soulFile(projectDir, label) {
   const g3 = path.join(projectDir, '_byan', 'agent', 'byan', `${label}.md`);
   const g2 = path.join(projectDir, '_byan', `${label}.md`);
   return fs.existsSync(g3) ? g3 : g2;
 }
 
-const files = [
-  { label: 'soul', path: soulFile('soul') },
-  { label: 'tao', path: soulFile('tao') },
-  { label: 'soul-memory', path: soulFile('soul-memory') },
-];
+// Same resolution as soul-memory-triggers.js: Gen3 _byan/memoire/ first, Gen2
+// _byan/_memory/ fallback. Kept in sync by hand (hooks avoid shared requires).
+function nudgeMarkerPath(projectDir) {
+  const memoireDir = path.join(projectDir, '_byan', 'memoire');
+  const memoryDir = fs.existsSync(memoireDir)
+    ? memoireDir
+    : path.join(projectDir, '_byan', '_memory');
+  return path.join(memoryDir, '.soul-memory-nudge-sent');
+}
 
-const chunks = [];
-for (const f of files) {
+// Reset the one-shot nudge marker at session start so the mid-session
+// soul-memory nudge can fire once per session instead of once per lifetime.
+function resetNudgeMarker(projectDir) {
   try {
-    if (fs.existsSync(f.path)) {
-      const content = fs.readFileSync(f.path, 'utf8').trim();
-      if (content.length > 0) {
-        chunks.push(`=== BYAN ${f.label.toUpperCase()} (${path.relative(projectDir, f.path)}) ===\n${content}`);
-      }
-    }
+    fs.rmSync(nudgeMarkerPath(projectDir), { force: true });
+    return true;
   } catch {
-    // Ignore read errors — hook must never block session start.
+    return false;
   }
 }
 
-const additionalContext =
-  chunks.length > 0
+function buildAdditionalContext(projectDir) {
+  const files = [
+    { label: 'soul', path: soulFile(projectDir, 'soul') },
+    { label: 'soul-memory', path: soulFile(projectDir, 'soul-memory') },
+  ];
+
+  const chunks = [];
+  for (const f of files) {
+    try {
+      if (fs.existsSync(f.path)) {
+        const content = fs.readFileSync(f.path, 'utf8').trim();
+        if (content.length > 0) {
+          chunks.push(
+            `=== BYAN ${f.label.toUpperCase()} (${path.relative(projectDir, f.path)}) ===\n${content}`
+          );
+        }
+      }
+    } catch {
+      // Ignore read errors — hook must never block session start.
+    }
+  }
+
+  return chunks.length > 0
     ? `BYAN Soul System (loaded at session start):\n\n${chunks.join('\n\n')}`
     : '';
+}
 
-if (additionalContext) {
-  process.stdout.write(JSON.stringify({ systemMessage: additionalContext }));
-} else {
-  process.stdout.write('{}');
+if (require.main === module) {
+  const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+  resetNudgeMarker(projectDir);
+  const additionalContext = buildAdditionalContext(projectDir);
+  if (additionalContext) {
+    process.stdout.write(
+      JSON.stringify({
+        hookSpecificOutput: { hookEventName: 'SessionStart', additionalContext },
+      })
+    );
+  } else {
+    process.stdout.write('{}');
+  }
 }
+
+module.exports = { soulFile, nudgeMarkerPath, resetNudgeMarker, buildAdditionalContext };

package/install/templates/.claude/hooks/leantime-fd-sync.js

@@ -0,0 +1,216 @@
+#!/usr/bin/env node
+// PostToolUse hook — mirror the BYAN FD lifecycle onto a Leantime board with no
+// agent action. Fires on byan_fd_advance / byan_fd_update; reads the fd-state the
+// tool echoed; drives lib/leantime-sync.js (ensure project, create tasks, move
+// columns) per the pure decision core lib/leantime-fd-core.js.
+//
+// Best-effort and bounded by design:
+//   - exits 0 in every path (a sync issue does not block the turn; this hook
+//     does not use the exit-2 blocking path);
+//   - no-ops silently when the tool is not an FD tool, no FD is active, or
+//     Leantime is not configured (syncEnabled false);
+//   - it never WRITES fd-state.json (state-coupling); it reads the state the tool
+//     echoed, with a read-only fd-state.json fallback. The Leantime id map lives
+//     in the gitignored .byan-leantime/ sidecar;
+//   - a per-call timeout plus a hook wall-clock budget keep a slow Leantime from
+//     stalling the turn; a dropped call self-heals on the next phase event
+//     (reconcile-from-state, tracked by sidecar.moveFailed).
+//
+// CJS shell + ESM libs reached via dynamic import() (the drain-advisory.js bridge).
+
+const fs = require('fs');
+const path = require('path');
+const { pathToFileURL } = require('url');
+
+const ROOT = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+const SIDECAR_DIR = path.join(ROOT, '.byan-leantime');
+const MAP_PATH = path.join(SIDECAR_DIR, 'map.json');
+const LOG_PATH = path.join(SIDECAR_DIR, 'sync.jsonl');
+const FD_STATE_PATH = path.join(ROOT, '_byan-output', 'fd-state.json');
+const PER_CALL_MS = 2500; // below the lib default (5000) so the hook bounds each call
+const HOOK_BUDGET_MS = 8000; // between-stage advisory, checked at each stage boundary (not a hard ceiling); a move issues 2 RPCs so a late stage can overrun it, though no call hangs (each aborts at PER_CALL_MS)
+
+// Reasons that deserve a one-line breadcrumb (a real wire/host issue, not "off").
+const LOUD = new Set(['non_json', 'timeout', 'rpc_error']);
+const isLoud = (reason) => typeof reason === 'string' && (LOUD.has(reason) || reason.startsWith('http_'));
+
+function readStdin() {
+  return new Promise((resolve) => {
+    if (process.stdin.isTTY) return resolve('');
+    let data = '';
+    process.stdin.on('data', (c) => (data += c));
+    process.stdin.on('end', () => resolve(data));
+    process.stdin.on('error', () => resolve(data));
+  });
+}
+
+function emit(additionalContext = '') {
+  process.stdout.write(
+    JSON.stringify({ hookSpecificOutput: { hookEventName: 'PostToolUse', additionalContext } }),
+  );
+  process.exit(0);
+}
+
+function readMap() {
+  try {
+    return JSON.parse(fs.readFileSync(MAP_PATH, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+function writeMap(map) {
+  try {
+    fs.mkdirSync(SIDECAR_DIR, { recursive: true });
+    const tmp = `${MAP_PATH}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify(map, null, 2));
+    fs.renameSync(tmp, MAP_PATH); // atomic swap so a crash mid-write keeps the old map
+  } catch {
+    // the sidecar is housekeeping; a write failure must not break the hook
+  }
+}
+
+function logLine(entry) {
+  try {
+    fs.mkdirSync(SIDECAR_DIR, { recursive: true });
+    fs.appendFileSync(LOG_PATH, `${JSON.stringify(entry)}\n`);
+  } catch {
+    // the log is housekeeping; swallow
+  }
+}
+
+(async () => {
+  let payload = {};
+  try {
+    const raw = await readStdin();
+    payload = raw ? JSON.parse(raw) : {};
+  } catch {
+    return emit();
+  }
+
+  try {
+    const toolName = payload.tool_name || payload.toolName || '';
+    const esm = (rel) => import(pathToFileURL(path.join(ROOT, rel)).href);
+    const core = await esm('_byan/mcp/byan-mcp-server/lib/leantime-fd-core.js');
+    if (!core.fdToolKind(toolName)) return emit(); // not an FD tool
+
+    // Read state from the tool's echoed result (state-coupling: no fd-state write).
+    const resp = payload.tool_response ?? payload.toolResponse ?? payload.response ?? null;
+    let state = core.parseFdState(resp);
+    if (!state) {
+      try {
+        state = JSON.parse(fs.readFileSync(FD_STATE_PATH, 'utf8'));
+      } catch {
+        state = null;
+      }
+    }
+    if (!state || typeof state.phase !== 'string') return emit();
+
+    const lt = await esm('_byan/mcp/byan-mcp-server/lib/leantime-sync.js');
+    if (!lt.syncEnabled()) return emit(); // Leantime not configured -> silent no-op
+
+    const fdId = state.fd_id || 'unknown';
+    const map = readMap();
+    const sidecar = map[fdId] || { tasks: {} };
+    sidecar.tasks = sidecar.tasks || {};
+    const assignUserConfigured = lt.assignUserId() != null;
+
+    const { intents, column } = core.decideActions({ toolName, state, sidecar, assignUserConfigured });
+
+    if (!intents || !intents.length) {
+      if (column && sidecar.lastColumn !== column) {
+        sidecar.lastColumn = column;
+        map[fdId] = sidecar;
+        writeMap(map);
+      }
+      return emit();
+    }
+
+    const opts = { timeoutMs: PER_CALL_MS };
+    const deadline = Date.now() + HOOK_BUDGET_MS;
+    const timeLeft = () => deadline - Date.now();
+    let firstLoud = null;
+    let moveFailed = false;
+
+    const record = (event, target, r) => {
+      const ok = !!(r && r.ok);
+      const synced = !!(r && r.synced);
+      logLine({ ts: new Date().toISOString(), fd_id: fdId, phase: state.phase, event, target, ok, synced, reason: (r && r.reason) || null });
+      if (!synced && isLoud(r && r.reason) && !firstLoud) firstLoud = r.reason;
+    };
+
+    // 1. Ensure the project (sequential — every later call needs the projectId).
+    const ensureIntent = intents.find((i) => i.op === 'project_ensure');
+    if (ensureIntent && !sidecar.projectId) {
+      const r = await lt.ensureProject({ name: ensureIntent.name, slug: ensureIntent.slug, details: ensureIntent.details }, opts);
+      record('project_ensure', ensureIntent.name, r);
+      if (r.ok && r.id) {
+        sidecar.projectId = r.id;
+        map[fdId] = sidecar;
+        writeMap(map); // persist immediately so a crash cannot re-create the project
+      }
+    }
+
+    // 2. Make the project visible to the configured human (best-effort).
+    if (intents.some((i) => i.op === 'assign_user') && sidecar.projectId && timeLeft() > 0) {
+      const r = await lt.assignUserToProject({ projectId: sidecar.projectId }, opts);
+      record('assign_user', sidecar.projectId, r);
+    }
+
+    // 3. Create tasks (parallel, bounded by the wall-clock budget).
+    const createIntents = intents.filter((i) => i.op === 'task_create');
+    if (createIntents.length && sidecar.projectId && timeLeft() > 0) {
+      const results = await Promise.allSettled(
+        createIntents.map((i) =>
+          lt.createTask({ projectId: sidecar.projectId, headline: i.headline }, opts).then((r) => ({ i, r })),
+        ),
+      );
+      for (const s of results) {
+        if (s.status === 'fulfilled') {
+          const { i, r } = s.value;
+          record('task_create', i.backlogId, r);
+          if (r.ok && r.id) sidecar.tasks[i.backlogId] = r.id;
+        }
+      }
+      map[fdId] = sidecar;
+      writeMap(map);
+    }
+
+    // 4. Move tasks to the current column (parallel, bounded).
+    const moveIntents = intents.filter((i) => i.op === 'task_move');
+    if (moveIntents.length && sidecar.projectId && timeLeft() > 0) {
+      const results = await Promise.allSettled(
+        moveIntents.map((i) => {
+          const taskId = sidecar.tasks[i.backlogId];
+          if (!taskId) return Promise.resolve({ i, r: { ok: false, synced: false, reason: 'no_task_id' } });
+          return lt.moveTask({ taskId, projectId: sidecar.projectId, column: i.column }, opts).then((r) => ({ i, r }));
+        }),
+      );
+      for (const s of results) {
+        if (s.status === 'fulfilled') {
+          const { i, r } = s.value;
+          record('task_move', i.backlogId, r);
+          if (!(r && r.synced)) moveFailed = true;
+        } else {
+          moveFailed = true;
+        }
+      }
+    } else if (moveIntents.length) {
+      // could not run the moves this fire (budget/no project) -> retry next event
+      moveFailed = true;
+    }
+
+    if (column) sidecar.lastColumn = column;
+    sidecar.moveFailed = moveFailed;
+    sidecar.updatedAt = new Date().toISOString();
+    map[fdId] = sidecar;
+    writeMap(map);
+
+    if (firstLoud) {
+      return emit(`Leantime sync: ${firstLoud} on ${state.phase} (board may lag; retried next phase). Check LEANTIME_API_URL / token.`);
+    }
+    return emit();
+  } catch {
+    return emit(); // any failure degrades silently — the sync is housekeeping
+  }
+})();