switchman-dev 0.1.6 → 0.1.8

package/src/core/enforcement.js

@@ -1,18 +1,23 @@
-import { appendFileSync, chmodSync, existsSync, mkdirSync, readFileSync, readdirSync, readlinkSync, renameSync, rmSync, statSync, writeFileSync } from 'fs';
-import { dirname, join, resolve, relative } from 'path';
+import { appendFileSync, chmodSync, existsSync, mkdirSync, readFileSync, readdirSync, readlinkSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from 'fs';
+import { dirname, join, posix, relative, resolve } from 'path';
 import { execFileSync, spawnSync } from 'child_process';
 
 import {
   getActiveFileClaims,
+  touchBoundaryValidationState,
   getCompletedFileClaims,
   getLease,
-  getTaskSpec,
   getWorktree,
+  listWorktrees,
   getWorktreeSnapshotState,
   replaceWorktreeSnapshotState,
   getStaleLeases,
+  listScopeReservations,
   listAuditEvents,
   listLeases,
+  listTasks,
+  getTask,
+  getTaskSpec,
   logAuditEvent,
   updateWorktreeCompliance,
 } from './db.js';
@@ -30,6 +35,14 @@ const DEFAULT_ENFORCEMENT_POLICY = {
   allowed_generated_paths: [],
 };
 
+function normalizeFsPath(filePath) {
+  try {
+    return realpathSync(filePath);
+  } catch {
+    return resolve(filePath);
+  }
+}
+
 function getEnforcementPolicyPath(repoRoot) {
   return join(repoRoot, '.switchman', 'enforcement.json');
 }
@@ -125,7 +138,19 @@ function diffSnapshots(previousSnapshot, currentSnapshot) {
 }
 
 function getLeaseScopePatterns(db, lease) {
-  return getTaskSpec(db, lease.task_id)?.allowed_paths || [];
+  const reservations = listScopeReservations(db, { leaseId: lease.id });
+  const scopePatterns = reservations
+    .filter((reservation) => reservation.ownership_level === 'path_scope' && reservation.scope_pattern)
+    .map((reservation) => reservation.scope_pattern);
+  return [...new Set(scopePatterns)];
+}
+
+function getLeaseSubsystemTags(db, lease) {
+  const reservations = listScopeReservations(db, { leaseId: lease.id });
+  const subsystemTags = reservations
+    .filter((reservation) => reservation.ownership_level === 'subsystem' && reservation.subsystem_tag)
+    .map((reservation) => reservation.subsystem_tag);
+  return [...new Set(subsystemTags)];
 }
 
 function findScopedLeaseOwner(db, leases, filePath, excludeLeaseId = null) {
@@ -139,6 +164,18 @@ function findScopedLeaseOwner(db, leases, filePath, excludeLeaseId = null) {
   return null;
 }
 
+function findSubsystemLeaseOwner(db, leases, subsystemTags, excludeLeaseId = null) {
+  if (!subsystemTags.length) return null;
+  for (const lease of leases) {
+    if (excludeLeaseId && lease.id === excludeLeaseId) continue;
+    const leaseTags = getLeaseSubsystemTags(db, lease);
+    if (leaseTags.some((tag) => subsystemTags.includes(tag))) {
+      return lease;
+    }
+  }
+  return null;
+}
+
 function normalizeDirectoryScopeRoot(pattern) {
   return String(pattern || '').replace(/\\/g, '/').replace(/\/\*\*$/, '').replace(/\/\*$/, '').replace(/\/+$/, '');
 }
@@ -163,8 +200,13 @@ function resolveLeasePathOwnership(db, lease, filePath, activeClaims, activeLeas
   }
 
   const ownScopePatterns = getLeaseScopePatterns(db, lease);
+  const ownSubsystemTags = getLeaseSubsystemTags(db, lease);
   const ownScopeMatch = ownScopePatterns.length > 0 && matchesPathPatterns(filePath, ownScopePatterns);
   if (ownScopeMatch) {
+    const foreignSubsystemOwner = findSubsystemLeaseOwner(db, activeLeases, ownSubsystemTags, lease.id);
+    if (foreignSubsystemOwner) {
+      return { ok: false, reason_code: 'path_scoped_by_other_lease', claim: null, ownership_type: null };
+    }
     const foreignScopeOwner = findScopedLeaseOwner(db, activeLeases, filePath, lease.id);
     if (foreignScopeOwner) {
       return { ok: false, reason_code: 'path_scoped_by_other_lease', claim: null, ownership_type: null };
@@ -177,9 +219,25 @@ function resolveLeasePathOwnership(db, lease, filePath, activeClaims, activeLeas
     return { ok: false, reason_code: 'path_scoped_by_other_lease', claim: null, ownership_type: null };
   }
 
+  const foreignSubsystemOwner = findSubsystemLeaseOwner(db, activeLeases, ownSubsystemTags, lease.id);
+  if (foreignSubsystemOwner) {
+    return { ok: false, reason_code: 'path_scoped_by_other_lease', claim: null, ownership_type: null };
+  }
+
   return { ok: false, reason_code: 'path_not_claimed', claim: null, ownership_type: null };
 }
 
+function completedScopedTaskOwnsPath(db, completedTasks, filePath) {
+  for (const task of completedTasks) {
+    const taskSpec = getTaskSpec(db, task.id);
+    const allowedPaths = Array.isArray(taskSpec?.allowed_paths) ? taskSpec.allowed_paths : [];
+    if (allowedPaths.length > 0 && matchesPathPatterns(filePath, allowedPaths)) {
+      return true;
+    }
+  }
+  return false;
+}
+
 function classifyObservedPath(db, repoRoot, worktree, filePath, options = {}) {
   const activeLeases = options.activeLeases || listLeases(db, 'active');
   const activeClaims = options.activeClaims || getActiveFileClaims(db);
@@ -188,12 +246,28 @@ function classifyObservedPath(db, repoRoot, worktree, filePath, options = {}) {
 
   const activeLease = activeLeases.find((lease) => lease.worktree === worktree.name) || null;
   const claim = activeClaims.find((item) => item.file_path === filePath && item.worktree === worktree.name) || null;
+  const foreignClaim = activeClaims.find((item) => item.file_path === filePath && item.worktree !== worktree.name) || null;
+  const foreignScopeOwner = findScopedLeaseOwner(db, activeLeases, filePath, activeLease?.id || null);
 
   if (!activeLease) {
-    return { status: 'denied', reason_code: 'no_active_lease', lease: null, claim };
+    return {
+      status: 'denied',
+      reason_code: 'no_active_lease',
+      lease: null,
+      claim,
+      owner_claim: foreignClaim,
+      owner_lease: foreignScopeOwner,
+    };
   }
   if (staleLeaseIds.has(activeLease.id)) {
-    return { status: 'denied', reason_code: 'lease_expired', lease: activeLease, claim };
+    return {
+      status: 'denied',
+      reason_code: 'lease_expired',
+      lease: activeLease,
+      claim,
+      owner_claim: foreignClaim,
+      owner_lease: foreignScopeOwner,
+    };
   }
   const ownership = resolveLeasePathOwnership(db, activeLease, filePath, activeClaims, activeLeases);
   if (ownership.ok) {
@@ -203,21 +277,42 @@ function classifyObservedPath(db, repoRoot, worktree, filePath, options = {}) {
       lease: activeLease,
       claim: ownership.claim ?? claim,
       ownership_type: ownership.ownership_type,
+      owner_claim: null,
+      owner_lease: null,
     };
   }
   if (matchesPathPatterns(filePath, policy.allowed_generated_paths || [])) {
-    return { status: 'allowed', reason_code: 'policy_exception_allowed', lease: activeLease, claim: null, ownership_type: 'policy' };
+    return {
+      status: 'allowed',
+      reason_code: 'policy_exception_allowed',
+      lease: activeLease,
+      claim: null,
+      ownership_type: 'policy',
+      owner_claim: null,
+      owner_lease: null,
+    };
   }
-  return { status: 'denied', reason_code: ownership.reason_code, lease: activeLease, claim: ownership.claim ?? claim, ownership_type: null };
+  return {
+    status: 'denied',
+    reason_code: ownership.reason_code,
+    lease: activeLease,
+    claim: ownership.claim ?? claim,
+    ownership_type: null,
+    owner_claim: ownership.claim ?? foreignClaim,
+    owner_lease: foreignScopeOwner,
+  };
 }
 
 function normalizeRepoPath(repoRoot, targetPath) {
-  const relativePath = String(targetPath || '').replace(/\\/g, '/').replace(/^\.\/+/, '');
+  const rawPath = String(targetPath || '').replace(/\\/g, '/').trim();
+  const relativePath = posix.normalize(rawPath.replace(/^\.\/+/, ''));
   if (
     relativePath === '' ||
-    relativePath.startsWith('..') ||
     relativePath === '.' ||
-    relativePath.startsWith('/')
+    relativePath === '..' ||
+    relativePath.startsWith('../') ||
+    rawPath.startsWith('/') ||
+    /^[A-Za-z]:\//.test(rawPath)
   ) {
     throw new Error('Target path must point to a file inside the repository.');
   }
@@ -358,6 +453,9 @@ export function validateLeaseAccess(db, { leaseId, worktree = null }) {
 }
 
 function logWriteEvent(db, status, reasonCode, validation, eventType, details = null) {
+  if (status === 'allowed' && validation.lease?.id) {
+    touchBoundaryValidationState(db, validation.lease.id, `write:${details?.operation || 'unknown'}`);
+  }
   logAuditEvent(db, {
     eventType,
     status,
@@ -529,7 +627,17 @@ export function gatewayMovePath(db, repoRoot, { leaseId, sourcePath, destination
 }
 
 export function gatewayMakeDirectory(db, repoRoot, { leaseId, path: targetPath, worktree = null }) {
-  const normalizedPath = String(targetPath || '').replace(/\\/g, '/').replace(/^\.\/+/, '').replace(/\/+$/, '');
+  let normalizedPath;
+  try {
+    normalizedPath = normalizeRepoPath(repoRoot, targetPath).relativePath.replace(/\/+$/, '');
+  } catch {
+    return {
+      ok: false,
+      reason_code: 'policy_exception_required',
+      file_path: targetPath,
+      lease_id: leaseId,
+    };
+  }
   const lease = getLease(db, leaseId);
 
   if (!lease || lease.status !== 'active') {
@@ -703,6 +811,9 @@ export function evaluateWorktreeCompliance(db, repoRoot, worktree, options = {})
   const activeLeases = options.activeLeases || listLeases(db, 'active');
   const activeClaims = options.activeClaims || getActiveFileClaims(db);
   const completedClaims = options.completedClaims || getCompletedFileClaims(db, worktree.name);
+  const completedTasks = options.completedTasks
+    || listTasks(db)
+      .filter((task) => task.status === 'done' && task.worktree === worktree.name);
 
   const changedFiles = getWorktreeChangedFiles(worktree.path, repoRoot);
   const activeLease = activeLeases.find((lease) => lease.worktree === worktree.name) || null;
@@ -715,7 +826,7 @@ export function evaluateWorktreeCompliance(db, repoRoot, worktree, options = {})
   for (const file of changedFiles) {
     const completedClaim = completedClaimsByPath.get(file);
     if (!activeLease) {
-      if (completedClaim) {
+      if (completedClaim || completedScopedTaskOwnsPath(db, completedTasks, file)) {
         continue;
       }
       violations.push({ file, reason_code: 'no_active_lease' });
@@ -825,6 +936,9 @@ export function monitorWorktreesOnce(db, repoRoot, worktrees, options = {}) {
         reason_code: classification.reason_code,
         lease_id: classification.lease?.id ?? null,
         task_id: classification.lease?.task_id ?? null,
+        owner_worktree: classification.owner_claim?.worktree || classification.owner_lease?.worktree || null,
+        owner_task_id: classification.owner_claim?.task_id || classification.owner_lease?.task_id || null,
+        owner_task_title: classification.owner_claim?.task_title || getTask(db, classification.owner_lease?.task_id || '')?.title || null,
         enforcement_action: null,
         quarantine_path: null,
       };
@@ -840,6 +954,10 @@ export function monitorWorktreesOnce(db, repoRoot, worktrees, options = {}) {
         details: JSON.stringify({ change_type: change.change_type }),
       });
 
+      if (classification.status === 'allowed' && classification.lease?.id) {
+        touchBoundaryValidationState(db, classification.lease.id, `observed:${change.change_type}`);
+      }
+
       if (classification.status === 'denied') {
         updateWorktreeCompliance(db, worktree.name, COMPLIANCE_STATES.NON_COMPLIANT);
         if (options.quarantine) {
@@ -881,9 +999,16 @@ export function runCommitGate(db, repoRoot, { cwd = process.cwd(), worktreeName
   const currentWorktree = worktreeName
     ? null
     : getCurrentWorktree(repoRoot, cwd);
+  const registeredWorktree = worktreeName
+    ? getWorktree(db, worktreeName)
+    : listWorktrees(db).find((entry) => normalizeFsPath(entry.path) === normalizeFsPath(cwd))
+      || (currentWorktree
+        ? listWorktrees(db).find((entry) => normalizeFsPath(entry.path) === normalizeFsPath(currentWorktree.path))
+        : null)
+      || null;
   const resolvedWorktree = worktreeName
-    ? { name: worktreeName, path: cwd }
-    : currentWorktree;
+    ? { name: worktreeName, path: registeredWorktree?.path || cwd }
+    : registeredWorktree || currentWorktree;
 
   if (!resolvedWorktree) {
     const result = {

package/src/core/git.js

@@ -4,8 +4,9 @@
  */
 
 import { execFileSync, execSync, spawnSync } from 'child_process';
-import { existsSync, realpathSync } from 'fs';
+import { existsSync, realpathSync, rmSync, statSync } from 'fs';
 import { join, relative, resolve, basename } from 'path';
+import { tmpdir } from 'os';
 import { filterIgnoredPaths } from './ignore.js';
 
 function normalizeFsPath(path) {
@@ -339,6 +340,289 @@ export function gitMergeBranchInto(repoRoot, baseBranch, topicBranch) {
   }
 }
 
+export function gitAssessBranchFreshness(repoRoot, baseBranch, topicBranch) {
+  const baseCommit = gitRevParse(repoRoot, baseBranch);
+  const topicCommit = gitRevParse(repoRoot, topicBranch);
+  if (!baseCommit || !topicCommit) {
+    return {
+      state: 'unknown',
+      base_commit: baseCommit || null,
+      topic_commit: topicCommit || null,
+      merge_base: null,
+    };
+  }
+
+  try {
+    const mergeBase = execFileSync('git', ['merge-base', baseBranch, topicBranch], {
+      cwd: repoRoot,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+    }).trim();
+    return {
+      state: mergeBase === baseCommit ? 'fresh' : 'behind',
+      base_commit: baseCommit,
+      topic_commit: topicCommit,
+      merge_base: mergeBase,
+    };
+  } catch {
+    return {
+      state: 'unknown',
+      base_commit: baseCommit,
+      topic_commit: topicCommit,
+      merge_base: null,
+    };
+  }
+}
+
+export function gitMaterializeIntegrationBranch(repoRoot, {
+  branch,
+  baseBranch = 'main',
+  mergeBranches = [],
+  tempWorktreePath = null,
+} = {}) {
+  const uniqueBranches = [...new Set(mergeBranches.filter(Boolean))].filter((candidate) => candidate !== branch);
+  const resolvedTempWorktreePath = tempWorktreePath || join(tmpdir(), `switchman-landing-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
+
+  try {
+    execFileSync('git', ['worktree', 'add', '--detach', resolvedTempWorktreePath, baseBranch], {
+      cwd: repoRoot,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    execFileSync('git', ['checkout', '-B', branch, baseBranch], {
+      cwd: resolvedTempWorktreePath,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    for (const mergeBranch of uniqueBranches) {
+      execFileSync('git', ['merge', '--no-ff', '--no-edit', mergeBranch], {
+        cwd: resolvedTempWorktreePath,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+      });
+    }
+
+    return {
+      branch,
+      base_branch: baseBranch,
+      merged_branches: uniqueBranches,
+      head_commit: gitRevParse(resolvedTempWorktreePath, 'HEAD'),
+      temp_worktree_path: resolvedTempWorktreePath,
+    };
+  } catch (err) {
+    const stderr = String(err?.stderr || '');
+    const stdout = String(err?.stdout || '');
+    const combinedOutput = `${stdout}${stderr}`.trim();
+    const message = String(err?.message || combinedOutput || 'Failed to materialize integration branch.');
+    const currentMergeBranch = uniqueBranches.find((candidate) =>
+      message.includes(candidate) || combinedOutput.includes(candidate),
+    ) || null;
+    let reasonCode = 'landing_branch_materialization_failed';
+    if (/CONFLICT|Automatic merge failed|Merge conflict/i.test(message) || /CONFLICT|Automatic merge failed/i.test(combinedOutput)) {
+      reasonCode = 'landing_branch_merge_conflict';
+    } else if (/not something we can merge|unknown revision|bad revision|not a valid object name/i.test(message) || /not something we can merge|unknown revision|bad revision|not a valid object name/i.test(combinedOutput)) {
+      reasonCode = 'landing_branch_missing_component';
+    } else if (message.includes(baseBranch) && /not something we can merge|unknown revision|bad revision|not a valid object name/i.test(message)) {
+      reasonCode = 'landing_branch_missing_base';
+    }
+    const conflictingFiles = reasonCode === 'landing_branch_merge_conflict'
+      ? execFileSync('git', ['diff', '--name-only', '--diff-filter=U'], {
+        cwd: resolvedTempWorktreePath,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+      }).trim().split('\n').filter(Boolean)
+      : [];
+    try {
+      execFileSync('git', ['merge', '--abort'], {
+        cwd: resolvedTempWorktreePath,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+      });
+    } catch {
+      // No active merge to abort.
+    }
+    const landingError = new Error(message);
+    landingError.code = reasonCode;
+    landingError.details = {
+      branch,
+      base_branch: baseBranch,
+      merge_branches: uniqueBranches,
+      failed_branch: currentMergeBranch,
+      conflicting_files: conflictingFiles,
+      output: combinedOutput.slice(0, 1000),
+      temp_worktree_path: resolvedTempWorktreePath,
+    };
+    throw landingError;
+  } finally {
+    try {
+      execFileSync('git', ['worktree', 'remove', resolvedTempWorktreePath, '--force'], {
+        cwd: repoRoot,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+      });
+    } catch {
+      rmSync(resolvedTempWorktreePath, { recursive: true, force: true });
+    }
+  }
+}
+
+export function gitPrepareIntegrationRecoveryWorktree(repoRoot, {
+  branch,
+  baseBranch = 'main',
+  mergeBranches = [],
+  recoveryPath,
+} = {}) {
+  const uniqueBranches = [...new Set(mergeBranches.filter(Boolean))].filter((candidate) => candidate !== branch);
+  if (!recoveryPath) {
+    throw new Error('Recovery path is required.');
+  }
+  if (existsSync(recoveryPath)) {
+    throw new Error(`Recovery path already exists: ${recoveryPath}`);
+  }
+
+  execFileSync('git', ['worktree', 'add', '--detach', recoveryPath, baseBranch], {
+    cwd: repoRoot,
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+
+  try {
+    execFileSync('git', ['checkout', '-B', branch, baseBranch], {
+      cwd: recoveryPath,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    for (const mergeBranch of uniqueBranches) {
+      try {
+        execFileSync('git', ['merge', '--no-ff', '--no-edit', mergeBranch], {
+          cwd: recoveryPath,
+          encoding: 'utf8',
+          stdio: ['ignore', 'pipe', 'pipe'],
+        });
+      } catch (err) {
+        const conflictingFiles = execFileSync('git', ['diff', '--name-only', '--diff-filter=U'], {
+          cwd: recoveryPath,
+          encoding: 'utf8',
+          stdio: ['ignore', 'pipe', 'pipe'],
+        }).trim().split('\n').filter(Boolean);
+        return {
+          ok: false,
+          branch,
+          base_branch: baseBranch,
+          recovery_path: recoveryPath,
+          merged_branches: uniqueBranches,
+          failed_branch: mergeBranch,
+          conflicting_files: conflictingFiles,
+          output: `${String(err.stdout || '')}${String(err.stderr || '')}`.trim().slice(0, 1000),
+        };
+      }
+    }
+
+    return {
+      ok: true,
+      branch,
+      base_branch: baseBranch,
+      recovery_path: recoveryPath,
+      merged_branches: uniqueBranches,
+      head_commit: gitRevParse(recoveryPath, 'HEAD'),
+      conflicting_files: [],
+      failed_branch: null,
+      output: '',
+    };
+  } catch (err) {
+    try {
+      execFileSync('git', ['worktree', 'remove', recoveryPath, '--force'], {
+        cwd: repoRoot,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+      });
+    } catch {
+      rmSync(recoveryPath, { recursive: true, force: true });
+    }
+    throw err;
+  }
+}
+
+export function gitRemoveWorktree(repoRoot, worktreePath) {
+  execFileSync('git', ['worktree', 'remove', worktreePath, '--force'], {
+    cwd: repoRoot,
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+}
+
+export function gitPruneWorktrees(repoRoot) {
+  execFileSync('git', ['worktree', 'prune'], {
+    cwd: repoRoot,
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+}
+
+function isSwitchmanTempLandingWorktreePath(worktreePath) {
+  const resolvedPath = normalizeFsPath(worktreePath || '');
+  const tempRoot = normalizeFsPath(tmpdir());
+  return resolvedPath.startsWith(`${tempRoot}/`) && basename(resolvedPath).startsWith('switchman-landing-');
+}
+
+export function cleanupCrashedLandingTempWorktrees(
+  repoRoot,
+  {
+    olderThanMs = 15 * 60 * 1000,
+    now = Date.now(),
+  } = {},
+) {
+  const actions = [];
+  const beforePrune = listGitWorktrees(repoRoot)
+    .filter((worktree) => isSwitchmanTempLandingWorktreePath(worktree.path));
+  const missingBeforePrune = beforePrune.filter((worktree) => !existsSync(worktree.path));
+
+  gitPruneWorktrees(repoRoot);
+
+  const afterPrune = listGitWorktrees(repoRoot)
+    .filter((worktree) => isSwitchmanTempLandingWorktreePath(worktree.path));
+  const remainingPaths = new Set(afterPrune.map((worktree) => worktree.path));
+
+  for (const worktree of missingBeforePrune) {
+    if (!remainingPaths.has(worktree.path)) {
+      actions.push({
+        kind: 'stale_temp_worktree_pruned',
+        path: worktree.path,
+        branch: worktree.branch || null,
+      });
+    }
+  }
+
+  for (const worktree of afterPrune) {
+    if (!existsSync(worktree.path)) continue;
+
+    let ageMs = 0;
+    try {
+      ageMs = Math.max(0, now - statSync(worktree.path).mtimeMs);
+    } catch {
+      continue;
+    }
+
+    if (ageMs < olderThanMs) continue;
+
+    gitRemoveWorktree(repoRoot, worktree.path);
+    actions.push({
+      kind: 'stale_temp_worktree_removed',
+      path: worktree.path,
+      branch: worktree.branch || null,
+      age_ms: ageMs,
+    });
+  }
+
+  return {
+    repaired: actions.length > 0,
+    actions,
+  };
+}
+
 /**
  * Create a new git worktree
  */
@@ -348,6 +632,7 @@ export function createGitWorktree(repoRoot, name, branch) {
   execSync(`git worktree add -b "${branch}" "${wtPath}"`, {
     cwd: repoRoot,
     encoding: 'utf8',
+    stdio: ['pipe', 'pipe', 'pipe'],
   });
   return wtPath;
 }

package/src/core/ignore.js

@@ -1,4 +1,5 @@
 export const DEFAULT_SCAN_IGNORE_PATTERNS = [
+  '.mcp.json',
   'node_modules/**',
   '.git/**',
   '.mcp.json',