goiabaseeds 1.0.0

package/src/context.js

@@ -0,0 +1,142 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+/**
+ * Parse YAML frontmatter from a markdown file.
+ * Returns { frontmatter: string, body: string, meta: object }
+ */
+export function parseFrontmatter(content) {
+  const normalized = content.replace(/\r\n/g, '\n');
+  const match = normalized.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+  if (!match) return { frontmatter: '', body: normalized, meta: {} };
+
+  const frontmatter = match[1];
+  const body = match[2];
+
+  // Simple key-value extraction from frontmatter
+  const meta = {};
+  for (const line of frontmatter.split('\n')) {
+    const kv = line.match(/^(\w[\w_-]*):\s*(.+)$/);
+    if (kv) meta[kv[1]] = kv[2].trim();
+  }
+
+  // Parse skills list (YAML array)
+  const skillsMatch = frontmatter.match(/^skills:\s*\n((?:\s+-\s+.+\n?)+)/m);
+  if (skillsMatch) {
+    meta.skills = [];
+    for (const line of skillsMatch[1].split('\n')) {
+      const item = line.match(/^\s+-\s+(.+)/);
+      if (item) meta.skills.push(item[1].trim());
+    }
+  }
+
+  // Parse tasks list (YAML array)
+  const tasksMatch = frontmatter.match(/^tasks:\s*\n((?:\s+-\s+.+\n?)+)/m);
+  if (tasksMatch) {
+    meta.tasks = [];
+    for (const line of tasksMatch[1].split('\n')) {
+      const item = line.match(/^\s+-\s+(.+)/);
+      if (item) meta.tasks.push(item[1].trim());
+    }
+  }
+
+  return { frontmatter, body, meta };
+}
+
+/**
+ * Read a file safely, returning empty string if not found.
+ */
+async function safeRead(filePath) {
+  try {
+    return await readFile(filePath, 'utf-8');
+  } catch (err) {
+    if (err.code === 'ENOENT') return '';
+    throw err;
+  }
+}
+
+/**
+ * Compose the full system prompt for an agent step.
+ *
+ * Composition order (matches runner.pipeline.md lines 83-126):
+ * 1. Agent .agent.md full content
+ * 2. Agent row from department-party.csv
+ * 3. Format best-practices (if step has format: field)
+ * 4. Skill instructions (for each skill in agent frontmatter)
+ * 5. Company context
+ * 6. Department memory
+ *
+ * @param {object} options
+ * @param {string} options.agentPath - Absolute path to the agent .agent.md file
+ * @param {object} options.stepMeta - Parsed step frontmatter (step_id, agent, format, etc.)
+ * @param {string} options.departmentDir - Absolute path to the department directory
+ * @param {string} options.targetDir - Absolute path to the project root
+ * @returns {Promise<string>} Composed system prompt
+ */
+export async function composeAgentContext({ agentPath, stepMeta, departmentDir, targetDir }) {
+  const parts = [];
+
+  // 1. Agent .agent.md full content
+  const agentContent = await safeRead(agentPath);
+  if (agentContent) {
+    parts.push(agentContent);
+  }
+
+  // 2. Agent row from department-party.csv
+  const partyPath = join(departmentDir, 'department-party.csv');
+  const partyContent = await safeRead(partyPath);
+  if (partyContent && stepMeta.agent) {
+    const lines = partyContent.split('\n').filter(l => l.trim());
+    const agentRow = lines.find(line => {
+      const [id] = line.split(',');
+      return id?.trim() === stepMeta.agent;
+    });
+    if (agentRow) {
+      parts.push(`--- AGENT PERSONA (from department party) ---\n${agentRow}`);
+    }
+  }
+
+  // 3. Format best-practices
+  if (stepMeta.format) {
+    const formatPath = join(targetDir, '_goiabaseeds', 'core', 'best-practices', `${stepMeta.format}.md`);
+    const formatContent = await safeRead(formatPath);
+    if (formatContent) {
+      const { body } = parseFrontmatter(formatContent);
+      parts.push(`--- FORMAT: ${stepMeta.format} ---\n${body}`);
+    }
+  }
+
+  // 4. Skill instructions (from agent's frontmatter skills list)
+  const { meta: agentMeta } = parseFrontmatter(agentContent);
+  const skills = agentMeta.skills || [];
+  if (skills.length > 0) {
+    const skillParts = [];
+    for (const skillName of skills) {
+      const skillPath = join(targetDir, 'skills', skillName, 'SKILL.md');
+      const skillContent = await safeRead(skillPath);
+      if (skillContent) {
+        const { body } = parseFrontmatter(skillContent);
+        skillParts.push(`## ${skillName}\n${body}`);
+      }
+    }
+    if (skillParts.length > 0) {
+      parts.push(`--- SKILL INSTRUCTIONS ---\n${skillParts.join('\n\n')}`);
+    }
+  }
+
+  // 5. Company context
+  const companyPath = join(targetDir, '_goiabaseeds', '_memory', 'company.md');
+  const companyContent = await safeRead(companyPath);
+  if (companyContent) {
+    parts.push(`--- COMPANY CONTEXT ---\n${companyContent}`);
+  }
+
+  // 6. Department memory
+  const memoryPath = join(departmentDir, '_memory', 'memories.md');
+  const memoryContent = await safeRead(memoryPath);
+  if (memoryContent) {
+    parts.push(`--- DEPARTMENT MEMORY ---\n${memoryContent}`);
+  }
+
+  return parts.join('\n\n');
+}

