aios-lite 0.1.2 → 0.1.4

package/CHANGELOG.md

@@ -2,6 +2,32 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.1.4] - Unreleased
+### Added
+- New command:
+  - `aios-lite test:smoke [workspace-path] [--lang=en|pt-BR] [--keep]`
+- New smoke test suite: `tests/smoke.test.js`.
+
+### Changed
+- `doctor` now supports safe remediation mode:
+  - `aios-lite doctor --fix`
+  - `aios-lite doctor --fix --dry-run`
+- `setup:context` and setup templates now default `aios_lite_version` to `0.1.4`.
+
+## [0.1.3] - 2026-03-01
+### Added
+- Localized agent prompt packs:
+  - `.aios-lite/locales/en/agents/*.md`
+  - `.aios-lite/locales/pt-BR/agents/*.md`
+- New command:
+  - `aios-lite locale:apply [path] [--lang=en|pt-BR] [--dry-run]`
+- Agent path resolution now supports locale-aware prompts with fallback to active agent paths.
+- New locale test suite: `tests/locales.test.js`.
+
+### Changed
+- `setup:context` now applies localized agent prompts based on `conversation_language`.
+- Documentation updated for locale pack workflow.
+
 ## [0.1.2] - 2026-03-01
 ### Added
 - New commands:

package/README.md

@@ -15,12 +15,14 @@ npx aios-lite install
 - `aios-lite install [path]`
 - `aios-lite update [path]`
 - `aios-lite info [path]`
-- `aios-lite doctor [path]`
+- `aios-lite doctor [path] [--fix] [--dry-run]`
 - `aios-lite i18n:add <locale>`
 - `aios-lite setup:context [path]`
 - `aios-lite agents`
 - `aios-lite agent:prompt <agent> [--tool=codex|claude|gemini|opencode]`
 - `aios-lite context:validate [path]`
+- `aios-lite locale:apply [path] [--lang=en|pt-BR]`
+- `aios-lite test:smoke [workspace-path] [--lang=en|pt-BR] [--keep]`
 
 ## Agent usage helper
 If your AI CLI does not show a visual agent picker, use:
@@ -28,6 +30,9 @@ If your AI CLI does not show a visual agent picker, use:
 ```bash
 aios-lite agents
 aios-lite agent:prompt setup --tool=codex
+aios-lite locale:apply --lang=pt-BR
+aios-lite doctor --fix
+aios-lite test:smoke --lang=pt-BR
 ```
 
 ## i18n

package/docs/en/i18n.md

@@ -7,6 +7,7 @@ AIOS Lite CLI supports localization through message dictionaries.
 - `src/i18n/index.js` resolves locale and fallback behavior.
 - Commands use translation keys instead of hardcoded strings.
 - Agent templates read `conversation_language` from `.aios-lite/context/project.context.md` and should use it for interaction/output language.
+- Localized agent packs live in `.aios-lite/locales/<locale>/agents/` and can be applied to active prompts with `aios-lite locale:apply`.
 
 ## Runtime selection
 - CLI option: `--locale=en`
