brainctl 0.1.16 → 0.1.18

package/dist/services/profile-import-service.js

@@ -1,31 +1,46 @@
 import { execSync } from 'node:child_process';
-import { copyFile, cp, mkdir, mkdtemp, readFile, rename, rm, stat, writeFile } from 'node:fs/promises';
-import { homedir, tmpdir } from 'node:os';
+import { copyFile, cp, mkdir, mkdtemp, readFile, rm, stat, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
 import path from 'node:path';
 import YAML from 'yaml';
 import { ProfileError } from '../errors.js';
-import { formatTimestamp } from './sync/agent-writer.js';
+import { installPlugin, installUserSkill } from './agent-asset-installer.js';
 import { resolvePortableMcpCredentials } from './credential-resolution-service.js';
 import { createMcpPreflightService } from './mcp-preflight-service.js';
 import { parseProfile } from './profile-service.js';
 const PROFILES_DIR = '.brainctl/profiles';
+async function pathExists(p) {
+    try {
+        await stat(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 export function createProfileImportService(deps = {}) {
     const mcpPreflightService = deps.mcpPreflightService ?? createMcpPreflightService();
     return {
         async execute(options) {
             const cwd = options.cwd ?? process.cwd();
             const archivePath = path.resolve(cwd, options.archivePath);
+            let archiveStats;
             try {
-                await stat(archivePath);
+                archiveStats = await stat(archivePath);
             }
             catch {
                 throw new ProfileError(`Archive not found: ${archivePath}`);
             }
-            const extractDir = await mkdtemp(path.join(tmpdir(), 'brainctl-import-'));
+            const isFolderSource = archiveStats.isDirectory();
+            const extractDir = isFolderSource
+                ? archivePath
+                : await mkdtemp(path.join(tmpdir(), 'brainctl-import-'));
             try {
-                execSync(`tar -xzf "${archivePath}" -C "${extractDir}"`, {
-                    stdio: 'pipe',
-                });
+                if (!isFolderSource) {
+                    execSync(`tar -xzf "${archivePath}" -C "${extractDir}"`, {
+                        stdio: 'pipe',
+                    });
+                }
                 const manifest = await readPortableManifest(extractDir);
                 const profileSource = await readFile(path.join(extractDir, 'profile.yaml'), 'utf8');
                 const profile = parseProfile(profileSource, 'imported');
@@ -33,21 +48,26 @@ export function createProfileImportService(deps = {}) {
                 if (manifest.profileName !== profileName) {
                     throw new ProfileError(`Portable profile manifest name "${manifest.profileName}" does not match profile name "${profileName}".`);
                 }
-                const profilePath = path.join(cwd, PROFILES_DIR, `${profileName}.yaml`);
+                const profileFolder = path.join(cwd, PROFILES_DIR, profileName);
+                const profilePath = path.join(profileFolder, 'profile.yaml');
+                const legacyProfilePath = path.join(cwd, PROFILES_DIR, `${profileName}.yaml`);
                 if (!options.force) {
-                    try {
-                        await stat(profilePath);
+                    if ((await pathExists(profilePath)) || (await pathExists(legacyProfilePath))) {
                         throw new ProfileError(`Profile "${profileName}" already exists. Use --force to overwrite.`);
                     }
-                    catch (err) {
-                        if (err instanceof ProfileError)
-                            throw err;
+                }
+                else {
+                    // clean up legacy single-file profile so it doesn't shadow the new layout
+                    if (await pathExists(legacyProfilePath)) {
+                        await rm(legacyProfilePath, { force: true });
                     }
                 }
+                const dotEnvCreds = await readDotEnvCredentials(extractDir);
+                const combinedCreds = { ...dotEnvCreds, ...(options.credentials ?? {}) };
                 const missingCredentials = new Map();
                 for (const [name, mcp] of Object.entries(profile.mcps)) {
                     const resolution = resolvePortableMcpCredentials(mcp, {
-                        credentials: options.credentials,
+                        credentials: combinedCreds,
                         credentialSpecs: manifest.credentials,
                         environment: process.env,
                     });
@@ -102,27 +122,44 @@ export function createProfileImportService(deps = {}) {
                 await validateImportedMcps(profile, cwd, mcpPreflightService);
                 const installedPlugins = [];
                 for (const plugin of manifest.plugins ?? []) {
-                    await restorePlugin(extractDir, plugin);
+                    const sourceDir = resolveBundledArchivePath(extractDir, plugin.archivePath);
+                    const profileLocalDir = path.join(cwd, PROFILES_DIR, profileName, plugin.archivePath);
+                    await rm(profileLocalDir, { recursive: true, force: true });
+                    await mkdir(path.dirname(profileLocalDir), { recursive: true });
+                    await cp(sourceDir, profileLocalDir, { recursive: true });
+                    await installPlugin(profileLocalDir, plugin);
                     installedPlugins.push(`${plugin.agent}:${plugin.name}`);
                 }
                 const installedUserSkills = [];
                 for (const skill of manifest.userSkills ?? []) {
-                    await restoreUserSkill(extractDir, skill);
+                    const sourceDir = resolveBundledArchivePath(extractDir, skill.archivePath);
+                    const profileLocalDir = path.join(cwd, PROFILES_DIR, profileName, skill.archivePath);
+                    await rm(profileLocalDir, { recursive: true, force: true });
+                    await mkdir(path.dirname(profileLocalDir), { recursive: true });
+                    await cp(sourceDir, profileLocalDir, { recursive: true });
+                    await installUserSkill(profileLocalDir, skill);
                     installedUserSkills.push(`${skill.agent}:${skill.name}`);
                 }
+                // retain manifest in profile folder so sync can reapply assets
+                try {
+                    await copyFile(path.join(extractDir, 'manifest.yaml'), path.join(cwd, PROFILES_DIR, profileName, 'manifest.yaml'));
+                }
+                catch {
+                    // best-effort
+                }
                 const outputYaml = {
                     name: profile.name,
                     ...(profile.description ? { description: profile.description } : {}),
-                    skills: profile.skills,
                     mcps: profile.mcps,
-                    memory: profile.memory,
                 };
                 await mkdir(path.dirname(profilePath), { recursive: true });
                 await writeFile(profilePath, YAML.stringify(outputYaml), 'utf8');
                 return { profileName, installedMcps, installedPlugins, installedUserSkills };
             }
             finally {
-                await rm(extractDir, { recursive: true, force: true });
+                if (!isFolderSource) {
+                    await rm(extractDir, { recursive: true, force: true });
+                }
             }
         },
     };
@@ -187,6 +224,31 @@ function formatExecError(error) {
     }
     return 'Unknown install error.';
 }
+async function readDotEnvCredentials(extractDir) {
+    try {
+        const content = await readFile(path.join(extractDir, '.env'), 'utf8');
+        const out = {};
+        for (const rawLine of content.split(/\r?\n/)) {
+            const line = rawLine.trim();
+            if (!line || line.startsWith('#'))
+                continue;
+            const eq = line.indexOf('=');
+            if (eq <= 0)
+                continue;
+            const key = line.slice(0, eq).trim();
+            let value = line.slice(eq + 1).trim();
+            if ((value.startsWith('"') && value.endsWith('"')) ||
+                (value.startsWith("'") && value.endsWith("'"))) {
+                value = value.slice(1, -1).replace(/\\"/g, '"').replace(/\\\\/g, '\\');
+            }
+            out[key.toLowerCase()] = value;
+        }
+        return out;
+    }
+    catch {
+        return {};
+    }
+}
 async function readPortableManifest(extractDir) {
     let source;
     try {
@@ -227,110 +289,3 @@ function resolveBundledArchivePath(extractDir, bundlePath) {
     }
     return resolved;
 }
-async function restorePlugin(extractDir, plugin) {
-    const sourceDir = resolveBundledArchivePath(extractDir, plugin.archivePath);
-    try {
-        await stat(sourceDir);
-    }
-    catch {
-        throw new ProfileError(`Bundled plugin "${plugin.name}" source missing in archive at ${plugin.archivePath}.`);
-    }
-    if (plugin.agent === 'gemini') {
-        // Gemini has no plugin cache concept. Treat as user-skill-equivalent no-op.
-        return;
-    }
-    const marketplace = plugin.marketplace ?? plugin.source;
-    const version = plugin.version ?? 'unknown';
-    const cacheRoot = path.join(homedir(), `.${plugin.agent}`, 'plugins', 'cache');
-    const targetDir = path.join(cacheRoot, marketplace, plugin.name, version);
-    await rm(targetDir, { recursive: true, force: true });
-    await mkdir(path.dirname(targetDir), { recursive: true });
-    await cp(sourceDir, targetDir, { recursive: true });
-    if (plugin.agent === 'claude') {
-        await registerClaudePlugin({
-            pluginKey: `${plugin.name}@${marketplace}`,
-            installPath: targetDir,
-            version,
-        });
-        return;
-    }
-    if (plugin.agent === 'codex') {
-        await registerCodexPlugin({
-            pluginKey: `${plugin.name}@${marketplace}`,
-        });
-    }
-}
-async function restoreUserSkill(extractDir, skill) {
-    const sourceDir = resolveBundledArchivePath(extractDir, skill.archivePath);
-    try {
-        await stat(sourceDir);
-    }
-    catch {
-        throw new ProfileError(`Bundled user skill "${skill.name}" source missing in archive at ${skill.archivePath}.`);
-    }
-    const targetDir = path.join(homedir(), `.${skill.agent}`, 'skills', skill.name);
-    await rm(targetDir, { recursive: true, force: true });
-    await mkdir(path.dirname(targetDir), { recursive: true });
-    await cp(sourceDir, targetDir, { recursive: true });
-}
-async function registerClaudePlugin(options) {
-    const filePath = path.join(homedir(), '.claude', 'plugins', 'installed_plugins.json');
-    let existing = { version: 2, plugins: {} };
-    try {
-        const source = await readFile(filePath, 'utf8');
-        existing = JSON.parse(source);
-        await backupFile(filePath);
-    }
-    catch {
-        // fresh file
-    }
-    const plugins = (existing.plugins ?? {});
-    const now = new Date().toISOString();
-    const entry = {
-        scope: 'user',
-        installPath: options.installPath,
-        version: options.version,
-        installedAt: now,
-        lastUpdated: now,
-    };
-    plugins[options.pluginKey] = [entry];
-    existing.plugins = plugins;
-    if (typeof existing.version !== 'number')
-        existing.version = 2;
-    await mkdir(path.dirname(filePath), { recursive: true });
-    await atomicWrite(filePath, JSON.stringify(existing, null, 2) + '\n');
-}
-async function registerCodexPlugin(options) {
-    const filePath = path.join(homedir(), '.codex', 'config.toml');
-    let existing = '';
-    try {
-        existing = await readFile(filePath, 'utf8');
-        await backupFile(filePath);
-    }
-    catch {
-        existing = '';
-    }
-    const header = `[plugins."${options.pluginKey}"]`;
-    if (existing.includes(header))
-        return;
-    const prefix = existing.length > 0 && !existing.endsWith('\n') ? '\n' : '';
-    const separator = existing.length > 0 ? '\n' : '';
-    const block = `${header}\nenabled = true\n`;
-    const next = existing + prefix + separator + block;
-    await mkdir(path.dirname(filePath), { recursive: true });
-    await atomicWrite(filePath, next);
-}
-async function backupFile(filePath) {
-    const backupPath = `${filePath}.bak.${formatTimestamp()}`;
-    try {
-        await copyFile(filePath, backupPath);
-    }
-    catch {
-        // file may not exist
-    }
-}
-async function atomicWrite(filePath, content) {
-    const tmpPath = `${filePath}.tmp.${Date.now()}`;
-    await writeFile(tmpPath, content, 'utf8');
-    await rename(tmpPath, filePath);
-}

package/dist/services/profile-service.d.ts

@@ -1,10 +1,11 @@
-import type { BrainctlMetaConfig, ProfileConfig } from '../types.js';
+import type { ProfileConfig } from '../types.js';
+export declare function profileDir(cwd: string, name: string): string;
+export declare function profileFile(cwd: string, name: string): string;
 export interface ProfileService {
     list(options?: {
         cwd?: string;
     }): Promise<{
         profiles: string[];
-        activeProfile: string | null;
     }>;
     get(options: {
         cwd?: string;
@@ -26,15 +27,6 @@ export interface ProfileService {
         cwd?: string;
         name: string;
     }): Promise<void>;
-    use(options: {
-        cwd?: string;
-        name: string;
-    }): Promise<{
-        previousProfile: string | null;
-    }>;
-    getMetaConfig(options?: {
-        cwd?: string;
-    }): Promise<BrainctlMetaConfig>;
 }
 export declare function createProfileService(): ProfileService;
 export declare function parseProfile(source: string, name: string): ProfileConfig;

package/dist/services/profile-service.js

@@ -1,133 +1,115 @@
-import { readdir, readFile, writeFile, mkdir, stat, unlink } from 'node:fs/promises';
+import { readdir, readFile, writeFile, mkdir, rename, rm, stat } from 'node:fs/promises';
 import path from 'node:path';
 import YAML from 'yaml';
 import { ProfileError, ProfileNotFoundError } from '../errors.js';
 const VALID_RUNTIMES = new Set(['node', 'python', 'java', 'go', 'rust', 'binary']);
-const BRAINCTL_DIR = '.brainctl';
 const PROFILES_DIR = '.brainctl/profiles';
-const META_CONFIG = '.brainctl/config.yaml';
+const PROFILE_FILE = 'profile.yaml';
+export function profileDir(cwd, name) {
+    return path.join(cwd, PROFILES_DIR, name);
+}
+export function profileFile(cwd, name) {
+    return path.join(profileDir(cwd, name), PROFILE_FILE);
+}
+function legacyProfileFile(cwd, name) {
+    return path.join(cwd, PROFILES_DIR, `${name}.yaml`);
+}
+async function migrateLegacyProfile(cwd, name) {
+    const legacy = legacyProfileFile(cwd, name);
+    const folder = profileDir(cwd, name);
+    const newFile = profileFile(cwd, name);
+    if (!(await pathExists(legacy)))
+        return;
+    if (await pathExists(newFile))
+        return;
+    await mkdir(folder, { recursive: true });
+    await rename(legacy, newFile);
+}
 export function createProfileService() {
     return {
         async list(options = {}) {
             const cwd = options.cwd ?? process.cwd();
             const profilesDir = path.join(cwd, PROFILES_DIR);
-            let files = [];
+            const names = new Set();
             try {
-                const entries = await readdir(profilesDir);
-                files = entries
-                    .filter((f) => f.endsWith('.yaml'))
-                    .map((f) => f.replace(/\.yaml$/, ''))
-                    .sort();
+                const entries = await readdir(profilesDir, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (entry.isDirectory()) {
+                        if (await pathExists(path.join(profilesDir, entry.name, PROFILE_FILE))) {
+                            names.add(entry.name);
+                        }
+                    }
+                    else if (entry.isFile() && entry.name.endsWith('.yaml')) {
+                        const bare = entry.name.replace(/\.yaml$/, '');
+                        await migrateLegacyProfile(cwd, bare);
+                        names.add(bare);
+                    }
+                }
             }
             catch {
                 // No profiles directory yet
             }
-            const meta = await loadMetaConfig(cwd);
             return {
-                profiles: files,
-                activeProfile: meta.active_profile || null,
+                profiles: Array.from(names).sort(),
             };
         },
         async get(options) {
             const cwd = options.cwd ?? process.cwd();
-            const profilePath = path.join(cwd, PROFILES_DIR, `${options.name}.yaml`);
+            await migrateLegacyProfile(cwd, options.name);
+            const filePath = profileFile(cwd, options.name);
             let source;
             try {
-                source = await readFile(profilePath, 'utf8');
+                source = await readFile(filePath, 'utf8');
             }
             catch {
-                throw new ProfileNotFoundError(`Profile "${options.name}" not found at ${profilePath}`);
+                throw new ProfileNotFoundError(`Profile "${options.name}" not found at ${filePath}`);
             }
             return parseProfile(source, options.name);
         },
         async create(options) {
             const cwd = options.cwd ?? process.cwd();
-            const profilesDir = path.join(cwd, PROFILES_DIR);
-            const profilePath = path.join(profilesDir, `${options.name}.yaml`);
-            if (await pathExists(profilePath)) {
+            const folder = profileDir(cwd, options.name);
+            const filePath = profileFile(cwd, options.name);
+            if ((await pathExists(filePath)) ||
+                (await pathExists(legacyProfileFile(cwd, options.name)))) {
                 throw new ProfileError(`Profile "${options.name}" already exists.`);
             }
             const scaffold = {
                 name: options.name,
                 description: options.description ?? '',
-                skills: {
-                    example: {
-                        description: 'Example skill',
-                        prompt: 'Describe what this skill does...',
-                    },
-                },
                 mcps: {},
-                memory: {
-                    paths: ['./memory'],
-                },
             };
-            await mkdir(profilesDir, { recursive: true });
-            await writeFile(profilePath, YAML.stringify(scaffold), 'utf8');
-            return { profilePath };
+            await mkdir(folder, { recursive: true });
+            await writeFile(filePath, YAML.stringify(scaffold), 'utf8');
+            return { profilePath: filePath };
         },
         async update(options) {
             const cwd = options.cwd ?? process.cwd();
-            const profilePath = path.join(cwd, PROFILES_DIR, `${options.name}.yaml`);
-            if (!(await pathExists(profilePath))) {
+            await migrateLegacyProfile(cwd, options.name);
+            const filePath = profileFile(cwd, options.name);
+            if (!(await pathExists(filePath))) {
                 throw new ProfileNotFoundError(`Profile "${options.name}" not found.`);
             }
             const normalized = normalizeProfileConfig(options.config, options.name);
             const data = {
                 name: normalized.name,
                 ...(normalized.description ? { description: normalized.description } : {}),
-                skills: normalized.skills,
                 mcps: normalized.mcps,
-                memory: normalized.memory,
             };
-            await writeFile(profilePath, YAML.stringify(data), 'utf8');
+            await writeFile(filePath, YAML.stringify(data), 'utf8');
         },
         async delete(options) {
             const cwd = options.cwd ?? process.cwd();
-            const profilePath = path.join(cwd, PROFILES_DIR, `${options.name}.yaml`);
-            if (!(await pathExists(profilePath))) {
-                throw new ProfileNotFoundError(`Profile "${options.name}" not found.`);
-            }
-            const meta = await loadMetaConfig(cwd);
-            if (meta.active_profile === options.name) {
-                throw new ProfileError('Cannot delete the active profile.');
-            }
-            await unlink(profilePath);
-        },
-        async use(options) {
-            const cwd = options.cwd ?? process.cwd();
-            // Validate profile exists
-            const profilePath = path.join(cwd, PROFILES_DIR, `${options.name}.yaml`);
-            if (!(await pathExists(profilePath))) {
+            await migrateLegacyProfile(cwd, options.name);
+            const folder = profileDir(cwd, options.name);
+            const filePath = profileFile(cwd, options.name);
+            if (!(await pathExists(filePath))) {
                 throw new ProfileNotFoundError(`Profile "${options.name}" not found.`);
             }
-            const meta = await loadMetaConfig(cwd);
-            const previousProfile = meta.active_profile || null;
-            meta.active_profile = options.name;
-            const metaPath = path.join(cwd, META_CONFIG);
-            await mkdir(path.dirname(metaPath), { recursive: true });
-            await writeFile(metaPath, YAML.stringify(meta), 'utf8');
-            return { previousProfile };
-        },
-        async getMetaConfig(options = {}) {
-            const cwd = options.cwd ?? process.cwd();
-            return loadMetaConfig(cwd);
+            await rm(folder, { recursive: true, force: true });
         },
     };
 }
-async function loadMetaConfig(cwd) {
-    const metaPath = path.join(cwd, META_CONFIG);
-    try {
-        const source = await readFile(metaPath, 'utf8');
-        const parsed = YAML.parse(source) ?? {};
-        return {
-            active_profile: typeof parsed.active_profile === 'string' ? parsed.active_profile : '',
-            agents: Array.isArray(parsed.agents) ? parsed.agents : ['claude', 'codex'],
-        };
-    }
-    catch {
-        return { active_profile: '', agents: ['claude', 'codex', 'gemini'] };
-    }
-}
 export function parseProfile(source, name) {
     let parsed;
     try {
@@ -146,38 +128,11 @@ export function normalizeProfileConfig(value, name) {
         throw new ProfileError(`Profile "${name}" has invalid structure.`);
     }
     const data = value;
-    const skills = {};
-    if (data.skills && typeof data.skills === 'object' && !Array.isArray(data.skills)) {
-        for (const [key, value] of Object.entries(data.skills)) {
-            if (value && typeof value === 'object' && !Array.isArray(value)) {
-                const s = value;
-                if (typeof s.prompt === 'string') {
-                    skills[key] = {
-                        prompt: s.prompt,
-                        description: typeof s.description === 'string' ? s.description : undefined,
-                    };
-                }
-            }
-        }
-    }
     const mcps = normalizeMcps(data.mcps, name);
-    const memoryPaths = [];
-    if (data.memory && typeof data.memory === 'object' && !Array.isArray(data.memory)) {
-        const mem = data.memory;
-        if (Array.isArray(mem.paths)) {
-            for (const p of mem.paths) {
-                if (typeof p === 'string') {
-                    memoryPaths.push(p);
-                }
-            }
-        }
-    }
     return {
         name: typeof data.name === 'string' ? data.name : name,
         description: typeof data.description === 'string' ? data.description : undefined,
-        skills,
         mcps,
-        memory: { paths: memoryPaths },
     };
 }
 function normalizeMcps(value, profileName) {

package/dist/services/profile-snapshot-service.d.ts

@@ -0,0 +1,12 @@
+import type { AgentName } from '../types.js';
+export interface ProfileSnapshotService {
+    execute(options: {
+        cwd: string;
+        agent: AgentName;
+        profileName: string;
+    }): Promise<{
+        profilePath: string;
+    }>;
+}
+export declare function createProfileSnapshotService(): ProfileSnapshotService;
+export declare function defaultBackupProfileName(agent: AgentName): string;

package/dist/services/profile-snapshot-service.js

@@ -0,0 +1,47 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import YAML from 'yaml';
+import { profileDir } from './profile-service.js';
+import { createPortableProfilePackService } from './portable-profile-pack-service.js';
+export function createProfileSnapshotService() {
+    const packService = createPortableProfilePackService();
+    return {
+        async execute(options) {
+            const outputPath = profileDir(options.cwd, options.profileName);
+            const result = await packService.execute({
+                cwd: options.cwd,
+                source: { source: 'agent', agent: options.agent, cwd: options.cwd },
+                outputPath,
+                format: 'folder',
+                credentialsMode: 'keep',
+            });
+            await renameInsideProfile(outputPath, options.profileName);
+            return { profilePath: result.archivePath };
+        },
+    };
+}
+async function renameInsideProfile(profilePath, name) {
+    const profileFile = path.join(profilePath, 'profile.yaml');
+    const manifestFile = path.join(profilePath, 'manifest.yaml');
+    for (const file of [profileFile, manifestFile]) {
+        try {
+            const source = await readFile(file, 'utf8');
+            const parsed = YAML.parse(source);
+            if (file === profileFile)
+                parsed.name = name;
+            else
+                parsed.profileName = name;
+            await writeFile(file, YAML.stringify(parsed), 'utf8');
+        }
+        catch {
+            // best-effort
+        }
+    }
+}
+export function defaultBackupProfileName(agent) {
+    const ts = new Date()
+        .toISOString()
+        .replace(/[-:T]/g, '')
+        .replace(/\..+$/, '');
+    return `backup-${agent}-${ts}`;
+}

package/dist/services/status-service.d.ts

@@ -1,11 +1,12 @@
-import type { AgentAvailability, ExecutorResolver } from '../executor/resolver.js';
-import type { AgentName, MemoryLoadResult } from '../types.js';
+import { type AgentAvailability, type AgentAvailabilityService } from './agent-availability-service.js';
+import { type ProfileService } from './profile-service.js';
+import type { AgentName } from '../types.js';
 export interface StatusResult {
-    configPath: string;
-    memory: MemoryLoadResult;
-    skills: string[];
-    mcpCount: number;
     agents: Record<AgentName, AgentAvailability>;
+    profiles: {
+        count: number;
+        names: string[];
+    };
 }
 export interface StatusService {
     execute(options?: {
@@ -13,5 +14,6 @@ export interface StatusService {
     }): Promise<StatusResult>;
 }
 export declare function createStatusService(dependencies?: {
-    resolver?: ExecutorResolver;
+    availabilityService?: AgentAvailabilityService;
+    profileService?: ProfileService;
 }): StatusService;

package/dist/services/status-service.js

@@ -1,21 +1,22 @@
-import { loadConfig } from '../config.js';
-import { loadMemory } from '../context/memory.js';
-import { createExecutorResolver } from '../executor/resolver.js';
+import { createAgentAvailabilityService, } from './agent-availability-service.js';
+import { createProfileService } from './profile-service.js';
 export function createStatusService(dependencies = {}) {
-    const resolver = dependencies.resolver ?? createExecutorResolver();
+    const availabilityService = dependencies.availabilityService ?? createAgentAvailabilityService();
+    const profileService = dependencies.profileService ?? createProfileService();
     return {
         async execute(options = {}) {
             const cwd = options.cwd ?? process.cwd();
-            const config = await loadConfig({ cwd });
-            const memory = await loadMemory({ paths: config.memory.paths });
-            const agents = await resolver.getAgentAvailability();
+            const [agents, profileList] = await Promise.all([
+                availabilityService.getAll(),
+                profileService.list({ cwd }),
+            ]);
             return {
-                configPath: config.configPath,
-                memory,
-                skills: Object.keys(config.skills).sort((left, right) => left.localeCompare(right)),
-                mcpCount: Object.keys(config.mcps).length,
-                agents
+                agents,
+                profiles: {
+                    count: profileList.profiles.length,
+                    names: profileList.profiles,
+                },
             };
-        }
+        },
     };
 }