package/src/export.js

@@ -0,0 +1,52 @@
+import { bundleDepartment } from './bundle.js';
+
+/**
+ * Export a department as a standalone bundle
+ * @param {string[]} args - Command arguments [departmentName, --format, format, --output, path, etc.]
+ * @param {string} projectDir - Project root directory
+ * @returns {Object} Result with success status
+ */
+export async function exportDepartment(args, projectDir) {
+  if (!args || args.length === 0) {
+    console.log(`
+  Usage: npx goiabaseeds export <department> [options]
+
+  Options:
+    --format [bundle|zip]   Output format (default: bundle)
+    --output <path>         Custom output directory
+    --zip                   Create ZIP file (shorthand)
+
+  Examples:
+    npx goiabaseeds export my-carousel
+    npx goiabaseeds export my-carousel --format zip
+    npx goiabaseeds export my-carousel --output ~/exports
+    `);
+    return { success: false };
+  }
+
+  const departmentName = args[0];
+  let options = { output: undefined, zip: false };
+
+  // Parse options
+  for (let i = 1; i < args.length; i++) {
+    if (args[i] === '--format' && i + 1 < args.length) {
+      if (args[i + 1] === 'zip') options.zip = true;
+      i++;
+    } else if (args[i] === '--zip') {
+      options.zip = true;
+    } else if (args[i] === '--output' && i + 1 < args.length) {
+      options.output = args[i + 1];
+      i++;
+    }
+  }
+
+  // Bundle the department
+  const result = await bundleDepartment(departmentName, projectDir, options);
+
+  if (!result.success) {
+    console.error(`❌ Export failed: ${result.error}`);
+    return { success: false };
+  }
+
+  return { success: true };
+}

package/src/i18n.js

