chore: version up to 2.80.34 and package

src/sidebarProvider.ts

@@ -1,6 +1,7 @@
 import * as vscode from 'vscode';
 import * as fs from 'fs';
 import * as path from 'path';
+import * as os from 'os';
 import { 
     _getBrainDir, 
     findBrainFiles, 
@@ -22,7 +23,8 @@ import { handleChatMessage } from './sidebar/chatHandlers';
 import { handleBrainMessage } from './sidebar/brainHandlers';
 import { handleChronicleMessage } from './sidebar/chronicleHandlers';
 import { handleAgentMessage } from './sidebar/agentHandlers';
-import { getOrCreateAgentEntry } from './skills/agentKnowledgeMap';
+import { getOrCreateAgentEntry, resolveScopeForAgent } from './skills/agentKnowledgeMap';
+import { estimateModelParamsB } from './lib/contextManager';
 import { loadExternalSkills, formatSkillsAsPromptBlock } from './skills/externalSkillLoader';
 
 export interface SidebarLmStudioDeps {
@@ -111,12 +113,14 @@ export class SidebarChatProvider implements vscode.WebviewViewProvider, BridgeIn
             void this._sendModels();
             void this._sendBrainProfiles();
             void this._sendAgentsList();
+            void this._sendReadyStatus();
         });
 
         webviewView.webview.html = this._getHtml(webviewView.webview);
         this._agent.setWebview(webviewView.webview);
 
         void this._restoreActiveSessionIntoView();
+        void this._sendReadyStatus();
 
         webviewView.webview.onDidReceiveMessage(async (data) => {
             if (await handleChatMessage(this, data)) return;
@@ -393,6 +397,71 @@ export class SidebarChatProvider implements vscode.WebviewViewProvider, BridgeIn
         });
     }
 
+    /**
+     * One-line "current readiness" snapshot for the sidebar's status bar:
+     * engine online?, model loaded?, Brain file count, active Agent + mapped knowledge
+     * folder count, memory on/off, context window. Cheap — no network calls except the
+     * already-cached LM Studio loaded-models list and online flag.
+     */
+    async _sendReadyStatus() {
+        if (!this._view) return;
+        let payload: any;
+        try {
+            const config = getConfig();
+            const engineKind = resolveEngine(config.ollamaUrl);
+            const activeBrain = getActiveBrainProfile();
+            let brainFiles = 0;
+            try { brainFiles = findBrainFiles(activeBrain.localBrainPath).length; } catch { /* ignore */ }
+
+            const agentPath = this._context.globalState.get<string>(SidebarChatProvider.lastAgentStateKey, 'none');
+            let agentName: string | null = null;
+            let scopeFolders = 0;
+            let mapped = false;
+            if (agentPath && agentPath !== 'none') {
+                agentName = path.basename(agentPath).replace(/\.md$/i, '');
+                try {
+                    const scope = resolveScopeForAgent(agentPath, activeBrain.localBrainPath || '');
+                    scopeFolders = scope.folders.length;
+                    if (scope.agent?.name) agentName = scope.agent.name;
+                    mapped = scope.source !== 'none';
+                } catch { /* ignore */ }
+            }
+
+            let modelLoaded: boolean | null = null;
+            if (engineKind === 'lmstudio') {
+                try {
+                    const loaded = (await this._lmStudio?.loadedModels()) || [];
+                    modelLoaded = loaded.includes(config.defaultModel);
+                } catch { modelLoaded = null; }
+            }
+
+            const paramB = estimateModelParamsB(config.defaultModel);
+            const cappedForSmallModel = config.smallModelContextCap > 0
+                && paramB !== null && paramB <= 4
+                && config.contextLength > config.smallModelContextCap;
+            const effectiveContextLength = cappedForSmallModel ? config.smallModelContextCap : config.contextLength;
+            payload = {
+                engine: {
+                    kind: engineKind,
+                    label: engineKind === 'lmstudio' ? 'LM Studio' : 'Ollama',
+                    online: this._modelsCache?.online ?? null,
+                },
+                model: { name: config.defaultModel, loaded: modelLoaded, paramB },
+                brain: { name: activeBrain.name, files: brainFiles },
+                agent: { name: agentName, scopeFolders, mapped },
+                memory: config.memoryEnabled,
+                multiAgent: config.multiAgentEnabled,
+                contextLength: effectiveContextLength,
+                nominalContextLength: config.contextLength,
+                cappedForSmallModel,
+            };
+        } catch (err: any) {
+            logError('Failed to build ready status.', { error: err?.message || String(err) });
+            return;
+        }
+        this._view.webview.postMessage({ type: 'readyStatus', value: payload });
+    }
+
     async _sendBrainProfiles() {
         if (!this._view) return;
         const activeBrain = getActiveBrainProfile();
@@ -411,6 +480,7 @@ export class SidebarChatProvider implements vscode.WebviewViewProvider, BridgeIn
                 profiles
             }
         });