@@ -18,6 +19,15 @@ AIOS Lite CLI supports localization through message dictionaries.
 aios-lite i18n:add fr
 ```
 
+## Apply localized agent prompts
+```bash
+# Use language from project.context.md
+aios-lite locale:apply
+
+# Or force a locale
+aios-lite locale:apply --lang=pt-BR
+```
+
 ## Add a new locale
 1. Run `aios-lite i18n:add <locale>`.
 2. Replace English strings in `src/i18n/messages/<locale>.js`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aios-lite",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Lightweight AI agent framework for software projects.",
   "keywords": [
     "ai",

package/src/agents.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const { AGENT_DEFINITIONS } = require('./constants');
+const { getLocalizedAgentPath } = require('./locales');
 
 function normalizeAgentName(input) {
   return String(input || '')
@@ -18,32 +19,38 @@ function listAgentDefinitions() {
   return [...AGENT_DEFINITIONS];
 }
 
-function buildAgentPrompt(agent, tool) {
+function resolveInstructionPath(agent, locale) {
+  if (!locale) return agent.path;
+  return getLocalizedAgentPath(agent.id, locale);
+}
+
+function buildAgentPrompt(agent, tool, options = {}) {
   const safeTool = String(tool || 'codex').toLowerCase();
+  const instructionPath = options.instructionPath || agent.path;
   const dependencyText =
     agent.dependsOn.length > 0
       ? `Check required context files first: ${agent.dependsOn.join(', ')}.`
       : 'No prerequisite context files are required.';
 
   if (safeTool === 'claude') {
-    return `Read ${agent.path} and execute ${agent.command}. ${dependencyText} Write output to ${agent.output}.`;
+    return `Read ${instructionPath} and execute ${agent.command}. ${dependencyText} Write output to ${agent.output}.`;
   }
 
   if (safeTool === 'gemini') {
-    return `Run the Gemini command mapped to ${agent.path} and execute ${agent.command}. ${dependencyText} Save result to ${agent.output}.`;
+    return `Run the Gemini command mapped to ${instructionPath} and execute ${agent.command}. ${dependencyText} Save result to ${agent.output}.`;
   }
 
   if (safeTool === 'opencode') {
-    return `Use agent "${agent.id}" from ${agent.path}. ${dependencyText} Save output to ${agent.output}.`;
+    return `Use agent "${agent.id}" from ${instructionPath}. ${dependencyText} Save output to ${agent.output}.`;
   }
 
-  return `Read AGENTS.md and execute ${agent.command} using ${agent.path}. ${dependencyText} Save output to ${agent.output}.`;
+  return `Read AGENTS.md and execute ${agent.command} using ${instructionPath}. ${dependencyText} Save output to ${agent.output}.`;
 }
 
 module.exports = {
   normalizeAgentName,
   getAgentDefinition,
   listAgentDefinitions,
+  resolveInstructionPath,
   buildAgentPrompt
 };
-

package/src/cli.js

@@ -11,6 +11,8 @@ const { runI18nAdd } = require('./commands/i18n-add');
 const { runAgentsList, runAgentPrompt } = require('./commands/agents');
 const { runContextValidate } = require('./commands/context-validate');
 const { runSetupContext } = require('./commands/setup-context');
+const { runLocaleApply } = require('./commands/locale-apply');
+const { runSmokeTest } = require('./commands/smoke');
 
 function printHelp(t) {
   console.log(`${t('cli.title')}\n`);
@@ -25,6 +27,8 @@ function printHelp(t) {
   console.log(`  ${t('cli.help_agent_prompt')}`);
   console.log(`  ${t('cli.help_context_validate')}`);
   console.log(`  ${t('cli.help_setup_context')}`);
+  console.log(`  ${t('cli.help_locale_apply')}`);
+  console.log(`  ${t('cli.help_test_smoke')}`);
 }
 
 async function main() {
@@ -84,6 +88,14 @@ async function main() {
       await runSetupContext({ args, options, logger, t });
       return;
     }
+    if (command === 'locale:apply' || command === 'locale-apply') {
+      await runLocaleApply({ args, options, logger, t });
+      return;
+    }
+    if (command === 'test:smoke' || command === 'test-smoke') {
+      await runSmokeTest({ args, options, logger, t });
+      return;
+    }
 
     logger.error(`${t('cli.unknown_command', { command })}\n`);
     printHelp(t);

package/src/commands/agents.js

@@ -1,19 +1,51 @@
 'use strict';
 
-const { listAgentDefinitions, getAgentDefinition, buildAgentPrompt } = require('../agents');
+const path = require('node:path');
+const {
+  listAgentDefinitions,
+  getAgentDefinition,
+  resolveInstructionPath,
+  buildAgentPrompt
+} = require('../agents');
+const { resolveAgentLocale } = require('../locales');
+const { validateProjectContextFile } = require('../context');
+const { exists } = require('../utils');
 
-async function runAgentsList({ logger, t }) {
+async function resolveLocaleForTarget(targetDir, options) {
+  const fromOption = options.language || options.lang;
+  if (fromOption) return resolveAgentLocale(fromOption);
+
+  const context = await validateProjectContextFile(targetDir);
+  if (context.parsed && context.data && context.data.conversation_language) {
+    return resolveAgentLocale(context.data.conversation_language);
+  }
+
+  return 'en';
+}
+
+async function resolveExistingInstructionPath(targetDir, agent, locale) {
+  const candidate = resolveInstructionPath(agent, locale);
+  const candidateAbs = path.join(targetDir, candidate);
+  if (await exists(candidateAbs)) return candidate;
+  return agent.path;
+}
+
+async function runAgentsList({ args, options, logger, t }) {
+  const targetDir = path.resolve(process.cwd(), args[0] || '.');
+  const locale = await resolveLocaleForTarget(targetDir, options);
   const agents = listAgentDefinitions();
-  logger.log(t('agents.list_title'));
+  logger.log(t('agents.list_title', { locale }));
   for (const agent of agents) {
     const deps = agent.dependsOn.length > 0 ? agent.dependsOn.join(', ') : t('agents.none');
+    const instructionPath = await resolveExistingInstructionPath(targetDir, agent, locale);
     logger.log(`- ${agent.command} (${agent.id})`);
-    logger.log(`  ${t('agents.path')}: ${agent.path}`);
+    logger.log(`  ${t('agents.path')}: ${instructionPath}`);
+    logger.log(`  ${t('agents.active_path')}: ${agent.path}`);
     logger.log(`  ${t('agents.depends')}: ${deps}`);
     logger.log(`  ${t('agents.output')}: ${agent.output}`);
   }
 
-  return { count: agents.length, agents };
+  return { count: agents.length, agents, locale };
 }
 
 async function runAgentPrompt({ args, options, logger, t }) {
@@ -27,17 +59,19 @@ async function runAgentPrompt({ args, options, logger, t }) {
     throw new Error(t('agents.prompt_unknown_agent', { agent: name }));
   }
 
+  const targetDir = path.resolve(process.cwd(), args[1] || '.');
+  const locale = await resolveLocaleForTarget(targetDir, options);
+  const instructionPath = await resolveExistingInstructionPath(targetDir, agent, locale);
   const tool = options.tool || 'codex';
-  const prompt = buildAgentPrompt(agent, tool);
+  const prompt = buildAgentPrompt(agent, tool, { instructionPath });
 
-  logger.log(t('agents.prompt_title', { agent: agent.id, tool }));
+  logger.log(t('agents.prompt_title', { agent: agent.id, tool, locale }));
   logger.log(prompt);
 
-  return { agent: agent.id, tool, prompt };
+  return { agent: agent.id, tool, locale, prompt };
 }
 
 module.exports = {
   runAgentsList,
   runAgentPrompt
 };
-

package/src/commands/doctor.js

@@ -1,12 +1,9 @@
 'use strict';
 
 const path = require('node:path');
-const { runDoctor } = require('../doctor');
-
-async function runDoctorCommand({ args, logger, t }) {
-  const targetDir = path.resolve(process.cwd(), args[0] || '.');
-  const report = await runDoctor(targetDir);
+const { runDoctor, applyDoctorFixes } = require('../doctor');
 
+function printDoctorChecks(report, logger, t) {
   for (const check of report.checks) {
     const icon = check.ok ? t('doctor.ok') : t('doctor.fail');
     logger.log(`[${icon}] ${t(check.key, check.params)}`);
@@ -14,6 +11,49 @@ async function runDoctorCommand({ args, logger, t }) {
       logger.log(`  ${t('doctor.hint_prefix', { hint: t(check.hintKey) })}`);
     }
   }
+}
+
+function printFixAction(action, logger, t, dryRun) {
+  logger.log(`- ${t(`doctor.fix_action_${action.id}`)}`);
+  if (action.skipped) {
+    logger.log(`  ${t('doctor.fix_not_applicable')}`);
+    return;
+  }
+  logger.log(`  ${t('doctor.fix_target_count', { count: action.missingCount || action.count || 0 })}`);
+  logger.log(
+    `  ${t(dryRun ? 'doctor.fix_planned_count' : 'doctor.fix_applied_count', {
+      count: action.count || 0
+    })}`
+  );
+  if (action.locale) {
+    logger.log(`  ${t('doctor.fix_locale', { locale: action.locale })}`);
+  }
+}
+
+async function runDoctorCommand({ args, options = {}, logger, t }) {
+  const targetDir = path.resolve(process.cwd(), args[0] || '.');
+  const fix = Boolean(options.fix);
+  const dryRun = Boolean(options['dry-run']);
+
+  let report = await runDoctor(targetDir);
+
+  if (fix) {
+    logger.log(dryRun ? t('doctor.fix_start_dry_run') : t('doctor.fix_start'));
+    const fixResult = await applyDoctorFixes(targetDir, report, { dryRun });
+    for (const action of fixResult.actions) {
+      printFixAction(action, logger, t, dryRun);
+    }
+
+    logger.log(
+      dryRun
+        ? t('doctor.fix_summary_dry_run', { count: fixResult.changedCount })
+        : t('doctor.fix_summary', { count: fixResult.changedCount })
+    );
+    logger.log('');
+    report = await runDoctor(targetDir);
+  }
+
+  printDoctorChecks(report, logger, t);
 
   if (!report.ok) {
     logger.log(`\n${t('doctor.diagnosis_fail', { count: report.failedCount })}`);

package/src/commands/locale-apply.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const path = require('node:path');
+const { applyAgentLocale, resolveAgentLocale } = require('../locales');
+const { validateProjectContextFile } = require('../context');
+
+async function runLocaleApply({ args, options, logger, t }) {
+  const targetDir = path.resolve(process.cwd(), args[0] || '.');
+  const dryRun = Boolean(options['dry-run']);
+
+  let requestedLanguage = options.language || options.lang || '';
+  if (!requestedLanguage) {
+    const context = await validateProjectContextFile(targetDir);
+    if (context.parsed && context.data && context.data.conversation_language) {
+      requestedLanguage = context.data.conversation_language;
+    }
+  }
+
+  const locale = resolveAgentLocale(requestedLanguage || 'en');
+  const result = await applyAgentLocale(targetDir, locale, { dryRun });
+
+  logger.log(
+    dryRun
+      ? t('locale_apply.dry_run_applied', { locale: result.locale })
+      : t('locale_apply.applied', { locale: result.locale })
+  );
+  logger.log(t('locale_apply.copied_count', { count: result.copied.length }));
+
+  if (result.missing.length > 0) {
+    logger.log(t('locale_apply.missing_count', { count: result.missing.length }));
+  }
+
+  for (const item of result.copied) {
+    logger.log(`- ${item.source} -> ${item.target}`);
+  }
+
+  return result;
+}
+
+module.exports = {
+  runLocaleApply
+};
+

package/src/commands/setup-context.js

@@ -9,6 +9,7 @@ const {
   renderProjectContext,
   writeProjectContext
 } = require('../context-writer');
+const { applyAgentLocale } = require('../locales');
 
 function resolveOption(options, name, fallback = '') {
   return options[name] !== undefined ? String(options[name]) : fallback;
@@ -52,7 +53,7 @@ async function runSetupContext({ args, options, logger, t }) {
     email: resolveOption(options, 'email', ''),
     payments: resolveOption(options, 'payments', ''),
     installCommands: resolveOption(options, 'install-commands', ''),
-    aiosLiteVersion: resolveOption(options, 'aios-lite-version', '0.1.2')
+    aiosLiteVersion: resolveOption(options, 'aios-lite-version', '0.1.4')
   };
 
   let userTypesCount = Number(options['user-types'] || 1);
@@ -105,6 +106,9 @@ async function runSetupContext({ args, options, logger, t }) {
 
   const content = renderProjectContext(data);
   const filePath = await writeProjectContext(targetDir, content);
+  const localeApplyResult = await applyAgentLocale(targetDir, data.conversationLanguage, {
+    dryRun: false
+  });
 
   logger.log(t('setup_context.written', { path: filePath }));
   logger.log(
@@ -113,15 +117,21 @@ async function runSetupContext({ args, options, logger, t }) {
       score: classificationResult.score
     })
   );
+  logger.log(
+    t('setup_context.locale_applied', {
+      locale: localeApplyResult.locale,
+      count: localeApplyResult.copied.length
+    })
+  );
 
   return {
     filePath,
     data,
-    classificationScore: classificationResult.score
+    classificationScore: classificationResult.score,
+    localeApplyResult
   };
 }
 
 module.exports = {
   runSetupContext
 };
-

package/src/commands/smoke.js

@@ -0,0 +1,151 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const os = require('node:os');
+const path = require('node:path');
+const { ensureDir } = require('../utils');
+const { runInstall } = require('./install');
+const { runSetupContext } = require('./setup-context');
+const { runLocaleApply } = require('./locale-apply');
+const { runAgentsList, runAgentPrompt } = require('./agents');
+const { runContextValidate } = require('./context-validate');
+const { runDoctor } = require('../doctor');
+const { runUpdate } = require('./update');
+
+function createQuietLogger() {
+  return {
+    log() {},
+    error() {}
+  };
+}
+
+function assertStep(condition, message) {
+  if (!condition) {
+    throw new Error(message);
+  }
+}
+
+async function runSmokeTest({ args, options, logger, t }) {
+  const language = String(options.language || options.lang || 'en');
+  const keep = Boolean(options.keep);
+  const baseDir = path.resolve(process.cwd(), args[0] || os.tmpdir());
+  await ensureDir(baseDir);
+
+  const workspaceRoot = await fs.mkdtemp(path.join(baseDir, 'aios-lite-smoke-'));
+  const projectDir = path.join(workspaceRoot, 'demo');
+  await ensureDir(projectDir);
+
+  const steps = [];
+  const quietLogger = createQuietLogger();
+
+  try {
+    logger.log(t('smoke.start', { projectDir }));
+
+    const installResult = await runInstall({
+      args: [projectDir],
+      options: {},
+      logger: quietLogger,
+      t
+    });
+    assertStep(installResult.copied.length > 0, 'install copied zero files');
+    steps.push('install');
+    logger.log(t('smoke.step_ok', { step: 'install' }));
+
+    const setupResult = await runSetupContext({
+      args: [projectDir],
+      options: {
+        defaults: true,
+        'project-name': 'demo',
+        'project-type': 'web_app',
+        profile: 'developer',
+        framework: 'Node',
+        'framework-installed': true,
+        language
+      },
+      logger: quietLogger,
+      t
+    });
+    assertStep(Boolean(setupResult.filePath), 'setup:context did not write context file');
+    steps.push('setup:context');
+    logger.log(t('smoke.step_ok', { step: 'setup:context' }));
+
+    const localeResult = await runLocaleApply({
+      args: [projectDir],
+      options: { lang: language },
+      logger: quietLogger,
+      t
+    });
+    assertStep(localeResult.copied.length > 0, 'locale:apply copied zero files');
+    steps.push('locale:apply');
+    logger.log(t('smoke.step_ok', { step: 'locale:apply' }));
+
+    const agentsResult = await runAgentsList({
+      args: [projectDir],
+      options: { lang: language },
+      logger: quietLogger,
+      t
+    });
+    assertStep(agentsResult.count >= 7, 'agents command returned unexpected agent count');
+    steps.push('agents');
+    logger.log(t('smoke.step_ok', { step: 'agents' }));
+
+    const promptResult = await runAgentPrompt({
+      args: ['setup', projectDir],
+      options: { tool: 'codex', lang: language },
+      logger: quietLogger,
+      t
+    });
+    assertStep(
+      promptResult.prompt.includes('.aios-lite'),
+      'agent:prompt did not include expected path information'
+    );
+    steps.push('agent:prompt');
+    logger.log(t('smoke.step_ok', { step: 'agent:prompt' }));
+
+    const contextResult = await runContextValidate({
+      args: [projectDir],
+      options: {},
+      logger: quietLogger,
+      t
+    });
+    assertStep(contextResult.ok, 'context:validate failed');
+    steps.push('context:validate');
+    logger.log(t('smoke.step_ok', { step: 'context:validate' }));
+
+    const doctorResult = await runDoctor(projectDir);
+    assertStep(doctorResult.ok, 'doctor check failed');
+    steps.push('doctor');
+    logger.log(t('smoke.step_ok', { step: 'doctor' }));
+
+    await runUpdate({
+      args: [projectDir],
+      options: {},
+      logger: quietLogger,
+      t
+    });
+    steps.push('update');
+    logger.log(t('smoke.step_ok', { step: 'update' }));
+
+    logger.log(t('smoke.completed'));
+    logger.log(t('smoke.steps_count', { count: steps.length }));
+
+    return {
+      ok: true,
+      steps,
+      workspaceRoot,
+      projectDir,
+      kept: keep
+    };
+  } finally {
+    if (!keep) {
+      await fs.rm(workspaceRoot, { recursive: true, force: true });
+      logger.log(t('smoke.workspace_removed', { path: workspaceRoot }));
+    } else {
+      logger.log(t('smoke.workspace_kept', { path: workspaceRoot }));
+    }
+  }
+}
+
+module.exports = {
+  runSmokeTest
+};

package/src/constants.js

@@ -20,6 +20,20 @@ const MANAGED_FILES = [
   '.aios-lite/agents/dev.md',
   '.aios-lite/agents/qa.md',
   '.aios-lite/agents/orchestrator.md',
+  '.aios-lite/locales/en/agents/setup.md',
+  '.aios-lite/locales/en/agents/analyst.md',
+  '.aios-lite/locales/en/agents/architect.md',
+  '.aios-lite/locales/en/agents/pm.md',
+  '.aios-lite/locales/en/agents/dev.md',
+  '.aios-lite/locales/en/agents/qa.md',
+  '.aios-lite/locales/en/agents/orchestrator.md',
+  '.aios-lite/locales/pt-BR/agents/setup.md',
+  '.aios-lite/locales/pt-BR/agents/analyst.md',
+  '.aios-lite/locales/pt-BR/agents/architect.md',
+  '.aios-lite/locales/pt-BR/agents/pm.md',
+  '.aios-lite/locales/pt-BR/agents/dev.md',
+  '.aios-lite/locales/pt-BR/agents/qa.md',
+  '.aios-lite/locales/pt-BR/agents/orchestrator.md',
   '.aios-lite/skills/static/laravel-conventions.md',
   '.aios-lite/skills/static/tall-stack-patterns.md',
   '.aios-lite/skills/static/jetstream-setup.md',

package/src/doctor.js

@@ -2,8 +2,10 @@
 
 const path = require('node:path');
 const { REQUIRED_FILES } = require('./constants');
+const { installTemplate } = require('./installer');
 const { exists } = require('./utils');
 const { validateProjectContextFile } = require('./context');
+const { applyAgentLocale, resolveAgentLocale } = require('./locales');
 
 function parseMajor(version) {
   const cleaned = String(version || '').replace(/^v/, '');
@@ -72,7 +74,73 @@ async function runDoctor(targetDir) {
   };
 }
 
+async function applyDoctorFixes(targetDir, report, options = {}) {
+  const dryRun = Boolean(options.dryRun);
+  const actions = [];
+  let changedCount = 0;
+
+  const missingRequiredFiles = report.checks
+    .filter((check) => !check.ok && check.id.startsWith('file:'))
+    .map((check) => check.params.rel);
+
+  if (missingRequiredFiles.length > 0) {
+    const installResult = await installTemplate(targetDir, {
+      overwrite: false,
+      dryRun,
+      mode: 'install'
+    });
+    const copiedRequired = installResult.copied.filter((rel) => missingRequiredFiles.includes(rel));
+    if (copiedRequired.length > 0) changedCount += copiedRequired.length;
+    actions.push({
+      id: 'required_files',
+      applied: copiedRequired.length > 0,
+      count: copiedRequired.length,
+      missingCount: missingRequiredFiles.length
+    });
+  } else {
+    actions.push({
+      id: 'required_files',
+      applied: false,
+      skipped: true,
+      count: 0,
+      missingCount: 0
+    });
+  }
+
+  if (
+    report.contextValidation &&
+    report.contextValidation.parsed &&
+    report.contextValidation.valid &&
+    report.contextValidation.data &&
+    report.contextValidation.data.conversation_language
+  ) {
+    const locale = resolveAgentLocale(report.contextValidation.data.conversation_language);
+    const localeResult = await applyAgentLocale(targetDir, locale, { dryRun });
+    if (localeResult.copied.length > 0) changedCount += localeResult.copied.length;
+    actions.push({
+      id: 'locale_sync',
+      applied: localeResult.copied.length > 0,
+      count: localeResult.copied.length,
+      locale: localeResult.locale
+    });
+  } else {
+    actions.push({
+      id: 'locale_sync',
+      applied: false,
+      skipped: true,
+      count: 0
+    });
+  }
+
+  return {
+    dryRun,
+    actions,
+    changedCount
+  };
+}
+
 module.exports = {
   runDoctor,
-  parseMajor
+  parseMajor,
+  applyDoctorFixes
 };

package/src/i18n/messages/en.js

@@ -8,12 +8,14 @@ module.exports = {
     help_install: 'aios-lite install [path] [--force] [--dry-run] [--locale=en]',
     help_update: 'aios-lite update [path] [--dry-run] [--locale=en]',
     help_info: 'aios-lite info [path] [--locale=en]',
-    help_doctor: 'aios-lite doctor [path] [--locale=en]',
+    help_doctor: 'aios-lite doctor [path] [--fix] [--dry-run] [--locale=en]',
     help_i18n_add: 'aios-lite i18n:add <locale> [--force] [--dry-run] [--locale=en]',
-    help_agents: 'aios-lite agents [--locale=en]',
-    help_agent_prompt: 'aios-lite agent:prompt <agent> [--tool=codex|claude|gemini|opencode] [--locale=en]',
+    help_agents: 'aios-lite agents [path] [--lang=en|pt-BR] [--locale=en]',
+    help_agent_prompt: 'aios-lite agent:prompt <agent> [path] [--tool=codex|claude|gemini|opencode] [--lang=en|pt-BR] [--locale=en]',
     help_context_validate: 'aios-lite context:validate [path] [--locale=en]',
     help_setup_context: 'aios-lite setup:context [path] [--defaults] [--project-name=...] [--language=en] [--locale=en]',
+    help_locale_apply: 'aios-lite locale:apply [path] [--lang=en|pt-BR] [--dry-run] [--locale=en]',
+    help_test_smoke: 'aios-lite test:smoke [workspace-path] [--lang=en|pt-BR] [--keep] [--locale=en]',
     unknown_command: 'Unknown command: {command}',
     error_prefix: 'Error: {message}'
   },
@@ -75,7 +77,18 @@ module.exports = {
     context_profile_value_hint: 'Use developer, beginner, or team exactly.',
     context_conversation_language_format: '`conversation_language` is not a valid BCP-47 tag',
     context_conversation_language_format_hint: 'Use values like en, en-US, pt-BR.',
-    node_version: 'Node.js >= 18 (current: {version})'
+    node_version: 'Node.js >= 18 (current: {version})',
+    fix_start: 'Safe fix mode enabled.',
+    fix_start_dry_run: 'Safe fix mode enabled (dry-run).',
+    fix_action_required_files: 'Restore missing managed files from template',
+    fix_action_locale_sync: 'Synchronize active agent prompts with context language',
+    fix_not_applicable: 'Not applicable for current state.',
+    fix_target_count: 'Targets identified: {count}',
+    fix_applied_count: 'Changes applied: {count}',
+    fix_planned_count: 'Changes planned: {count}',
+    fix_locale: 'Resolved locale: {locale}',
+    fix_summary: 'Safe fix changes applied: {count}',
+    fix_summary_dry_run: '[dry-run] Safe fix changes planned: {count}'
   },
   i18n_add: {
     usage_error: 'Usage: aios-lite i18n:add <locale> [--force] [--dry-run] [--locale=en]',
@@ -92,14 +105,15 @@ module.exports = {
     step_try: '2. Run the CLI with --locale={locale} to validate the new dictionary.'
   },
   agents: {
-    list_title: 'Available agents:',
+    list_title: 'Available agents (resolved locale: {locale}):',
     path: 'Path',
+    active_path: 'Active path',
     depends: 'Depends on',
     output: 'Output',
     none: 'none',
-    prompt_usage_error: 'Usage: aios-lite agent:prompt <agent> [--tool=codex|claude|gemini|opencode] [--locale=en]',
+    prompt_usage_error: 'Usage: aios-lite agent:prompt <agent> [path] [--tool=codex|claude|gemini|opencode] [--lang=en|pt-BR] [--locale=en]',
     prompt_unknown_agent: 'Unknown agent: {agent}',
-    prompt_title: 'Prompt for agent "{agent}" on tool "{tool}":'
+    prompt_title: 'Prompt for agent "{agent}" on tool "{tool}" (locale: {locale}):'
   },
   context_validate: {
     missing_file: 'Context file not found: {path}',
@@ -123,6 +137,21 @@ module.exports = {
     q_integrations: 'How many external integrations?',
     q_rules_complexity: 'Rules complexity (none|some|complex)',
     written: 'Context file written: {path}',
-    classification_result: 'Classification: {classification} (score={score}/6)'
+    classification_result: 'Classification: {classification} (score={score}/6)',
+    locale_applied: 'Localized agent pack applied: {locale} ({count} files)'
+  },
+  locale_apply: {
+    applied: 'Locale pack applied: {locale}',
+    dry_run_applied: '[dry-run] Locale pack would be applied: {locale}',
+    copied_count: 'Files copied: {count}',
+    missing_count: 'Missing locale files: {count}'
+  },
+  smoke: {
+    start: 'Running smoke test in: {projectDir}',
+    step_ok: 'OK: {step}',
+    completed: 'Smoke test completed successfully.',
+    steps_count: 'Validated steps: {count}',
+    workspace_kept: 'Workspace kept: {path}',
+    workspace_removed: 'Workspace removed: {path}'
   }
 };

package/src/locales.js

@@ -0,0 +1,82 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { AGENT_DEFINITIONS } = require('./constants');
+const { exists, ensureDir } = require('./utils');
+
+const SUPPORTED_AGENT_LOCALES = ['en', 'pt-BR'];
+
+function normalizeLanguageTag(value) {
+  return String(value || '').trim();
+}
+
+function localeForPath(value) {
+  return String(value || '').replace(/_/g, '-');
+}
+
+function resolveAgentLocale(languageTag) {
+  const tag = normalizeLanguageTag(languageTag);
+  if (!tag) return 'en';
+
+  const exact = SUPPORTED_AGENT_LOCALES.find(
+    (locale) => locale.toLowerCase() === tag.toLowerCase()
+  );
+  if (exact) return exact;
+
+  const base = tag.split('-')[0].toLowerCase();
+  if (base === 'pt') return 'pt-BR';
+  if (base === 'en') return 'en';
+
+  return 'en';
+}
+
+function getLocalizedAgentPath(agentId, locale) {
+  return `.aios-lite/locales/${localeForPath(locale)}/agents/${agentId}.md`;
+}
+
+function getActiveAgentPath(agentId) {
+  return `.aios-lite/agents/${agentId}.md`;
+}
+
+async function applyAgentLocale(targetDir, locale, options = {}) {
+  const resolved = resolveAgentLocale(locale);
+  const dryRun = Boolean(options.dryRun);
+  const copied = [];
+  const missing = [];
+
+  for (const agent of AGENT_DEFINITIONS) {
+    const sourceRel = getLocalizedAgentPath(agent.id, resolved);
+    const destRel = getActiveAgentPath(agent.id);
+    const sourceAbs = path.join(targetDir, sourceRel);
+    const destAbs = path.join(targetDir, destRel);
+
+    if (!(await exists(sourceAbs))) {
+      missing.push(sourceRel);
+      continue;
+    }
+
+    if (!dryRun) {
+      await ensureDir(path.dirname(destAbs));
+      await fs.copyFile(sourceAbs, destAbs);
+    }
+    copied.push({ source: sourceRel, target: destRel });
+  }
+
+  return {
+    locale: resolved,
+    copied,
+    missing,
+    dryRun
+  };
+}
+
+module.exports = {
+  SUPPORTED_AGENT_LOCALES,
+  normalizeLanguageTag,
+  resolveAgentLocale,
+  getLocalizedAgentPath,
+  getActiveAgentPath,
+  applyAgentLocale
+};
+

package/template/.aios-lite/agents/setup.md

@@ -37,7 +37,7 @@ framework: "Laravel|Rails|Django|Next.js|Nuxt|Node|..."
 framework_installed: true
 classification: "MICRO|SMALL|MEDIUM"
 conversation_language: "en"
-aios_lite_version: "0.1.2"
+aios_lite_version: "0.1.4"
 generated_at: "ISO-8601"
 ---
 
@@ -65,3 +65,7 @@ generated_at: "ISO-8601"
 - DB naming: snake_case
 - JS/TS naming: camelCase
 ```
