minovative-mind-cli 2.3.1 → 2.3.3

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);
 /**
@@ -134,7 +134,24 @@ export async function handleSlashCommand(command, context) {
         const prevUsage = context.chatSessionState?.previousUsageMetadata;
         const currentModel = chat.getModel();
         const globalModel = getGlobalActiveModel();
-        const displayModel = globalModel === 'auto' ? `Auto (Last turn: ${currentModel})` : currentModel;
+        const modelUsageCounts = context.chatSessionState?.modelUsageCounts || {};
+        const modelsUsed = Object.keys(modelUsageCounts);
+        let modelStatsStr = '';
+        if (modelsUsed.length > 0) {
+            const totalTurns = Object.values(modelUsageCounts).reduce((a, b) => a + b, 0);
+            const parts = modelsUsed.map((m) => {
+                const percent = Math.round((modelUsageCounts[m] / totalTurns) * 100);
+                return `${m} ${percent}%`;
+            });
+            modelStatsStr = parts.join(', ');
+        }
+        let displayModel = '';
+        if (globalModel === 'auto') {
+            displayModel = modelStatsStr ? `Auto (${modelStatsStr})` : `Auto (Last turn: ${currentModel})`;
+        }
+        else {
+            displayModel = modelStatsStr || currentModel;
+        }
         const autoApprove = getApprovalMode() === 'skip-all' ? 'Enabled' : 'Disabled';
         const subAgents = isSubAgentsEnabled() ? 'Enabled' : 'Disabled';
         const planMode = context.isPlanMode ? 'Enabled' : 'Disabled';
@@ -405,6 +422,7 @@ export async function handleSlashCommand(command, context) {
                     chatSessionState.totalOutputTokens = session.totalOutputTokens || 0;
                     chatSessionState.latestUsageMetadata = session.latestUsageMetadata;
                     chatSessionState.previousUsageMetadata = session.previousUsageMetadata;
+                    chatSessionState.modelUsageCounts = session.modelUsageCounts || {};
                     chat.setSessionInfo(session.id, workspaceRoot);
                 }
                 process.stdout.write('\x1B[2J\x1B[3J\x1B[H'); // Hard clear screen and scrollback
@@ -495,7 +513,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 +557,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 +573,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 +621,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 +640,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 +662,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 +709,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 +738,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/agent/types.d.ts

@@ -18,6 +18,7 @@ export interface SlashCommandContext {
         totalOutputTokens: number;
         latestUsageMetadata?: any;
         previousUsageMetadata?: any;
+        modelUsageCounts?: Record<string, number>;
     };
 }
 export interface SlashCommandResult {

package/dist/services/agent.d.ts

@@ -57,6 +57,7 @@ export declare function executeSingleTurn(workspaceRoot: string, userInput: stri
     totalOutputTokens: number;
     latestUsageMetadata?: any;
     previousUsageMetadata?: any;
+    modelUsageCounts?: Record<string, number>;
 }, isPlanMode: boolean, cachedContextResult?: any): Promise<{
     planModeReturn?: string;
     contextResult?: any;

package/dist/services/agent.js

@@ -86,7 +86,7 @@ export async function startAgentLoop(workspaceRoot, version) {
     chatHistoryService.init(workspaceRoot);
     const chat = createSharedChatSession();
     const inputHandler = new AsyncInputHandler();
-    const chatSessionState = { id: crypto.randomUUID(), title: '', totalTokens: 0, totalInputTokens: 0, totalOutputTokens: 0 };
+    const chatSessionState = { id: crypto.randomUUID(), title: '', totalTokens: 0, totalInputTokens: 0, totalOutputTokens: 0, modelUsageCounts: {} };
     chat.setSessionInfo(chatSessionState.id, workspaceRoot);
     const sessionInputHistory = [];
     let isRawPasteMode = false;
@@ -115,6 +115,9 @@ export async function startAgentLoop(workspaceRoot, version) {
             chatSessionState.totalTokens = 0;
             chatSessionState.totalInputTokens = 0;
             chatSessionState.totalOutputTokens = 0;
+            chatSessionState.modelUsageCounts = {};
+            chatSessionState.latestUsageMetadata = undefined;
+            chatSessionState.previousUsageMetadata = undefined;
             chat.setSessionInfo(chatSessionState.id, workspaceRoot);
         }
         inputHandler.stop();
@@ -377,6 +380,12 @@ export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHan
                     }
                     // Print Usage Stats
                     const usage = getAndResetTurnUsage();
+                    chatSessionState.modelUsageCounts = chatSessionState.modelUsageCounts || {};
+                    if (usage.modelsUsed) {
+                        for (const [m, count] of Object.entries(usage.modelsUsed)) {
+                            chatSessionState.modelUsageCounts[m] = (chatSessionState.modelUsageCounts[m] || 0) + count;
+                        }
+                    }
                     chatSessionState.previousUsageMetadata = chatSessionState.latestUsageMetadata;
                     chatSessionState.latestUsageMetadata = usage;
                     chatSessionState.totalTokens += usage.totalTokenCount;
@@ -433,6 +442,7 @@ export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHan
                             subAgents: isSubAgentsEnabled(),
                             latestUsageMetadata: chatSessionState.latestUsageMetadata,
                             previousUsageMetadata: chatSessionState.previousUsageMetadata,
+                            modelUsageCounts: chatSessionState.modelUsageCounts,
                         })
                             .catch((e) => debugLog('Failed to auto-save session: ' + e));
                     }
@@ -511,6 +521,12 @@ export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHan
                 changeLogger.markComplete();
             }
             if (usage) {
+                chatSessionState.modelUsageCounts = chatSessionState.modelUsageCounts || {};
+                if (usage.modelsUsed) {
+                    for (const [m, count] of Object.entries(usage.modelsUsed)) {
+                        chatSessionState.modelUsageCounts[m] = (chatSessionState.modelUsageCounts[m] || 0) + count;
+                    }
+                }
                 chatSessionState.previousUsageMetadata = chatSessionState.latestUsageMetadata;
                 chatSessionState.latestUsageMetadata = usage;
                 chatSessionState.totalTokens += usage.totalTokenCount || 0;
@@ -541,6 +557,7 @@ export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHan
                             subAgents: isSubAgentsEnabled(),
                             latestUsageMetadata: chatSessionState.latestUsageMetadata,
                             previousUsageMetadata: chatSessionState.previousUsageMetadata,
+                            modelUsageCounts: chatSessionState.modelUsageCounts,
                         });
                     }
                     catch (e) {
@@ -564,6 +581,7 @@ export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHan
                     subAgents: isSubAgentsEnabled(),
                     latestUsageMetadata: chatSessionState.latestUsageMetadata,
                     previousUsageMetadata: chatSessionState.previousUsageMetadata,
+                    modelUsageCounts: chatSessionState.modelUsageCounts,
                 })
                     .catch((e) => debugLog('Failed to auto-save session: ' + e));
             }

package/dist/services/chatHistoryService.d.ts

@@ -35,6 +35,8 @@ export interface ChatSessionData {
     latestUsageMetadata?: any;
     /** Optional metadata about the token usage from the turn prior to the last turn. */
     previousUsageMetadata?: any;