@@ -0,0 +1,48 @@
+import { readFile } from 'node:fs/promises';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const LOCALES_DIR = join(__dirname, 'locales');
+
+const LANG_MAP = {
+  'Português (Brasil)': 'pt-BR',
+  'English': 'en',
+  'Español': 'es',
+};
+
+let strings = {};
+let fallback = {};
+let currentCode = 'en';
+
+export async function loadLocale(langLabel) {
+  const code = LANG_MAP[langLabel] || 'en';
+  currentCode = code;
+
+  const enPath = join(LOCALES_DIR, 'en.json');
+  fallback = JSON.parse(await readFile(enPath, 'utf-8'));
+
+  if (code === 'en') {
+    strings = fallback;
+    return;
+  }
+
+  try {
+    const localePath = join(LOCALES_DIR, `${code}.json`);
+    strings = JSON.parse(await readFile(localePath, 'utf-8'));
+  } catch {
+    strings = fallback;
+  }
+}
+
+export function getLocaleCode() {
+  return currentCode;
+}
+
+export function t(key, vars = {}) {
+  let str = strings[key] ?? fallback[key] ?? key;
+  for (const [k, v] of Object.entries(vars)) {
+    str = str.replaceAll(`{${k}}`, v);
+  }
+  return str;
+}

package/src/init.js