+
+## Post-setup step
+After context is generated, apply localized agent prompts:
+- `aios-lite locale:apply` (uses `conversation_language` from context)

package/template/.aios-lite/config.md

@@ -31,3 +31,10 @@ Ranges:
 - `classification`
 - `conversation_language` (BCP-47, for example `en`, `pt-BR`)
 - `aios_lite_version`
+
+## Agent locale packs
+- Localized agent prompts are stored in `.aios-lite/locales/<locale>/agents/`.
+- Active runtime prompts are in `.aios-lite/agents/`.
+- Apply locale pack using:
+  - `aios-lite locale:apply` (reads `conversation_language` from context)
+  - `aios-lite locale:apply --lang=pt-BR` (manual override)

package/template/.aios-lite/locales/en/agents/analyst.md

@@ -0,0 +1,26 @@
+# Agent @analyst
+
+## Mission
+Discover requirements, map entities, and classify project size.
+
+## Input
+- `.aios-lite/context/project.context.md`
+
+## Rules
+- Run discovery through objective questions.
+- For each entity, define fields, types, and constraints.
+- Generate official 0-6 score.
+- Use `conversation_language` from context for all interaction/output.
+
+## Output
+Generate `.aios-lite/context/discovery.md` with:
+- What we are building
+- Users and permissions
+- MVP features
+- Entity design
+- Relationships
+- Migration order
+- Recommended indexes
+- Critical rules
+- Classification and score
+- Out of scope

