@sage-protocol/cli 0.4.1 → 0.4.2

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

@@ -59,6 +59,7 @@ const {
   getToolMeta,
 } = require('./services/mcp/sage-tool-registry');
 const { createToolDispatcher } = require('./services/mcp/tool-dispatcher');
+const ProjectContextService = require('./services/project-context');
 const { createProposalLister } = require('./services/mcp/proposal-lister');
 const fs = require('fs');
 const path = require('path');
@@ -84,6 +85,18 @@ class SageMCPServer {
     };
 
     this.tools = [
+      {
+        name: 'get_project_context',
+        description: `Get context about the current Sage project (root, DAO, counts, etc).
+When to use:
+- At the start of a session to understand where you are
+- Before suggesting tools to check if workspace/wallet is available`,
+        inputSchema: {
+          type: 'object',
+          properties: {},
+          required: []
+        }
+      },
       {
         name: 'suggest_sage_tools',
         description: `Suggest the most relevant Sage MCP tools for a given goal.
@@ -255,7 +268,7 @@ Next steps:
           properties: {
             query: { type: 'string', description: 'Free-text search applied to names, descriptions, and tags' },
             source: { type: 'string', enum: ['local', 'onchain', 'all'], description: 'Data source preference (default: all)' },
-            subdao: { type: 'string', description: 'Optional SubDAO address when source=onchain' },
+            subdao: { type: 'string', description: 'Optional DAO address when source=onchain' },
             tags: { type: 'array', items: { type: 'string' }, description: 'Optional tag filters (matches any tag)' },
             includeContent: { type: 'boolean', description: 'Include raw prompt content when supported (default: false)' },
             page: { type: 'number', description: 'Results page (default: 1)' },
@@ -349,7 +362,7 @@ Next steps:
       },
       {
         name: 'search_onchain_prompts',
-        description: 'Search for prompts directly on-chain from LibraryRegistry and SubDAO registries',
+        description: 'Search for prompts directly on-chain from LibraryRegistry and DAO registries',
         inputSchema: {
           type: 'object',
           properties: {
@@ -359,7 +372,7 @@ Next steps:
             },
             subdao: {
               type: 'string',
-              description: 'Filter by specific SubDAO address (optional)'
+              description: 'Filter by specific DAO address (optional)'
             },
             tags: {
               type: 'array',
@@ -503,13 +516,13 @@ Next steps:
       },
       {
         name: 'list_subdaos',
-        description: 'List all available SubDAOs in the Sage Protocol',
+        description: 'List all available DAOs in the Sage Protocol',
         inputSchema: {
           type: 'object',
           properties: {
             limit: {
               type: 'number',
-              description: 'Maximum number of SubDAOs to return (default: 20)'
+              description: 'Maximum number of DAOs to return (default: 20)'
             }
           },
           required: []
@@ -531,10 +544,10 @@ Next steps:
       },
       {
         name: 'refresh_library_bindings',
-        description: 'Refresh cached per-library registry mappings (optional: target a specific SubDAO)',
+        description: 'Refresh cached per-library registry mappings (optional: target a specific DAO)',
         inputSchema: {
           type: 'object',
-          properties: { subdao: { type: 'string', description: 'Optional SubDAO address (0x...)' } },
+          properties: { subdao: { type: 'string', description: 'Optional DAO address (0x...)' } },
           required: []
         }
       },
@@ -558,10 +571,10 @@ Next steps:
       },
       {
         name: 'list_subdao_libraries',
-        description: 'List per-library PromptRegistry mappings for a SubDAO',
+        description: 'List per-library PromptRegistry mappings for a DAO',
         inputSchema: {
           type: 'object',
-          properties: { subdao: { type: 'string', description: 'SubDAO address (0x...)' } },
+          properties: { subdao: { type: 'string', description: 'DAO address (0x...)' } },
           required: ['subdao']
         }
       },
@@ -589,13 +602,13 @@ Next steps:
       },
       {
         name: 'propose_manifest',
-        description: `Generate the proposal payload and CLI commands for a SubDAO update.
+        description: `Generate the proposal payload and CLI commands for a DAO governance update.
 Note: This tool does NOT sign transactions. It generates the hex data and CLI commands for you to execute in your terminal.`,
         inputSchema: {
           type: 'object',
           properties: {
             cid: { type: 'string', description: 'IPFS CID of the manifest' },
-            subdao: { type: 'string', description: 'SubDAO address' },
+            subdao: { type: 'string', description: 'DAO address' },
             description: { type: 'string', description: 'Proposal description' },
             promptCount: { type: 'number', description: 'Number of prompts (optional override)' },
             manifest: { type: 'object', description: 'Optional manifest object for context' }
@@ -639,11 +652,11 @@ Note: This tool does NOT sign transactions. It generates the hex data and CLI co
       },
       {
         name: 'list_proposals',
-        description: 'List active proposals for a SubDAO',
+        description: 'List active governance proposals for a DAO',
         inputSchema: {
           type: 'object',
           properties: {
-            subdao: { type: 'string', description: 'SubDAO address' },
+            subdao: { type: 'string', description: 'DAO address' },
             state: { type: 'string', description: 'Filter by state (Active, Executed, etc)' },
             limit: { type: 'number', description: 'Max items (default 10)' }
           },
@@ -662,7 +675,7 @@ Note: This tool does NOT sign transactions. It prepares everything so you can ex
           type: 'object',
           properties: {
             manifest: { type: 'object', description: 'Manifest JSON' },
-            subdao: { type: 'string', description: 'Optional SubDAO address for hints' },
+            subdao: { type: 'string', description: 'Optional DAO address for hints' },
             description: { type: 'string', description: 'Optional description override' },
             dry_run: { type: 'boolean', description: 'Validate and build proposal payload without uploading to IPFS (no network calls)' }
           },
@@ -813,7 +826,7 @@ Note: This tool does NOT sign transactions. It prepares everything so you can ex
       },
       {
         name: 'suggest_subdaos_for_library',
-        description: 'Suggest SubDAOs that might be a good fit for publishing a given local library, and provide CLI workflows for creating your own SubDAO and pushing the library.',
+        description: 'Suggest DAOs that might be a good fit for publishing a given local library, and provide CLI workflows for creating your own DAO and pushing the library.',
         inputSchema: {
           type: 'object',
           properties: {
@@ -823,7 +836,7 @@ Note: This tool does NOT sign transactions. It prepares everything so you can ex
             },
             limit: {
               type: 'number',
-              description: 'Max SubDAOs to return (default 5)',
+              description: 'Max DAOs to return (default 5)',
               default: 5
             },
             mode_filter: {
@@ -848,36 +861,15 @@ Note: This tool does NOT sign transactions. It prepares everything so you can ex
             },
             target: {
               type: 'string',
-              description: 'Target SubDAO address or "auto" to pick a likely candidate',
+              description: 'Target DAO address or "auto" to pick a likely candidate',
               default: 'auto'
             }
           },
           required: ['library']
         }
       },
-      {
-        name: 'list_workspace_skills',
-        description: 'List local workspace skills from prompts/ (e.g. prompts/skills/*.md)',
-        inputSchema: {
-          type: 'object',
-          properties: {},
-          required: []
-        }
-      },
-      {
-        name: 'get_workspace_skill',
-        description: 'Load a workspace skill by key and return its content',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            key: {
-              type: 'string',
-              description: 'Skill key relative to prompts dir (e.g. skills/backend-dev-guidelines)'
-            }
-          },
-          required: ['key']
-        }
-      }
+      // NOTE: list_workspace_skills and get_workspace_skill have been removed.
+      // Use list_prompts({ kind: 'skill' }) and get_prompt({ key }) instead.
     ];
 
     // Structured logger to stderr (stdout must remain JSON-RPC only)
