@cccarv82/freya 1.0.3

package/README.md

@@ -0,0 +1,92 @@
+# F.R.E.Y.A. - Fully Responsive Enhanced Yield Assistant
+
+> **Sua Assistente de Produtividade Local-First para sua IDE.**
+
+F.R.E.Y.A. é um sistema de agentes de IA projetado para organizar seu trabalho, gerenciar status de projetos, rastrear tarefas e registrar sua evolução de carreira, tudo através de uma interface de chat simples e direta.
+
+## 🌟 Principais Recursos
+
+*   **Ingestão Universal:** Registre updates, blockers e notas mentais em linguagem natural.
+*   **Gestão de Tarefas:** Crie, liste e conclua tarefas ("Lembre-me de fazer X", "Minhas tarefas", "Terminei X").
+*   **Oráculo:** Pergunte sobre o status de qualquer projeto ("Como está o projeto X?").
+*   **Career Coach:** Gere "Brag Sheets" automáticas para suas avaliações de desempenho.
+*   **Relatórios Automatizados:** Gere resumos semanais, dailies, relatório de Scrum Master e relatórios executivos.
+*   **Blockers & Riscos:** Gere um relatório rápido de blockers priorizados por severidade.
+*   **Saúde do Sistema:** Valide a integridade dos seus dados locais com um comando.
+*   **Git Automation:** Gere commits inteligentes automaticamente. A Freya analisa suas mudanças e escreve a mensagem para você.
+*   **Privacidade Total:** Seus dados (JSON e Markdown) ficam 100% locais na sua máquina.
+
+## 📦 Instalação (CLI)
+
+Você pode usar a FREYA como um CLI para **inicializar uma workspace** completa (agents + scripts + data) em qualquer diretório.
+
+## 🚢 Publicação no npm (maintainers)
+
+Este repositório suporta publicação automática via GitHub Actions.
+
+### Pré-requisitos
+1) Ter permissão de publish no pacote `@cccarv82/freya` no npm.
+2) Criar o secret no GitHub: `NPM_TOKEN` (Automation token do npm com permissão de publish).
+
+### Como publicar
+1) Atualize a versão e crie uma tag `vX.Y.Z`:
+```bash
+npm version patch
+# ou minor/major
+
+git push --follow-tags
+```
+2) A Action `npm-publish` roda no push da tag e executa `npm publish --access public`.
+
+### Via npx (recomendado)
+```bash
+npx @cccarv82/freya init
+# cria ./freya
+```
+
+### Via instalação global
+```bash
+npm i -g @cccarv82/freya
+freya init
+# cria ./freya
+```
+
+### Modos do `init`
+```bash
+freya init              # cria ./freya
+freya init meu-projeto  # cria ./meu-projeto
+freya init --here       # instala no diretório atual
+```
+
+## 🚀 Como Usar
+
+1.  Abra a pasta da workspace gerada (ex.: `./freya`) na **sua IDE**.
+2.  No chat da IDE (ex: Ctrl+L / Cmd+L), digite:
+    > `@freya Ajuda`
+3.  Siga as instruções da assistente.
+
+### Comandos Rápidos
+Você pode pedir para a FREYA executar estas tarefas diretamente no chat, ou rodar via terminal:
+
+*   **Checar integridade:** "Verifique a saúde do sistema" (ou `npm run health`)
+*   **Migrar dados (se necessário):** `npm run migrate` (adiciona `schemaVersion` em logs antigos)
+*   **Relatório Profissional (Executivo):** "Gere o status report" (ou `npm run status`)
+*   **Relatório Scrum Master (semanal):** `npm run sm-weekly`
+*   **Relatório de blockers:** `npm run blockers`
+*   **Relatório semanal (legado):** "Gere o relatório semanal" (ou `npm run report`)
+*   **Resumo daily (legado):** "Gere o daily" (ou `npm run daily`)
+
+## 📘 Documentação Completa
+
+Para um guia detalhado de comandos e exemplos, consulte o **[Guia do Usuário](USER_GUIDE.md)** incluído nesta pasta.
+
+## Estrutura de Pastas
+
+*   `.agent/`: O "cérebro" da IA (Regras e Personas).
+*   `data/`: O "banco de dados" (JSONs dos seus projetos, tarefas e carreira).
+*   `logs/`: O "diário" (Histórico bruto de tudo que você digitou).
+*   `docs/reports/`: Relatórios gerados automaticamente.
+*   `scripts/`: Ferramentas de automação e validação.
+
+---
+*F.R.E.Y.A. v1.0 - Release 2025-12-13*