@@ -0,0 +1,367 @@
+import { cp, mkdir, readdir, readFile, writeFile, stat } from 'node:fs/promises';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { execSync, spawn } from 'node:child_process';
+import { userInfo, platform } from 'node:os';
+import { createPrompt } from './prompt.js';
+import { loadLocale, t } from './i18n.js';
+import { listAvailable, installSkill } from './skills.js';
+import { logEvent } from './logger.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const TEMPLATES_DIR = join(__dirname, '..', 'templates');
+
+const LANGUAGES = [
+  { label: 'Português (Brasil)', value: 'Português (Brasil)' },
+  { label: 'English', value: 'English' },
+  { label: 'Español', value: 'Español' },
+];
+
+const IDES = [
+  { label: 'Standalone (recommended)', value: 'standalone', checked: true },
+  { label: 'Antigravity', value: 'antigravity' },
+  { label: 'Claude Code', value: 'claude-code' },
+  { label: 'Codex (OpenAI)', value: 'codex' },
+  { label: 'Cursor', value: 'cursor' },
+  { label: 'OpenCode', value: 'opencode' },
+  { label: 'VS Code + Copilot', value: 'vscode-copilot' },
+];
+
+const PROVIDERS = [
+  { label: 'Anthropic (Claude)', value: 'anthropic' },
+  { label: 'OpenAI (GPT)', value: 'openai' },
+  { label: 'Google (Gemini)', value: 'google' },
+  { label: 'GitHub Copilot', value: 'github-copilot' },
+];
+
+const PROVIDER_ENV_KEYS = {
+  anthropic: 'ANTHROPIC_API_KEY',
+  openai: 'OPENAI_API_KEY',
+  google: 'GOOGLE_GENERATIVE_AI_API_KEY',
+  'github-copilot': 'GITHUB_TOKEN',
+};
+
+export async function init(targetDir, options = {}) {
+
+  // Check if already initialized
+  let isReInit = false;
+  try {
+    await stat(join(targetDir, '_goiabaseeds'));
+    isReInit = true;
+  } catch {
+    // Not initialized yet — continue
+  }
+
+  console.log(isReInit ? '\n  🔄 GoiabaSeeds — Re-configure\n' : '\n  🟢 GoiabaSeeds — Setup\n');
+
+  // Guided installation (skip in test mode)
+  let language = options._language || 'English';
+  let ides = options._ides ?? ['claude-code'];
+  let userName = '';
+
+  if (options._quick) {
+    // Quick mode: no prompts, smart defaults
+    userName = userInfo().username;
+    await loadLocale(language);
+  } else if (!options._skipPrompts) {
+    const prompt = createPrompt();
+
+    try {
+      // Language is asked FIRST (in English, before locale is loaded)
+      const langChoice = await prompt.choose('What language do you prefer for outputs?', LANGUAGES);
+      language = langChoice.value;
+
+      // Load locale — all messages from here are translated
+      await loadLocale(language);
+
+      console.log(`\n  ${t('welcome')}\n`);
+
+      userName = (await prompt.ask(`  ${t('askName')}`)).trim();
+
+      ides = await prompt.multiChoose(t('chooseIdes'), IDES);
+    } finally {
+      prompt.close();
+    }
+  } else {
+    await loadLocale(language);
+  }
+
+  // Copy template files
+  await copyCommonTemplates(targetDir);
+
+  // Filter 'standalone' from IDE templates (no IDE-specific dir) and copy IDE templates
+  const ideTemplates = ides.filter(ide => ide !== 'standalone');
+  await copyIdeTemplates(ideTemplates, targetDir);
+  await installAllSkills(targetDir);
+  if (!options._skipPrompts && !options._skipDeps) {
+    await installDependencies(targetDir);
+  }
+  await writeProjectReadme(targetDir);
+
+  // Standalone mode setup — generate provider config
+  if (ides.includes('standalone')) {
+    await setupStandaloneConfig(targetDir, options);
+  }
+
+  // Write user preferences
+  const prefsPath = join(targetDir, '_goiabaseeds', '_memory', 'preferences.md');
+  await mkdir(dirname(prefsPath), { recursive: true });
+  const prefsContent = `# GoiabaSeeds Preferences
+
+- **User Name:** ${userName}
+- **Output Language:** ${language}
+- **IDEs:** ${ides.join(', ')}
+- **Date Format:** YYYY-MM-DD
+`;
+  await writeFile(prefsPath, prefsContent, 'utf-8');
+
+  await logEvent('init', { language, ides: ides.join(',') }, targetDir);
+
+  console.log(`\n  ${t('success')}\n`);
+  console.log(`  ${t('nextSteps')}`);
+  for (const ide of ides) {
+    if (ide === 'standalone') {
+      const providerName = options._provider || 'anthropic';
+      const envKey = PROVIDER_ENV_KEYS[providerName] || 'ANTHROPIC_API_KEY';
+      console.log(`  1. Set your API key: export ${envKey}=your-key-here`);
+      console.log(`  2. Test connectivity: npx goiabaseeds models test`);
+      console.log(`  3. Run a department:  npx goiabaseeds run <department-name>\n`);
+    } else if (ide === 'claude-code') {
+      console.log(`  ${t('step1ClaudeCode')}`);
+      console.log(`  ${t('step2ClaudeCode')}`);
+      console.log(`  ${t('step3ClaudeCode')}\n`);
+    } else if (ide === 'codex') {
+      console.log(`  ${t('step1Codex')}\n`);
+    } else if (ide === 'antigravity') {
+      console.log(`  ${t('step1Antigravity')}\n`);
+    } else if (ide === 'cursor') {
+      console.log(`  ${t('step1Cursor')}\n`);
+    } else if (ide === 'opencode') {
+      console.log(`  ${t('step1Opencode')}\n`);
+    } else if (ide === 'vscode-copilot') {
+      console.log(`  ${t('step1VsCodeCopilot')}`);
+      console.log(`  ${t('step2VsCodeCopilot')}`);
+      console.log(`  ${t('step3VsCodeCopilot')}\n`);
+    }
+  }
+
+  // Quick mode: auto-start dashboard and open browser
+  if (options._quick && !options._skipDashboardStart) {
+    startDashboard(targetDir);
+    setTimeout(() => openBrowser('http://localhost:5173'), 3000);
+  }
+}
+
+export async function loadSavedLocale(targetDir) {
+  try {
+    const prefsPath = join(targetDir, '_goiabaseeds', '_memory', 'preferences.md');
+    const content = await readFile(prefsPath, 'utf-8');
+    const match = content.match(/\*\*Output Language:\*\*\s*(.+)/);
+    if (match) {
+      await loadLocale(match[1].trim());
+      return;
+    }
+  } catch {
+    // No preferences file yet
+  }
+  await loadLocale('English');
+}
+
+async function setupStandaloneConfig(targetDir, options) {
+  let providerName = options._provider || 'anthropic';
+
+  // If not skipping prompts, ask for provider
+  if (!options._skipPrompts && !options._quick) {
+    const prompt = createPrompt();
+    try {
+      const choice = await prompt.choose('Which AI provider do you want to use?', PROVIDERS);
+      providerName = choice.value;
+    } finally {
+      prompt.close();
+    }
+  }
+
+  // Store the chosen provider in options for next-steps display
+  options._provider = providerName;
+
+  const configContent = `# GoiabaSeeds Standalone Configuration
+runtime: standalone
+default_provider: ${providerName}
+
+providers:
+  anthropic:
+    models:
+      powerful: claude-sonnet-4-20250514
+      fast: claude-haiku-4-5-20251001
+  openai:
+    models:
+      powerful: gpt-4o
+      fast: gpt-4o-mini
+  google:
+    models:
+      powerful: gemini-2.5-pro
+      fast: gemini-2.0-flash
+  github-copilot:
+    models:
+      powerful: gpt-4o
+      fast: gpt-4o-mini
+`;
+
+  const configPath = join(targetDir, '_goiabaseeds', 'config.yaml');
+  await mkdir(dirname(configPath), { recursive: true });
+  await writeFile(configPath, configContent, 'utf-8');
+  console.log(`  ${t('createdFile', { path: '_goiabaseeds/config.yaml' })}`);
+}
+
+async function installAllSkills(targetDir) {
+  const available = await listAvailable();
+  for (const id of available) {
+    await installSkill(id, targetDir);
+    console.log(`  ${t('createdFile', { path: `skills/${id}/SKILL.md` })}`);
+  }
+}
+
+async function installDependencies(targetDir) {
+  console.log(`\n  Installing dependencies...`);
+  execSync('npm install', { cwd: targetDir, stdio: 'inherit' });
+  console.log(`\n  Installing dashboard dependencies...`);
+  execSync('npm install', { cwd: join(targetDir, 'dashboard'), stdio: 'inherit' });
+  console.log(`\n  Installing Playwright browsers...`);
+  execSync('npx playwright install chromium', { cwd: targetDir, stdio: 'inherit' });
+}
+
+async function writeProjectReadme(targetDir) {
+  const readmePath = join(__dirname, 'readme', 'README.md');
+  const content = await readFile(readmePath, 'utf-8');
+  await writeFile(join(targetDir, 'README.md'), content, 'utf-8');
+}
+
+async function copyCommonTemplates(targetDir) {
+  const entries = await getTemplateEntries(TEMPLATES_DIR);
+
+  for (const entry of entries) {
+    // Skip anything inside ide-templates/ — handled by copyIdeTemplates
+    if (entry.replace(/\\/g, '/').includes('/ide-templates/')) continue;
+
+    const relativePath = entry.slice(TEMPLATES_DIR.length + 1);
+    const destPath = join(targetDir, relativePath);
+    const destDir = dirname(destPath);
+    await mkdir(destDir, { recursive: true });
+    try {
+      await stat(destPath);
+      continue; // file already exists — skip
+    } catch {
+      // does not exist — copy it
+    }
+    await cp(entry, destPath);
+    console.log(`  ${t('createdFile', { path: relativePath })}`);
+  }
+}
+
+async function copyIdeTemplates(ides, targetDir) {
+  const ideTemplatesDir = join(TEMPLATES_DIR, 'ide-templates');
+  const writtenPaths = new Set();
+
+  for (const ide of ides) {
+    const ideSrcDir = join(ideTemplatesDir, ide);
+    let entries;
+    try {
+      entries = await getTemplateEntries(ideSrcDir);
+    } catch {
+      continue; // no template dir for this IDE yet
+    }
+
+    for (const entry of entries) {
+      const relativePath = entry.slice(ideSrcDir.length + 1);
+      // settings.json for vscode-copilot is handled by mergeVsCodeSettings — skip here
+      if (ide === 'vscode-copilot' && relativePath.replace(/\\/g, '/') === '.vscode/settings.json') continue;
+      if (writtenPaths.has(relativePath)) continue;
+      writtenPaths.add(relativePath);
+
+      const destPath = join(targetDir, relativePath);
+      const destDir = dirname(destPath);
+      await mkdir(destDir, { recursive: true });
+      await cp(entry, destPath);
+      console.log(`  ${t('createdFile', { path: relativePath })}`);
+    }
+  }
+
+  if (ides.includes('vscode-copilot')) {
+    await mergeVsCodeSettings(targetDir);
+  }
+}
+
+async function mergeVsCodeSettings(targetDir) {
+  const settingsPath = join(targetDir, '.vscode', 'settings.json');
+
+  let exists = false;
+  try {
+    await stat(settingsPath);
+    exists = true;
+  } catch {
+    // doesn't exist
+  }
+
+  if (!exists) {
+    const templateBase = join(TEMPLATES_DIR, 'ide-templates', 'vscode-copilot', '.vscode', 'settings.json');
+    await mkdir(join(targetDir, '.vscode'), { recursive: true });
+    await cp(templateBase, settingsPath);
+    return;
+  }
+
+  const raw = await readFile(settingsPath, 'utf-8');
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    console.log(`  ⚠️  .vscode/settings.json has invalid JSON — skipping merge. Add manually: "chat.promptFilesLocations": [".github/prompts"]`);
+    return;
+  }
+
+  if (!parsed['chat.promptFilesLocations']) {
+    parsed['chat.promptFilesLocations'] = ['.github/prompts'];
+  } else if (!parsed['chat.promptFilesLocations'].includes('.github/prompts')) {
+    parsed['chat.promptFilesLocations'].push('.github/prompts');
+  }
+
+  await writeFile(settingsPath, JSON.stringify(parsed, null, 2), 'utf-8');
+}
+
+function startDashboard(targetDir) {
+  const dashboardDir = join(targetDir, 'dashboard');
+  const child = spawn('npm', ['run', 'dev'], {
+    cwd: dashboardDir,
+    stdio: 'ignore',
+    detached: true,
+    shell: true,
+  });
+  child.unref();
+  console.log('\n  🖥️  Dashboard starting at http://localhost:5173\n');
+}
+
+function openBrowser(url) {
+  const os = platform();
+  try {
+    if (os === 'darwin') execSync(`open ${url}`);
+    else if (os === 'win32') execSync(`start ${url}`, { shell: true });
+    else execSync(`xdg-open ${url}`);
+  } catch {
+    // Browser open failed — not critical
+  }
+}
+
+export async function getTemplateEntries(dir) {
+  const results = [];
+  const entries = await readdir(dir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...await getTemplateEntries(fullPath));
+    } else {
+      results.push(fullPath);
+    }
+  }
+
+  return results;
+}