@@ -911,6 +903,9 @@ Note: This tool does NOT sign transactions. It prepares everything so you can ex
     // Local library helper for unified search
     this.libraryManager = new LibraryManager();
 
+    // Project context service for get_project_context tool
+    this.projectContextService = new ProjectContextService();
+
     // Simple rate limiter (token bucket per tool)
     this.rateConfig = { capacity: 20, refillPerSec: 0.33 }; // ~20/min
     this.rateLimiter = createRateLimiter(this.rateConfig);
@@ -1104,8 +1099,6 @@ Note: This tool does NOT sign transactions. It prepares everything so you can ex
       'tool:list_proposals': (params) => this.listProposals(params),
       'tool:publish_manifest_flow': (params) => this.publishManifestFlow(params),
       'tool:refresh_library_bindings': (params) => this.refreshLibraryBindings(params),
-      'tool:list_workspace_skills': (params) => this.listWorkspaceSkills(params),
-      'tool:get_workspace_skill': (params) => this.getWorkspaceSkill(params),
       'tool:update_library_metadata': (params) => this.updateLibraryMetadata(params),
       'tool:bulk_update_prompts': (params) => this.bulkUpdatePrompts(params),
       'tool:list_templates': (params) => this.listTemplates(params),
@@ -1115,6 +1108,7 @@ Note: This tool does NOT sign transactions. It prepares everything so you can ex
       '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),
