mixdog 1.4.1 → 1.4.3

package/src/runtime/agent/orchestrator/tools/builtin/git-command-tool.mjs

@@ -9,11 +9,12 @@ import { withBuiltinPathLocks } from './path-locks.mjs';
 import { withAdvisoryLocks } from './advisory-lock.mjs';
 import { gitRepoLockKey, withGitWorktreeWriteLock } from './git-repo-rw-lock.mjs';
 import { invalidateBuiltinResultCache } from './cache-layers.mjs';
-import { tryAdmitWorkspaceActivity } from '../../../../shared/worktrees/activity-gate.mjs';
+import { tryAdmitWorkspaceActivityAsync } from '../../../../shared/worktrees/activity-gate.mjs';
 import { WORKTREE_SNAPSHOT_KIND } from '../../../../shared/worktrees/contract.mjs';
 import { isWithin } from '../../../../shared/worktrees/paths.mjs';
 import { readRegistrySync } from '../../../../shared/worktrees/registry.mjs';
 import { runAbortable } from '../../../../shared/abort-race.mjs';
+import { startGit } from '../../../../shared/git-launch.mjs';
 import { sleep } from '../../../../shared/sleep.mjs';
 import { capMarker } from '../../../../shared/tool-output-marker.mjs';
 import { drainCodeGraphCache } from '../code-graph-state.mjs';
@@ -97,7 +98,7 @@ export const GIT_TOOL_DEF = {
     openWorldHint: true,
     compressible: true,
   },
