@intent-systems/nexus 2026.1.5-4 → 2026.1.5-8

package/dist/commands/onboard-quickstart.js

@@ -1,18 +1,18 @@
 import net from "node:net";
+import { CLAUDE_CLI_PROFILE_ID, CODEX_CLI_PROFILE_ID, ensureAuthProfileStore, } from "../agents/auth-profiles.js";
 import { CONFIG_PATH_NEXUS, readConfigFileSnapshot, resolveGatewayPort, writeConfigFile, } from "../config/config.js";
-import { resolveGatewayService } from "../daemon/service.js";
-import { resolveGatewayProgramArguments } from "../daemon/program-args.js";
 import { GATEWAY_LAUNCH_AGENT_LABEL } from "../daemon/constants.js";
+import { resolveGatewayProgramArguments } from "../daemon/program-args.js";
+import { resolveGatewayService } from "../daemon/service.js";
 import { ensureControlUiAssetsBuilt } from "../infra/control-ui-assets.js";
 import { defaultRuntime } from "../runtime.js";
 import { resolveUserPath, sleep } from "../utils.js";
+import { applyBootstrapPreset } from "./bootstrap-preset.js";
 import { healthCommand } from "./health.js";
 import { applyAuthProfileConfig, setAnthropicApiKey } from "./onboard-auth.js";
-import { applyBootstrapPreset } from "./bootstrap-preset.js";
 import { applyWizardMetadata, DEFAULT_WORKSPACE, detectBrowserOpenSupport, ensureWorkspaceAndSessions, openUrl, resolveControlUiLinks, } from "./onboard-helpers.js";
-import { CLAUDE_CLI_PROFILE_ID, CODEX_CLI_PROFILE_ID, ensureAuthProfileStore, } from "../agents/auth-profiles.js";
-import { ensureSystemdUserLingerNonInteractive } from "./systemd-linger.js";
 import { applyOpenAICodexModelDefault } from "./openai-codex-model-default.js";
