conectese 0.1.15 → 0.2.0

package/dashboard/src/plugin/{squadWatcher.ts → teamWatcher.ts}

@@ -7,40 +7,40 @@ import fsp from "node:fs/promises";
 import { watch as chokidarWatch } from "chokidar";
 import path from "node:path";
 import { parse as parseYaml } from "yaml";
-import type { SquadInfo, SquadState, WsMessage } from "../types/state";
+import type { TeamInfo, TeamState, WsMessage } from "../types/state";
 
-function resolveSquadsDir(): string {
+function resolveTeamsDir(): string {
   const candidates = [
-    path.resolve(process.cwd(), "../squads"),  // started from dashboard/
-    path.resolve(process.cwd(), "squads"),     // started from project root
+    path.resolve(process.cwd(), "../teams"),  // started from dashboard/
+    path.resolve(process.cwd(), "teams"),     // started from project root
   ];
   for (const c of candidates) {
     if (fs.existsSync(c)) return c;
   }
-  return path.resolve(process.cwd(), "../squads"); // default (will be created on demand)
+  return path.resolve(process.cwd(), "../teams"); // default (will be created on demand)
 }
 
-async function discoverSquads(squadsDir: string): Promise<SquadInfo[]> {
+async function discoverTeams(teamsDir: string): Promise<TeamInfo[]> {
   let entries;
   try {
-    entries = await fsp.readdir(squadsDir, { withFileTypes: true });
+    entries = await fsp.readdir(teamsDir, { withFileTypes: true });
   } catch {
     return [];
   }
 
-  const squads: SquadInfo[] = [];
+  const teams: TeamInfo[] = [];
 
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
     if (entry.name.startsWith(".") || entry.name.startsWith("_")) continue;
 
-    const yamlPath = path.join(squadsDir, entry.name, "squad.yaml");
+    const yamlPath = path.join(teamsDir, entry.name, "team.yaml");
     try {
       const raw = await fsp.readFile(yamlPath, "utf-8");
       const parsed = parseYaml(raw);
-      const s = parsed?.squad;
+      const s = parsed?.team;
       if (s) {
-        squads.push({
+        teams.push({
           code: typeof s.code === "string" ? s.code : entry.name,
           name: typeof s.name === "string" ? s.name : entry.name,
           description: typeof s.description === "string" ? s.description : "",
@@ -50,10 +50,10 @@ async function discoverSquads(squadsDir: string): Promise<SquadInfo[]> {
         continue;
       }
     } catch {
-      // No squad.yaml or invalid YAML — fall through to default
+      // No team.yaml or invalid YAML — fall through to default
     }
 
-    squads.push({
+    teams.push({
       code: entry.name,
       name: entry.name,
       description: "",
@@ -62,10 +62,10 @@ async function discoverSquads(squadsDir: string): Promise<SquadInfo[]> {
     });
   }
 
-  return squads;
+  return teams;
 }
 
-function isValidState(data: unknown): data is SquadState {
+function isValidState(data: unknown): data is TeamState {
   if (!data || typeof data !== "object") return false;
   const d = data as Record<string, unknown>;
   return (
@@ -75,19 +75,19 @@ function isValidState(data: unknown): data is SquadState {
   );
 }
 
-async function readActiveStates(squadsDir: string): Promise<Record<string, SquadState>> {
-  const states: Record<string, SquadState> = {};
+async function readActiveStates(teamsDir: string): Promise<Record<string, TeamState>> {
+  const states: Record<string, TeamState> = {};
 
   let entries;
   try {
-    entries = await fsp.readdir(squadsDir, { withFileTypes: true });
+    entries = await fsp.readdir(teamsDir, { withFileTypes: true });
   } catch {
     return states;
   }
 
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const statePath = path.join(squadsDir, entry.name, "state.json");
+    const statePath = path.join(teamsDir, entry.name, "state.json");
 
     try {
       const raw = await fsp.readFile(statePath, "utf-8");
@@ -103,11 +103,11 @@ async function readActiveStates(squadsDir: string): Promise<Record<string, Squad
   return states;
 }
 
-async function buildSnapshot(squadsDir: string): Promise<WsMessage> {
+async function buildSnapshot(teamsDir: string): Promise<WsMessage> {
   return {
     type: "SNAPSHOT",
-    squads: await discoverSquads(squadsDir),
-    activeStates: await readActiveStates(squadsDir),
+    teams: await discoverTeams(teamsDir),
+    activeStates: await readActiveStates(teamsDir),
   };
 }
 
@@ -124,22 +124,22 @@ function broadcast(wss: WebSocketServer, msg: WsMessage) {
   }
 }
 
-export function squadWatcherPlugin(): Plugin {
+export function teamWatcherPlugin(): Plugin {
   return {
-    name: "squad-watcher",
+    name: "team-watcher",
     configureServer(server: ViteDevServer) {
       if (!server.httpServer) {
-        server.config.logger.warn("[squad-watcher] no httpServer — skipping");
+        server.config.logger.warn("[team-watcher] no httpServer — skipping");
         return;
       }
 
-      const squadsDir = resolveSquadsDir();
-      server.config.logger.info(`[squad-watcher] squads dir: ${squadsDir}`);
+      const teamsDir = resolveTeamsDir();
+      server.config.logger.info(`[team-watcher] teams dir: ${teamsDir}`);
 
       // Create WebSocket server with noServer to avoid intercepting Vite's HMR
       const wss = new WebSocketServer({ noServer: true });
       (server.httpServer as Server).on("upgrade", (req: IncomingMessage, socket: Duplex, head: Buffer) => {
-        if (req.url === "/__squads_ws") {
+        if (req.url === "/__teams_ws") {
           wss.handleUpgrade(req, socket, head, (ws) => {
             wss.emit("connection", ws, req);
           });
@@ -150,23 +150,23 @@ export function squadWatcherPlugin(): Plugin {
       // Send snapshot on new connection
       wss.on("connection", async (ws) => {
         try {
-          const snap = await buildSnapshot(squadsDir);
+          const snap = await buildSnapshot(teamsDir);
           ws.send(JSON.stringify(snap));
         } catch {
           // Connection may have closed before snapshot was ready
         }
       });
 
-      // Ensure squads directory exists
-      fsp.mkdir(squadsDir, { recursive: true }).catch((err) => {
-        server.config.logger.error(`[squad-watcher] failed to create squads dir: ${err.message}`);
+      // Ensure teams directory exists
+      fsp.mkdir(teamsDir, { recursive: true }).catch((err) => {
+        server.config.logger.error(`[team-watcher] failed to create teams dir: ${err.message}`);
       });
 
       // REST API fallback & File Upload
       server.middlewares.use(async (req, res, next) => {
         if (req.url === "/api/snapshot" && req.method === "GET") {
           try {
-            const snapshot = await buildSnapshot(squadsDir);
+            const snapshot = await buildSnapshot(teamsDir);
             res.setHeader("Content-Type", "application/json");
             res.setHeader("Cache-Control", "no-cache");
             res.end(JSON.stringify(snapshot));
@@ -256,11 +256,50 @@ export function squadWatcherPlugin(): Plugin {
           return;
         }
 
+        if (req.url?.startsWith("/api/team/") && req.url?.endsWith("/checkpoint") && req.method === "POST") {
+          const parts = req.url.split("/");
+          const teamName = parts[3];
+          let body = "";
+          req.on("data", chunk => body += chunk.toString());
+          req.on("end", async () => {
+            try {
+              const payload = JSON.parse(body);
+              const checkpointFile = path.join(teamsDir, teamName, "checkpoint_response.json");
+              await fsp.writeFile(checkpointFile, JSON.stringify(payload, null, 2), "utf-8");
+
+              const stateFile = path.join(teamsDir, teamName, "state.json");
+              try {
+                const stateRaw = await fsp.readFile(stateFile, "utf-8");
+                const state = JSON.parse(stateRaw);
+                state.status = "running"; // Clear checkpoint status on UI
+                if (state.agents) {
+                  state.agents.forEach((a: any) => {
+                    if (a.status === "checkpoint") a.status = "working";
+                  });
+                }
+                state.updatedAt = new Date().toISOString();
+                await fsp.writeFile(stateFile, JSON.stringify(state, null, 2), "utf-8");
+              } catch (e) {
+                // Ignore state.json update errors
+              }
+
+              res.setHeader("Content-Type", "application/json");
+              res.writeHead(200);
+              res.end(JSON.stringify({ success: true }));
+            } catch (err: any) {
+              res.setHeader("Content-Type", "application/json");
+              res.writeHead(400);
+              res.end(JSON.stringify({ success: false, error: err.message }));
+            }
+          });
+          return;
+        }
+
         return next();
       });
 
       // File watcher using chokidar — reliable cross-platform, handles partial writes
-      const watcher = chokidarWatch(squadsDir, {
+      const watcher = chokidarWatch(teamsDir, {
         ignoreInitial: true,
         awaitWriteFinish: { stabilityThreshold: 300, pollInterval: 50 },
         ignored: [/(^|[/\\])\./, /node_modules/, /output[/\\]/],
@@ -268,38 +307,38 @@ export function squadWatcherPlugin(): Plugin {
       });
 
       function handleFileChange(filePath: string) {
-        const relative = path.relative(squadsDir, filePath).replace(/\\/g, "/");
+        const relative = path.relative(teamsDir, filePath).replace(/\\/g, "/");
         const parts = relative.split("/");
         if (parts.length < 2) return;
 
-        const squadName = parts[0];
+        const teamName = parts[0];
         const fileName = parts[1];
 
         if (fileName === "state.json") {
           fsp.readFile(filePath, "utf-8").then((raw) => {
             const parsed = JSON.parse(raw);
             if (!isValidState(parsed)) return;
-            broadcast(wss, { type: "SQUAD_UPDATE", squad: squadName, state: parsed });
+            broadcast(wss, { type: "TEAM_UPDATE", team: teamName, state: parsed });
           }).catch(() => {
             // Invalid JSON — next change event will retry
           });
-        } else if (fileName === "squad.yaml") {
-          buildSnapshot(squadsDir).then((snap) => broadcast(wss, snap));
+        } else if (fileName === "team.yaml") {
+          buildSnapshot(teamsDir).then((snap) => broadcast(wss, snap));
         }
       }
 
       function handleFileRemoval(filePath: string) {
-        const relative = path.relative(squadsDir, filePath).replace(/\\/g, "/");
+        const relative = path.relative(teamsDir, filePath).replace(/\\/g, "/");
         const parts = relative.split("/");
         if (parts.length < 2) return;
 
-        const squadName = parts[0];
+        const teamName = parts[0];
         const fileName = parts[1];
 
         if (fileName === "state.json") {
-          broadcast(wss, { type: "SQUAD_INACTIVE", squad: squadName });
-        } else if (fileName === "squad.yaml") {
-          buildSnapshot(squadsDir).then((snap) => broadcast(wss, snap));
+          broadcast(wss, { type: "TEAM_INACTIVE", team: teamName });
+        } else if (fileName === "team.yaml") {
+          buildSnapshot(teamsDir).then((snap) => broadcast(wss, snap));
         }
       }
 

package/dashboard/src/store/useTeamStore.ts

@@ -0,0 +1,56 @@
+import { create } from "zustand";
+import type { TeamInfo, TeamState } from "@/types/state";
+
+interface TeamStore {
+  // State
+  teams: Map<string, TeamInfo>;
+  activeStates: Map<string, TeamState>;
+  selectedTeam: string | null;
+  isConnected: boolean;
+
+  // Actions
+  selectTeam: (name: string | null) => void;
+  setConnected: (connected: boolean) => void;
+  setSnapshot: (teams: TeamInfo[], activeStates: Record<string, TeamState>) => void;
+  setTeamActive: (team: string, state: TeamState) => void;
+  updateTeamState: (team: string, state: TeamState) => void;
+  setTeamInactive: (team: string) => void;
+}
+
+export const useTeamStore = create<TeamStore>((set) => ({
+  teams: new Map(),
+  activeStates: new Map(),
+  selectedTeam: null,
+  isConnected: false,
+
+  selectTeam: (name) => set({ selectedTeam: name }),
+
+  setConnected: (connected) => set({ isConnected: connected }),
+
+  setSnapshot: (teams, activeStates) =>
+    set({
+      teams: new Map(teams.map((s) => [s.code, s])),
+      activeStates: new Map(Object.entries(activeStates)),
+    }),
+
+  setTeamActive: (team, state) =>
+    set((prev) => ({
+      activeStates: new Map(prev.activeStates).set(team, state),
+    })),
+
+  updateTeamState: (team, state) =>
+    set((prev) => ({
+      activeStates: new Map(prev.activeStates).set(team, state),
+    })),
+
+  setTeamInactive: (team) =>
+    set((prev) => {
+      const next = new Map(prev.activeStates);
+      next.delete(team);
+      return {
+        activeStates: next,
+        // Reset selection if the inactive team was selected
+        selectedTeam: prev.selectedTeam === team ? null : prev.selectedTeam,
+      };
+    }),
+}));

package/dashboard/src/types/state.ts

@@ -25,17 +25,18 @@ export interface Handoff {
   to: string;
   message: string;
   completedAt: string;
+  missingData?: string[];
 }
 
-export type SquadStatus =
+export type TeamStatus =
   | "idle"
   | "running"
   | "completed"
   | "checkpoint";
 
-export interface SquadState {
-  squad: string;
-  status: SquadStatus;
+export interface TeamState {
+  team: string;
+  status: TeamStatus;
   step: {
     current: number;
     total: number;
@@ -47,8 +48,8 @@ export interface SquadState {
   updatedAt: string;
 }
 
-// Squad metadata from squad.yaml
-export interface SquadInfo {
+// Team metadata from team.yaml
+export interface TeamInfo {
   code: string;
   name: string;
   description: string;
@@ -58,6 +59,6 @@ export interface SquadInfo {
 
 // WebSocket messages
 export type WsMessage =
-  | { type: "SNAPSHOT"; squads: SquadInfo[]; activeStates: Record<string, SquadState> }
-  | { type: "SQUAD_UPDATE"; squad: string; state: SquadState }
-  | { type: "SQUAD_INACTIVE"; squad: string };
+  | { type: "SNAPSHOT"; teams: TeamInfo[]; activeStates: Record<string, TeamState> }
+  | { type: "TEAM_UPDATE"; team: string; state: TeamState }
+  | { type: "TEAM_INACTIVE"; team: string };

package/dashboard/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["./src/app.tsx","./src/main.tsx","./src/vite-env.d.ts","./src/components/ingestionmodal.tsx","./src/components/squadcard.tsx","./src/components/squadselector.tsx","./src/components/statusbadge.tsx","./src/components/statusbar.tsx","./src/hooks/usesquadsocket.ts","./src/lib/formattime.ts","./src/lib/normalizestate.ts","./src/office/agentsprite.ts","./src/office/officescene.ts","./src/office/phasergame.tsx","./src/office/roombuilder.ts","./src/office/assetkeys.ts","./src/office/palette.ts","./src/plugin/squadwatcher.ts","./src/store/usesquadstore.ts","./src/types/state.ts"],"version":"5.9.3"}
+{"root":["./src/app.tsx","./src/main.tsx","./src/vite-env.d.ts","./src/components/ingestionmodal.tsx","./src/components/statusbadge.tsx","./src/components/statusbar.tsx","./src/components/teamcard.tsx","./src/components/teamselector.tsx","./src/hooks/useteamsocket.ts","./src/lib/formattime.ts","./src/lib/normalizestate.ts","./src/office/agentsprite.ts","./src/office/officescene.ts","./src/office/phasergame.tsx","./src/office/roombuilder.ts","./src/office/assetkeys.ts","./src/office/palette.ts","./src/plugin/teamwatcher.ts","./src/store/useteamstore.ts","./src/types/state.ts"],"version":"5.9.3"}

package/dashboard/vite.config.ts

@@ -1,10 +1,10 @@
 import { defineConfig } from "vite";
 import react from "@vitejs/plugin-react";
 import path from "node:path";
-import { squadWatcherPlugin } from "./src/plugin/squadWatcher";
+import { teamWatcherPlugin } from "./src/plugin/teamWatcher";
 
 export default defineConfig({
-  plugins: [react(), squadWatcherPlugin()],
+  plugins: [react(), teamWatcherPlugin()],
   resolve: {
     alias: {
       "@": path.resolve(__dirname, "./src"),

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "conectese",
-  "version": "0.1.15",
-  "description": "Multi-agent orchestration framework — create AI squads that work together",
+  "version": "0.2.0",
+  "description": "Multi-agent orchestration framework — create AI teams that work together",
   "type": "module",
   "bin": {
     "conectese": "bin/conectese.js"
   },
   "scripts": {
-    "test": "node --test tests/*.test.js",
+    "test": "node --test 'tests/**/*.test.js' 'tests/*.test.js'",
     "lint": "eslint src/ bin/ tests/",
     "setup-admin": "node bin/setup_admin.js",
     "version": "node -e \"require('fs').writeFileSync('templates/_conectese/.conectese-version', require('./package.json').version + '\\n')\" && git add templates/_conectese/.conectese-version"
@@ -17,16 +17,16 @@
     "ai-agents",
     "multi-agent",
     "orchestration",
-    "squads"
+    "teams"
   ],
-  "author": "Renato Asse (https://github.com/renatoasse)",
-  "homepage": "https://github.com/renatoasse/conectese#readme",
+  "author": "Carlos Henrique (https://github.com/henriqueadm-ai)",
+  "homepage": "https://github.com/henriqueadm-ai/conectese#readme",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/renatoasse/conectese.git"
+    "url": "git+https://github.com/henriqueadm-ai/conectese.git"
   },
   "bugs": {
-    "url": "https://github.com/renatoasse/conectese/issues"
+    "url": "https://github.com/henriqueadm-ai/conectese/issues"
   },
   "license": "MIT",
   "engines": {
@@ -38,10 +38,10 @@
     "agents/",
     "skills/",
     "templates/",
-    "_conectese/",
     "dashboard/"
   ],
   "dependencies": {
+    "@google/genai": "^1.48.0",
     "@inquirer/checkbox": "^5.1.0",
     "@inquirer/input": "^5.0.0",
     "@inquirer/select": "^5.1.0",
@@ -51,6 +51,9 @@
     "dotenv": "^17.4.0",
     "html-to-docx": "^1.8.0",
     "marked": "^17.0.5",
+    "pdf-parse": "^2.4.5"
+  },
+  "optionalDependencies": {
     "puppeteer": "^24.40.0",
     "puppeteer-extra": "^3.3.6",
     "puppeteer-extra-plugin-stealth": "^2.11.2"

package/skills/README.md

@@ -1,6 +1,6 @@
 # Conectese Skill Catalog
 
-Browse available skills for your squads. Install any skill with:
+Browse available skills for your teams. Install any skill with:
 
 ```bash
 npx conectese install <skill-name>

package/skills/conectese-agent-creator/SKILL.md

@@ -142,7 +142,7 @@ The Best-Practice Creator workflow (above) handles the initial `whenToUse` cross
 
 ### When updating a best-practice file's `whenToUse` scope
 
-This is the most impactful change — it affects how the Architect selects best practices during squad creation.
+This is the most impactful change — it affects how the Architect selects best practices during team creation.
 
 1. Document the old scope and new scope
 2. Update the best-practice file's `whenToUse` field

package/skills/conectese-design/SKILL.md

@@ -0,0 +1,50 @@
+---
+name: conectese-design
+description: >
+  Motor de design jurídico (Visual Law). Converte Markdown judicial em PDFs
+  e DOCXs estilizados com timbre do escritório, empregando CSS premium e
+  Puppeteer para renderização fiel. Inclui geração de contratos, procurações,
+  recibos e peças processuais formatadas.
+type: mcp
+version: "1.0.0"
+mcp:
+  server_name: conectese-design
+  command: node
+  args: ["skills/conectese-design/index.cjs"]
+  transport: stdio
+categories: [design, legal, pdf, visual-law]
+---
+
+# Conectese Design (Visual Law Engine)
+
+## When to use
+
+Use esta skill quando o pipeline precisar gerar documentos jurídicos em PDF ou DOCX com formatação profissional e timbre do escritório. Ela é o motor de saída visual da plataforma Conecte.se.
+
+## Instructions
+
+### Ferramentas disponíveis (MCP Tools)
+
+- **`generate_visual_law_pdf`**: Recebe Markdown + ID do processo, gera PDF estilizado com timbre institucional.
+- **`generate_visual_law_docx`**: Mesmo fluxo mas gera DOCX editável.
+- **`generate_contract_pdf`**: Gera PDF de contrato preenchido a partir de modelo + dados do cliente.
+
+### Parâmetros obrigatórios
+
+| Parâmetro | Descrição |
+|-----------|-----------|
+| `markdownContent` | O conteúdo Markdown da peça/documento |
+| `processId` | ID do processo (ex: `P05_04_0001`) ou `ADMINISTRATIVO` para documentos fora de processos |
+| `outputFormat` | `pdf` ou `docx` |
+
+### Comportamento de saída
+
+- PDFs e DOCXs são salvos automaticamente em `PROCESSOS/{processId}/` ou `ADMINISTRATIVO/`.
+- O timbre do escritório é carregado de `_conectese/_memory/company/dados.json`.
+- CSS premium aplicado com fontes profissionais e espaçamento tipográfico adequado.
+
+### Best practices
+
+- Sempre passe o `processId` correto para organização automática de arquivos.
+- O Markdown de entrada deve usar as tags de anonimização `[PESSOA_1]` até o `lgpd-restorer` fazer a restauração final.
+- Para documentos administrativos (contratos, procurações), use `ADMINISTRATIVO` como processId.

package/skills/conectese-skill-creator/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: conectese-skill-creator
-description: Create new Conectese skills, modify and improve existing skills, and measure skill performance. Use when users want to create a skill for their squads, update or optimize an existing skill, run evals to test a skill, or benchmark skill performance. Supports all Conectese skill types: MCP integrations, custom scripts, hybrid, and behavioral prompts.
+description: Create new Conectese skills, modify and improve existing skills, and measure skill performance. Use when users want to create a skill for their teams, update or optimize an existing skill, run evals to test a skill, or benchmark skill performance. Supports all Conectese skill types: MCP integrations, custom scripts, hybrid, and behavioral prompts.
 ---
 
 # Conectese Skill Creator
@@ -47,7 +47,7 @@ It's OK to briefly explain terms if you're in doubt, and feel free to clarify te
 Start by understanding the user's intent. The current conversation might already contain a workflow the user wants to capture (e.g., they say "turn this into a skill"). If so, extract answers from the conversation history first — the tools used, the sequence of steps, corrections the user made, input/output formats observed. The user may need to fill the gaps, and should confirm before proceeding to the next step.
 
 1. What should this skill enable agents to do?
-2. When should this skill be used? (what user phrases/contexts/squad scenarios)
+2. When should this skill be used? (what user phrases/contexts/team scenarios)
 3. What's the expected output format?
 4. Should we set up test cases to verify the skill works? Skills with objectively verifiable outputs (file transforms, data extraction, code generation, fixed workflow steps) benefit from test cases. Skills with subjective outputs (writing style, art) often don't need them. Suggest the appropriate default based on the skill type, but let the user decide.
 
@@ -190,7 +190,7 @@ For each test case, spawn two subagents in the same turn — one with the skill,
 
 **With-skill run:**
 
-The with-skill run simulates how a Conectese agent operates with this skill injected into its context. The skill's SKILL.md body gets appended to the agent's instructions, just like the pipeline runner does during actual squad execution.
+The with-skill run simulates how a Conectese agent operates with this skill injected into its context. The skill's SKILL.md body gets appended to the agent's instructions, just like the pipeline runner does during actual team execution.
 
 ```
 Execute this task:

package/skills/conectese-skill-creator/references/skill-format.md

@@ -91,7 +91,7 @@ mcp:
 
 ## When to use
 
-Use this skill when the user or squad pipeline needs to create visual content — social media posts, presentations, flyers, or any graphic design task that benefits from Canva's template library.
+Use this skill when the user or team pipeline needs to create visual content — social media posts, presentations, flyers, or any graphic design task that benefits from Canva's template library.
 
 ## Instructions
 
@@ -155,7 +155,7 @@ Use this skill when the pipeline needs to analyze tabular data from CSV files
 ```yaml
 ---
 name: professional-tone
-description: Write content in a professional corporate tone. Use when squad agents need to produce business communications, reports, or client-facing materials that require formal, polished language.
+description: Write content in a professional corporate tone. Use when team agents need to produce business communications, reports, or client-facing materials that require formal, polished language.
 type: prompt
 version: 1.0.0
 categories:
@@ -198,7 +198,7 @@ When writing in professional tone:
 ```yaml
 ---
 name: social-publisher
-description: Draft social media content and publish via API. Use when squads need to create and post content to Instagram, Twitter/X, or LinkedIn with approval workflows.
+description: Draft social media content and publish via API. Use when teams need to create and post content to Instagram, Twitter/X, or LinkedIn with approval workflows.
 type: hybrid
 version: 1.0.0
 categories:
@@ -227,7 +227,7 @@ Use this skill when the pipeline needs to both create and publish social media c
 
 ## Instructions
 
-1. Draft the content using squad agent context (topic, tone, audience)
+1. Draft the content using team agent context (topic, tone, audience)
 2. Run the formatting script to prepare platform-specific versions
 3. Present drafts for user approval at the checkpoint
 4. After approval, use the MCP server to publish to the target platforms

package/skills/document-analyzer/SKILL.md

@@ -0,0 +1,40 @@
+---
+name: document-analyzer
+description: >
+  Motor analítico de documentos para extração e estruturação profunda de PDFs.
+  Lê arquivos não estruturados e aplica frameworks de extração semântica 
+  (classificação de entidades, SLAs, Prazos, CNPJs, etc.).
+version: "1.0.0"
+type: "custom"
+categories: [data, parsing, legal]
+---
+
+# Document Analyzer
+
+## When to use
+
+Use a ferramenta `document-analyzer` quando você ou outro Agente precisar inferir e extrair inteligência processável a partir de contratos, relatórios, peças processuais ou arquivos PDF enviados por usuários. Esta skill consolida extração óptica/vetorial (OCR/Parsing) com a sua própria capacidade nativa cognitiva para devolver formatos padronizados (JSON, Markdown) livres de ruído estrutural.
+
+## Instructions
+
+Esta Skill invoca scripts locais do Node.js (via bash) juntamente com suas próprias heurísticas de extração semântica.
+
+### Key capabilities
+
+- **Text Extraction (PDFs):** Extração bruta de texto de vetores locais usando algoritmos otimizados para evitar alucinações de formatação.
+- **Data Extractor Pipeline:** Extração estruturada de dados densos (ex: Cláusulas de Quebra, Multas, Prazos Recusais, Qualificação de Partes) de forma determinística.
+- **Noise Reduction:** Limpeza de cabeçalhos/rodapés mortos que gastam cota de tokens no prompt.
+
+### Best practices
+
+- **Sempre Verifique o Retorno:** Ao ler um arquivo grande usando a ferramenta de extração, procure limitar a resposta fatiando-a, se for necessário analisar em múltiplos passos.
+- **Saída Estruturada:** Se o usuário pedir os "termos chave", elabore um mapeamento estrito retornando num formato de blocos demarcados (`JSON` ou `lista md`).
+- **Anonimização (LGPD):** Se você for rotear o resultado documentado para fora do ambiente de auditoria, Oculte CPFs e nomes sensíveis.
+
+## Available operations
+
+Abaixo explicamos o wrapper integrado para consumo. Execute o script com sua sandbox local:
+
+- `node skills/document-analyzer/scripts/parse-doc.js <caminho.pdf>`: Recebe um arquivo PDF e tenta extrair o texto via parsing nativo. Caso retorne texto vazio (indicando ser um arquivo digitalizado/imagem), **fará um fallback automático** para leitura via LLM (Gemini Vision) em background requerendo a chave de ambiente `GEMINI_API_KEY`.
+- `node skills/document-analyzer/scripts/parse-doc.js <caminho.pdf> --vision`: Força imediatamente a leitura visual multimodal desabilitando a decodificação pura do arquivo local.
+- `node skills/document-analyzer/scripts/parse-doc.js <caminho.pdf> --extract="Extraia apenas os valores e datas em formato JSON"`: Além de fazer OCR/Vision do documento, embute um system prompt customizado onde a extração será orientada de modo formidável a retornar dados pré-estruturados conforme seu pedido.