+    /** Optional map tracking the number of turns each model was used during the session. */
+    modelUsageCounts?: Record<string, number>;
 }
 /**
  * Service responsible for managing the persistence, retrieval, and deletion of chat session histories.

package/dist/services/proxyClient.d.ts

@@ -21,6 +21,7 @@ export declare function getAndResetTurnUsage(): {
     totalTokenCount: number;
     creditsUsed: number;
     remainingBalance: number | undefined;
+    modelsUsed: Record<string, number>;
 };
 export declare function peekTurnUsage(): {
     promptTokens: number;
@@ -29,6 +30,7 @@ export declare function peekTurnUsage(): {
     totalTokenCount: number;
     creditsUsed: number;
     remainingBalance: number | undefined;
+    modelsUsed: Record<string, number>;
 };
 /**
  * Client service interacting directly with the serverless Gemini proxy endpoint.

package/dist/services/proxyClient.js

@@ -39,7 +39,8 @@ let globalSessionAccumulatedUsage = {
     cachedTokens: 0,
     totalTokenCount: 0,
     creditsUsed: 0,
-    remainingBalance: undefined
+    remainingBalance: undefined,
+    modelsUsed: {}
 };
 export function getAndResetTurnUsage() {
     const current = { ...globalSessionAccumulatedUsage };
@@ -49,7 +50,8 @@ export function getAndResetTurnUsage() {
         cachedTokens: 0,
         totalTokenCount: 0,
         creditsUsed: 0,
-        remainingBalance: undefined
+        remainingBalance: undefined,
+        modelsUsed: {}
     };
     return current;
 }
@@ -190,6 +192,7 @@ export class ProxyClient {
                                     if (data.usage.remainingBalance !== undefined) {
                                         globalSessionAccumulatedUsage.remainingBalance = data.usage.remainingBalance;
                                     }
+                                    globalSessionAccumulatedUsage.modelsUsed[modelName] = (globalSessionAccumulatedUsage.modelsUsed[modelName] || 0) + 1;
                                 }
                                 if (data.groundingMetadata) {
                                     groundingMetadata = data.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.1"
+  "version": "2.3.3"
 }

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.1",
+  "version": "2.3.3",
   "author": "Daniel Ward",
   "bin": {
     "minovative-mind-cli": "bin/run.js"