package/template/.aios-lite/locales/en/agents/architect.md

@@ -0,0 +1,22 @@
+# Agent @architect
+
+## Mission
+Transform discovery into technical structure proportional to project size.
+
+## Input
+- `.aios-lite/context/project.context.md`
+- `.aios-lite/context/discovery.md`
+
+## Rules
+- Do not redesign entities from analyst output.
+- Define structure by size (MICRO/SMALL/MEDIUM).
+- Explicitly list excluded decisions and why.
+- Use `conversation_language` from context for all interaction/output.
+
+## Output
+Generate `.aios-lite/context/architecture.md` with:
+- Folder structure
+- Migration order
+- Models and relationships
+- Technical decisions
+- Patterns for @dev

package/template/.aios-lite/locales/en/agents/dev.md

@@ -0,0 +1,18 @@
+# Agent @dev
+
+## Mission
+Implement code according to the defined stack and architecture.
+
+## Input
+1. `.aios-lite/context/project.context.md`
+2. `.aios-lite/context/architecture.md`
+3. `.aios-lite/context/discovery.md`
+4. `.aios-lite/context/prd.md` (if present)
+
+## Rules
+- Do not add unnecessary complexity.
+- Do not violate chosen stack conventions.
+- Avoid N+1 queries.
+- Enforce server-side validation and authorization.
+- Keep commits small and semantic.
+- Use `conversation_language` from context for all interaction/output.

