@sage-protocol/cli 0.3.10 → 0.4.1

package/dist/cli/mcp-server-stdio.js

@@ -53,6 +53,11 @@ const { createLibraryLister, formatLibraryList } = require('./services/mcp/libra
 const { createSubdaoDiscovery } = require('./services/mcp/subdao-discovery');
 const { createUnifiedPromptSearcher } = require('./services/mcp/unified-prompt-search');
 const { createToolArgsValidator } = require('./services/mcp/tool-args-validator');
+const {
+  TOOL_REGISTRY,
+  getToolsForCategory,
+  getToolMeta,
+} = require('./services/mcp/sage-tool-registry');
 const { createToolDispatcher } = require('./services/mcp/tool-dispatcher');
 const { createProposalLister } = require('./services/mcp/proposal-lister');
 const fs = require('fs');
@@ -79,6 +84,41 @@ class SageMCPServer {
     };
 
     this.tools = [
+      {
+        name: 'suggest_sage_tools',
+        description: `Suggest the most relevant Sage MCP tools for a given goal.
+When to use:
+- You have a vague goal and want help choosing the right Sage tools
+- You want a ranked list of 3–5 tools with rationale and required parameters
+
+This tool does not execute any actions; it only recommends which tools to call next.`,
+        inputSchema: {
+          type: 'object',
+          properties: {
+            goal: { type: 'string', description: 'Free-text description of what you are trying to do' },
+            stage: {
+              type: 'string',
+              enum: ['prompt_workspace', 'persona', 'libraries', 'governance', 'treasury', 'discovery'],
+              description: 'Optional hint about which area you are working in',
+            },
+            context: {
+              type: 'object',
+              description: 'Optional execution context (workspace, wallet, etc.)',
+              properties: {
+                hasWorkspace: { type: 'boolean', description: 'Whether a Sage prompt workspace is present' },
+                hasWallet: { type: 'boolean', description: 'Whether a wallet is configured/available' },
+                currentTask: { type: 'string', description: 'Short description of what you just did' },
+              },
+            },
+            limit: { type: 'number', description: 'Maximum number of primary recommendations (default: 5)' },
+            includeAlternatives: {
+              type: 'boolean',
+              description: 'Whether to include a secondary list of alternative tools (default: false)',
+            },
+          },
+          required: ['goal'],
+        },
+      },
       {
         name: 'quick_create_prompt',
         description: `Quickly create a new prompt. Handles library creation automatically.
@@ -374,6 +414,42 @@ Next steps:
           required: []
         }
       },
+      {
+        name: 'list_persona_templates',
+        description: 'List available persona templates for the Metaprompt Engine',
+        inputSchema: {
+          type: 'object',
+          properties: {},
+          required: []
+        }
+      },
+      {
+        name: 'run_persona_interview',
+        description: 'Generate a persona system prompt from structured answers (One-Shot, no human loop)',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            template: { type: 'string', description: 'Template key (e.g., coding-assistant, governance-helper)' },
+            answers: { type: 'object', description: 'Key-value map of slot answers' },
+            save: { type: 'boolean', description: 'Whether to save the artifact to disk (default: false)' },
+            saveKey: { type: 'string', description: 'Optional filename for saving' }
+          },
+          required: ['template', 'answers']
+        }
+      },
+      {
+        name: 'persona_interview_step',
+        description: 'Stateful persona interview. Returns slot metadata for the host agent to phrase questions. Pass answers back with the stateToken to progress through slots.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            template: { type: 'string', description: 'Template key (coding-assistant, governance-helper, research-analyst, custom). Required on first call.' },
+            stateToken: { type: 'string', description: 'Base64-encoded state from previous response. Omit on first call.' },
+            answer: { type: 'string', description: 'Answer for the slot identified by currentSlotKey in the previous response.' }
+          },
+          required: []
+        }
+      },
       {
         name: 'save_metaprompt',
         description: 'Persist a metaprompt to the local Sage workspace and optionally append to agents.md',
@@ -1013,6 +1089,9 @@ Note: This tool does NOT sign transactions. It prepares everything so you can ex
       'tool:get_prompts_from_manifest': (params) => this.getPromptsFromManifest(params),
       'tool:list_metaprompts': () => this.listMetaprompts(),
       'tool:start_metaprompt_interview': (params) => this.startMetapromptInterview(params),
+      'tool:list_persona_templates': () => this.listPersonaTemplates(),
+      'tool:run_persona_interview': (params) => this.runPersonaInterview(params),
+      'tool:persona_interview_step': (params) => this.personaInterviewStep(params),
       'tool:save_metaprompt': (params) => this.saveMetaprompt(params),
       'tool:get_metaprompt': (params) => this.getMetaprompt(params),
       'tool:generate_metaprompt_link': (params) => this.generateMetapromptLink(params),
@@ -1035,6 +1114,7 @@ Note: This tool does NOT sign transactions. It prepares everything so you can ex
       'tool:analyze_dependencies': (params) => this.analyzeDependencies(params),
       'tool:suggest_subdaos_for_library': (params) => this.suggestSubdaosForLibrary(params),
       'tool:generate_publishing_commands': (params) => this.generatePublishingCommands(params),
+      'tool:suggest_sage_tools': (params) => this.suggestSageTools(params),
     });
 
     const toolHandlers = {
@@ -2453,6 +2533,274 @@ Use \`help(topic="create")\` for more details.
     return this.listLibrariesHandler(options);
   }
 
+  // ───────────────────────── Tool suggestion meta-router ─────────────────────────
+
+  tokenizeForMatching(text) {
+    if (!text) return [];
+    const lower = String(text).toLowerCase();
+    const tokens = lower.split(/[^a-z0-9]+/g).filter(Boolean);
+    // Small stopword list; just enough to ignore generic phrasing.
+    const stop = new Set([
+      'the', 'a', 'an', 'to', 'for', 'and', 'or', 'of', 'in', 'on', 'with', 'this', 'that',
+      'i', 'me', 'my', 'we', 'our', 'you', 'your',
+      'want', 'need', 'help', 'can', 'could', 'would', 'should',
+      'how', 'do', 'does', 'did', 'what', 'is', 'are', 'it', 'be',
+    ]);
+    return tokens.filter((t) => !stop.has(t));
+  }
+
+  inferStage(goal, explicitStage) {
+    if (explicitStage) return explicitStage;
+    if (!goal) return null;
+
+    const patterns = {
+      prompt_workspace: /\b(prompt|skill|workspace|create|edit|draft|write|local)\b/gi,
+      persona: /\b(persona|metaprompt|interview|agent|character|assistant|system prompt)\b/gi,
+      libraries: /\b(library|manifest|template|collection|import|export)\b/gi,
+      governance: /\b(publish|proposal|vote|subdao|dao|govern|approve|execute)\b/gi,
+      treasury: /\b(treasury|bond|boost|withdraw|sxxx|token|stake)\b/gi,
+      discovery: /\b(search|find|list|browse|explore|trending|discover)\b/gi,
+    };
+
+    const scores = {};
+    for (const [stage, pattern] of Object.entries(patterns)) {
+      const matches = goal.match(pattern) || [];
+      if (matches.length > 0) scores[stage] = matches.length;
+    }
+
+    const entries = Object.entries(scores);
+    if (!entries.length) return null;
+    entries.sort((a, b) => b[1] - a[1]);
+    return entries[0][0];
+  }
+
+  detectWorkflow(goal) {
+    if (!goal) return null;
+    const lower = goal.toLowerCase();
+
+    const workflows = [
+      {
+        // Create & publish a prompt/library
+        pattern: /create.*prompt.*publish|publish.*prompt|create.*library.*publish|publish.*library/i,
+        tools: ['quick_create_prompt', 'improve_prompt', 'publish_manifest_flow'],
+      },
+      {
+        // Design & (optionally) publish a persona
+        pattern: /create.*persona.*publish|design.*persona.*publish|persona.*publish/i,
+        tools: ['list_persona_templates', 'persona_interview_step', 'save_metaprompt', 'publish_manifest_flow'],
+      },
+      {
+        // Design a persona without explicit publishing intent
+        pattern: /design.*persona|create.*persona|persona.*workflow/i,
+        tools: ['list_persona_templates', 'persona_interview_step', 'save_metaprompt'],
+      },
+      {
+        // Find & iterate on prompts
+        pattern: /find.*prompt.*iterate|iterate.*prompt|improve.*prompt/i,
+        tools: ['search_prompts', 'get_prompt', 'quick_iterate_prompt'],
+      },
+      {
+        // Publish to a DAO/SubDAO
+        pattern: /publish.*dao|dao.*publish|publish.*subdao|subdao.*publish/i,
+        tools: ['suggest_subdaos_for_library', 'generate_publishing_commands', 'publish_manifest_flow'],
+      },
+    ];
+
+    for (const wf of workflows) {
+      if (wf.pattern.test(lower)) {
+        return wf.tools;
+      }
+    }
+    return null;
+  }
+
+  scoreToolForGoal(toolMeta, goalTokens, stage) {
+    // BM25-inspired scoring with simple term frequency and length normalization.
+    const baseTerms = [
+      ...(toolMeta.keywords || []),
+      ...this.tokenizeForMatching(toolMeta.description || ''),
+      ...this.tokenizeForMatching(toolMeta.whenToUse || ''),
+    ];
+
+    const docLen = baseTerms.length || 1;
+    const avgLen = 15;
+    const k1 = 1.2;
+    const b = 0.75;
+
+    let score = 0;
+
+    for (const token of goalTokens) {
+      const tf = baseTerms.filter((t) => t === token).length;
+      if (tf > 0) {
+        const tfScore = (tf * (k1 + 1)) / (tf + k1 * (1 - b + b * (docLen / avgLen)));
+        score += tfScore;
+      }
+    }
+
+    // Negative keyword penalty.
+    if (toolMeta.negativeKeywords && toolMeta.negativeKeywords.length) {
+      let penalties = 0;
+      for (const neg of toolMeta.negativeKeywords) {
+        if (goalTokens.includes(neg)) penalties += 1;
+      }
+      if (penalties > 0) {
+        score *= (0.5 ** penalties);
+      }
+    }
+
+    // Stage/category boost.
+    if (stage && toolMeta.category === stage) {
+      score *= 1.5;
+    }
+
+    // Base weight.
+    const weight = typeof toolMeta.weight === 'number' ? toolMeta.weight : 1;
+    score *= weight;
+
+    // Normalize to 0–1 range.
+    return Math.min(score / 5, 1);
+  }
+
+  orderSuggestedTools(scored, limit) {
+    if (!Array.isArray(scored) || !scored.length) return [];
+    const sorted = [...scored].sort((a, b) => b.confidence - a.confidence).slice(0, limit);
+    if (sorted.length <= 3) {
+      return sorted.map((item, idx) => ({ ...item, priority: idx + 1 }));
+    }
+
+    // Simple U-shaped ordering: higher-ranked items gravitate to the ends.
+    const result = [];
+    for (let i = 0; i < sorted.length; i += 1) {
+      if (i % 2 === 0) {
+        // Even indices append to the end
+        result.push(sorted[i]);
+      } else {
+        // Odd indices unshift to the front
+        result.unshift(sorted[i]);
+      }
+    }
+
+    return result.map((item, idx) => ({ ...item, priority: idx + 1 }));
+  }
+
+  async suggestSageTools(params) {
+    // Arguments are already validated by createToolArgsValidator.
+    const { goal, stage, context, limit = 5, includeAlternatives = false } = params || {};
+
+    const effectiveStage = this.inferStage(goal, stage);
+    const goalTokens = this.tokenizeForMatching(goal);
+
+    // Choose candidate tools from registry.
+    let candidates = [];
+    if (effectiveStage === 'discovery') {
+      // Discovery is intentionally cross-cutting; surface the most browse/search oriented tools.
+      const discoveryTools = ['search_prompts', 'list_prompts', 'trending_prompts', 'list_persona_templates', 'list_libraries'];
+      candidates = discoveryTools
+        .map((name) => getToolMeta(name))
+        .filter(Boolean);
+    } else if (effectiveStage) {
+      candidates = getToolsForCategory(effectiveStage);
+    } else {
+      // If no clear stage, fall back to a small set of discovery-friendly tools.
+      const discoveryTools = ['search_prompts', 'list_prompts', 'trending_prompts', 'list_persona_templates', 'list_libraries'];
+      candidates = discoveryTools
+        .map((name) => getToolMeta(name))
+        .filter(Boolean);
+    }
+
+    // Cross-category fallback: if we have a clear stage, allow strongly-matching tools
+    // from other categories to join the candidate set.
+    if (effectiveStage) {
+      const allTools = Object.entries(TOOL_REGISTRY).map(([name, meta]) => ({ name, ...meta }));
+      const existingNames = new Set(candidates.map((c) => c.name));
+      const crossCategory = allTools
+        .filter((t) => t.category !== effectiveStage && !existingNames.has(t.name))
+        .map((t) => ({
+          ...t,
+          confidence: this.scoreToolForGoal(t, goalTokens, null),
+        }))
+        .filter((t) => t.confidence > 0.6);
+
+      if (crossCategory.length) {
+        candidates = candidates.concat(crossCategory);
+      }
+    }
+
+    // Apply simple context-based filtering/hints.
+    if (context && context.hasWorkspace === false) {
+      // If there is no workspace, de-prioritize workspace-only tools.
+      candidates = candidates.map((c) => {
+        if (c.category === 'prompt_workspace') {
+          return { ...c, weight: (c.weight || 1) * 0.7 };
+        }
+        return c;
+      });
+    }
+
+    // Score tools.
+    const scored = candidates.map((meta) => ({
+      ...meta,
+      confidence: this.scoreToolForGoal(meta, goalTokens, effectiveStage),
+    })).filter((item) => item.confidence >= 0.15);
+
+    if (!scored.length) {
+      const fallback = {
+        recommendations: [],
+        alternatives: [],
+        inferredStage: effectiveStage || null,
+        suggestedWorkflow: null,
+      };
+      return {
+        content: [{
+          type: 'text',
+          text: JSON.stringify(fallback, null, 2),
+        }],
+      };
+    }
+
+    const ordered = this.orderSuggestedTools(scored, limit);
+    const workflow = this.detectWorkflow(goal);
+
+    const recommendations = ordered.map((item) => ({
+      toolName: item.name,
+      category: item.category,
+      confidence: item.confidence,
+      priority: item.priority,
+      rationale: item.whenToUse,
+      requiredParams: item.requiredParams || [],
+    }));
+
+    let alternatives = [];
+    if (includeAlternatives) {
+      const remaining = scored
+        .filter((s) => !ordered.find((r) => r.name === s.name))
+        .sort((a, b) => b.confidence - a.confidence)
+        .slice(0, limit);
+      alternatives = remaining.map((item, idx) => ({
+        toolName: item.name,
+        category: item.category,
+        confidence: item.confidence,
+        priority: idx + 1,
+        rationale: item.whenToUse,
+        requiredParams: item.requiredParams || [],
+      }));
+    }
+
+    const result = {
+      recommendations,
+      alternatives,
+      inferredStage: effectiveStage || null,
+      suggestedWorkflow: workflow || null,
+    };
+
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify(result, null, 2),
+      }],
+    };
+  }
+
   listMetaprompts() {
     const rows = metapromptDesigner.listMetaprompts();
     if (!rows.length) {
@@ -2848,6 +3196,207 @@ Use \`help(topic="create")\` for more details.
     }
   }
 
+  // ───────────────────────────── Metaprompt Engine Tools ─────────────────────────────
+
+  async listPersonaTemplates() {
+    try {
+      const templates = require('./services/metaprompt/templates.json');
+      const list = Object.values(templates).map(t => ({
+        key: t.key,
+        name: t.name,
+        description: t.description,
+        recommended_slots: t.recommended_slots?.map(s => s.label) || []
+      }));
+      
+      return {
+        content: [
+          {
+            type: 'text',
+            text: JSON.stringify(list, null, 2)
+          }
+        ]
+      };
+    } catch (error) {
+      return {
+        isError: true,
+        content: [{ type: 'text', text: `Failed to list templates: ${error.message}` }]
+      };
+    }
+  }
+
+  async runPersonaInterview(params) {
+    const { template, answers, save, saveKey } = params;
+    try {
+      const config = require('./config');
+      const PromptBuilder = require('./services/metaprompt/prompt-builder');
+      const MetapromptPersistence = require('./services/metaprompt/persistence');
+      const templates = require('./services/metaprompt/templates.json');
+
+      // 1. Validate Template
+      const templateDef = templates[template] || templates['custom'];
+      
+      // 2. Build Prompt (One-Shot)
+      // Note: run_persona_interview assumes the *agent* has already done the planning/filling.
+      // It bypasses the SlotPlanner and just builds the artifact.
+      const builder = new PromptBuilder();
+      // We need the full slot definitions to build dynamic sections.
+      // Since we skipped the planner, we'll use the template's recommended slots as the definition.
+      const slots = templateDef.recommended_slots || [];
+      
+      const systemPrompt = builder.buildSystemPrompt(template, slots, answers || {});
+
+      let result = {
+        systemPrompt,
+        slug: '',
+        paths: {}
+      };
+
+      // 3. Save (Optional)
+      if (save) {
+        const persistence = new MetapromptPersistence(config);
+        const slug = saveKey || `${template}-${Date.now().toString().slice(-6)}`;
+        
+        // Save dummy history so the artifact exists
+        const historyPaths = persistence.saveMetaprompt(slug, {
+          templateKey: template,
+          transcript: [{ role: 'system', content: 'Generated via MCP run_persona_interview (one-shot).' }],
+          answers: answers || {}
+        });
+        
+        // Save Skill
+        const skillPath = persistence.saveSkill(slug, systemPrompt);
+        
+        result.slug = slug;
+        result.paths = {
+          metaprompt: historyPaths.metaprompt,
+          skill: skillPath
+        };
+      }
+
+      return {
+        content: [
+          {
+            type: 'text',
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+
+    } catch (error) {
+      return {
+        isError: true,
+        content: [{ type: 'text', text: `Failed to run persona interview: ${error.message}` }]
+      };
+    }
+  }
+
+  /**
+   * Stateful persona interview that walks through template slots.
+   *
+   * Returns slot metadata (label, description, group) for the host agent to phrase questions.
+   * The agent passes answers back with the stateToken to progress through slots.
+   * When all required slots are filled, returns the generated system prompt.
+   *
+   * @param {object} params
+   * @param {string} params.template - Template key (coding-assistant, governance-helper, etc.)
+   * @param {string} [params.stateToken] - Base64-encoded state from previous call
+   * @param {string} [params.answer] - Answer for the current slot (currentSlotKey from previous response)
+   */
+  async personaInterviewStep(params) {
+    const { template, stateToken, answer } = params;
+    try {
+      const templates = require('./services/metaprompt/templates.json');
+      const PromptBuilder = require('./services/metaprompt/prompt-builder');
+
+      // 1. Restore or initialize state
+      let state;
+      if (stateToken) {
+        try {
+          state = JSON.parse(Buffer.from(stateToken, 'base64').toString('utf8'));
+        } catch {
+          return { isError: true, content: [{ type: 'text', text: 'Invalid stateToken' }] };
+        }
+      } else {
+        // Initialize new interview state
+        const templateKey = template || 'custom';
+        const templateDef = templates[templateKey] || templates.custom;
+        state = {
+          templateKey,
+          slots: templateDef.recommended_slots || [],
+          answers: {},
+          currentSlotKey: null,
+        };
+      }
+
+      // 2. Record answer for the current slot (if provided)
+      if (answer && state.currentSlotKey) {
+        state.answers[state.currentSlotKey] = answer;
+      }
+
+      // 3. Find next unanswered slot (required first, then optional by priority)
+      const unanswered = state.slots.filter(s => !state.answers[s.key]);
+      const requiredUnanswered = unanswered.filter(s => s.required);
+      const nextSlot = requiredUnanswered[0] || unanswered.find(s => s.priority <= 2) || null;
+
+      // 4. Update state with current slot key
+      state.currentSlotKey = nextSlot?.key || null;
+
+      // 5. Serialize state for next call
+      const newStateToken = Buffer.from(JSON.stringify(state)).toString('base64');
+
+      // 6. Check if interview is complete
+      if (!nextSlot) {
+        // All required slots filled - build the system prompt (no LLM needed)
+        const builder = new PromptBuilder();
+        const systemPrompt = builder.buildSystemPrompt(state.templateKey, state.slots, state.answers);
+
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              done: true,
+              systemPrompt,
+              template: state.templateKey,
+              answers: state.answers,
+              filledSlots: Object.keys(state.answers).length,
+              totalSlots: state.slots.length,
+              stateToken: newStateToken,
+            }, null, 2)
+          }]
+        };
+      }
+
+      // 7. Return next slot info for the host LLM to phrase the question
+      // The host LLM should use slotLabel/slotDescription to ask the user
+      const suggestedQuestion = `Please provide: ${nextSlot.label}. ${nextSlot.description || ''}`.trim();
+
+      return {
+        content: [{
+          type: 'text',
+          text: JSON.stringify({
+            done: false,
+            currentSlotKey: nextSlot.key,
+            slotLabel: nextSlot.label,
+            slotDescription: nextSlot.description || '',
+            slotGroup: nextSlot.group || 'general',
+            slotRequired: nextSlot.required || false,
+            suggestedQuestion,
+            filledSlots: Object.keys(state.answers).length,
+            totalSlots: state.slots.length,
+            remainingRequired: requiredUnanswered.length,
+            stateToken: newStateToken,
+          }, null, 2)
+        }]
+      };
+
+    } catch (error) {
+      return {
+        isError: true,
+        content: [{ type: 'text', text: `Failed to execute interview step: ${error.message}` }]
+      };
+    }
+  }
+
   async getSubDAOList(options = {}) {
     try {
       return await this.subdaoDiscovery.listSubDaos(options);

package/dist/cli/mcp-server.js

@@ -11,6 +11,7 @@ const { ethers } = require('ethers');
 const { execSync } = require('child_process');
 const axios = require('axios');
 const fss = require('fs');
+const { hydrateEnvFromSageConfig } = require('./services/mcp/env-loader');
 const { createLibraryManifestLister } = require('./services/mcp/library-manifests');
 const { createManifestFetcher } = require('./services/mcp/manifest-fetcher');
 const { createManifestWorkflows } = require('./services/mcp/manifest-workflows');
@@ -57,37 +58,10 @@ class MCPServer extends EventEmitter {
   }
 
   async initialize() {
-    // Hydrate env from .sage/config.json if missing
+    // Hydrate env from .sage/config.json if missing (factory, registry, token, subgraph)
     try {
-      let dir = process.cwd();
-      let cfgPath = null;
-      for (let i = 0; i < 6; i++) {
-        const cand = path.join(dir, '.sage', 'config.json');
-        if (fss.existsSync(cand)) { cfgPath = cand; break; }
-        const next = path.dirname(dir);
-        if (next === dir) break;
-        dir = next;
-      }
-      if (!cfgPath) {
-        const alt = path.join(__dirname, '..', '.sage', 'config.json');
-        if (fss.existsSync(alt)) cfgPath = alt;
-      }
-      if (cfgPath) {
-        const raw = fss.readFileSync(cfgPath, 'utf8');
-        const j = JSON.parse(raw);
-        const active = j.activeProfile || Object.keys(j.profiles || {})[0];
-        const a = (j.profiles && j.profiles[active] && j.profiles[active].addresses) || {};
-        if (!process.env.SUBDAO_FACTORY_ADDRESS && (a.SUBDAO_FACTORY_ADDRESS || a.SUBDAO_FACTORY)) {
-          process.env.SUBDAO_FACTORY_ADDRESS = a.SUBDAO_FACTORY_ADDRESS || a.SUBDAO_FACTORY;
-        }
-        if (!process.env.LIBRARY_REGISTRY_ADDRESS && (a.LIBRARY_REGISTRY_ADDRESS || a.LIBRARY_REGISTRY)) {
-          process.env.LIBRARY_REGISTRY_ADDRESS = a.LIBRARY_REGISTRY_ADDRESS || a.LIBRARY_REGISTRY;
-        }
-        if (!process.env.SXXX_TOKEN_ADDRESS && (a.SXXX_TOKEN_ADDRESS || a.SXXX)) {
-          process.env.SXXX_TOKEN_ADDRESS = a.SXXX_TOKEN_ADDRESS || a.SXXX;
-        }
-      }
-    } catch (_) { /* ignore */ }
+      hydrateEnvFromSageConfig({ cwd: process.cwd(), fallbackDir: path.join(__dirname, '..') });
+    } catch (_) { /* non-fatal */ }
     // Ensure directories exist
     await this.ensureDirectories();