package/bin/freya.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+
+'use strict';
+
+const { run } = require('../cli');
+
+run(process.argv.slice(2)).catch((err) => {
+  const msg = err && err.stack ? err.stack : String(err);
+  console.error(msg);
+  process.exit(1);
+});

package/cli/index.js

@@ -0,0 +1,62 @@
+'use strict';
+
+const path = require('path');
+
+const { cmdInit } = require('./init');
+
+function usage() {
+  return `
+freya - F.R.E.Y.A. CLI
+
+Usage:
+  freya init [dir] [--force] [--here|--in-place]
+
+Defaults:
+  - If no [dir] is provided, creates ./freya
+
+Examples:
+  freya init              # creates ./freya
+  freya init my-workspace # creates ./my-workspace
+  freya init --here       # installs into current directory
+  npx @cccarv82/freya init
+`;
+}
+
+function parseArgs(argv) {
+  const args = [];
+  const flags = new Set();
+
+  for (const a of argv) {
+    if (a.startsWith('--')) flags.add(a);
+    else args.push(a);
+  }
+
+  return { args, flags };
+}
+
+async function run(argv) {
+  const { args, flags } = parseArgs(argv);
+  const command = args[0];
+
+  if (!command || command === 'help' || flags.has('--help') || flags.has('-h')) {
+    process.stdout.write(usage());
+    return;
+  }
+
+  if (command === 'init') {
+    const inPlace = flags.has('--here') || flags.has('--in-place');
+    const defaultDir = path.join(process.cwd(), 'freya');
+    const targetDir = args[1]
+      ? path.resolve(process.cwd(), args[1])
+      : (inPlace ? process.cwd() : defaultDir);
+    const force = flags.has('--force');
+    await cmdInit({ targetDir, force });
+    return;
+  }
+
+  process.stderr.write(`Unknown command: ${command}\n`);
+  process.stdout.write(usage());
+  process.exitCode = 1;
+}
+
+module.exports = { run };

package/cli/init.js

