kenaz 0.3.3 → 0.3.5

package/core/.formation/tools/formations.js

@@ -1,1203 +0,0 @@
-'use strict';
-/**
- * Formations
- *
- * Formation launcher functions extracted from headless.js (TASK_890).
- * Contains all launchXxx functions and worktree management helpers.
- *
- * Exports: launchHuginnThink, launchUnit, launchSolo, launchSquad,
- *          launchLegion, launchLegacy, createWorktree, removeWorktree,
- *          cleanupAllWorktrees
- *
- * Internal: squadSynthesis, waitAll, printResults, hasSuccess
- */
-
-const fs = require('fs');
-const path = require('path');
-const { execSync } = require('child_process');
-const {
-  buildSquadSynthesisPrompt, buildSquadDebatePrompts,
-  buildLegionLeadPrompt, HEADLESS_PREFIX,
-} = require('./prompt');
-const { runHeadless, runLegionLead, runner: formationRunner } = require('./runner');
-const {
-  ROOT, getLogDir,
-  createWorktree: createTaskWorktree, removeWorktree: removeTaskWorktree,
-  ensureWorktreeDirIgnored, resolveWorktreeDecision,
-  dispatchLockPath, tryAcquireDispatchLock,
-  buildWorktreeGitAddCommand,
-  unlinkNodeModulesBestEffort,
-} = require('./utils');
-const { postComplete } = require('./post-complete');
-const {
-  waitForDispatchSlot, registerDispatch, unregisterDispatch,
-  logAnalytics, _decrementParallelCount, isProcessAlive,
-} = require('./dispatch-registry');
-const { enqueueDispatchNotification } = require('./dispatch-notifier');
-const { _activeWorktrees, trackChild } = require('./process-state');
-const { broadcastStatus, broadcastStatusSync, syncCommit } = require('./broadcast');
-const { checkAndDispatchFix } = require('./task-utils');
-
-let canary;
-try { canary = require('../../.specialist/tools/canary'); } catch { canary = null; }
-
-function buildDispatchCompletionEvent({
-  taskId,
-  sessionId,
-  originSessionId,
-  formation,
-  skill,
-  projectPath,
-  logPath,
-  finalCode,
-  postCompleteResult,
-}) {
-  if (!taskId || !originSessionId) return null;
-
-  const result = postCompleteResult || null;
-  const git = result?.git || null;
-  let status = 'failed';
-  let summary = `Task ${taskId} ended with exit code ${finalCode ?? 0}.`;
-
-  if ((finalCode ?? 0) !== 0) {
-    status = 'failed';
-    summary = `Task ${taskId} agent execution failed with exit code ${finalCode}.`;
-  } else if (git?.mergeConflict) {
-    status = 'merge_conflict';
-    summary = `Task ${taskId} hit a merge conflict and requires manual resolution.`;
-  } else if (git?.missingTaskBranch || git?.scopePathsMissing) {
-    status = 'failed';
-    summary = `Task ${taskId} did not produce a mergeable task branch.`;
-  } else if (result?.taskCompleted || git?.merged || (git?.noChanges && (git?.memoryOnly || git?.noGitRepo))) {
-    status = 'completed';
-    summary = `Task ${taskId} completed successfully.`;
-  } else if (git && !git.merged && !git.noChanges && !git.noGitRepo) {
-    status = 'manual_resolution';
-    summary = `Task ${taskId} finished agent execution but still needs manual follow-up.`;
-  } else if (git?.noChanges) {
-    status = 'completed';
-    summary = `Task ${taskId} completed without code changes.`;
-  }
-
-  return {
-    originSessionId,
-    taskId,
-    status,
-    summary,
-    formation,
-    skill,
-    dispatchSessionId: sessionId,
-    projectPath: projectPath || null,
-    logPath: logPath || null,
-    metadata: {
-      merged: git?.merged === true,
-      taskCompleted: result?.taskCompleted === true,
-      userBranch: git?.userBranch || git?.originalBranch || null,
-      regressionFixTask: git?.regressionFixTask || null,
-      acceptanceFixTasks: git?.acceptanceFixTasks || [],
-      integrationFixTask: git?.integrationFixTask || null,
-      worktreePath: git?.conflictWorktreePath || null,
-      conflictSummary: git?.conflictSummary || null,
-    },
-  };
-}
-
-function emitDispatchCompletion(event) {
-  if (!event) return;
-  try {
-    enqueueDispatchNotification(event, ROOT);
-  } catch {}
-}
-
-// ─────────────────────────────────────────
-// Worktree Management (squad member worktrees)
-// ─────────────────────────────────────────
-
-/**
- * Create an isolated git worktree for a squad member.
- * Returns the absolute worktree path, or null on failure (graceful fallback to shared dir).
- * Includes .git/index.lock detection and retry with exponential backoff for Windows
- * parallel-load resilience (ETIMEDOUT from competing git processes).
- */
-function createWorktree(sessionId, memberId, projectRoot) {
-  const worktreesDir = path.join(projectRoot, '.formation', 'worktrees');
-  const worktreePath = path.join(worktreesDir, `${sessionId}-${memberId}`);
-  const ts_start = Date.now();
-
-  if (!fs.existsSync(worktreesDir)) {
-    try { fs.mkdirSync(worktreesDir, { recursive: true }); }
-    catch (err) {
-      console.warn(`⚠️  Failed to create worktrees dir for ${memberId}: ${err.message}`);
-      return null;
-    }
-  }
-
-  // Wait for .git/index.lock to clear (Windows parallel git lock contention)
-  const indexLock = path.join(projectRoot, '.git', 'index.lock');
-  const waitForIndexLock = (maxMs) => {
-    const deadline = Date.now() + maxMs;
-    while (fs.existsSync(indexLock) && Date.now() < deadline) {
-      const w = Date.now() + 200; while (Date.now() < w) {}
-    }
-    if (fs.existsSync(indexLock)) {
-      console.warn(`   ⚠️  .git/index.lock still held after ${maxMs}ms for ${memberId} — proceeding anyway`);
-    }
-  };
-
-  waitForIndexLock(15000);
-
-  // Retry with exponential backoff: 3 retries at 2s, 4s, 8s
-  const retryDelays = [2000, 4000, 8000];
-  let lastErr;
-  for (let attempt = 0; attempt <= retryDelays.length; attempt++) {
-    if (attempt > 0) waitForIndexLock(10000);
-    try {
-      // --detach avoids branch naming conflicts; HEAD starts at same commit as main tree
-      execSync(`git worktree add --detach "${worktreePath}"`, {
-        cwd: projectRoot, encoding: 'utf8', timeout: 30000, windowsHide: true, stdio: 'pipe',
-      });
-      const duration = Date.now() - ts_start;
-      _activeWorktrees.set(worktreePath, projectRoot);
-      console.log(`   🌿 Worktree created: ${path.relative(projectRoot, worktreePath)} (${duration}ms, attempt ${attempt + 1})`);
-      return worktreePath;
-    } catch (err) {
-      lastErr = err;
-      if (attempt < retryDelays.length) {
-        const delay = retryDelays[attempt];
-        console.warn(`   ⚠️  Worktree attempt ${attempt + 1} failed for ${memberId}: ${(err.message || '').split('\n')[0]}`);
-        console.warn(`   Retrying in ${delay / 1000}s...`);
-        const w = Date.now() + delay; while (Date.now() < w) {}
-      }
-    }
-  }
-
-  const duration = Date.now() - ts_start;
-  console.warn(`⚠️  Worktree creation failed for ${memberId} after ${retryDelays.length + 1} attempts (${duration}ms): ${lastErr.message}`);
-  console.warn(`   Falling back to shared directory.`);
-  return null;
-}
-
-/**
- * Remove a single worktree and unregister it from _activeWorktrees.
- */
-function removeWorktree(worktreePath, projectRoot) {
-  // TASK_1844/TASK_2030: MUST run before any `git worktree remove` -- Git for
-  // Windows recurses through a node_modules junction/symlink on removal and
-  // empties the link target (the main checkout's node_modules).
-  unlinkNodeModulesBestEffort(worktreePath);
-  try {
-    execSync(`git worktree remove --force "${worktreePath}"`, {
-      cwd: projectRoot,
-      encoding: 'utf8',
-      timeout: 30000,
-      windowsHide: true,
-      stdio: 'pipe',
-    });
-    console.log(`   🧹 Worktree removed: ${path.relative(projectRoot, worktreePath)}`);
-  } catch (err) {
-    console.warn(`⚠️  Worktree removal failed for ${worktreePath}: ${err.message}`);
-  }
-  _activeWorktrees.delete(worktreePath);
-}
-
-/**
- * Clean up all registered worktrees.
- * Called after squad synthesis completes (and from exit handler).
- */
-function cleanupAllWorktrees() {
-  if (_activeWorktrees.size === 0) return;
-  console.log(`\n🧹 Cleaning up ${_activeWorktrees.size} worktree(s)...`);
-  for (const [worktreePath, projectRoot] of [..._activeWorktrees]) {
-    removeWorktree(worktreePath, projectRoot);
-  }
-}
-
-// ─────────────────────────────────────────
-// 共用工具函數
-// ─────────────────────────────────────────
-
-function waitAll(children) {
-  return Promise.all(
-    children.map(child =>
-      new Promise((resolve) => {
-        let resolved = false;
-        const done = (code) => {
-          if (resolved) return;
-          resolved = true;
-          resolve({
-            memberId: child._formation.memberId,
-            exitCode: code ?? 0,
-            logPath: child._formation.logPath
-          });
-        };
-        child.on('close', done);
-        child.on('formation:done', done);
-      })
-    )
-  );
-}
-
-function printResults(label, results, total) {
-  console.log(`\n⚔️  ${label}: ${results.length}/${total}`);
-  for (const r of results) {
-    const status = r.exitCode === 0 ? '✅' : '❌';
-    console.log(`   ${status} [${r.memberId}] exit ${r.exitCode} → ${r.logPath}`);
-  }
-}
-
-function hasSuccess(results) {
-  const successCount = results.filter(r => r.exitCode === 0).length;
-  if (successCount === 0) {
-    console.log('\n⚠️  All members failed. Stopping.');
-    return false;
-  }
-  if (successCount < results.length) {
-    console.log(`\n⚠️  ${results.length - successCount} member(s) failed.`);
-  }
-  return true;
-}
-
-// ═════════════════════════════════════════
-// Huginn Think：Prefrontal 思考引擎（無任務、無 skill YAML）
-// ═════════════════════════════════════════
-
-function launchHuginnThink({ trigger, focus, query, sessionId, projectPath, dryRun, inProcess, depth, model = null }) {
-  // Read skill workflow from .claude/skills/huginn/SKILL.md (single source of truth)
-  const skillMdPath = path.join(ROOT, '.claude', 'skills', 'huginn', 'SKILL.md');
-  let skillMd = '';
-  try { skillMd = fs.readFileSync(skillMdPath, 'utf-8'); } catch { /* not found — workflow still in prompt */ }
-
-  const ctxLines = [
-    `trigger: ${trigger || 'manual'}`,
-    `project_path: ${projectPath || ROOT}`,
-  ];
-  if (focus) ctxLines.push(`focus: ${focus}`);
-  if (query) ctxLines.push(`query: ${query}`);
-  const context = ctxLines.join('\n');
-
-  const depthFlag = depth ? ` --depth=${depth}` : '';
-  const prompt = `${HEADLESS_PREFIX}
-
-## Role
-You are Huginn ᚺᚢ, the Prefrontal Thinking Engine of KenazAI.
-Execute: node .specialist/tools/session.js prompt Huginn --mode=assembled${depthFlag}
-Follow the assembled persona output before proceeding with the workflow below.
-
-## Context
-${context}
-
-## Workflow
-${skillMd || '(See .specialist/Huginn/core.yaml for the full workflow)'}
-`;
-
-  console.log(`ᚺᚢ  Formation Headless Launch (Huginn Think)`);
-  console.log(`   Trigger:   ${trigger || 'manual'}`);
-  console.log(`   Session:   ${sessionId}`);
-  if (focus) console.log(`   Focus:     ${focus}`);
-  if (query) console.log(`   Query:     ${query}`);
-  if (projectPath) console.log(`   Project:   ${projectPath}`);
-  console.log('');
-
-  if (dryRun) {
-    console.log('--- HUGINN THINK DRY RUN ---');
-    console.log(prompt);
-    console.log('--- END ---');
-    return null;
-  }
-
-  // Broadcast online
-  broadcastStatus(projectPath, { is_online: true, current_task: 'huginn-think', touching_files: [] });
-  if (!inProcess) {
-    const handleSignal = (code) => {
-      broadcastStatusSync(projectPath, { is_online: false, current_task: null, touching_files: [] });
-      process.exit(code);
-    };
-    process.on('SIGINT', () => handleSignal(130));
-    process.on('SIGTERM', () => handleSignal(143));
-  }
-
-  const child = runHeadless({ prompt, formation: 'huginn', skill: 'huginn-think', sessionId, projectPath, model });
-  trackChild(child);
-
-  const logPath = child._formation?.logPath;
-  registerDispatch({ sessionId, logPath, taskId: null, formation: 'huginn', projectPath });
-
-  if (!inProcess) {
-    process.on('exit', () => unregisterDispatch(sessionId));
-  }
-
-  let cleanedUp = false;
-  const onDone = (code) => {
-    if (cleanedUp) return;
-    cleanedUp = true;
-    unregisterDispatch(sessionId);
-    const finalCode = child._formationExitCode ?? code ?? 0;
-
-    if (code === 0) {
-      console.log('\nᚺᚢ Huginn thinking session complete — proposals written, no post-complete needed');
-    } else {
-      console.log(`\n⚠️  Huginn think exited with code ${code}`);
-    }
-
-    broadcastStatusSync(projectPath, { is_online: false, current_task: null, touching_files: [] });
-    setTimeout(() => process.exit(code || 0), 500);
-  };
-
-  child.on('close', onDone);
-  child.on('formation:done', onDone);
-
-  return inProcess ? { child, sessionId, logPath, taskId: null } : child;
-}
-
-// ═════════════════════════════════════════
-// Unit：單一 agent 直接執行
-// ═════════════════════════════════════════
-
-function launchUnit(opts) {
-  const { rawPrompt, skill, sessionId, projectPath, taskId, taskScopePaths, role, rigor, skipPostComplete, skipTests, inProcess,
-    worktreePath = null, countFile = null, countLock = null, originSessionId = null,
-    dispatchModel = null,
-    // TASK_1929 (Agent Hub M2): see headless.js CLI + runner.js spawnClaude/
-    // spawnBifrost. Defaults are "no override" — zero behavior change for
-    // every dispatch path that doesn't pass these (which is all of them
-    // except agent_hub/launch.rs's `hub` skill launches).
-    mcpConfigExtra = [], allowedToolsOverride = null } = opts;
-  const ts_start = Date.now();
-
-  let finalPrompt = HEADLESS_PREFIX + rawPrompt;
-  try {
-    const { block } = canary.generate({
-      session: sessionId,
-      specialist: 'unit',
-      task: taskId || 'none',
-      scope: (taskScopePaths || []).join(','),
-    }, projectPath);
-    finalPrompt = block + '\n\n' + finalPrompt;
-  } catch (err) {
-    console.warn(`⚠️  Canary injection skipped: ${err.message}`);
-  }
-
-  // 等待 concurrency 插槽 BEFORE spawning claude.
-  // CRITICAL: Atomics.wait blocks the Node.js event loop. If called AFTER
-  // spawnClaude, child.stdin.write(prompt) I/O flush never executes → claude
-  // gets no prompt → hangs → zero output for 60 min (deadlock root cause).
-  waitForDispatchSlot('unit');
-
-  const child = runHeadless({
-    prompt: finalPrompt,
-    formation: 'unit',
-    skill,
-    sessionId,
-    projectPath,
-    rigor,  // passed to runner.js for activity timeout scaling (high=10min, medium=7min, low=5min)
-    worktreeDir: worktreePath,  // null = run in projectPath/ROOT (serial fallback or non-task)
-    model: dispatchModel,  // Quick Actions → Default Models → Dispatch agent
-    // TASK_1929: extraMcpConfigs=[] and no allowedTools key when unset —
-    // spawnClaude's own defaults (empty array / its built-in allowedTools
-    // list) then apply exactly as before this task.
-    extraMcpConfigs: mcpConfigExtra,
-    ...(allowedToolsOverride ? { allowedTools: allowedToolsOverride } : {}),
-  });
-  trackChild(child);
-
-  // 註冊 dispatch（Dashboard Agent Monitor 用）
-  const logPath = child._formation?.logPath;
-  registerDispatch({
-    sessionId,
-    logPath,
-    taskId,
-    formation: 'unit',
-    projectPath,
-    worktreePath,
-    originSessionId,
-    originTransport: originSessionId ? 'mcp' : null,
-    originNotificationMethod: originSessionId ? 'notifications/kenaz/dispatch_complete' : null,
-    pid: child.pid || null,
-  });
-
-  // 保底清理：父進程被 kill 時確保 unregister（防止 .active-dispatches.json 殘留）
-  // inProcess 模式跳過 — 不能在 MCP server 上註冊 process.on('exit')
-  if (!inProcess) {
-    process.on('exit', () => unregisterDispatch(sessionId));
-  }
-
-  // 閉環：agent 完成後自動執行 post-complete + Yggdrasil cleanup
-  // Guard: 確保只執行一次（close + formation:done 可能都觸發）
-  let cleanedUp = false;
-  const onDone = (code) => {
-    if (cleanedUp) return;
-    cleanedUp = true;
-    unregisterDispatch(sessionId);
-    const finalCode = child._formationExitCode ?? code ?? 0;
-
-    const willPostComplete = Boolean(
-      taskId && taskId.startsWith('TASK_') && !skipPostComplete && finalCode === 0
-    );
-
-    // Worktree cleanup on agent failure or read-only/skip-post-complete sessions.
-    // On success with real task: let postComplete handle cleanup via worktree merge path
-    // to avoid double-decrement of the parallel semaphore.
-    if (worktreePath && !willPostComplete) {
-      // Rescue commit: if the agent wrote code but exited non-zero (e.g. cargo test
-      // timeout), save uncommitted changes to the task branch before deleting the
-      // worktree. Without this, all agent work is silently lost on non-zero exit.
-      if (taskId && finalCode !== 0) {
-        try {
-          const { execSync: rescueExec } = require('child_process');
-          const status = rescueExec('git status --porcelain', {
-            cwd: worktreePath, encoding: 'utf8', timeout: 10000, windowsHide: true, stdio: 'pipe',
-          }).trim();
-          if (status.length > 0) {
-            // TASK_1957: exclude telemetry/daemon-noise paths (same list as the
-            // dispatch prompt's commit step, buildWorktreeGitAddCommand) so a
-            // rescue commit doesn't sweep canary/session/progress-note/dispatch
-            // files into the task branch either.
-            rescueExec(buildWorktreeGitAddCommand(), { cwd: worktreePath, timeout: 15000, windowsHide: true, stdio: 'pipe' });
-            rescueExec(`git commit -m "[${taskId}] rescue commit (agent exit code ${finalCode})"`, {
-              cwd: worktreePath, timeout: 15000, windowsHide: true, stdio: 'pipe',
-            });
-            console.log(`   🆘 Rescue commit saved for ${taskId} (exit ${finalCode}, ${status.split('\n').length} files)`);
-          }
-        } catch (e) {
-          console.log(`   ⚠️  Rescue commit failed: ${e.message}`);
-        }
-      }
-      try { removeTaskWorktree(projectPath || ROOT, worktreePath); } catch {}
-      if (countFile && countLock) _decrementParallelCount(countFile, countLock);
-    }
-
-    if (taskId && taskId.startsWith('TASK_') && !skipPostComplete) {
-      if (finalCode === 0) {
-        console.log(`\n⚔️  Auto Post-Complete: ${taskId}`);
-        // Pass worktreePath so postComplete uses worktree merge path (merge task branch + cleanup).
-        // postComplete handles worktree removal + semaphore decrement via cleanupWorktree.
-        let postCompleteResult = null;
-        try {
-          postCompleteResult = postComplete({ taskId, projectPath, skipTests, logPath, formation: 'unit', skill, worktreePath: worktreePath || undefined });
-          // Note: postComplete internally calls commit-sync after successful git commit
-        } catch (e) {
-          console.error(`❌ Post-complete failed: ${e.message}`);
-        }
-        emitDispatchCompletion(buildDispatchCompletionEvent({
-          taskId,
-          sessionId,
-          originSessionId,
-          formation: 'unit',
-          skill,
-          projectPath,
-          logPath,
-          finalCode,
-          postCompleteResult,
-        }));
-        // Branch recovery guarantee: postComplete's _gitMergeFromWorktree finally block
-        // may silently fail to checkout userBranch (throws:false). Explicitly recover here
-        // so main repo never stays stuck on a task/ branch after worktree dispatch.
-        if (worktreePath) {
-          try {
-            const { execSync: brEs } = require('child_process');
-            const { ROOT: brROOT } = require('./utils');
-            const gitRoot = projectPath || brROOT;
-            const dispatchFile = path.join(gitRoot, '.formation', '.dispatch-branch');
-            const dispatchBranch = require('fs').existsSync(dispatchFile)
-              ? require('fs').readFileSync(dispatchFile, 'utf8').trim()
-              : null;
-            let targetBranch = (dispatchBranch && !dispatchBranch.startsWith('task/')) ? dispatchBranch : null;
-            if (!targetBranch) {
-              // Dynamic current-branch resolution — correct for ANY user/branch.
-              // Previously `git config user.name`, which assumed the working branch
-              // was named after the git user and produced phantom branches (e.g.
-              // user.name "xyz9516" vs branch "xyz951610"), silently falling through
-              // to hardcoded `main`. Branch must NEVER be hardcoded: production builds
-              // run as different users on differently-named branches. Mirrors
-              // post-complete.js resolveUserBranch().
-              try {
-                const cur = brEs('git rev-parse --abbrev-ref HEAD', {
-                  cwd: gitRoot, encoding: 'utf8', timeout: 5000, windowsHide: true, stdio: 'pipe',
-                }).trim();
-                if (cur && cur !== 'HEAD' && !cur.startsWith('task/')) targetBranch = cur;
-              } catch {}
-            }
-            if (!targetBranch) {
-              try {
-                targetBranch = brEs('git rev-parse --verify main', {
-                  cwd: gitRoot, encoding: 'utf8', timeout: 5000, windowsHide: true, stdio: 'pipe',
-                }) ? 'main' : null;
-              } catch {}
-            }
-            if (!targetBranch) targetBranch = 'master';
-            const currentBranch = brEs('git rev-parse --abbrev-ref HEAD', {
-              cwd: gitRoot, encoding: 'utf8', timeout: 5000, windowsHide: true, stdio: 'pipe',
-            }).trim();
-            if (currentBranch.startsWith('task/')) {
-              brEs(`git checkout ${targetBranch}`, {
-                cwd: gitRoot, encoding: 'utf8', timeout: 10000, windowsHide: true, stdio: 'pipe',
-              });
-              console.log(`   ✅  Branch recovery: ${currentBranch} → ${targetBranch}`);
-            }
-          } catch { /* non-fatal — best-effort recovery */ }
-        }
-        // 閉環: 檢查 FIX queue，自動 re-dispatch
-        checkAndDispatchFix({ formation: 'unit', skill, projectPath });
-      } else {
-        console.log(`\n⚠️  Agent exited with code ${finalCode} — skipping post-complete`);
-        emitDispatchCompletion(buildDispatchCompletionEvent({
-          taskId,
-          sessionId,
-          originSessionId,
-          formation: 'unit',
-          skill,
-          projectPath,
-          logPath,
-          finalCode,
-          postCompleteResult: null,
-        }));
-      }
-    } else if (finalCode === 0) {
-      // skipPostComplete or no TASK_ — still sync commits if agent succeeded
-      syncCommit(taskId, projectPath);
-    } else {
-      emitDispatchCompletion(buildDispatchCompletionEvent({
-        taskId,
-        sessionId,
-        originSessionId,
-        formation: 'squad',
-        skill,
-        projectPath,
-        logPath: child._formation?.logPath,
-        finalCode: code,
-        postCompleteResult: null,
-      }));
-    }
-
-    // TASK_1785: snapshot lifecycle follows the dispatch — remove AFTER both
-    // consumers (runner leak check during 'close', postComplete rescue above)
-    // have had their chance to read it. Best-effort, never throws.
-    try {
-      const { removeDispatchDirtySnapshot } = require('./git-salvage');
-      removeDispatchDirtySnapshot(projectPath || ROOT, { sessionId });
-      if (projectPath && path.resolve(projectPath) !== path.resolve(ROOT)) {
-        removeDispatchDirtySnapshot(ROOT, { sessionId });
-      }
-    } catch { /* non-fatal */ }
-
-    // Analytics: record dispatch outcome
-    logAnalytics({ ts_start, taskId, skill, formation: 'unit', role, projectPath, exit_code: finalCode });
-
-    // Yggdrasil: mark offline + clear task (synchronous HTTP to ensure delivery before exit)
-    broadcastStatusSync(projectPath, { is_online: false, current_task: null, touching_files: [] });
-
-    // Exit the process after cleanup — signal handlers and timers keep the event loop alive,
-    // so Node.js won't exit naturally. Small delay to let sync HTTP complete.
-    setTimeout(() => process.exit(finalCode || 0), 500);
-  };
-
-  child.on('close', onDone);
-  // Fallback: formation:done fires when result is received, even if process lingers on Windows
-  child.on('formation:done', onDone);
-
-  return inProcess ? { child, sessionId, logPath, taskId } : child;
-}
-
-// ═════════════════════════════════════════
-// Solo：單一 agent 多視角分析
-// ═════════════════════════════════════════
-
-function launchSolo(opts) {
-  const { rawPrompt, skill, sessionId, projectPath, taskId, taskScopePaths, role, skipPostComplete, skipTests, inProcess, originSessionId = null } = opts;
-  const ts_start = Date.now();
-
-  let finalPrompt = HEADLESS_PREFIX + rawPrompt;
-  try {
-    const { block } = canary.generate({
-      session: sessionId,
-      specialist: 'solo',
-      task: taskId || 'none',
-      scope: (taskScopePaths || []).join(','),
-    }, projectPath);
-    finalPrompt = block + '\n\n' + finalPrompt;
-  } catch (err) {
-    console.warn(`⚠️  Canary injection skipped: ${err.message}`);
-  }
-
-  // Wait for slot BEFORE spawn — Atomics.wait blocks event loop (see launchUnit comment)
-  waitForDispatchSlot('solo');
-
-  const child = runHeadless({
-    prompt: finalPrompt,
-    formation: 'solo',
-    skill,
-    sessionId,
-    projectPath
-  });
-  trackChild(child);
-
-  const logPath = child._formation?.logPath;
-  registerDispatch({
-    sessionId,
-    logPath,
-    taskId,
-    formation: 'solo',
-    projectPath,
-    originSessionId,
-    originTransport: originSessionId ? 'mcp' : null,
-    originNotificationMethod: originSessionId ? 'notifications/kenaz/dispatch_complete' : null,
-    pid: child.pid || null,
-  });
-
-  // 保底清理：父進程被 kill 時確保 unregister
-  if (!inProcess) {
-    process.on('exit', () => unregisterDispatch(sessionId));
-  }
-
-  // 閉環：agent 完成後自動執行 post-complete + Yggdrasil cleanup
-  // Guard: 確保只執行一次
-  let cleanedUp = false;
-  const onDone = (code) => {
-    if (cleanedUp) return;
-    cleanedUp = true;
-    unregisterDispatch(sessionId);
-    const finalCode = child._formationExitCode ?? code ?? 0;
-
-    if (taskId && taskId.startsWith('TASK_') && !skipPostComplete) {
-      if (finalCode === 0) {
-        console.log(`\n⚔️  Auto Post-Complete: ${taskId}`);
-        // ensureTaskComplete removed — post-complete.js marks done AFTER merge
-        let postCompleteResult = null;
-        try {
-          postCompleteResult = postComplete({ taskId, projectPath, skipTests, logPath, formation: 'solo', skill });
-        } catch (e) {
-          console.error(`❌ Post-complete failed: ${e.message}`);
-        }
-        emitDispatchCompletion(buildDispatchCompletionEvent({
-          taskId,
-          sessionId,
-          originSessionId,
-          formation: 'solo',
-          skill,
-          projectPath,
-          logPath,
-          finalCode,
-          postCompleteResult,
-        }));
-        checkAndDispatchFix({ formation: 'solo', skill, projectPath });
-      } else {
-        console.log(`\n⚠️  Agent exited with code ${finalCode} — skipping post-complete`);
-        emitDispatchCompletion(buildDispatchCompletionEvent({
-          taskId,
-          sessionId,
-          originSessionId,
-          formation: 'solo',
-          skill,
-          projectPath,
-          logPath,
-          finalCode,
-          postCompleteResult: null,
-        }));
-      }
-    } else if (finalCode === 0) {
-      syncCommit(taskId, projectPath);
-    }
-
-    // Analytics: record dispatch outcome
-    logAnalytics({ ts_start, taskId, skill, formation: 'solo', role, projectPath, exit_code: finalCode });
-
-    broadcastStatusSync(projectPath, { is_online: false, current_task: null, touching_files: [] });
-
-    setTimeout(() => process.exit(finalCode || 0), 500);
-  };
-
-  child.on('close', onDone);
-  child.on('formation:done', onDone);
-
-  return inProcess ? { child, sessionId, logPath, taskId } : child;
-}
-
-// ═════════════════════════════════════════
-// Squad：多 agent 並行 + 辯論 + 整合
-// ═════════════════════════════════════════
-
-function launchSquad(opts) {
-  const { rawPrompt, skill, sessionId, skillDef, projectPath, taskId, taskScopePaths, role, skipPostComplete, skipTests, originSessionId = null } = opts;
-  const reportDir = `squad-${skill}`;
-
-  // 替換 {session} 佔位符 + inject canary per member
-  const memberPrompts = rawPrompt.map(m => {
-    let prompt = m.prompt.replace(/\{session\}/g, reportDir);
-    try {
-      const { block } = canary.generate({
-        session: sessionId,
-        specialist: `squad-${m.memberId}`,
-        task: taskId || 'none',
-        scope: (taskScopePaths || []).join(','),
-      }, projectPath);
-      prompt = block + '\n\n' + prompt;
-    } catch (err) {
-      console.warn(`⚠️  Canary injection skipped for ${m.memberId}: ${err.message}`);
-    }
-    return { ...m, prompt };
-  });
-
-  const debateEnabled = skillDef.debate?.enabled;
-  const totalRounds = debateEnabled ? 2 : 1;
-
-  console.log(`⚔️  Squad Launch: ${memberPrompts.length} members × ${totalRounds} round(s)\n`);
-
-  // ── Round 1: 獨立分析（並行）──
-  console.log(`── Round 1: Independent Analysis ──\n`);
-  const projectRoot = projectPath || ROOT;
-  const r1Children = memberPrompts.map(m => {
-    // Create isolated worktree for each squad member; fallback to shared dir on failure
-    const worktreeDir = createWorktree(sessionId, m.memberId, projectRoot) || undefined;
-    const child = runHeadless({
-      prompt: HEADLESS_PREFIX + m.prompt,
-      formation: 'squad',
-      skill: m.skill || skill,
-      sessionId,
-      memberId: m.memberId,
-      silent: true,
-      projectPath,
-      worktreeDir,
-    });
-    trackChild(child);
-    return child;
-  });
-
-  waitAll(r1Children).then(r1Results => {
-    printResults('Round 1 Complete', r1Results, memberPrompts.length);
-    if (!hasSuccess(r1Results)) return;
-
-    // ── Round 2: 交叉辯論（如果啟用）──
-    if (debateEnabled) {
-      console.log(`\n── Round 2: Cross-Debate ──\n`);
-      const debatePrompts = buildSquadDebatePrompts(skillDef, reportDir);
-
-      const r2Children = debatePrompts.map(m => {
-        const child = runHeadless({
-          prompt: HEADLESS_PREFIX + m.prompt,
-          formation: 'squad',
-          skill: m.skill || skill,
-          sessionId,
-          memberId: `${m.memberId}-r2`,
-          silent: true,
-          projectPath
-        });
-        trackChild(child);
-        return child;
-      });
-
-      waitAll(r2Children).then(r2Results => {
-        printResults('Round 2 Complete', r2Results, debatePrompts.length);
-        if (!hasSuccess(r2Results)) return;
-        squadSynthesis({ skill, sessionId, skillDef, reportDir, projectPath, taskId, role, skipPostComplete, skipTests, originSessionId });
-      });
-    } else {
-      squadSynthesis({ skill, sessionId, skillDef, reportDir, projectPath, taskId, role, skipPostComplete, skipTests, originSessionId });
-    }
-  });
-
-  return r1Children;
-}
-
-/**
- * Squad Synthesis：讀取所有報告，產出整合報告
- */
-function squadSynthesis(opts) {
-  const { skill, sessionId, skillDef, reportDir, projectPath, taskId, role, skipPostComplete, skipTests, originSessionId = null } = opts;
-  if (!skillDef?.merge || !reportDir) return;
-  const ts_start = Date.now();
-
-  console.log(`\n── Synthesis ──\n`);
-  const synthPrompt = buildSquadSynthesisPrompt(skillDef, reportDir);
-
-  // Wait for slot BEFORE spawn — Atomics.wait blocks event loop (see launchUnit comment)
-  waitForDispatchSlot('squad');
-
-  const child = runHeadless({
-    prompt: HEADLESS_PREFIX + synthPrompt,
-    formation: 'squad',
-    skill: `${skill}-synthesis`,
-    sessionId,
-    memberId: 'synthesis',
-    projectPath
-  });
-  trackChild(child);
-
-  registerDispatch({
-    sessionId,
-    logPath: child._formation?.logPath,
-    taskId,
-    formation: 'squad',
-    projectPath,
-    originSessionId,
-    originTransport: originSessionId ? 'mcp' : null,
-    originNotificationMethod: originSessionId ? 'notifications/kenaz/dispatch_complete' : null,
-    pid: child.pid || null,
-  });
-
-  // 保底清理：父進程被 kill 時確保 unregister
-  process.on('exit', () => unregisterDispatch(sessionId));
-
-  // Guard: 確保只執行一次
-  let cleanedUp = false;
-  const onDone = (code) => {
-    if (cleanedUp) return;
-    cleanedUp = true;
-    unregisterDispatch(sessionId);
-    // Cleanup worktrees created for Round 1 squad members
-    cleanupAllWorktrees();
-    const status = code === 0 ? '✅' : '❌';
-    console.log(`\n⚔️  Synthesis ${status} (exit ${code})`);
-    if (code === 0) {
-      console.log(`   Report: .formation/reports/${reportDir}/synthesis.md`);
-
-      // 閉環：squad synthesis 完成後自動執行 post-complete
-      if (taskId && taskId.startsWith('TASK_') && !skipPostComplete) {
-        console.log(`\n⚔️  Auto Post-Complete: ${taskId}`);
-        // ensureTaskComplete removed — post-complete.js marks done AFTER merge
-        try {
-          var postCompleteResult = null;
-          postCompleteResult = postComplete({ taskId, projectPath, skipTests, logPath: child._formation?.logPath, formation: 'squad', skill });
-        } catch (e) {
-          console.error(`❌ Post-complete failed: ${e.message}`);
-        }
-        emitDispatchCompletion(buildDispatchCompletionEvent({
-          taskId,
-          sessionId,
-          originSessionId,
-          formation: 'squad',
-          skill,
-          projectPath,
-          logPath: child._formation?.logPath,
-          finalCode: code,
-          postCompleteResult,
-        }));
-        checkAndDispatchFix({ formation: 'squad', skill, projectPath });
-      } else {
-        syncCommit(taskId, projectPath);
-      }
-    }
-
-    // Analytics: record dispatch outcome
-    logAnalytics({ ts_start, taskId, skill, formation: 'squad', role, projectPath, exit_code: code });
-
-    // Yggdrasil: mark offline (synchronous to ensure delivery before exit)
-    broadcastStatusSync(projectPath, { is_online: false, current_task: null, touching_files: [] });
-
-    setTimeout(() => process.exit(code || 0), 500);
-  };
-
-  child.on('close', onDone);
-  child.on('formation:done', onDone);
-}
-
-// ═════════════════════════════════════════
-// Legion：Agent Teams 啟動
-// ═════════════════════════════════════════
-
-function launchLegion(opts) {
-  const { rawPrompt: legionConfig, skill, sessionId, projectPath, taskId, role } = opts;
-  const ts_start = Date.now();
-
-  let leadPrompt = buildLegionLeadPrompt(legionConfig);
-
-  // Inject canary block for Legion Lead (long-lived agent needs context integrity)
-  try {
-    const resolvedTaskId = opts.taskId
-      || (legionConfig.lead?.prompt?.match(/\*\*Task ID\*\*:\s*(TASK_\d+)/) || [])[1]
-      || 'none';
-    const { block } = canary.generate({
-      session: sessionId,
-      specialist: 'legion-lead',
-      task: resolvedTaskId,
-      scope: (opts.taskScopePaths || []).join(','),
-    }, projectPath);
-    leadPrompt = block + '\n\n' + leadPrompt;
-  } catch (err) {
-    console.warn(`⚠️  Canary injection skipped: ${err.message}`);
-  }
-
-  console.log(`⚔️  Legion Launch: ${legionConfig.members.length} members planned\n`);
-
-  // FormationRunner facade: single entry point over launchLegion→runLegionLead→spawn*
-  // Reduces Legion dispatch boundary crossings from ~9 to 4-5 steps (TASK_1559).
-  // Behavior-preserving: delegates to runLegionLead internally, no semantic change.
-  const child = formationRunner.run('legion-lead', {
-    prompt: leadPrompt,
-    formation: 'legion',
-    skill,
-    sessionId,
-    memberId: 'lead',
-    projectPath
-  });
-  trackChild(child);
-
-  // Analytics: record dispatch outcome when legion lead exits
-  let legionAnalyticsDone = false;
-  const onLegionDone = (code) => {
-    if (legionAnalyticsDone) return;
-    legionAnalyticsDone = true;
-    logAnalytics({ ts_start, taskId, skill, formation: 'legion', role, projectPath, exit_code: code ?? 0 });
-  };
-  child.on('close', onLegionDone);
-  child.on('formation:done', onLegionDone);
-
-  return child;
-}
-
-// ═════════════════════════════════════════
-// Legacy：連續排程器（Rust SingleAgentScheduler 對等實作）
-// ═════════════════════════════════════════
-
-function launchLegacy(opts) {
-  const { skillDef, concurrency, projectPath } = opts;
-
-  // ── Pre-check: is a scheduler already running for this project? ──
-  // Uses heartbeat-based zombie detection (matching legacy-scheduler.js guard)
-  const HEARTBEAT_STALE_MS = 5 * 60 * 1000;
-  const logDir = projectPath
-    ? path.join(getLogDir(projectPath), 'legacy')
-    : path.join(ROOT, '.formation', 'logs', 'legacy');
-  const pidFile = path.join(logDir, 'scheduler.pid');
-  if (fs.existsSync(pidFile)) {
-    try {
-      const existing = JSON.parse(fs.readFileSync(pidFile, 'utf8'));
-      if (existing.pid && existing.pid !== process.pid) {
-        let isAlive = false;
-        try { process.kill(existing.pid, 0); isAlive = true; } catch {}
-        if (isAlive) {
-          const heartbeat = existing.heartbeat ? new Date(existing.heartbeat).getTime() : 0;
-          const stale = Date.now() - heartbeat > HEARTBEAT_STALE_MS;
-          if (!stale) {
-            console.log(`ℹ️  Scheduler already running (PID ${existing.pid}). Skipping duplicate launch.`);
-            return null;
-          }
-          console.log(`⚠️  Stale scheduler detected (PID ${existing.pid}). Killing zombie...`);
-          try {
-            if (process.platform === 'win32') {
-              require('child_process').execSync(`taskkill /F /PID ${existing.pid}`, { stdio: 'ignore', timeout: 5000, windowsHide: true });
-            } else {
-              process.kill(existing.pid, 'SIGTERM');
-            }
-          } catch {}
-          try { fs.unlinkSync(pidFile); } catch {}
-        }
-      }
-    } catch {}
-  }
-
-  const legacyScheduler = require('./legacy-scheduler');
-
-  // 從 skillDef.config 提取 CLI 可覆蓋的參數
-  const overrides = {};
-  if (skillDef.config) {
-    if (skillDef.config.initial_delay_secs != null) overrides.initialDelay = skillDef.config.initial_delay_secs;
-    if (skillDef.config.interval_minutes != null) overrides.interval = skillDef.config.interval_minutes;
-    if (skillDef.config.dev_timeout_minutes != null) overrides.devTimeout = skillDef.config.dev_timeout_minutes;
-    if (skillDef.config.enable_self_enhancement != null) overrides.selfEnhancement = skillDef.config.enable_self_enhancement;
-  }
-
-  // [merge: main + {git_user}] instance-id (main) + concurrency/projectPath ({git_user})
-  // Pass through --instance-id from Dashboard (Rust) CLI args
-  const instanceIdArg = process.argv.find(a => a.startsWith('--instance-id='));
-  if (instanceIdArg) overrides.instanceId = instanceIdArg.split('=')[1];
-
-  // CLI --concurrency 覆蓋 YAML 設定
-  if (concurrency != null) overrides.concurrency = concurrency;
-
-  // 傳遞子專案路徑
-  if (projectPath) overrides.projectPath = projectPath;
-
-  // legacy scheduler 是自己的 async 迴圈，不回傳 child process
-  // 必須 catch rejection，否則 headless 模式下 unhandledRejection 會靜默殺掉進程
-  legacyScheduler.start(overrides).catch(err => {
-    console.error(`❌ Legacy Scheduler fatal error: ${err.message}`);
-    console.error(err.stack);
-    process.exit(1);
-  });
-  return null;
-}
-
-// ─────────────────────────────────────────
-// Unit Worktree Isolation Setup
-// ─────────────────────────────────────────
-
-/**
- * Set up an isolated git worktree for a unit/solo task dispatch.
- * Implements parallel semaphore (up to MAX_PARALLEL=5) with serial dispatch-lock fallback.
- * Registers process.on('exit'/'SIGTERM'/'SIGINT') cleanup handlers.
- * TASK_1775: use_worktree:false in the dispatched project's .kenaz/project.yaml
- * skips worktree entirely and routes straight to serial dispatch-lock mode.
- *
- * Extracted from launch() in headless.js (TASK_891) to slim the orchestrator.
- *
- * @param {object} opts
- * @param {string} opts.projectRoot - Absolute project root path
- * @param {string|null} opts.projectPath - Sub-project path (may differ from projectRoot)
- * @param {string} opts.taskId - Task ID (e.g. TASK_891)
- * @param {string} opts.sessionId - Session ID for lock identification
- * @param {boolean|null} [opts.useWorktreeOverride] - TASK_1833 dispatch-time toggle
- *   (true/false forces the mode; null falls through to env/project.yaml/default)
- * @returns {{ worktreePath: string|null, countFile: string|null, countLock: string|null }}
- */
-function setupUnitWorktree({ projectRoot, projectPath, taskId, sessionId, useWorktreeOverride = null }) {
-  // TASK_1785 (DEFECT-C/D): snapshot the dirty paths of the dispatched project's
-  // working tree BEFORE any worktree/lock work. The runner leak detector and the
-  // post-complete rescue scan use this to consider ONLY paths that became dirty
-  // during the dispatch window — pre-existing user WIP is never swept/salvaged.
-  // Best-effort: a capture failure degrades those consumers to legacy behavior.
-  try {
-    const { captureDispatchDirtySnapshot } = require('./git-salvage');
-    const snap = captureDispatchDirtySnapshot(projectRoot, { sessionId, taskId });
-    if (snap) {
-      console.log(`   📸 [TASK_1785] Pre-dispatch dirty snapshot: ${snap.dirtyPaths.length} pre-existing dirty path(s) recorded`);
-    } else {
-      console.warn(`   ⚠️  [TASK_1785] Pre-dispatch dirty snapshot capture failed — leak/rescue will use legacy semantics`);
-    }
-    // The runner's leak detector audits the CORE root working tree (mainRoot=ROOT)
-    // even for sub-project dispatches — snapshot core too when it differs.
-    if (path.resolve(projectRoot) !== path.resolve(ROOT)) {
-      captureDispatchDirtySnapshot(ROOT, { sessionId, taskId });
-    }
-  } catch (e) {
-    console.warn(`   ⚠️  [TASK_1785] Pre-dispatch dirty snapshot error (non-fatal): ${e.message}`);
-  }
-
-  const worktreeName = `task_${taskId.toLowerCase()}`;
-  const absoluteWorktreePath = path.join(projectRoot, '.formation', 'worktrees', worktreeName);
-  // KENAZ_PARALLEL_COUNT_FILE: test-only override so tests never touch the real semaphore.
-  const countFile = process.env.KENAZ_PARALLEL_COUNT_FILE || path.join(ROOT, '.formation', '.parallel-count');
-  const countLock = process.env.KENAZ_PARALLEL_COUNT_FILE
-    ? process.env.KENAZ_PARALLEL_COUNT_FILE + '-lock'
-    : path.join(ROOT, '.formation', '.parallel-count-lock');
-  const MAX_PARALLEL = 5;
-  const SEMAPHORE_POLL_MS = 5000;
-  const SEMAPHORE_WAIT_TIMEOUT_MS = 1800000; // 30 min
-
-  // TASK_1775: explicit worktree opt-out — read the DISPATCHED project's
-  // .kenaz/project.yaml (projectPath), not core's. use_worktree:false routes
-  // straight to serial dispatch-lock mode (huge repos / single-editor-bound
-  // projects where a worktree checkout is architecturally wrong).
-  // TASK_1833: decision now flows through utils.resolveWorktreeDecision — the
-  // SAME function the sub-agent dispatch path uses (dispatch-time override >
-  // env FORMATION_USE_WORKTREE > project.yaml > default true).
-  const wtDecision = resolveWorktreeDecision(projectPath || projectRoot, useWorktreeOverride);
-  const worktreeEnabled = wtDecision.useWorktree;
-  if (!worktreeEnabled) {
-    console.log(`   ⏭️  Worktree opt-out (${wtDecision.source}) — serial dispatch-lock mode`);
-  } else {
-    // Ensure .formation/worktrees/ is in .gitignore (idempotent)
-    ensureWorktreeDirIgnored(projectRoot);
-  }
-
-  // Semaphore: wait for a parallel slot (max MAX_PARALLEL concurrent worktree dispatches)
-  let slotAcquired = false;
-  const semaphoreDeadline = Date.now() + SEMAPHORE_WAIT_TIMEOUT_MS;
-  while (worktreeEnabled && Date.now() < semaphoreDeadline) {
-    let lockFd = null;
-    try {
-      lockFd = fs.openSync(countLock, 'wx'); // O_EXCL atomic create
-      try {
-        const count = fs.existsSync(countFile) ? (parseInt(fs.readFileSync(countFile, 'utf-8').trim()) || 0) : 0;
-        if (count < MAX_PARALLEL) {
-          fs.writeFileSync(countFile, String(count + 1));
-          slotAcquired = true;
-        } else {
-          console.log(`⏳ Max parallel dispatches reached (${count}/${MAX_PARALLEL}), waiting...`);
-        }
-      } finally {
-        fs.closeSync(lockFd);
-        try { fs.unlinkSync(countLock); } catch {}
-      }
-      if (slotAcquired) break;
-    } catch {
-      /* count-lock held — retry */
-    }
-    const wait = Date.now() + SEMAPHORE_POLL_MS;
-    while (Date.now() < wait) { /* busy wait */ }
-  }
-
-  if (slotAcquired) {
-    // Attempt to create an isolated git worktree for this task
-    const branchName = `task/${taskId.toLowerCase()}`;
-    try {
-      createTaskWorktree(projectRoot, absoluteWorktreePath, branchName);
-      console.log(`   🌿 Unit worktree: .formation/worktrees/${worktreeName}`);
-
-      // Register cleanup on exit (worktree + semaphore release)
-      const releaseWorktree = () => {
-        try { removeTaskWorktree(projectRoot, absoluteWorktreePath); } catch {}
-        _decrementParallelCount(countFile, countLock);
-      };
-      process.on('exit', releaseWorktree);
-      process.on('SIGTERM', () => { releaseWorktree(); process.exit(1); });
-      process.on('SIGINT', () => { releaseWorktree(); process.exit(1); });
-
-      return { worktreePath: absoluteWorktreePath, countFile, countLock };
-    } catch (err) {
-      // Worktree creation failed — release the semaphore slot and fall back to serial lock
-      console.warn(`⚠️  Worktree creation failed: ${err.message}`);
-      console.warn(`   Falling back to serial dispatch-lock mode.`);
-      _decrementParallelCount(countFile, countLock);
-    }
-  }
-
-  // Serial dispatch-lock fallback: used when worktree is disabled, creation fails, or slot not acquired
-  // TASK_1833: lock path + acquisition/stale-breaking are shared with the
-  // sub-agent dispatch path (dispatch.js serial_lock mode) via
-  // utils.dispatchLockPath / tryAcquireDispatchLock — Formation and sub-agent
-  // dispatches against the same project serialize against EACH OTHER.
-  const lockFile = dispatchLockPath(projectPath);
-  const LOCK_WAIT_TIMEOUT_MS = 1800000; // 30 minutes max wait
-  const LOCK_POLL_MS = 5000;
-  const lockDeadline = Date.now() + LOCK_WAIT_TIMEOUT_MS;
-
-  while (Date.now() < lockDeadline) {
-    const acq = tryAcquireDispatchLock(lockFile, { sessionId, taskId, pid: process.pid });
-    if (acq.acquired) {
-      if (acq.broke) {
-        console.log(`   ⚠️  Broke ${acq.brokeReason} dispatch lock from ${acq.broke.taskId || acq.broke.sessionId || '<corrupt>'}`);
-      }
-      break; // lock acquired
-    }
-    if (acq.error) break; // unexpected error — proceed without lock (legacy behavior)
-    if (acq.holder) {
-      console.log(`⏳ Waiting for dispatch lock (held by ${acq.holder.taskId || acq.holder.sessionId})...`);
-    }
-    const wait = Date.now() + LOCK_POLL_MS;
-    while (Date.now() < wait) { /* busy wait */ }
-  }
-
-  // TASK_1391: retry on EBUSY (Windows AV/watcher race). Silent on ENOENT.
-  const releaseLock = () => {
-    for (let i = 0; i < 3; i++) {
-      try { fs.unlinkSync(lockFile); return; }
-      catch (e) {
-        if (e.code === 'ENOENT') return;
-        if (e.code === 'EBUSY' && i < 2) {
-          const wait = Date.now() + 100;
-          while (Date.now() < wait) {}
-          continue;
-        }
-        return;
-      }
-    }
-  };
-  process.on('exit', releaseLock);
-  process.on('SIGTERM', () => { releaseLock(); process.exit(1); });
-  process.on('SIGINT', () => { releaseLock(); process.exit(1); });
-
-  return { worktreePath: null, countFile: null, countLock: null };
-}
-
-module.exports = {
-  launchHuginnThink,
-  launchUnit,
-  launchSolo,
-  launchSquad,
-  launchLegion,
-  launchLegacy,
-  createWorktree,
-  removeWorktree,
-  cleanupAllWorktrees,
-  setupUnitWorktree,
-};