trackfw 1.0.4 → 2.0.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": "2.0.0",
   "description": "Governed software delivery framework: ADR → REQ → ROADMAP → kanban",
   "keywords": [
     "cli",

package/src/commands/adr.js

@@ -3,28 +3,29 @@
 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')
+    await generators.listADRs(require('../config').load().adrDirs[0])
   })
 
 module.exports = cmd

package/src/commands/discover.js

@@ -0,0 +1,359 @@
+'use strict';
+
+const { Command } = require('commander');
+const fs = require('fs');
+const path = require('path');
+
+function scan(rootDir) {
+  const r = {
+    adrDirs: [],
+    reqDir: '',
+    roadmapDir: '',
+    roadmapNamespacing: 'flat',
+    agents: [],
+    adrCount: 0,
+    reqCount: 0,
+    roadmapCount: 0,
+    hasTrackfwYAML: false,
+    hasTrackfwLog: false,
+    governanceScore: 0,
+    hookFramework: 'none',
+    ciSystem: 'none',
+  };
+
+  // trackfw.yaml
+  r.hasTrackfwYAML = fs.existsSync(path.join(rootDir, 'trackfw.yaml'));
+
+  // REQ dir
+  for (const candidate of ['docs/req', 'docs/requisições', 'docs/requirements', 'docs/reqs']) {
+    const full = path.join(rootDir, candidate);
+    if (isDir(full)) {
+      r.reqDir = candidate;
+      r.reqCount = countMD(full);
+      break;
+    }
+  }
+
+  // ADR dirs
+  const adrRoot = path.join(rootDir, 'docs', 'adr');
+  if (isDir(adrRoot)) {
+    const subDirs = listSubDirs(adrRoot);
+    if (subDirs.length > 0) {
+      for (const sub of subDirs) {
+        const rel = 'docs/adr/' + sub;
+        r.adrDirs.push(rel);
+        r.adrCount += countMD(path.join(rootDir, rel));
+      }
+    } else {
+      r.adrDirs = ['docs/adr'];
+      r.adrCount = countMD(adrRoot);
+    }
+  }
+
+  // Roadmap dir e namespacing
+  const roadmapRoot = path.join(rootDir, 'docs', 'roadmaps');
+  if (isDir(roadmapRoot)) {
+    r.roadmapDir = 'docs/roadmaps';
+    const agentDirs = listSubDirs(roadmapRoot);
+    let byAgent = false;
+    const agents = [];
+    for (const sub of agentDirs) {
+      const wipDir = path.join(roadmapRoot, sub, 'wip');
+      const backlogDir = path.join(roadmapRoot, sub, 'backlog');
+      const doneDir = path.join(roadmapRoot, sub, 'done');
+      const abandonedDir = path.join(roadmapRoot, sub, 'abandoned');
+      const blockedDir = path.join(roadmapRoot, sub, 'blocked');
+      if (isDir(wipDir) || isDir(backlogDir) || isDir(doneDir) || isDir(abandonedDir) || isDir(blockedDir)) {
+        byAgent = true;
+        agents.push(sub);
+      }
+    }
+    if (byAgent) {
+      r.roadmapNamespacing = 'by_agent';
+      r.agents = agents;
+      for (const agent of agents) {
+        for (const state of ['backlog', 'wip', 'blocked', 'done', 'abandoned']) {
+          r.roadmapCount += countMD(path.join(roadmapRoot, agent, state));
+        }
+      }
+    } else {
+      r.roadmapNamespacing = 'flat';
+      for (const state of ['backlog', 'wip', 'blocked', 'done', 'abandoned']) {
+        r.roadmapCount += countMD(path.join(roadmapRoot, state));
+      }
+    }
+
+    r.hasTrackfwLog = fs.existsSync(path.join(roadmapRoot, '.trackfw-log'));
+  }
+
+  // Hook framework
+  if (isFile(path.join(rootDir, 'lefthook.yml')) || isFile(path.join(rootDir, '.lefthook.yml'))) {
+    r.hookFramework = 'lefthook';
+  } else if (isDir(path.join(rootDir, '.husky'))) {
+    r.hookFramework = 'husky';
+  } else if (isFile(path.join(rootDir, '.pre-commit-config.yaml'))) {
+    r.hookFramework = 'pre-commit';
+  } else {
+    r.hookFramework = 'none';
+  }
+
+  // CI
+  if (isDir(path.join(rootDir, '.github', 'workflows'))) {
+    r.ciSystem = 'github-actions';
+  } else if (isFile(path.join(rootDir, '.gitlab-ci.yml'))) {
+    r.ciSystem = 'gitlab';
+  } else {
+    r.ciSystem = 'none';
+  }
+
+  r.governanceScore = calcScore(r);
+  return r;
+}
+
+function calcScore(r) {
+  let score = 0;
+  if (r.adrCount > 0) score += 20;
+  if (r.reqCount > 0) score += 20;
+  if (r.roadmapCount > 0) score += 20;
+  if (r.hasTrackfwYAML) score += 20;
+  if (r.hasTrackfwLog) score += 20;
+  return score;
+}
+
+function generateYAML(r) {
+  let out = '# trackfw configuration — gerado por trackfw discover\n';
+  out += '# governance_mode: lenient permite validação não-bloqueante durante onboarding\n\n';
+  out += 'governance_mode: lenient\n\n';
+
+  if (r.adrDirs.length > 0) {
+    out += 'adr_dirs:\n';
+    r.adrDirs.forEach(d => { out += `  - ${d}\n`; });
+  } else {
+    out += 'adr_dirs:\n  - docs/adr\n';
+  }
+
+  out += `req_dir: ${r.reqDir || 'docs/req'}\n`;
+  out += `roadmap_dir: ${r.roadmapDir || 'docs/roadmaps'}\n`;
+  out += `roadmap_namespacing: ${r.roadmapNamespacing}\n`;
+
+  if (r.agents.length > 0) {
+    out += 'agents:\n';
+    r.agents.forEach(a => { out += `  - ${a}\n`; });
+  }
+
+  out += `hooks: ${r.hookFramework}\n`;
+  out += `ci: ${r.ciSystem}\n`;
+
+  return out;
+}
+
+function generateBootstrapLog(r, rootDir) {
+  let out = '';
+  const roadmapRoot = path.join(rootDir, r.roadmapDir);
+
+  const appendEntries = (dir, agent) => {
+    if (!isDir(dir)) return;
+    for (const entry of fs.readdirSync(dir)) {
+      if (!entry.endsWith('.md')) continue;
+      const filePath = path.join(dir, entry);
+      const stat = fs.statSync(filePath);
+      const ts = stat.mtime.toISOString().slice(0, 16).replace('T', ' ');
+      const basename = agent ? agent + '/' + entry : entry;
+      out += `${ts}  ${basename.padEnd(50)}  backlog → done\n`;
+    }
+  };
+
+  if (r.roadmapNamespacing === 'by_agent') {
+    for (const agent of r.agents) {
+      appendEntries(path.join(roadmapRoot, agent, 'done'), agent);
+    }
+  } else {
+    appendEntries(path.join(roadmapRoot, 'done'), '');
+  }
+
+  return out;
+}
+
+// installGates instala artefatos de governança: validate script, hook entry, CI workflow.
+function installGates(r, rootDir) {
+  writeValidateScript(rootDir);
+  installHook(r.hookFramework, rootDir);
+  if (r.ciSystem === 'github-actions') {
+    writeCIWorkflow(rootDir);
+  }
+}
+
+function writeValidateScript(rootDir) {
+  const scriptsDir = path.join(rootDir, 'scripts');
+  if (!isDir(scriptsDir)) fs.mkdirSync(scriptsDir, { recursive: true });
+  const content = '#!/usr/bin/env bash\nset -euo pipefail\ntrackfw validate\n';
+  const dest = path.join(scriptsDir, 'trackfw-validate.sh');
+  fs.writeFileSync(dest, content, { mode: 0o755 });
+}
+
+function installHook(framework, rootDir) {
+  const hookEntry = '\npre-commit:\n  commands:\n    trackfw-validate:\n      run: scripts/trackfw-validate.sh\n';
+  const huskyEntry = '\nscripts/trackfw-validate.sh\n';
+
+  if (framework === 'lefthook') {
+    let cfgPath = path.join(rootDir, 'lefthook.yml');
+    if (!isFile(cfgPath)) cfgPath = path.join(rootDir, '.lefthook.yml');
+    const content = fs.readFileSync(cfgPath, 'utf8');
+    if (content.includes('trackfw')) return; // idempotente
+    fs.appendFileSync(cfgPath, hookEntry, 'utf8');
+  } else if (framework === 'husky') {
+    const huskyHook = path.join(rootDir, '.husky', 'pre-commit');
+    fs.appendFileSync(huskyHook, huskyEntry, 'utf8');
+  } else {
+    console.log('⚠ No hook framework detected — skipping hook installation');
+  }
+}
+
+function writeCIWorkflow(rootDir) {
+  const workflowsDir = path.join(rootDir, '.github', 'workflows');
+  if (!isDir(workflowsDir)) fs.mkdirSync(workflowsDir, { recursive: true });
+  const dest = path.join(workflowsDir, 'trackfw-validate.yml');
+  if (isFile(dest)) return; // idempotente
+  const content = `name: trackfw validate
+on: [push, pull_request]
+jobs:
+  governance:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-go@v5
+        with:
+          go-version: "1.22"
+      - run: go install github.com/kgsaran/trackfw/cmd/trackfw@latest
+      - run: trackfw validate
+`;
+  fs.writeFileSync(dest, content, 'utf8');
+}
+
+// helpers
+function isDir(p) {
+  try { return fs.statSync(p).isDirectory(); } catch { return false; }
+}
+
+function isFile(p) {
+  try { return fs.statSync(p).isFile(); } catch { return false; }
+}
+
+function countMD(dir) {
+  let n = 0;
+  function walk(d) {
+    let entries;
+    try { entries = fs.readdirSync(d, { withFileTypes: true }); } catch { return; }
+    for (const e of entries) {
+      if (e.isDirectory()) walk(path.join(d, e.name));
+      else if (e.name.endsWith('.md')) n++;
+    }
+  }
+  walk(dir);
+  return n;
+}
+
+function listSubDirs(dir) {
+  try {
+    return fs.readdirSync(dir).filter(f => {
+      try { return fs.statSync(path.join(dir, f)).isDirectory(); } catch { return false; }
+    });
+  } catch { return []; }
+}
+
+const cmd = new Command('discover');
+cmd.description('Scan the repository and auto-detect the governance structure');
+cmd.option('--init', 'generate trackfw.yaml calibrated for this project');
+cmd.option('--bootstrap-log', 'create retroactive .trackfw-log from done/ files');
+cmd.action((opts) => {
+  const cwd = process.cwd();
+  console.log(`trackfw discover — scanning ${cwd}\n`);
+
+  const r = scan(cwd);
+
+  // ADR dirs
+  if (r.adrCount > 0) {
+    const dirs = r.adrDirs.join(', ');
+    console.log(`✓ ADRs found:      ${String(r.adrCount).padEnd(4)}  (${dirs})`);
+  } else {
+    console.log('⚠ No ADRs found');
+  }
+
+  // REQ dir
+  if (r.reqCount > 0) {
+    console.log(`✓ REQs found:      ${String(r.reqCount).padEnd(4)}  (${r.reqDir})`);
+  } else {
+    console.log('⚠ No REQs found');
+  }
+
+  // Roadmaps
+  if (r.roadmapCount > 0) {
+    const mode = r.roadmapNamespacing === 'by_agent' ? 'by_agent mode' : r.roadmapNamespacing;
+    console.log(`✓ Roadmaps found:  ${String(r.roadmapCount).padEnd(4)}  (${r.roadmapDir} — ${mode})`);
+  } else {
+    console.log('⚠ No roadmaps found');
+  }
+
+  // Agents
+  if (r.agents.length > 0) {
+    console.log(`✓ Agents detected: ${r.agents.join(', ')}`);
+  }
+
+  // trackfw.yaml
+  if (!r.hasTrackfwYAML) {
+    console.log('⚠ No trackfw.yaml — run with --init to generate one');
+  } else {
+    console.log('✓ trackfw.yaml found');
+  }
+
+  // .trackfw-log
+  if (!r.hasTrackfwLog) {
+    console.log('⚠ No .trackfw-log — run with --bootstrap-log to create retroactive history');
+  } else {
+    console.log('✓ .trackfw-log found');
+  }
+
+  // hooks
+  if (r.hookFramework !== 'none') {
+    console.log(`✓ Hooks: ${r.hookFramework}`);
+  } else {
+    console.log('⚠ No hook framework detected');
+  }
+
+  // CI
+  if (r.ciSystem !== 'none') {
+    console.log(`✓ CI: ${r.ciSystem}`);
+  } else {
+    console.log('⚠ No CI system detected');
+  }
+
+  console.log(`\nGovernance Score: ${r.governanceScore}/100`);
+
+  if (opts.init) {
+    const yaml = generateYAML(r);
+    fs.writeFileSync('trackfw.yaml', yaml, 'utf8');
+    console.log('\n✓ trackfw.yaml generated');
+    try {
+      installGates(r, cwd);
+      console.log('✓ governance gates installed');
+    } catch (e) {
+      console.log(`⚠ gates install partial: ${e.message}`);
+    }
+  }
+
+  if (opts.bootstrapLog) {
+    if (!r.roadmapDir) {
+      console.error('⚠ No roadmap dir detected — cannot bootstrap log');
+      return;
+    }
+    const logContent = generateBootstrapLog(r, cwd);
+    const logPath = r.roadmapDir + '/.trackfw-log';
+    fs.appendFileSync(logPath, logContent, 'utf8');
+    console.log(`✓ bootstrap log written to ${logPath}`);
+  }
+});
+
+module.exports = cmd;
+module.exports.scan = scan;
+module.exports.generateYAML = generateYAML;
+module.exports.generateBootstrapLog = generateBootstrapLog;

package/src/commands/index.js

@@ -18,6 +18,7 @@ function createProgram() {
   program.addCommand(require('./status'))
   program.addCommand(require('./log'))
   program.addCommand(require('./plugins'))
+  program.addCommand(require('./discover'))
 
   // plugin dispatch — comandos desconhecidos tentam executar plugin
   program.hook('preSubcommand', () => {})

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))
 })