mixdog 1.2.0 → 1.2.2

package/src/runtime/agent/orchestrator/session/synthetic-user-envelope.mjs

@@ -16,6 +16,7 @@
 import { isActualUserInstructionMessage, isInjectedSkillBodyMessage, isSummaryMessage } from './compact/messages.mjs';
 import { ACTIVE_TURN_CONTINUATION_ANCHOR, ACTIVE_TURN_CONTINUATION_SOURCE } from './compact/continuation.mjs';
 import { parseTaskNotification } from '../../../shared/task-notification-envelope.mjs';
+import { isImportedMessage } from './imported-message.mjs';
 
 export const SYNTHETIC_USER_ENVELOPE_TAG = 'mixdog-runtime';
 
@@ -62,7 +63,8 @@ function isAlreadyEnveloped(text) {
 
 // null => a real user instruction (or nothing to wrap); otherwise the kind.
 export function classifySyntheticUserMessage(message) {
-  if (message?.role !== 'user') return null;
+  // Imported prose stays the user's own (unwrapped) voice.
+  if (message?.role !== 'user' || isImportedMessage(message)) return null;
   const text = messageText(message);
   if (!text.trim()) return null;
   if (isAlreadyEnveloped(text)) return null;

package/src/runtime/agent/orchestrator/session/tool-batch/pre-dispatch.mjs

@@ -92,7 +92,7 @@ function crossTurnStub(batch, call, ctSig) {
 // (which spans ONE assistant turn): when the model re-issues an IDENTICAL
 // normalized call that has already failed repeatFailLimit times in a row
 // across iterations, stop re-executing — the result will not change, and
-// each retry burns a full LLM round-trip until the hard iteration cap. The
+// each retry burns a full LLM round-trip with no iteration cap to end it. The
 // call stays unresolved; the guard only skips re-execution.
 function repeatFailureSkip(batch, call, sigs) {
   const { sessionRef, repeatFailLimit } = batch;

package/src/runtime/agent/orchestrator/session/transcript-restore/restore.mjs

@@ -6,7 +6,7 @@
  */
 import { contextMeasurementStats } from '../../../../shared/context-measurement.mjs';
 import { toolResultText } from './tool-result-text.mjs';
-import { restoredUserText } from './user-text.mjs';
+import { restoredUserImageRefs, restoredUserText } from './user-text.mjs';
 import {
   completionCardFromExecution,
   parseModelVisibleCompletionWrapper,
@@ -38,6 +38,7 @@ import {
 } from '../../../../shared/tool-execution-contract.mjs';
 import { toolResultTerminalStatus } from '../../../../shared/tool-status.mjs';
 import { transcriptRouteMetadataFields } from '../../../../shared/transcript-metadata.mjs';
+import { isImportedMessage } from '../imported-message.mjs';
 
 function restoredTranscriptMetadata(message) {
   const value = message?.meta?.transcript;
@@ -62,6 +63,10 @@ function restoredTranscriptMetadata(message) {
     ...(typeof value.sender === 'string' && value.sender ? { sender: value.sender } : {}),
     ...(typeof value.device === 'string' && value.device ? { device: value.device } : {}),
     ...(typeof value.checkpointId === 'string' && value.checkpointId ? { checkpointId: value.checkpointId } : {}),
+    // Skills this user turn explicitly loaded (header selection or `$name`).
+    ...(Array.isArray(value.appliedSkills) && value.appliedSkills.length
+      ? { appliedSkills: value.appliedSkills.filter((name) => typeof name === 'string' && name) }
+      : {}),
     ...(completion ? { completion } : {}),
   };
 }
@@ -281,7 +286,9 @@ function mergeRestoredToolItems(items) {
 }
 
 function restoredMessageItemUpperBound(message) {
-  const boundaries = Array.isArray(message?.meta?.sessionInheritances) ? message.meta.sessionInheritances.length : 0;
+  const boundaries =
+    (Array.isArray(message?.meta?.sessionInheritances) ? message.meta.sessionInheritances.length : 0) +
+    (Array.isArray(message?.meta?.modelSwitches) ? message.meta.modelSwitches.length : 0);
   if (message?.role === 'user') return 1 + boundaries;
   if (message?.role !== 'assistant') return boundaries;
   const calls = restoredMessageToolCalls(message);
@@ -322,6 +329,11 @@ function restoredUserTranscriptItems(message, nextId) {
   // skill bodies (meta:'skill'), hook/system reminders, and tag-wrapped context
   // blocks must not restore as user bubbles in any client.
   if (message?.meta === 'skill' || message?.meta === 'hook') return [];
+  // Imported prose renders verbatim: never a control row, card or display rewrite.
+  if (isImportedMessage(message)) {
+    const text = (typeof message.content === 'string' ? message.content : toolResultText(message.content)).trim();
+    return text ? [{ kind: 'user', id: nextId(), text, ...restoredTranscriptMetadata(message) }] : [];
+  }
   const text = restoredUserText(message?.content).trim();
   // Persisted async-completion wrappers ("Async shell task ... finished. Result:
   // > ...") are the only durable record of a background completion — the live
@@ -353,11 +365,33 @@ function restoredUserTranscriptItems(message, nextId) {
   }
   const synthetic = parseSyntheticAgentMessage(text);
   if (!synthetic) {
-    return [{ kind: 'user', id: nextId(), text, ...restoredTranscriptMetadata(message) }];
+    const imageRefs = restoredUserImageRefs(message?.content);
+    return [
+      {
+        kind: 'user',
+        id: nextId(),
+        text,
+        ...restoredTranscriptMetadata(message),
+        ...(imageRefs.length ? { imageRefs } : {}),
+      },
+    ];
   }
   return [restoredNotificationToolItem(synthetic, text, message, nextId, /^(failed|error|killed|cancelled)$/i)];
 }
 
+/** The transcript row of an in-place model switch (live and restored). */
+export function modelSwitchItem(id, boundary) {
+  return {
+    kind: 'statusdone',
+    id,
+    status: 'model-switched',
+    label: 'Model switched',
+    provider: boundary.provider,
+    modelId: boundary.modelId,
+    at: boundary.at,
+  };
+}
+
 function restoreTranscriptRange(messages, start, sessionId) {
   const items = [];
   const pendingToolCalls = new Map();
@@ -389,6 +423,10 @@ function restoreTranscriptRange(messages, start, sessionId) {
         at: boundary.at,
       });
     }
+    for (const boundary of Array.isArray(message?.meta?.modelSwitches) ? message.meta.modelSwitches : []) {
+      if (!boundary?.provider || !boundary?.modelId) continue;
+      items.push(modelSwitchItem(restoredId(), boundary));
+    }
   }
   return mergeRestoredToolItems(items);
 }

package/src/runtime/agent/orchestrator/session/transcript-restore/user-text.mjs

@@ -21,9 +21,7 @@ const FEEDBACK_BLOCK = /<visualize_feedback>\n([\s\S]*?)\n?<\/visualize_feedback
 // on the blob itself: the reference's claimed sizeBytes is not trusted.
 const FEEDBACK_MAX_BYTES = 128 * 1024;
 const QUOTED = '("(?:[^"\\\\]|\\\\.)*")';
-const CHOICE_LINE = new RegExp(
-  `· group: (?:${QUOTED}|\\(none\\)) → choice: ${QUOTED}(?: \\(${QUOTED}\\))?$`
-);
+const CHOICE_LINE = new RegExp(`· group: (?:${QUOTED}|\\(none\\)) → choice: ${QUOTED}(?: \\(${QUOTED}\\))?$`);
 
 function unquote(value) {
   if (!value) return '';
@@ -53,7 +51,7 @@ function feedbackDisplay(body) {
       continue;
     }
     if (tweaks) {
-      const change = /^    (.+?) \([^)]*\): (.*) \(was (.*)\)$/.exec(line);
+      const change = /^ {4}(.+?) \([^)]*\): (.*) \(was (.*)\)$/.exec(line);
       if (change) tweaks.push(`${change[1]}: ${change[2]} (was ${change[3]})`);
       else if (line.startsWith('  - tab: ')) {
         tweaks = [];
@@ -118,23 +116,46 @@ function referencedFeedbackText(part) {
   }
 }
 
-export function restoredUserText(content) {
-  if (!Array.isArray(content)) {
-    return withVisualizeFeedbackDisplay(typeof content === 'string' ? content : toolResultText(content));
-  }
+/** The display lines of a stored prompt's parts, and for each image part the
+ *  line that draws it: the composer's metadata line right before it, else a
+ *  bare line of its own (a bare line never stands for the next image). */
+function restoredUserParts(content) {
   const texts = [];
-  let previous = '';
+  const images = [];
+  let pendingMetadata = '';
   for (const part of content) {
-    let text;
     if (part?.type === 'image' || part?.type === 'input_image') {
-      text = IMAGE_METADATA_LINE.test(previous) ? '' : `[Image: ${part.mimeType || part.mediaType || 'image'}]`;
-    } else if (isAttachmentReference(part)) {
-      text = referencedFeedbackText(part);
-    } else {
-      text = toolResultText([part]);
+      let line = pendingMetadata;
+      if (!line) {
+        line = `[Image: ${part.mimeType || part.mediaType || 'image'}]`;
+        texts.push(line);
+      }
+      pendingMetadata = '';
+      images.push({ part, line });
+      continue;
     }
-    previous = text;
+    const text = isAttachmentReference(part) ? referencedFeedbackText(part) : toolResultText([part]);
     if (text) texts.push(text);
+    pendingMetadata = IMAGE_METADATA_LINE.test(text) ? text.trimEnd().split(/\r?\n/).pop().trim() : '';
   }
-  return withVisualizeFeedbackDisplay(texts.join('\n'));
+  return { texts, images };
+}
+
+export function restoredUserText(content) {
+  if (!Array.isArray(content)) {
+    return withVisualizeFeedbackDisplay(typeof content === 'string' ? content : toolResultText(content));
+  }
+  return withVisualizeFeedbackDisplay(restoredUserParts(content).texts.join('\n'));
+}
+
+/** The stored original of each image the restored bubble draws, by the
+ *  `[Image: …]` line that draws it. Every image keeps its slot (one without a
+ *  stored original has no `ref`) so later images do not shift onto it; empty
+ *  when no image has a stored original. */
+export function restoredUserImageRefs(content) {
+  if (!Array.isArray(content)) return [];
+  const slots = restoredUserParts(content).images.map(({ part, line }) =>
+    isAttachmentReference(part) ? { line, ref: part.attachmentRef } : { line }
+  );
+  return slots.some((slot) => slot.ref) ? slots : [];
 }

package/src/runtime/agent/orchestrator/tools/builtin/arg-guard.mjs

@@ -786,9 +786,9 @@ function guardShell(a) {
   }
   // Over-max is an unambiguous "wait as long as allowed"; clamp like the other
   // saturating integer args instead of failing the call.
-  if (hasOwn(a, 'wait_ms') && Number.isInteger(a.wait_ms) && a.wait_ms > 120000) a.wait_ms = 120000;
+  if (hasOwn(a, 'wait_ms') && Number.isInteger(a.wait_ms) && a.wait_ms > 30000) a.wait_ms = 30000;
   if (hasOwn(a, 'wait_ms') && (!Number.isInteger(a.wait_ms) || a.wait_ms < 1000)) {
-    return `Error: shell arg "wait_ms" must be an integer from 15000 to 120000, e.g. wait_ms:30000 (got ${JSON.stringify(a.wait_ms)})`;
+    return `Error: shell arg "wait_ms" must be an integer from 10000 to 30000, e.g. wait_ms:20000 (got ${JSON.stringify(a.wait_ms)})`;
   }
   if (!hasOwn(a, 'command')) {
     return 'Error: shell requires "command"';

package/src/runtime/agent/orchestrator/tools/builtin/bash-tool/deadline-plan.mjs

@@ -1,12 +1,12 @@
 // Commands start in the foreground. Only work still running after the
-// 15 s coordination budget is promoted to a tracked background task.
+// 10 s coordination budget is promoted to a tracked background task.
 // Short commands therefore complete in the original tool turn, while longer
 // work returns partial output plus task_id and finishes by notification.
-// 15 s because a command promoted moments before it ends costs a whole
-// follow-up request on `task wait`. Session logs (2026-09-30..10-05), the 260
-// promoted commands with a recorded duration: 108 had ended within 10 s, 144
-// within 15 s and only 152 within 20 s.
-export const DEFAULT_SHELL_AUTO_BACKGROUND_MS = 15_000;
+// A per-call wait_ms may stretch the window for a command whose result should
+// return in the same call, never past 30 s, so the conversation is never held
+// open long; anything longer finishes by notification.
+export const DEFAULT_SHELL_AUTO_BACKGROUND_MS = 10_000;
+export const MAX_SHELL_WAIT_MS = 30_000;
 
 // JS timers (setTimeout) and PS WaitForExit(ms) are 32-bit: a delay above
 // 2^31-1 wraps to a tiny/negative value and fires immediately. Clamp the
@@ -17,17 +17,14 @@ const TIMER_MAX_MS = 2_147_483_647;
 
 // Main-agent blocking budget. A timeout is the command's total deadline, not
 // permission to hold the conversation open for that whole duration: after
-// 15 s a still-running command becomes a tracked background task and
+// 10 s a still-running command becomes a tracked background task and
 // completion is pushed to the owner. MIXDOG_SHELL_AUTO_BACKGROUND_MS
 // overrides; an explicit 0 disables. Gated on backgroundOnTimeout so
 // disabled background tasks remain foreground.
-// A per-call wait_ms extends that default for the call, capped by the
-// foreground maximum; it never shortens it. A shorter window promotes a
-// command that would have returned its result in the starting call and spends
-// a whole follow-up request on `task wait`. Session logs (2026-09-30..10-05,
-// 3062 shell calls): 329 passed a wait_ms under the default (53% of one model
-// family's calls), 256 of those were promoted, and 108 of the 192 with a
-// recorded duration had finished inside the default window (10 s then).
+// A per-call wait_ms extends that default for the call, capped by
+// MAX_SHELL_WAIT_MS and the foreground maximum; it never shortens it. A
+// shorter window promotes a command that would have returned its result in
+// the starting call and spends a whole follow-up request on `task wait`.
 function autoBackgroundBudget(backgroundOnTimeout, timeout, waitMs, maxForegroundMs) {
   const raw = process.env.MIXDOG_SHELL_AUTO_BACKGROUND_MS;
   const parsed = Number(raw);
@@ -35,7 +32,7 @@ function autoBackgroundBudget(backgroundOnTimeout, timeout, waitMs, maxForegroun
     raw != null && String(raw).trim() !== '' && Number.isFinite(parsed) && parsed >= 0
       ? Math.floor(parsed)
       : DEFAULT_SHELL_AUTO_BACKGROUND_MS;
-  if (waitMs > 0) defaultMs = Math.max(defaultMs, Math.min(waitMs, maxForegroundMs));
+  if (waitMs > 0) defaultMs = Math.max(defaultMs, Math.min(waitMs, MAX_SHELL_WAIT_MS, maxForegroundMs));
   if (!backgroundOnTimeout || defaultMs <= 0) return 0;
   return timeout > 0 ? Math.min(defaultMs, timeout) : defaultMs;
 }

package/src/runtime/agent/orchestrator/tools/builtin/bash-tool/invocation-plan.mjs

@@ -3,13 +3,25 @@ import { buildPowerShellFilterTeePlan } from '../shell-analysis.mjs';
 import { normalizeErrorMessage } from '../path-diagnostics.mjs';
 import { planDirectExeSpawn } from '../shell-direct-exe.mjs';
 import { POWERSHELL_UTF8_PREFIX } from '../../../../../shared/shell-display.mjs';
+import { renderPowerShellSkillFunction, skillScriptRuntime } from '../../../../../shared/skill-script-runtime.mjs';
 import { buildShellSpawnEnv } from './spawn-env.mjs';
 import { formatShellToolFailure } from './result-format.mjs';
 
+// Every PowerShell model command defines `mixdog-skill-node` first, so the
+// skill launcher runs without the .cmd's cmd.exe argument re-parsing.
+// Injected whenever absent, independent of the UTF-8 prefix deduplication.
+function prefixPowerShellSkillFunction(command) {
+  const fn = renderPowerShellSkillFunction(skillScriptRuntime());
+  const text = String(command || '');
+  return text.trimStart().startsWith(`${fn}\n`) ? text : `${fn}\n${text}`;
+}
+
 function prefixPowerShellUtf8(command) {
   const prefix = POWERSHELL_UTF8_PREFIX;
   const text = String(command || '');
-  return text.trimStart().startsWith(prefix) ? text : `${prefix}\n${text}`;
+  const trimmed = text.trimStart();
+  const body = trimmed.startsWith(prefix) ? trimmed.slice(prefix.length).replace(/^[ \t]*\r?\n/, '') : text;
+  return `${prefix}\n${prefixPowerShellSkillFunction(body)}`;
 }
 
 // How the command reaches the child: a direct exe spawn, PowerShell with the
@@ -54,6 +66,10 @@ export async function planShellInvocation({ command, resolvedSpec, cwd }) {
     plan.wrappedCommand = prefixPowerShellUtf8(plan.teePlan ? plan.teePlan.command : command);
     return plan;
   }
+  if (shellType === 'powershell') {
+    plan.wrappedCommand = prefixPowerShellSkillFunction(command);
+    return plan;
+  }
   if (process.platform !== 'win32' && (shell.includes('bash') || shell.includes('zsh'))) {
     try {
       plan.wrappedCommand = await wrapCommandWithSnapshot(shell, command);

package/src/runtime/agent/orchestrator/tools/builtin/bash-tool/spawn-env.mjs

@@ -1,4 +1,5 @@
 import { resourceAdmission } from '../../../../../shared/resource-admission.mjs';
+import { withSkillLauncherPath } from '../../../../../shared/skill-script-runtime.mjs';
 import {
   applyShellEgressPolicy,
   scrubLoaderVars,
@@ -24,5 +25,8 @@ export function buildShellSpawnEnv(cwd, baseEnv = process.env) {
   scrubLoaderVars(spawnEnv);
   scrubRuntimeRootVars(spawnEnv);
   applyShellEgressPolicy(spawnEnv);
+  // `mixdog-skill-node` (a skill's ${MIXDOG_SKILL_NODE}) resolves in every
+  // model shell; only this env gets the entry, never the daemon's own.
+  withSkillLauncherPath(spawnEnv);
   return spawnEnv;
 }

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

@@ -146,7 +146,7 @@ export const BUILTIN_TOOLS = [
       openWorldHint: true,
       compressible: true,
     },
-    description: `Run programs, builds, tests and computation. Never use shell commands or scripts for work covered by dedicated tools: cat/head/tail→read, ls→list, find→glob, filename lookup→find, grep/rg→grep, code structure→code_graph, file edits/writes (sed/awk/redirection)→edit/apply_patch, Git→git when that tool is on the surface. Tool names are not shell commands. ${_shellBackgroundDisabled ? 'Commands run in the foreground until completion.' : 'After a 15s foreground window (not a timeout; wait_ms extends it up to 120s for one call, e.g. a test suite), unfinished work continues under task_id; use task wait, not read polling. If no execution slot frees within the admission wait, the command is queued as a background task with a task_id. Dev servers/watchers: pass timeout_ms or stop them with task cancel when done.'}`,
+    description: `Run programs, builds, tests and computation. Never use shell commands or scripts for work covered by dedicated tools: cat/head/tail→read, ls→list, find→glob, filename lookup→find, grep/rg→grep, code structure→code_graph, file edits/writes (sed/awk/redirection)→edit/apply_patch, Git→git when that tool is on the surface. Tool names are not shell commands. ${_shellBackgroundDisabled ? 'Commands run in the foreground until completion.' : 'After a 10s foreground window (not a timeout; omit wait_ms by default, set it up to 30s only for a command you expect to finish in 10–30s, e.g. one test file), unfinished work continues under task_id; use task wait, not read polling. If no execution slot frees within the admission wait, the command is queued as a background task with a task_id. Dev servers/watchers: pass timeout_ms or stop them with task cancel when done.'}`,
     inputSchema: {
       type: 'object',
       properties: {
@@ -155,14 +155,14 @@ export const BUILTIN_TOOLS = [
           type: 'integer',
           minimum: 0,
           description:
-            'Hard kill deadline in ms (omit or 0 = none), separate from the 15s foreground window; set one for throwaway probes so a slow check fails fast.',
+            'Hard kill deadline in ms (omit or 0 = none), separate from the 10s foreground window; set one for throwaway probes so a slow check fails fast.',
         },
         wait_ms: {
           type: 'integer',
-          minimum: 15000,
-          maximum: 120000,
+          minimum: 10000,
+          maximum: 30000,
           description:
-            'Foreground wait in ms before unfinished work continues as a background task (default 15000); raise it for a command that should return its result in this call.',
+            'Foreground wait in ms before unfinished work continues as a background task (default 10000). Omit it by default. Set it only when you expect the command to finish within 10–30s (e.g. one test file or a small build step); never for work expected to take longer, which finishes by notification.',
         },
       },
       required: ['command'],

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

@@ -8,7 +8,7 @@ import { normalizeOutputPath, resolveAgainstCwd } from '../path-utils.mjs';
 /** Report the requested path's result; suggestions never retarget the operation. */
 export async function readFamilyPathEnoentOrError(workDir, fullPath, inputPath, err) {
   const safeMsg = normalizeErrorMessage(err instanceof Error ? err.message : String(err));
-  const hint = buildNotFoundHint(workDir, fullPath, 'List', err?.code);
+  const hint = await buildNotFoundHint(workDir, fullPath, 'List', err?.code);
   const tail = finalizeReadFamilyEnoentTail(hint, inputPath, err?.code);
   // Conclusive absence is the list's ANSWER, not a tool failure (matches
   // read's `[path absent]` and git's `repo:false` policy). Genuine
@@ -78,4 +78,4 @@ export async function countTextFileLines(fullPath, size) {
   } finally {
     await handle?.close().catch(() => {});
   }
-}
+}

package/src/runtime/agent/orchestrator/tools/builtin/path-diagnostics.mjs

@@ -97,7 +97,7 @@ const BASENAME_SCAN_SKIP_DIRS = new Set([
 // directories scanned and wall-clock. `visitEntry` decides what counts as a
 // match and which directories to queue, and returns true to stop reading the
 // current directory (its own limit break).
-function scanByBasename(searchRoot, { limit, maxDirs, deadlineMs }, visitEntry) {
+async function scanByBasename(searchRoot, { limit, maxDirs, deadlineMs }, visitEntry) {
   const matches = [];
   const queue = [searchRoot];
   const stopAt = Date.now() + Math.max(1, deadlineMs);
@@ -112,7 +112,7 @@ function scanByBasename(searchRoot, { limit, maxDirs, deadlineMs }, visitEntry)
     scanned++;
     let entries;
     try {
-      entries = readdirSync(dir, { withFileTypes: true });
+      entries = await readdir(dir, { withFileTypes: true });
     } catch {
       continue;
     }
@@ -127,7 +127,7 @@ function scanByBasename(searchRoot, { limit, maxDirs, deadlineMs }, visitEntry)
   return matches;
 }
 
-export function findFileByBasename(
+export async function findFileByBasename(
   searchRoot,
   fullPath,
   { limit = 3, maxDirs = 6000, deadlineMs = BASENAME_SCAN_DEADLINE_MS } = {}
@@ -136,7 +136,7 @@ export function findFileByBasename(
     if (typeof searchRoot !== 'string' || !searchRoot) return [];
     const target = basename(fullPath).toLowerCase();
     if (!target) return [];
-    return scanByBasename(searchRoot, { limit, maxDirs, deadlineMs }, (dir, ent, matches, queue) => {
+    return await scanByBasename(searchRoot, { limit, maxDirs, deadlineMs }, (dir, ent, matches, queue) => {
       const name = ent.name;
       if (ent.isDirectory()) {
         if (name.startsWith('.') || BASENAME_SCAN_SKIP_DIRS.has(name)) return false;
@@ -205,7 +205,7 @@ export function findBySuffixStrip(searchRoot, fullPath, { maxIterations = 12 } =
 
 // Same as findFileByBasename but for directories sharing the missing path's
 // final segment name (e.g. guessed `src/shared` → the real `lib/shared`).
-export function findDirectoryByBasename(
+export async function findDirectoryByBasename(
   searchRoot,
   fullPath,
   { limit = 3, maxDirs = 6000, deadlineMs = BASENAME_SCAN_DEADLINE_MS } = {}
@@ -214,7 +214,7 @@ export function findDirectoryByBasename(
     if (typeof searchRoot !== 'string' || !searchRoot) return [];
     const target = basename(fullPath).toLowerCase();
     if (!target) return [];
-    return scanByBasename(searchRoot, { limit, maxDirs, deadlineMs }, (dir, ent, matches, queue) => {
+    return await scanByBasename(searchRoot, { limit, maxDirs, deadlineMs }, (dir, ent, matches, queue) => {
       const name = ent.name;
       if (!ent.isDirectory()) return false;
       if (name.toLowerCase() === target) {