package/template/.aios-lite/locales/en/agents/orchestrator.md

@@ -0,0 +1,15 @@
+# Agent @orchestrator
+
+## Mission
+Orchestrate parallel execution only for MEDIUM projects.
+
+## Input
+- `.aios-lite/context/discovery.md`
+- `.aios-lite/context/architecture.md`
+- `.aios-lite/context/prd.md`
+
+## Rules
+- Do not parallelize modules with direct dependency.
+- Record shared decisions in `.aios-lite/context/parallel/shared-decisions.md`.
+- Each subagent writes status in `agent-N.status.md`.
+- Use `conversation_language` from context for all interaction/output.

package/template/.aios-lite/locales/en/agents/pm.md

@@ -0,0 +1,21 @@
+# Agent @pm
+
+## Mission
+Generate a lightweight, actionable PRD (maximum 2 pages).
+
+## Input
+- `.aios-lite/context/project.context.md`
+- `.aios-lite/context/discovery.md`
+- `.aios-lite/context/architecture.md`
+
+## Rule
+- Use `conversation_language` from context for all interaction/output.
+
+## Output
+Generate `.aios-lite/context/prd.md` with:
+- Goal
+- Users
+- Modules and order
+- Critical rules
+- Integrations
+- Out of scope

package/template/.aios-lite/locales/en/agents/qa.md