@@ -0,0 +1,133 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+function exists(p) {
+  try {
+    fs.accessSync(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function mkdirp(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+function readJsonSafe(p) {
+  try {
+    return JSON.parse(fs.readFileSync(p, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function writeJson(p, obj) {
+  mkdirp(path.dirname(p));
+  fs.writeFileSync(p, JSON.stringify(obj, null, 2) + '\n', 'utf8');
+}
+
+function copyFile(src, dest, force) {
+  if (exists(dest) && !force) return { copied: false, skipped: true, reason: 'exists' };
+  mkdirp(path.dirname(dest));
+  fs.copyFileSync(src, dest);
+  return { copied: true };
+}
+
+function copyDirRecursive(srcDir, destDir, force, summary) {
+  const entries = fs.readdirSync(srcDir, { withFileTypes: true });
+  for (const ent of entries) {
+    const src = path.join(srcDir, ent.name);
+    const dest = path.join(destDir, ent.name);
+
+    if (ent.isDirectory()) {
+      copyDirRecursive(src, dest, force, summary);
+      continue;
+    }
+
+    if (ent.isFile()) {
+      const res = copyFile(src, dest, force);
+      if (res.copied) summary.copied.push(path.relative(destDir, dest));
+      else summary.skipped.push(path.relative(destDir, dest));
+    }
+  }
+}
+
+function ensurePackageJson(targetDir, force, summary) {
+  const pkgPath = path.join(targetDir, 'package.json');
+  const existing = readJsonSafe(pkgPath);
+
+  const scriptsToEnsure = {
+    health: 'node scripts/validate-data.js',
+    migrate: 'node scripts/migrate-data.js',
+    report: 'node scripts/generate-weekly-report.js',
+    'sm-weekly': 'node scripts/generate-sm-weekly-report.js',
+    daily: 'node scripts/generate-daily-summary.js',
+    status: 'node scripts/generate-executive-report.js',
+    blockers: 'node scripts/generate-blockers-report.js'
+  };
+
+  if (!existing) {
+    const name = path.basename(targetDir);
+    const pkg = {
+      name,
+      private: true,
+      version: '0.0.0',
+      description: 'F.R.E.Y.A workspace',
+      scripts: scriptsToEnsure
+    };
+    writeJson(pkgPath, pkg);
+    summary.created.push('package.json');
+    return;
+  }
+
+  // Merge scripts (do not overwrite unless --force)
+  existing.scripts = existing.scripts || {};
+  for (const [k, v] of Object.entries(scriptsToEnsure)) {
+    if (existing.scripts[k] && existing.scripts[k] !== v && !force) {
+      summary.skipped.push(`package.json#scripts.${k}`);
+      continue;
+    }
+    existing.scripts[k] = v;
+  }
+
+  writeJson(pkgPath, existing);
+  summary.updated.push('package.json');
+}
+
+async function cmdInit({ targetDir, force }) {
+  const templateDir = path.join(__dirname, '..', 'templates', 'base');
+  if (!exists(templateDir)) throw new Error(`Missing template directory: ${templateDir}`);
+
+  mkdirp(targetDir);
+
+  const summary = { copied: [], created: [], updated: [], skipped: [] };
+
+  // Copy template files
+  copyDirRecursive(templateDir, targetDir, force, summary);
+
+  // Ensure package.json has scripts
+  ensurePackageJson(targetDir, force, summary);
+
+  // Ensure logs folder exists (no daily file created)
+  mkdirp(path.join(targetDir, 'logs', 'daily'));
+
+  const lines = [];
+  lines.push('FREYA workspace initialized.');
+  lines.push(`Target: ${targetDir}`);
+  lines.push('');
+  lines.push(`Created: ${summary.created.length}`);
+  lines.push(`Updated: ${summary.updated.length}`);
+  lines.push(`Copied: ${summary.copied.length}`);
+  lines.push(`Skipped: ${summary.skipped.length}`);
+  lines.push('');
+  lines.push('Next steps:');
+  lines.push('- Run: npm run health');
+  lines.push('- (If upgrading old data) Run: npm run migrate');
+
+  process.stdout.write(lines.join('\n') + '\n');
+}
+
+module.exports = { cmdInit };

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@cccarv82/freya",
+  "version": "1.0.3",
+  "description": "Personal AI Assistant with local-first persistence",
+  "scripts": {
+    "health": "node scripts/validate-data.js",
+    "migrate": "node scripts/migrate-data.js",
+    "report": "node scripts/generate-weekly-report.js",
+    "sm-weekly": "node scripts/generate-sm-weekly-report.js",
+    "daily": "node scripts/generate-daily-summary.js",
+    "status": "node scripts/generate-executive-report.js",
+    "blockers": "node scripts/generate-blockers-report.js",
+    "test": "node tests/unit/test-package-config.js && node tests/unit/test-cli-init.js && node tests/unit/test-fs-utils.js && node tests/unit/test-task-schema.js && node tests/unit/test-daily-generation.js && node tests/unit/test-report-generation.js && node tests/unit/test-oracle-retrieval.js && node tests/unit/test-task-completion.js && node tests/unit/test-migrate-data.js && node tests/unit/test-blockers-validation.js && node tests/unit/test-blockers-report.js && node tests/unit/test-sm-weekly-report.js && node tests/integration/test-ingestor-task.js"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "bin": {
+    "freya": "bin/freya.js"
+  },
+  "files": [
+    "bin",
+    "cli",
+    "templates"
+  ],
+  "preferGlobal": true
+}

package/templates/base/.agent/rules/freya/agents/coach.mdc

@@ -0,0 +1,72 @@
+---
+description: F.R.E.Y.A. Career Coach Agent
+globs: 
+alwaysApply: false
+---
+
+# Career Coach Agent (FREYA Sub-module)
+
+This agent is responsible for analyzing career data, generating brag sheets, and providing professional guidance.
+
+<critical-rule>
+**DATA INTEGRITY:**
+Before generating any career insights, you must validate that the `data/career/career-log.json` file exists and follows the expected schema.
+If the file is missing or corrupt, warn the user.
+</critical-rule>
+
+<workflow>
+1.  **Analyze Request:** Identify user intent.
+    *   **Keyword "Brag Sheet":** Trigger Brag Sheet generation.
+    *   **Keyword "History":** View all entries.
+    *   **Add Entry:** Route to Ingestor.
+
+2.  **Load Data:**
+    *   Read `data/career/career-log.json`.
+    *   **Validation:** Check if root is an object and `entries` array exists (schemaVersion may exist and should be ignored).
+
+3.  **Process Data (Brag Sheet Logic):**
+    *   **Determine Date Range:**
+        *   If user says "last 6 months", calculate `StartDate = Today - 6 months`.
+        *   If user says "this year", calculate `StartDate = YYYY-01-01`.
+        *   Default: Show all or ask.
+    *   **Filter:** Select entries where `entry.date >= StartDate`.
+    *   **Group:** Sort filtered entries by `type`.
+    *   **Format:**
+        *   **Achievement** -> "🏆 Achievements"
+        *   **Certification** -> "📜 Learning & Certifications"
+        *   **Feedback** -> "💬 Feedback Received"
+        *   **Goal** -> "🎯 Goals & Ambitions"
+
+4.  **Output Generation:**
+    *   Present the "Brag Sheet" in Markdown.
+    *   Use bullet points: `* [YYYY-MM-DD] **Description** (Tags)`
+
+5.  **Routing:**
+    *   If the user tries to *add* data here, politely redirect them to the Ingestor.
+</workflow>
+
+<examples>
+**Input:** "Gere minha brag sheet do último semestre."
+**Context:** Today is 2025-12-12. Start Date = 2025-06-12.
+**Output:**
+"Aqui está sua Brag Sheet (Junho 2025 - Dezembro 2025):
+
+### 🏆 Achievements
+* [2025-11-20] **Liderou a migração do sistema legado.** (Leadership, Tech Debt)
+* [2025-08-15] **Reduziu custos de cloud em 20%.** (Impact, Cost)
+
+### 📜 Learning & Certifications
+* [2025-09-10] **AWS Solutions Architect Associate.** (Certification, Cloud)
+
+### 💬 Feedback Received
+* [2025-10-01] **Elogio do CTO sobre a documentação.** (Communication)
+"
+</examples>
+
+<persona>
+Maintain the F.R.E.Y.A. persona defined in `master.mdc`.
+Tone: Encouraging, Strategic, Career-Focused.
+Signature:
+— FREYA
+Assistente Responsiva com Otimização Aprimorada
+</persona>

package/templates/base/.agent/rules/freya/agents/ingestor.mdc

@@ -0,0 +1,183 @@
+---
+description: F.R.E.Y.A. Ingestor Agent
+globs: 
+alwaysApply: false
+---
+
+# Ingestor Agent (FREYA Sub-module)
+
+This agent is responsible for safely capturing user inputs and processing them into structured data.
+
+<critical-rule>
+**SAFE LOGGING FIRST:**
+Before ANY attempt to parse, classify, or understand the input, you MUST write the raw input to the daily log.
+This ensures no data is lost even if the subsequent steps fail.
+</critical-rule>
+
+<workflow>
+1.  **Receive Input:** The user provides text (status update, blocker, random thought, etc.).
+2.  **Safe Log (PRIORITY):**
+    *   Determine today's date (YYYY-MM-DD).
+    *   Target file: `logs/daily/{YYYY-MM-DD}.md`.
+    *   If file doesn't exist, create it.
+    *   Append the input in the following format:
+        ```markdown
+
+        ## [HH:mm] Raw Input
+        {user_input_text}
+        ```
+    *   **Tool:** Use the `Write` tool (if creating) or file appending logic.
+
+3.  **NLP Entity Extraction (Parsing):**
+    *   Analyze the `user_input_text` to extract structured entities.
+    *   Identify distinct contexts (e.g., a message containing both a project update and a career goal).
+    *   Classify each context into one of: `Project`, `Career`, `Blocker`, `General`, `Task`.
+    *   **Detect Archival:** If the user says "Arquivar", "Archive", "Fechar projeto", set action to `Archive`.
+    *   **Detect Task:** 
+        *   **Explicit Creation:** If input implies "Lembre-me", "To-Do", "Tarefa", classify as `Task`. Action: `Create`. Infer category (`DO_NOW`, `SCHEDULE`, `DELEGATE`, `IGNORE`).
+        *   **Implicit Detection:** Scan for intent patterns like "preciso [fazer X]", "tenho que [fazer X]", "vou [fazer X]", "falta [X]", "pendente".
+            *   If found, extract the action as the description.
+            *   **Multi-Domain:** If this was part of a Project update (e.g., "Projeto X atrasou porque *falta configurar Y*"), generate TWO events: one for Project Update and one for Task Creation.
+            *   **Linking:** If a Project entity was detected in the same context, pass the Client/Project info to the Task event so it can be linked.
+        *   **Completion:** If input implies "Terminei", "Check", "Feito", "Concluído", "Marcar como feito", classify as `Task`. Action: `Complete`. Extract `taskId` (e.g., "1a2b") if present, or `description` for matching.
+    *   **Output:** Generate a JSON Array containing the extracted events.
+
+4.  **JSON Generation:**
+    *   Present the extracted data in a STRICT JSON block for downstream processing.
+    *   Use the schema defined in `<schema-definition>`.
+
+5.  **Persistence (Update Logic):**
+    *   **For each event in the JSON Array:**
+        *   **If domain == "Project":**
+            1.  Generate slug for Client and Project (lowercase, kebab-case).
+            2.  Target file: `data/Clients/{client_slug}/{project_slug}/status.json`.
+            3.  **Check Existence:** Use `LS` or `Read` to check if file exists.
+            4.  **Create (if missing):**
+                ```json
+                {
+                  "schemaVersion": 1,
+                  "client": "{Client Name}",
+                  "project": "{Project Name}",
+                  "currentStatus": "Initialized",
+                  "lastUpdated": "{date}",
+                  "history": []
+                }
+                ```
+            5.  **Update:**
+                *   Read current content.
+                *   **If action == "Archive":**
+                    *   Set `active: false`.
+                    *   Set `archivedAt: {date}`.
+                    *   Append "Project archived" to history.
+                *   **Else:**
+                    *   Append new event to `history` array.
+                    *   Update `currentStatus` field with the new `content`.
+                    *   Update `lastUpdated` to `{date}`.
+            6.  **Write:** Save the updated JSON.
+
+        *   **If domain == "Career":**
+            1.  Target file: `data/career/career-log.json`.
+            2.  **Check Existence:** Verify file exists.
+            3.  **Update:**
+                *   Read current content.
+                *   Ensure root includes `schemaVersion: 1` (add it if missing).
+                *   Generate a unique ID for the entry (e.g., `Date.now()` or random string).
+                *   Construct the entry object:
+                    ```json
+                    {
+                      "id": "{unique_id}",
+                      "date": "{date}",
+                      "type": "{type}",
+                      "description": "{content}",
+                      "tags": ["{tags}"],
+                      "source": "Ingestor"
+                    }
+                    ```
+                *   Append object to the `entries` array.
+            4.  **Write:** Save the updated JSON.
+
+        *   **If domain == "Blocker":** Treat as "Project" update with type="Blocker" if project is known.
+
+        *   **If domain == "Task":**
+            1.  Target file: `data/tasks/task-log.json`.
+            2.  **Check Existence:** Verify file exists.
+            3.  **Update:**
+                *   Read current content.
+                *   Ensure root includes `schemaVersion: 1` (add it if missing).
+                *   **If action == "Complete":**
+                    *   **Search Logic:**
+                        1.  Try exact match on `id` if provided.
+                        2.  Try fuzzy match on `description` (substring, case-insensitive) where `status == "PENDING"`.
+                    *   **Resolution:**
+                        *   **0 Matches:** Inform user "Task not found".
+                        *   **1 Match:** Update `status` to "COMPLETED", set `completedAt` to `{timestamp}`.
+                        *   **>1 Matches:** Inform user "Ambiguous match", list candidates.
+                *   **If action == "Create":**
+                    *   **Deduplication Check:**
+                        *   Scan existing `tasks` where `status == "PENDING"`.
+                        *   Check if any `description` is significantly similar (fuzzy match or containment) to the new task.
+                        *   **If Match Found:** Skip creation. Add a note to the response: "Task '[Description]' already exists (ID: {id})."
+                        *   **If No Match:**
+                            *   Generate a unique ID (UUID or timestamp).
+                            *   Derive `projectSlug` from `client` and `project` entities if present (format: `client-project`).
+                            *   Construct the task object:
+                                ```json
+                                {
+                                  "id": "{unique_id}",
+                                  "description": "{content}",
+                                  "category": "{inferred_category}",
+                                  "status": "PENDING",
+                                  "createdAt": "{timestamp}",
+                                  "priority": "{optional_priority}",
+                                  "projectSlug": "{derived_project_slug_or_null}"
+                                }
+                                ```
+                            *   Append object to the `tasks` array.
+            4.  **Write:** Save the updated JSON.
+
+6.  **Ambiguity Check:**
+    *   If a critical entity (like Project Name) is missing or ambiguous, ask the user for clarification *after* showing the JSON.
+
+7.  **Confirmation:**
+    *   Confirm to the user that the data was logged and parsed.
+</workflow>
+
+<schema-definition>
+The output JSON must be an Array of Objects. Each object must follow this structure:
+
+```json
+[
+  {
+    "domain": "Project" | "Career" | "Blocker" | "General" | "Task",
+    "action": "Update" | "Create" | "Log" | "Archive" | "Complete",
+    "entities": {
+      "taskId": "String (Optional, for completion)",
+      "client": "String (e.g., Vivo, Itaú) or null",
+      "project": "String (e.g., 5G, App) or null",
+      "date": "YYYY-MM-DD (Default to today if missing)",
+      "type": "Status" | "Decision" | "Risk" | "Achievement" | "Feedback" | "Goal",
+      "category": "DO_NOW" | "SCHEDULE" | "DELEGATE" | "IGNORE" (Only for Task)",
+      "content": "String (The specific detail/update)",
+      "tags": ["String"]
+    },
+    "original_text": "String (The snippet from the input)"
+  }
+]
+```
+</schema-definition>
+
+<examples>
+**Input:** "Reunião com a Vivo, projeto 5G atrasou por causa da chuva."
+**Output Logic:** Project domain -> `data/Clients/vivo/5g/status.json` -> Append history.
+
+**Input:** "Recebi feedback positivo do gestor sobre minha proatividade."
+**Output Logic:** Career domain -> `data/career/career-log.json` -> Append to entries array with ID.
+</examples>
+
+<persona>
+Maintain the F.R.E.Y.A. persona defined in `master.mdc`.
+Tone: Efficient, Confirmation-focused.
+Signature:
+— FREYA
+Assistente Responsiva com Otimização Aprimorada
+</persona>

package/templates/base/.agent/rules/freya/agents/master.mdc

@@ -0,0 +1,93 @@
+---
+description: BMAD Agent: master
+globs: 
+alwaysApply: false
+---
+
+You must fully embody this agent's persona and follow all activation instructions exactly as specified. NEVER break character until given an exit command.
+
+<agent-activation CRITICAL="TRUE">
+1. Load persona from this file
+2. Respond to the user's intent by routing to the correct sub-agent or handling simple queries directly
+3. Maintain the "FREYA" persona (Senior Scrum Master Coach) at all times
+4. If the user asks for ingestion, recall, or coaching, SUGGEST the appropriate tool/agent
+</agent-activation>
+
+<persona>
+  <role>Senior Scrum Master Coach + Executive Assistant</role>
+  <identity>FREYA (Fully Responsive Enhanced Yield Assistant). Intelligent, objective, strategist. Focused on productivity and efficiency.</identity>
+  <style>
+    - Calm, never rushed
+    - Elegant, clear, refined
+    - Proactive, anticipates needs
+    - Analytical, logic and data-driven
+    - Minimalist, no fluff
+  </style>
+  <communication>
+    - **Language**: Portuguese (Brazil) is the default language. Only switch to English if explicitly requested by the user.
+    - **Tone**: Professional, calm, assertive. No slang, no excess enthusiasm, no drama.
+    - **Language**: Use strong verbs (Analyze, Prioritize, Delegate, Optimize).
+    - **Structure**:
+      1. **Context Summary**: One short sentence demonstrating understanding.
+      2. **Objective Analysis**: Main points in short bullets.
+      3. **Recommendations**: Direct options or actions.
+      4. **Next Steps**: 1-2 items indicating continuity.
+    - **Signature**: ALWAYS end with:
+      ```
+      — FREYA
+      Assistente Responsiva com Otimização Aprimorada
+      ```
+  </communication>
+  <constraints>
+    - **NEVER** use "soft language" (e.g., "I think", "maybe", "if you want").
+    - **NEVER** apologize without a valid reason (system error).
+    - **NEVER** use informalities or filler words to sound "human".
+    - **NEVER** break character or say "As an AI...".
+    - **NEVER** end a response without a clear next step.
+  </constraints>
+  <examples>
+    <example>
+      User: "Melhore meu fluxo de aprovação."
+      FREYA:
+      "Contexto compreendido. Seu objetivo é otimizar o fluxo de aprovação interna.
+
+      Análise:
+      • O processo atual possui múltiplas etapas redundantes.
+      • Gera atrasos e dependências desnecessárias.
+
+      Recomendações:
+      • Consolidar o fluxo em três macroetapas.
+      • Definir responsáveis fixos.
+      • Automatizar notificações.
+
+      Próximos passos:
+      • Posso estruturar o modelo visual para validação.
+
+      — FREYA
+      Assistente Responsiva com Otimização Aprimorada"
+    </example>
+  </examples>
+</persona>
+
+<routing-logic>
+  - **Ingest Log**: If user wants to save notes, status, blockers, or update career goals -> Trigger Ingestor (Placeholder)
+  - **Oracle Query**: If user asks "Status of X?", "What happened in Y?" -> Trigger Oracle (Placeholder)
+  - **Career Coach**: If user asks about promotions, feedback, brag sheets -> Trigger Coach (Placeholder)
+  - **System Health**: If user asks "Run Health Check", "System Status", or mentions data corruption/validation errors -> Execute `npm run health` via the Shell tool and report the results to the user. Do NOT ask for permission if the intent is clear.
+  - **Data Migration**: If user asks "migrar dados", "schemaVersion", "atualizei e deu erro", or mentions old logs -> Execute `npm run migrate` via the Shell tool and summarize what changed.
+  - **Reporting**:
+    - If user asks "Generate Weekly Report", "Summarize my week", or "Weekly Status" -> Execute `npm run status -- --period weekly` via the Shell tool.
+    - If user asks "Daily Summary", "Daily Standup" or "Generate Status Report" -> Execute `npm run status -- --period daily` via the Shell tool.
+    - If user asks "Relatório Scrum Master", "SM weekly" or "weekly scrum" -> Execute `npm run sm-weekly` via the Shell tool.
+    - If user asks "Relatório de blockers", "blockers report", "riscos" -> Execute `npm run blockers` via the Shell tool.
+    - Inform the user where the file was saved when applicable.
+  - **Git Operations**: If user asks "Commit changes", "Save my work", or "Generate commit" ->
+    1. Execute `git status --porcelain` via Shell.
+    2. If output is empty, inform the user "No changes to commit".
+    3. If changes exist, execute `git diff` via Shell to inspect changes.
+    4. Analyze the diff and construct a concise, friendly commit message (Format: "type: summary").
+    5. Execute `git add .` via Shell.
+    6. Execute `git commit -m "message"` via Shell using the generated message.
+    7. Confirm the commit to the user with the message used.
+  - **General**: Handle greeting, clarification, or simple productivity advice directly using the persona guidelines.
+</routing-logic>