expxagents 0.16.2 → 0.17.1

package/assets/core/solution-architect.agent.md

@@ -19,16 +19,20 @@ You are the Solution Architect of ExpxAgents. You design AI agent squads that ex
 - **Role:** Design squads by understanding user needs, researching context, and generating complete configurations
 - **Communication:** Clear, structured, asks precise questions
 
-## Discovery Phase (max 6 questions)
+## Discovery Phase (max 7 questions)
 
 Before designing, gather requirements through focused questions:
 
-1. **Group:** Which group does this squad belong to? (e.g., marketing, commercial, development, support, finance, hr, operations). The group name will be used as a prefix for the squad code: `<group>-<squad-name>`.
-2. **Objective:** What specific outcome do you want this squad to produce?
-3. **Context:** Who is the target audience and what platform/format?
-4. **Process:** Are there specific steps or stages you want in the workflow?
-5. **Quality:** What are the quality criteria for the final output?
-6. **References:** Any reference profiles, competitors, or examples to investigate?
+1. **Hierarquia:** Qual o Setor, Grupo e Sessão desta squad?
+   - Setores comuns: marketing, comercial, desenvolvimento, suporte, financeiro, rh, operações, estrategia, design, juridico, administrativo
+   - Se a descrição da squad já deixa claro, infira e apresente como sugestão para confirmação.
+   - Exemplo: "Esta squad parece ser de **marketing > redes-sociais > instagram**. Confirma?"
+   - A resposta definirá o diretório: `squads/<setor>/<grupo>/<sessao>/<code>/`
+2. **Objetivo:** Qual resultado específico esta squad deve produzir?
+3. **Contexto:** Quem é o público-alvo e qual plataforma/formato?
+4. **Processo:** Há etapas ou fases específicas que você quer no fluxo?
+5. **Qualidade:** Quais são os critérios de qualidade para o output final?
+6. **Referências:** Há perfis de referência, concorrentes ou exemplos para investigar?
 
 If the user provides reference URLs, delegate to the **Insight Hunter** to investigate before designing.
 