+      'tool:get_project_context': (params) => this.getProjectContext(params),
     });
 
     const toolHandlers = {
@@ -1282,93 +1276,9 @@ Note: This tool does NOT sign transactions. It prepares everything so you can ex
   }
 
   // ───────────────────────── Workspace skills (repo-tied skills) ─────────────────────────
-
-  /**
-   * List skills defined in the current project's prompt workspace.
-   * Convention:
-   * - Workspace file: .sage/workspace.json (optional)
-   * - Prompts dir: workspace.promptsDir or "prompts"
-   * - Skill files live under promptsDir/skills/*.md
-   */
-  listWorkspaceSkills() {
-    try {
-      const { readWorkspace, DEFAULT_DIR } = require('./services/prompts/workspace');
-      const { findWorkspaceSkills } = require('./services/skills/discovery');
-      const ws = readWorkspace() || {};
-      const promptsDir = ws.promptsDir || DEFAULT_DIR || 'prompts';
-      const results = findWorkspaceSkills({ promptsDir });
-      if (!results.length) {
-        return {
-          content: [
-            {
-              type: 'text',
-              text: 'No skills found. Create prompts/skills/<name>.md or prompts/skills/<name>/SKILL.md to define skills for this repo.',
-            },
-            { type: 'text', text: '```json\n' + JSON.stringify({ skills: [] }, null, 2) + '\n```' },
-          ],
-        };
-      }
-      const textLines = results
-        .map(
-          (s, idx) =>
-            `${idx + 1}. **${s.name}** (${s.key})\n   📁 ${path.relative(process.cwd(), s.path)}${s.summary ? `\n   📝 ${s.summary}` : ''
-            }${s.tags && s.tags.length ? `\n   🔖 ${s.tags.join(', ')}` : ''}`,
-        )
-        .join('\n\n');
-      return {
-        content: [
-          { type: 'text', text: `Workspace skills (${results.length})\n\n${textLines}` },
-          { type: 'text', text: '```json\n' + JSON.stringify({ skills: results }, null, 2) + '\n```' },
-        ],
-      };
-    } catch (error) {
-      return {
-        content: [{ type: 'text', text: `Error listing workspace skills: ${error.message}` }],
-      };
-    }
-  }
-
-  /**
-   * Load a workspace skill by key and return its content.
-   * Key is relative to prompts dir, e.g. "skills/backend-dev-guidelines".
-   */
-  getWorkspaceSkill({ key }) {
-    try {
-      if (!key || !String(key).trim()) {
-        return { content: [{ type: 'text', text: 'get_workspace_skill: key is required' }] };
-      }
-      const { readWorkspace, DEFAULT_DIR } = require('./services/prompts/workspace');
-      const { resolveSkillFileByKey } = require('./services/skills/discovery');
-      const ws = readWorkspace() || {};
-      const promptsDir = ws.promptsDir || DEFAULT_DIR || 'prompts';
-      const safeKey = String(key).trim().replace(/^\/+/, '').replace(/\.md$/i, '');
-      const resolved = resolveSkillFileByKey({ promptsDir, key: safeKey });
-      if (!resolved || !fs.existsSync(resolved.path)) {
-        const expectedFlat = path.join(process.cwd(), promptsDir, `${safeKey}.md`);
-        const expectedDir = path.join(process.cwd(), promptsDir, safeKey, 'SKILL.md');
-        return {
-          content: [
-            {
-              type: 'text',
-              text: `Workspace skill not found for key '${safeKey}'. Expected at ${path.relative(process.cwd(), expectedFlat)} or ${path.relative(process.cwd(), expectedDir)}`,
-            },
-          ],
-        };
-      }
-      const body = fs.readFileSync(resolved.path, 'utf8');
-      return {
-        content: [
-          {
-            type: 'text',
-            text: `Loaded workspace skill '${safeKey}' from ${path.relative(process.cwd(), resolved.path)}.\n\n${body}`,
-          },
-          { type: 'text', text: '```json\n' + JSON.stringify({ key: safeKey, path: resolved.path, baseDir: resolved.baseDir, body }, null, 2) + '\n```' },
-        ],
-      };
-    } catch (error) {
-      return { content: [{ type: 'text', text: `Error loading workspace skill: ${error.message}` }] };
-    }
-  }
+  // NOTE: listWorkspaceSkills and getWorkspaceSkill have been removed.
+  // Use list_prompts({ kind: 'skill' }) and get_prompt({ key }) instead.
+  // ─────────────────────────────────────────────────────────────────────────────────────────
 
   async getPromptByName(params = {}) {
     const name = String(params.name || '').trim();
@@ -1461,38 +1371,87 @@ Note: This tool does NOT sign transactions. It prepares everything so you can ex
     return this.searchPromptsUnifiedHandler(options);
   }
 
