minovative-mind-cli 2.3.0 → 2.3.2

package/README.md

@@ -121,11 +121,13 @@ Hot-swap during a session using `/models`:
 
 ---
 
-## 🌐 Multi-Workspace & Cross-Repo Support
+## 🌐 Multi-Workspace & Cross-Repo Support (Master & Sub-Workspaces)
 
-Minovative Mind CLI doesn't restrict you to a single repository. You can link multiple external workspaces to your current session and the AI will seamlessly operate across all of them simultaneously.
+Minovative Mind CLI doesn't restrict you to a single repository. You can logically group multiple external repositories into **Master Workspaces** (Profiles) containing dedicated **Sub-Workspaces** (mapped to short aliases like `@backend` or `@frontend`). 
 
-By prefixing file paths with `@alias/` (e.g. `@backend/src/api.ts` and `@frontend/src/App.tsx`), the Context Agent and Thread Agents can investigate, refactor, and coordinate changes across your entire tech stack in a single prompt. The terminal highlights cross-workspace actions with a blue `[alias]` visual tag. Use the "Edit Workspace" menu option to configure your linked projects.
+The Context Agent and Thread Agents operate strictly within the boundaries of the active Master Workspace, ignoring other profiles to keep the context window highly targeted and memory-efficient.
+
+By prefixing file paths with `@alias/` (e.g., `@backend/src/api.ts` and `@frontend/src/App.tsx`), the agents can investigate, refactor, and coordinate changes across your entire nested stack in a single prompt. The terminal highlights cross-workspace actions with a blue `[alias]` visual tag. Use the `/workspaces` command to create profiles, link sub-workspaces, or switch active environments.
 
 ---
 

package/dist/services/agent/slashCommands.js

@@ -11,7 +11,7 @@ import { chatHistoryService } from '../chatHistoryService.js';
 import { printLogo, brandBg, brandFg } from '../../utils/logo.js';
 import { readPaste } from '../../utils/paste.js';
 import { setApprovalMode, getApprovalMode, isSubAgentsEnabled, setSubAgentsEnabled } from '../agent-tools.js';