+import { ensureSystemdUserLingerNonInteractive } from "./systemd-linger.js";
 async function isPortFree(port) {
     try {
         await new Promise((resolve, reject) => {
@@ -51,7 +51,7 @@ async function pickGatewayPort(preferred) {
     });
 }
 function applyQuickstartAuth(cfg, runtime) {
-    // Sync external credentials (Keychain on macOS, ~/.claude, ~/.codex) into the store.
+    // Quickstart only considers credentials already imported into the store.
     const store = ensureAuthProfileStore();
     // 1) Prefer OpenAI Codex credentials if present (works without API keys).
     if (store.profiles[CODEX_CLI_PROFILE_ID]) {
@@ -79,9 +79,9 @@ function applyQuickstartAuth(cfg, runtime) {
     // valid for general Anthropic API requests. We avoid auto-selecting them here.
     // Users can still opt in via `nexus onboard` interactive.
     if (store.profiles[CLAUDE_CLI_PROFILE_ID]) {
-        runtime.log('Detected Claude Code credentials, but Nexus may require an Anthropic API key (or another provider) for API access. Run `nexus onboard` to choose billing/auth.');
+        runtime.log("Detected Claude Code credentials, but Nexus may require an Anthropic API key (or another provider) for API access. Run `nexus onboard` to choose billing/auth.");
     }
-    runtime.log("No Claude/Codex credentials detected yet. You can set this later via `nexus onboard` or `nexus configure`.");
+    runtime.log("No Claude/Codex credentials detected yet. If you use the CLIs, run `nexus credential import claude-cli` or `nexus credential import codex-cli`.");
     return cfg;
 }
 export async function runQuickstartOnboarding(opts, runtime = defaultRuntime) {
@@ -113,14 +113,19 @@ export async function runQuickstartOnboarding(opts, runtime = defaultRuntime) {
         },
     };
     nextConfig = applyQuickstartAuth(nextConfig, runtime);
-    nextConfig = applyWizardMetadata(nextConfig, { command: "onboard", mode: "local" });
+    nextConfig = applyWizardMetadata(nextConfig, {
+        command: "onboard",
+        mode: "local",
+    });
     await writeConfigFile(nextConfig);
     runtime.log(`Updated ${CONFIG_PATH_NEXUS}`);
     await ensureWorkspaceAndSessions(workspaceDir, runtime, {
         skipBootstrap: Boolean(nextConfig.agent?.skipBootstrap),
     });
     // Scripted bootstrap (test harness / automation): fill identity files + delete BOOTSTRAP.md.
-    if (opts.bootstrapPreset || opts.bootstrapAgentName || opts.bootstrapUserName) {
+    if (opts.bootstrapPreset ||
+        opts.bootstrapAgentName ||
+        opts.bootstrapUserName) {
         await applyBootstrapPreset({
             workspaceDir,
             runtime,
@@ -142,7 +147,9 @@ export async function runQuickstartOnboarding(opts, runtime = defaultRuntime) {
             const { programArguments, workingDirectory } = await resolveGatewayProgramArguments({ port, dev: devMode });
             const environment = {
                 PATH: process.env.PATH,
-                NEXUS_LAUNCHD_LABEL: process.platform === "darwin" ? GATEWAY_LAUNCH_AGENT_LABEL : undefined,
+                NEXUS_LAUNCHD_LABEL: process.platform === "darwin"
+                    ? GATEWAY_LAUNCH_AGENT_LABEL
+                    : undefined,
             };
             await service.install({
                 env: process.env,

package/dist/commands/quest-state.js

@@ -0,0 +1,271 @@
+import fs from "node:fs";
+import path from "node:path";
+import { DEFAULT_AGENT_WORKSPACE_DIR } from "../agents/workspace.js";
+import { loadConfig } from "../config/config.js";
+import { resolveUserPath } from "../utils.js";
+const QUEST_CATALOG = [
+    {
+        id: "identity-setup",
+        title: "Identity setup",
+        description: "Create the agent + user identity files.",
+        path: "core",
+        weight: 10,
+        quickWin: true,
+    },
+    {
+        id: "filesystem-wow",
+        title: "Filesystem organization",
+        description: "Use home/ projects + memory for a quick win.",
+        path: "core",
+        weight: 5,
+        quickWin: true,
+    },
+    {
+        id: "credential-manager",
+        title: "Credential manager",
+        description: "Store your first credentials for secure access.",
+        path: "core",
+        weight: 15,
+    },
+    {
+        id: "cloud-backup",
+        title: "Cloud backup",
+        description: "Set up Nexus Cloud sync + rollback.",
+        path: "core",
+        weight: 10,
+    },
+    {
+        id: "connect-email",
+        title: "Connect email",
+        description: "Unlock email read/send capabilities.",
+        path: "breadth",
+        weight: 10,
+    },
+    {
+        id: "connect-messages",
+        title: "Connect messages",
+        description: "Unlock messaging read/send capabilities.",
+        path: "breadth",
+        weight: 10,
+    },
+    {
+        id: "connect-calendar",
+        title: "Connect calendar",
+        description: "Unlock calendar access.",
+        path: "breadth",
+        weight: 5,
+    },
+    {
+        id: "enable-llm",
+        title: "Enable LLM",
+        description: "Configure an LLM provider.",
+        path: "breadth",
+        weight: 5,
+    },
+    {
+        id: "enable-scheduling",
+        title: "Enable scheduling",
+        description: "Turn on scheduling automation.",
+        path: "power",
+        weight: 10,
+    },
+    {
+        id: "enable-agent-comms",
+        title: "Enable agent comms",
+        description: "Let your agent reach you outside the IDE.",
+        path: "power",
+        weight: 15,
+    },
+    {
+        id: "first-automation",
+        title: "First automation",
+        description: "Set up a reactive trigger.",
+        path: "power",
+        weight: 5,
+    },
+    {
+        id: "completionist",
+        title: "Completionist",
+        description: "Unlock everything in the catalog.",
+        path: "secret",
+        weight: 5,
+    },
+    {
+        id: "polyglot",
+        title: "Polyglot",
+        description: "Connect 3+ distinct messaging platforms.",
+        path: "secret",
+        weight: 5,
+    },
+    {
+        id: "social-butterfly",
+        title: "Social butterfly",
+        description: "Connect multiple social networks.",
+        path: "secret",
+        weight: 5,
+    },
+    {
+        id: "home-automation",
+        title: "Home automation",
+        description: "Activate smart home capabilities.",
+        path: "secret",
+        weight: 5,
+    },
+    {
+        id: "full-stack",
+        title: "Full stack",
+        description: "Enable web + automation + dev tooling.",
+        path: "secret",
+        weight: 5,
+    },
+];
+const QUEST_ORDER = QUEST_CATALOG.map((quest) => quest.id);
+const QUEST_PROGRESS_VERSION = 1;
+const PROGRESS_NOTE = "Progress is computed dynamically; no persistent progress.json.";
+function getCapabilityStatusMap(capabilities) {
+    return new Map(capabilities.map((cap) => [cap.id, cap.status]));
+}
+function isCapabilityReady(status) {
+    return status === "active" || status === "ready";
+}
+async function dirHasEntries(dir) {
+    try {
+        const entries = await fs.promises.readdir(dir, { withFileTypes: true });
+        return entries.some((entry) => entry.name && !entry.name.startsWith("."));
+    }
+    catch {
+        return false;
+    }
+}
+function resolveWorkspaceDir() {
+    const config = loadConfig();
+    return resolveUserPath(config.agent?.workspace ?? DEFAULT_AGENT_WORKSPACE_DIR);
+}
+function computeQuestAutoCompletion(params) {
+    const { identityConfigured, capabilities, credentials, workspaceDir } = params;
+    const capabilityMap = getCapabilityStatusMap(capabilities);
+    const hasCredentials = Object.keys(credentials.services ?? {}).length > 0;
+    const anyReady = (ids) => ids.some((id) => isCapabilityReady(capabilityMap.get(id)));
+    return (async () => {
+        const hasProjects = await dirHasEntries(path.join(workspaceDir, "projects"));
+        const hasMemory = await dirHasEntries(path.join(workspaceDir, "memory"));
+        const readySocial = anyReady(["social-x", "social-instagram", "social-linkedin"]) ||
+            anyReady(["social", "social-news"]);
+        const readyMessaging = anyReady(["messaging-read", "messaging-send"]);
+        const readyChat = anyReady(["chat-send", "chat-read"]);
+        const readySmartHome = anyReady([
+            "smart-lights",
+            "smart-audio",
+            "smart-sleep",
+            "bluetooth",
+            "camera-control",
+        ]);
+        const readyDev = anyReady(["version-control", "terminal-sessions"]);
+        const readyWeb = anyReady(["web-search", "url-fetch"]);
+        const readyAutomation = anyReady(["reactive-triggers"]);
+        return {
+            "identity-setup": identityConfigured,
+            "filesystem-wow": hasProjects || hasMemory,
+            "credential-manager": hasCredentials,
+            "cloud-backup": anyReady(["cloud-sync", "rollback"]),
+            "connect-email": anyReady(["email-read", "email-send"]),
+            "connect-messages": readyMessaging,
+            "connect-calendar": anyReady(["calendar"]),
+            "enable-llm": anyReady(["anthropic", "openai", "gemini"]),
+            "enable-scheduling": anyReady(["scheduling"]),
+            "enable-agent-comms": readyChat || readyMessaging,
+            "first-automation": readyAutomation,
+            completionist: capabilities.every((cap) => cap.status === "active"),
+            polyglot: readyMessaging && readyChat,
+            "social-butterfly": readySocial,
+            "home-automation": readySmartHome,
+            "full-stack": readyWeb && readyAutomation && readyDev,
+        };
+    })();
+}
+function computePower(quests) {
+    const baseQuests = quests.filter((quest) => quest.path !== "secret");
+    const bonusQuests = quests.filter((quest) => quest.path === "secret" && quest.status === "completed");
+    const baseTotal = baseQuests.reduce((sum, quest) => sum + quest.weight, 0);
+    const baseScore = baseQuests.reduce((sum, quest) => sum + (quest.status === "completed" ? quest.weight : 0), 0);
+    const bonus = bonusQuests.reduce((sum, quest) => sum + quest.weight, 0);
+    const percent = baseTotal > 0 ? Math.round((baseScore / baseTotal) * 100) : 0;
+    const nextQuest = baseQuests.find((quest) => quest.status !== "completed");
+    return {
+        score: baseScore + bonus,
+        baseTotal,
+        percent: Math.min(100, Math.max(0, percent)),
+        bonus,
+        nextQuest: nextQuest
+            ? { id: nextQuest.id, title: nextQuest.title, weight: nextQuest.weight }
+            : undefined,
+    };
+}
+function buildProgressSnapshot(quests, updatedAt) {
+    const entries = {};
+    for (const quest of quests) {
+        entries[quest.id] = {
+            status: quest.status,
+            completedAt: quest.status === "completed" ? updatedAt : undefined,
+            updatedAt,
+        };
+    }
+    return {
+        version: QUEST_PROGRESS_VERSION,
+        updatedAt,
+        quests: entries,
+    };
+}
+function sortQuests(a, b) {
+    const aIdx = QUEST_ORDER.indexOf(a.id);
+    const bIdx = QUEST_ORDER.indexOf(b.id);
+    if (aIdx !== -1 && bIdx !== -1)
+        return aIdx - bIdx;
+    if (aIdx !== -1)
+        return -1;
+    if (bIdx !== -1)
+        return 1;
+    return a.title.localeCompare(b.title);
+}
+export async function resolveQuestState(params) {
+    const workspaceDir = params.workspaceDir ?? resolveWorkspaceDir();
+    const autoCompletion = await computeQuestAutoCompletion({
+        identityConfigured: params.identityConfigured,
+        capabilities: params.capabilities,
+        credentials: params.credentials,
+        workspaceDir,
+    });
+    const now = new Date().toISOString();
+    const quests = QUEST_CATALOG.filter((quest) => params.includeSecrets || quest.path !== "secret").map((quest) => {
+        const autoCompleted = Boolean(autoCompletion[quest.id]);
+        const status = autoCompleted ? "completed" : "not_started";
+        return {
+            ...quest,
+            status,
+            autoCompleted,
+        };
+    });
+    quests.sort(sortQuests);
+    const power = computePower(quests);
+    const progress = buildProgressSnapshot(quests, now);
+    progress.note = PROGRESS_NOTE;
+    return { quests, progress, power };
+}
+export async function startQuest(questId) {
+    const now = new Date().toISOString();
+    return {
+        version: QUEST_PROGRESS_VERSION,
+        updatedAt: now,
+        quests: {
+            [questId]: {
+                status: "in_progress",
+                startedAt: now,
+                updatedAt: now,
+            },
+        },
+        note: PROGRESS_NOTE,
+    };
+}
+export function getQuestCatalog() {
+    return [...QUEST_CATALOG];
+}

package/dist/commands/quest.js

@@ -1,27 +1,67 @@
-import { defaultRuntime } from "../runtime.js";
+import { resolveIdentitySnapshot } from "../agents/identity-state.js";
 import { detectCapabilities } from "../capabilities/detector.js";
+import { defaultRuntime } from "../runtime.js";
+import { listCredentials } from "./credential.js";
+import { getQuestCatalog, resolveQuestState, startQuest, } from "./quest-state.js";
 export async function questCommand(opts, runtime = defaultRuntime) {
+    if (opts?.start) {
+        const catalog = getQuestCatalog();
+        if (!catalog.some((quest) => quest.id === opts.start)) {
+            runtime.error(`Unknown quest: ${opts.start}`);
+            runtime.exit(1);
+            return;
+        }
+        await startQuest(opts.start);
+        if (!opts.json) {
+            runtime.log(`Marked quest as in-progress: ${opts.start}`);
+            runtime.log("Note: quest progress is computed dynamically (no progress.json).");
+        }
+    }
     const snapshot = detectCapabilities();
-    const suggestions = snapshot.capabilities
-        .filter((cap) => ["needs_setup", "needs_install", "ready"].includes(cap.status))
-        .slice(0, 5)
-        .map((cap) => ({
-        id: cap.id,
-        status: cap.status,
-        providers: cap.providers.map((p) => p.id),
-    }));
+    const credentials = await listCredentials();
+    const identityResolution = resolveIdentitySnapshot();
+    const identityConfigured = identityResolution.ok
+        ? identityResolution.snapshot.hasIdentity
+        : false;
+    const questState = await resolveQuestState({
+        identityConfigured,
+        capabilities: snapshot.capabilities,
+        credentials,
+        includeSecrets: Boolean(opts?.secrets),
+    });
+    let quests = questState.quests;
+    if (opts?.powerPath) {
+        quests = quests.filter((quest) => quest.path === "power");
+    }
+    if (opts?.quickWins) {
+        quests = quests.filter((quest) => quest.quickWin);
+    }
+    if (!opts?.list && !opts?.progress) {
+        quests = quests.filter((quest) => quest.status !== "completed").slice(0, 5);
+    }
     if (opts?.json) {
         runtime.log(JSON.stringify({
-            suggestions,
+            power: questState.power,
+            quests,
+            progress: questState.progress,
         }, null, 2));
         return;
     }
-    if (suggestions.length === 0) {
+    if (opts?.progress) {
+        const completed = quests.filter((quest) => quest.status === "completed").length;
+        runtime.log(`Quest progress: ${completed}/${quests.length} complete (${questState.power.percent}%)`);
+        if (questState.power.nextQuest) {
+            runtime.log(`Next unlock: ${questState.power.nextQuest.title} (+${questState.power.nextQuest.weight}%)`);
+        }
+        return;
+    }
+    if (quests.length === 0) {
         runtime.log("No quests found. You're fully configured.");
         return;
     }
     runtime.log("Quests");
-    for (const [idx, item] of suggestions.entries()) {
-        runtime.log(`  ${idx + 1}. ${item.id} (${item.status})`);
+    for (const [idx, item] of quests.entries()) {
+        const pathLabel = item.path === "secret" ? "secret" : item.path;
+        runtime.log(`  ${idx + 1}. ${item.id} (${pathLabel}, ${item.status})`);
     }
 }

package/dist/commands/reset.js

@@ -7,7 +7,7 @@ import { defaultRuntime } from "../runtime.js";
  * Requires --confirm flag to actually delete.
  */
 export async function resetCommand(opts = {}, runtime = defaultRuntime) {
-    const { local = false, state = false, all = false, confirm = false, workspace } = opts;
+    const { local = false, state = false, all = false, confirm = false, workspace, } = opts;
     // Validate: at least one target must be specified
     if (!local && !state && !all) {
         throw new Error("Must specify at least one target: --local, --state, or --all");

package/dist/commands/sessions-ingest.js

@@ -56,7 +56,10 @@ function lexicalToPlainText(raw) {
             }
         };
         walk(root);
-        return out.join("").replace(/\n{3,}/g, "\n\n").trim();
+        return out
+            .join("")
+            .replace(/\n{3,}/g, "\n\n")
+            .trim();
     }
     catch {
         return raw;
@@ -119,9 +122,7 @@ async function findCursorWorkspaceStorageDir(params) {
                 return { hash, dir, stateDbPath };
             }
         }
-        catch {
-            continue;
-        }
+        catch { }
     }
     return null;
 }

package/dist/commands/setup.js

@@ -1,7 +1,7 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import JSON5 from "json5";
-import { DEFAULT_AGENT_WORKSPACE_DIR, ensureAgentWorkspace } from "../agents/workspace.js";
+import { DEFAULT_AGENT_WORKSPACE_DIR, ensureAgentWorkspace, } from "../agents/workspace.js";
 import { CONFIG_PATH_NEXUS } from "../config/config.js";
 import { applyModelDefaults } from "../config/defaults.js";
 import { resolveSessionTranscriptsDir } from "../config/sessions.js";
@@ -21,7 +21,9 @@ async function readConfigFileRaw() {
 }
 async function writeConfigFile(cfg) {
     await fs.mkdir(path.dirname(CONFIG_PATH_NEXUS), { recursive: true });
-    const json = JSON.stringify(applyModelDefaults(cfg), null, 2).trimEnd().concat("\n");
+    const json = JSON.stringify(applyModelDefaults(cfg), null, 2)
+        .trimEnd()
+        .concat("\n");
     await fs.writeFile(CONFIG_PATH_NEXUS, json, "utf-8");
 }
 export async function setupCommand(opts, runtime = defaultRuntime) {

package/dist/commands/skills-manifest.js

@@ -2,7 +2,7 @@ import fs from "node:fs";
 import fsp from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { resolveStateDir } from "../config/paths.js";
+import { SKILLS_STATE_DIR } from "../utils.js";
 /**
  * Parse skill frontmatter to extract name and description
  */
@@ -16,7 +16,7 @@ function parseSkillFrontmatter(content) {
         return result;
     const block = normalized.slice(4, endIndex);
     for (const line of block.split("\n")) {
-        const match = line.match(/^(name|description):\s*(.*)$/);
+        const match = line.match(/^(name|description|type|metadata):\s*(.*)$/);
         if (!match)
             continue;
         const key = match[1];
@@ -26,10 +26,40 @@ function parseSkillFrontmatter(content) {
             (value.startsWith("'") && value.endsWith("'"))) {
             value = value.slice(1, -1);
         }
-        result[key] = value;
+        if (key === "metadata") {
+            result.metadataRaw = value;
+        }
+        else {
+            result[key] = value;
+        }
     }
     return result;
 }
+function resolveSkillRootDirs(rootDir) {
+    const typedDirs = ["tools", "connectors", "guides"].map((segment) => path.join(rootDir, segment));
+    const existingTyped = typedDirs.filter((dir) => fs.existsSync(dir));
+    if (existingTyped.length > 0)
+        return existingTyped;
+    return fs.existsSync(rootDir) ? [rootDir] : [];
+}
+function resolveSkillType(frontmatter) {
+    if (frontmatter.type === "tool" || frontmatter.type === "connector" || frontmatter.type === "guide") {
+        return frontmatter.type;
+    }
+    if (!frontmatter.metadataRaw)
+        return null;
+    try {
+        const parsed = JSON.parse(frontmatter.metadataRaw);
+        const type = parsed?.nexus?.type;
+        if (type === "tool" || type === "connector" || type === "guide") {
+            return type;
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
 /**
  * Resolve the bundled skills directory from the installed Nexus package.
  * This finds skills shipped with the CLI, NOT from user workspace.
@@ -98,6 +128,17 @@ async function scanSkillsDir(dir, source) {
     }
     return skills;
 }
+async function scanSkillRoots(rootDir, source) {
+    const roots = resolveSkillRootDirs(rootDir);
+    const merged = {};
+    for (const root of roots) {
+        const scanned = await scanSkillsDir(root, source);
+        for (const [name, entry] of Object.entries(scanned)) {
+            merged[name] = entry;
+        }
+    }
+    return merged;
+}
 /**
  * Copy bundled skills from installed package to ~/nexus/skills/
  */
@@ -113,29 +154,48 @@ export async function copyBundledSkills(targetDir) {
         return result;
     }
     await fsp.mkdir(targetDir, { recursive: true });
-    const entries = await fsp.readdir(bundledDir, { withFileTypes: true });
-    for (const entry of entries) {
-        if (!entry.isDirectory())
-            continue;
-        if (entry.name.startsWith("."))
-            continue;
-        const sourcePath = path.join(bundledDir, entry.name);
-        const targetPath = path.join(targetDir, entry.name);
-        // Check if SKILL.md exists
-        if (!fs.existsSync(path.join(sourcePath, "SKILL.md")))
-            continue;
-        try {
-            // Check if already exists
-            if (fs.existsSync(targetPath)) {
-                result.skipped.push(entry.name);
+    const bundledRoots = resolveSkillRootDirs(bundledDir);
+    for (const root of bundledRoots) {
+        const entries = await fsp.readdir(root, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory())
                 continue;
+            if (entry.name.startsWith("."))
+                continue;
+            const sourcePath = path.join(root, entry.name);
+            const skillPath = path.join(sourcePath, "SKILL.md");
+            if (!fs.existsSync(skillPath))
+                continue;
+            let targetBase = targetDir;
+            if (root !== bundledDir) {
+                targetBase = path.join(targetDir, path.basename(root));
+            }
+            else {
+                try {
+                    const content = await fsp.readFile(skillPath, "utf-8");
+                    const frontmatter = parseSkillFrontmatter(content);
+                    const type = resolveSkillType(frontmatter);
+                    if (type) {
+                        targetBase = path.join(targetDir, `${type}s`);
+                    }
+                }
+                catch {
+                    // keep default targetBase
+                }
+            }
+            const targetPath = path.join(targetBase, entry.name);
+            try {
+                await fsp.mkdir(targetBase, { recursive: true });
+                if (fs.existsSync(targetPath)) {
+                    result.skipped.push(entry.name);
+                    continue;
+                }
+                await fsp.cp(sourcePath, targetPath, { recursive: true });
+                result.copied.push(entry.name);
+            }
+            catch (err) {
+                result.errors.push(`${entry.name}: ${err instanceof Error ? err.message : String(err)}`);
             }
-            // Copy recursively
-            await fsp.cp(sourcePath, targetPath, { recursive: true });
-            result.copied.push(entry.name);
-        }
-        catch (err) {
-            result.errors.push(`${entry.name}: ${err instanceof Error ? err.message : String(err)}`);
         }
     }
     return result;
@@ -145,17 +205,17 @@ export async function copyBundledSkills(targetDir) {
  */
 export async function generateSkillManifest(skillsDir, userSkillsDir) {
     // Skills in ~/nexus/skills/ are considered "bundled" (copied from package)
-    // Skills user installs via NexusHub go in a managed/ subfolder or directly
+    // Managed skills live under ~/nexus/skills/managed/
     // User skills are in ~/nexus/home/skills/
-    const bundledSkills = await scanSkillsDir(skillsDir, "bundled");
+    const bundledSkills = await scanSkillRoots(skillsDir, "bundled");
     // Check for managed subfolder (NexusHub installs)
     const managedDir = path.join(skillsDir, "managed");
     const managedSkills = fs.existsSync(managedDir)
-        ? await scanSkillsDir(managedDir, "managed")
+        ? await scanSkillRoots(managedDir, "managed")
         : {};
     // User skills from workspace
     const userSkills = userSkillsDir
-        ? await scanSkillsDir(userSkillsDir, "user")
+        ? await scanSkillRoots(userSkillsDir, "user")
         : {};
     return {
         version: 1,
@@ -178,7 +238,7 @@ export async function generateSkillManifest(skillsDir, userSkillsDir) {
  * Get the path to the skills manifest file
  */
 export function getSkillManifestPath() {
-    return path.join(resolveStateDir(), "nexus", "skills", "manifest.json");
+    return path.join(SKILLS_STATE_DIR, "manifest.json");
 }
 /**
  * Write the skill manifest to disk