@magnusekdahl/parallix 1.2.0 → 1.3.0

package/lib/core/mission-utils.js

@@ -1,196 +1,264 @@
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const fmt = require('./fmt');
-const { loadAdapterConfig, resolveTaskStorage } = require('./product-config');
-
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SUPPORTED_VERIFY_AREAS = void 0;
+exports.missionBaseDir = missionBaseDir;
+exports.missionUsesYearTier = missionUsesYearTier;
+exports.missionBranchPrefix = missionBranchPrefix;
+exports.missionBranchName = missionBranchName;
+exports.missionBranchRef = missionBranchRef;
+exports.isMissionSlugCandidate = isMissionSlugCandidate;
+exports.extractSlugFromBranch = extractSlugFromBranch;
+exports.getPrimaryBranch = getPrimaryBranch;
+exports.resolveMainRepo = resolveMainRepo;
+exports.getPrimaryWorktree = getPrimaryWorktree;
+exports.conventionalWorktreePath = conventionalWorktreePath;
+exports.conventionalBaseWorktreePath = conventionalBaseWorktreePath;
+exports.detectLaunchBaseBranch = detectLaunchBaseBranch;
+exports.parseBaseBranchLine = parseBaseBranchLine;
+exports.readRecordedBaseBranch = readRecordedBaseBranch;
+exports.resolveMissionBaseBranch = resolveMissionBaseBranch;
+exports.resolveBaseWorktree = resolveBaseWorktree;
+exports.getMissionYear = getMissionYear;
+exports.findMissionDir = findMissionDir;
+exports.resolveWorktree = resolveWorktree;
+exports.findCheckpoints = findCheckpoints;
+exports.compareCheckpointFiles = compareCheckpointFiles;
+exports.checkpointOrder = checkpointOrder;
+exports.getFirstLine = getFirstLine;
+exports.missionTitle = missionTitle;
+exports.normalizeVerifyArea = normalizeVerifyArea;
+exports.detectMissionAreaFromContent = detectMissionAreaFromContent;
+exports.findMissionArea = findMissionArea;
+exports.graphifyAvailable = graphifyAvailable;
+exports.graphifyCommandCandidates = graphifyCommandCandidates;
+exports.probeGraphifyAvailability = probeGraphifyAvailability;
+exports.updateGraphifyKnowledgeGraph = updateGraphifyKnowledgeGraph;
+exports.missionPathForSlug = missionPathForSlug;
+exports.missionDirForSlug = missionDirForSlug;
+exports.inferSlug = inferSlug;
+exports.parseConflictFilesFromMergeOutput = parseConflictFilesFromMergeOutput;
+exports.getConflictFiles = getConflictFiles;
+exports.findLastNonNoiseCommit = findLastNonNoiseCommit;
+exports.squashTrailingBacklogNoiseIntoPreviousMission = squashTrailingBacklogNoiseIntoPreviousMission;
+exports.softResetTrailingBacklogNoise = softResetTrailingBacklogNoise;
+exports.findMissionDocInBranches = findMissionDocInBranches;
+exports.isMissionArtifact = isMissionArtifact;
+exports.isWorkflowGeneratedArtifact = isWorkflowGeneratedArtifact;
+const fs = __importStar(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const fmt = __importStar(require("./fmt.js"));
+const product_config_js_1 = require("./product-config.js");
+const gitModule = __importStar(require("./git.js"));
 /** @param {string} prefix */
 function normalizeBranchPrefix(prefix) {
-  if (typeof prefix !== 'string' || !prefix.trim()) {
-    return 'mission/';
-  }
-  return prefix.endsWith('/') ? prefix : `${prefix}/`;
+    if (typeof prefix !== 'string' || !prefix.trim()) {
+        return 'mission/';
+    }
+    return prefix.endsWith('/') ? prefix : prefix + '/';
 }
-
 function missionAdapterDefaults() {
-  return {
-    baseDir: 'missions',
-    branchPrefix: 'mission/',
-    worktreePattern: '../<repo>-<slug>',
-  };
+    return {
+        baseDir: 'missions',
+        branchPrefix: 'mission/',
+        worktreePattern: '../<repo>-<slug>',
+    };
 }
-
 function resolveMissionAdapter(rootDir = process.cwd()) {
-  const adapters = loadAdapterConfig(rootDir);
-  const missions = adapters.missions || {};
-  const defaults = missionAdapterDefaults();
-  return {
-    baseDir: typeof missions.baseDir === 'string' && missions.baseDir.trim()
-      ? missions.baseDir
-      : defaults.baseDir,
-    branchPrefix: normalizeBranchPrefix(missions.branchPrefix || defaults.branchPrefix),
-    worktreePattern: typeof missions.worktreePattern === 'string' && missions.worktreePattern.trim()
-      ? missions.worktreePattern
-      : defaults.worktreePattern,
-  };
+    const adapters = (0, product_config_js_1.loadAdapterConfig)(rootDir);
+    const missions = adapters.missions || {};
+    const defaults = missionAdapterDefaults();
+    return {
+        baseDir: typeof missions.baseDir === 'string' && missions.baseDir.trim()
+            ? missions.baseDir
+            : defaults.baseDir,
+        branchPrefix: normalizeBranchPrefix(missions.branchPrefix || defaults.branchPrefix),
+        worktreePattern: typeof missions.worktreePattern === 'string' && missions.worktreePattern.trim()
+            ? missions.worktreePattern
+            : defaults.worktreePattern,
+    };
 }
-
 function missionBaseDir(rootDir = process.cwd()) {
-  return path.resolve(rootDir, resolveMissionAdapter(rootDir).baseDir);
+    return node_path_1.default.resolve(rootDir, resolveMissionAdapter(rootDir).baseDir);
 }
-
 function missionUsesYearTier(rootDir = process.cwd()) {
-  return resolveMissionAdapter(rootDir).baseDir !== missionAdapterDefaults().baseDir;
+    return resolveMissionAdapter(rootDir).baseDir !== missionAdapterDefaults().baseDir;
 }
-
 function missionBranchPrefix(rootDir = process.cwd()) {
-  return resolveMissionAdapter(rootDir).branchPrefix;
+    return resolveMissionAdapter(rootDir).branchPrefix;
 }
-
 /** @param {string} slug @param {string} [rootDir] */
 function missionBranchName(slug, rootDir = process.cwd()) {
-  return `${missionBranchPrefix(rootDir)}${slug}`;
+    return missionBranchPrefix(rootDir) + slug;
 }
-
 /** @param {string} slug @param {string} [rootDir] */
 function missionBranchRef(slug, rootDir = process.cwd()) {
-  return `refs/heads/${missionBranchName(slug, rootDir)}`;
+    return 'refs/heads/' + missionBranchName(slug, rootDir);
 }
-
 /** @param {unknown} value */
 function isMissionSlugCandidate(value) {
-  return typeof value === 'string' && /^(task|adhoc)-[a-z0-9][a-z0-9-]*$/i.test(value.trim());
+    return typeof value === 'string' && /^(task|adhoc)-[a-z0-9][a-z0-9-]*$/i.test(value.trim());
 }
-
 /** @param {string} branch @param {string} [rootDir] */
 function extractSlugFromBranch(branch, rootDir = process.cwd()) {
-  const prefix = missionBranchPrefix(rootDir);
-  if (!branch || !branch.startsWith(prefix)) {return null;}
-  return branch.slice(prefix.length).toLowerCase();
+    const prefix = missionBranchPrefix(rootDir);
+    if (!branch || !branch.startsWith(prefix)) {
+        return null;
+    }
+    return branch.slice(prefix.length).toLowerCase();
 }
-
 /** @param {string|Function} rootDirOrGitFn @param {Function|null} [maybeGitFn] */
 function getPrimaryBranch(rootDirOrGitFn = process.cwd(), maybeGitFn = null) {
-  const { git } = require('./git');
-  const rootDir = typeof rootDirOrGitFn === 'function' ? process.cwd() : rootDirOrGitFn;
-  /** @type {Function} */
-  const runner = typeof rootDirOrGitFn === 'function' ? rootDirOrGitFn : (maybeGitFn || git);
-  const listLocalBranches = () => {
-    const result = runner(['-C', rootDir, 'branch', '--list', '--format=%(refname:short)', 'main', 'master']);
-    return (result.stdout || '').split('\n').map((/** @type {string} */ b) => b.trim()).filter(Boolean);
-  };
-
-  try {
-    const missions = loadAdapterConfig(rootDir).missions || {};
-    if (typeof missions.primaryBranch === 'string' && missions.primaryBranch.trim()) {
-      const configured = missions.primaryBranch.trim();
-      const branches = listLocalBranches();
-      if (branches.includes(configured)) {
-        return configured;
-      }
-      if (configured !== 'main' && configured !== 'master') {
-        return configured;
-      }
-    }
-  } catch (_) {
-    // fall through to git-based detection
-  }
-  try {
-    const branches = listLocalBranches();
-    if (branches.includes('main')) {return 'main';}
-    if (branches.includes('master')) {return 'master';}
-  } catch (_) {
-    // fall through
-  }
-  throw new Error(
-    "Could not detect primary branch. Neither 'main' nor 'master' exists as a local branch."
-  );
+    const rootDir = typeof rootDirOrGitFn === 'function' ? process.cwd() : rootDirOrGitFn;
+    /** @type {Function} */
+    const runner = typeof rootDirOrGitFn === 'function' ? rootDirOrGitFn : (maybeGitFn || gitModule.git);
+    const listLocalBranches = () => {
+        const result = runner(['-C', rootDir, 'branch', '--list', '--format=%(refname:short)', 'main', 'master']);
+        return (result.stdout || '').split('\n').map((b) => b.trim()).filter(Boolean);
+    };
+    try {
+        const config = (0, product_config_js_1.loadAdapterConfig)(rootDir);
+        const missions = config.missions || {};
+        if (typeof missions.primaryBranch === 'string' && missions.primaryBranch.trim()) {
+            const configured = missions.primaryBranch.trim();
+            const branches = listLocalBranches();
+            if (branches.includes(configured)) {
+                return configured;
+            }
+            if (configured !== 'main' && configured !== 'master') {
+                return configured;
+            }
+        }
+    }
+    catch (_) {
+        // fall through to git-based detection
+    }
+    try {
+        const branches = listLocalBranches();
+        if (branches.includes('main')) {
+            return 'main';
+        }
+        if (branches.includes('master')) {
+            return 'master';
+        }
+    }
+    catch (_) {
+        // fall through
+    }
+    throw new Error("Could not detect primary branch. Neither 'main' nor 'master' exists as a local branch.");
 }
-
 function resolveMainRepo() {
-  if (process.env.PRIMARY_WORKTREE) {return process.env.PRIMARY_WORKTREE;}
-
-  const { git, getCurrentBranch } = require('./git');
-  const { isStandaloneWorkflowLayout } = require('./product-config');
-  const cwd = process.cwd();
-  const primaryBranch = getPrimaryBranch(process.cwd(), git);
-  try {
-    const lines = git(['worktree', 'list', '--porcelain']).stdout.split('\n');
-    const worktrees = [];
-    let current = null;
-
-    for (const line of lines) {
-      if (line.startsWith('worktree ')) {
-        if (current) {worktrees.push(current);}
-        current = { path: line.slice('worktree '.length).trim(), branch: /** @type {string|null} */(null), bare: false };
-        continue;
-      }
-
-      if (!current) {continue;}
-
-      if (line.startsWith('branch ')) {
-        current.branch = line.slice('branch '.length).trim();
-      } else if (line === 'bare') {
-        current.bare = true;
-      } else if (line === '') {
-        worktrees.push(current);
-        current = null;
-      }
-    }
-
-    if (current) {worktrees.push(current);}
-
-    const primaryWorktree = worktrees.find(worktree => !worktree.bare && worktree.branch === `refs/heads/${primaryBranch}`);
-    if (primaryWorktree) {return primaryWorktree.path;}
-  } catch (error) {
-    // ignore git errors, fall through to error
-  }
-
-  try {
-    const currentBranch = getCurrentBranch(cwd);
-    const toplevel = git(['-C', cwd, 'rev-parse', '--show-toplevel']);
-    const repoRoot = (toplevel.stdout || '').trim();
-    if (toplevel.status === 0 && repoRoot) {
-      if (currentBranch === primaryBranch) {
-        return repoRoot;
-      }
-
-      // Fresh exported repos can already have a `.git` directory but still lack
-      // stable worktree metadata or a readable current branch. When draft runs
-      // from that standalone repo root, treat the current checkout as the
-      // primary repository so draft can create the first mission worktree.
-      if (
-        path.resolve(repoRoot) === path.resolve(cwd) &&
-        isStandaloneWorkflowLayout(repoRoot) &&
-        !currentBranch
-      ) {
-        return repoRoot;
-      }
-    }
-  } catch (_) {
-    // ignore git errors, fall through to error
-  }
-
-  throw new Error(
-    `Could not resolve primary repository. No worktree on '${primaryBranch}' branch found and PRIMARY_WORKTREE is not set. ` +
-    "Verify your worktree setup or set the PRIMARY_WORKTREE environment variable."
-  );
+    if (process.env.PRIMARY_WORKTREE) {
+        return process.env.PRIMARY_WORKTREE;
+    }
+    const cwd = process.cwd();
+    const primaryBranch = getPrimaryBranch(process.cwd(), gitModule.git);
+    try {
+        const lines = gitModule.git(['worktree', 'list', '--porcelain']).stdout.split('\n');
+        const worktrees = [];
+        let current = null;
+        for (const line of lines) {
+            if (line.startsWith('worktree ')) {
+                if (current) {
+                    worktrees.push(current);
+                }
+                current = { path: line.slice('worktree '.length).trim(), branch: null, bare: false };
+                continue;
+            }
+            if (!current) {
+                continue;
+            }
+            if (line.startsWith('branch ')) {
+                current.branch = line.slice('branch '.length).trim();
+            }
+            else if (line === 'bare') {
+                current.bare = true;
+            }
+            else if (line === '') {
+                worktrees.push(current);
+                current = null;
+            }
+        }
+        if (current) {
+            worktrees.push(current);
+        }
+        const primaryWorktree = worktrees.find(wt => !wt.bare && wt.branch === `refs/heads/${primaryBranch}`);
+        if (primaryWorktree) {
+            return primaryWorktree.path;
+        }
+    }
+    catch (_) {
+        // ignore git errors, fall through to error
+    }
+    try {
+        const currentBranch = gitModule.getCurrentBranch(cwd);
+        const toplevel = gitModule.git(['-C', cwd, 'rev-parse', '--show-toplevel']);
+        const repoRoot = (toplevel.stdout || '').trim();
+        if (toplevel.status === 0 && repoRoot) {
+            if (currentBranch === primaryBranch) {
+                return repoRoot;
+            }
+            if (node_path_1.default.resolve(repoRoot) === node_path_1.default.resolve(cwd) &&
+                (0, product_config_js_1.isStandaloneWorkflowLayout)(repoRoot) &&
+                !currentBranch) {
+                return repoRoot;
+            }
+        }
+    }
+    catch (_) {
+        // ignore git errors, fall through to error
+    }
+    throw new Error(`Could not resolve primary repository. No worktree on '${primaryBranch}' branch found and PRIMARY_WORKTREE is not set. ` +
+        "Verify your worktree setup or set the PRIMARY_WORKTREE environment variable.");
 }
-
 function getPrimaryWorktree() {
-  return resolveMainRepo();
+    return resolveMainRepo();
 }
-
 /** @param {string} slug @param {string} [mainRepo] */
 function conventionalWorktreePath(slug, mainRepo = getPrimaryWorktree()) {
-  const projectName = path.basename(mainRepo);
-  const pattern = resolveMissionAdapter(mainRepo).worktreePattern;
-  const rendered = pattern
-    .replaceAll('<repo>', projectName)
-    .replaceAll('<slug>', slug);
-  return path.resolve(mainRepo, rendered);
+    const projectName = node_path_1.default.basename(mainRepo);
+    const pattern = resolveMissionAdapter(mainRepo).worktreePattern;
+    const rendered = pattern
+        .replaceAll('<repo>', projectName)
+        .replaceAll('<slug>', slug);
+    return node_path_1.default.resolve(mainRepo, rendered);
 }
-
 /**
  * Conventional path for an auto-created *base* feature-branch worktree.
  *
@@ -201,10 +269,9 @@ function conventionalWorktreePath(slug, mainRepo = getPrimaryWorktree()) {
  */
 /** @param {string} baseBranch @param {string} [mainRepo] */
 function conventionalBaseWorktreePath(baseBranch, mainRepo = getPrimaryWorktree()) {
-  const safeName = String(baseBranch).replace(/[\\/]+/g, '-');
-  return conventionalWorktreePath(`base-${safeName}`, mainRepo);
+    const safeName = String(baseBranch).replace(/[\\/]+/g, '-');
+    return conventionalWorktreePath(`base-${safeName}`, mainRepo);
 }
-
 /**
  * Detect the branch HEAD is on at draft time, to be used as the mission base.
  *
@@ -219,31 +286,28 @@ function conventionalBaseWorktreePath(baseBranch, mainRepo = getPrimaryWorktree(
  */
 /** @param {string} [cwd] @param {{gitFn?: Function}} [options] */
 function detectLaunchBaseBranch(cwd = process.cwd(), options = {}) {
-  const { git } = require('./git');
-  /** @type {Function} */
-  const runner = options.gitFn || git;
-  const result = runner(['-C', cwd, 'branch', '--show-current']);
-  const branch = ((result && result.stdout) || '').trim();
-  if (!branch) {
-    return null;
-  }
-  const prefix = missionBranchPrefix(cwd);
-  if (branch.startsWith(prefix)) {
-    throw new Error(
-      `Cannot launch a mission from mission branch '${branch}': the '${prefix}' prefix is reserved. ` +
-      'Check out the feature branch or primary branch you want as the base before running draft.'
-    );
-  }
-  return branch;
+    /** @type {Function} */
+    const runner = options.gitFn || gitModule.git;
+    const result = runner(['-C', cwd, 'branch', '--show-current']);
+    const branch = ((result && result.stdout) || '').trim();
+    if (!branch) {
+        return null;
+    }
+    const prefix = missionBranchPrefix(cwd);
+    if (branch.startsWith(prefix)) {
+        throw new Error(`Cannot launch a mission from mission branch '${branch}': the '${prefix}' prefix is reserved. ` +
+            'Check out the feature branch or primary branch you want as the base before running draft.');
+    }
+    return branch;
 }
-
 /** @param {string} content */
 function parseBaseBranchLine(content) {
-  if (!content) {return null;}
-  const match = content.match(/^Base-Branch:\s*(\S+)\s*$/m);
-  return match ? match[1].trim() : null;
+    if (!content) {
+        return null;
+    }
+    const match = content.match(/^Base-Branch:\s*(\S+)\s*$/m);
+    return match ? match[1].trim() : null;
 }
-
 /**
  * Read the `Base-Branch:` line recorded in the mission's MISSION.md.
  *
@@ -251,48 +315,47 @@ function parseBaseBranchLine(content) {
  * is not on disk, falls back to reading it from the mission branch via
  * `git show <branch>:<path>`. Returns `null` when no `Base-Branch:` line exists
  * (every pre-existing mission), so callers fall back to the primary branch.
-  */
+ */
 /** @param {string} slug @param {string} [rootDir] @param {{gitFn?: Function}} [options] */
 function readRecordedBaseBranch(slug, rootDir = process.cwd(), options = {}) {
-  /** @type {Function | null} */
-  const gitFn = options.gitFn ?? null;
-  if (!slug) {return null;}
-
-  const missionDir = findMissionDir(slug, rootDir);
-  if (missionDir) {
-    const missionPath = path.join(missionDir, 'MISSION.md');
-    if (fs.existsSync(missionPath)) {
-      return parseBaseBranchLine(fs.readFileSync(missionPath, 'utf8'));
-    }
-  }
-
-  const { git } = require('./git');
-  const runner = gitFn || git;
-  const branch = missionBranchName(slug, rootDir);
-  const baseSlugMatch = slug.match(/^(task-\d+)/i);
-  const baseSlug = baseSlugMatch ? baseSlugMatch[1].toLowerCase() : slug;
-  const year = getMissionYear(slug, rootDir);
-  const adapterBaseDir = (path.relative(rootDir, missionBaseDir(rootDir)) || '.').split(path.sep).join('/');
-  const paths = Array.from(new Set([
-    path.posix.join(adapterBaseDir, year, slug, 'MISSION.md'),
-    path.posix.join(adapterBaseDir, year, baseSlug, 'MISSION.md')
-  ]));
-
-  for (const p of paths) {
-    try {
-      const res = runner(['-C', rootDir, 'show', `${branch}:${p}`]);
-      if (res && res.status === 0) {
-        const parsed = parseBaseBranchLine(res.stdout);
-        if (parsed) {return parsed;}
-      }
-    } catch (_) {
-      // ignore and try the next candidate
-    }
-  }
-
-  return null;
+    /** @type {Function | null} */
+    const gitFn = options.gitFn ?? null;
+    if (!slug) {
+        return null;
+    }
+    const missionDir = findMissionDir(slug, rootDir);
+    if (missionDir) {
+        const missionPath = node_path_1.default.join(missionDir, 'MISSION.md');
+        if (fs.existsSync(missionPath)) {
+            return parseBaseBranchLine(fs.readFileSync(missionPath, 'utf8'));
+        }
+    }
+    const runner = gitFn || gitModule.git;
+    const branch = missionBranchName(slug, rootDir);
+    const baseSlugMatch = slug.match(/^(task-\d+)/i);
+    const baseSlug = baseSlugMatch ? baseSlugMatch[1].toLowerCase() : slug;
+    const year = getMissionYear(slug, rootDir);
+    const adapterBaseDir = (node_path_1.default.relative(rootDir, missionBaseDir(rootDir)) || '.').split(node_path_1.default.sep).join('/');
+    const files = Array.from(new Set([
+        node_path_1.default.posix.join(adapterBaseDir, year, slug, 'MISSION.md'),
+        node_path_1.default.posix.join(adapterBaseDir, year, baseSlug, 'MISSION.md')
+    ]));
+    for (const f of files) {
+        try {
+            const res = runner(['-C', rootDir, 'show', `${branch}:${f}`]);
+            if (res && res.status === 0) {
+                const parsed = parseBaseBranchLine(res.stdout);
+                if (parsed) {
+                    return parsed;
+                }
+            }
+        }
+        catch (_) {
+            // ignore and try the next candidate
+        }
+    }
+    return null;
 }
-
 /**
  * Resolve the base branch a mission was drafted from.
  *
@@ -301,34 +364,41 @@ function readRecordedBaseBranch(slug, rootDir = process.cwd(), options = {}) {
  */
 /** @param {string} slug @param {string} [rootDir] @param {{gitFn?: Function}} [options] */
 function resolveMissionBaseBranch(slug, rootDir = process.cwd(), options = {}) {
-  /** @type {Function | null} */
-  const gitFn = options.gitFn ?? null;
-  const recorded = readRecordedBaseBranch(slug, rootDir, { gitFn: /** @type {Function|undefined} */(gitFn) });
-  if (recorded) {return recorded;}
-  return gitFn ? getPrimaryBranch(rootDir, gitFn) : getPrimaryBranch(rootDir);
+    /** @type {Function | null} */
+    const gitFn = options.gitFn ?? null;
+    const recorded = readRecordedBaseBranch(slug, rootDir, { gitFn: gitFn });
+    if (recorded) {
+        return recorded;
+    }
+    return gitFn ? getPrimaryBranch(rootDir, gitFn) : getPrimaryBranch(rootDir);
 }
-
 /** @param {string} branchRef @param {Function} runner @param {string} mainRepo */
 function findWorktreeForBranch(branchRef, runner, mainRepo) {
-  const result = runner(['-C', mainRepo, 'worktree', 'list', '--porcelain']);
-  const lines = ((result && result.stdout) || '').split('\n');
-  let current = null;
-  for (const line of lines) {
-    if (line.startsWith('worktree ')) {
-      current = { path: line.slice('worktree '.length).trim(), branch: null };
-    } else if (!current) {
-      continue;
-    } else if (line.startsWith('branch ')) {
-      current.branch = line.slice('branch '.length).trim();
-    } else if (line === '') {
-      if (current.branch === branchRef) {return current.path;}
-      current = null;
-    }
-  }
-  if (current && current.branch === branchRef) {return current.path;}
-  return null;
+    const result = runner(['-C', mainRepo, 'worktree', 'list', '--porcelain']);
+    const lines = ((result && result.stdout) || '').split('\n');
+    let current = null;
+    for (const line of lines) {
+        if (line.startsWith('worktree ')) {
+            current = { path: line.slice('worktree '.length).trim(), branch: null };
+        }
+        else if (!current) {
+            continue;
+        }
+        else if (line.startsWith('branch ')) {
+            current.branch = line.slice('branch '.length).trim();
+        }
+        else if (line === '') {
+            if (current.branch === branchRef) {
+                return current.path;
+            }
+            current = null;
+        }
+    }
+    if (current && current.branch === branchRef) {
+        return current.path;
+    }
+    return null;
 }
-
 /**
  * Resolve the worktree the mission integrates back into.
  *
@@ -340,376 +410,336 @@ function findWorktreeForBranch(branchRef, runner, mainRepo) {
  */
 /** @param {string} slug @param {{rootDir?: string, gitFn?: Function}} [options] */
 function resolveBaseWorktree(slug, options = {}) {
-  /** @type {string} */
-  const rootDir = options.rootDir || process.cwd();
-  /** @type {Function | null} */
-  const gitFn = options.gitFn ?? null;
-  const { git } = require('./git');
-  const runner = gitFn || git;
-  const base = resolveMissionBaseBranch(slug, rootDir, { gitFn: /** @type {Function|undefined} */(gitFn) });
-  const primary = gitFn ? getPrimaryBranch(rootDir, gitFn) : getPrimaryBranch(rootDir);
-  if (base === primary) {
-    return getPrimaryWorktree();
-  }
-
-  const mainRepo = getPrimaryWorktree();
-  const baseRef = `refs/heads/${base}`;
-
-  const existing = findWorktreeForBranch(baseRef, runner, mainRepo);
-  if (existing) {return existing;}
-
-  const branchExists = runner(['-C', mainRepo, 'show-ref', '--verify', '--quiet', baseRef]);
-  if (!branchExists || branchExists.status !== 0) {
-    throw new Error(
-      `Mission ${slug} records base branch '${base}' but it does not exist locally. ` +
-      `Create or fetch the '${base}' base branch before integrating.`
-    );
-  }
-
-  const worktreePath = conventionalBaseWorktreePath(base, mainRepo);
-  const addResult = runner(['-C', mainRepo, 'worktree', 'add', worktreePath, base]);
-  if (!addResult || addResult.status !== 0) {
-    const detail = addResult ? [addResult.stdout, addResult.stderr].filter(Boolean).join('\n').trim() : '';
-    throw new Error(
-      `Could not create base worktree for base branch '${base}' at ${worktreePath}${detail ? `: ${detail}` : '.'}`
-    );
-  }
-  return worktreePath;
+    const rootDir = options.rootDir || process.cwd();
+    /** @type {Function | null} */
+    const gitFn = options.gitFn ?? null;
+    const runner = gitFn || gitModule.git;
+    const base = resolveMissionBaseBranch(slug, rootDir, { gitFn: gitFn });
+    const primary = gitFn ? getPrimaryBranch(rootDir, gitFn) : getPrimaryBranch(rootDir);
+    if (base === primary) {
+        return getPrimaryWorktree();
+    }
+    const mainRepo = getPrimaryWorktree();
+    const baseRef = `refs/heads/${base}`;
+    const existing = findWorktreeForBranch(baseRef, runner, mainRepo);
+    if (existing) {
+        return existing;
+    }
+    const branchExists = runner(['-C', mainRepo, 'show-ref', '--verify', '--quiet', baseRef]);
+    if (!branchExists || branchExists.status !== 0) {
+        throw new Error(`Mission ${slug} records base branch '${base}' but it does not exist locally. ` +
+            `Create or fetch the '${base}' base branch before integrating.`);
+    }
+    const worktreePath = conventionalBaseWorktreePath(base, mainRepo);
+    const addResult = runner(['-C', mainRepo, 'worktree', 'add', worktreePath, base]);
+    if (!addResult || addResult.status !== 0) {
+        const detail = addResult ? [addResult.stdout, addResult.stderr].filter(Boolean).join('\n').trim() : '';
+        throw new Error(`Could not create base worktree for base branch '${base}' at ${worktreePath}${detail ? ': ' + detail : '.'}`);
+    }
+    return worktreePath;
 }
-
 /** @param {string|undefined} [slug] @param {string} [rootDir] */
 function getMissionYear(slug = undefined, rootDir = process.cwd()) {
-  if (process.env.MISSION_YEAR_OVERRIDE) {
-    return process.env.MISSION_YEAR_OVERRIDE;
-  }
-
-  // Flat default layout has no year tier. Keep returning the current year for
-  // callers that use it as metadata, but do not scan it as a path component.
-  const hasExplicitConfig = fs.existsSync(path.join(rootDir, 'workflow.config.json'));
-  if (slug && (missionUsesYearTier(rootDir) || (!hasExplicitConfig && fs.existsSync(path.join(rootDir, 'docs', 'missions'))))) {
-    const baseDir = missionUsesYearTier(rootDir)
-      ? missionBaseDir(rootDir)
-      : path.join(rootDir, 'docs', 'missions');
-    if (fs.existsSync(baseDir)) {
-      try {
-        const stat = fs.statSync(baseDir);
-        if (!stat.isDirectory()) {
-          return new Date().getFullYear().toString();
-        }
-      } catch (_) {
-        return new Date().getFullYear().toString();
-      }
-      const years = fs.readdirSync(baseDir)
-        .filter(d => /^\d{4}$/.test(d))
-        .sort((/** @type {string} */ a, /** @type {string} */ b) => b.localeCompare(a)); // Descending order (newest first)
-
-      /** @type {string} */
-      const slugStr = slug;
-      const candidateSlugs = [slugStr.toLowerCase()];
-      const baseTaskMatch = slugStr.match(/^(task-\d+)/i);
-      if (baseTaskMatch) {
-        candidateSlugs.push(baseTaskMatch[1].toLowerCase());
-      }
-
-      for (const year of years) {
-        for (const s of candidateSlugs) {
-          const missionDir = path.join(baseDir, year, s);
-          if (fs.existsSync(missionDir)) {
-            return year;
-          }
+    if (process.env.MISSION_YEAR_OVERRIDE) {
+        return process.env.MISSION_YEAR_OVERRIDE;
+    }
+    const hasExplicitConfig = fs.existsSync(node_path_1.default.join(rootDir, 'workflow.config.json'));
+    if (slug && (missionUsesYearTier(rootDir) || (!hasExplicitConfig && fs.existsSync(node_path_1.default.join(rootDir, 'docs', 'missions'))))) {
+        const baseDir = missionUsesYearTier(rootDir)
+            ? missionBaseDir(rootDir)
+            : node_path_1.default.join(rootDir, 'docs', 'missions');
+        if (fs.existsSync(baseDir)) {
+            try {
+                const stat = fs.statSync(baseDir);
+                if (!stat.isDirectory()) {
+                    return new Date().getFullYear().toString();
+                }
+            }
+            catch (_) {
+                return new Date().getFullYear().toString();
+            }
+            const years = fs.readdirSync(baseDir)
+                .filter(d => /^\d{4}$/.test(d))
+                .sort((a, b) => b.localeCompare(a));
+            const slugStr = slug;
+            const candidateSlugs = [slugStr.toLowerCase()];
+            const baseTaskMatch = slugStr.match(/^(task-\d+)/i);
+            if (baseTaskMatch) {
+                candidateSlugs.push(baseTaskMatch[1].toLowerCase());
+            }
+            for (const year of years) {
+                for (const s of candidateSlugs) {
+                    const missionDir = node_path_1.default.join(baseDir, year, s);
+                    if (fs.existsSync(missionDir)) {
+                        return year;
+                    }
+                }
+            }
         }
-      }
     }
-  }
-
-  return new Date().getFullYear().toString();
+    return new Date().getFullYear().toString();
 }
-
 /** @param {string} slug @param {string} [rootDir] @param {{missionPath?: string}} options */
 function findMissionDir(slug, rootDir = process.cwd(), options = {}) {
-  /** @type {{missionPath?: string}} */
-  const opts = options;
-  if (opts.missionPath && fs.existsSync(opts.missionPath)) {
-    return fs.statSync(opts.missionPath).isDirectory() ? opts.missionPath : path.dirname(opts.missionPath);
-  }
-  if (!slug) {return null;}
-  const missionDir = missionDirForSlug(rootDir, slug);
-  if (fs.existsSync(missionDir)) {return missionDir;}
-
-  // Hardening: Try base task ID if slug has a suffix (e.g., task-1004-modern -> task-1004)
-  const baseTaskMatch = slug.match(/^(task-\d+)/i);
-  if (baseTaskMatch) {
-    const baseSlug = baseTaskMatch[1].toLowerCase();
-    const baseMissionDir = missionDirForSlug(rootDir, baseSlug);
-    if (fs.existsSync(baseMissionDir)) {return baseMissionDir;}
-  }
-
-  // Read compatibility during the TASK-1243 migration window. New no-config
-  // missions are created flat, but existing year-tier history remains readable.
-  const legacyBaseDir = path.join(rootDir, 'docs', 'missions');
-  if (!missionUsesYearTier(rootDir) && !fs.existsSync(path.join(rootDir, 'workflow.config.json')) && fs.existsSync(legacyBaseDir)) {
-    const year = getMissionYear(slug, rootDir);
-    const legacyMissionDir = path.join(legacyBaseDir, year, slug);
-    if (fs.existsSync(legacyMissionDir)) {return legacyMissionDir;}
+    const opts = options;
+    if (opts.missionPath && fs.existsSync(opts.missionPath)) {
+        return fs.statSync(opts.missionPath).isDirectory() ? opts.missionPath : node_path_1.default.dirname(opts.missionPath);
+    }
+    if (!slug) {
+        return null;
+    }
+    const missionDir = missionDirForSlug(rootDir, slug);
+    if (fs.existsSync(missionDir)) {
+        return missionDir;
+    }
+    const baseTaskMatch = slug.match(/^(task-\d+)/i);
     if (baseTaskMatch) {
-      const legacyBaseMissionDir = path.join(legacyBaseDir, year, baseTaskMatch[1].toLowerCase());
-      if (fs.existsSync(legacyBaseMissionDir)) {return legacyBaseMissionDir;}
+        const baseSlug = baseTaskMatch[1].toLowerCase();
+        const baseMissionDir = missionDirForSlug(rootDir, baseSlug);
+        if (fs.existsSync(baseMissionDir)) {
+            return baseMissionDir;
+        }
     }
-  }
-
-  return null;
+    const legacyBaseDir = node_path_1.default.join(rootDir, 'docs', 'missions');
+    if (!missionUsesYearTier(rootDir) && !fs.existsSync(node_path_1.default.join(rootDir, 'workflow.config.json')) && fs.existsSync(legacyBaseDir)) {
+        const year = getMissionYear(slug, rootDir);
+        const legacyMissionDir = node_path_1.default.join(legacyBaseDir, year, slug);
+        if (fs.existsSync(legacyMissionDir)) {
+            return legacyMissionDir;
+        }
+        if (baseTaskMatch) {
+            const legacyBaseMissionDir = node_path_1.default.join(legacyBaseDir, year, baseTaskMatch[1].toLowerCase());
+            if (fs.existsSync(legacyBaseMissionDir)) {
+                return legacyBaseMissionDir;
+            }
+        }
+    }
+    return null;
 }
-
 /** @param {string} slug @param {{cwd?: string, gitFn?: Function}} [options] */
 function resolveWorktree(slug, options = {}) {
-  /** @type {string} */
-  const cwd = options.cwd || process.cwd();
-  /** @type {Function | null} */
-  const gitFn = options.gitFn ?? null;
-  const { git, getCurrentBranch } = require('./git');
-  const runGit = gitFn || git;
-  const branchRef = missionBranchRef(slug, cwd);
-
-  try {
-    const lines = runGit(['worktree', 'list', '--porcelain']).stdout.split('\n');
-    const matches = [];
-    let current = null;
-
-    for (const line of lines) {
-      if (line.startsWith('worktree ')) {
-        current = { path: line.slice('worktree '.length).trim(), branch: null, prunable: false };
-        continue;
-      }
-      if (!current) {continue;}
-      if (line.startsWith('branch ')) {
-        current.branch = line.slice('branch '.length).trim();
-      } else if (line.startsWith('prunable ')) {
-        current.prunable = true;
-      } else if (line === '') {
-        if (current.branch === branchRef) {matches.push(current);}
-        current = null;
-      }
-    }
-
-    if (current && current.branch === branchRef) {matches.push(current);}
-
-    const liveMatches = matches.filter(match => !match.prunable);
-    if (liveMatches.length > 0) {
-      const cwdMatch = liveMatches.find(match => cwd === match.path || cwd.startsWith(`${match.path}/`));
-      if (cwdMatch) {return cwdMatch.path;}
-      return liveMatches[0].path;
-    }
-  } catch (_) {
-    // fall through to branch-based cwd fallback
-  }
-
-  try {
-    if (getCurrentBranch(cwd) === missionBranchName(slug, cwd)) {
-      return cwd;
-    }
-  } catch (_) {
-    // fall through to null
-  }
-
-  return null;
+    const cwd = options.cwd || process.cwd();
+    /** @type {Function | null} */
+    const gitFn = options.gitFn ?? null;
+    const runGit = gitFn || gitModule.git;
+    const branchRef = missionBranchRef(slug, cwd);
+    try {
+        const lines = runGit(['worktree', 'list', '--porcelain']).stdout.split('\n');
+        const matches = [];
+        let current = null;
+        for (const line of lines) {
+            if (line.startsWith('worktree ')) {
+                current = { path: line.slice('worktree '.length).trim(), branch: null, prunable: false };
+                continue;
+            }
+            if (!current) {
+                continue;
+            }
+            if (line.startsWith('branch ')) {
+                current.branch = line.slice('branch '.length).trim();
+            }
+            else if (line.startsWith('prunable ')) {
+                current.prunable = true;
+            }
+            else if (line === '') {
+                if (current.branch === branchRef) {
+                    matches.push(current);
+                }
+                current = null;
+            }
+        }
+        if (current && current.branch === branchRef) {
+            matches.push(current);
+        }
+        const liveMatches = matches.filter(m => !m.prunable);
+        if (liveMatches.length > 0) {
+            const cwdMatch = liveMatches.find(m => cwd === m.path || cwd.startsWith(m.path + '/'));
+            if (cwdMatch) {
+                return cwdMatch.path;
+            }
+            return liveMatches[0].path;
+        }
+    }
+    catch (_) {
+        // fall through to branch-based cwd fallback
+    }
+    try {
+        if (gitModule.getCurrentBranch(cwd) === missionBranchName(slug, cwd)) {
+            return cwd;
+        }
+    }
+    catch (_) {
+        // fall through to null
+    }
+    return null;
 }
-
 /** @param {string} missionDir */
 function findCheckpoints(missionDir) {
-  const files = fs.readdirSync(missionDir);
-  return files
-    .filter(f => /^(CHECKPOINT_|CP-\d+).*\.md$/i.test(f))
-    .sort(compareCheckpointFiles)
-    .map(f => path.join(missionDir, f));
+    const files = fs.readdirSync(missionDir);
+    return files
+        .filter(f => /^(CHECKPOINT_|CP-\d+).*\.md$/i.test(f))
+        .sort(compareCheckpointFiles)
+        .map(f => node_path_1.default.join(missionDir, f));
 }
-
 /** @param {string} a @param {string} b */
 function compareCheckpointFiles(a, b) {
-  const aOrder = checkpointOrder(a);
-  const bOrder = checkpointOrder(b);
-
-  if (aOrder !== bOrder) {
-    return aOrder - bOrder;
-  }
-
-  return a.localeCompare(b);
+    const aOrder = checkpointOrder(a);
+    const bOrder = checkpointOrder(b);
+    if (aOrder !== bOrder) {
+        return aOrder - bOrder;
+    }
+    return a.localeCompare(b);
 }
-
 /** @param {string} filename */
 function checkpointOrder(filename) {
-  const numericMatch = filename.match(/(?:CP-|CHECKPOINT_)(\d+)/i);
-  if (numericMatch) {
-    return Number(numericMatch[1]);
-  }
-
-  return Number.MAX_SAFE_INTEGER;
+    const numericMatch = filename.match(/(?:CP-|CHECKPOINT_)(\d+)/i);
+    if (numericMatch) {
+        return Number(numericMatch[1]);
+    }
+    return Number.MAX_SAFE_INTEGER;
 }
-
 /** @param {string} filePath */
 function getFirstLine(filePath) {
-  const content = fs.readFileSync(filePath, 'utf8');
-  return content.split('\n')[0].replace(/^#+\s*/, '').trim();
+    const content = fs.readFileSync(filePath, 'utf8');
+    return content.split('\n')[0].replace(/^#+\s*/, '').trim();
 }
-
 /** @param {string} [slug] */
 function missionTitle(slug) {
-  if (!slug) {return null;}
-  const missionDir = findMissionDir(slug);
-  if (!missionDir) {return null;}
-
-  const missionPath = path.join(missionDir, 'MISSION.md');
-  if (!fs.existsSync(missionPath)) {return null;}
-
-  const firstLine = fs.readFileSync(missionPath, 'utf8').split('\n')[0] || '';
-  return firstLine.replace(/^#\s*Mission:\s*/i, '').trim() || null;
+    if (!slug) {
+        return null;
+    }
+    const missionDir = findMissionDir(slug);
+    if (!missionDir) {
+        return null;
+    }
+    const missionPath = node_path_1.default.join(missionDir, 'MISSION.md');
+    if (!fs.existsSync(missionPath)) {
+        return null;
+    }
+    const firstLine = fs.readFileSync(missionPath, 'utf8').split('\n')[0] || '';
+    return firstLine.replace(/^#\s*Mission:\s*/i, '').trim() || null;
 }
-
-const SUPPORTED_VERIFY_AREAS = new Set(['docs', 'workflow', 'web', 'server', 'auth', 'android', 'k8s', 'deps', 'all']);
-
+exports.SUPPORTED_VERIFY_AREAS = new Set(['docs', 'workflow', 'web', 'server', 'auth', 'android', 'k8s', 'deps', 'all']);
 /** @param {string} [area] */
 function normalizeVerifyArea(area) {
-  if (!area) {return 'docs';}
-  if (area === 'auth-server') {return 'auth';}
-  return SUPPORTED_VERIFY_AREAS.has(area) ? area : area;
+    if (!area) {
+        return 'docs';
+    }
+    if (area === 'auth-server') {
+        return 'auth';
+    }
+    return exports.SUPPORTED_VERIFY_AREAS.has(area) ? area : area;
 }
-
 /** @param {string} content */
 function detectMissionAreaFromContent(content) {
-  // Capture the area argument after a verification-script invocation. Matches only
-  // scripts with recognized extensions (.sh, .bash, .py, .rb) or bare executables
-  // (no dots) referenced via `./` or `../`. The area argument must sit at end-of-line
-  // to prevent prose-matched paths (e.g. "run ./scripts/deploy.sh server before merge")
-  // from being mistaken for gate invocations. Falls back to `docs` when none found.
-  const gateMatch = content.match(
-    /(?:^|\s)(?:\.{1,2}\/[\w.\/-]+\.(?:sh|bash|py|rb)|\.{1,2}\/[a-z][\w-]*)\s+([a-zA-Z0-9_-]+)\s*(?:$|\n)/m
-  );
-  return normalizeVerifyArea(gateMatch ? gateMatch[1] : 'docs');
+    const gateMatch = content.match(/(?:^|\s)(?:\.{1,2}\/[\w.\/-]+\.(?:sh|bash|py|rb)|\.{1,2}\/[a-z][\w-]*)\s+([a-zA-Z0-9_-]+)\s*(?:$|\n)/m);
+    return normalizeVerifyArea(gateMatch ? gateMatch[1] : 'docs');
 }
-
-function findMissionArea(/** @type {string} */ missionDir) {
-  const missionPath = path.join(missionDir, 'MISSION.md');
-  if (!fs.existsSync(missionPath)) {return 'docs';}
-
-  const content = fs.readFileSync(missionPath, 'utf8');
-  return detectMissionAreaFromContent(content);
+function findMissionArea(missionDir) {
+    const missionPath = node_path_1.default.join(missionDir, 'MISSION.md');
+    if (!fs.existsSync(missionPath)) {
+        return 'docs';
+    }
+    const content = fs.readFileSync(missionPath, 'utf8');
+    return detectMissionAreaFromContent(content);
 }
-
 /** @param {{commandRunner?: Function}} [options] */
 function graphifyAvailable(options = {}) {
-  /** @type {Function | null} */
-  const commandRunner = options.commandRunner ?? null;
-  const run = commandRunner || require('./git').run;
-  return probeGraphifyAvailability({ commandRunner: run }).available;
+    const commandRunner = options.commandRunner ?? null;
+    const cmdRunner = commandRunner || gitModule.run;
+    return probeGraphifyAvailability({ commandRunner: cmdRunner }).available;
 }
-
 /** @returns {string[]} */
 function graphifyCommandCandidates() {
-  /** @type {string[]} */
-  const candidates = [];
-  const seen = new Set();
-
-  /** @param {string} candidate */
-  const pushCandidate = candidate => {
-    if (!candidate || seen.has(candidate)) {return;}
-    seen.add(candidate);
-    candidates.push(candidate);
-  };
-
-  if (process.env.GRAPHIFY_BIN) {pushCandidate(process.env.GRAPHIFY_BIN);}
-  pushCandidate('graphify');
-  pushCandidate(path.join(os.homedir(), '.local', 'bin', 'graphify'));
-
-  return candidates;
+    const candidates = [];
+    const seen = new Set();
+    const pushCandidate = (candidate) => {
+        if (!candidate || seen.has(candidate)) {
+            return;
+        }
+        seen.add(candidate);
+        candidates.push(candidate);
+    };
+    if (process.env.GRAPHIFY_BIN) {
+        pushCandidate(process.env.GRAPHIFY_BIN);
+    }
+    pushCandidate('graphify');
+    pushCandidate(node_path_1.default.join(node_os_1.default.homedir(), '.local', 'bin', 'graphify'));
+    return candidates;
 }
-
 /** @param {{commandRunner?: Function}} [options] */
 function probeGraphifyAvailability(options = {}) {
-  /** @type {Function | null} */
-  const commandRunner = options.commandRunner ?? null;
-  const run = commandRunner || require('./git').run;
-  for (const command of graphifyCommandCandidates()) {
-    try {
-      const result = run(command, ['--help']);
-      return {
-        available: result.status !== null && result.status !== undefined,
-        command,
-        status: result.status ?? null
-      };
-    } catch (/** @type {unknown} */ error) {
-      /** @type {Error & {code?: string}} */
-      const e = /** @type {Error & {code?: string}} */(error);
-      if (e && e.code === 'ENOENT') {
-        continue;
-      }
-      return {
-        available: false,
-        reason: 'probe-failed',
-        command,
-        error
-      };
-    }
-  }
-
-  return { available: false, reason: 'missing-command' };
+    const commandRunner = options.commandRunner ?? null;
+    const cmdRunner = commandRunner || gitModule.run;
+    for (const command of graphifyCommandCandidates()) {
+        try {
+            const result = cmdRunner(command, ['--help']);
+            return {
+                available: result.status !== null && result.status !== undefined,
+                command,
+                status: result.status ?? null
+            };
+        }
+        catch (error) {
+            const e = error;
+            if (e && e.code === 'ENOENT') {
+                continue;
+            }
+            return {
+                available: false,
+                reason: 'probe-failed',
+                command,
+                error
+            };
+        }
+    }
+    return { available: false, reason: 'missing-command' };
 }
-
 /**
  * @param {{rootDir?: string, commandRunner?: Function, log?: Function, startMessage?: string, failureHint?: string}} [options]
  */
+/** @param {{rootDir?: string, commandRunner?: Function, log?: Function, startMessage?: string, failureHint?: string}} [options] */
 function updateGraphifyKnowledgeGraph(options = {}) {
-  /** @type {string} */
-  const rootDir = options.rootDir || process.cwd();
-  /** @type {Function | undefined} */
-  const commandRunner = options.commandRunner;
-  /** @type {Function} */
-  const log = options.log || fmt.log.plain;
-  /** @type {string} */
-  const startMessage = options.startMessage || 'Updating graphify knowledge graph...';
-  /** @type {string} */
-  const failureHint = options.failureHint || 'Continuing without blocking workflow.';
-  /** @param {string} command @param {string[]} args @param {{stdio?: string}} [opts] */
-  const run = commandRunner || ((/** @type {string} */ command, /** @type {string[]} */ args, /** @type {{stdio?: string}} */ opts) => require('./git').run(command, args, opts));
-  const probe = probeGraphifyAvailability({ commandRunner: run });
-  if (!probe.available) {
-    if (probe.reason === 'missing-command') {
-      log(fmt.status('WARN', 'graphify not found in PATH. Skipping knowledge graph update.'));
-      return { updated: false, skipped: true, reason: 'missing-command' };
-    }
-
-    const probeError = probe.error && typeof probe.error === 'object' && 'message' in probe.error ? /** @type{{message:string}} */(probe.error).message : 'unknown probe failure';
-    log(fmt.status('WARN', `graphify probe failed (${probeError}). Skipping knowledge graph update.`));
-    return { updated: false, skipped: true, reason: 'probe-failed' };
-  }
-
-  log(fmt.status('INFO', startMessage));
-  const result = run(probe.command, ['update', '.'], {
-    cwd: rootDir,
-    stdio: 'inherit'
-  });
-
-  if (result.status !== 0) {
-    log(fmt.status('WARN', `graphify update failed with status ${result.status}. ${failureHint}`));
-    return { updated: false, skipped: true, reason: 'update-failed', status: result.status };
-  }
-
-  return { updated: true, skipped: false };
+    const rootDir = options.rootDir || process.cwd();
+    const commandRunner = options.commandRunner;
+    const logFn = options.log || fmt.log.plain;
+    const startMessage = options.startMessage || 'Updating graphify knowledge graph...';
+    const failureHint = options.failureHint || 'Continuing without blocking workflow.';
+    const cmdRunner = commandRunner || gitModule.run;
+    const probe = probeGraphifyAvailability({ commandRunner: cmdRunner });
+    if (!probe.available) {
+        if (probe.reason === 'missing-command') {
+            logFn(fmt.status('WARN', 'graphify not found in PATH. Skipping knowledge graph update.'));
+            return { updated: false, skipped: true, reason: 'missing-command' };
+        }
+        const probeError = probe.error && typeof probe.error === 'object' && 'message' in probe.error ? probe.error.message : 'unknown probe failure';
+        logFn(fmt.status('WARN', `graphify probe failed (${probeError}). Skipping knowledge graph update.`));
+        return { updated: false, skipped: true, reason: 'probe-failed' };
+    }
+    logFn(fmt.status('INFO', startMessage));
+    const result = cmdRunner(probe.command, ['update', '.'], {
+        cwd: rootDir,
+        stdio: 'inherit'
+    });
+    if (result.status !== 0) {
+        logFn(fmt.status('WARN', `graphify update failed with status ${result.status}. ${failureHint}`));
+        return { updated: false, skipped: true, reason: 'update-failed', status: result.status };
+    }
+    return { updated: true, skipped: false };
 }
-
 /** @param {string} rootDir @param {string} slug */
 function missionPathForSlug(rootDir, slug) {
-  return path.join(missionDirForSlug(rootDir, slug), 'MISSION.md');
+    return node_path_1.default.join(missionDirForSlug(rootDir, slug), 'MISSION.md');
 }
-
 /** @param {string} rootDir @param {string} slug */
 function missionDirForSlug(rootDir, slug) {
-  const parts = [missionBaseDir(rootDir)];
-  if (missionUsesYearTier(rootDir)) {
-    parts.push(getMissionYear(slug, rootDir));
-  }
-  parts.push(slug);
-  return path.join(...parts);
+    const parts = [missionBaseDir(rootDir)];
+    if (missionUsesYearTier(rootDir)) {
+        parts.push(getMissionYear(slug, rootDir));
+    }
+    parts.push(slug);
+    return node_path_1.default.join(...parts);
 }
-
 /**
  * Infer mission slug from current context:
  * 1. Explicit slugCandidate (task-NNN)
@@ -722,53 +752,53 @@ function missionDirForSlug(rootDir, slug) {
  */
 /** @param {string} [slugCandidate] */
 function inferSlug(slugCandidate) {
-  if (isMissionSlugCandidate(slugCandidate)) {
-    return /** @type{string} */(slugCandidate).toLowerCase();
-  }
-
-  const { git, getCurrentBranch } = require('./git');
-
-  // 1. Check branch
-  try {
-    const branch = getCurrentBranch();
-    const fromBranch = extractSlugFromBranch(branch);
-    if (fromBranch) {return fromBranch;}
-  } catch (_) {
-    // ignore
-  }
-
-  // 3. Check directory name
-  const cwd = process.cwd();
-  const dirName = path.basename(cwd);
-  const dirSlugMatch = dirName.match(/((?:task|adhoc)-[a-z0-9][a-z0-9-]*)$/i);
-  if (dirSlugMatch) {
-    return dirSlugMatch[1].toLowerCase();
-  }
-
-
-  // 3. Check worktree registry
-  try {
-    const lines = git(['worktree', 'list', '--porcelain']).stdout.split('\n');
-    let currentPath = null;
-    for (const line of lines) {
-      if (line.startsWith('worktree ')) {
-        currentPath = line.slice('worktree '.length).trim();
-      } else if (line.startsWith('branch ') && currentPath === cwd) {
-        const branch = line.slice('branch '.length).trim();
-        const shortBranch = branch.replace(/^refs\/heads\//, '');
-        const fromBranch = extractSlugFromBranch(shortBranch, cwd);
-        if (fromBranch) {return fromBranch;}
-      } else if (line === '') {
-        currentPath = null;
-      }
-    }
-  } catch (_) {
-    // ignore
-  }
-
-  return null;
+    if (slugCandidate && isMissionSlugCandidate(slugCandidate)) {
+        return slugCandidate.toLowerCase();
+    }
+    // 1. Check branch
+    try {
+        const branch = gitModule.getCurrentBranch();
+        const fromBranch = extractSlugFromBranch(branch);
+        if (fromBranch) {
+            return fromBranch;
+        }
+    }
+    catch (_) {
+        // ignore
+    }
+    // 3. Check directory name
+    const cwd = process.cwd();
+    const dirName = node_path_1.default.basename(cwd);
+    const dirSlugMatch = dirName.match(/((?:task|adhoc)-[a-z0-9][a-z0-9-]*)$/i);
+    if (dirSlugMatch) {
+        return dirSlugMatch[1].toLowerCase();
+    }
+    // 3. Check worktree registry
+    try {
+        const lines = gitModule.git(['worktree', 'list', '--porcelain']).stdout.split('\n');
+        let currentPath = null;
+        for (const line of lines) {
+            if (line.startsWith('worktree ')) {
+                currentPath = line.slice('worktree '.length).trim();
+            }
+            else if (line.startsWith('branch ') && currentPath === cwd) {
+                const branch = line.slice('branch '.length).trim();
+                const shortBranch = branch.replace(/^refs\/heads\//, '');
+                const fromBranch = extractSlugFromBranch(shortBranch, cwd);
+                if (fromBranch) {
+                    return fromBranch;
+                }
+            }
+            else if (line === '') {
+                currentPath = null;
+            }
+        }
+    }
+    catch (_) {
+        // ignore
+    }
+    return null;
 }
-
 /**
  * Parse files with merge conflicts from the output of `git merge --no-commit --no-ff`.
  *
@@ -781,28 +811,33 @@ function inferSlug(slugCandidate) {
  */
 /** @param {string} output */
 function parseConflictFilesFromMergeOutput(output) {
-  const seen = new Set();
-  const files = [];
-  for (const line of output.split('\n')) {
-    if (!line.startsWith('CONFLICT')) {continue;}
-    // "Merge conflict in <file>" pattern (content, add/add, rename/rename, etc.)
-    const inMatch = line.match(/Merge conflict in (.+)$/);
-    if (inMatch) {
-      const f = inMatch[1].trim();
-      if (f && !seen.has(f)) { seen.add(f); files.push(f); }
-      continue;
-    }
-    // "CONFLICT (modify/delete): <file> deleted in ..." — file is right after the colon
-    const colonIdx = line.indexOf(':');
-    if (colonIdx !== -1) {
-      const rest = line.slice(colonIdx + 1).trim();
-      const f = rest.split(/\s+/)[0];
-      if (f && !seen.has(f)) { seen.add(f); files.push(f); }
-    }
-  }
-  return files;
+    const seen = new Set();
+    const files = [];
+    for (const line of output.split('\n')) {
+        if (!line.startsWith('CONFLICT')) {
+            continue;
+        }
+        const inMatch = line.match(/Merge conflict in (.+)$/);
+        if (inMatch) {
+            const f = inMatch[1].trim();
+            if (f && !seen.has(f)) {
+                seen.add(f);
+                files.push(f);
+            }
+            continue;
+        }
+        const colonIdx = line.indexOf(':');
+        if (colonIdx !== -1) {
+            const rest = line.slice(colonIdx + 1).trim();
+            const f = rest.split(/\s+/)[0];
+            if (f && !seen.has(f)) {
+                seen.add(f);
+                files.push(f);
+            }
+        }
+    }
+    return files;
 }
-
 /**
  * Identify files that would have merge conflicts when merging `branch` into `rootDir`.
  *
@@ -814,202 +849,166 @@ function parseConflictFilesFromMergeOutput(output) {
  * @param {{ gitRunner?: Function }} [options]
  * @returns {string[]} Relative paths of conflicting files (empty if no conflicts).
  */
-function getConflictFiles(rootDir, branch, { gitRunner } = {}) {
-  const { git: defaultGit } = require('./git');
-  const runner = gitRunner || defaultGit;
-
-  const merge = runner(['-C', rootDir, 'merge', '--no-commit', '--no-ff', branch]);
-  // Always clean up the in-progress merge (ignore abort errors for clean merges)
-  runner(['-C', rootDir, 'merge', '--abort']);
-
-  if (merge.status === 0) {return [];}
-
-  const output = [merge.stdout, merge.stderr].filter(Boolean).join('\n');
-  const conflictFiles = parseConflictFilesFromMergeOutput(output);
-
-  if (conflictFiles.length === 0) {
-    // Merge failed but no CONFLICT lines found — a non-conflict failure (dirty worktree,
-    // unfinished rebase, locked index, etc.). Surface the raw failure rather than returning
-    // an empty list, which callers would interpret as "no conflicts / merge was clean".
-    const summary = output.slice(0, 500) || '(no output)';
-    throw new Error(`git merge exited ${merge.status} with no CONFLICT lines — raw output:\n${summary}`);
-  }
-
-  return conflictFiles;
+/** @param {string} rootDir @param {string} branch @param {{gitRunner?: Function}} [options] */
+function getConflictFiles(rootDir, branch, options = {}) {
+    const runner = options.gitRunner || gitModule.git;
+    const merge = runner(['-C', rootDir, 'merge', '--no-commit', '--no-ff', branch]);
+    runner(['-C', rootDir, 'merge', '--abort']);
+    if (merge.status === 0) {
+        return [];
+    }
+    const output = [merge.stdout, merge.stderr].filter(Boolean).join('\n');
+    const conflictFiles = parseConflictFilesFromMergeOutput(output);
+    if (conflictFiles.length === 0) {
+        const summary = output.slice(0, 500) || '(no output)';
+        throw new Error(`git merge exited ${merge.status} with no CONFLICT lines — raw output:\n${summary}`);
+    }
+    return conflictFiles;
 }
-
 /** @param {string} rootDir @param {Function} [gitRunner] */
 function findLastNonNoiseCommit(rootDir, gitRunner) {
-  if (!gitRunner) {gitRunner = require('./git').git;}
-
-  const currentFullRef = gitRunner(['-C', rootDir, 'rev-parse', '--symbolic-full-name', 'HEAD'], { stdio: 'pipe' }).stdout.trim();
-
-  let commit = 'HEAD';
-  // safety break after 100 commits
-  for (let i = 0; i < 100; i++) {
-    const commitSha = gitRunner(['-C', rootDir, 'rev-parse', commit], { stdio: 'pipe' }).stdout.trim();
-
-    // Safety: If any OTHER branch (local or remote) contains this commit, it's a branch-off point.
-    // We must stop here to avoid rewriting history that other branches depend on.
-    const branchesContaining = gitRunner(['-C', rootDir, 'branch', '-a', '--contains', commitSha, '--format=%(refname)'], { stdio: 'pipe' })
-      .stdout.trim().split('\n').filter(Boolean);
-
-    // Safety: If this commit is already published to ANY remote, we MUST NOT amend it.
-    const isShared = branchesContaining.some((/** @type {string} */ b) => b.startsWith('refs/remotes/'));
-    if (isShared) {
-      return null;
-    }
-
-    // Safety: If any OTHER local branch contains this commit, it's the branch-off point.
-    // We must return null (not the commit) so the caller does not amend a commit another
-    // branch depends on — returning the commit here caused squash to rewrite it.
-    const otherLocalBranches = branchesContaining.filter((/** @type {string} */ b) => b !== currentFullRef && b.startsWith('refs/heads/'));
-    if (otherLocalBranches.length > 0) {
-      return null;
-    }
-
-    const log = gitRunner(['-C', rootDir, 'log', '-1', '--format=%s', commit], { stdio: 'pipe' });
-    if (log.status !== 0) {return null;}
-    const msg = log.stdout.trim();
-
-    const diff = gitRunner(['-C', rootDir, 'diff-tree', '--no-commit-id', '--name-only', '-r', commit], { stdio: 'pipe' });
-    if (diff.status !== 0) {return null;}
-
-    const files = diff.stdout.trim().split('\n').filter(Boolean);
-    if (files.length > 0) {
-      let isNoiseFiles = true;
-      for (const file of files) {
-        if (!file.startsWith('backlog/') && !file.endsWith('agents.local.json')) {
-          isNoiseFiles = false;
-          break;
+    const runner = gitRunner || gitModule.git;
+    const currentFullRef = runner(['-C', rootDir, 'rev-parse', '--symbolic-full-name', 'HEAD'], { stdio: 'pipe' }).stdout.trim();
+    let commit = 'HEAD';
+    for (let i = 0; i < 100; i++) {
+        const commitSha = runner(['-C', rootDir, 'rev-parse', commit], { stdio: 'pipe' }).stdout.trim();
+        const branchesContaining = runner(['-C', rootDir, 'branch', '-a', '--contains', commitSha, '--format=%(refname)'], { stdio: 'pipe' })
+            .stdout.trim().split('\n').filter(Boolean);
+        const isShared = branchesContaining.some((b) => b.startsWith('refs/remotes/'));
+        if (isShared) {
+            return null;
+        }
+        const otherLocalBranches = branchesContaining.filter((b) => b !== currentFullRef && b.startsWith('refs/heads/'));
+        if (otherLocalBranches.length > 0) {
+            return null;
+        }
+        const logResult = runner(['-C', rootDir, 'log', '-1', '--format=%s', commit], { stdio: 'pipe' });
+        if (logResult.status !== 0) {
+            return null;
+        }
+        const msg = logResult.stdout.trim();
+        const diffResult = runner(['-C', rootDir, 'diff-tree', '--no-commit-id', '--name-only', '-r', commit], { stdio: 'pipe' });
+        if (diffResult.status !== 0) {
+            return null;
         }
-      }
-
-      // Learnings from manual cleanup: check for automated/grooming message patterns
-      const isNoiseMsg = /^(Create task|Update task|backlog|assign|fixes|backlig|housekeeping|Archive task|fixing tasks|new mission|added new backlog task|docs: move|mission changes|random changes|new\/updated mission|task updates)/i.test(msg);
-
-      if (!isNoiseFiles || !isNoiseMsg) {
-        return commit;
-      }
-    } else {
-      // Empty commit (e.g. from a merge or manual empty commit) - stop here
-      return commit;
-    }
-    commit = `${commit}^`;
-  }
-  return null;
+        const files = diffResult.stdout.trim().split('\n').filter(Boolean);
+        if (files.length > 0) {
+            let isNoiseFiles = true;
+            for (const file of files) {
+                if (!file.startsWith('backlog/') && !file.endsWith('agents.local.json')) {
+                    isNoiseFiles = false;
+                    break;
+                }
+            }
+            const isNoiseMsg = /^(Create task|Update task|backlog|assign|fixes|backlig|housekeeping|Archive task|fixing tasks|new mission|added new backlog task|docs: move|mission changes|random changes|new\/updated mission|task updates)/i.test(msg);
+            if (!isNoiseFiles || !isNoiseMsg) {
+                return commit;
+            }
+        }
+        else {
+            return commit;
+        }
+        commit = `${commit}^`;
+    }
+    return null;
 }
-
 /** @param {string} rootDir @param {Function} [gitRunner] */
 function squashTrailingBacklogNoiseIntoPreviousMission(rootDir, gitRunner) {
-  if (!gitRunner) {gitRunner = require('./git').git;}
-
-  // Pattern violation fix: destructive history rewrite without a cleanliness gate.
-  // Refuse to squash if the index or worktree is dirty to avoid absorbing unrelated changes.
-  const status = gitRunner(['-C', rootDir, 'status', '--porcelain']).stdout.trim();
-  if (status) {
-    fmt.log.warn(`Skipping noise squash in ${rootDir}: worktree is not clean.`);
+    const runner = gitRunner || gitModule.git;
+    const status = runner(['-C', rootDir, 'status', '--porcelain']).stdout.trim();
+    if (status) {
+        fmt.log.warn(`Skipping noise squash in ${rootDir}: worktree is not clean.`);
+        return false;
+    }
+    const nonNoiseCommit = findLastNonNoiseCommit(rootDir, runner);
+    if (!nonNoiseCommit) {
+        return false;
+    }
+    const headSha = runner(['-C', rootDir, 'rev-parse', 'HEAD']).stdout.trim();
+    const baseSha = runner(['-C', rootDir, 'rev-parse', nonNoiseCommit]).stdout.trim();
+    if (headSha !== baseSha) {
+        fmt.log.info(`Squashing trailing backlog noise into ${baseSha.substring(0, 7)}...`);
+        const date = runner(['-C', rootDir, 'log', '-1', '--format=%aD', baseSha]).stdout.trim();
+        const resetResult = runner(['-C', rootDir, 'reset', '--soft', baseSha]);
+        if (resetResult.status !== 0) {
+            fmt.log.fail(`Failed to reset to ${baseSha}: ${resetResult.stderr}`);
+            return false;
+        }
+        const commitResult = runner(['-C', rootDir, 'commit', '--amend', '--no-edit', '--date', date]);
+        if (commitResult.status !== 0) {
+            fmt.log.fail(`Failed to amend commit: ${commitResult.stderr}`);
+            return false;
+        }
+        return true;
+    }
     return false;
-  }
-
-  const nonNoiseCommit = findLastNonNoiseCommit(rootDir, gitRunner);
-  if (!nonNoiseCommit) {return false;}
-
-  const headSha = gitRunner(['-C', rootDir, 'rev-parse', 'HEAD']).stdout.trim();
-  const baseSha = gitRunner(['-C', rootDir, 'rev-parse', nonNoiseCommit]).stdout.trim();
-
-  if (headSha !== baseSha) {
-    fmt.log.info(`Squashing trailing backlog noise into ${baseSha.substring(0, 7)}...`);
-    const date = gitRunner(['-C', rootDir, 'log', '-1', '--format=%aD', baseSha]).stdout.trim();
-    const resetResult = gitRunner(['-C', rootDir, 'reset', '--soft', baseSha]);
-    if (resetResult.status !== 0) {
-      fmt.log.fail(`Failed to reset to ${baseSha}: ${resetResult.stderr}`);
-      return false;
-    }
-    const commitResult = gitRunner(['-C', rootDir, 'commit', '--amend', '--no-edit', '--date', date]);
-    if (commitResult.status !== 0) {
-      fmt.log.fail(`Failed to amend commit: ${commitResult.stderr}`);
-      return false;
-    }
-    return true;
-  }
-  return false;
 }
-
 /** @param {string} rootDir @param {Function} [gitRunner] */
 function softResetTrailingBacklogNoise(rootDir, gitRunner) {
-  if (!gitRunner) {gitRunner = require('./git').git;}
-
-  // Refuse to reset if the index or worktree is dirty.
-  const status = gitRunner(['-C', rootDir, 'status', '--porcelain']).stdout.trim();
-  if (status) {
-    fmt.log.warn(`Skipping noise reset in ${rootDir}: worktree is not clean.`);
+    const runner = gitRunner || gitModule.git;
+    const status = runner(['-C', rootDir, 'status', '--porcelain']).stdout.trim();
+    if (status) {
+        fmt.log.warn(`Skipping noise reset in ${rootDir}: worktree is not clean.`);
+        return false;
+    }
+    const nonNoiseCommit = findLastNonNoiseCommit(rootDir, runner);
+    if (!nonNoiseCommit) {
+        return false;
+    }
+    const headSha = runner(['-C', rootDir, 'rev-parse', 'HEAD']).stdout.trim();
+    const baseSha = runner(['-C', rootDir, 'rev-parse', nonNoiseCommit]).stdout.trim();
+    if (headSha !== baseSha) {
+        fmt.log.info(`Resetting trailing backlog noise back to ${baseSha.substring(0, 7)} to include in the integration...`);
+        const resetResult = runner(['-C', rootDir, 'reset', '--soft', baseSha]);
+        if (resetResult.status !== 0) {
+            fmt.log.fail(`Failed to reset to ${baseSha}: ${resetResult.stderr}`);
+            return false;
+        }
+        return true;
+    }
     return false;
-  }
-
-  const nonNoiseCommit = findLastNonNoiseCommit(rootDir, gitRunner);
-  if (!nonNoiseCommit) {return false;}
-
-  const headSha = gitRunner(['-C', rootDir, 'rev-parse', 'HEAD']).stdout.trim();
-  const baseSha = gitRunner(['-C', rootDir, 'rev-parse', nonNoiseCommit]).stdout.trim();
-
-  if (headSha !== baseSha) {
-    fmt.log.info(`Resetting trailing backlog noise back to ${baseSha.substring(0, 7)} to include in the integration...`);
-    const resetResult = gitRunner(['-C', rootDir, 'reset', '--soft', baseSha]);
-    if (resetResult.status !== 0) {
-      fmt.log.fail(`Failed to reset to ${baseSha}: ${resetResult.stderr}`);
-      return false;
-    }
-    return true;
-  }
-  return false;
 }
-
 /** @param {string} slug @param {string} [rootDir] @param {Function|null} [gitRunner] */
-function findMissionDocInBranches(/** @type {string} */ slug, /** @type {string} */ rootDir = process.cwd(), /** @type {Function|null} */ gitRunner = null) {
-  if (!gitRunner) {gitRunner = require('./git').git;}
-  /** @type {{branch: string, path: string}[]} */
-  const candidates = [];
-
-  const baseSlugMatch = slug.match(/^(task-\d+)/i);
-  const baseSlug = baseSlugMatch ? baseSlugMatch[1].toLowerCase() : slug;
-  const paths = [
-    path.relative(rootDir, missionPathForSlug(rootDir, slug)).split(path.sep).join('/'),
-    path.relative(rootDir, missionPathForSlug(rootDir, baseSlug)).split(path.sep).join('/')
-  ];
-  const uniquePaths = Array.from(new Set(paths));
-
-  let branchResult;
-  try {
-    branchResult = gitRunner(['-C', rootDir, 'branch', '-a', '--format=%(refname:short)']);
-    if (branchResult.status !== 0) {return candidates;}
-  } catch (e) {
-    return candidates;
-  }
-
-  /** @param {string} b */
-  const branches = branchResult.stdout.trim().split('\n')
-    .filter(Boolean)
-    .filter((/** @type {string} */ b) => !b.includes('HEAD'))
-    .filter((/** @type {string} */ b) => b.endsWith(baseSlug) || b.includes(`/${baseSlug}-`) || b.includes(`/${baseSlug}/`));
-
-  for (const branch of branches) {
-    for (const p of uniquePaths) {
-      try {
-        const lsResult = gitRunner(['-C', rootDir, 'ls-tree', '--name-only', branch, p]);
-        if (lsResult.status === 0 && lsResult.stdout.trim() === p) {
-          candidates.push({ branch, path: p });
-          break; // Next branch
+function findMissionDocInBranches(slug, rootDir = process.cwd(), gitRunner) {
+    const runner = gitRunner || gitModule.git;
+    const candidates = [];
+    const baseSlugMatch = slug.match(/^(task-\d+)/i);
+    const baseSlug = baseSlugMatch ? baseSlugMatch[1].toLowerCase() : slug;
+    const files = [
+        node_path_1.default.relative(rootDir, missionPathForSlug(rootDir, slug)).split(node_path_1.default.sep).join('/'),
+        node_path_1.default.relative(rootDir, missionPathForSlug(rootDir, baseSlug)).split(node_path_1.default.sep).join('/')
+    ];
+    const uniquePaths = Array.from(new Set(files));
+    let branchResult;
+    try {
+        branchResult = runner(['-C', rootDir, 'branch', '-a', '--format=%(refname:short)']);
+        if (branchResult.status !== 0) {
+            return candidates;
+        }
+    }
+    catch (e) {
+        return candidates;
+    }
+    const branches = branchResult.stdout.trim().split('\n')
+        .filter(Boolean)
+        .filter((b) => !b.includes('HEAD'))
+        .filter((b) => b.endsWith(baseSlug) || b.includes(`/${baseSlug}-`) || b.includes(`/${baseSlug}/`));
+    for (const branch of branches) {
+        for (const f of uniquePaths) {
+            try {
+                const lsResult = runner(['-C', rootDir, 'ls-tree', '--name-only', branch, f]);
+                if (lsResult.status === 0 && lsResult.stdout.trim() === f) {
+                    candidates.push({ branch, path: f });
+                    break;
+                }
+            }
+            catch (err) {
+                // ignore
+            }
         }
-      } catch (err) {
-        // ignore
-      }
     }
-  }
-
-  return candidates;
+    return candidates;
 }
-
 /**
  * Check if a file path is a mission artifact for a specific slug.
  * Mission artifacts include:
@@ -1024,77 +1023,36 @@ function findMissionDocInBranches(/** @type {string} */ slug, /** @type {string}
  */
 /** @param {string} file @param {string} slug @param {string} [rootDir] */
 function isMissionArtifact(file, slug, rootDir = process.cwd()) {
-  if (!file || !slug) {return false;}
-
-  const missionDir = `${path.relative(rootDir, missionDirForSlug(rootDir, slug)).split(path.sep).join('/')}/`;
-  if (file.startsWith(missionDir)) {return true;}
-  const legacyMissionDir = `docs/missions/${getMissionYear(slug, rootDir)}/${slug}/`;
-  if (file.startsWith(legacyMissionDir)) {return true;}
-
-  // Task files: task-NNN - title.md or task-NNN.md in the configured storage.
-  const escapedSlug = slug.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-  const taskStorage = resolveTaskStorage(rootDir);
-  const taskDirs = [taskStorage.tasksDir, taskStorage.completedDir]
-    .map(dir => path.relative(rootDir, dir).split(path.sep).join('/'))
-    .map(dir => dir.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
-  const taskPattern = new RegExp(`^(?:${taskDirs.join('|')})/${escapedSlug}(?:\\s+-\\s+[^/]+\\.md|\\.md)$`, 'i');
-  if (taskPattern.test(file)) {return true;}
-
-  return false;
+    if (!file || !slug) {
+        return false;
+    }
+    const missionDir = `${node_path_1.default.relative(rootDir, missionDirForSlug(rootDir, slug)).split(node_path_1.default.sep).join('/')}/`;
+    if (file.startsWith(missionDir)) {
+        return true;
+    }
+    const legacyMissionDir = `docs/missions/${getMissionYear(slug, rootDir)}/${slug}/`;
+    if (file.startsWith(legacyMissionDir)) {
+        return true;
+    }
+    const escapedSlug = slug.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const taskStorage = (0, product_config_js_1.resolveTaskStorage)(rootDir);
+    const taskDirs = [taskStorage.tasksDir, taskStorage.completedDir]
+        .map(dir => node_path_1.default.relative(rootDir, dir).split(node_path_1.default.sep).join('/'))
+        .map(dir => dir.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
+    const taskPattern = new RegExp(`^(?:${taskDirs.join('|')})/${escapedSlug}(?:\\s+-\\s+[^/]+\\.md|\\.md)$`, 'i');
+    if (taskPattern.test(file)) {
+        return true;
+    }
+    return false;
 }
-
 /** @param {string} [file] */
 function isWorkflowGeneratedArtifact(file) {
-  if (!file) {return false;}
-  return file.startsWith('.workflow/')
-    || file.startsWith('.sessions/')
-    || file.startsWith('.forgejo-local/')
-    || file === 'graphify-out'
-    || file.startsWith('graphify-out/');
+    if (!file) {
+        return false;
+    }
+    return file.startsWith('.workflow/')
+        || file.startsWith('.sessions/')
+        || file.startsWith('.forgejo-local/')
+        || file === 'graphify-out'
+        || file.startsWith('graphify-out/');
 }
-
-module.exports = {
-  resolveMissionAdapter,
-  missionBaseDir,
-  missionUsesYearTier,
-  missionBranchPrefix,
-  missionBranchName,
-  missionBranchRef,
-  extractSlugFromBranch,
-  isMissionSlugCandidate,
-  getPrimaryBranch,
-  getPrimaryWorktree,
-  resolveMainRepo,
-  conventionalWorktreePath,
-  conventionalBaseWorktreePath,
-  detectLaunchBaseBranch,
-  parseBaseBranchLine,
-  readRecordedBaseBranch,
-  resolveMissionBaseBranch,
-  resolveBaseWorktree,
-  getMissionYear,
-  findMissionDir,
-  resolveWorktree,
-  findCheckpoints,
-  compareCheckpointFiles,
-  checkpointOrder,
-  getFirstLine,
-  findMissionArea,
-  graphifyAvailable,
-  probeGraphifyAvailability,
-  updateGraphifyKnowledgeGraph,
-  missionTitle,
-  normalizeVerifyArea,
-  detectMissionAreaFromContent,
-  missionPathForSlug,
-  missionDirForSlug,
-  inferSlug,
-  parseConflictFilesFromMergeOutput,
-  getConflictFiles,
-  findLastNonNoiseCommit,
-  squashTrailingBacklogNoiseIntoPreviousMission,
-  softResetTrailingBacklogNoise,
-  findMissionDocInBranches,
-  isMissionArtifact,
-  isWorkflowGeneratedArtifact
-};