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

package/dist/agents/identity-state.js

@@ -2,10 +2,44 @@ import fs from "node:fs";
 import path from "node:path";
 import { resolveBootstrapPath, resolveStateDir } from "../config/paths.js";
 import { resolveAgentId } from "./agent-id.js";
+function parseFrontmatter(content) {
+    const frontmatter = {};
+    const normalized = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+    if (!normalized.startsWith("---"))
+        return frontmatter;
+    const endIndex = normalized.indexOf("\n---", 3);
+    if (endIndex === -1)
+        return frontmatter;
+    const block = normalized.slice(4, endIndex);
+    for (const line of block.split("\n")) {
+        const match = line.match(/^([\w-]+)\s*:\s*(.*)$/);
+        if (!match)
+            continue;
+        const key = match[1].trim().toLowerCase();
+        const rawValue = match[2].trim();
+        if (!key || !rawValue)
+            continue;
+        const value = (rawValue.startsWith('"') && rawValue.endsWith('"')) ||
+            (rawValue.startsWith("'") && rawValue.endsWith("'"))
+            ? rawValue.slice(1, -1)
+            : rawValue;
+        frontmatter[key] = value;
+    }
+    return frontmatter;
+}
+function escapeRegex(input) {
+    return input.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 function readField(pathname, label) {
     try {
         const raw = fs.readFileSync(pathname, "utf-8");
-        const regex = new RegExp(`^[-*]?\\s*${label}\\s*:\\s*(.+)$`, "im");
+        const frontmatter = parseFrontmatter(raw);
+        const key = label.trim().toLowerCase();
+        const frontmatterValue = frontmatter[key];
+        if (frontmatterValue)
+            return frontmatterValue;
+        const escaped = escapeRegex(label.trim());
+        const regex = new RegExp(`^[-*]?\\s*(?:\\*\\*)?${escaped}(?:\\*\\*)?\\s*:\\s*(.+)$`, "im");
         const match = raw.match(regex);
         return match?.[1]?.trim();
     }
@@ -13,20 +47,8 @@ function readField(pathname, label) {
         return undefined;
     }
 }
-function hasPopulatedField(pathname) {
-    try {
-        const raw = fs.readFileSync(pathname, "utf-8");
-        const lines = raw.split(/\r?\n/);
-        return lines.some((line) => {
-            const match = line.match(/^[-*]?\s*[^:]+:\s*(.+)$/);
-            if (!match)
-                return false;
-            return match[1].trim().length > 0;
-        });
-    }
-    catch {
-        return false;
-    }
+function hasNamedIdentity(pathname) {
+    return Boolean(readField(pathname, "Name"));
 }
 function resolveAgentFromState(resolution, stateDir) {
     if (!resolution.ok) {
@@ -37,20 +59,20 @@ function resolveAgentFromState(resolution, stateDir) {
         };
     }
     const agentId = resolution.agentId;
-    const agentIdentityDir = path.join(stateDir, "agents", agentId, "identity");
-    const userIdentityDir = path.join(stateDir, "user", "identity");
+    const agentIdentityDir = path.join(stateDir, "agents", agentId);
+    const userIdentityDir = path.join(stateDir, "user");
     const agentIdentityPath = path.join(agentIdentityDir, "IDENTITY.md");
     const agentSoulPath = path.join(agentIdentityDir, "SOUL.md");
     const agentMemoryPath = path.join(agentIdentityDir, "MEMORY.md");
-    const userProfilePath = path.join(userIdentityDir, "PROFILE.md");
+    const userIdentityPath = path.join(userIdentityDir, "IDENTITY.md");
     const bootstrapPath = resolveBootstrapPath(undefined, stateDir);
     const agentIdentityExists = fs.existsSync(agentIdentityPath);
     const agentSoulExists = fs.existsSync(agentSoulPath);
     const agentMemoryExists = fs.existsSync(agentMemoryPath);
-    const userProfileExists = fs.existsSync(userProfilePath);
-    const hasIdentity = hasPopulatedField(agentIdentityPath) && hasPopulatedField(userProfilePath);
+    const userIdentityExists = fs.existsSync(userIdentityPath);
+    const hasIdentity = hasNamedIdentity(agentIdentityPath) && hasNamedIdentity(userIdentityPath);
     const agentName = readField(agentIdentityPath, "Name");
-    const userName = readField(userProfilePath, "Name");
+    const userName = readField(userIdentityPath, "Name");
     return {
         ok: true,
         snapshot: {
@@ -62,12 +84,12 @@ function resolveAgentFromState(resolution, stateDir) {
             agentIdentityPath,
             agentSoulPath,
             agentMemoryPath,
-            userProfilePath,
+            userIdentityPath,
             bootstrapPath,
             agentIdentityExists,
             agentSoulExists,
             agentMemoryExists,
-            userProfileExists,
+            userIdentityExists,
             hasIdentity,
         },
     };

package/dist/agents/skill-runner.js

@@ -2,7 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { loadConfig } from "../config/config.js";
 import { runCommandWithTimeout } from "../process/exec.js";
-import { MANAGED_SKILLS_DIR, resolveUserPath } from "../utils.js";
+import { NEXUS_ROOT, resolveUserPath } from "../utils.js";
 import { getSkillExecutionType, getSkillScriptConfig, getSkillToolConfig, } from "./skill-tools.js";
 import { recordSkillUsage } from "./skill-usage.js";
 import { getSkillMetadata, hasBinary, loadWorkspaceSkillEntries, } from "./skills.js";
@@ -11,7 +11,7 @@ import { DEFAULT_AGENT_WORKSPACE_DIR } from "./workspace.js";
 function loadSkillContext(name) {
     const config = loadConfig();
     const workspaceDir = resolveUserPath(config.agent?.workspace ?? DEFAULT_AGENT_WORKSPACE_DIR);
-    const managedSkillsDir = MANAGED_SKILLS_DIR;
+    const managedSkillsDir = path.join(NEXUS_ROOT, "skills", "managed");
     const entries = loadWorkspaceSkillEntries(workspaceDir, {
         config,
         managedSkillsDir,
@@ -200,6 +200,8 @@ export async function verifySkill(name) {
         return { ok: false, error: `Missing requirements: ${missingSummary}` };
     }
     const execType = getSkillExecutionType(entry.skill.name);
+    const metadata = getSkillMetadata(entry);
+    const metaType = metadata?.type;
     if (execType === "prompt") {
         return { ok: true, message: "Prompt-only skill requires no verification." };
     }
@@ -223,6 +225,14 @@ export async function verifySkill(name) {
         }
         return { ok: true, message: "Skill verified successfully." };
     }
+    if (execType === "unknown" && (metaType === "tool" || metaType === "connector")) {
+        const bins = metadata?.requires?.bins ?? metadata?.requires?.anyBins ?? [];
+        const missing = bins.filter((bin) => !hasBinary(bin));
+        if (missing.length > 0) {
+            return { ok: false, error: `Missing binary: ${missing.join(", ")}` };
+        }
+        return { ok: true, message: "Skill appears configured." };
+    }
     if (execType === "script") {
         const scriptConfig = getSkillScriptConfig(entry.skill.name);
         if (!scriptConfig) {

package/dist/agents/skill-usage.js

@@ -1,22 +1,20 @@
 import fs from "node:fs";
 import path from "node:path";
 import { loadConfig } from "../config/config.js";
-import { MANAGED_SKILLS_DIR, resolveUserPath } from "../utils.js";
+import { SKILLS_STATE_DIR, resolveUserPath } from "../utils.js";
 import { loadWorkspaceSkillEntries } from "./skills.js";
 import { buildWorkspaceSkillStatus } from "./skills-status.js";
 import { DEFAULT_AGENT_WORKSPACE_DIR } from "./workspace.js";
 function loadSkillEntries() {
     const config = loadConfig();
     const workspaceDir = resolveUserPath(config.agent?.workspace ?? DEFAULT_AGENT_WORKSPACE_DIR);
-    const managedSkillsDir = MANAGED_SKILLS_DIR;
     const entries = loadWorkspaceSkillEntries(workspaceDir, {
         config,
-        managedSkillsDir,
     });
-    return { config, workspaceDir, managedSkillsDir, entries };
+    return { config, workspaceDir, entries };
 }
 function resolveUsageLogPath(name) {
-    return path.join(MANAGED_SKILLS_DIR, name, "usage.log");
+    return path.join(SKILLS_STATE_DIR, name, "usage.log");
 }
 function parseUsageEntry(line) {
     try {
@@ -110,10 +108,9 @@ export async function getSkillStats(name, opts) {
     };
 }
 export async function getAggregateStats(opts) {
-    const { config, workspaceDir, managedSkillsDir, entries } = loadSkillEntries();
+    const { config, workspaceDir, entries } = loadSkillEntries();
     const status = buildWorkspaceSkillStatus(workspaceDir, {
         config,
-        managedSkillsDir,
         entries,
     });
     const sinceMs = opts?.windowDays && opts.windowDays > 0

package/dist/agents/skills-status.js

@@ -1,4 +1,5 @@
-import { MANAGED_SKILLS_DIR } from "../utils.js";
+import path from "node:path";
+import { NEXUS_ROOT } from "../utils.js";
 import { getSkillMetadata, hasBinary, isBundledSkillAllowed, isConfigPathTruthy, loadWorkspaceSkillEntries, resolveBundledAllowlist, resolveConfigPath, resolveSkillConfig, resolveSkillsInstallPreferences, } from "./skills.js";
 function resolveSkillKey(entry) {
     return getSkillMetadata(entry)?.skillKey ?? entry.skill.name;
@@ -146,7 +147,7 @@ function buildSkillStatus(entry, config, prefs) {
     };
 }
 export function buildWorkspaceSkillStatus(workspaceDir, opts) {
-    const managedSkillsDir = opts?.managedSkillsDir ?? MANAGED_SKILLS_DIR;
+    const managedSkillsDir = opts?.managedSkillsDir ?? path.join(NEXUS_ROOT, "skills", "managed");
     const skillEntries = opts?.entries ?? loadWorkspaceSkillEntries(workspaceDir, opts);
     const prefs = resolveSkillsInstallPreferences(opts?.config);
     return {

package/dist/agents/skills.js

@@ -2,7 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { formatSkillsForPrompt, loadSkillsFromDir, } from "@mariozechner/pi-coding-agent";
-import { MANAGED_SKILLS_DIR, resolveUserPath } from "../utils.js";
+import { NEXUS_ROOT, resolveUserPath } from "../utils.js";
 function resolveBundledSkillsDir() {
     const override = process.env.NEXUS_BUNDLED_SKILLS_DIR?.trim();
     if (override)
@@ -41,6 +41,13 @@ function stripQuotes(value) {
     }
     return value;
 }
+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 parseFrontmatter(content) {
     const frontmatter = {};
     const normalized = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
@@ -398,36 +405,24 @@ function loadSkillEntries(workspaceDir, opts) {
         }
         return [];
     };
-    const managedSkillsDir = opts?.managedSkillsDir ?? MANAGED_SKILLS_DIR;
-    const workspaceSkillsDir = path.join(workspaceDir, "skills");
+    const workspaceSkillsRoot = path.join(NEXUS_ROOT, "skills");
+    const userSkillsRoot = path.join(resolveUserPath(workspaceDir), "skills");
+    const managedSkillsDir = opts?.managedSkillsDir ?? path.join(workspaceSkillsRoot, "managed");
     const bundledSkillsDir = opts?.bundledSkillsDir ?? resolveBundledSkillsDir();
     const extraDirsRaw = opts?.config?.skills?.load?.extraDirs ?? [];
     const extraDirs = extraDirsRaw
         .map((d) => (typeof d === "string" ? d.trim() : ""))
         .filter(Boolean);
+    const loadFromDirs = (dirs, source) => dirs.flatMap((dir) => loadSkills({ dir, source }));
     const bundledSkills = bundledSkillsDir
-        ? loadSkills({
-            dir: bundledSkillsDir,
-            source: "nexus-bundled",
-        })
+        ? loadFromDirs(resolveSkillRootDirs(bundledSkillsDir), "nexus-bundled")
         : [];
-    const extraSkills = extraDirs.flatMap((dir) => {
-        const resolved = resolveUserPath(dir);
-        return loadSkills({
-            dir: resolved,
-            source: "nexus-extra",
-        });
-    });
-    const managedSkills = loadSkills({
-        dir: managedSkillsDir,
-        source: "nexus-managed",
-    });
-    const workspaceSkills = loadSkills({
-        dir: workspaceSkillsDir,
-        source: "nexus-workspace",
-    });
+    const extraSkills = extraDirs.flatMap((dir) => loadFromDirs(resolveSkillRootDirs(resolveUserPath(dir)), "nexus-extra"));
+    const managedSkills = loadFromDirs(resolveSkillRootDirs(managedSkillsDir), "nexus-managed");
+    const workspaceSkills = loadFromDirs(resolveSkillRootDirs(workspaceSkillsRoot), "nexus-workspace");
+    const userSkills = loadFromDirs(resolveSkillRootDirs(userSkillsRoot), "nexus-user");
     const merged = new Map();
-    // Precedence: extra < bundled < managed < workspace
+    // Precedence: extra < bundled < managed < workspace < user
     for (const skill of extraSkills)
         merged.set(skill.name, skill);
     for (const skill of bundledSkills)
@@ -436,6 +431,8 @@ function loadSkillEntries(workspaceDir, opts) {
         merged.set(skill.name, skill);
     for (const skill of workspaceSkills)
         merged.set(skill.name, skill);
+    for (const skill of userSkills)
+        merged.set(skill.name, skill);
     const skillEntries = Array.from(merged.values()).map((skill) => {
         let frontmatter = {};
         try {

package/dist/agents/workspace.js

@@ -3,7 +3,7 @@ import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { resolveBootstrapPath, resolveStateDir } from "../config/paths.js";
-import { MANAGED_SKILLS_DIR, NEXUS_ROOT, resolveUserPath } from "../utils.js";
+import { NEXUS_ROOT, SKILLS_STATE_DIR, resolveUserPath } from "../utils.js";
 export function resolveDefaultAgentWorkspaceDir(env = process.env, homedir = os.homedir) {
     const profile = env.NEXUS_PROFILE?.trim();
     if (profile && profile.toLowerCase() !== "default") {
@@ -16,7 +16,8 @@ export const DEFAULT_AGENTS_FILENAME = "AGENTS.md";
 export const DEFAULT_SOUL_FILENAME = "SOUL.md";
 export const DEFAULT_TOOLS_FILENAME = "TOOLS.md";
 export const DEFAULT_IDENTITY_FILENAME = "IDENTITY.md";
-export const DEFAULT_USER_FILENAME = "PROFILE.md";
+export const DEFAULT_USER_FILENAME = "IDENTITY.md";
+export const DEFAULT_USER_TEMPLATE_NAME = "USER.md";
 export const DEFAULT_BOOTSTRAP_FILENAME = "BOOTSTRAP.md";
 const DEFAULT_AGENTS_TEMPLATE = `# AGENTS.md - Nexus Workspace
 
@@ -31,10 +32,10 @@ nexus status
 That command tells you who you are, what you can do, and what to do next.
 
 ## Identity & memory
-- Agent identity: state/agents/{agent}/identity/IDENTITY.md
-- Agent values: state/agents/{agent}/identity/SOUL.md
-- Agent memory: state/agents/{agent}/identity/MEMORY.md
-- User profile: state/user/identity/PROFILE.md
+- Agent identity: state/agents/{agent}/IDENTITY.md
+- Agent values: state/agents/{agent}/SOUL.md
+- Agent memory: state/agents/{agent}/MEMORY.md
+- User identity: state/user/IDENTITY.md
 
 ## User workspace
 The user-owned workspace lives in home/. Do not modify it without permission.
@@ -84,32 +85,44 @@ The agent will write identity files as you chat (takes ~5 min).
 You are beginning the bootstrap conversation. Goals:
 
 1) Learn the user's name
-   → Write: state/user/identity/PROFILE.md
+   → Write: state/user/IDENTITY.md
 
 2) Let the user name you
-   → Write: state/agents/{agent}/identity/IDENTITY.md
+   → Write: state/agents/{agent}/IDENTITY.md
 
 3) Define personality and boundaries
-   → Write: state/agents/{agent}/identity/SOUL.md
+   → Write: state/agents/{agent}/SOUL.md
 
 4) Initialize long-term memory
-   → Write: state/agents/{agent}/identity/MEMORY.md
+   → Write: state/agents/{agent}/MEMORY.md
 
 Be warm, curious, and conversational. Don't rush a checklist.
 
 When complete, run \`nexus status\` to show what's unlocked.
 `;
-const DEFAULT_IDENTITY_TEMPLATE = `# IDENTITY.md - Agent Identity
+const DEFAULT_IDENTITY_TEMPLATE = `---
+name:
+emoji:
+creature:
+vibe:
+---
+# IDENTITY.md - Agent Identity
 
 - Name:
 - Creature:
 - Vibe:
 - Emoji:
 `;
-const DEFAULT_USER_TEMPLATE = `# PROFILE.md - User Profile
+const DEFAULT_USER_TEMPLATE = `---
+name:
+call:
+pronouns:
+timezone:
+---
+# IDENTITY.md - About Your Human
 
 - Name:
-- Preferred address:
+- What to call them:
 - Pronouns (optional):
 - Timezone (optional):
 - Notes:
@@ -169,9 +182,9 @@ export async function ensureAgentWorkspace(params) {
     const stateDir = resolveStateDir();
     const nexusStateDir = path.join(stateDir, "nexus");
     const agentId = process.env.NEXUS_AGENT_ID?.trim() || "default";
-    const agentIdentityDir = path.join(stateDir, "agents", agentId, "identity");
-    const userIdentityDir = path.join(stateDir, "user", "identity");
-    const skillsStateDir = MANAGED_SKILLS_DIR;
+    const agentIdentityDir = path.join(stateDir, "agents", agentId);
+    const userIdentityDir = path.join(stateDir, "user");
+    const skillsStateDir = SKILLS_STATE_DIR;
     const credentialsDir = path.join(stateDir, "credentials");
     await fs.mkdir(nexusStateDir, { recursive: true });
     await fs.mkdir(agentIdentityDir, { recursive: true });
@@ -192,7 +205,7 @@ export async function ensureAgentWorkspace(params) {
         const soulTemplate = await loadTemplate(DEFAULT_SOUL_FILENAME, DEFAULT_SOUL_TEMPLATE);
         const toolsTemplate = await loadTemplate(DEFAULT_TOOLS_FILENAME, DEFAULT_TOOLS_TEMPLATE);
         const identityTemplate = await loadTemplate(DEFAULT_IDENTITY_FILENAME, DEFAULT_IDENTITY_TEMPLATE);
-        const userTemplate = await loadTemplate(DEFAULT_USER_FILENAME, DEFAULT_USER_TEMPLATE);
+        const userTemplate = await loadTemplate(DEFAULT_USER_TEMPLATE_NAME, DEFAULT_USER_TEMPLATE);
         const memoryTemplate = DEFAULT_MEMORY_TEMPLATE;
         const bootstrapTemplate = await loadTemplate(DEFAULT_BOOTSTRAP_FILENAME, DEFAULT_BOOTSTRAP_TEMPLATE);
         if (createHomeLayout) {
@@ -221,8 +234,8 @@ export async function loadWorkspaceBootstrapFiles(dir) {
     const resolvedDir = resolveUserPath(dir);
     const stateDir = resolveStateDir();
     const agentId = process.env.NEXUS_AGENT_ID?.trim() || "default";
-    const agentIdentityDir = path.join(stateDir, "agents", agentId, "identity");
-    const userIdentityDir = path.join(stateDir, "user", "identity");
+    const agentIdentityDir = path.join(stateDir, "agents", agentId);
+    const userIdentityDir = path.join(stateDir, "user");
     const bootstrapPath = resolveBootstrapPath();
     const entries = [
         {

package/dist/capabilities/detector.js

@@ -3,7 +3,7 @@ import path from "node:path";
 import { getSkillMetadata, isConfigPathTruthy, loadWorkspaceSkillEntries, resolveRuntimePlatform, resolveSkillConfig, } from "../agents/skills.js";
 import { loadConfig } from "../config/config.js";
 import { ensureCredentialIndexSync } from "../credentials/store.js";
-import { MANAGED_SKILLS_DIR, NEXUS_ROOT } from "../utils.js";
+import { NEXUS_ROOT, SKILLS_STATE_DIR } from "../utils.js";
 import { loadCapabilityRegistry } from "./registry.js";
 const STATUS_PRIORITY = [
     "active",
@@ -57,7 +57,7 @@ function setupLooksCredentialed(raw) {
         lowered.includes("key"));
 }
 function detectSkillUsageActive(skillName) {
-    const usageLog = path.join(MANAGED_SKILLS_DIR, skillName, "usage.log");
+    const usageLog = path.join(SKILLS_STATE_DIR, skillName, "usage.log");
     try {
         const stat = fs.statSync(usageLog);
         return stat.isFile() && stat.size > 0;

package/dist/cli/cloud-cli.js

@@ -2,6 +2,7 @@ import { spawn } from "node:child_process";
 import crypto from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
+import { fileURLToPath } from "node:url";
 import { scanCredentials } from "../commands/credential.js";
 import { openUrl } from "../commands/onboard-helpers.js";
 import { resolveDefaultEnvVar, storeKeychainSecret, writeCredentialRecord, } from "../credentials/store.js";
@@ -208,6 +209,56 @@ function resolveRepoRoot(argv1 = process.argv[1]) {
     }
     return null;
 }
+function resolveModuleRoot() {
+    try {
+        let dir = path.dirname(fileURLToPath(import.meta.url));
+        for (let i = 0; i < 6; i += 1) {
+            if (fs.existsSync(path.join(dir, "package.json")))
+                return dir;
+            const parent = path.dirname(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+function resolvePackageRoot(argv1 = process.argv[1]) {
+    const moduleRoot = resolveModuleRoot();
+    if (moduleRoot)
+        return moduleRoot;
+    if (!argv1)
+        return null;
+    let normalized = path.resolve(argv1);
+    try {
+        normalized = fs.realpathSync(normalized);
+    }
+    catch {
+        // ignore
+    }
+    const parts = normalized.split(path.sep);
+    const distIndex = parts.lastIndexOf("dist");
+    if (distIndex !== -1) {
+        return parts.slice(0, distIndex).join(path.sep);
+    }
+    return null;
+}
+function resolveBundledCloudBinary(packageRoot) {
+    const ext = process.platform === "win32" ? ".exe" : "";
+    const platformId = `${process.platform}-${process.arch}`;
+    const candidates = [
+        path.join(packageRoot, "dist", "native", "nexus-cloud", platformId, `nexus-cloud-rs${ext}`),
+        path.join(packageRoot, "dist", "native", "nexus-cloud", `nexus-cloud-rs${ext}`),
+    ];
+    for (const candidate of candidates) {
+        if (fs.existsSync(candidate))
+            return candidate;
+    }
+    return null;
+}
 function resolveCloudRunner(args) {
     const env = { ...process.env };
     if (!env.NEXUS_HOME && NEXUS_ROOT) {
@@ -217,6 +268,13 @@ function resolveCloudRunner(args) {
     if (override) {
         return { command: override, args, env };
     }
+    const packageRoot = resolvePackageRoot();
+    if (packageRoot) {
+        const bundled = resolveBundledCloudBinary(packageRoot);
+        if (bundled) {
+            return { command: bundled, args, env };
+        }
+    }
     const repoRoot = resolveRepoRoot();
     if (repoRoot) {
         const nativeRoot = path.join(repoRoot, "native", "nexus-cloud");

package/dist/cli/credential-cli.js

@@ -1,5 +1,6 @@
 import { cancel, confirm, isCancel } from "@clack/prompts";
 import { addCredential, flagCredential, getCredential, getCredentialPaths, getCredentialValue, importCliCredential, listCredentials, removeCredential, scanCredentialEnv, verifyCredentials, } from "../commands/credential.js";
+import { listCredentialEntries } from "../credentials/store.js";
 function parseFields(raw, fieldsArgs) {
     const out = {};
     if (raw) {
@@ -81,18 +82,47 @@ export function registerCredentialCli(program) {
         }
     });
     credential
-        .command("get")
+        .command("get [serviceAccount]")
         .description("Get a credential value")
-        .requiredOption("--service <id>", "Service id")
-        .requiredOption("--account <id>", "Account id")
-        .requiredOption("--auth <id>", "Auth id")
+        .option("--service <id>", "Service id")
+        .option("--account <id>", "Account id")
+        .option("--auth <id>", "Auth id")
         .option("--json", "Output as JSON")
         .option("--record", "Show credential record instead of value")
-        .action(async (opts) => {
+        .action(async (serviceAccount, opts) => {
+        let service = opts.service;
+        let account = opts.account;
+        let authId = opts.auth;
+        if (serviceAccount && typeof serviceAccount === "string") {
+            const parts = serviceAccount.split("/").filter(Boolean);
+            if (parts.length >= 2) {
+                service = service ?? parts[0];
+                account = account ?? parts[1];
+                if (parts.length >= 3) {
+                    authId = authId ?? parts.slice(2).join("/");
+                }
+            }
+        }
+        if (!service || !account) {
+            console.error("Missing service/account. Use service/account or flags.");
+            process.exit(1);
+        }
+        if (!authId) {
+            const entries = await listCredentialEntries();
+            const matches = entries.filter((entry) => entry.service === service && entry.account === account);
+            const auths = Array.from(new Set(matches.map((entry) => entry.authId)));
+            if (auths.length === 1) {
+                authId = auths[0];
+            }
+            else {
+                console.error(`Missing --auth. Available auth ids: ${auths.join(", ") || "none"}`);
+                process.exit(1);
+            }
+        }
         const params = {
-            service: opts.service,
-            account: opts.account,
-            authId: opts.auth,
+            service,
+            account,
+            authId,
         };
         if (opts.record) {
             const result = await getCredential(params);
@@ -269,6 +299,8 @@ export function registerCredentialCli(program) {
         .command("scan")
         .description("Scan environment variables for credentials")
         .option("--deep", "Scan all environment variables for credential patterns")
+        .option("--import", "Import detected credentials into the store")
+        .option("--account <id>", "Account id for imported credentials")
         .option("--yes", "Skip confirmation prompts")
         .option("--json", "Output as JSON")
         .action(async (opts) => {
@@ -283,6 +315,43 @@ export function registerCredentialCli(program) {
             }
         }
         const result = scanCredentialEnv({ deep: Boolean(opts.deep) });
+        if (opts.import) {
+            const accountOverride = typeof opts.account === "string" && opts.account.trim()
+                ? opts.account.trim()
+                : null;
+            const importable = [
+                ...result.known,
+                ...(result.deep ? result.discovered : []),
+            ].filter((entry) => entry.service && entry.type);
+            const existing = await listCredentialEntries();
+            const existingKeys = new Set(existing.map((entry) => `${entry.service}::${entry.account}::${entry.authId}`));
+            const imported = [];
+            const skipped = [];
+            for (const entry of importable) {
+                const account = accountOverride ?? `env:${entry.env}`;
+                const authId = entry.type ?? "token";
+                const key = `${entry.service}::${account}::${authId}`;
+                if (existingKeys.has(key)) {
+                    skipped.push(`${entry.service}/${account}/${authId}`);
+                    continue;
+                }
+                await addCredential({
+                    service: entry.service ?? "unknown",
+                    account,
+                    type: authId,
+                    storage: { provider: "env", var: entry.env },
+                });
+                imported.push(`${entry.service}/${account}/${authId}`);
+            }
+            if (opts.json) {
+                console.log(JSON.stringify({ imported, skipped, total: importable.length }, null, 2));
+                return;
+            }
+            console.log(`Imported: ${imported.length}`);
+            if (skipped.length > 0) {
+                console.log(`Skipped (already exists): ${skipped.length}`);
+            }
+        }
         if (opts.json) {
             console.log(JSON.stringify(result, null, 2));
             return;

package/dist/cli/program.js

@@ -1,5 +1,6 @@
 import { Command } from "commander";
 import { capabilitiesCommand } from "../commands/capabilities.js";
+import { configGetCommand, configListCommand, configSetCommand, } from "../commands/config.js";
 import { configViewCommand } from "../commands/config-view.js";
 import { identityCommand } from "../commands/identity.js";
 import { initCommand } from "../commands/init.js";
@@ -167,13 +168,34 @@ export function buildProgram() {
             : undefined;
         await identityCommand({ target: normalized, json: Boolean(opts.json) }, defaultRuntime);
     });
-    program
-        .command("config")
+    const config = program.command("config").description("Manage config");
+    config
         .description("Show config path and status")
         .option("--json", "Output as JSON")
         .action(async (opts) => {
         await configViewCommand({ json: Boolean(opts.json) }, defaultRuntime);
     });
+    config
+        .command("list")
+        .description("List config values")
+        .option("--json", "Output as JSON")
+        .action(async (opts) => {
+        await configListCommand({ json: Boolean(opts.json) }, defaultRuntime);
+    });
+    config
+        .command("get <key>")
+        .description("Get a config value")
+        .option("--json", "Output as JSON")
+        .action(async (key, opts) => {
+        await configGetCommand({ key, json: Boolean(opts.json) }, defaultRuntime);
+    });
+    config
+        .command("set <key> <value>")
+        .description("Set a config value")
+        .option("--json", "Output as JSON")
+        .action(async (key, value, opts) => {
+        await configSetCommand({ key, value, json: Boolean(opts.json) }, defaultRuntime);
+    });
     program
         .command("update")
         .description("Update nexus CLI")