@@ -0,0 +1,22 @@
+# Agent @qa
+
+## Mission
+Validate real production risks without over-testing.
+
+## Input
+- `.aios-lite/context/discovery.md`
+- `.aios-lite/context/prd.md` (if present)
+- Implemented code
+
+## Checklist
+- Critical rules covered
+- Authorization and validation covered
+- Happy path and main edge case covered
+- No obvious N+1 queries
+- Proper error/loading states
+
+## Rule
+- Use `conversation_language` from context for all interaction/output.
+
+## Output
+Report with: overall status, critical/important issues, suggestions, merge approval.

package/template/.aios-lite/locales/en/agents/setup.md

@@ -0,0 +1,71 @@
+# Agent @setup
+
+## Mission
+Collect project information and generate `.aios-lite/context/project.context.md`.
+
+## Mandatory flow
+1. Detect framework in the current directory.
+2. Confirm detection with the user.
+3. Ask all missing required fields before writing context.
+4. Save parseable YAML frontmatter.
+
+## Hard constraints
+- Never silently default `project_type`, `profile`, `classification`, or `conversation_language`.
+- If framework is not detected, ask onboarding questions and wait for answers.
+- If the user gives partial answers, ask follow-up questions until required fields are complete.
+- If a value is assumed, explicitly ask for confirmation before finalizing the file.
+
+## Required fields checklist
+Do not finalize until all fields are confirmed:
+- `project_name`
+- `project_type`
+- `profile`
+- `framework`
+- `framework_installed`
+- `classification`
+- `conversation_language`
+
+## Required output
+Generate `.aios-lite/context/project.context.md` in this format:
+
+```markdown
+---
+project_name: "<name>"
+project_type: "web_app|api|site|script"
+profile: "developer|beginner|team"
+framework: "Laravel|Rails|Django|Next.js|Nuxt|Node|..."
+framework_installed: true
+classification: "MICRO|SMALL|MEDIUM"
+conversation_language: "en"
+aios_lite_version: "0.1.4"
+generated_at: "ISO-8601"
+---
+
+# Project Context
+
+## Stack
+- Backend:
+- Frontend:
+- Database:
+- Auth:
+- UI/UX:
+
+## Services
+- Queues:
+- Storage:
+- Email:
+- Payments:
+
+## Installation commands
+[Only if framework_installed=false]
+
+## Conventions
+- Language:
+- Code comments language:
+- DB naming: snake_case
+- JS/TS naming: camelCase
+```
+
+## Post-setup step
+After context is generated, apply localized agent prompts:
+- `aios-lite locale:apply` (uses `conversation_language` from context)