-import { ProxyChatSession, setGlobalActiveModel, getGlobalActiveModel, } from '../ai.js';
+import { ProxyChatSession, setGlobalActiveModel, getGlobalActiveModel } from '../ai.js';
 import { GEMINI_MODELS } from '../../utils/config.js';
 const execAsync = promisify(exec);
 /**
@@ -495,7 +495,9 @@ export async function handleSlashCommand(command, context) {
                     p.log.info(`${pc.dim('Model:')} ${pc.cyan(session.modelName)}`);
                 }
                 if (session.totalTokens !== undefined) {
-                    const inputStr = session.totalInputTokens ? ` (Input: ${session.totalInputTokens.toLocaleString()}, Output: ${(session.totalOutputTokens || 0).toLocaleString()})` : '';
+                    const inputStr = session.totalInputTokens
+                        ? ` (Input: ${session.totalInputTokens.toLocaleString()}, Output: ${(session.totalOutputTokens || 0).toLocaleString()})`
+                        : '';
                     p.log.info(`${pc.dim('Session Token Usage:')} ${pc.cyan(session.totalTokens.toLocaleString() + ' total tokens')}${pc.dim(inputStr)}`);
                 }
                 if (session.gitBranch) {
@@ -537,9 +539,9 @@ export async function handleSlashCommand(command, context) {
         while (true) {
             const allRoots = workspaceRegistry.getAllRoots(workspaceRoot);
             const options = [];
+            const hasProfiles = workspaceRegistry.hasProfiles();
             options.push({ value: 'add', label: 'Add Workspace' });
-            const externalRoots = allRoots.filter((r) => r.alias);
-            if (externalRoots.length > 0) {
+            if (hasProfiles) {
                 options.push({ value: 'edit', label: 'Edit Workspace' });
                 options.push({ value: 'remove', label: 'Remove Workspace' });
                 options.push({ value: 'list', label: 'List Workspaces' });
@@ -553,6 +555,40 @@ export async function handleSlashCommand(command, context) {
                 break;
             }
             if (action === 'add') {
+                const type = await p['select']({
+                    message: 'What type of workspace would you like to add?',
+                    options: [
+                        { value: 'master', label: 'Master Workspace (Create)' },
+                        { value: 'sub', label: 'Sub-workspace', hint: 'Requires an existing Master Workspace' },
+                    ],
+                });
+                if (p.isCancel(type))
+                    continue;
+                let profileStr;
+                if (type === 'master') {
+                    profileStr = (await p['text']({
+                        message: 'Enter profile name (e.g. work, personal):',
+                        validate: (val) => {
+                            if (!val)
+                                return 'Profile name is required';
+                        },
+                    }));
+                    if (p.isCancel(profileStr))
+                        continue;
+                }
+                else {
+                    const profiles = workspaceRegistry.listProfiles();
+                    if (profiles.length === 0) {
+                        p.log.error('No master workspaces (profiles) exist. Please create one first.');
+                        continue;
+                    }
+                    profileStr = (await p['select']({
+                        message: 'Select a Master Workspace (For Sub-Workspaces):',
+                        options: profiles.map((p) => ({ value: p.name, label: p.name })),
+                    }));
+                    if (p.isCancel(profileStr))
+                        continue;
+                }
                 const aliasStr = await p['text']({
                     message: 'Enter a short alias (e.g. backend, ui):',
                     validate: (val) => {
@@ -567,7 +603,7 @@ export async function handleSlashCommand(command, context) {
                 if (p.isCancel(aliasStr))
                     continue;
                 const rootPathStr = await p['text']({
-                    message: 'Enter the absolute path to the workspace root (e.g. /Users/name/Projects/app):',
+                    message: 'Enter the absolute path to the workspace root:',
                     validate: (val) => {
                         if (!val)
                             return 'Path is required';
@@ -586,17 +622,17 @@ export async function handleSlashCommand(command, context) {
                         p.log.error('Path is not a directory.');
                         continue;
                     }
-                    workspaceRegistry.register(aliasStr, cleanRootPathStr);
-                    p.log.success(`Added @${aliasStr} -> ${cleanRootPathStr}`);
+                    workspaceRegistry.register(profileStr, aliasStr, cleanRootPathStr);
+                    p.log.success(`Added @${aliasStr} -> ${cleanRootPathStr} (Profile: ${profileStr})`);
                 }
                 catch (e) {
-                    p.log.error(`Invalid path or directory does not exist: ${cleanRootPathStr}`);
+                    p.log.error(e.message || `Invalid path or directory does not exist: ${cleanRootPathStr}`);
                 }
             }
             else if (action === 'edit') {
-                const editOptions = externalRoots.map((r) => ({
+                const editOptions = workspaceRegistry.list().map((r) => ({
                     value: r.alias,
-                    label: `@${r.alias} -> ${r.root}`,
+                    label: `@${r.alias} -> ${r.absolutePath}`,
                 }));
                 editOptions.push({ value: 'cancel', label: 'Cancel' });
                 const aliasToEdit = await p['select']({
@@ -608,6 +644,16 @@ export async function handleSlashCommand(command, context) {
                 const ws = workspaceRegistry.get(aliasToEdit);
                 if (!ws)
                     continue;
+                const newProfileStr = await p['text']({
+                    message: `Enter new profile name (current: ${ws.profile}):`,
+                    initialValue: ws.profile,
+                    validate: (val) => {
+                        if (!val)
+                            return 'Profile name is required';
+                    },
+                });
+                if (p.isCancel(newProfileStr))
+                    continue;
                 const newAliasStr = await p['text']({
                     message: `Enter new alias (current: ${ws.alias}):`,
                     initialValue: ws.alias,
@@ -645,22 +691,22 @@ export async function handleSlashCommand(command, context) {
                     }
                     // Remove old alias first to avoid duplicate alias error, or to clean up
                     workspaceRegistry.unregister(ws.alias);
-                    workspaceRegistry.register(newAliasStr, cleanNewRootPathStr);
-                    p.log.success(`Updated @${newAliasStr} -> ${cleanNewRootPathStr}`);
+                    workspaceRegistry.register(newProfileStr, newAliasStr, cleanNewRootPathStr);
+                    p.log.success(`Updated @${newAliasStr} -> ${cleanNewRootPathStr} (Profile: ${newProfileStr})`);
                 }
                 catch (e) {
                     // If register failed, try to rollback
                     p.log.error(`Failed to update workspace: ${e instanceof Error ? e.message : String(e)}`);
                     try {
-                        workspaceRegistry.register(ws.alias, ws.absolutePath);
+                        workspaceRegistry.register(ws.profile, ws.alias, ws.absolutePath);
                     }
                     catch { }
                 }
             }
             else if (action === 'remove') {
-                const removeOptions = externalRoots.map((r) => ({
+                const removeOptions = workspaceRegistry.list().map((r) => ({
                     value: r.alias,
-                    label: `@${r.alias} -> ${r.root}`,
+                    label: `@${r.alias} -> ${r.absolutePath}`,
                 }));
                 removeOptions.push({ value: 'cancel', label: 'Cancel' });
                 const aliasToRemove = await p['select']({
@@ -674,8 +720,9 @@ export async function handleSlashCommand(command, context) {
             }
             else if (action === 'list') {
                 for (const { alias, root } of allRoots) {
+                    const ws = alias ? workspaceRegistry.get(alias) : null;
                     if (alias) {
-                        p.log.step(`${pc.blue(`@${alias}`)} -> ${pc.dim(root)}`);
+                        p.log.step(`${pc.blue(`@${alias}`)} [${ws?.profile || 'default'}] -> ${pc.dim(root)}`);
                     }
                     else {
                         p.log.step(`${pc.cyan('(primary)')} -> ${pc.dim(root)}`);

package/dist/services/proxyClient.d.ts

@@ -1,18 +1,4 @@
 import type { Content, Tool, ToolConfig, FunctionCall } from '@google/generative-ai';
-/**
- * ============================================================================
- *                               PROXY CLIENT SERVICE
- * ============================================================================
- * Facilitates stream-based communication with the secure, Firebase-authenticated
- * serverless Gemini content generation proxy.
- *
- * Core Capabilities:
- * - Server-Sent Events (SSE) parsing for thoughts, text, and function calls.
- * - Secure Authentication handling (Firebase ID Tokens).
- * - Real-time stream-callback piping for instant responses.
- * - Accurate token usage, credit consumption, and grounding metadata parsing.
- * ============================================================================
- */
 /**
  * Metadata containing real-time proxy token and credit usage diagnostics.
  */

