@kuznai/inception-engine 0.25.1 → 1.0.0

package/dist/src/core/deploy.js

@@ -8,11 +8,12 @@ import * as frontmatterAdapter from "./adapters/frontmatter.js";
 import { compileAdapterActions } from "./adapters/index.js";
 import { applyTomlMcpPatch } from "./adapters/toml.js";
 import { planCapabilityForDeploy } from "./capabilities.js";
+import { mapConcurrentOrdered } from "./concurrency.js";
 import { applyMergePatch, computeUndoPatch, isPlainObject, } from "./merge-patch.js";
 import { defaultRegistryPersistence, lookupDeployment, RunRegistry, registerDeployment, registryDirPath, verifyDeployment, } from "./ownership.js";
 import { getDeployMethod, resolveAgentSkillPath } from "./resolve.js";
 import { resolveTargetTemplate } from "./runtime-paths.js";
-import { sourceAccessError, validateSkillDefinitionFile, validateSourceFile, validateSourcePath, } from "./validation.js";
+import { createSourcePathValidator, sourceAccessError, validateSkillDefinitionFile, validateSourceFile, } from "./validation.js";
 async function readJsonConfigFile(filePath) {
     let rawContent;
     try {
@@ -232,7 +233,7 @@ function assertNoAntigravityPathCollisions(manifest) {
         return;
     throw new UserError("MANIFEST_INVALID", collisions.map((warning) => warning.message).join("; "));
 }
-async function planSkillDirActions(manifest, sourceDir, resolvedSourceDir, realRoot, detectedAgents, home) {
+async function planSkillDirActions(manifest, sourceDir, resolvedSourceDir, validateSource, detectedAgents, home) {
     const method = getDeployMethod();
     const actions = [];
     const warnings = [];
@@ -241,7 +242,7 @@ async function planSkillDirActions(manifest, sourceDir, resolvedSourceDir, realR
         if (targetAgents.length === 0)
             return;
         const source = path.resolve(sourceDir, skill.path);
-        await validateSourcePath(source, skill.path, resolvedSourceDir, realRoot);
+        await validateSource(source, skill.path, resolvedSourceDir);
         await validateSkillContract(source, skill.path);
         for (const agentId of targetAgents) {
             const plan = planCapabilityForDeploy({
@@ -273,7 +274,7 @@ async function planSkillDirActions(manifest, sourceDir, resolvedSourceDir, realR
     await Promise.all(manifest.skills.map(planSkillEntry));
     return { actions, warnings };
 }
-async function planFileWriteActions(manifest, sourceDir, resolvedSourceDir, realRoot, detectedAgents, home, repo, workspace) {
+async function planFileWriteActions(manifest, sourceDir, resolvedSourceDir, validateSource, detectedAgents, home, repo, workspace) {
     const actions = [];
     await Promise.all((manifest.files ?? []).map(async (fileEntry) => {
         const targetAgents = fileEntry.agents.filter((agentId) => detectedAgents.includes(agentId));
@@ -281,7 +282,7 @@ async function planFileWriteActions(manifest, sourceDir, resolvedSourceDir, real
             return;
         assertApprovedManagedTargetTemplate(fileEntry.target, targetAgents, "files");
         const source = path.resolve(sourceDir, fileEntry.path);
-        await validateSourcePath(source, fileEntry.path, resolvedSourceDir, realRoot);
+        await validateSource(source, fileEntry.path, resolvedSourceDir);
         await validateSourceFile(source, fileEntry.path);
         for (const agentId of targetAgents) {
             const agent = AGENT_REGISTRY_BY_ID[agentId];
@@ -334,18 +335,19 @@ export async function planDeploy(manifest, sourceDir, detectedAgents, home, repo
     catch {
         realRoot = resolvedSourceDir;
     }
+    const validateSource = createSourcePathValidator(realRoot);
     const repoDir = repo ?? realRoot;
-    const skillPlan = await planSkillDirActions(manifest, sourceDir, resolvedSourceDir, realRoot, detectedAgents, home);
+    const skillPlan = await planSkillDirActions(manifest, sourceDir, resolvedSourceDir, validateSource, detectedAgents, home);
     if (signal?.aborted)
         return { actions: [], warnings: [] };
     const actions = [
         ...skillPlan.actions,
-        ...(await planFileWriteActions(manifest, sourceDir, resolvedSourceDir, realRoot, detectedAgents, home, repoDir, workspace)),
+        ...(await planFileWriteActions(manifest, sourceDir, resolvedSourceDir, validateSource, detectedAgents, home, repoDir, workspace)),
         ...planConfigPatchActions(manifest, detectedAgents, home, repoDir, workspace),
     ];
     if (signal?.aborted)
         return { actions: [], warnings: [] };
-    const adapterResult = await compileAdapterActions(manifest.mcpServers, manifest.agentRules, manifest.permissions ?? [], sourceDir, resolvedSourceDir, realRoot, detectedAgents, home, repoDir, manifest.agentDefinitions ?? [], workspace, manifest.hooks ?? [], manifest.executionConfigs ?? []);
+    const adapterResult = await compileAdapterActions(manifest.mcpServers, manifest.agentRules, manifest.permissions ?? [], sourceDir, resolvedSourceDir, validateSource, detectedAgents, home, repoDir, manifest.agentDefinitions ?? [], workspace, manifest.hooks ?? [], manifest.executionConfigs ?? []);
     actions.push(...adapterResult.actions);
     const warnings = [
         ...skillPlan.warnings,
@@ -360,55 +362,142 @@ export async function planDeploy(manifest, sourceDir, detectedAgents, home, repo
     return { actions, warnings };
 }
 export async function executeDeploy(actions, dryRun, verbose, home, deps = {}, signal) {
-    let succeeded = 0;
-    const failed = [];
     const planned = [];
     const runRegistry = new RunRegistry(deps.registry ?? defaultRegistryPersistence);
     const depsWithRegistry = {
         ...deps,
         registry: runRegistry,
     };
+    const preflightFailure = await preflightDeployRegistry(actions, dryRun, home, runRegistry);
+    if (preflightFailure) {
+        return preflightFailure;
+    }
+    const results = await executeDeployActions(actions, dryRun, verbose, home, depsWithRegistry, signal);
     if (!dryRun) {
-        try {
-            await runRegistry.preflight(home);
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            return {
-                succeeded: 0,
-                failed: actions.map((action) => ({ action, error: message })),
-                planned,
-            };
-        }
+        await runRegistry.flush(home);
     }
-    for (const action of actions) {
+    return summarizeDeployResults(actions, results, planned);
+}
+async function preflightDeployRegistry(actions, dryRun, home, runRegistry) {
+    if (dryRun)
+        return null;
+    try {
+        await runRegistry.preflight(home);
+        return null;
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            succeeded: 0,
+            failed: actions.map((action) => ({ action, error: message })),
+            planned: [],
+        };
+    }
+}
+async function executeDeployActions(actions, dryRun, verbose, home, deps, signal) {
+    const results = new Array(actions.length);
+    if (dryRun) {
+        await executeDryRunDeployActions(results, actions, verbose, home, deps, signal);
+        return results;
+    }
+    const lanes = partitionDeployActionLanes(actions);
+    await mapConcurrentOrdered(lanes, async (lane) => {
+        for (const indexedAction of lane) {
+            if (signal?.aborted)
+                return;
+            results[indexedAction.index] = await dispatchDeployAction(indexedAction.action, false, verbose, home, deps);
+        }
+    }, { signal });
+    return results;
+}
+async function executeDryRunDeployActions(results, actions, verbose, home, deps, signal) {
+    for (const [index, action] of actions.entries()) {
         if (signal?.aborted)
             break;
-        const result = await dispatchDeployAction(action, dryRun, verbose, home, planned, depsWithRegistry);
+        results[index] = await dispatchDeployAction(action, true, verbose, home, deps);
+    }
+}
+function summarizeDeployResults(actions, results, planned) {
+    let succeeded = 0;
+    const failed = [];
+    for (const [index, result] of results.entries()) {
+        if (!result)
+            continue;
+        emitDeployLogs(result.logs);
+        if (result.plannedChange) {
+            planned.push(result.plannedChange);
+        }
         if (result.error === null) {
-            succeeded++;
+            succeeded += 1;
         }
         else {
-            failed.push({ action, error: result.error });
+            failed.push({
+                action: actions[index],
+                error: result.error,
+            });
         }
     }
-    if (!dryRun) {
-        await runRegistry.flush(home);
-    }
     return { succeeded, failed, planned };
 }
-async function dispatchDeployAction(action, dryRun, verbose, home, planned, deps) {
+function emitDeployLogs(logs) {
+    for (const event of logs) {
+        switch (event.kind) {
+            case "ok":
+                logger.ok(event.label);
+                break;
+            case "fail":
+                logger.fail(event.label, event.message);
+                break;
+            case "detail":
+                logger.detail(event.message);
+                break;
+            default:
+                throw new Error(`Unhandled deploy log event: ${event.kind}`);
+        }
+    }
+}
+function buildSuccessResult(label, detail, plannedChange) {
+    const logs = [];
+    if (!plannedChange) {
+        logs.push({ kind: "ok", label });
+        if (detail) {
+            logs.push({ kind: "detail", message: detail });
+        }
+    }
+    return { error: null, logs, plannedChange };
+}
+function buildFailureResult(label, message) {
+    return {
+        error: message,
+        logs: [{ kind: "fail", label, message }],
+    };
+}
+function pushVerboseDetail(logs, verbose, message) {
+    if (verbose) {
+        logs.push({ kind: "detail", message });
+    }
+}
+function partitionDeployActionLanes(actions) {
+    const lanes = new Map();
+    for (const [index, action] of actions.entries()) {
+        const lane = lanes.get(action.target) ?? [];
+        lane.push({ action, index });
+        lanes.set(action.target, lane);
+    }
+    return Array.from(lanes.values());
+}
+async function dispatchDeployAction(action, dryRun, verbose, home, deps) {
     switch (action.kind) {
         case "skill-dir":
-            return deploySkillDir(action, dryRun, verbose, home, planned, deps);
+            return deploySkillDir(action, dryRun, verbose, home, deps);
         case "file-write":
-            return deployFileWrite(action, dryRun, verbose, home, planned, deps);
+            return deployFileWrite(action, dryRun, verbose, home, deps);
         case "config-patch":
-            return deployConfigPatch(action, dryRun, verbose, home, planned, deps);
+            return deployConfigPatch(action, dryRun, verbose, home, deps);
         case "toml-patch":
-            return deployTomlPatch(action, dryRun, verbose, home, planned, deps);
+            return deployTomlPatch(action, dryRun, verbose, home, deps);
         case "frontmatter-emit":
-            return deployFrontmatterEmit(action, dryRun, verbose, home, planned, deps);
+            return deployFrontmatterEmit(action, dryRun, verbose, home, deps);
         default:
             throw new Error(`Unhandled deploy action kind: ${action.kind}`);
     }
@@ -520,18 +609,17 @@ async function replaceFileAtomically(targetPath, deps, stageTempFile, prepareBac
         await fileOps.rm(backupPath, { recursive: true, force: true });
     }
 }
-async function deploySkillDir(action, dryRun, verbose, home, planned, deps) {
+async function deploySkillDir(action, dryRun, verbose, home, deps) {
     const label = `${action.skill} -> ${action.agent}`;
     try {
         await access(action.source);
     }
     catch (err) {
         const msg = sourceAccessError(err, action.source);
-        logger.fail(label, msg);
-        return { error: msg };
+        return buildFailureResult(label, msg);
     }
     if (dryRun) {
-        planned.push({
+        return buildSuccessResult(label, undefined, {
             verb: action.method === "symlink" ? "create-symlink" : "copy-dir",
             kind: "skill-dir",
             skill: action.skill,
@@ -541,30 +629,27 @@ async function deploySkillDir(action, dryRun, verbose, home, planned, deps) {
             method: action.method,
             confidence: action.confidence,
         });
-        return { error: null };
     }
     try {
-        await executeDeployAction(action, verbose, home, deps);
-        return { error: null };
+        const logs = await executeDeployAction(action, verbose, home, deps);
+        return { error: null, logs };
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
-        logger.fail(label, msg);
-        return { error: msg };
+        return buildFailureResult(label, msg);
     }
 }
-async function deployFileWrite(action, dryRun, verbose, home, planned, deps) {
+async function deployFileWrite(action, dryRun, verbose, home, deps) {
     const label = `${action.skill} -> ${action.agent}`;
     try {
         await access(action.source);
     }
     catch (err) {
         const msg = sourceAccessError(err, action.source);
-        logger.fail(label, msg);
-        return { error: msg };
+        return buildFailureResult(label, msg);
     }
     if (dryRun) {
-        planned.push({
+        return buildSuccessResult(label, undefined, {
             verb: "write-file",
             kind: "file-write",
             skill: action.skill,
@@ -572,7 +657,6 @@ async function deployFileWrite(action, dryRun, verbose, home, planned, deps) {
             source: action.source,
             target: action.target,
         });
-        return { error: null };
     }
     try {
         await replaceFileAtomically(action.target, deps, (tempPath, fileOps) => fileOps.copyFile(action.source, tempPath), () => backupManagedFileWriteTarget(action, home, deps), () => registerDeployment(home, action.target, {
@@ -582,28 +666,22 @@ async function deployFileWrite(action, dryRun, verbose, home, planned, deps) {
             agent: action.agent,
             migratedFrom: action.migratedFrom,
         }, deps.registry));
-        logger.ok(label);
-        if (verbose) {
-            logger.detail(`write-file: ${action.source} -> ${action.target}`);
-        }
-        return { error: null };
+        return buildSuccessResult(label, verbose ? `write-file: ${action.source} -> ${action.target}` : undefined);
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
-        logger.fail(label, msg);
-        return { error: msg };
+        return buildFailureResult(label, msg);
     }
 }
-async function deployConfigPatch(action, dryRun, verbose, home, planned, deps) {
+async function deployConfigPatch(action, dryRun, verbose, home, deps) {
     const label = `${action.skill} -> ${action.agent}`;
     if (!isPlainObject(action.patch)) {
         const msg = `Config patch for skill "${action.skill}" must be a plain object`;
-        logger.fail(label, msg);
-        return { error: msg };
+        return buildFailureResult(label, msg);
     }
     const patch = action.patch;
     if (dryRun) {
-        planned.push({
+        return buildSuccessResult(label, undefined, {
             verb: "patch-config",
             kind: "config-patch",
             skill: action.skill,
@@ -611,7 +689,6 @@ async function deployConfigPatch(action, dryRun, verbose, home, planned, deps) {
             target: action.target,
             patch,
         });
-        return { error: null };
     }
     try {
         // Guard against double-patching by a different skill/agent
@@ -639,22 +716,19 @@ async function deployConfigPatch(action, dryRun, verbose, home, planned, deps) {
             skill: action.skill,
             agent: action.agent,
         }, deps.registry));
-        logger.ok(label);
-        if (verbose) {
-            logger.detail(`patch-config: applied ${Object.keys(patch).length} key(s) to ${action.target}`);
-        }
-        return { error: null };
+        return buildSuccessResult(label, verbose
+            ? `patch-config: applied ${Object.keys(patch).length} key(s) to ${action.target}`
+            : undefined);
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
-        logger.fail(label, msg);
-        return { error: msg };
+        return buildFailureResult(label, msg);
     }
 }
-async function deployTomlPatch(action, dryRun, verbose, home, planned, deps) {
+async function deployTomlPatch(action, dryRun, verbose, home, deps) {
     const label = `${action.skill} -> ${action.agent}`;
     if (dryRun) {
-        planned.push({
+        return buildSuccessResult(label, undefined, {
             verb: "patch-toml",
             kind: "toml-patch",
             skill: action.skill,
@@ -662,7 +736,6 @@ async function deployTomlPatch(action, dryRun, verbose, home, planned, deps) {
             target: action.target,
             patch: action.config,
         });
-        return { error: null };
     }
     try {
         const { previousValue } = await (deps.registry
@@ -677,27 +750,21 @@ async function deployTomlPatch(action, dryRun, verbose, home, planned, deps) {
             skill: action.skill,
             agent: action.agent,
         }, deps.registry);
-        logger.ok(label);
-        if (verbose) {
-            logger.detail(`patch-toml: ${action.target}`);
-        }
-        return { error: null };
+        return buildSuccessResult(label, verbose ? `patch-toml: ${action.target}` : undefined);
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
-        logger.fail(label, msg);
-        return { error: msg };
+        return buildFailureResult(label, msg);
     }
 }
-async function deployFrontmatterEmit(action, dryRun, verbose, home, planned, deps) {
+async function deployFrontmatterEmit(action, dryRun, verbose, home, deps) {
     const label = `${action.skill} -> ${action.agent}`;
     if (!isPlainObject(action.frontmatter)) {
         const msg = `Frontmatter patch for skill "${action.skill}" must be a plain object`;
-        logger.fail(label, msg);
-        return { error: msg };
+        return buildFailureResult(label, msg);
     }
     if (dryRun) {
-        planned.push({
+        return buildSuccessResult(label, undefined, {
             verb: "emit-frontmatter",
             kind: "frontmatter-emit",
             skill: action.skill,
@@ -705,7 +772,6 @@ async function deployFrontmatterEmit(action, dryRun, verbose, home, planned, dep
             target: action.target,
             frontmatter: action.frontmatter,
         });
-        return { error: null };
     }
     try {
         const existingEntry = await lookupDeployment(home, action.target, deps.registry);
@@ -742,16 +808,11 @@ async function deployFrontmatterEmit(action, dryRun, verbose, home, planned, dep
             skill: action.skill,
             agent: action.agent,
         }, deps.registry));
-        logger.ok(label);
-        if (verbose) {
-            logger.detail(`emit-frontmatter: ${action.target}`);
-        }
-        return { error: null };
+        return buildSuccessResult(label, verbose ? `emit-frontmatter: ${action.target}` : undefined);
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
-        logger.fail(label, msg);
-        return { error: msg };
+        return buildFailureResult(label, msg);
     }
 }
 async function validateSkillContract(source, skillPath) {
@@ -816,13 +877,13 @@ async function createDeployTarget(action, home, deps) {
     }, deps.registry);
 }
 async function executeDeployAction(action, verbose, home, deps) {
-    const label = `${action.skill} -> ${action.agent}`;
+    const logs = [];
     const backupPath = await backupExisting(action.target, verbose, home, {
         kind: action.kind,
         source: action.source,
         skill: action.skill,
         agent: action.agent,
-    }, deps);
+    }, deps, logs);
     await mkdir(path.dirname(action.target), { recursive: true });
     try {
         await assertTargetAbsent(action.target);
@@ -847,12 +908,11 @@ async function executeDeployAction(action, verbose, home, deps) {
     if (backupPath) {
         await (deps.skillDirOps ?? defaultSkillDirOps).removeTarget(backupPath);
     }
-    logger.ok(label);
-    if (verbose) {
-        logger.detail(`${action.method}: ${action.source} -> ${action.target}`);
-    }
+    logs.push({ kind: "ok", label: `${action.skill} -> ${action.agent}` });
+    pushVerboseDetail(logs, verbose, `${action.method}: ${action.source} -> ${action.target}`);
+    return logs;
 }
-async function backupExisting(targetPath, verbose, home, expected, deps) {
+async function backupExisting(targetPath, verbose, home, expected, deps, logs) {
     try {
         await lstat(targetPath);
     }
@@ -868,9 +928,7 @@ async function backupExisting(targetPath, verbose, home, expected, deps) {
         throw new UserError("DEPLOY_FAILED", `Target "${targetPath}" exists but is not managed by inception-engine - refusing to overwrite`);
     }
     const backupPath = `${targetPath}.inception-backup`;
-    if (verbose) {
-        logger.detail(`backing up existing target: ${targetPath}`);
-    }
+    pushVerboseDetail(logs, verbose, `backing up existing target: ${targetPath}`);
     // Remove any stale backup from a previous failed attempt. Using rm with
     // { force: true } avoids a separate lstat existence check and handles
     // the case where the stale backup is a directory (which rename cannot

package/dist/src/core/init.d.ts

@@ -1,4 +1,5 @@
 import type { AgentId } from "../schemas/manifest.ts";
+export declare function isInsideSkillDir(relPath: string, skillDirRelPaths: Set<string>): boolean;
 export interface InitOptions {
     directory: string;
     agents: AgentId[] | null;

package/dist/src/core/init.js

@@ -1,4 +1,4 @@
-import { access, readdir, readFile } from "node:fs/promises";
+import { access, opendir, readdir, readFile } from "node:fs/promises";
 import path from "node:path";
 import { AGENT_REGISTRY } from "../config/agents.js";
 import { dryRunPrefix, logger } from "../logger.js";
@@ -7,6 +7,7 @@ import { parseFrontmatterDocument } from "./adapters/frontmatter.js";
 import { writeFileAtomic } from "./atomic-write.js";
 import { shouldInitIncludeAgent } from "./capabilities.js";
 const SAFE_NAME_RE = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
+const SKILL_SCAN_CONCURRENCY = 8;
 // Ordered list: first match wins. Catch-all is applied at call site.
 // Derived from the registry: group agents by the filename of their global
 // agentRulesSupport path. Agents with requiresPrimary (e.g. github-copilot)
@@ -79,36 +80,81 @@ async function hasAntigravityMcpFrontmatter(absPath) {
     return (Object.hasOwn(attributes, "mcp-servers") ||
         Object.hasOwn(attributes, "mcpServers"));
 }
-async function findSkillDirs(baseDir, dir, found, signal) {
-    if (signal?.aborted)
-        return;
-    let entries;
+async function inspectSkillScanDir(dir) {
+    let handle = null;
     try {
-        entries = await readdir(dir, { withFileTypes: true, encoding: "utf-8" });
+        handle = await opendir(dir, { encoding: "utf-8" });
     }
     catch {
-        return;
+        return null;
     }
-    const hasSkillMd = entries.some((e) => e.isFile() && e.name === "SKILL.md");
-    if (hasSkillMd) {
-        const relPath = path.relative(baseDir, dir).split(path.sep).join("/");
-        const name = path.basename(dir);
-        if (SAFE_NAME_RE.test(name)) {
-            found.push({ relPath, name });
-        }
-        else {
-            logger.warn("init", `Skipping "${relPath}": directory name "${name}" is not a valid skill name`);
+    const subdirs = [];
+    try {
+        while (true) {
+            const entry = await handle.read();
+            if (entry === null)
+                break;
+            if (entry.isFile() && entry.name === "SKILL.md") {
+                return { hasSkillMd: true, subdirs: [] };
+            }
+            if (entry.isDirectory() && !entry.name.startsWith(".")) {
+                subdirs.push(path.join(dir, entry.name));
+            }
         }
-        // Don't recurse into a skill directory
+    }
+    finally {
+        await handle.close().catch(() => {
+            // Ignore double-close when returning early after finding SKILL.md.
+        });
+    }
+    return { hasSkillMd: false, subdirs };
+}
+function addFoundSkill(baseDir, dir, found) {
+    const relPath = path.relative(baseDir, dir).split(path.sep).join("/");
+    const name = path.basename(dir);
+    if (SAFE_NAME_RE.test(name)) {
+        found.push({ relPath, name });
         return;
     }
-    for (const entry of entries) {
+    logger.warn("init", `Skipping "${relPath}": directory name "${name}" is not a valid skill name`);
+}
+function enqueueSubdirs(queue, subdirs, signal) {
+    for (const subdir of subdirs) {
         if (signal?.aborted)
-            return;
-        if (entry.isDirectory() && !entry.name.startsWith(".")) {
-            await findSkillDirs(baseDir, path.join(dir, entry.name), found, signal);
+            return false;
+        queue.push(subdir);
+    }
+    return true;
+}
+async function processSkillScanDir(baseDir, dir, queue, found, signal) {
+    const scanned = await inspectSkillScanDir(dir);
+    if (scanned === null)
+        return true;
+    if (scanned.hasSkillMd) {
+        addFoundSkill(baseDir, dir, found);
+        return true;
+    }
+    return enqueueSubdirs(queue, scanned.subdirs, signal);
+}
+async function findSkillDirs(baseDir, startDir, signal) {
+    const found = [];
+    const queue = [startDir];
+    async function worker() {
+        while (queue.length > 0) {
+            if (signal?.aborted)
+                return;
+            const dir = queue.shift();
+            if (!dir)
+                return;
+            if (!(await processSkillScanDir(baseDir, dir, queue, found, signal))) {
+                return;
+            }
         }
     }
+    const workerCount = Math.min(SKILL_SCAN_CONCURRENCY, queue.length || 1);
+    await Promise.all(Array.from({ length: workerCount }, () => worker()));
+    found.sort((a, b) => a.relPath.localeCompare(b.relPath));
+    return found;
 }
 function resolveSkillName(relPath, name, namesSeen) {
     if (!namesSeen.has(name))
@@ -141,11 +187,17 @@ function defaultAgentsForFile(fileName, fallback) {
     }
     return fallback;
 }
-function isInsideSkillDir(relPath, skillDirRelPaths) {
-    const parentRelPath = path.dirname(relPath).split(path.sep).join("/");
-    if (skillDirRelPaths.has(parentRelPath))
-        return true;
-    return [...skillDirRelPaths].some((sp) => parentRelPath === sp || parentRelPath.startsWith(`${sp}/`));
+export function isInsideSkillDir(relPath, skillDirRelPaths) {
+    let parentRelPath = path.posix.dirname(relPath.split(path.sep).join("/"));
+    while (parentRelPath !== "." && parentRelPath !== "/") {
+        if (skillDirRelPaths.has(parentRelPath))
+            return true;
+        const nextParent = path.posix.dirname(parentRelPath);
+        if (nextParent === parentRelPath)
+            break;
+        parentRelPath = nextParent;
+    }
+    return false;
 }
 function deriveAgentRulesName(relPath, fileName) {
     const ext = path.extname(fileName).toLowerCase();
@@ -634,8 +686,7 @@ export async function runInit(options) {
         logger.error(`Error: ${manifestPath} already exists. Use --force to overwrite.`);
         return 2;
     }
-    const found = [];
-    await findSkillDirs(directory, directory, found, signal);
+    const found = await findSkillDirs(directory, directory, signal);
     if (signal?.aborted)
         return 0;
     if (found.length === 0) {

package/dist/src/core/preflight.js

@@ -2,6 +2,7 @@ import { readFile, stat } from "node:fs/promises";
 import path from "node:path";
 import { AGENT_REGISTRY_BY_ID } from "../config/agents.js";
 import { describeCapabilityConfidence, planCapabilityForDeploy, } from "./capabilities.js";
+import { mapConcurrentOrdered } from "./concurrency.js";
 import { resolveRuntimePaths } from "./runtime-paths.js";
 const BUDGET_WARN_BYTES = 50 * 1024; // 50 KB
 async function detectEnterpriseManagement(agentId, home) {
@@ -314,10 +315,11 @@ async function collectAgentWarnings(agentId, manifest, home) {
 }
 export async function runPreflight(options, manifest, home, detectedAgents, signal) {
     const warnings = [];
-    for (const agentId of detectedAgents) {
-        if (signal?.aborted)
-            return warnings;
-        warnings.push(...(await collectAgentWarnings(agentId, manifest, home)));
+    const agentWarnings = await mapConcurrentOrdered(detectedAgents, (agentId) => collectAgentWarnings(agentId, manifest, home), { signal });
+    for (const warningSet of agentWarnings) {
+        if (!warningSet)
+            continue;
+        warnings.push(...warningSet);
     }
     if (signal?.aborted)
         return warnings;