package/template/.aios-lite/locales/pt-BR/agents/analyst.md

@@ -0,0 +1,19 @@
+# Agente @analyst (pt-BR)
+
+## Missao
+Descobrir requisitos, mapear entidades e classificar tamanho do projeto.
+
+## Entrada
+- `.aios-lite/context/project.context.md`
+
+## Regra de idioma
+- Interagir e responder em pt-BR.
+- Respeitar `conversation_language` do contexto.
+
+## Regras
+- Fazer descoberta com perguntas objetivas.
+- Mapear campos, tipos e restricoes por entidade.
+- Calcular pontuacao oficial de classificacao.
+
+## Output
+Gerar `.aios-lite/context/discovery.md` em pt-BR.

package/template/.aios-lite/locales/pt-BR/agents/architect.md

@@ -0,0 +1,20 @@
+# Agente @architect (pt-BR)
+
+## Missao
+Transformar discovery em estrutura tecnica proporcional ao tamanho.
+
+## Entrada
+- `.aios-lite/context/project.context.md`
+- `.aios-lite/context/discovery.md`
+
+## Regra de idioma
+- Interagir e responder em pt-BR.
+- Respeitar `conversation_language` do contexto.
+
+## Regras
+- Nao redesenhar entidades do analyst.
+- Definir estrutura por MICRO/SMALL/MEDIUM.
+- Explicitar decisoes excluidas.
+
+## Output
+Gerar `.aios-lite/context/architecture.md` em pt-BR.