package/src/locales/en.json

@@ -0,0 +1,72 @@
+{
+  "welcome": "Welcome! Let's set up GoiabaSeeds for your project.",
+  "askName": "What's your name? → ",
+  "atLeastOneIde": "Please select at least one IDE.",
+  "chooseIdes": "Which IDEs/tools do you use? (select all that apply)",
+  "step1Codex": "1. See AGENTS.md in your project root for Codex instructions",
+  "step1Antigravity": "1. Open Antigravity, type / in the chat and select goiabaseeds to get started.",
+  "step1Cursor": "1. Open Cursor, type / in the chat and select goiabaseeds to get started.",
+  "step1Opencode": "1. Open OpenCode and type /goiabaseeds to get started.",
+  "ideNotAvailable": "⚠️  \"{label}\" is not available yet. Choose another option.",
+  "enterNumber": "Please enter a number between 1 and {max}.",
+  "alreadyInitialized": "⚠️  GoiabaSeeds is already initialized in this directory.",
+  "alreadyInitializedHint": "Use Claude Code and type /goiabaseeds to get started.",
+  "createdFile": "📄 Created {path}",
+  "success": "✅ GoiabaSeeds initialized successfully!",
+  "nextSteps": "Next steps:",
+  "step1ClaudeCode": "1. Open this directory in Claude Code",
+  "step2ClaudeCode": "2. Type /goiabaseeds to start the onboarding wizard",
+  "step3ClaudeCode": "3. Follow the prompts to set up your company profile",
+  "comingSoon": "coming soon",
+  "_test_fallback_only": "English fallback works",
+  "updateNotInitialized": "No GoiabaSeeds installation found. Run 'init' first.",
+  "updateStarting": "Updating GoiabaSeeds {old} → {new}...",
+  "updateStartingUnknown": "Updating GoiabaSeeds (unknown version) → {new}...",
+  "updatedFile": "📄 Updated {path}",
+  "updateSuccess": "✅ GoiabaSeeds {version} installed successfully!",
+  "updatePreserved": "✓ Preserved: _memory/, _investigations/, departments/",
+  "updateFileCount": "✓ Updated: {count} system files",
+  "updateLatestHint": "💡 Tip: Use 'npx goiabaseeds@latest update' to always get the newest version.",
+  "skillsNotInitialized": "No GoiabaSeeds installation found. Run 'init' first.",
+  "skillsFetching": "Fetching skills registry...",
+  "skillsInstalledHeader": "Installed:",
+  "skillsAvailableHeader": "Available:",
+  "skillsNoneInstalled": "No skills installed yet.",
+  "skillsNoneAvailable": "No skills available in registry.",
+  "skillsInstallHint": "Install with: npx goiabaseeds install <id>",
+  "skillsInstalling": "Installing {id}...",
+  "skillsInstalled": "✅ Installed: {id}",
+  "skillsAlreadyInstalled": "⚠️  {id} is already installed. Reinstall? (y/n) ",
+  "skillsReinstalled": "✅ Reinstalled: {id}",
+  "skillsRemoving": "Removing {id}...",
+  "skillsRemoved": "✅ Removed: {id}",
+  "skillsNotInstalled": "⚠️  {id} is not installed.",
+  "skillsUpdating": "Updating all installed skills...",
+  "skillsUpdateDone": "✅ Updated {count} skill(s).",
+  "skillsUpdateNone": "No skills installed to update.",
+  "skillsError": "❌ Error: {message}",
+  "skillsUnknownCommand": "Unknown skills command: {cmd}\n  Usage: goiabaseeds skills list|install|remove|update",
+  "chooseSkills": "Which skills do you want to install? (optional)",
+  "skillsEnvWarning": "   Requires: {vars}",
+  "skillsSkipped": "You can install skills later with: npx goiabaseeds install <name>",
+  "skillsInstalledCount": "Installed {count} skill(s).",
+  "agentsNotInitialized": "No GoiabaSeeds installation found. Run 'init' first.",
+  "agentsInstalledHeader": "Installed:",
+  "agentsNoneInstalled": "No agents installed yet.",
+  "agentsInstallHint": "Install with: npx goiabaseeds agents install <id>",
+  "agentsInstalling": "Installing {id}...",
+  "agentsInstalled": "✅ Installed: {id}",
+  "agentsAlreadyInstalled": "⚠️  {id} is already installed. Reinstall? (y/n) ",
+  "agentsReinstalled": "✅ Reinstalled: {id}",
+  "agentsRemoving": "Removing {id}...",
+  "agentsRemoved": "✅ Removed: {id}",
+  "agentsNotInstalled": "⚠️  {id} is not installed.",
+  "agentsUpdating": "Updating all installed agents...",
+  "agentsUpdateDone": "✅ Updated {count} agent(s).",
+  "agentsUpdateNone": "No agents installed to update.",
+  "agentsError": "❌ Error: {message}",
+  "agentsUnknownCommand": "Unknown agents command: {cmd}\n  Usage: goiabaseeds agents list|install|remove|update",
+  "step1VsCodeCopilot": "1. Open this directory in VS Code",
+  "step2VsCodeCopilot": "2. Open Copilot Chat (Ctrl+Alt+I)",
+  "step3VsCodeCopilot": "3. Type /goiabaseeds to get started"
+}