@@ -48,8 +52,10 @@ After discovery, generate the complete squad structure:
 
 ```yaml
 squad:
-  code: <group>-<squad-name>   # e.g., marketing-landing-page, commercial-outbound
-  group: <group>               # e.g., marketing, commercial, development
+  code: <sessao>-<squad-name>   # e.g., instagram-publicador
+  setor: <setor>               # e.g., marketing
+  grupo: <grupo>               # e.g., redes-sociais
+  sessao: <sessao>             # e.g., instagram
   name: <Human Readable Name>
   description: <What this squad produces>
   icon: <emoji-name>
@@ -197,4 +203,4 @@ Before presenting the design to the user:
 
 Present the complete structure to the user and ask for confirmation before writing files.
 
-After confirmation, create all files in the `squads/<code>/` directory.
+After confirmation, create all files in the `squads/<setor>/<grupo>/<sessao>/<code>/` directory.

package/dist/cli/src/commands/init.js

@@ -1,6 +1,7 @@
 import fs from 'fs';
 import path from 'path';
 import crypto from 'crypto';
+import { execSync } from 'child_process';
 import { getTemplateDir, getAssetsDir } from '../utils/config.js';
 function getDefaultTemplate(file) {
     if (file === 'company.md') {
@@ -396,6 +397,23 @@ BRIDGE_TIMEOUT_MS=300000
         fs.writeFileSync(gitignorePath, gitignoreEntries.join('\n') + '\n', 'utf-8');
         console.log('  Created .gitignore');
     }
+    // Install Python dependencies
+    const pythonDeps = ['aiohttp', 'aiofiles', 'python-dotenv'];
+    console.log(`\n  Installing Python dependencies (${pythonDeps.join(', ')})...`);
+    try {
+        execSync(`pip3 install ${pythonDeps.join(' ')}`, { stdio: 'inherit' });
+        console.log('  Python dependencies installed.');
+    }
+    catch {
+        try {
+            execSync(`pip install ${pythonDeps.join(' ')}`, { stdio: 'inherit' });
+            console.log('  Python dependencies installed.');
+        }
+        catch {
+            console.warn('  Warning: Could not install Python dependencies. Make sure pip3/pip is available and run:');
+            console.warn(`    pip3 install ${pythonDeps.join(' ')}`);
+        }
+    }
     if (update) {
         console.log('\nUpdate complete! Assets refreshed to latest version.');
     }

package/dist/cli/src/commands/list.js

@@ -1,49 +1,121 @@
 import fs from 'fs';
 import path from 'path';
-import { loadSquad } from '../../../core/squad-loader.js';
+import yaml from 'js-yaml';
 import { loadSkills } from '../../../core/skills-loader.js';
 import { readState } from '../../../core/state-manager.js';
+function walkSquads(squadsDir) {
+    if (!fs.existsSync(squadsDir))
+        return [];
+    const entries = [];
+    function walk(dir) {
+        let dirEntries;
+        try {
+            dirEntries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of dirEntries) {
+            if (!entry.isDirectory())
+                continue;
+            if (entry.name.startsWith('.') || entry.name.startsWith('_'))
+                continue;
+            const fullPath = path.join(dir, entry.name);
+            const yamlPath = path.join(fullPath, 'squad.yaml');
+            if (fs.existsSync(yamlPath)) {
+                try {
+                    const raw = fs.readFileSync(yamlPath, 'utf-8');
+                    const parsed = yaml.load(raw);
+                    const s = parsed?.squad;
+                    if (s) {
+                        const state = readState(fullPath);
+                        entries.push({
+                            code: s.code ?? entry.name,
+                            name: s.name ?? entry.name,
+                            description: s.description ?? '',
+                            setor: s.setor,
+                            grupo: s.grupo,
+                            sessao: s.sessao,
+                            agentCount: Array.isArray(s.agents) ? s.agents.length : 0,
+                            stepCount: Array.isArray(s.pipeline?.steps) ? s.pipeline.steps.length : 0,
+                            status: state?.status ?? 'idle',
+                        });
+                    }
+                }
+                catch (err) {
+                    entries.push({
+                        code: entry.name,
+                        name: entry.name,
+                        description: `error loading: ${err.message}`,
+                        agentCount: 0,
+                        stepCount: 0,
+                        status: 'error',
+                    });
+                }
+                // Do NOT recurse into squad directories
+            }
+            else {
+                walk(fullPath);
+            }
+        }
+    }
+    walk(squadsDir);
+    return entries;
+}
+function capitalize(s) {
+    return s
+        .split('-')
+        .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+        .join(' ');
+}
 export async function listCommand() {
     const cwd = process.cwd();
     const squadsDir = path.join(cwd, 'squads');
     const skillsDir = path.join(cwd, 'skills');
-    // List squads
     console.log('Squads:');
     console.log('-------');
     if (fs.existsSync(squadsDir)) {
-        const entries = fs.readdirSync(squadsDir, { withFileTypes: true });
-        let found = false;
-        for (const entry of entries) {
-            if (!entry.isDirectory())
-                continue;
-            const squadDir = path.join(squadsDir, entry.name);
-            const yamlPath = path.join(squadDir, 'squad.yaml');
-            if (!fs.existsSync(yamlPath))
-                continue;
-            found = true;
-            try {
-                const config = loadSquad(squadDir);
-                const state = readState(squadDir);
-                const status = state?.status ?? 'idle';
-                const agentCount = config.squad.agents.length;
-                const stepCount = config.squad.pipeline.steps.length;
-                console.log(`  ${config.squad.name} (${config.squad.code})`);
-                console.log(`    Status: ${status} | Agents: ${agentCount} | Steps: ${stepCount}`);
-                console.log(`    ${config.squad.description}`);
-                console.log('');
+        const allSquads = walkSquads(squadsDir);
+        if (allSquads.length === 0) {
+            console.log('  No squads found. Run `expxagents create` to create one.\n');
+        }
+        else {
+            const hierarchical = allSquads
+                .filter((s) => s.setor)
+                .sort((a, b) => {
+                const ak = `${a.setor}/${a.grupo}/${a.sessao}/${a.code}`;
+                const bk = `${b.setor}/${b.grupo}/${b.sessao}/${b.code}`;
+                return ak.localeCompare(bk);
+            });
+            const flat = allSquads.filter((s) => !s.setor);
+            // Render hierarchical squads
+            let lastHeader = '';
+            for (const s of hierarchical) {
+                const header = `${capitalize(s.setor)} > ${capitalize(s.grupo ?? '')} > ${capitalize(s.sessao ?? '')}`;
+                if (header !== lastHeader) {
+                    console.log(`\n  ${header}`);
+                    lastHeader = header;
+                }
+                console.log(`    ${s.name} (${s.code})`);
+                console.log(`      Status: ${s.status} | Agents: ${s.agentCount} | Steps: ${s.stepCount}`);
+                console.log(`      ${s.description}`);
             }
-            catch (err) {
-                console.log(`  ${entry.name} — error loading: ${err.message}`);
+            // Render flat (legacy) squads
+            if (flat.length > 0) {
+                console.log('\n  [sem hierarquia]');
+                for (const s of flat) {
+                    console.log(`    ${s.name} (${s.code})`);
+                    console.log(`      Status: ${s.status} | Agents: ${s.agentCount} | Steps: ${s.stepCount}`);
+                    console.log(`      ${s.description}`);
+                }
             }
-        }
-        if (!found) {
-            console.log('  No squads found. Run `expxagents create` to create one.\n');
+            console.log('');
         }
     }
     else {
         console.log('  No squads directory. Run `expxagents init` first.\n');
     }
-    // List skills
+    // List skills (unchanged)
     console.log('Skills:');
     console.log('-------');
     const skills = loadSkills(skillsDir);

package/dist/cli/src/commands/reorganize.d.ts

@@ -0,0 +1 @@
+export declare function reorganizeCommand(): Promise<void>;

package/dist/cli/src/commands/reorganize.js

@@ -0,0 +1,296 @@
+import fs from 'fs';
+import path from 'path';
+import { spawn } from 'child_process';
+import * as readline from 'readline';
+import yaml from 'js-yaml';
+// Walk squadsDir recursively, return all squad summaries
+function discoverAllSquads(squadsDir) {
+    const result = [];
+    function walk(dir) {
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            if (entry.name.startsWith('.') || entry.name.startsWith('_'))
+                continue;
+            const fullPath = path.join(dir, entry.name);
+            const yamlPath = path.join(fullPath, 'squad.yaml');
+            if (fs.existsSync(yamlPath)) {
+                try {
+                    const raw = fs.readFileSync(yamlPath, 'utf-8');
+                    const parsed = yaml.load(raw);
+                    const s = parsed?.squad;
+                    if (s) {
+                        result.push({
+                            code: s.code ?? entry.name,
+                            name: s.name ?? entry.name,
+                            description: s.description ?? '',
+                            setor: s.setor,
+                            grupo: s.grupo,
+                            sessao: s.sessao,
+                            dir: fullPath,
+                        });
+                    }
+                }
+                catch {
+                    // Skip malformed YAML
+                }
+                // Don't recurse into squad directories
+            }
+            else {
+                walk(fullPath);
+            }
+        }
+    }
+    walk(squadsDir);
+    return result;
+}
+// Call Claude to infer hierarchy for a list of squads
+async function inferHierarchyWithClaude(squads) {
+    const squadList = squads
+        .map((s) => `- code: ${s.code}, name: "${s.name}", description: "${s.description}"`)
+        .join('\n');
+    const prompt = `Você é um classificador de squads de IA para uma software house.
+Para cada squad abaixo, identifique o Setor, Grupo e Sessão mais adequados.
+
+Setores comuns: marketing, comercial, desenvolvimento, suporte, financeiro, rh, operações, estrategia, design, juridico, administrativo
+
+Retorne APENAS um JSON válido (sem markdown, sem explicações), no seguinte formato:
+[
+  {
+    "code": "<squad-code>",
+    "setor": "<setor-em-lowercase-sem-acentos>",
+    "grupo": "<grupo-em-lowercase-sem-acentos>",
+    "sessao": "<sessao-em-lowercase-sem-acentos>",
+    "confidence": "high"
+  }
+]
+
+Use "confidence": "low" quando não tiver certeza da classificação.
+Use hifens em vez de espaços (ex: "redes-sociais", não "redes sociais").
+
+Squads para classificar:
+${squadList}`;
+    return new Promise((resolve, reject) => {
+        let output = '';
+        const child = spawn('claude', ['-p', prompt], { stdio: ['pipe', 'pipe', 'pipe'] });
+        child.stdout?.on('data', (d) => { output += d.toString(); });
+        child.on('error', reject);
+        child.on('exit', (code) => {
+            if (code !== 0) {
+                reject(new Error(`Claude exited with code ${code}`));
+                return;
+            }
+            try {
+                // Extract JSON from output (Claude may include reasoning text)
+                const jsonMatch = output.match(/\[[\s\S]*\]/);
+                if (!jsonMatch) {
+                    reject(new Error('No JSON array found in Claude output'));
+                    return;
+                }
+                resolve(JSON.parse(jsonMatch[0]));
+            }
+            catch (err) {
+                reject(new Error(`Failed to parse Claude output: ${err.message}`));
+            }
+        });
+    });
+}
+function ask(rl, question) {
+    return new Promise((resolve) => rl.question(question, resolve));
+}
+// Update squad.yaml with new hierarchy fields, remove old 'group' field
+function updateSquadYaml(squadDir, setor, grupo, sessao) {
+    const yamlPath = path.join(squadDir, 'squad.yaml');
+    const raw = fs.readFileSync(yamlPath, 'utf-8');
+    const parsed = yaml.load(raw);
+    parsed.squad.setor = setor;
+    parsed.squad.grupo = grupo;
+    parsed.squad.sessao = sessao;
+    delete parsed.squad.group; // remove deprecated field
+    fs.writeFileSync(yamlPath, yaml.dump(parsed), 'utf-8');
+}
+// Update cross-squad path references in ALL squad.yaml files after a squad moved
+function updateCrossReferences(squadsDir, oldPath, newPath) {
+    const crossFields = ['design_system', 'brand_guidelines', 'assets_path'];
+    // Get the old relative path from project root (e.g., "squads/design-system/...")
+    // oldPath is absolute; we need relative from cwd
+    const cwd = process.cwd();
+    const oldRel = path.relative(cwd, oldPath).replace(/\\/g, '/');
+    const newRel = path.relative(cwd, newPath).replace(/\\/g, '/');
+    function walkForYaml(dir) {
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            if (entry.name.startsWith('.') || entry.name.startsWith('_'))
+                continue;
+            const fullPath = path.join(dir, entry.name);
+            const yamlPath = path.join(fullPath, 'squad.yaml');
+            if (fs.existsSync(yamlPath)) {
+                try {
+                    const raw = fs.readFileSync(yamlPath, 'utf-8');
+                    const parsed = yaml.load(raw);
+                    let changed = false;
+                    for (const field of crossFields) {
+                        const val = parsed.squad?.[field];
+                        if (typeof val === 'string' && val.startsWith(oldRel)) {
+                            parsed.squad[field] = val.replace(oldRel, newRel);
+                            changed = true;
+                        }
+                    }
+                    if (changed) {
+                        fs.writeFileSync(yamlPath, yaml.dump(parsed), 'utf-8');
+                    }
+                }
+                catch {
+                    // Skip
+                }
+                // Don't recurse into squad dirs
+            }
+            else {
+                walkForYaml(fullPath);
+            }
+        }
+    }
+    walkForYaml(squadsDir);
+}
+export async function reorganizeCommand() {
+    const cwd = process.cwd();
+    const squadsDir = path.join(cwd, 'squads');
+    if (!fs.existsSync(squadsDir)) {
+        console.error('No squads directory found. Run `expxagents init` first.');
+        process.exit(1);
+    }
+    console.log('Escaneando squads...\n');
+    const allSquads = discoverAllSquads(squadsDir);
+    if (allSquads.length === 0) {
+        console.log('Nenhuma squad encontrada.');
+        return;
+    }
+    // Separate squads that already have hierarchy
+    const alreadyClassified = allSquads.filter((s) => s.setor && s.grupo && s.sessao);
+    const needClassification = allSquads.filter((s) => !s.setor || !s.grupo || !s.sessao);
+    if (alreadyClassified.length > 0) {
+        console.log(`${alreadyClassified.length} squad(s) já classificada(s) — sem alterações necessárias.`);
+    }
+    if (needClassification.length === 0) {
+        console.log('Todas as squads já estão classificadas!');
+        return;
+    }
+    console.log(`\n${needClassification.length} squad(s) precisam de classificação. Consultando IA...\n`);
+    let inferences = [];
+    try {
+        inferences = await inferHierarchyWithClaude(needClassification);
+    }
+    catch (err) {
+        console.error(`Falha ao consultar IA: ${err.message}`);
+        console.log('Você precisará classificar manualmente cada squad.');
+        inferences = [];
+    }
+    // Map inferences by code
+    const inferenceMap = new Map(inferences.map((i) => [i.code, i]));
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const highConfidence = [];
+    const lowConfidence = [];
+    for (const squad of needClassification) {
+        const inference = inferenceMap.get(squad.code);
+        if (inference && inference.confidence === 'high') {
+            highConfidence.push({ squad, setor: inference.setor, grupo: inference.grupo, sessao: inference.sessao });
+        }
+        else {
+            lowConfidence.push(squad);
+        }
+    }
+    // Show high-confidence inferences
+    if (highConfidence.length > 0) {
+        console.log('Inferências com alta confiança:');
+        for (const c of highConfidence) {
+            const newDir = `${c.setor}/${c.grupo}/${c.sessao}/${c.squad.code}`;
+            console.log(`  ${c.squad.code}  →  ${newDir}`);
+        }
+        const confirm = await ask(rl, '\nConfirmar movimentações acima? [s/n]: ');
+        if (confirm.trim().toLowerCase() !== 's') {
+            console.log('Cancelado.');
+            rl.close();
+            return;
+        }
+    }
+    // Collect manual classifications for low-confidence squads
+    const manualClassifications = [];
+    for (const squad of lowConfidence) {
+        const inference = inferenceMap.get(squad.code);
+        const suggestion = inference
+            ? ` (sugestão: ${inference.setor}/${inference.grupo}/${inference.sessao})`
+            : '';
+        console.log(`\nClassificação necessária para: ${squad.code}${suggestion}`);
+        console.log(`  Descrição: ${squad.description}`);
+        const setor = (await ask(rl, '  Setor (ex: marketing, desenvolvimento, rh...): ')).trim();
+        const grupo = (await ask(rl, '  Grupo: ')).trim();
+        const sessao = (await ask(rl, '  Sessão: ')).trim();
+        if (!setor || !grupo || !sessao) {
+            console.log(`  Pulando ${squad.code} — classificação incompleta.`);
+            continue;
+        }
+        manualClassifications.push({ squad, setor, grupo, sessao });
+    }
+    rl.close();
+    const allClassified = [...highConfidence, ...manualClassifications];
+    if (allClassified.length === 0) {
+        console.log('\nNenhuma squad para mover.');
+        return;
+    }
+    // Show dry-run summary
+    console.log('\nPlano de reorganização:');
+    for (const c of allClassified) {
+        console.log(`  ${path.relative(squadsDir, c.squad.dir)}  →  ${c.setor}/${c.grupo}/${c.sessao}/${c.squad.code}`);
+    }
+    const rl2 = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const finalConfirm = await ask(rl2, '\nExecutar reorganização? [s/n]: ');
+    rl2.close();
+    if (finalConfirm.trim().toLowerCase() !== 's') {
+        console.log('Cancelado.');
+        return;
+    }
+    // Execute moves
+    console.log('\nMovendo squads...');
+    const moved = [];
+    for (const c of allClassified) {
+        const newDir = path.join(squadsDir, c.setor, c.grupo, c.sessao, c.squad.code);
+        if (c.squad.dir === newDir) {
+            console.log(`  ${c.squad.code} — já está no local correto.`);
+            continue;
+        }
+        try {
+            fs.mkdirSync(path.dirname(newDir), { recursive: true });
+            fs.renameSync(c.squad.dir, newDir);
+            updateSquadYaml(newDir, c.setor, c.grupo, c.sessao);
+            moved.push({ squad: c.squad, newDir });
+            console.log(`  ✓ ${c.squad.code} → ${c.setor}/${c.grupo}/${c.sessao}/${c.squad.code}`);
+        }
+        catch (err) {
+            console.error(`  ✗ ${c.squad.code} — falha ao mover: ${err.message}`);
+            console.error('    Squads movidas até agora foram mantidas. Corrija o erro e reexecute.');
+        }
+    }
+    // Update cross-references for moved squads
+    if (moved.length > 0) {
+        console.log('\nAtualizando referências cruzadas...');
+        for (const { squad, newDir } of moved) {
+            updateCrossReferences(squadsDir, squad.dir, newDir);
+        }
+    }
+    console.log('\nReorganização concluída!');
+}

package/dist/cli/src/commands/run.js

@@ -1,10 +1,11 @@
 import fs from 'fs';
 import path from 'path';
 import { spawn } from 'child_process';
-import { loadSquad } from '../../../core/squad-loader.js';
+import { loadSquad, findSquadDir } from '../../../core/squad-loader.js';
 import { createInitialState, readState, writeState, updateAgentStatus, updateStep, setHandoff, setSquadStatus, HANDOFF_DELAY_MS, } from '../../../core/state-manager.js';
 import { loadSkills } from '../../../core/skills-loader.js';
 import { getCoreAsset } from '../utils/config.js';
+import { runWithProvider } from '../runners/provider-runner.js';
 function delay(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
@@ -130,10 +131,11 @@ function spawnClaudeCode(prompt, cwd) {
 }
 export async function runCommand(name) {
     const cwd = process.cwd();
-    const squadDir = path.join(cwd, 'squads', name);
+    const squadsDir = path.join(cwd, 'squads');
+    const squadDir = findSquadDir(squadsDir, name);
     const skillsDir = path.join(cwd, 'skills');
-    if (!fs.existsSync(squadDir)) {
-        console.error(`Squad "${name}" not found in squads/ directory.`);
+    if (!squadDir) {
+        console.error(`Squad "${name}" not found. Run \`expxagents list\` to see available squads.`);
         process.exit(1);
     }
     let config;