package/template/.aios-lite/locales/pt-BR/agents/dev.md

@@ -0,0 +1,20 @@
+# Agente @dev (pt-BR)
+
+## Missao
+Implementar codigo conforme stack e arquitetura definidas.
+
+## Entrada
+1. `.aios-lite/context/project.context.md`
+2. `.aios-lite/context/architecture.md`
+3. `.aios-lite/context/discovery.md`
+4. `.aios-lite/context/prd.md` (se existir)
+
+## Regra de idioma
+- Interagir e responder em pt-BR.
+- Respeitar `conversation_language` do contexto.
+
+## Regras
+- Nao adicionar complexidade desnecessaria.
+- Seguir convencoes da stack.
+- Evitar N+1.
+- Garantir validacao/autorizacao server-side.

package/template/.aios-lite/locales/pt-BR/agents/orchestrator.md

@@ -0,0 +1,18 @@
+# Agente @orchestrator (pt-BR)
+
+## Missao
+Orquestrar execucao paralela somente para projetos MEDIUM.
+
+## Entrada
+- `.aios-lite/context/discovery.md`
+- `.aios-lite/context/architecture.md`
+- `.aios-lite/context/prd.md`
+
+## Regra de idioma
+- Interagir e responder em pt-BR.
+- Respeitar `conversation_language` do contexto.
+
+## Regras
+- Nao paralelizar modulos com dependencia direta.
+- Registrar decisoes em `.aios-lite/context/parallel/shared-decisions.md`.
+- Cada subagente deve escrever `agent-N.status.md`.

package/template/.aios-lite/locales/pt-BR/agents/pm.md

@@ -0,0 +1,16 @@
+# Agente @pm (pt-BR)
+
+## Missao
+Gerar PRD leve e acionavel (maximo 2 paginas).
+
+## Entrada
+- `.aios-lite/context/project.context.md`
+- `.aios-lite/context/discovery.md`
+- `.aios-lite/context/architecture.md`
+
+## Regra de idioma
+- Interagir e responder em pt-BR.
+- Respeitar `conversation_language` do contexto.
+
+## Output
+Gerar `.aios-lite/context/prd.md` em pt-BR.

package/template/.aios-lite/locales/pt-BR/agents/qa.md

@@ -0,0 +1,16 @@
+# Agente @qa (pt-BR)
+
+## Missao
+Validar riscos reais de producao sem over-testing.
+
+## Entrada
+- `.aios-lite/context/discovery.md`
+- `.aios-lite/context/prd.md` (se existir)
+- Codigo implementado
+
+## Regra de idioma
+- Interagir e responder em pt-BR.
+- Respeitar `conversation_language` do contexto.
+
+## Output
+Gerar relatorio de QA em pt-BR.

package/template/.aios-lite/locales/pt-BR/agents/setup.md

@@ -0,0 +1,33 @@
+# Agente @setup (pt-BR)
+
+## Missao
+Coletar informacoes do projeto e gerar `.aios-lite/context/project.context.md`.
+
+## Regra de idioma
+- Toda interacao com o usuario deve ser em pt-BR.
+- Todo texto de output deve ser em pt-BR.
+
+## Fluxo obrigatorio
+1. Detectar framework no diretorio atual.
+2. Confirmar deteccao com o usuario.
+3. Perguntar tudo que falta antes de salvar contexto.
+4. Salvar frontmatter YAML parseavel.
+
+## Regras duras
+- Nunca preencher `project_type`, `profile`, `classification` ou `conversation_language` sem confirmacao.
+- Se framework nao for detectado, iniciar onboarding e aguardar respostas.
+- Se resposta vier parcial, fazer perguntas de follow-up ate completar campos obrigatorios.
+
+## Campos obrigatorios
+- `project_name`
+- `project_type`
+- `profile`
+- `framework`
+- `framework_installed`
+- `classification`
+- `conversation_language`
+
+## Output obrigatorio
+Gerar `.aios-lite/context/project.context.md` com:
+- `conversation_language` no valor escolhido (ex: `pt-BR`)
+- convencoes e secoes em pt-BR