package/dist/services/proxyClient.js

@@ -1,4 +1,38 @@
 import { debugLog } from '../utils/logger.js';
+/**
+ * ============================================================================
+ *                               PROXY CLIENT SERVICE
+ * ============================================================================
+ * Facilitates stream-based communication with the secure, Firebase-authenticated
+ * serverless Gemini content generation proxy.
+ *
+ * Core Capabilities:
+ * - Server-Sent Events (SSE) parsing for thoughts, text, and function calls.
+ * - Secure Authentication handling (Firebase ID Tokens).
+ * - Real-time stream-callback piping for instant responses.
+ * - Accurate token usage, credit consumption, and grounding metadata parsing.
+ * ============================================================================
+ */
+/**
+ * Helper to pause execution for a specified duration, respecting abort signals.
+ */
+async function delay(ms, abortSignal) {
+    return new Promise((resolve, reject) => {
+        let timeout;
+        const abortHandler = () => {
+            clearTimeout(timeout);
+            reject(new Error('Operation aborted'));
+        };
+        if (abortSignal?.aborted) {
+            return abortHandler();
+        }
+        abortSignal?.addEventListener('abort', abortHandler);
+        timeout = setTimeout(() => {
+            abortSignal?.removeEventListener('abort', abortHandler);
+            resolve();
+        }, ms);
+    });
+}
 let globalSessionAccumulatedUsage = {
     promptTokens: 0,
     candidatesTokens: 0,
@@ -45,132 +79,162 @@ export class ProxyClient {
      * @throws {Error} If authentication fails (401), credits are insufficient (402), or network/proxy errors occur.
      */
     async generateFunctionCallViaProxy(idToken, modelName, contents, tools, toolConfig, systemInstruction, generationConfig, streamCallbacks, abortSignal) {
-        const response = await fetch(this.PROXY_URL, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                'X-Firebase-Auth': `Bearer ${idToken}`,
-            },
-            body: JSON.stringify({
-                model: modelName,
-                contents,
-                tools,
-                toolConfig,
-                systemInstruction,
-                generationConfig,
-            }),
-            signal: abortSignal,
-        });
-        debugLog(`Proxy Request to ${modelName} complete. Status: ${response.status} ${response.statusText}`);
-        if (response.status === 401) {
-            let details = '';
-            try {
-                const text = await response.text();
+        const MAX_RETRIES = 5;
+        const BASE_DELAY_MS = 2000;
+        const MAX_DELAY_MS = 30000;
+        let attempt = 0;
+        retryLoop: while (true) {
+            const response = await fetch(this.PROXY_URL, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'X-Firebase-Auth': `Bearer ${idToken}`,
+                },
+                body: JSON.stringify({
+                    model: modelName,
+                    contents,
+                    tools,
+                    toolConfig,
+                    systemInstruction,
+                    generationConfig,
+                }),
+                signal: abortSignal,
+            });
+            debugLog(`Proxy Request to ${modelName} complete. Status: ${response.status} ${response.statusText}`);
+            if ((response.status === 429 || response.status === 503) && attempt < MAX_RETRIES) {
+                const exponentialDelay = Math.min(MAX_DELAY_MS, BASE_DELAY_MS * Math.pow(2, attempt));
+                const delayTime = Math.round(exponentialDelay * (0.5 + Math.random() * 0.5));
+                console.warn(`Rate limit or service unavailable hit (${response.status}). Retrying in ${(delayTime / 1000).toFixed(1)}s... (Attempt ${attempt + 1}/${MAX_RETRIES})`);
+                await delay(delayTime, abortSignal);
+                attempt++;
+                continue;
+            }
+            if (response.status === 401) {
+                let details = '';
                 try {
-                    const errorData = JSON.parse(text);
-                    details = errorData.details || errorData.error || text;
+                    const text = await response.text();
+                    try {
+                        const errorData = JSON.parse(text);
+                        details = errorData.details || errorData.error || text;
+                    }
+                    catch (e) {
+                        details = text;
+                    }
                 }
                 catch (e) {
-                    details = text;
+                    details = 'Unknown error reading body';
                 }
+                throw new Error(`Authentication failed: ${details}. Please login again.`);
             }
-            catch (e) {
-                details = 'Unknown error reading body';
+            if (response.status === 402) {
+                throw new Error('Insufficient credits. Please visit minovativemind.dev to purchase more credits.');
             }
-            throw new Error(`Authentication failed: ${details}. Please login again.`);
-        }
-        if (response.status === 402) {
-            throw new Error('Insufficient credits. Please visit minovativemind.dev to purchase more credits.');
-        }
-        if (!response.ok) {
-            const errorData = await response.json().catch(() => ({}));
-            throw new Error(`Proxy error ${response.status}: ${errorData.error || response.statusText}`);
-        }
-        if (!response.body) {
-            throw new Error('No response body received from proxy');
-        }
-        // Node 18+ fetch body is a ReadableStream which is async iterable but type might mismatch.
-        // Let's read chunks manually
-        const reader = response.body.getReader();
-        const decoder = new TextDecoder();
-        let buffer = '';
-        let functionCall = null;
-        const functionCalls = [];
-        let thought = '';
-        let parts = undefined;
-        let usageMetadata = undefined;
-        let groundingMetadata = undefined;
-        try {
-            while (true) {
-                const { done, value } = await reader.read();
-                if (done)
-                    break;
-                buffer += decoder.decode(value, { stream: true });
-                const lines = buffer.split('\n\n');
-                buffer = lines.pop() || '';
-                for (const line of lines) {
-                    if (!line.startsWith('data: '))
-                        continue;
-                    const dataStr = line.slice(6);
-                    try {
-                        const data = JSON.parse(dataStr);
-                        if (data.type === 'functionCall' && data.functionCall) {
-                            functionCall = data.functionCall;
-                            functionCalls.push(data.functionCall);
-                        }
-                        else if (data.type === 'thought' && data.thought) {
-                            thought += data.thought;
-                            if (streamCallbacks?.onChunk)
-                                streamCallbacks.onChunk(data.thought);
-                        }
-                        else if (data.type === 'chunk' && data.text) {
-                            thought += data.text;
-                            if (streamCallbacks?.onChunk)
-                                streamCallbacks.onChunk(data.text);
-                        }
-                        else if (data.type === 'parts' && data.parts) {
-                            parts = data.parts;
-                        }
-                        else if (data.type === 'done') {
-                            if (data.usage) {
-                                usageMetadata = data.usage;
-                                globalSessionAccumulatedUsage.promptTokens += data.usage.promptTokens || 0;
-                                globalSessionAccumulatedUsage.candidatesTokens += data.usage.candidatesTokens || 0;
-                                globalSessionAccumulatedUsage.cachedTokens += data.usage.cachedTokens || 0;
-                                globalSessionAccumulatedUsage.creditsUsed += data.usage.creditsUsed || 0;
-                                globalSessionAccumulatedUsage.totalTokenCount +=
-                                    (data.usage.promptTokens || 0) + (data.usage.cachedTokens || 0) + (data.usage.candidatesTokens || 0);
-                                if (data.usage.remainingBalance !== undefined) {
-                                    globalSessionAccumulatedUsage.remainingBalance = data.usage.remainingBalance;
+            if (!response.ok) {
+                const errorData = await response.json().catch(() => ({}));
+                throw new Error(`Proxy error ${response.status}: ${errorData.error || response.statusText}`);
+            }
+            if (!response.body) {
+                throw new Error('No response body received from proxy');
+            }
+            // Node 18+ fetch body is a ReadableStream which is async iterable but type might mismatch.
+            // Let's read chunks manually
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = '';
+            let functionCall = null;
+            const functionCalls = [];
+            let thought = '';
+            let parts = undefined;
+            let usageMetadata = undefined;
+            let groundingMetadata = undefined;
+            try {
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    buffer += decoder.decode(value, { stream: true });
+                    const lines = buffer.split('\n\n');
+                    buffer = lines.pop() || '';
+                    for (const line of lines) {
+                        if (!line.startsWith('data: '))
+                            continue;
+                        const dataStr = line.slice(6);
+                        try {
+                            const data = JSON.parse(dataStr);
+                            if (data.type === 'functionCall' && data.functionCall) {
+                                functionCall = data.functionCall;
+                                functionCalls.push(data.functionCall);
+                            }
+                            else if (data.type === 'thought' && data.thought) {
+                                thought += data.thought;
+                                if (streamCallbacks?.onChunk)
+                                    streamCallbacks.onChunk(data.thought);
+                            }
+                            else if (data.type === 'chunk' && data.text) {
+                                thought += data.text;
+                                if (streamCallbacks?.onChunk)
+                                    streamCallbacks.onChunk(data.text);
+                            }
+                            else if (data.type === 'parts' && data.parts) {
+                                parts = data.parts;
+                            }
+                            else if (data.type === 'done') {
+                                if (data.usage) {
+                                    usageMetadata = data.usage;
+                                    globalSessionAccumulatedUsage.promptTokens += data.usage.promptTokens || 0;
+                                    globalSessionAccumulatedUsage.candidatesTokens += data.usage.candidatesTokens || 0;
+                                    globalSessionAccumulatedUsage.cachedTokens += data.usage.cachedTokens || 0;
+                                    globalSessionAccumulatedUsage.creditsUsed += data.usage.creditsUsed || 0;
+                                    globalSessionAccumulatedUsage.totalTokenCount +=
+                                        (data.usage.promptTokens || 0) + (data.usage.cachedTokens || 0) + (data.usage.candidatesTokens || 0);
+                                    if (data.usage.remainingBalance !== undefined) {
+                                        globalSessionAccumulatedUsage.remainingBalance = data.usage.remainingBalance;
+                                    }
+                                }
+                                if (data.groundingMetadata) {
+                                    groundingMetadata = data.groundingMetadata;
                                 }
                             }
-                            if (data.groundingMetadata) {
-                                groundingMetadata = data.groundingMetadata;
+                            else if (data.type === 'error') {
+                                throw new Error(`Proxy generation error: ${data.message}`);
                             }
                         }
-                        else if (data.type === 'error') {
-                            throw new Error(`Proxy generation error: ${data.message}`);
+                        catch (parseError) {
+                            if (parseError.message && parseError.message.startsWith('Proxy generation error:')) {
+                                throw parseError;
+                            }
+                            debugLog(`Failed to parse SSE data: ${dataStr} - Error: ${parseError.message || parseError}`);
                         }
                     }
-                    catch (parseError) {
-                        if (parseError.message && parseError.message.startsWith('Proxy generation error:')) {
-                            throw parseError;
-                        }
-                        debugLog(`Failed to parse SSE data: ${dataStr} - Error: ${parseError.message || parseError}`);
+                }
+            }
+            catch (streamError) {
+                if (streamError.message?.includes('429') ||
+                    streamError.message?.includes('503') ||
+                    streamError.message?.includes('RESOURCE_EXHAUSTED') ||
+                    streamError.message?.includes('Too Many Requests')) {
+                    if (attempt < MAX_RETRIES) {
+                        const exponentialDelay = Math.min(MAX_DELAY_MS, BASE_DELAY_MS * Math.pow(2, attempt));
+                        const delayTime = Math.round(exponentialDelay * (0.5 + Math.random() * 0.5));
+                        console.warn(`Rate limit or service unavailable hit during stream. Retrying in ${(delayTime / 1000).toFixed(1)}s... (Attempt ${attempt + 1}/${MAX_RETRIES})`);
+                        await delay(delayTime, abortSignal);
+                        attempt++;
+                        continue retryLoop;
                     }
                 }
+                throw streamError;
             }
+            finally {
+                reader.releaseLock();
+            }
+            return {
+                functionCall,
+                functionCalls,
+                thought: thought.trim(),
+                parts,
+                usageMetadata,
+                groundingMetadata,
+            };
         }
-        finally {
-            reader.releaseLock();
-        }
-        return {
-            functionCall,
-            functionCalls,
-            thought: thought.trim(),
-            parts,
-            usageMetadata,
-            groundingMetadata,
-        };
     }
 }

package/dist/services/workspaceRegistry.d.ts

@@ -8,6 +8,17 @@ export interface RegisteredWorkspace {
     absolutePath: string;
     /** Unix epoch timestamp (ms) when this workspace was registered. */
     registeredAt: number;
+    /** The profile (main workspace) this workspace belongs to. */
+    profile: string;
+}
+/**
+ * Represents a Profile (Main Workspace) that groups multiple registered workspaces.
+ */
+export interface Profile {
+    /** Unique name of the profile. */
+    name: string;
+    /** Unix epoch timestamp (ms) when this profile was created. */
+    createdAt: number;
 }
 /**
  * Result of resolving an `@alias/relative/path` string against the workspace registry.
@@ -39,6 +50,8 @@ export interface ResolvedWorkspacePath {
 declare class WorkspaceRegistry {
     /** In-memory map of alias → registered workspace. */
     private workspaces;
+    /** In-memory map of profile name → Profile. */
+    private profiles;
     /** Whether the registry has been loaded from disk. */
     private initialized;
     /**
@@ -47,8 +60,9 @@ declare class WorkspaceRegistry {
      */
     init(): void;
     /**
-     * Registers a new external workspace root with the given alias.
+     * Registers a new external workspace root with the given alias under a profile.
      *
+     * @param profile - The profile (main workspace) name.
      * @param alias - Short identifier for the workspace (e.g., "backend").
      *   Must be lowercase alphanumeric with hyphens/underscores, 1–30 chars.
      * @param absolutePath - Absolute path to the workspace root directory.
@@ -56,7 +70,7 @@ declare class WorkspaceRegistry {
      * @returns The created `RegisteredWorkspace`, or throws on validation failure.
      * @throws Error if the alias is invalid, the path doesn't exist, or the alias is already taken.
      */
-    register(alias: string, absolutePath: string): RegisteredWorkspace;
+    register(profile: string, alias: string, absolutePath: string): RegisteredWorkspace;
     /**
      * Removes a registered workspace by alias.
      *
@@ -69,13 +83,21 @@ declare class WorkspaceRegistry {
      */
     list(): RegisteredWorkspace[];
     /**
-     * Returns the number of registered workspaces.
+     * Returns all profiles (main workspaces).
      */
-    get size(): number;
+    listProfiles(): Profile[];
     /**
-     * Checks whether any external workspaces are registered.
+     * Checks whether any profiles (main workspaces) exist.
+     */
+    hasProfiles(): boolean;
+    /**
+     * Checks whether any workspaces exist.
      */
     hasWorkspaces(): boolean;
+    /**
+     * Returns all registered workspaces for a given profile.
+     */
+    getWorkspacesByProfile(profile: string): RegisteredWorkspace[];
     /**
      * Looks up a workspace by alias.
      *

package/dist/services/workspaceRegistry.js

@@ -24,6 +24,8 @@ const REGISTRY_FILE = path.join(GLOBAL_CONFIG_DIR, 'workspaces.json');
 class WorkspaceRegistry {
     /** In-memory map of alias → registered workspace. */
     workspaces = new Map();
+    /** In-memory map of profile name → Profile. */
+    profiles = new Map();
     /** Whether the registry has been loaded from disk. */
     initialized = false;
     /**
@@ -37,8 +39,9 @@ class WorkspaceRegistry {
         this.loadFromDisk();
     }
     /**
-     * Registers a new external workspace root with the given alias.
+     * Registers a new external workspace root with the given alias under a profile.
      *
+     * @param profile - The profile (main workspace) name.
      * @param alias - Short identifier for the workspace (e.g., "backend").
      *   Must be lowercase alphanumeric with hyphens/underscores, 1–30 chars.
      * @param absolutePath - Absolute path to the workspace root directory.
@@ -46,8 +49,16 @@ class WorkspaceRegistry {
      * @returns The created `RegisteredWorkspace`, or throws on validation failure.
      * @throws Error if the alias is invalid, the path doesn't exist, or the alias is already taken.
      */
-    register(alias, absolutePath) {
+    register(profile, alias, absolutePath) {
+        const normalizedProfile = profile.toLowerCase().trim();
         const normalizedAlias = alias.toLowerCase().trim();
+        // Ensure profile exists
+        if (!this.profiles.has(normalizedProfile)) {
+            this.profiles.set(normalizedProfile, {
+                name: normalizedProfile,
+                createdAt: Date.now(),
+            });
+        }
         // Validate alias format
         if (!ALIAS_PATTERN.test(normalizedAlias)) {
             throw new Error(`Invalid workspace alias "${normalizedAlias}". Must be 1-30 characters, ` +
@@ -85,10 +96,11 @@ class WorkspaceRegistry {
             alias: normalizedAlias,
             absolutePath: normalizedPath,
             registeredAt: Date.now(),
+            profile: normalizedProfile,
         };
         this.workspaces.set(normalizedAlias, workspace);
         this.saveToDisk();
-        debugLog(`Registered workspace: @${normalizedAlias} → ${normalizedPath}`);
+        debugLog(`Registered workspace: @${normalizedAlias} → ${normalizedPath} (Profile: ${normalizedProfile})`);
         return workspace;
     }
     /**
@@ -113,17 +125,29 @@ class WorkspaceRegistry {
         return Array.from(this.workspaces.values()).sort((a, b) => a.alias.localeCompare(b.alias));
     }
     /**
-     * Returns the number of registered workspaces.
+     * Returns all profiles (main workspaces).
      */
-    get size() {
-        return this.workspaces.size;
+    listProfiles() {
+        return Array.from(this.profiles.values()).sort((a, b) => a.name.localeCompare(b.name));
     }
     /**
-     * Checks whether any external workspaces are registered.
+     * Checks whether any profiles (main workspaces) exist.
+     */
+    hasProfiles() {
+        return this.profiles.size > 0;
+    }
+    /**
+     * Checks whether any workspaces exist.
      */
     hasWorkspaces() {
         return this.workspaces.size > 0;
     }
+    /**
+     * Returns all registered workspaces for a given profile.
+     */
+    getWorkspacesByProfile(profile) {
+        return this.list().filter((ws) => ws.profile === profile.toLowerCase().trim());
+    }
     /**
      * Looks up a workspace by alias.
      *
@@ -216,12 +240,31 @@ class WorkspaceRegistry {
             }
             const raw = fs.readFileSync(REGISTRY_FILE, 'utf-8');
             const data = JSON.parse(raw);
-            if (!Array.isArray(data)) {
+            if (!data || !Array.isArray(data.workspaces)) {
+                // Fallback for old schema
+                const oldData = JSON.parse(raw);
+                if (Array.isArray(oldData)) {
+                    for (const entry of oldData) {
+                        if (typeof entry.alias === 'string' &&
+                            typeof entry.absolutePath === 'string' &&
+                            ALIAS_PATTERN.test(entry.alias)) {
+                            if (fs.existsSync(entry.absolutePath)) {
+                                const profile = 'default';
+                                this.workspaces.set(entry.alias, { ...entry, profile });
+                                if (!this.profiles.has(profile)) {
+                                    this.profiles.set(profile, { name: profile, createdAt: Date.now() });
+                                }
+                            }
+                        }
+                    }
+                    debugLog(`Migrated ${this.workspaces.size} workspace(s) from old schema.`);
+                    return;
+                }
                 debugLog('Workspace registry file has invalid format, starting fresh.');
                 return;
             }
             // Validate each entry and skip invalid ones
-            for (const entry of data) {
+            for (const entry of data.workspaces) {
                 if (typeof entry.alias === 'string' &&
                     typeof entry.absolutePath === 'string' &&
                     ALIAS_PATTERN.test(entry.alias)) {
@@ -234,7 +277,10 @@ class WorkspaceRegistry {
                     }
                 }
             }
-            debugLog(`Loaded ${this.workspaces.size} workspace(s) from global registry.`);
+            for (const profile of data.profiles) {
+                this.profiles.set(profile.name, profile);
+            }
+            debugLog(`Loaded ${this.workspaces.size} workspace(s) and ${this.profiles.size} profile(s) from global registry.`);
         }
         catch (err) {
             debugLog(`Failed to load workspace registry: ${err instanceof Error ? err.message : String(err)}`);
@@ -250,12 +296,15 @@ class WorkspaceRegistry {
             if (!fs.existsSync(GLOBAL_CONFIG_DIR)) {
                 fs.mkdirSync(GLOBAL_CONFIG_DIR, { recursive: true });
             }
-            const data = Array.from(this.workspaces.values());
+            const data = {
+                workspaces: Array.from(this.workspaces.values()),
+                profiles: Array.from(this.profiles.values()),
+            };
             const tempPath = `${REGISTRY_FILE}.${Date.now()}.tmp`;
             fs.writeFileSync(tempPath, JSON.stringify(data, null, 2), 'utf-8');
             // Atomic rename to prevent corruption
             fs.renameSync(tempPath, REGISTRY_FILE);
-            debugLog(`Saved ${data.length} workspace(s) to global registry.`);
+            debugLog(`Saved ${data.workspaces.length} workspace(s) and ${data.profiles.length} profile(s) to global registry.`);
         }
         catch (err) {
             debugLog(`Failed to save workspace registry: ${err instanceof Error ? err.message : String(err)}`);

package/oclif.manifest.json

@@ -65,5 +65,5 @@
       ]
     }
   },
-  "version": "2.3.0"
+  "version": "2.3.2"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "minovative-mind-cli",
   "description": "An automated AI agent powered by Vertex AI that helps you write software",
-  "version": "2.3.0",
+  "version": "2.3.2",
   "author": "Daniel Ward",
   "bin": {
     "minovative-mind-cli": "bin/run.js"