trackfw 1.0.4 → 1.1.0

package/README.md

@@ -79,12 +79,14 @@ brew install kgsaran/tap/trackfw
 go install github.com/kgsaran/trackfw/cmd/trackfw@latest
 ```
 
-### npm
+### npm (pure Node.js — no binary)
 
 ```bash
 npm install -g trackfw
 ```
 
+The npm package is pure Node.js — no compiled binary, no postinstall download. Works everywhere Node.js ≥ 18 is installed, including corporate Windows environments where unsigned `.exe` files are blocked by antivirus.
+
 ### pip
 
 ```bash
@@ -127,18 +129,25 @@ trackfw status
 | `trackfw req new "title"` | Create a REQ with guided ADR discovery |
 | `trackfw req list` | List all REQs with status |
 | `trackfw roadmap new "title"` | Create a roadmap in `backlog/` |
+| `trackfw roadmap show <name>` | Print a roadmap with its current state |
 | `trackfw roadmap move <name> <state>` | Move roadmap between states |
 | `trackfw roadmap list` | List all roadmaps grouped by state |
 | `trackfw validate` | Check governance consistency (use as CI gate) |
 | `trackfw status` | Show wip, blocked, REQs waiting on ADRs |
-| `trackfw agents` | Install Claude Code subagents |
-| `trackfw gemini` | Install Gemini CLI skills and commands |
-| `trackfw cursor` | Install Cursor rules |
-| `trackfw copilot` | Install GitHub Copilot instructions |
-| `trackfw windsurf` | Install Windsurf rules and workflows |
-| `trackfw amazonq` | Install Amazon Q Developer rules |
+| `trackfw log [--tail N]` | Show roadmap state transition history |
+| `trackfw plugins list` | List installed plugins |
+| `trackfw plugins add <user/repo>` | Install a plugin from GitHub Releases |
+| `trackfw plugins remove <name>` | Remove an installed plugin |
+| `trackfw agents` | Install Claude Code subagents *(Go binary only)* |
+| `trackfw gemini` | Install Gemini CLI skills and commands *(Go binary only)* |
+| `trackfw cursor` | Install Cursor rules *(Go binary only)* |
+| `trackfw copilot` | Install GitHub Copilot instructions *(Go binary only)* |
+| `trackfw windsurf` | Install Windsurf rules and workflows *(Go binary only)* |
+| `trackfw amazonq` | Install Amazon Q Developer rules *(Go binary only)* |
 | `trackfw version` | Print version |
 
+> **Go binary only** commands (`agents`, `gemini`, `cursor`, `copilot`, `windsurf`, `amazonq`) are available when installed via brew, `install.sh`, or `go install`. When using the npm package, AI integrations are installed through `trackfw init`.
+
 ---
 
 ## Governance chain
@@ -227,7 +236,7 @@ $ trackfw status
 
 ## AI assistant integration
 