-  async listPrompts({ source = 'local', library = '', limit = 20 } = {}) {
+  async listPrompts({ source = 'local', library = '', limit = 20, kind, publishable } = {}) {
     try {
-      const results = await this.searchPromptsUnifiedHandler({
-        query: '',
-        source,
-        includeContent: false,
-        page: 1,
-        pageSize: limit
-      });
-
-      if (library && results?.content?.[1]?.text) {
-        const jsonMatch = results.content[1].text.match(/```json\n([\s\S]+)\n```/);
-        if (jsonMatch) {
-          const data = JSON.parse(jsonMatch[1]);
-          const libraryLower = library.toLowerCase();
-          data.results = data.results.filter(r =>
-            r.library?.name?.toLowerCase().includes(libraryLower) ||
-            r.library?.cid?.toLowerCase().includes(libraryLower)
-          );
-          data.total = data.results.length;
+      // If source is 'workspace' or we want to include workspace artifacts, use ArtifactManager
+      const includeWorkspace = source === 'local' || source === 'workspace' || source === 'all';
+
+      let workspaceResults = [];
+      if (includeWorkspace) {
+        const ArtifactManager = require('./services/artifact-manager');
+        const artifactManager = new ArtifactManager();
+        const filter = {};
+        if (kind) filter.kind = kind;
+        if (publishable !== undefined) filter.publishable = publishable;
+
+        const artifacts = await artifactManager.listArtifacts(filter);
+        workspaceResults = artifacts.map(a => ({
+          resultType: 'prompt',
+          origin: 'workspace',
+          source: 'Workspace',
+          key: a.key,
+          name: a.meta?.title || a.key,
+          description: a.meta?.summary || '',
+          tags: a.meta?.tags || [],
+          content: a.body,
+          kind: a.kind,
+          publishable: a.publishable,
+          publishing: a.publishing,
+          targets: a.targets,
+          filePath: a.filePath,
+        }));
+      }
+
+      // Also get library prompts if not workspace-only
+      let libraryResults = [];
+      if (source !== 'workspace') {
+        const results = await this.searchPromptsUnifiedHandler({
+          query: '',
+          source: source === 'workspace' ? 'local' : source,
+          includeContent: false,
+          page: 1,
+          pageSize: limit
+        });
 
-          const formatted = this.formatUnifiedResults(data.results, { total: data.total, page: 1, pageSize: limit });
-          return {
-            content: [
-              { type: 'text', text: formatted },
-              { type: 'text', text: '```json\n' + JSON.stringify(data, null, 2) + '\n```' }
-            ]
-          };
+        if (results?.content?.[1]?.text) {
+          const jsonMatch = results.content[1].text.match(/```json\n([\s\S]+)\n```/);
+          if (jsonMatch) {
+            const data = JSON.parse(jsonMatch[1]);
+            libraryResults = (data.results || []).map(r => ({
+              ...r,
+              kind: r.kind || 'prompt',
+              publishable: true, // library prompts are published
+              publishing: { status: 'published' }
+            }));
+          }
         }
       }
 
-      return results;
+      // Merge and filter
+      let allResults = [...workspaceResults, ...libraryResults];
+
+      // Filter by library if specified
+      if (library) {
+        const libraryLower = library.toLowerCase();
+        allResults = allResults.filter(r =>
+          r.library?.name?.toLowerCase().includes(libraryLower) ||
+          r.library?.cid?.toLowerCase().includes(libraryLower) ||
+          r.origin === 'workspace' // workspace prompts don't have library
+        );
+      }
+
+      // Apply limit
+      allResults = allResults.slice(0, limit);
+
+      const data = { results: allResults, total: allResults.length, page: 1, pageSize: limit };
+      const formatted = this.formatUnifiedResults(allResults, { total: data.total, page: 1, pageSize: limit });
+
+      return {
+        content: [
+          { type: 'text', text: formatted },
+          { type: 'text', text: '```json\n' + JSON.stringify(data, null, 2) + '\n```' }
+        ]
+      };
     } catch (error) {
       return { content: [{ type: 'text', text: `Error listing prompts: ${error.message}` }] };
     }
@@ -1504,6 +1463,41 @@ Note: This tool does NOT sign transactions. It prepares everything so you can ex
         return { content: [{ type: 'text', text: 'Error: key parameter is required' }] };
       }
 
+      // First try workspace artifacts (ArtifactManager)
+      const ArtifactManager = require('./services/artifact-manager');
+      const artifactManager = new ArtifactManager();
+      const artifact = await artifactManager.getArtifact(key);
+
+      if (artifact) {
+        const prompt = {
+          resultType: 'prompt',
+          origin: 'workspace',
+          source: 'Workspace',
+          key: artifact.key,
+          name: artifact.meta?.title || artifact.key,
+          description: artifact.meta?.summary || '',
+          tags: artifact.meta?.tags || [],
+          content: artifact.body,
+          kind: artifact.kind,
+          publishable: artifact.publishable,
+          publishing: artifact.publishing,
+          targets: artifact.targets,
+          filePath: artifact.filePath,
+        };
+
+        const kindBadge = prompt.kind !== 'prompt' ? ` [${prompt.kind}]` : '';
+        const publishBadge = prompt.publishable ? '' : ' (local only)';
+        const text = `**${prompt.name}**${kindBadge}${publishBadge}\n\n🔑 Key: ${prompt.key}\n📂 Source: Workspace\n📄 ${prompt.description || 'No description'}\n🏷️ Tags: ${prompt.tags?.join(', ') || 'None'}\n📌 Kind: ${prompt.kind}\n📤 Publishable: ${prompt.publishable}\n📊 Status: ${prompt.publishing?.status || 'unknown'}\n\n**Content:**\n\`\`\`\n${prompt.content || '(No content)'}\n\`\`\``;
+
+        return {
+          content: [
+            { type: 'text', text },
+            { type: 'text', text: '```json\n' + JSON.stringify(prompt, null, 2) + '\n```' }
+          ]
+        };
+      }
+
+      // Fall back to library search
       const results = await this.searchPromptsUnifiedHandler({
         query: key,
         source: 'local',
@@ -1532,7 +1526,12 @@ Note: This tool does NOT sign transactions. It prepares everything so you can ex
             return { content: [{ type: 'text', text: `No prompt found with key "${key}"` }] };
           }
 
-          const text = `**${prompt.name}**\n\n🔑 Key: ${prompt.key}\n📚 Library: ${prompt.library?.name || 'Unknown'}\n📄 ${prompt.description || 'No description'}\n🏷️ Tags: ${prompt.tags?.join(', ') || 'None'}\n\n**Content:**\n\`\`\`\n${prompt.content || '(No content)'}\n\`\`\``;
+          // Add kind/publishable for library prompts
+          prompt.kind = prompt.kind || 'prompt';
+          prompt.publishable = true;
+          prompt.publishing = { status: 'published' };
+
+          const text = `**${prompt.name}**\n\n🔑 Key: ${prompt.key}\n📚 Library: ${prompt.library?.name || 'Unknown'}\n📄 ${prompt.description || 'No description'}\n🏷️ Tags: ${prompt.tags?.join(', ') || 'None'}\n📌 Kind: ${prompt.kind}\n\n**Content:**\n\`\`\`\n${prompt.content || '(No content)'}\n\`\`\``;
 
           return {
             content: [
@@ -1665,6 +1664,61 @@ Note: This tool does NOT sign transactions. It prepares everything so you can ex
     }
   }
 
+  async getProjectContext(params) {
+    try {
+      const ctx = await this.projectContextService.getProjectContext(params || {});
+      const lines = [];
+      lines.push('✅ Project context');
+      lines.push(`Project root: ${ctx.projectRoot || 'not found'}`);
+      lines.push(`Prompts dir: ${ctx.promptsDir || 'prompts'}`);
+      if (ctx.subdao) {
+        lines.push(`SubDAO: ${ctx.subdao}`);
+      }
+      if (ctx.registry) {
+        lines.push(`Library registry: ${ctx.registry}`);
+      }
+      if (ctx.network) {
+        lines.push(`Network: ${ctx.network}`);
+      }
+      if (ctx.rpcUrl) {
+        lines.push(`RPC URL: ${ctx.rpcUrl}`);
+      }
+      if (ctx.workspace) {
+        lines.push(
+          `Workspace artifacts: prompts=${ctx.workspace.promptCount}, skills=${ctx.workspace.skillCount}, snippets=${ctx.workspace.snippetCount}, total=${ctx.workspace.total}`
+        );
+      }
+      if (ctx.agentSurfaces) {
+        const surfaces = [];
+        if (ctx.agentSurfaces.cursorRulesDir) {
+          surfaces.push(`cursor rules at ${ctx.agentSurfaces.cursorRulesDir}`);
+        }
+        if (ctx.agentSurfaces.claudeManifest) {
+          surfaces.push(`CLAUDE manifest at ${ctx.agentSurfaces.claudeManifest}`);
+        }
+        if (ctx.agentSurfaces.copilotPromptsDir) {
+          surfaces.push(`Copilot prompts at ${ctx.agentSurfaces.copilotPromptsDir}`);
+        }
+        if (Array.isArray(ctx.agentSurfaces.agentsFiles) && ctx.agentSurfaces.agentsFiles.length) {
+          surfaces.push(`AGENTS files: ${ctx.agentSurfaces.agentsFiles.join(', ')}`);
+        }
+        if (surfaces.length) {
+          lines.push('Agent surfaces:');
+          surfaces.forEach((s) => lines.push(`- ${s}`));
+        }
+      }
+
+      return {
+        content: [
+          { type: 'text', text: lines.join('\n') },
+          { type: 'text', text: '```json\n' + JSON.stringify(ctx, null, 2) + '\n```' },
+        ],
+      };
+    } catch (error) {
+      return { content: [{ type: 'text', text: `Error retrieving project context: ${error.message}` }] };
+    }
+  }
+
   async listTemplates(params = {}) {
     try {
       const result = this.templateManager.listTemplates(params || {});
@@ -3207,7 +3261,7 @@ Use \`help(topic="create")\` for more details.
         description: t.description,
         recommended_slots: t.recommended_slots?.map(s => s.label) || []
       }));
-      
+
       return {
         content: [
           {
@@ -3234,7 +3288,7 @@ Use \`help(topic="create")\` for more details.
 
       // 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.
@@ -3242,7 +3296,7 @@ Use \`help(topic="create")\` for more details.
       // 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 = {
@@ -3255,17 +3309,17 @@ Use \`help(topic="create")\` for more details.
       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,