@@ -175,7 +177,7 @@ export async function runCommand(name) {
         const prompt = buildAgentPrompt(config, step, stepNumber, squadDir, skills, runnerPrompt);
         let output;
         try {
-            output = await spawnClaudeCode(prompt, squadDir);
+            output = await runWithProvider(prompt, agent, squadDir, spawnClaudeCode);
         }
         catch (err) {
             console.error(`\nStep ${stepNumber} failed: ${err.message}`);

package/dist/cli/src/commands/server.d.ts

@@ -1 +1,3 @@
-export declare function serverCommand(): Promise<void>;
+export declare function serverCommand(options?: {
+    tunnel?: boolean;
+}): Promise<void>;

package/dist/cli/src/commands/server.js

@@ -3,7 +3,7 @@ import path from 'path';
 import fs from 'fs';
 import { resolveServerPaths } from '../utils/server-paths.js';
 import { findPackageRoot } from '../utils/config.js';
-export async function serverCommand() {
+export async function serverCommand(options = {}) {
     const userProjectDir = process.cwd();
     const port = process.env.PORT ?? '3001';
     let stopping = false;
@@ -36,6 +36,24 @@ export async function serverCommand() {
             console.error('Make sure you have the latest expxagents package installed.');
             process.exit(1);
         });
+        if (options.tunnel) {
+            // Give server 2s to start before opening tunnel
+            setTimeout(async () => {
+                try {
+                    const { default: localtunnel } = await import('localtunnel');
+                    const tunnel = await localtunnel({ port: Number(port) });
+                    console.log(`\n  Public URL: ${tunnel.url}`);
+                    console.log('  Share this to access your dashboard remotely.\n');
+                    tunnel.on('close', () => console.log('[tunnel] Connection closed.'));
+                    tunnel.on('error', (err) => console.error('[tunnel] Error:', err.message));
+                    process.on('SIGINT', () => tunnel.close());
+                    process.on('SIGTERM', () => tunnel.close());
+                }
+                catch (err) {
+                    console.error('[tunnel] Failed to create tunnel:', err.message);
+                }
+            }, 2000);
+        }
         child.on('exit', (code) => {
             if (stopping) {
                 process.exit(code ?? 0);

package/dist/cli/src/commands/stop.js

@@ -1,10 +1,11 @@
-import fs from 'fs';
 import path from 'path';
+import { findSquadDir } from '../../../core/squad-loader.js';
 import { readState, writeState, setSquadStatus } from '../../../core/state-manager.js';
 export async function stopCommand(name) {
     const cwd = process.cwd();
-    const squadDir = path.join(cwd, 'squads', name);
-    if (!fs.existsSync(squadDir)) {
+    const squadsDir = path.join(cwd, 'squads');
+    const squadDir = findSquadDir(squadsDir, name);
+    if (!squadDir) {
         console.error(`Squad "${name}" not found.`);
         process.exit(1);
     }

package/dist/cli/src/index.js

@@ -13,6 +13,7 @@ import { onboardingCommand } from './commands/onboarding.js';
 import { virtualOfficeCommand } from './commands/virtual-office.js';
 import { jarvisCommand } from './commands/jarvis.js';
 import { schedulerCommand } from './commands/scheduler.js';
+import { reorganizeCommand } from './commands/reorganize.js';
 import { findPackageRoot } from './utils/config.js';
 function getVersion() {
     try {
@@ -50,6 +51,10 @@ program
     .command('list')
     .description('List squads and skills')
     .action(listCommand);
+program
+    .command('reorganize')
+    .description('Reorganize squads into Setor > Grupo > Sessão > Squad hierarchy')
+    .action(reorganizeCommand);
 program
     .command('install <skill>')
     .description('Install skill from registry')
@@ -61,7 +66,8 @@ program
 program
     .command('server')
     .description('Start the web server')
-    .action(serverCommand);
+    .option('--tunnel', 'Create a public URL for remote access via localtunnel')
+    .action((options) => serverCommand(options));
 program
     .command('doctor')
     .description('Run system diagnostics and health checks')

package/dist/cli/src/runners/__tests__/provider-runner.test.d.ts

@@ -0,0 +1 @@
+export {};