-  description: `${GIT_DESCRIPTION_HEAD} Worktrees are managed only: action:worktree; git worktree add/remove/list/prune map to managed operations (add -b keeps the session in place; add --detach makes a read-only snapshot worktree, removed when its turn ends; list --porcelain stays raw git; move/lock/unlock/repair are refused). Merge or remove only when the user asks.`,
+  description: `${GIT_DESCRIPTION_HEAD} Worktrees are managed only: action:worktree; git worktree add/remove/list/prune map to managed operations (add -b keeps the session in place; add --detach makes a read-only snapshot worktree, removed when its turn ends, and is the one add a delegated worker may run; list --porcelain stays raw git; move/lock/unlock/repair are refused). Merge or remove only when the user asks.`,
   inputSchema: {
     type: 'object',
     properties: {
@@ -143,7 +144,10 @@ export const GIT_TOOL_DEF = {
         description: 'enter/return/merge/remove: another session (it must be idle); default the caller.',
       },
       name: { type: 'string', description: 'enter: the new worktree name (branch <prefix><name>).' },
-      branch: { type: 'string', description: 'enter: use the worktree of this branch instead.' },
+      branch: {
+        type: 'string',
+        description: "enter: use the worktree of this branch instead. remove: this session's worktree of that branch.",
+      },
       create: { type: 'boolean', description: 'enter with branch: create that branch.' },
       carry: {
         type: 'string',
@@ -437,7 +441,24 @@ function parseCommand(rawCommand, workDir) {
   return { command: String(command), cwd, globalArgs, operation, args };
 }
 
-async function runProcess(program, argv, { cwd, signal, maxBytes = MAX_CAPTURE_BYTES, optionalLocks = true } = {}) {
+function gitToolEnvironment(optionalLocks) {
+  return {
+    ...process.env,
+    GIT_TERMINAL_PROMPT: '0',
+    GIT_PAGER: 'cat',
+    GIT_EDITOR: 'true',
+    GIT_SEQUENCE_EDITOR: 'true',
+    LC_ALL: 'C',
+    // Reads run beside writes without a lock (git-repo-rw-lock.mjs).
+    // With optional locks off `git status` never takes index.lock to
+    // write back a refreshed index, so it cannot fail a concurrent
+    // write on that lock. (`git diff` ignores the setting and may still
+    // refresh the index briefly; the write retry absorbs that.)
+    ...(optionalLocks ? {} : { GIT_OPTIONAL_LOCKS: '0' }),
+  };
+}
+
+async function runProcess(program, argv, { cwd, signal, maxBytes = MAX_CAPTURE_BYTES, env } = {}) {
   let child;
   try {
     await ensureNativeSpawnServer();
@@ -446,20 +467,7 @@ async function runProcess(program, argv, { cwd, signal, maxBytes = MAX_CAPTURE_B
       argv,
       spawnOptions: {
         cwd,
-        env: {
-          ...process.env,
-          GIT_TERMINAL_PROMPT: '0',
-          GIT_PAGER: 'cat',
-          GIT_EDITOR: 'true',
-          GIT_SEQUENCE_EDITOR: 'true',
-          LC_ALL: 'C',
-          // Reads run beside writes without a lock (git-repo-rw-lock.mjs).
-          // With optional locks off `git status` never takes index.lock to
-          // write back a refreshed index, so it cannot fail a concurrent
-          // write on that lock. (`git diff` ignores the setting and may still
-          // refresh the index briefly; the write retry absorbs that.)
-          ...(optionalLocks ? {} : { GIT_OPTIONAL_LOCKS: '0' }),
-        },
+        env,
         outputLimit: maxBytes,
         // Bytes as git wrote them, decoded once by the caller: a multibyte
         // character split across two pipe reads must not become U+FFFD.
@@ -573,11 +581,12 @@ function commandFailure(plan, result, limit = GIT_OUTPUT_LINES_DEFAULT) {
 }
 
 function runGit(plan, argv, options = {}) {
-  return runProcess('git', [...plan.globalArgs, ...argv], {
-    cwd: plan.cwd,
-    signal: options.signal,
-    optionalLocks: !options.readOnly,
-  });
+  return startGit(
+    gitToolEnvironment(!options.readOnly),
+    (command, env) =>
+      runProcess(command, [...plan.globalArgs, ...argv], { cwd: plan.cwd, signal: options.signal, env }),
+    (result) => result.error
+  );
 }
 
 // Another process (an editor, a terminal, an IDE) holding one of git's lock
@@ -585,6 +594,10 @@ function runGit(plan, argv, options = {}) {
 // config.lock. Commands take that lock before changing anything, so a brief
 // retry with backoff turns the collision into a short wait; a command that had
 // already done part of its work reports its own state on the retry.
+// Git reports lock contention only as text: lockfile.c's "Unable to create
+// '<path>.lock': File exists" (and config.c's "could not lock config file"),
+// stable English because runProcess pins LC_ALL=C. The delays are a bounded
+// backoff (3.1 s in all), a policy choice rather than anything git reports.
 const GIT_LOCK_CONTENTION_RE =
   /Unable to create '[^'\n]*\.lock': File exists|could not lock config file [^\n]*: File exists/;
 const GIT_LOCK_RETRY_DELAYS_MS = [100, 200, 400, 800, 1600];
@@ -884,12 +897,13 @@ function snapshotContaining(repo) {
 // lease it holds (activity-gate, the same as a background shell's) keeps the
 // snapshot from being removed in any process until it ends, and a snapshot
 // whose removal is under way refuses it. Returns the release.
-function admitSnapshotCommand(repo, sessionId) {
+async function admitSnapshotCommand(repo, sessionId) {
   const snapshot = snapshotContaining(repo);
   if (!snapshot) return () => {};
-  const leave = tryAdmitWorkspaceActivity(sessionId || 'git-tool', repo, { kind: 'command' });
+  const leave = await tryAdmitWorkspaceActivityAsync(sessionId || 'git-tool', repo, { kind: 'command' });
   if (!leave) throw new Error(`the snapshot worktree ${snapshot.path} is being removed; nothing ran`);
-  return leave;
+  // Fails only when workspace admission stopped (reported there), which keeps the snapshot held.
+  return () => leave().catch(() => {});
 }
 
 function invalidateAfterGitMutation() {
@@ -1057,14 +1071,14 @@ async function executeSingleGitTool(input, workDir, options = {}) {
   // under it, and a snapshot being removed refuses it.
   let leaveSnapshot;
   try {
-    leaveSnapshot = admitSnapshotCommand(repo, options.sessionId);
+    leaveSnapshot = await admitSnapshotCommand(repo, options.sessionId);
   } catch (error) {
     return rejected(error.message);
   }
   try {
     return await runInRepository(input, plan, { repo, lockKey, limit, signal, workDir });
   } finally {
-    leaveSnapshot();
+    await leaveSnapshot();
   }
 }
 

package/src/runtime/agent/orchestrator/tools/builtin/git-worktree-tool.mjs

@@ -15,7 +15,9 @@
  *
  * Every operation but `list` belongs to the Lead: the session runtime that
  * hosts the caller registers its host (shared/worktrees/tool-host.mjs); a
- * caller no host claims (a delegated worker) is refused.
+ * caller no host claims (a delegated worker) is refused, except for a
+ * read-only `add --detach` snapshot held by its own session and removed when
+ * its turn settles (shared/worktrees/worker-snapshots.mjs).
  */
 import { basename, resolve } from 'node:path';
 import { isPlainObject } from '../../../../shared/object.mjs';
@@ -23,6 +25,7 @@ import { WORKTREE_REFUSAL_REASONS } from '../../../../shared/worktrees/contract.
 import { firstLine, listWorktrees, runGit } from '../../../../shared/worktrees/git.mjs';
 import { canonicalPath, samePath } from '../../../../shared/worktrees/paths.mjs';
 import { worktreeToolHost } from '../../../../shared/worktrees/tool-host.mjs';
+import { createWorkerSnapshot } from '../../../../shared/worktrees/worker-snapshots.mjs';
 
 export const WORKTREE_TOOL_ACTIONS = Object.freeze(['enter', 'return', 'merge', 'remove', 'list', 'prune']);
 const CARRY_CHOICES = ['leave', 'carry'];
@@ -327,26 +330,34 @@ async function rawAdd(plan, input, options) {
   const [path, commitish = null] = positional;
   if (!path || positional.length > 2) throw new Error('git worktree add requires <path> [<commit-ish>]');
   if (detach && branch) throw new Error('git worktree add: --detach excludes -b/-B');
-  const host = leadHost(options, 'git worktree add');
+  const host = worktreeToolHost(options?.sessionId);
+  if (!host && !detach) {
+    throw new Error(
+      'git worktree add belongs to the Lead session; a delegated worker may only make a read-only snapshot: git worktree add --detach <path> [<commit>]'
+    );
+  }
   const repo = await repositoryAt(plan.cwd);
   if (!repo) throw new Error(`git worktree add: ${plan.cwd} is not a git repository`);
   const confirmLarge = input.confirm_large === true;
   const txId = txIdOf(options, plan.command);
   const mapped = { mapped: plan.command, requestedPath: resolve(plan.cwd, path) };
   // A detached checkout, or a commit-ish that names no local branch: a snapshot.
-  const snapshotCommit = detach
-    ? (commitish ?? 'HEAD')
-    : !branch && commitish && !(await localBranchExists(plan.cwd, commitish))
-      ? commitish
-      : null;
+  let snapshotCommit = null;
+  if (detach) snapshotCommit = commitish ?? 'HEAD';
+  else if (!branch && commitish && !(await localBranchExists(plan.cwd, commitish))) snapshotCommit = commitish;
   if (snapshotCommit) {
     const commit = await commitIn(plan.cwd, snapshotCommit);
     if (!commit) throw new Error(`git worktree add: ${snapshotCommit} is not a commit`);
-    const entry = await runOn(
-      host,
-      { op: 'snapshot', commit, confirmLarge, txId, repoCommonDir: repo.repoCommonDir },
-      options
-    );
+    // A delegated worker's snapshot is held by its own session and removed when its turn settles.
+    const entry = host
+      ? await runOn(host, { op: 'snapshot', commit, confirmLarge, txId, repoCommonDir: repo.repoCommonDir }, options)
+      : await createWorkerSnapshot({
+          sessionId: options?.sessionId,
+          projectPath: plan.cwd,
+          commit,
+          txId,
+          confirmLarge,
+        });
     return okJson({
       ...mapped,
       snapshot: true,
@@ -514,7 +525,7 @@ function worktreeInputError(input) {
   const misplaced =
     only('session_id', ['enter', 'return', 'merge', 'remove']) ||
     only('name', ['enter']) ||
-    only('branch', ['enter']) ||
+    only('branch', ['enter', 'remove']) ||
     only('create', ['enter']) ||
     only('carry', ['enter']) ||
     only('confirm_large', ['enter']) ||
@@ -531,6 +542,9 @@ function worktreeInputError(input) {
     return 'branch excludes name and carry (the branch names the worktree; changes stay in the project folder)';
   }
   if (input.carry !== undefined && !CARRY_CHOICES.includes(input.carry)) return 'carry must be leave or carry';
+  if (action === 'remove' && input.branch !== undefined && input.session_id !== undefined) {
+    return "branch names one of this session's own worktrees; it excludes session_id";
+  }
   return null;
 }
 
@@ -556,7 +570,9 @@ export async function executeWorktreeAction(input, workDir, options = {}) {
             confirmLarge: input.confirm_large === true,
           }
         : {}),
-      ...(action === 'remove' ? { force: input.force === true } : {}),
+      ...(action === 'remove'
+        ? { force: input.force === true, ...(input.branch?.trim() ? { branch: input.branch.trim() } : {}) }
+        : {}),
       ...(action === 'prune'
         ? { repoCommonDir: (await repositoryAt(resolve(workDir || process.cwd())))?.repoCommonDir ?? null }
         : {}),

package/src/runtime/agent/orchestrator/tools/builtin/lib/search-input-helpers.mjs

@@ -34,7 +34,7 @@ export function uniqueStrings(values) {
   return Array.from(new Set(values.filter((value) => typeof value === 'string' && value)));
 }
 
-export function coerceNonNegInt(value) {
+function coerceNonNegInt(value) {
   if (value === undefined || value === null || value === '') return null;
   const n = Number(value);
   if (!Number.isFinite(n) || n < 0) return NaN;
@@ -49,7 +49,7 @@ export function stringList(value) {
 
 // head_limit shared by the single-path flow and the path[] fan-out:
 // absent → the default cap, 0 → unlimited, otherwise the coerced integer.
-export function resolveHeadLimit(coerced, defaultLimit) {
+function resolveHeadLimit(coerced, defaultLimit) {
   if (coerced === null) return defaultLimit;
   return coerced === 0 ? Infinity : coerced;
 }

package/src/runtime/agent/orchestrator/tools/builtin/lib/shell-job-records.mjs

@@ -27,24 +27,40 @@ import { join } from 'node:path';
 import { holdsNoData, writeJsonAtomicAsync } from '../../../../../shared/atomic-file.mjs';
 import { isPidAlive } from '../../../../../shared/pid-liveness.mjs';
 import { displayShellCommand } from '../../../../../shared/shell-display.mjs';
-import { tryAdmitWorkspaceActivity } from '../../../../../shared/worktrees/activity-gate.mjs';
+import { tryAdmitWorkspaceActivityAsync } from '../../../../../shared/worktrees/activity-gate.mjs';
 import { worktreeError } from '../../../../../shared/worktrees/contract.mjs';
 import { workspaceSees } from '../../../../../shared/worktrees/workspace-visibility.mjs';
 
 const workspaceLeases = new Map();
 
+/**
+ * Calls both releases in order; settles once both did. Never goes unhandled
+ * (an asynchronous release rejects only when workspace admission stopped).
+ */
+export function bothReleased(first, second) {
+  const both = Promise.all([first(), second()]);
+  both.catch(() => {});
+  return both;
+}
+
+/**
+ * A workspace grant requested now, for a release handle needed before it is
+ * answered: the release, whenever called, follows the grant (and releases
+ * nothing if it was refused or failed).
+ */
+export function pendingWorkspaceAdmission(granting) {
+  granting.catch(() => {});
+  return () =>
+    granting.then(
+      (leave) => leave?.(),
+      () => {}
+    );
+}
+
 /** Transfer a foreground reader to a surviving-descendant task without a lease gap. */
 export function adoptShellWorkspaceAdmission(jobId, leave) {
   const prior = workspaceLeases.get(jobId);
-  workspaceLeases.set(
-    jobId,
-    prior
-      ? () => {
-          prior();
-          leave();
-        }
-      : leave
-  );
+  workspaceLeases.set(jobId, prior ? () => bothReleased(prior, leave) : leave);
 }
 
 // A record whose owner process is gone is garbage. Age alone never deletes a
@@ -88,8 +104,13 @@ function validJobId(jobId) {
 
 function terminalRecord(base, detail) {
   const finishedAt = detail?.finishedAt || new Date().toISOString();
+  // A completed record no longer claims an unconfirmed termination: it is
+  // written once the processes are confirmed gone, or explicitly released.
+  // A completed record no longer claims an unconfirmed termination: it is
+  // written once the processes are confirmed gone, or explicitly released.
+  const { terminationUnconfirmed: _held, ...open } = base || {};
   return {
-    ...(base || {}),
+    ...open,
     jobId: String(detail?.jobId || base?.jobId || ''),
     kind: 'bash',
     status: String(detail?.status || 'failed'),
@@ -172,7 +193,14 @@ async function sweepOrphanRecords(dir) {
   }
 }
 
-/** Publish the record for a job that has just started or been promoted. */
+/**
+ * Publish the record for a job that has just started or been promoted. Its
+ * workspace lease (under the job's pid) is requested at the call and adopted
+ * under the job id at once, so a later release of the job — or of a
+ * predecessor's lease — is ordered after it. Resolves once the lease is in
+ * both ledger copies; rejects (and writes no record) when it is refused or
+ * cannot be written. The returned promise never goes unhandled.
+ */
 export function publishShellJobRecord(
   task,
   {
@@ -184,16 +212,20 @@ export function publishShellJobRecord(
   } = {}
 ) {
   const jobId = String(task?.jobId || '').trim();
-  if (!jobId) return;
+  if (!jobId) return Promise.resolve();
+  let admitted = Promise.resolve();
   if (task?.cwd) {
-    const leave = tryAdmitWorkspaceActivity(ownerSessionId || jobId, task.cwd, {
+    const granting = tryAdmitWorkspaceActivityAsync(ownerSessionId || jobId, task.cwd, {
       pid: Number(task.pid) || process.pid,
       kind: 'command',
     });
-    if (!leave) throw worktreeError('WORKTREE_BUSY_JOBS', 'The command folder is being managed.');
+    admitted = granting.then((leave) => {
+      if (!leave) throw worktreeError('WORKTREE_BUSY_JOBS', 'The command folder is being managed.');
+    });
+    admitted.catch(() => {});
     // A descendant handoff can reuse the job id with a different live pid.
-    // Acquire its reader before releasing any predecessor's admission.
-    adoptShellWorkspaceAdmission(jobId, leave);
+    // Its reader is requested before any predecessor's admission is released.
+    adoptShellWorkspaceAdmission(jobId, pendingWorkspaceAdmission(granting));
   }
   const ownerPid = Number(clientHostPid ?? task?.clientHostPid) || process.pid;
   const dir = jobsDir();
@@ -202,6 +234,8 @@ export function publishShellJobRecord(
   paths.set(jobId, [jsonPath, ownerPath]);
   void enqueue(jobId, async () => {
     try {
+      // No record for a job whose workspace lease was not granted.
+      await admitted;
       await mkdir(dir, { recursive: true });
       if (!sweepStarted) {
         sweepStarted = true;
@@ -244,6 +278,7 @@ export function publishShellJobRecord(
       /* the record is presentation only; never fail a job for it */
     }
   });
+  return admitted;
 }
 
 /** Preserve a bounded terminal snapshot for manual recovery after restart. */
@@ -335,8 +370,9 @@ export function releaseShellJobWorkspace(jobId) {
   const key = String(jobId || '').trim();
   const leave = workspaceLeases.get(key);
   if (!leave) return;
-  leave();
+  const released = leave();
   if (workspaceLeases.get(key) === leave) workspaceLeases.delete(key);
+  return released;
 }
 
 /** Flag a still-open job record as "termination unconfirmed" for the readouts. */
@@ -390,8 +426,10 @@ export function completeShellJobRecord(jobId, detail) {
       // Callers complete a record only once its processes are confirmed gone
       // (or explicitly released): the workspace admission follows that, not
       // the record write, so a failed write cannot strand it with no handle.
-      leaveWorkspace?.();
+      const released = leaveWorkspace?.();
       if (workspaceLeases.get(key) === leaveWorkspace) workspaceLeases.delete(key);
+      // Fails only when workspace admission stopped (reported there), which keeps the folder held.
+      await Promise.resolve(released).catch(() => {});
     }
     await removePaths(ownerPaths);
     paths.set(key, [jsonPath, donePath]);
@@ -486,6 +524,6 @@ export function retireShellJobRecord(jobId) {
     records.delete(key);
     incarnations.delete(key);
     await removePaths(list);
-    leaveWorkspace?.();
+    await leaveWorkspace?.();
   });
 }

package/src/runtime/agent/orchestrator/tools/builtin/read-range-index.mjs

@@ -293,7 +293,7 @@ function requestReadRangeIndexPersist(key, job) {
   })();
 }
 
-export function scheduleReadRangeIndexPersist(index) {
+function scheduleReadRangeIndexPersist(index) {
   if (!READ_RANGE_INDEX_DISK_DIR || !currentReadRangeIndex(index)) return;
   const key = canonicalCachePath(index.fullPath);
   const inflight = READ_RANGE_INDEX_INFLIGHT.get(key);

package/src/runtime/agent/orchestrator/tools/builtin/read-single-fast-paths.mjs

@@ -11,7 +11,6 @@ import { invalidateBuiltinResultCache } from './cache-layers.mjs';
 import { getReadSnapshot } from './read-snapshot-runtime.mjs';
 import { snapshotCoversFullFile, statMatchesSnapshot } from './snapshot-helpers.mjs';
 import { canCacheReadFile, READ_PREFIX_HASH_BYTES } from './read-cache-policy.mjs';
-export { READ_PREFIX_HASH_BYTES } from './read-cache-policy.mjs';
 
 // A mutation snapshot claims the full file because it knows the bytes it
 // wrote; it proves the session holds the body only when bodyDelivered says so.

package/src/runtime/agent/orchestrator/tools/builtin/runtime-capabilities.mjs

@@ -1,6 +1,7 @@
 import { readdirSync, readFileSync, statSync } from 'node:fs';
 import { spawnSync } from 'node:child_process';
 import { readdir as readdirAsync } from 'node:fs/promises';
+import { startGitSync } from '../../../../shared/git-launch.mjs';
 import { runGitOffThread } from '../../../../shared/git-runner.mjs';
 import { findPathExecutable } from '../../../../shared/path-executable.mjs';
 import { dirname as pathDirname, join as pathJoin, resolve as pathResolveAbsolute } from 'node:path';
@@ -161,13 +162,15 @@ function _changeStateArgs(root) {
 
 function _probeRepositoryChangeStateSync(root) {
   try {
-    const result = spawnSync('git', _changeStateArgs(root), {
-      encoding: 'utf8',
-      env: { ...process.env, GIT_OPTIONAL_LOCKS: '0' },
-      maxBuffer: 64 * 1024,
-      timeout: 1500,
-      windowsHide: true,
-    });
+    const result = startGitSync({ ...process.env, GIT_OPTIONAL_LOCKS: '0' }, (command, env) =>
+      spawnSync(command, _changeStateArgs(root), {
+        encoding: 'utf8',
+        env,
+        maxBuffer: 64 * 1024,
+        timeout: 1500,
+        windowsHide: true,
+      })
+    );
     const output = String(result.stdout || '').trim();
     if (result.status === 0) return output ? 'changes present' : 'clean';
     if (result.error?.code === 'ENOBUFS' && output) return 'changes present';
@@ -271,14 +274,16 @@ function _checkIgnoreArgs(directory) {
 
 function _probeGitIgnoredEntriesSync(directory, names) {
   try {
-    const result = spawnSync('git', _checkIgnoreArgs(directory), {
-      encoding: 'utf8',
-      input: `${names.join('\0')}\0`,
-      env: { ...process.env, GIT_OPTIONAL_LOCKS: '0' },
-      maxBuffer: 1024 * 1024,
-      timeout: 1500,
-      windowsHide: true,
-    });
+    const result = startGitSync({ ...process.env, GIT_OPTIONAL_LOCKS: '0' }, (command, env) =>
+      spawnSync(command, _checkIgnoreArgs(directory), {
+        encoding: 'utf8',
+        input: `${names.join('\0')}\0`,
+        env,
+        maxBuffer: 1024 * 1024,
+        timeout: 1500,
+        windowsHide: true,
+      })
+    );
     // Exit 1 is "nothing ignored", not a failure.
     if (result.status !== 0 && result.status !== 1) return new Set();
     return new Set(

package/src/runtime/agent/orchestrator/tools/builtin/search-tool.mjs

@@ -1,12 +1,2 @@
-export {
-  _suggestIndexedPaths,
-  basePathDiagnostic,
-  buildNotFoundHint,
-  isUncOrSmbPath,
-  relativePathPrefix,
-  relativeSearchResultPath,
-  resolveSearchScope,
-  uncRefusalMessage,
-} from './search-path-diagnostics.mjs';
 export { executeGrepTool } from './search-grep-tool.mjs';
 export { executeGlobTool } from './search-glob-tool.mjs';