nothumanallowed 14.1.80 → 14.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nothumanallowed",
-  "version": "14.1.80",
+  "version": "14.2.0",
   "description": "NotHumanAllowed — 38 AI agents, 80 tools, Studio (visual agentic workflows). Email, calendar, browser automation, screen capture, canvas, cron/heartbeat, Alexandria E2E messaging, GitHub, Notion, Slack, voice chat, free AI (Liara), 28 languages. Zero-dependency CLI.",
   "type": "module",
   "bin": {

package/src/constants.mjs

@@ -5,7 +5,7 @@ import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
-export const VERSION = '14.1.80';
+export const VERSION = '14.2.0';
 export const BASE_URL = 'https://nothumanallowed.com/cli';
 export const API_BASE = 'https://nothumanallowed.com/api/v1';
 

package/src/server/routes/webcraft.mjs

@@ -381,6 +381,26 @@ const SkillStore = {
     if (fs.existsSync(abs)) fs.unlinkSync(abs);
   },
 
+  /** Ensure memory.md, skills.md, and provider.md always exist for a project. */
+  ensureDefaults(projectName, config) {
+    const dir = ensureDir(this.dir(projectName));
+    const provider = config?.llm?.provider || 'nha';
+    const model = config?.llm?.model || '';
+
+    const memFile = path.join(dir, 'memory.md');
+    if (!fs.existsSync(memFile)) {
+      fs.writeFileSync(memFile, `# ${projectName} — Project Memory\n\n_Architectural decisions, preferences, and notes._\n`, 'utf-8');
+    }
+    const skillsFile = path.join(dir, 'skills.md');
+    if (!fs.existsSync(skillsFile)) {
+      fs.writeFileSync(skillsFile, `# ${projectName} — Skills\n\n_Coding patterns, best practices, and conventions for this project._\n`, 'utf-8');
+    }
+    const providerFile = path.join(dir, `${provider}.md`);
+    if (!fs.existsSync(providerFile)) {
+      fs.writeFileSync(providerFile, `# ${provider.toUpperCase()} — ${model || 'Default'}\n\n_Model-specific notes, prompt tips, and configuration._\n`, 'utf-8');
+    }
+  },
+
   context(projectName) {
     const skills = this.list(projectName);
     if (skills.length === 0) return '';
@@ -455,165 +475,259 @@ const ChatStore = {
  * Uses structured SSE events: { type: 'text', token } | { type: 'tool', ... } | { type: 'done', changed }
  */
 async function runWebCraftAgent(config, projectName, message, attachments, emit) {
+  const MAX_STEPS = 8; // max agentic loop iterations
   const dir = ProjectStore.dir(projectName);
   if (!fs.existsSync(dir)) { emit({ type: 'error', msg: 'Project not found' }); return; }
 
-  const files = _listProjectFiles(dir);
-  const skillCtx = SkillStore.context(projectName);
+  SkillStore.ensureDefaults(projectName, config);
 
-  const fileIndex = files.map((f) => `- ${f}`).join('\n');
   const today = new Date().toISOString().slice(0, 10);
   const LANG_MAP = { en:'English',it:'Italian',es:'Spanish',fr:'French',de:'German',pt:'Portuguese' };
   const language = LANG_MAP[(config?.language||'it').slice(0,2)] || 'Italian';
 
-  // Build context: include files mentioned in the message + key project files
-  const mentionedFiles = files.filter((f) => message.toLowerCase().includes(f.toLowerCase().split('/').pop() ?? ''));
-  // Always include key structural files
-  const keyFiles = files.filter((f) => /^(server|app|index)\.(js|mjs|ts)$/.test(f) || f === 'package.json' || f.includes('routes/index'));
-  const contextFiles = [...new Set([...mentionedFiles, ...keyFiles, ...files.slice(0, 12)])].slice(0, 15);
-  const fileContents = contextFiles.map((rel) => {
-    try {
-      const content = fs.readFileSync(path.join(dir, rel), 'utf-8');
-      return `### FILE: ${rel}\n\`\`\`\n${content.slice(0, 8000)}\n\`\`\``;
-    } catch { return ''; }
-  }).filter(Boolean).join('\n\n');
-
   const toolSpec = `
-AVAILABLE TOOLS (use XML tags exactly as shown):
+AVAILABLE TOOLS (use exactly ONE tool per <tool> tag):
+
+1. Read a file (to see its current content before editing):
+<tool>{"op":"read","path":"relative/path.js"}</tool>
+
+2. Edit a file (surgical replacement of exact code):
+<tool>{"op":"edit","path":"relative/path.js","old":"EXACT_EXISTING_CODE","new":"REPLACEMENT_CODE"}</tool>
 
-1. Read a file:
-<tool>{"op":"read","path":"filename.js"}</tool>
+3. Write/create a file (complete content):
+<tool>{"op":"write","path":"relative/path.js","content":"FULL_FILE_CONTENT"}</tool>
 
-2. Edit a file (replace a snippet):
-<tool>{"op":"edit","path":"filename.js","old":"EXACT_EXISTING_CODE","new":"REPLACEMENT_CODE"}</tool>
+4. Check syntax of a JS file:
+<tool>{"op":"check","path":"relative/path.js"}</tool>
 
-3. Write a complete file (full content):
-<tool>{"op":"write","path":"filename.js","content":"FULL_FILE_CONTENT"}</tool>
+WORKFLOW — follow this for every change:
+1. Read the file(s) you need to modify
+2. Make your changes with edit or write
+3. Use check to verify JS files have no syntax errors
+4. If check fails, read the file again and fix
+5. When ALL changes are complete and verified, output: <done/>
 
 RULES:
-- Always use edit for small targeted changes (preferred — faster and safer)
-- Use write only when creating a new file or doing a complete rewrite
-- "old" must be an EXACT verbatim match of the existing code — no paraphrasing
-- Never apply a tool to a file outside the project scope
-- After each tool use, continue explaining what you did
+- "old" must be an EXACT verbatim copy from the file — copy-paste, no paraphrasing
+- Use edit for targeted changes, write for new files or complete rewrites
+- ALWAYS read before edit if you haven't seen the file content yet
+- ALWAYS check JS files after modifications
+- Output <done/> when you are completely finished — this is MANDATORY
 `;
 
-  // Load memory.md and skills.md for context
-  const ctxDir = SkillStore.dir(projectName);
-  let skillContext = '';
-  try {
-    const memPath = path.join(ctxDir, 'memory.md');
-    const skillsPath = path.join(ctxDir, 'skills.md');
-    const providerPath = path.join(ctxDir, `${config.llm?.provider || 'nha'}.md`);
+  // Build system prompt with fresh file list each step
+  function buildSystemPrompt() {
+    const files = _listProjectFiles(dir);
+    const fileIndex = files.map((f) => `- ${f}`).join('\n');
+    const skillCtx = SkillStore.context(projectName);
+    const ctxDir = SkillStore.dir(projectName);
+    let skillContext = '';
+    try {
+      for (const name of ['memory.md', 'skills.md', `${config.llm?.provider || 'nha'}.md`]) {
+        const p = path.join(ctxDir, name);
+        if (fs.existsSync(p)) skillContext += `\n### ${name}:\n${fs.readFileSync(p, 'utf-8')}\n`;
+      }
+    } catch {}
 
-    if (fs.existsSync(memPath)) {
-      const memContent = fs.readFileSync(memPath, 'utf-8');
-      skillContext += `\n### MEMORY:\n${memContent}\n`;
-    }
-    if (fs.existsSync(skillsPath)) {
-      const skillsContent = fs.readFileSync(skillsPath, 'utf-8');
-      skillContext += `\n### SKILLS:\n${skillsContent}\n`;
-    }
-    if (fs.existsSync(providerPath)) {
-      const providerContent = fs.readFileSync(providerPath, 'utf-8');
-      skillContext += `\n### MODEL INFO:\n${providerContent}\n`;
-    }
-  } catch {}
+    // Key files: load full content for server, package.json, index
+    const keyFiles = files.filter((f) =>
+      /^(server|app|index)\.(js|mjs|ts)$/.test(f) || f === 'package.json' || f.includes('routes/index')
+    );
+    const mentionedFiles = files.filter((f) =>
+      message.toLowerCase().includes((f.split('/').pop() || '').toLowerCase())
+    );
+    const contextFiles = [...new Set([...mentionedFiles, ...keyFiles])].slice(0, 10);
+    const fileContents = contextFiles.map((rel) => {
+      try {
+        const content = fs.readFileSync(path.join(dir, rel), 'utf-8');
+        return `### FILE: ${rel}\n\`\`\`\n${content}\n\`\`\``;
+      } catch { return ''; }
+    }).filter(Boolean).join('\n\n');
+
+    return [
+      `You are WebCraft Agent — an elite AI coding assistant. Today: ${today}. Language: ${language}.`,
+      `\nYou control the project IDE. You MUST use tools to implement changes — never just explain.`,
+      `\nYour workflow: read → plan → edit/write → check → verify → done.`,
+      `\nAfter EVERY tool use, you will receive the result. Based on the result, decide what to do next.`,
+      `\nWhen finished, output <done/> to signal completion.`,
+      `\n\n## PROJECT: ${projectName}`,
+      `\n## FILE TREE:\n${fileIndex}`,
+      skillContext,
+      skillCtx ? `\n\n## PROJECT KNOWLEDGE:\n${skillCtx}` : '',
+      attachments?.length ? `\n\n## ATTACHMENTS: ${attachments.map((a) => a.name).join(', ')}` : '',
+      fileContents ? `\n\n## LOADED FILES:\n${fileContents}` : '',
+      `\n\n${toolSpec}`,
+    ].join('');
+  }
 
-  const systemPrompt = [
-    `You are WebCraft Agent — a team of 200 senior developers working as one entity. Today is ${today}. Respond in ${language}.`,
-    `\nYou have FULL control of the project IDE. You read files, edit them surgically, and write new ones.`,
-    `\nYour edits MUST be enterprise-grade: security, error handling, responsive design, accessibility.`,
-    `\nWhen the user asks for changes, you MUST use tools to implement them — never just explain. ACT, don't talk.`,
-    `\nAfter each tool use, briefly explain what changed and why.`,
-    `\n\n## PROJECT: ${projectName}`,
-    `\n## FILES:\n${fileIndex}`,
-    skillContext,
-    skillCtx ? `\n\n## ADDITIONAL CONTEXT:\n${skillCtx}` : '',
-    attachments?.length ? `\n\n## ATTACHMENTS: ${attachments.map((a) => a.name).join(', ')}` : '',
-    `\n\n## CURRENT FILE CONTENTS:\n${fileContents}`,
-    `\n\n${toolSpec}`,
-  ].join('');
-
-  // Prepare user content (text + images if any)
+  // Prepare user content
   const userContent = attachments?.length
     ? _buildMultimodalContent(message, attachments)
     : message;
 
-  let fullResponse = '';
+  // ── Agentic loop ───────────────────────────────────────────────────────────
   let hasChanges = false;
+  const modifiedFiles = new Set();
+  let conversationHistory = [
+    { role: 'user', content: userContent },
+  ];
+
+  for (let step = 0; step < MAX_STEPS; step++) {
+    const systemPrompt = buildSystemPrompt();
+    emit({ type: 'step', step: step + 1, max: MAX_STEPS });
+
+    // Build user message from conversation history
+    // callLLMStream takes a single string, so we concatenate the conversation
+    let stepResponse = '';
+    const userMsg = conversationHistory.map((m) =>
+      m.role === 'user' ? m.content : `[ASSISTANT RESPONSE]\n${m.content.slice(0, 6000)}`
+    ).join('\n\n---\n\n');
+
+    await callLLMStream(config, systemPrompt, userMsg, (token) => {
+      stepResponse += token;
+      // Stream visible text (suppress tool tags)
+      const visible = token.replace(/<tool>[\s\S]*?<\/tool>/g, '').replace(/<done\s*\/>/g, '');
+      if (visible) emit({ type: 'text', token: visible });
+    }, { max_tokens: 16384 });
+
+    // Check if agent signaled completion
+    const isDone = stepResponse.includes('<done/>') || stepResponse.includes('<done />');
+
+    // Extract and execute ALL tool calls from this step
+    const toolRegex = /<tool>([\s\S]*?)<\/tool>/g;
+    let match;
+    const toolResults = [];
+
+    while ((match = toolRegex.exec(stepResponse)) !== null) {
+      let toolCall;
+      try {
+        // Fix common JSON issues from LLM
+        let raw = match[1].trim();
+        raw = raw.replace(/,\s*}/g, '}').replace(/,\s*]/g, ']');
+        toolCall = JSON.parse(raw);
+      } catch {
+        toolResults.push({ op: 'error', result: 'JSON parse failed' });
+        emit({ type: 'tool', op: 'parse_error', path: '', result: 'json_parse_failed' });
+        continue;
+      }
 
-  await callLLMStream(config, systemPrompt, userContent, (token) => {
-    fullResponse += token;
-    // Suppress raw <tool> blocks from text stream — only emit visible text
-    const visibleToken = token.replace(/<tool>[\s\S]*?<\/tool>/g, '');
-    if (visibleToken) emit({ type: 'text', token: visibleToken });
-  }, { max_tokens: 16384 });
-
-  // ── Execute all tool calls found in the response ───────────────────────────
-  const toolRegex = /<tool>([\s\S]*?)<\/tool>/g;
-  let match;
-  while ((match = toolRegex.exec(fullResponse)) !== null) {
-    let toolCall;
-    try { toolCall = JSON.parse(match[1].trim()); } catch {
-      emit({ type: 'tool', op: 'parse_error', path: '', result: 'json_parse_failed' });
-      continue;
-    }
-
-    const { op, path: relPath, old: oldStr, new: newStr, content } = toolCall;
-    if (!relPath || !_isSafePath(relPath)) {
-      emit({ type: 'tool', op, path: relPath ?? '', result: 'unsafe_path' });
-      continue;
-    }
-
-    if (op === 'read') {
-      const src = ProjectStore.readFile(projectName, relPath);
-      emit({ type: 'tool', op: 'read', path: relPath, result: src !== null ? 'ok' : 'not_found' });
+      const { op, path: relPath, old: oldStr, new: newStr, content } = toolCall;
+      if (!relPath || !_isSafePath(relPath)) {
+        toolResults.push({ op, path: relPath, result: 'unsafe_path' });
+        emit({ type: 'tool', op, path: relPath ?? '', result: 'unsafe_path' });
+        continue;
+      }
 
-    } else if (op === 'edit') {
-      const src = ProjectStore.readFile(projectName, relPath);
-      if (src === null) {
-        emit({ type: 'tool', op: 'edit', path: relPath, result: 'file_not_found' });
-      } else if (!src.includes(oldStr)) {
-        // Fallback: try LLM-assisted repair
-        const repaired = await _attemptEditRepair(config, relPath, src, oldStr, newStr);
-        if (repaired) {
-          ProjectStore.writeFile(projectName, relPath, repaired);
+      if (op === 'read') {
+        const src = ProjectStore.readFile(projectName, relPath);
+        const result = src !== null ? 'ok' : 'not_found';
+        toolResults.push({ op: 'read', path: relPath, result, content: src?.slice(0, 12000) });
+        emit({ type: 'tool', op: 'read', path: relPath, result });
+
+      } else if (op === 'check') {
+        const src = ProjectStore.readFile(projectName, relPath);
+        let checkResult = 'ok';
+        if (!src) { checkResult = 'file_not_found'; }
+        else if (relPath.endsWith('.js') || relPath.endsWith('.mjs')) {
+          try { new Function(src); } catch (e) { checkResult = `syntax_error: ${e.message.replace(/\n.*/s, '')}`; }
+        } else if (relPath.endsWith('.json')) {
+          try { JSON.parse(src); } catch (e) { checkResult = `json_error: ${e.message}`; }
+        } else if (relPath.endsWith('.html')) {
+          checkResult = src.includes('</html>') ? 'ok' : 'missing_closing_html_tag';
+        }
+        toolResults.push({ op: 'check', path: relPath, result: checkResult });
+        emit({ type: 'tool', op: 'check', path: relPath, result: checkResult });
+
+      } else if (op === 'edit') {
+        const src = ProjectStore.readFile(projectName, relPath);
+        if (src === null) {
+          toolResults.push({ op: 'edit', path: relPath, result: 'file_not_found' });
+          emit({ type: 'tool', op: 'edit', path: relPath, result: 'file_not_found' });
+        } else if (!src.includes(oldStr)) {
+          const repaired = await _attemptEditRepair(config, relPath, src, oldStr, newStr);
+          if (repaired) {
+            ProjectStore.writeFile(projectName, relPath, repaired);
+            hasChanges = true;
+            modifiedFiles.add(relPath);
+            toolResults.push({ op: 'edit', path: relPath, result: 'ok_repaired' });
+            emit({ type: 'tool', op: 'edit', path: relPath, result: 'ok_repaired', oldSnippet: oldStr.slice(0, 300), newSnippet: newStr?.slice(0, 300) });
+          } else {
+            toolResults.push({ op: 'edit', path: relPath, result: 'old_not_found', hint: 'Use read to see current content, then retry with exact text' });
+            emit({ type: 'tool', op: 'edit', path: relPath, result: 'old_not_found', oldSnippet: oldStr.slice(0, 200) });
+          }
+        } else {
+          const newSrc = src.replace(oldStr, newStr ?? '');
+          ProjectStore.writeFile(projectName, relPath, newSrc);
           hasChanges = true;
-          emit({ type: 'tool', op: 'edit', path: relPath, result: 'ok_repaired', oldSnippet: oldStr.slice(0, 300), newSnippet: newStr.slice(0, 300) });
+          modifiedFiles.add(relPath);
+          toolResults.push({ op: 'edit', path: relPath, result: 'ok' });
+          emit({ type: 'tool', op: 'edit', path: relPath, result: 'ok', oldSnippet: oldStr.slice(0, 300), newSnippet: newStr?.slice(0, 300) ?? '' });
+        }
+
+      } else if (op === 'write') {
+        if (content === undefined) {
+          toolResults.push({ op: 'write', path: relPath, result: 'missing_content' });
+          emit({ type: 'tool', op: 'write', path: relPath, result: 'missing_content' });
         } else {
-          emit({ type: 'tool', op: 'edit', path: relPath, result: 'old_not_found', oldSnippet: oldStr.slice(0, 200) });
+          ProjectStore.writeFile(projectName, relPath, content);
+          hasChanges = true;
+          modifiedFiles.add(relPath);
+          toolResults.push({ op: 'write', path: relPath, result: 'ok' });
+          emit({ type: 'tool', op: 'write', path: relPath, result: 'ok' });
         }
-      } else {
-        const newSrc = src.replace(oldStr, newStr ?? '');
-        ProjectStore.writeFile(projectName, relPath, newSrc);
-        hasChanges = true;
-        emit({ type: 'tool', op: 'edit', path: relPath, result: 'ok', oldSnippet: oldStr.slice(0, 300), newSnippet: newStr?.slice(0, 300) ?? '' });
       }
+    }
+
+    // If agent said done or no tools were called, break
+    if (isDone || toolResults.length === 0) break;
+
+    // Build tool results feedback for next iteration
+    const feedbackParts = toolResults.map((r) => {
+      let msg = `[${r.op}] ${r.path || ''}: ${r.result}`;
+      if (r.op === 'read' && r.content) msg += `\n\`\`\`\n${r.content}\n\`\`\``;
+      if (r.hint) msg += ` — ${r.hint}`;
+      return msg;
+    });
+
+    // Add assistant response + tool results to conversation
+    conversationHistory.push({ role: 'assistant', content: stepResponse });
+    conversationHistory.push({ role: 'user', content: `TOOL RESULTS:\n${feedbackParts.join('\n\n')}\n\nContinue your work. When done, output <done/>` });
 
-    } else if (op === 'write') {
-      if (content === undefined) {
-        emit({ type: 'tool', op: 'write', path: relPath, result: 'missing_content' });
-      } else {
-        ProjectStore.writeFile(projectName, relPath, content);
-        hasChanges = true;
-        emit({ type: 'tool', op: 'write', path: relPath, result: 'ok' });
+    // Trim conversation to avoid context overflow (keep first user msg + last 4 exchanges)
+    if (conversationHistory.length > 10) {
+      conversationHistory = [conversationHistory[0], ...conversationHistory.slice(-6)];
+    }
+  }
+
+  // ── Post-edit: syntax check all modified JS files ──────────────────────────
+  const syntaxErrors = [];
+  for (const relPath of modifiedFiles) {
+    if (relPath.endsWith('.js') || relPath.endsWith('.mjs')) {
+      const src = ProjectStore.readFile(projectName, relPath);
+      if (src) {
+        try { new Function(src); } catch (e) {
+          syntaxErrors.push({ file: relPath, error: e.message.replace(/\n.*/s, '') });
+        }
       }
     }
   }
+  if (syntaxErrors.length > 0) {
+    emit({ type: 'syntax_errors', errors: syntaxErrors });
+  }
 
-  // Log chat interaction to changes.log.md
+  // Log chat interaction
   if (hasChanges) {
     try {
-      const ctxDir = SkillStore.dir(projectName);
-      const logFile = path.join(ctxDir, 'changes.log.md');
-      const timestamp = new Date().toISOString();
-      const logEntry = `\n## ${timestamp.slice(0, 16).replace('T', ' ')} — Chat modification\n- User: ${message.slice(0, 100)}${message.length > 100 ? '...' : ''}\n- Files modified: ${fullResponse.match(/<tool>[\s\S]*?"op":"(write|edit)"[\s\S]*?"path":"([^"]+)"[\s\S]*?<\/tool>/g)?.map(m => m.match(/"path":"([^"]+)"/)?.[1]).filter(Boolean).join(', ') || 'none'}\n`;
-      fs.writeFileSync(logFile, (fs.existsSync(logFile) ? fs.readFileSync(logFile, 'utf-8') : '') + logEntry, 'utf-8');
+      const logFile = path.join(SkillStore.dir(projectName), 'changes.log.md');
+      const ts = new Date().toISOString().slice(0, 16).replace('T', ' ');
+      const entry = `\n## ${ts} — Chat modification\n- User: ${message.slice(0, 100)}${message.length > 100 ? '...' : ''}\n- Files: ${[...modifiedFiles].join(', ')}\n`;
+      fs.writeFileSync(logFile, (fs.existsSync(logFile) ? fs.readFileSync(logFile, 'utf-8') : '') + entry, 'utf-8');
     } catch {}
   }
 
-  emit({ type: 'done', changed: hasChanges });
+  // Notify about modified files so frontend can reload them
+  emit({ type: 'files_changed', files: [...modifiedFiles] });
+  emit({ type: 'done', changed: hasChanges, syntaxErrors: syntaxErrors.length });
 }
 
 // ── Generation pipeline (SSE) ─────────────────────────────────────────────────
@@ -970,17 +1084,15 @@ Continue from here:`;
   };
   fs.writeFileSync(ProjectStore.metaPath(projectName), JSON.stringify(meta, null, 2), 'utf-8');
 
-  // Initialize skill context files
-  const ctxDir = ensureDir(SkillStore.dir(projectName));
-  const memFile = path.join(ctxDir, 'memory.md');
-  if (!fs.existsSync(memFile)) {
-    fs.writeFileSync(memFile, `# ${projectName} — Project Memory\n\n_Add architectural decisions, preferences, and notes here._\n`, 'utf-8');
-  }
+  // Initialize skill context files (memory.md, skills.md, provider.md)
+  SkillStore.ensureDefaults(projectName, config);
+  const ctxDir = SkillStore.dir(projectName);
 
-  // Generate skills.md with project context knowledge structure
+  // Generate detailed skills.md with project context knowledge structure (first time only)
   const skillsFile = path.join(ctxDir, 'skills.md');
-  if (!fs.existsSync(skillsFile)) {
-    const skillsContent = `# ${projectName} — Skills & Knowledge Structure
+  const skillsContent = fs.existsSync(skillsFile) ? fs.readFileSync(skillsFile, 'utf-8') : '';
+  if (skillsContent.length < 100) {
+    const detailedSkills = `# ${projectName} — Skills & Knowledge Structure
 
 ## Context Discovery Strategy
 
@@ -1018,36 +1130,11 @@ Agents score context relevance based on:
 
 This approach ensures agents have the right context without being overwhelmed by irrelevant information.
 `;
-    fs.writeFileSync(skillsFile, skillsContent, 'utf-8');
+    fs.writeFileSync(skillsFile, detailedSkills, 'utf-8');
   }
-  // Initialize provider-specific file (liara.md, claude.md, etc.)
+
   const provider = config.llm?.provider || 'nha';
   const model = config.llm?.model || '';
-  const providerFile = path.join(ctxDir, `${provider}.md`);
-  if (!fs.existsSync(providerFile)) {
-    const providerContent = `# ${provider.toUpperCase()} Model Configuration
-
-## Current Model: ${model || 'Default'}
-
-### Model Characteristics
-- **Provider**: ${provider}
-- **Model**: ${model || 'Default model for this provider'}
-- **Context Window**: Varies by model
-- **Strengths**: Add specific strengths of this model
-- **Limitations**: Add specific limitations to be aware of
-
-### Best Practices for This Model
-- Write specific coding patterns this model excels at
-- Note any formatting preferences
-- Document prompt engineering tips that work well
-
-### Configuration Notes
-- Add any specific configuration notes for this provider
-- Document any rate limits or special considerations
-`;
-    fs.writeFileSync(providerFile, providerContent, 'utf-8');
-  }
-
   const logFile = path.join(ctxDir, 'changes.log.md');
   const logEntry = `## ${new Date().toISOString().slice(0, 10)} — Initial generation\n- Generated ${generatedFiles.length} files\n- Tokens in: ${totalTokensIn} / out: ${totalTokensOut}\n- Description: ${description}\n- Provider: ${provider} (${model || 'default'})\n`;
   fs.writeFileSync(logFile, (fs.existsSync(logFile) ? fs.readFileSync(logFile, 'utf-8') : '') + logEntry, 'utf-8');
@@ -1160,6 +1247,8 @@ export function register(router) {
   // ── Skills get ────────────────────────────────────────────────────────────
   router.get(/^\/api\/studio\/webcraft\/skills\/(?<name>[^/?]+)(?:\?|$)/, (req, res) => {
     const projectName = decodeURIComponent(req.params.name ?? '');
+    // Always ensure defaults exist when loading skills
+    SkillStore.ensureDefaults(projectName, loadConfig());
     sendJSON(res, 200, { skills: SkillStore.list(projectName) });
   });