-`trackfw init` asks which AI tools your team uses and installs native governance context for each. Commands can also be run independently.
+`trackfw init` asks which AI tools your team uses and installs native governance context for each. When using the Go binary (brew, `install.sh`, `go install`), each integration can also be run as a standalone command.
 
 | Command | Installs | Format |
 |---|---|---|

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trackfw",
-  "version": "1.0.4",
+  "version": "1.1.0",
   "description": "Governed software delivery framework: ADR → REQ → ROADMAP → kanban",
   "keywords": [
     "cli",

package/src/commands/adr.js

@@ -3,26 +3,27 @@
 const { Command } = require('commander')
 const { input } = require('@inquirer/prompts')
 const generators = require('../generators/adr')
+const { t } = require('../i18n')
 
 const cmd = new Command('adr')
-cmd.description('Manage Architecture Decision Records')
+cmd.description(t('adr.description'))
 
 cmd.command('new <title>')
-  .description('Create a new ADR')
+  .description(t('adr.new.description'))
   .action(async (title) => {
     const content = { title }
     // wizard interativo se TTY
     if (process.stdin.isTTY) {
-      content.context = await input({ message: 'Context (what motivates this decision)?', default: '' })
-      content.decision = await input({ message: 'Decision (what was decided)?', default: '' })
-      content.consequences = await input({ message: 'Consequences (positive and negative)?', default: '' })
-      content.alternatives = await input({ message: 'Alternatives considered?', default: '' })
+      content.context = await input({ message: t('adr.new.prompt.context'), default: '' })
+      content.decision = await input({ message: t('adr.new.prompt.decision'), default: '' })
+      content.consequences = await input({ message: t('adr.new.prompt.consequences'), default: '' })
+      content.alternatives = await input({ message: t('adr.new.prompt.alternatives'), default: '' })
     }
     await generators.newADR(content)
   })
 
 cmd.command('list')
-  .description('List all ADRs in docs/adr/')
+  .description(t('adr.list.description'))
   .action(async () => {
     await generators.listADRs('docs/adr')
   })

package/src/commands/init.js

@@ -1,8 +1,9 @@
 'use strict'
 const { Command } = require('commander')
+const { t } = require('../i18n')
 
 const cmd = new Command('init')
-cmd.description('Initialize trackfw governance in the current project')
+cmd.description(t('init.description'))
 cmd.action(async () => {
   const path = require('path')
   const generators = require('../generators/init')
@@ -19,27 +20,27 @@ cmd.action(async () => {
       ci: 'none',
     }
     await generators.scaffold(cfg)
-    console.log("\n✓ trackfw initialized — run 'trackfw status' to see your governance state.")
+    console.log(`\n${t('init.success')}`)
     return
   }
 
   const { input, select, checkbox } = require('@inquirer/prompts')
 
-  let projectName, projectType, frontend, pkgManager, backend, hooks, ci, aiTools
+  let projectName, projectType, frontend, pkgManager, backend, backendFramework, hooks, ci, aiTools
 
   try {
     projectName = await input({
-      message: 'Project name?',
+      message: t('init.prompt.projectName'),
       default: path.basename(process.cwd()),
     })
 
     projectType = await select({
-      message: 'Project type?',
+      message: t('init.prompt.projectType'),
       choices: [
-        { name: 'Full-stack (frontend + backend)', value: 'fullstack' },
-        { name: 'Frontend only', value: 'frontend' },
-        { name: 'Backend only', value: 'backend' },
-        { name: 'Governance only (no build stack)', value: 'governance' },
+        { name: t('init.prompt.projectType_fullstack'), value: 'fullstack' },
+        { name: t('init.prompt.projectType_frontend'), value: 'frontend' },
+        { name: t('init.prompt.projectType_backend'), value: 'backend' },
+        { name: t('init.prompt.projectType_governance'), value: 'governance' },
       ],
     })
 
@@ -47,7 +48,7 @@ cmd.action(async () => {
     pkgManager = ''
     if (projectType === 'fullstack' || projectType === 'frontend') {
       frontend = await select({
-        message: 'Frontend stack?',
+        message: t('init.prompt.frontendStack'),
         choices: [
           { name: 'React / Next.js', value: 'react' },
           { name: 'Vue', value: 'vue' },
@@ -55,7 +56,7 @@ cmd.action(async () => {
         ],
       })
       pkgManager = await select({
-        message: 'Package manager?',
+        message: t('init.prompt.pkgManager'),
         choices: [
           { name: 'npm', value: 'npm' },
           { name: 'pnpm', value: 'pnpm' },
@@ -66,20 +67,50 @@ cmd.action(async () => {
     }
 
     backend = ''
+    let backendFramework = ''
     if (projectType === 'fullstack' || projectType === 'backend') {
       backend = await select({
-        message: 'Backend stack?',
+        message: t('init.prompt.backendLang'),
         choices: [
           { name: 'Go', value: 'go' },
-          { name: 'Java / Spring Boot', value: 'java' },
+          { name: 'Java', value: 'java' },
           { name: 'Node.js', value: 'node' },
           { name: 'Python', value: 'python' },
         ],
       })
+
+      const frameworkChoices = {
+        go: [
+          { name: 'Gin', value: 'gin' },
+          { name: 'Echo', value: 'echo' },
+          { name: 'Fiber', value: 'fiber' },
+          { name: 'Standard library (net/http)', value: 'stdlib' },
+        ],
+        java: [
+          { name: 'Spring Boot', value: 'spring-boot' },
+          { name: 'Quarkus', value: 'quarkus' },
+          { name: 'Micronaut', value: 'micronaut' },
+        ],
+        node: [
+          { name: 'Express', value: 'express' },
+          { name: 'Fastify', value: 'fastify' },
+          { name: 'NestJS', value: 'nestjs' },
+          { name: 'Koa', value: 'koa' },
+        ],
+        python: [
+          { name: 'FastAPI', value: 'fastapi' },
+          { name: 'Django', value: 'django' },
+          { name: 'Flask', value: 'flask' },
+        ],
+      }
+      backendFramework = await select({
+        message: t('init.prompt.backendFramework'),
+        choices: frameworkChoices[backend] || [],
+      })
     }
 
     hooks = await select({
-      message: 'Git hooks?',
+      message: t('init.prompt.gitHooks'),
       choices: [
         { name: 'husky', value: 'husky' },
         { name: 'lefthook', value: 'lefthook' },
@@ -88,7 +119,7 @@ cmd.action(async () => {
     })
 
     ci = await select({
-      message: 'CI system?',
+      message: t('init.prompt.ci'),
       choices: [
         { name: 'GitHub Actions', value: 'github-actions' },
         { name: 'GitLab CI', value: 'gitlab-ci' },
@@ -97,7 +128,7 @@ cmd.action(async () => {
     })
 
     aiTools = await checkbox({
-      message: 'Which AI assistants do you use?',
+      message: t('init.prompt.aiTools'),
       choices: [
         { name: 'Claude Code', value: 'claude' },
         { name: 'Gemini CLI', value: 'gemini' },
@@ -119,11 +150,11 @@ cmd.action(async () => {
       ci: 'none',
     }
     await generators.scaffold(cfg)
-    console.log("\n✓ trackfw initialized — run 'trackfw status' to see your governance state.")
+    console.log(`\n${t('init.success')}`)
     return
   }
 
-  const cfg = { projectName, projectType, frontend, backend, pkgManager, hooks, ci }
+  const cfg = { projectName, projectType, frontend, backend, backendFramework, pkgManager, hooks, ci }
   await generators.scaffold(cfg)
 
   for (const tool of (aiTools || [])) {
@@ -137,7 +168,7 @@ cmd.action(async () => {
     }
   }
 
-  console.log("\n✓ trackfw initialized — run 'trackfw status' to see your governance state.")
+  console.log(`\n${t('init.success')}`)
 })
 
 module.exports = cmd

package/src/commands/log.js

@@ -2,16 +2,17 @@
 const { Command } = require('commander')
 const fs = require('fs')
 const path = require('path')
+const { t } = require('../i18n')
 
 const cmd = new Command('log')
-cmd.description('Show roadmap state transition history')
-cmd.option('--tail <n>', 'Number of recent transitions to show', '20')
+cmd.description(t('log.description'))
+cmd.option('--tail <n>', t('log.tail'), '20')
 cmd.action(async (opts) => {
   const tail = parseInt(opts.tail, 10)
   const logPath = path.join('docs', 'roadmaps', '.trackfw-log')
 
   if (!fs.existsSync(logPath)) {
-    console.log('No transitions recorded yet.')
+    console.log(t('log.empty'))
     return
   }
 
@@ -22,7 +23,7 @@ cmd.action(async (opts) => {
   const start = Math.max(0, lines.length - tail)
   const visible = lines.slice(start)
 
-  console.log('── trackfw log ─────────────────────────')
+  console.log(t('log.header'))
   visible.forEach(l => console.log(l))
 })
 

package/src/commands/plugins.js

@@ -3,6 +3,7 @@ const { Command } = require('commander')
 const os = require('os')
 const path = require('path')
 const fs = require('fs')
+const { t } = require('../i18n')
 
 function pluginsDir() {
   return path.join(os.homedir(), '.trackfw', 'plugins')
@@ -40,7 +41,7 @@ async function installPlugin(repo) {
     : `https://github.com/${base}/releases/download/${tag}/${assetName}`
 
   const res = await fetch(url)
-  if (!res.ok) throw new Error(`download failed: HTTP ${res.status} for ${url}`)
+  if (!res.ok) throw new Error(t('errors.downloadFailed', { status: res.status, url }))
 
   const dir = pluginsDir()
   fs.mkdirSync(dir, { recursive: true })
@@ -49,32 +50,32 @@ async function installPlugin(repo) {
 
 function removePlugin(name) {
   const filePath = path.join(pluginsDir(), name)
-  if (!fs.existsSync(filePath)) throw new Error(`plugin "${name}" not found`)
+  if (!fs.existsSync(filePath)) throw new Error(t('errors.pluginNotFound', { name }))
   fs.unlinkSync(filePath)
 }
 
 const cmd = new Command('plugins')
-cmd.description('Manage trackfw plugins')
+cmd.description(t('plugins.description'))
 
 cmd.command('list')
-  .description('List installed plugins')
+  .description(t('plugins.list.description'))
   .action(() => {
     const plugins = listPlugins()
     if (plugins.length === 0) {
-      console.log('No plugins installed. Use `trackfw plugins add <user/repo>` to install one.')
+      console.log(t('plugins.list.empty'))
       return
     }
     plugins.forEach(p => console.log(p))
   })
 
 cmd.command('add <repo>')
-  .description('Install a plugin from GitHub Releases (user/repo or user/repo@tag)')
+  .description(t('plugins.add.description'))
   .action(async (repo) => {
     try {
-      console.log(`Installing plugin from ${repo}...`)
+      console.log(t('plugins.add.installing', { repo }))
       await installPlugin(repo)
       const name = repo.split('@')[0].split('/').pop()
-      console.log(`Plugin "${name}" installed successfully.`)
+      console.log(t('plugins.add.success', { name }))
     } catch (err) {
       console.error(`Error: ${err.message}`)
       process.exit(1)
@@ -82,11 +83,11 @@ cmd.command('add <repo>')
   })
 
 cmd.command('remove <name>')
-  .description('Remove an installed plugin')
+  .description(t('plugins.remove.description'))
   .action((name) => {
     try {
       removePlugin(name)
-      console.log(`Plugin "${name}" removed.`)
+      console.log(t('plugins.remove.success', { name }))
     } catch (err) {
       console.error(`Error: ${err.message}`)
       process.exit(1)

package/src/commands/req.js

@@ -1,12 +1,13 @@
 'use strict'
 const { Command } = require('commander')
 const { listREQs } = require('../generators/req')
+const { t } = require('../i18n')
 
 const cmd = new Command('req')
-cmd.description('Manage Requirements')
+cmd.description(t('req.description'))
 
 cmd.command('new <title>')
-  .description('Create a new REQ')
+  .description(t('req.new.description'))
   .action(async (title) => {
     const { input, select } = require('@inquirer/prompts')
     const generators = require('../generators/req')
@@ -16,14 +17,14 @@ cmd.command('new <title>')
 
     if (process.stdin.isTTY) {
       // Form 1 — título + motivação
-      content.title = await input({ message: 'Project requirement', default: title })
-      content.motivation = await input({ message: 'Motivation (why is this needed?)', default: '' })
+      content.title = await input({ message: t('req.new.prompt.title'), default: title })
+      content.motivation = await input({ message: t('req.new.prompt.motivation'), default: '' })
 
       // Detectar domínios com base em título + motivação
       const probes = generators.detectDomains(content.title + ' ' + content.motivation)
 
       // Form 2 — critérios de aceite
-      content.criteria = await input({ message: 'Acceptance Criteria (one per line)', default: '- [ ]\n- [ ]' })
+      content.criteria = await input({ message: t('req.new.prompt.criteria'), default: '- [ ]\n- [ ]' })
 
       // Perguntas dinâmicas por probe
       const generatedADRs = []
@@ -42,7 +43,7 @@ cmd.command('new <title>')
               const basename = await adrGenerators.newADRDraft(answer)
               if (basename) generatedADRs.push(basename)
             } catch (e) {
-              console.warn(`warning: could not create ADR draft for ${answer}: ${e.message}`)
+              console.warn(t('req.new.adrWarning', { slug: answer, message: e.message }))
             }
           }
         }
@@ -54,14 +55,14 @@ cmd.command('new <title>')
     await generators.newREQ(content)
 
     if (content.dependsOnADRs.length > 0) {
-      console.log('\nADR drafts created:')
+      console.log(`\n${t('req.new.adrDraftsCreated')}`)
       content.dependsOnADRs.forEach(adr => console.log(`  -> ${adr}`))
-      console.log('\nResolve these ADRs (set Status: Accepted) before creating a roadmap.')
+      console.log(`\n${t('req.new.resolveADRs')}`)
     }
   })
 
 cmd.command('list')
-  .description('List all REQs in docs/req/')
+  .description(t('req.list.description'))
   .action(async () => {
     listREQs('docs/req')
   })

package/src/commands/roadmap.js

@@ -1,12 +1,13 @@
 'use strict'
 const { Command } = require('commander')
 const { listRoadmaps, showRoadmap, moveRoadmap, newRoadmap } = require('../generators/roadmap')
+const { t } = require('../i18n')
 
 const cmd = new Command('roadmap')
-cmd.description('Manage Roadmaps')
+cmd.description(t('roadmap.description'))
 
 cmd.command('new')
-  .description('Create a new roadmap from a REQ')
+  .description(t('roadmap.new.description'))
   .option('-t, --title <title>', 'Roadmap title')
   .option('-r, --req <path>', 'Path to the linked REQ')
   .action(async (opts) => {
@@ -16,19 +17,19 @@ cmd.command('new')
   })
 
 cmd.command('list')
-  .description('List all roadmaps grouped by state')
+  .description(t('roadmap.list.description'))
   .action(async () => {
     listRoadmaps()
   })
 
 cmd.command('show <name>')
-  .description('Show a roadmap by name (partial match)')
+  .description(t('roadmap.show.description'))
   .action(async (name) => {
     showRoadmap(name)
   })
 
 cmd.command('move <name> <state>')
-  .description('Move a roadmap between states (backlog|wip|blocked|done|abandoned)')
+  .description(t('roadmap.move.description'))
   .action(async (name, state) => {
     moveRoadmap(name, state)
   })

package/src/commands/status.js

@@ -1,9 +1,10 @@
 'use strict'
 const { Command } = require('commander')
 const { getStatus } = require('../validator')
+const { t } = require('../i18n')
 
 const cmd = new Command('status')
-cmd.description('Show project governance status')
+cmd.description(t('status.description'))
 cmd.action(async () => {
   console.log(await getStatus())
 })

package/src/commands/validate.js

@@ -1,24 +1,25 @@
 'use strict'
 const { Command } = require('commander')
 const { validate } = require('../validator')
+const { t } = require('../i18n')
 
 const cmd = new Command('validate')
-cmd.description('Validate governance rules')
+cmd.description(t('validate.description'))
 cmd.action(async () => {
   const { violations, warnings } = await validate()
 
   if (violations.length === 0 && warnings.length === 0) {
-    console.log('✓ No violations found.')
+    console.log(t('validate.ok'))
     return
   }
 
   if (violations.length > 0) {
-    console.log(`\n✗ Violations (${violations.length}):`)
+    console.log(`\n${t('validate.violations', { count: violations.length })}`)
     violations.forEach(v => console.log(`  • ${v}`))
   }
 
   if (warnings.length > 0) {
-    console.log(`\n⚠ Warnings (${warnings.length}):`)
+    console.log(`\n${t('validate.warnings', { count: warnings.length })}`)
     warnings.forEach(w => console.log(`  • ${w}`))
   }
 

package/src/generators/init.js

@@ -29,6 +29,7 @@ async function scaffold(cfg) {
   generateCIWorkflow(cfg)
   generateGitHooks(cfg)
   generateClaudeMD(cfg)
+  if (cfg.backend === 'java') generatePomXml(cfg)
   generateClaudeCommands()
 }
 
@@ -43,6 +44,7 @@ function writeTrackfwConfig(cfg) {
 
 frontend: ${cfg.frontend || ''}
 backend: ${cfg.backend || ''}
+backend_framework: ${cfg.backendFramework || ''}
 pkg_manager: ${cfg.pkgManager || ''}
 hooks: ${cfg.hooks || ''}
 ci: ${cfg.ci || ''}
@@ -193,6 +195,63 @@ function generateLefthookHook() {
   console.log('  ✓ lefthook.yml')
 }
 
+// ---------------------------------------------------------------------------
+// pom.xml (Java / Spring Boot)
+// ---------------------------------------------------------------------------
+
+function generatePomXml(cfg) {
+  const slug = cfg.projectName
+    ? cfg.projectName.toLowerCase().replace(/[^a-z0-9-]/g, '-').replace(/-+/g, '-').replace(/^-|-$/g, '')
+    : 'my-app'
+  const name = cfg.projectName || 'My App'
+  const content = `<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <parent>
+    <groupId>org.springframework.boot</groupId>
+    <artifactId>spring-boot-starter-parent</artifactId>
+    <version>3.3.0</version>
+    <relativePath/>
+  </parent>
+  <groupId>com.example</groupId>
+  <artifactId>${slug}</artifactId>
+  <version>0.0.1-SNAPSHOT</version>
+  <name>${name}</name>
+  <description>${name} — generated by trackfw</description>
+  <properties>
+    <java.version>21</java.version>
+  </properties>
+  <dependencies>
+    <dependency>
+      <groupId>org.springframework.boot</groupId>
+      <artifactId>spring-boot-starter-web</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>org.springframework.boot</groupId>
+      <artifactId>spring-boot-starter-actuator</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>org.springframework.boot</groupId>
+      <artifactId>spring-boot-starter-test</artifactId>
+      <scope>test</scope>
+    </dependency>
+  </dependencies>
+  <build>
+    <plugins>
+      <plugin>
+        <groupId>org.springframework.boot</groupId>
+        <artifactId>spring-boot-maven-plugin</artifactId>
+      </plugin>
+    </plugins>
+  </build>
+</project>
+`
+  fs.writeFileSync('pom.xml', content, 'utf8')
+  console.log('  ✓ pom.xml')
+}
+
 // ---------------------------------------------------------------------------
 // CLAUDE.md
 // ---------------------------------------------------------------------------

package/src/i18n/index.js

@@ -0,0 +1,53 @@
+'use strict'
+const path = require('path')
+const fs = require('fs')
+
+function detectLocale() {
+  const raw = process.env.LANG || process.env.LC_ALL || process.env.LANGUAGE || ''
+  // Mapeia pt_BR.UTF-8 → pt-BR, es_ES.UTF-8 → es-ES, en_US.UTF-8 → en-US
+  const map = { pt: 'pt-BR', es: 'es-ES' }
+  const code = raw.split('.')[0].replace('_', '-')  // pt-BR
+  const lang = code.split('-')[0]                   // pt
+  if (map[lang]) return map[lang]
+  // Fallback para Windows: usar Intl
+  try {
+    const loc = Intl.DateTimeFormat().resolvedOptions().locale
+    const l = loc.split('-')[0]
+    if (map[l]) return map[l]
+  } catch (_) {}
+  return 'en-US'
+}
+
+let _locale = null
+let _messages = null
+
+function load() {
+  if (_messages) return
+  _locale = detectLocale()
+  const filePath = path.join(__dirname, 'locales', `${_locale}.json`)
+  const fallback = path.join(__dirname, 'locales', 'en-US.json')
+  try {
+    _messages = JSON.parse(fs.readFileSync(fs.existsSync(filePath) ? filePath : fallback, 'utf8'))
+  } catch (_) {
+    _messages = {}
+  }
+}
+
+function t(key, vars = {}) {
+  load()
+  const keys = key.split('.')
+  let val = _messages
+  for (const k of keys) {
+    val = val?.[k]
+    if (val === undefined) break
+  }
+  if (typeof val !== 'string') return key
+  return val.replace(/\{\{(\w+)\}\}/g, (_, k) => vars[k] ?? `{{${k}}}`)
+}
+
+function locale() {
+  load()
+  return _locale
+}
+
+module.exports = { t, locale }

package/src/i18n/locales/en-US.json

@@ -0,0 +1,122 @@
+{
+  "init": {
+    "description": "Initialize trackfw governance in the current project",
+    "prompt": {
+      "projectName": "Project name?",
+      "projectType": "Project type?",
+      "frontendStack": "Frontend stack?",
+      "pkgManager": "Package manager?",
+      "backendLang": "Backend language?",
+      "backendFramework": "Backend framework?",
+      "gitHooks": "Git hooks?",
+      "ci": "CI system?",
+      "aiTools": "Which AI assistants do you use?",
+      "projectType_fullstack": "Full-stack (frontend + backend)",
+      "projectType_frontend": "Frontend only",
+      "projectType_backend": "Backend only",
+      "projectType_governance": "Governance only (no build stack)"
+    },
+    "success": "✓ trackfw initialized — run 'trackfw status' to see your governance state."
+  },
+  "adr": {
+    "description": "Manage Architecture Decision Records",
+    "new": {
+      "description": "Create a new Architecture Decision Record",
+      "prompt": {
+        "title": "ADR title?",
+        "status": "Initial status?",
+        "context": "Context (what motivates this decision)?",
+        "decision": "Decision (what was decided)?",
+        "consequences": "Consequences (positive and negative)?",
+        "alternatives": "Alternatives considered?"
+      },
+      "created": "✓ ADR created: {{path}}"
+    },
+    "list": {
+      "description": "List all ADRs with status",
+      "empty": "No ADRs found in docs/adr/"
+    }
+  },
+  "req": {
+    "description": "Manage Requirements",
+    "new": {
+      "description": "Create a new requirement",
+      "prompt": {
+        "title": "Project requirement",
+        "motivation": "Motivation (why is this needed)?",
+        "criteria": "Acceptance Criteria (one per line)",
+        "domainQuestion_authentication": "How will users authenticate?",
+        "domainQuestion_ui": "Is there an existing UI framework or design system?",
+        "domainQuestion_persistence": "Which database engine will be used?",
+        "domainQuestion_api": "Which API protocol will be used?",
+        "domainQuestion_deploy": "What is the deployment target?",
+        "domainQuestion_events": "Which event broker will be used?"
+      },
+      "detectedDomains": "Detected domains: {{domains}}",
+      "created": "✓ REQ created: {{path}}",
+      "adrDraftsCreated": "ADR drafts created:",
+      "resolveADRs": "Resolve these ADRs (set Status: Accepted) before creating a roadmap.",
+      "adrWarning": "warning: could not create ADR draft for {{slug}}: {{message}}"
+    },
+    "list": {
+      "description": "List all REQs with status",
+      "empty": "No REQs found in docs/req/"
+    }
+  },
+  "roadmap": {
+    "description": "Manage Roadmaps",
+    "list": {
+      "description": "List all roadmaps grouped by state",
+      "empty": "No roadmaps found."
+    },
+    "show": {
+      "description": "Show a roadmap by name (partial match)",
+      "notFound": "Roadmap not found: {{name}}"
+    },
+    "move": {
+      "description": "Move a roadmap between states (backlog|wip|blocked|done|abandoned)",
+      "success": "✓ Moved {{name}} → {{state}}",
+      "notFound": "Roadmap not found: {{name}}"
+    },
+    "new": {
+      "description": "Create a new roadmap from a REQ",
+      "created": "✓ Roadmap created: {{path}}"
+    }
+  },
+  "validate": {
+    "description": "Validate governance rules (use as CI gate)",
+    "ok": "✓ No violations found.",
+    "violations": "✗ Violations ({{count}}):",
+    "warnings": "⚠ Warnings ({{count}}):"
+  },
+  "status": {
+    "description": "Show project governance status"
+  },
+  "log": {
+    "description": "Show roadmap state transition history",
+    "empty": "No transitions recorded yet.",
+    "tail": "Number of recent transitions to show",
+    "header": "── trackfw log ─────────────────────────"
+  },
+  "plugins": {
+    "description": "Manage trackfw plugins",
+    "list": {
+      "description": "List installed plugins",
+      "empty": "No plugins installed. Use `trackfw plugins add <user/repo>` to install one."
+    },
+    "add": {
+      "description": "Install a plugin from GitHub Releases (user/repo or user/repo@tag)",
+      "installing": "Installing plugin from {{repo}}...",
+      "success": "Plugin \"{{name}}\" installed successfully."
+    },
+    "remove": {
+      "description": "Remove an installed plugin",
+      "success": "Plugin \"{{name}}\" removed."
+    }
+  },
+  "errors": {
+    "notFound": "Not found: {{path}}",
+    "downloadFailed": "download failed: HTTP {{status}} for {{url}}",
+    "pluginNotFound": "plugin \"{{name}}\" not found"
+  }
+}

package/src/i18n/locales/es-ES.json

@@ -0,0 +1,122 @@
+{
+  "init": {
+    "description": "Inicializa la gobernanza trackfw en el proyecto actual",
+    "prompt": {
+      "projectName": "¿Nombre del proyecto?",
+      "projectType": "¿Tipo de proyecto?",
+      "frontendStack": "¿Stack de frontend?",
+      "pkgManager": "¿Gestor de paquetes?",
+      "backendLang": "¿Lenguaje de backend?",
+      "backendFramework": "¿Framework de backend?",
+      "gitHooks": "¿Git hooks?",
+      "ci": "¿Sistema de CI?",
+      "aiTools": "¿Qué asistentes de IA usas?",
+      "projectType_fullstack": "Full-stack (frontend + backend)",
+      "projectType_frontend": "Solo frontend",
+      "projectType_backend": "Solo backend",
+      "projectType_governance": "Solo gobernanza (sin stack de build)"
+    },
+    "success": "✓ trackfw inicializado — ejecuta 'trackfw status' para ver el estado de gobernanza."
+  },
+  "adr": {
+    "description": "Gestionar Architecture Decision Records",
+    "new": {
+      "description": "Crear un nuevo Architecture Decision Record",
+      "prompt": {
+        "title": "¿Título del ADR?",
+        "status": "¿Estado inicial?",
+        "context": "¿Contexto (qué motiva esta decisión)?",
+        "decision": "¿Decisión (qué fue decidido)?",
+        "consequences": "¿Consecuencias (positivas y negativas)?",
+        "alternatives": "¿Alternativas consideradas?"
+      },
+      "created": "✓ ADR creado: {{path}}"
+    },
+    "list": {
+      "description": "Listar todos los ADRs con estado",
+      "empty": "No se encontraron ADRs en docs/adr/"
+    }
+  },
+  "req": {
+    "description": "Gestionar Requisitos",
+    "new": {
+      "description": "Crear un nuevo requisito",
+      "prompt": {
+        "title": "Requisito del proyecto",
+        "motivation": "¿Motivación (por qué lo necesitamos)?",
+        "criteria": "Criterios de aceptación (uno por línea)",
+        "domainQuestion_authentication": "¿Cómo se autenticarán los usuarios?",
+        "domainQuestion_ui": "¿Existe un framework de UI o design system ya elegido?",
+        "domainQuestion_persistence": "¿Qué motor de base de datos se usará?",
+        "domainQuestion_api": "¿Qué protocolo de API se usará?",
+        "domainQuestion_deploy": "¿Cuál es el destino de despliegue?",
+        "domainQuestion_events": "¿Qué message broker se usará?"
+      },
+      "detectedDomains": "Dominios detectados: {{domains}}",
+      "created": "✓ REQ creado: {{path}}",
+      "adrDraftsCreated": "ADR borradores creados:",
+      "resolveADRs": "Resuelve estos ADRs (establece Status: Accepted) antes de crear un roadmap.",
+      "adrWarning": "advertencia: no se pudo crear ADR borrador para {{slug}}: {{message}}"
+    },
+    "list": {
+      "description": "Listar todos los REQs con estado",
+      "empty": "No se encontraron REQs en docs/req/"
+    }
+  },
+  "roadmap": {
+    "description": "Gestionar Roadmaps",
+    "list": {
+      "description": "Listar todos los roadmaps agrupados por estado",
+      "empty": "No se encontraron roadmaps."
+    },
+    "show": {
+      "description": "Mostrar roadmap por nombre (coincidencia parcial)",
+      "notFound": "Roadmap no encontrado: {{name}}"
+    },
+    "move": {
+      "description": "Mover un roadmap entre estados (backlog|wip|blocked|done|abandoned)",
+      "success": "✓ Movido {{name}} → {{state}}",
+      "notFound": "Roadmap no encontrado: {{name}}"
+    },
+    "new": {
+      "description": "Crear un nuevo roadmap desde un REQ",
+      "created": "✓ Roadmap creado: {{path}}"
+    }
+  },
+  "validate": {
+    "description": "Validar reglas de gobernanza (úsalo como gate de CI)",
+    "ok": "✓ No se encontraron violaciones.",
+    "violations": "✗ Violaciones ({{count}}):",
+    "warnings": "⚠ Avisos ({{count}}):"
+  },
+  "status": {
+    "description": "Mostrar el estado actual de gobernanza del proyecto"
+  },
+  "log": {
+    "description": "Mostrar historial de transiciones de estado de los roadmaps",
+    "empty": "Aún no hay transiciones registradas.",
+    "tail": "Número de transiciones recientes a mostrar",
+    "header": "── trackfw log ─────────────────────────"
+  },
+  "plugins": {
+    "description": "Gestionar plugins de trackfw",
+    "list": {
+      "description": "Listar plugins instalados",
+      "empty": "No hay plugins instalados. Usa `trackfw plugins add <user/repo>` para instalar uno."
+    },
+    "add": {
+      "description": "Instalar un plugin desde GitHub Releases (user/repo o user/repo@tag)",
+      "installing": "Instalando plugin desde {{repo}}...",
+      "success": "Plugin \"{{name}}\" instalado correctamente."
+    },
+    "remove": {
+      "description": "Eliminar un plugin instalado",
+      "success": "Plugin \"{{name}}\" eliminado."
+    }
+  },
+  "errors": {
+    "notFound": "No encontrado: {{path}}",
+    "downloadFailed": "fallo en la descarga: HTTP {{status}} para {{url}}",
+    "pluginNotFound": "plugin \"{{name}}\" no encontrado"
+  }
+}

package/src/i18n/locales/pt-BR.json

@@ -0,0 +1,122 @@
+{
+  "init": {
+    "description": "Inicializa a governança trackfw no projeto atual",
+    "prompt": {
+      "projectName": "Nome do projeto?",
+      "projectType": "Tipo de projeto?",
+      "frontendStack": "Stack de frontend?",
+      "pkgManager": "Gerenciador de pacotes?",
+      "backendLang": "Linguagem de backend?",
+      "backendFramework": "Framework de backend?",
+      "gitHooks": "Git hooks?",
+      "ci": "Sistema de CI?",
+      "aiTools": "Quais assistentes de IA você usa?",
+      "projectType_fullstack": "Full-stack (frontend + backend)",
+      "projectType_frontend": "Somente frontend",
+      "projectType_backend": "Somente backend",
+      "projectType_governance": "Somente governança (sem stack de build)"
+    },
+    "success": "✓ trackfw inicializado — execute 'trackfw status' para ver o estado de governança."
+  },
+  "adr": {
+    "description": "Gerenciar Architecture Decision Records",
+    "new": {
+      "description": "Criar um novo Architecture Decision Record",
+      "prompt": {
+        "title": "Título do ADR?",
+        "status": "Status inicial?",
+        "context": "Contexto (o que motiva esta decisão)?",
+        "decision": "Decisão (o que foi decidido)?",
+        "consequences": "Consequências (positivas e negativas)?",
+        "alternatives": "Alternativas consideradas?"
+      },
+      "created": "✓ ADR criado: {{path}}"
+    },
+    "list": {
+      "description": "Listar todos os ADRs com status",
+      "empty": "Nenhum ADR encontrado em docs/adr/"
+    }
+  },
+  "req": {
+    "description": "Gerenciar Requisitos",
+    "new": {
+      "description": "Criar um novo requisito",
+      "prompt": {
+        "title": "Requisito do projeto",
+        "motivation": "Motivação (por que isso é necessário)?",
+        "criteria": "Critérios de aceite (um por linha)",
+        "domainQuestion_authentication": "Como os usuários serão autenticados?",
+        "domainQuestion_ui": "Existe um framework de UI ou design system já escolhido?",
+        "domainQuestion_persistence": "Qual engine de banco de dados será usada?",
+        "domainQuestion_api": "Qual protocolo de API será usado?",
+        "domainQuestion_deploy": "Qual é o destino de deploy?",
+        "domainQuestion_events": "Qual message broker será usado?"
+      },
+      "detectedDomains": "Domínios detectados: {{domains}}",
+      "created": "✓ REQ criado: {{path}}",
+      "adrDraftsCreated": "ADR drafts criados:",
+      "resolveADRs": "Resolva estes ADRs (defina Status: Accepted) antes de criar um roadmap.",
+      "adrWarning": "aviso: não foi possível criar ADR draft para {{slug}}: {{message}}"
+    },
+    "list": {
+      "description": "Listar todos os REQs com status",
+      "empty": "Nenhum REQ encontrado em docs/req/"
+    }
+  },
+  "roadmap": {
+    "description": "Gerenciar Roadmaps",
+    "list": {
+      "description": "Listar todos os roadmaps agrupados por estado",
+      "empty": "Nenhum roadmap encontrado."
+    },
+    "show": {
+      "description": "Exibir roadmap pelo nome (correspondência parcial)",
+      "notFound": "Roadmap não encontrado: {{name}}"
+    },
+    "move": {
+      "description": "Mover um roadmap entre estados (backlog|wip|blocked|done|abandoned)",
+      "success": "✓ Movido {{name}} → {{state}}",
+      "notFound": "Roadmap não encontrado: {{name}}"
+    },
+    "new": {
+      "description": "Criar um novo roadmap a partir de uma REQ",
+      "created": "✓ Roadmap criado: {{path}}"
+    }
+  },
+  "validate": {
+    "description": "Validar regras de governança (use como gate de CI)",
+    "ok": "✓ Nenhuma violação encontrada.",
+    "violations": "✗ Violações ({{count}}):",
+    "warnings": "⚠ Avisos ({{count}}):"
+  },
+  "status": {
+    "description": "Exibir o estado atual de governança do projeto"
+  },
+  "log": {
+    "description": "Exibir histórico de transições de estado dos roadmaps",
+    "empty": "Nenhuma transição registrada ainda.",
+    "tail": "Número de transições recentes a exibir",
+    "header": "── trackfw log ─────────────────────────"
+  },
+  "plugins": {
+    "description": "Gerenciar plugins do trackfw",
+    "list": {
+      "description": "Listar plugins instalados",
+      "empty": "Nenhum plugin instalado. Use `trackfw plugins add <user/repo>` para instalar um."
+    },
+    "add": {
+      "description": "Instalar um plugin do GitHub Releases (user/repo ou user/repo@tag)",
+      "installing": "Instalando plugin de {{repo}}...",
+      "success": "Plugin \"{{name}}\" instalado com sucesso."
+    },
+    "remove": {
+      "description": "Remover um plugin instalado",
+      "success": "Plugin \"{{name}}\" removido."
+    }
+  },
+  "errors": {
+    "notFound": "Não encontrado: {{path}}",
+    "downloadFailed": "falha no download: HTTP {{status}} para {{url}}",
+    "pluginNotFound": "plugin \"{{name}}\" não encontrado"
+  }
+}