+        void this._sendReadyStatus();
     }
 
     _postBrainProfiles(profiles: any[], activeBrainId: string) {
@@ -1558,9 +1628,18 @@ export class SidebarChatProvider implements vscode.WebviewViewProvider, BridgeIn
     }
 
     _getAgentsDir(): string {
-        const defaultPath = 'E:\\Wiki\\Agent\\.agent\\skills';
-        if (fs.existsSync(defaultPath)) return defaultPath;
-        
+        // 1) Explicit config override (works on any OS — useful on Windows or for skills outside the workspace).
+        const configured = (vscode.workspace.getConfiguration('g1nation').get<string>('agentSkillsPath', '') || '').trim();
+        const expanded = configured.startsWith('~/') || configured === '~'
+            ? path.join(os.homedir(), configured.slice(1).replace(/^[\\/]/, ''))
+            : configured;
+        if (expanded && path.isAbsolute(expanded)) {
+            if (!fs.existsSync(expanded)) {
+                try { fs.mkdirSync(expanded, { recursive: true }); } catch { /* fall through to workspace */ }
+            }
+            if (fs.existsSync(expanded)) return expanded;
+        }
+        // 2) Default: <workspace>/.agent/skills
         const workspaceFolders = vscode.workspace.workspaceFolders;
         if (workspaceFolders) {
             const localPath = path.join(workspaceFolders[0].uri.fsPath, '.agent', 'skills');
@@ -1586,6 +1665,7 @@ export class SidebarChatProvider implements vscode.WebviewViewProvider, BridgeIn
         }
         const lastPath = this._context.globalState.get<string>(SidebarChatProvider.lastAgentStateKey, 'none');
         this._view.webview.postMessage({ type: 'agentsList', value: agents, selected: lastPath });
+        void this._sendReadyStatus();
     }
 
     async _handleProactiveSuggestion(context: string) {
@@ -1629,7 +1709,7 @@ export class SidebarChatProvider implements vscode.WebviewViewProvider, BridgeIn
 
         const filePath = path.join(dir, `${safeName}.md`);
         if (!fs.existsSync(filePath)) {
-            fs.writeFileSync(filePath, `# Agent Persona: ${safeName}\\n\\nAdd your instructions here...\\n`, 'utf8');
+            fs.writeFileSync(filePath, `# Agent Persona: ${safeName}\n\nAdd your instructions here...\n`, 'utf8');
         }
 
         const doc = await vscode.workspace.openTextDocument(filePath);
@@ -1834,6 +1914,8 @@ export class SidebarChatProvider implements vscode.WebviewViewProvider, BridgeIn
         } catch (error: any) {
             logError('Prompt handling failed in sidebar provider.', { error: error?.message || String(error), promptPreview: summarizeText(value || '', 200) });
             this._view.webview.postMessage({ type: 'error', value: error.message });
+        } finally {
+            void this._sendReadyStatus();
         }
     }
 
@@ -1934,6 +2016,7 @@ export class SidebarChatProvider implements vscode.WebviewViewProvider, BridgeIn
         } finally {
             this._modelDiscoveryInFlight = false;
         }
+        void this._sendReadyStatus();
     }
 
     static _htmlTemplateCache: string | undefined;