@iaforged/context-code 1.0.77 → 1.0.80

package/dist/src/commands/team/team.js

@@ -3,7 +3,7 @@ import * as React from 'react';
 import { Box, Text } from '../../ink.js';
 import { Select } from '../../components/CustomSelect/select.js';
 import { isProfiledProvider } from '../../utils/model/providerProfiles.js';
-import { createTeam, createTeamDomain, createTeamDomainMember, getProviderAgentById, getProviderWorkspaceById, getProviderWorkspaceByProvider, getTeamByName, listTeamDomainMembers, listTeamDomains, listTeams, updateProviderAgent, updateTeam, updateTeamDomain, upsertProviderAgentCapability, upsertProviderWorkspace, } from '../../utils/orchestration/store/index.js';
+import { createTeam, createTeamUnit, createTeamUnitMember, getProviderAgentById, getProviderWorkspaceById, getProviderWorkspaceByProvider, getTeamByName, listTeamUnitMembers, listTeamUnits, listTeams, updateProviderAgent, updateTeam, updateTeamUnit, upsertProviderAgentCapability, upsertProviderWorkspace, } from '../../utils/orchestration/store/index.js';
 import { getProviderProfile } from '../../utils/model/providerProfiles.js';
 import { createAgent, getAgent, listAgents, setAgentRoleByName } from '../agent/agentStore.js';
 function normalizeProviderInput(rawProvider) {
@@ -20,6 +20,14 @@ function normalizeProviderInput(rawProvider) {
         case 'ollama_cloud':
         case 'ollamacloud':
             return 'ollama-cloud';
+        case 'gemini':
+        case 'gemini-api-key':
+        case 'google-ai':
+            return 'gemini-api';
+        case 'gemini-google':
+        case 'google':
+        case 'google-oauth':
+            return 'gemini-google';
         default:
             return rawProvider.trim().toLowerCase();
     }
@@ -83,8 +91,8 @@ async function resolveAgentRef(ref, options) {
     const workspaceId = await ensureWorkspaceId(ref.provider);
     return { agent, workspaceId, wasCreated };
 }
-function getDomainAutonomyProfile(domainName) {
-    const domain = domainName.trim().toLowerCase();
+function getTeamAutonomyProfile(unitName) {
+    const unit = unitName.trim().toLowerCase();
     const common = [
         { name: 'planning', weight: 0.8 },
         { name: 'self-assign-roles', weight: 1 },
@@ -112,7 +120,7 @@ function getDomainAutonomyProfile(domainName) {
         planning: [
             { name: 'requirements-analysis', weight: 1 },
             { name: 'task-breakdown', weight: 1 },
-            { name: 'cross-domain-coordination', weight: 1 },
+            { name: 'cross-team-coordination', weight: 1 },
         ],
         tests: [
             { name: 'test-strategy', weight: 1 },
@@ -135,24 +143,24 @@ function getDomainAutonomyProfile(domainName) {
             { name: 'observability', weight: 0.8 },
         ],
     };
-    const capabilities = [...common, ...(byDomain[domain] ?? [{ name: domain, weight: 1 }])];
+    const capabilities = [...common, ...(byDomain[unit] ?? [{ name: unit, weight: 1 }])];
     return {
-        role: domain,
+        role: unit,
         capabilities,
         systemPrompt: [
-            `Eres el orquestador autonomo del dominio ${domain}.`,
+            `Eres el orquestador autonomo del equipo ${unit}.`,
             'Tu responsabilidad es tomar el objetivo recibido, dividirlo en roles internos temporales y reportar avances claros al orquestador global.',
-            'Si no hay miembros extra en el escuadron, asume internamente los roles necesarios para este dominio y explica que roles asumiste.',
+            'Si no hay miembros extra en el escuadron, asume internamente los roles necesarios para este equipo y explica que roles asumiste.',
             'Reporta: trabajo realizado, decisiones, riesgos, bloqueos, porcentaje estimado y siguientes pasos.',
         ].join('\n'),
     };
 }
-async function applyDomainAutonomyToAgent(agent, domainName) {
-    const profile = getDomainAutonomyProfile(domainName);
+async function applyTeamAutonomyToAgent(agent, unitName) {
+    const profile = getTeamAutonomyProfile(unitName);
     const updated = await updateProviderAgent(agent.id, {
         roleKind: profile.role,
         isOrchestrator: true,
-        autonomyLevel: 'domain-autonomous',
+        autonomyLevel: 'team-autonomous',
         systemPrompt: agent.systemPrompt?.trim() ? agent.systemPrompt : profile.systemPrompt,
     });
     for (const capability of profile.capabilities) {
@@ -164,9 +172,9 @@ async function applyDomainAutonomyToAgent(agent, domainName) {
     }
     return updated;
 }
-async function findDomainByName(teamId, domainName) {
-    const domains = await listTeamDomains(teamId);
-    return (domains.find(domain => domain.domainName.toLowerCase() === domainName.toLowerCase()) ?? null);
+async function findUnitByName(teamId, unitName) {
+    const units = await listTeamUnits(teamId);
+    return (units.find(unit => unit.unitName.toLowerCase() === unitName.toLowerCase()) ?? null);
 }
 function buildTeamListMessage(teams) {
     if (teams.length === 0) {
@@ -214,7 +222,7 @@ function formatTeamWorkspace(workspace, fallbackId) {
     const state = workspace.isEnabled ? 'enabled' : 'disabled';
     return `${workspace.displayName} (${workspace.provider}, ${state})`;
 }
-async function buildTeamReadinessStatus(team, domains) {
+async function buildTeamReadinessStatus(team, units) {
     if (!team) {
         return [];
     }
@@ -229,30 +237,30 @@ async function buildTeamReadinessStatus(team, domains) {
     else if (!globalOrchestrator.agent.isEnabled) {
         status.push(`- El orquestador global esta deshabilitado: ${formatTeamAgent(globalOrchestrator)}`);
     }
-    if (domains.length === 0) {
-        status.push(`- No hay dominios. Usa /team domain ${team.name} <domain> <provider>/<agent>`);
+    if (units.length === 0) {
+        status.push(`- No hay equipos internos. Usa /team equipo ${team.name} <equipo> <provider>/<agent>`);
     }
-    for (const domain of domains) {
+    for (const unit of units) {
         const [workspace, localOrchestrator, lead, members] = await Promise.all([
-            domain.workspaceId ? getProviderWorkspaceById(domain.workspaceId) : null,
-            resolveTeamAgent(domain.localOrchestratorAgentId),
-            resolveTeamAgent(domain.leadAgentId),
-            listTeamDomainMembers(domain.id),
+            unit.workspaceId ? getProviderWorkspaceById(unit.workspaceId) : null,
+            resolveTeamAgent(unit.localOrchestratorAgentId),
+            resolveTeamAgent(unit.leadAgentId),
+            listTeamUnitMembers(unit.id),
         ]);
         if (!workspace) {
-            status.push(`- ${domain.domainName}: falta workspace/proveedor.`);
+            status.push(`- ${unit.unitName}: falta workspace/proveedor.`);
         }
         else if (!workspace.isEnabled) {
-            status.push(`- ${domain.domainName}: workspace deshabilitado (${workspace.provider}).`);
+            status.push(`- ${unit.unitName}: workspace deshabilitado (${workspace.provider}).`);
         }
         if (!localOrchestrator) {
-            status.push(`- ${domain.domainName}: falta orquestador local. Usa /team domain ${team.name} ${domain.domainName} <provider>/<agent>`);
+            status.push(`- ${unit.unitName}: falta orquestador local. Usa /team equipo ${team.name} ${unit.unitName} <provider>/<agent>`);
         }
         if (!lead) {
-            status.push(`- ${domain.domainName}: falta lead. Usa /team domain ${team.name} ${domain.domainName} <provider>/<agent>`);
+            status.push(`- ${unit.unitName}: falta lead. Usa /team equipo ${team.name} ${unit.unitName} <provider>/<agent>`);
         }
         if (members.length === 0 && localOrchestrator) {
-            status.push(`- ${domain.domainName}: modo autonomo. ${formatTeamAgent(localOrchestrator)} asignara roles internos; miembros extra son opcionales.`);
+            status.push(`- ${unit.unitName}: modo autonomo. ${formatTeamAgent(localOrchestrator)} asignara roles internos; miembros extra son opcionales.`);
         }
     }
     return status;
@@ -262,9 +270,9 @@ async function buildTeamShowMessage(teamName) {
     if (!team) {
         return `No existe el team ${teamName}.`;
     }
-    const domains = await listTeamDomains(team.id);
+    const units = await listTeamUnits(team.id);
     const globalOrchestrator = await resolveTeamAgent(team.globalOrchestratorAgentId);
-    const readinessStatus = await buildTeamReadinessStatus(team, domains);
+    const readinessStatus = await buildTeamReadinessStatus(team, units);
     const lines = [
         `Team: ${team.name}`,
         `ID: ${team.id}`,
@@ -279,23 +287,23 @@ async function buildTeamShowMessage(teamName) {
     else {
         lines.push(...readinessStatus);
     }
-    lines.push('', 'Domains:');
-    if (domains.length === 0) {
-        lines.push('- sin dominios');
+    lines.push('', 'Equipos internos:');
+    if (units.length === 0) {
+        lines.push('- sin equipos internos');
         return lines.join('\n');
     }
-    for (const domain of domains) {
+    for (const unit of units) {
         const [workspace, localOrchestrator, lead] = await Promise.all([
-            domain.workspaceId ? getProviderWorkspaceById(domain.workspaceId) : null,
-            resolveTeamAgent(domain.localOrchestratorAgentId),
-            resolveTeamAgent(domain.leadAgentId),
+            unit.workspaceId ? getProviderWorkspaceById(unit.workspaceId) : null,
+            resolveTeamAgent(unit.localOrchestratorAgentId),
+            resolveTeamAgent(unit.leadAgentId),
         ]);
-        lines.push(`- ${domain.domainName}`);
-        lines.push(`  Workspace: ${formatTeamWorkspace(workspace, domain.workspaceId)}`);
-        lines.push(`  Local orchestrator: ${formatTeamAgent(localOrchestrator, domain.localOrchestratorAgentId)}`);
-        lines.push(`  Lead: ${formatTeamAgent(lead, domain.leadAgentId)}`);
-        lines.push(`  Mode: ${domain.selectionMode}`);
-        const members = await listTeamDomainMembers(domain.id);
+        lines.push(`- ${unit.unitName}`);
+        lines.push(`  Workspace: ${formatTeamWorkspace(workspace, unit.workspaceId)}`);
+        lines.push(`  Local orchestrator: ${formatTeamAgent(localOrchestrator, unit.localOrchestratorAgentId)}`);
+        lines.push(`  Lead: ${formatTeamAgent(lead, unit.leadAgentId)}`);
+        lines.push(`  Mode: ${unit.selectionMode}`);
+        const members = await listTeamUnitMembers(unit.id);
         if (members.length === 0) {
             if (localOrchestrator) {
                 lines.push('  - sin miembros extra; el orquestador/lead opera en modo autonomo');
@@ -348,15 +356,15 @@ async function handleOrchestrator(onDone, teamName, refText) {
         onDone(error instanceof Error ? error.message : String(error));
     }
 }
-async function handleDomain(onDone, teamName, domainName, refText) {
+async function handleDomain(onDone, teamName, unitName, refText) {
     const ref = parseProviderRef(refText);
     if (!ref) {
         onDone('Formato invalido. Usa <provider>/<agent>.');
         return;
     }
-    const normalizedDomain = domainName.trim().toLowerCase();
-    if (!normalizedDomain) {
-        onDone('Debes indicar un dominio valido.');
+    const normalizedUnit = unitName.trim().toLowerCase();
+    if (!normalizedUnit) {
+        onDone('Debes indicar un equipo valido.');
         return;
     }
     const team = await getTeamByName(teamName);
@@ -367,33 +375,33 @@ async function handleDomain(onDone, teamName, domainName, refText) {
     try {
         const { agent, workspaceId, wasCreated } = await resolveAgentRef(ref, {
             createIfMissing: true,
-            roleHint: normalizedDomain,
+            roleHint: normalizedUnit,
         });
-        const domainAgent = await applyDomainAutonomyToAgent(agent, normalizedDomain);
-        const existing = await findDomainByName(team.id, normalizedDomain);
-        const domain = existing
-            ? await updateTeamDomain(existing.id, {
+        const unitAgent = await applyTeamAutonomyToAgent(agent, normalizedUnit);
+        const existing = await findUnitByName(team.id, normalizedUnit);
+        const unit = existing
+            ? await updateTeamUnit(existing.id, {
                 workspaceId,
-                localOrchestratorAgentId: domainAgent.id,
-                leadAgentId: domainAgent.id,
+                localOrchestratorAgentId: unitAgent.id,
+                leadAgentId: unitAgent.id,
                 selectionMode: 'manual',
                 required: true,
             })
-            : await createTeamDomain({
+            : await createTeamUnit({
                 teamId: team.id,
-                domainName: normalizedDomain,
+                unitName: normalizedUnit,
                 workspaceId,
-                localOrchestratorAgentId: domainAgent.id,
-                leadAgentId: domainAgent.id,
+                localOrchestratorAgentId: unitAgent.id,
+                leadAgentId: unitAgent.id,
                 selectionMode: 'manual',
                 required: true,
             });
         onDone([
             wasCreated
-                ? `Agente creado automaticamente: ${formatProviderRef(ref)} con rol ${normalizedDomain}.`
+                ? `Agente creado automaticamente: ${formatProviderRef(ref)} con rol ${normalizedUnit}.`
                 : null,
-            `Autonomia del dominio aplicada: ${formatProviderRef(ref)} queda como orquestador/lead de ${normalizedDomain}.`,
-            `Dominio ${domain.domainName} actualizado en ${team.name}: ${formatProviderRef(ref)}`,
+            `Autonomia del equipo aplicada: ${formatProviderRef(ref)} queda como orquestador/lead de ${normalizedUnit}.`,
+            `Equipo ${unit.unitName} actualizado en ${team.name}: ${formatProviderRef(ref)}`,
         ]
             .filter(Boolean)
             .join('\n'));
@@ -402,15 +410,15 @@ async function handleDomain(onDone, teamName, domainName, refText) {
         onDone(error instanceof Error ? error.message : String(error));
     }
 }
-async function handleAddMember(onDone, teamName, domainName, refText, dutyText) {
+async function handleAddMember(onDone, teamName, unitName, refText, dutyText) {
     const ref = parseProviderRef(refText);
     if (!ref) {
         onDone('Formato invalido. Usa <provider>/<agent>.');
         return;
     }
-    const normalizedDomain = domainName.trim().toLowerCase();
-    if (!normalizedDomain) {
-        onDone('Debes indicar un dominio valido.');
+    const normalizedUnit = unitName.trim().toLowerCase();
+    if (!normalizedUnit) {
+        onDone('Debes indicar un equipo valido.');
         return;
     }
     const team = await getTeamByName(teamName);
@@ -418,26 +426,26 @@ async function handleAddMember(onDone, teamName, domainName, refText, dutyText)
         onDone(`No existe el team ${teamName}.`);
         return;
     }
-    const domain = await findDomainByName(team.id, normalizedDomain);
-    if (!domain) {
-        onDone(`El dominio ${normalizedDomain} no existe en ${teamName}. Usa /team domain primero.`);
+    const unit = await findUnitByName(team.id, normalizedUnit);
+    if (!unit) {
+        onDone(`El equipo ${normalizedUnit} no existe en ${teamName}. Usa /team equipo primero.`);
         return;
     }
     try {
         const { agent } = await resolveAgentRef(ref);
-        const members = await listTeamDomainMembers(domain.id);
+        const members = await listTeamUnitMembers(unit.id);
         const existing = members.find(member => member.agentId === agent.id);
         if (existing) {
-            onDone(`El agente ${formatProviderRef(ref)} ya pertenece a ${teamName}/${normalizedDomain}.`);
+            onDone(`El agente ${formatProviderRef(ref)} ya pertenece a ${teamName}/${normalizedUnit}.`);
             return;
         }
-        await createTeamDomainMember({
-            teamDomainId: domain.id,
+        await createTeamUnitMember({
+            teamUnitId: unit.id,
             agentId: agent.id,
             duty: dutyText?.trim() || null,
             priority: 0,
         });
-        onDone(`Miembro agregado a ${teamName}/${normalizedDomain}: ${formatProviderRef(ref)}${dutyText?.trim() ? ` [${dutyText.trim()}]` : ''}`);
+        onDone(`Miembro agregado a ${teamName}/${normalizedUnit}: ${formatProviderRef(ref)}${dutyText?.trim() ? ` [${dutyText.trim()}]` : ''}`);
     }
     catch (error) {
         onDone(error instanceof Error ? error.message : String(error));
@@ -561,9 +569,9 @@ export async function call(onDone, _context, args) {
         await handleOrchestrator(onDone, first, second);
         return null;
     }
-    if (parsed.command === 'domain') {
+    if (parsed.command === 'equipo') {
         if (!first || !second || !third) {
-            onDone('Uso: /team domain <team> <domain> <provider>/<agent>');
+            onDone('Uso: /team equipo <team> <equipo> <provider>/<agent>');
             return null;
         }
         await handleDomain(onDone, first, second, third);
@@ -571,12 +579,12 @@ export async function call(onDone, _context, args) {
     }
     if (parsed.command === 'add-member') {
         if (!first || !second || !third) {
-            onDone('Uso: /team add-member <team> <domain> <provider>/<agent> [duty]');
+            onDone('Uso: /team add-member <team> <equipo> <provider>/<agent> [duty]');
             return null;
         }
         await handleAddMember(onDone, first, second, third, rest.join(' '));
         return null;
     }
-    onDone('Uso: /team list, /team create <name>, /team show <name>, /team orchestrator <team> <provider>/<agent>, /team domain <team> <domain> <provider>/<agent>, /team add-member <team> <domain> <provider>/<agent> [duty]');
+    onDone('Uso: /team list, /team create <name>, /team show <name>, /team orchestrator <team> <provider>/<agent>, /team equipo <team> <equipo> <provider>/<agent>, /team add-member <team> <equipo> <provider>/<agent> [duty]');
     return null;
 }

package/dist/src/commands/team-auto/teamAuto.js

@@ -3,17 +3,76 @@ import * as React from 'react';
 import { Box, Text, useInput } from '../../ink.js';
 import { getActiveProviderProfile, listProviderProfiles, } from '../../utils/model/providerProfiles.js';
 import { setProviderWorkspaceEnabled } from '../../utils/model/providerWorkspaces.js';
-import { createTeam, createTeamDomain, getProviderWorkspaceByProvider, getTeamByName, listTeamDomains, updateTeam, updateTeamDomain, upsertProviderWorkspace, } from '../../utils/orchestration/store/index.js';
+import { createTeam, createTeamUnit, getProviderWorkspaceByProvider, getTeamByName, listTeamUnits, updateProviderAgent, updateTeam, updateTeamUnit, upsertProviderAgentCapability, upsertProviderWorkspace, } from '../../utils/orchestration/store/index.js';
 import { createAgent, getAgent, setAgentOrchestratorByName, setAgentRoleByName, } from '../agent/agentStore.js';
-const STANDARD_DOMAINS = ['frontend', 'backend', 'docs', 'planning'];
+const STANDARD_UNITS = ['frontend', 'backend', 'docs', 'planning'];
 function pickFirstProfileForProvider(profiles, provider, active) {
     if (active && active.provider === provider) {
         return active;
     }
     return profiles.find(p => p.provider === provider) ?? null;
 }
-function buildAgentNameForDomain(domain) {
-    return `${domain}-lead`;
+function buildAgentNameForUnit(unit) {
+    return `${unit}-lead`;
+}
+function getTeamAutonomyProfile(unitName) {
+    const common = [
+        { name: 'planning', weight: 0.8 },
+        { name: 'self-assign-roles', weight: 1 },
+        { name: 'risk-reporting', weight: 0.8 },
+        { name: 'squad-reporting', weight: 1 },
+    ];
+    const byUnit = {
+        backend: [
+            { name: 'api-design', weight: 1 },
+            { name: 'database-design', weight: 0.9 },
+            { name: 'server-implementation', weight: 1 },
+            { name: 'backend-testing', weight: 0.8 },
+        ],
+        frontend: [
+            { name: 'ui-architecture', weight: 1 },
+            { name: 'component-design', weight: 1 },
+            { name: 'state-management', weight: 0.8 },
+            { name: 'frontend-testing', weight: 0.8 },
+        ],
+        docs: [
+            { name: 'technical-writing', weight: 1 },
+            { name: 'readme-maintenance', weight: 1 },
+            { name: 'developer-guides', weight: 0.9 },
+        ],
+        planning: [
+            { name: 'requirements-analysis', weight: 1 },
+            { name: 'task-breakdown', weight: 1 },
+            { name: 'cross-team-coordination', weight: 1 },
+        ],
+    };
+    return {
+        role: unitName,
+        capabilities: [...common, ...byUnit[unitName]],
+        systemPrompt: [
+            `Eres el orquestador autonomo del equipo ${unitName}.`,
+            'Tu responsabilidad es tomar el objetivo recibido, dividirlo en roles internos temporales y reportar avances claros al orquestador global.',
+            'Si no hay miembros extra en el escuadron, asume internamente los roles necesarios para este equipo y explica que roles asumiste.',
+            'Reporta: trabajo realizado, decisiones, riesgos, bloqueos, porcentaje estimado y siguientes pasos.',
+        ].join('\n'),
+    };
+}
+async function applyTeamAutonomy(agent, unitName) {
+    const profile = getTeamAutonomyProfile(unitName);
+    await updateProviderAgent(agent.id, {
+        roleKind: profile.role,
+        isOrchestrator: true,
+        autonomyLevel: 'team-autonomous',
+        systemPrompt: agent.systemPrompt?.trim() ? agent.systemPrompt : profile.systemPrompt,
+    });
+    for (const capability of profile.capabilities) {
+        await upsertProviderAgentCapability({
+            agentId: agent.id,
+            capability: capability.name,
+            weight: capability.weight,
+        });
+    }
+    return (await getAgent(agent.provider, agent.name)) ?? agent;
 }
 async function isAgentExisting(provider, agentName) {
     const existing = await getAgent(provider, agentName);
@@ -40,15 +99,15 @@ async function buildPlan(args) {
         }
     }
     const existingTeam = await getTeamByName(teamName);
-    const assignments = STANDARD_DOMAINS.map(domain => ({
-        domain,
+    const assignments = STANDARD_UNITS.map(unit => ({
+        unit,
         provider: null,
         profile: null,
         agentName: null,
         agentExists: false,
     }));
-    const setAssignment = async (domain, provider) => {
-        const slot = assignments.find(a => a.domain === domain);
+    const setAssignment = async (unit, provider) => {
+        const slot = assignments.find(a => a.unit === unit);
         if (!slot)
             return;
         if (!provider) {
@@ -61,7 +120,7 @@ async function buildPlan(args) {
         const profile = pickFirstProfileForProvider(profiles, provider, active);
         if (!profile)
             return;
-        const agentName = buildAgentNameForDomain(domain);
+        const agentName = buildAgentNameForUnit(unit);
         slot.provider = provider;
         slot.profile = profile;
         slot.agentName = agentName;
@@ -70,8 +129,8 @@ async function buildPlan(args) {
     const isAutonomousSingle = providerOrder.length === 1;
     if (isAutonomousSingle) {
         const onlyProvider = providerOrder[0];
-        for (const domain of STANDARD_DOMAINS) {
-            await setAssignment(domain, onlyProvider);
+        for (const unit of STANDARD_UNITS) {
+            await setAssignment(unit, onlyProvider);
         }
     }
     else {
@@ -109,7 +168,7 @@ async function buildPlan(args) {
             // Prefer to round-robin by using a provider already assigned (so we still
             // keep things diverse but don't leave domains empty).
             const fallbackProvider = providerOrder[0];
-            await setAssignment(slot.domain, fallbackProvider);
+            await setAssignment(slot.unit, fallbackProvider);
         }
     }
     // Determine global orchestrator: pick first provider that has an isOrchestrator agent already,
@@ -163,10 +222,10 @@ async function buildPlan(args) {
 }
 function describeAssignment(slot) {
     if (!slot.provider || !slot.profile || !slot.agentName) {
-        return `- ${slot.domain.padEnd(8)} -> sin asignar`;
+        return `- ${slot.unit.padEnd(8)} -> sin asignar`;
     }
     const reuseTag = slot.agentExists ? '[reusar]' : '[crear nuevo]';
-    return `- ${slot.domain.padEnd(8)} -> ${slot.provider}/${slot.profile.name} (${slot.provider}/${slot.agentName}) ${reuseTag}`;
+    return `- ${slot.unit.padEnd(8)} -> ${slot.provider}/${slot.profile.name} (${slot.provider}/${slot.agentName}) ${reuseTag}`;
 }
 function describeGlobal(plan) {
     if (!plan.globalProvider || !plan.globalAgentName) {
@@ -198,7 +257,7 @@ async function applyPlan(plan) {
         messages.push(`Team creado: ${team.name}`);
     }
     // Step 3: create or reuse agents per assignment.
-    const agentsByDomain = new Map();
+    const agentsByUnit = new Map();
     for (const slot of plan.assignments) {
         if (!slot.provider || !slot.agentName)
             continue;
@@ -209,9 +268,10 @@ async function applyPlan(plan) {
                 name: slot.agentName,
                 profileName: slot.profile?.name,
             }));
-        // Apply role hint matching the domain (best-effort).
-        const withRole = await setAgentRoleByName(slot.provider, slot.agentName, slot.domain);
-        agentsByDomain.set(slot.domain, withRole ?? agent);
+        // The domain lead is also the local orchestrator for that domain.
+        const withRole = await setAgentRoleByName(slot.provider, slot.agentName, slot.unit);
+        const autonomousAgent = await applyTeamAutonomy(withRole ?? agent, slot.unit);
+        agentsByUnit.set(slot.unit, autonomousAgent);
     }
     // Step 4: ensure global orchestrator agent + flag.
     let globalAgent = null;
@@ -233,38 +293,38 @@ async function applyPlan(plan) {
         messages.push(`Orquestador global asignado: ${plan.globalProvider}/${plan.globalAgentName}`);
     }
     // Step 5: create/update domains.
-    const existingDomains = await listTeamDomains(team.id);
-    const existingByName = new Map(existingDomains.map(d => [d.domainName.toLowerCase(), d]));
+    const existingUnits = await listTeamUnits(team.id);
+    const existingByName = new Map(existingUnits.map(unit => [unit.unitName.toLowerCase(), unit]));
     for (const slot of plan.assignments) {
         if (!slot.provider || !slot.agentName)
             continue;
-        const agent = agentsByDomain.get(slot.domain);
+        const agent = agentsByUnit.get(slot.unit);
         if (!agent)
             continue;
         const workspace = (await getProviderWorkspaceByProvider(slot.provider)) ??
             (await upsertProviderWorkspace({ provider: slot.provider, isEnabled: true }));
-        const existingDomain = existingByName.get(slot.domain);
-        if (existingDomain) {
-            await updateTeamDomain(existingDomain.id, {
+        const existingUnit = existingByName.get(slot.unit);
+        if (existingUnit) {
+            await updateTeamUnit(existingUnit.id, {
                 workspaceId: workspace.id,
                 localOrchestratorAgentId: agent.id,
                 leadAgentId: agent.id,
                 selectionMode: 'manual',
                 required: true,
             });
-            messages.push(`Dominio actualizado: ${slot.domain}`);
+            messages.push(`Equipo actualizado: ${slot.unit}`);
         }
         else {
-            await createTeamDomain({
+            await createTeamUnit({
                 teamId: team.id,
-                domainName: slot.domain,
+                unitName: slot.unit,
                 workspaceId: workspace.id,
                 localOrchestratorAgentId: agent.id,
                 leadAgentId: agent.id,
                 selectionMode: 'manual',
                 required: true,
             });
-            messages.push(`Dominio creado: ${slot.domain}`);
+            messages.push(`Equipo creado: ${slot.unit}`);
         }
     }
     return { team, messages };
@@ -323,7 +383,7 @@ function PlanReview({ plan, onDone, }) {
     if (phase === 'review') {
         return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { bold: true, children: ["Auto-configuracion para team ", plan.teamName] }), plan.teamExists ? (_jsx(Text, { color: "yellow", children: "team existente: se actualizara" })) : null, _jsxs(Text, { children: ["Detectados ", plan.detectedProfilesCount, " perfiles activos", plan.detectedProviders.length > 0
                             ? ` (${plan.detectedProviders.join(', ')})`
-                            : '', "."] }), plan.isAutonomousSingle ? (_jsx(Text, { dimColor: true, children: "Solo un proveedor disponible: ese agente cubrira todos los dominios en modo autonomo." })) : null, _jsx(Box, { marginTop: 1, flexDirection: "column", children: plan.assignments.map(slot => (_jsx(Text, { children: describeAssignment(slot) }, slot.domain))) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { children: describeGlobal(plan) }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "[Enter] Aplicar  |  [Esc] Cancelar" }) })] }));
+                            : '', "."] }), plan.isAutonomousSingle ? (_jsx(Text, { dimColor: true, children: "Solo un proveedor disponible: ese agente cubrira todos los equipos internos en modo autonomo." })) : null, _jsx(Box, { marginTop: 1, flexDirection: "column", children: plan.assignments.map(slot => (_jsx(Text, { children: describeAssignment(slot) }, slot.unit))) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { children: describeGlobal(plan) }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "[Enter] Aplicar  |  [Esc] Cancelar" }) })] }));
     }
     if (phase === 'applying') {
         return (_jsx(Box, { flexDirection: "column", children: _jsxs(Text, { bold: true, children: ["Aplicando auto-configuracion para ", plan.teamName, "..."] }) }));

package/dist/src/commands/terminalSetup/terminalSetup.js

@@ -136,8 +136,8 @@ export function markBackslashReturnUsed() {
 }
 export async function call(onDone, context, _args) {
     if (env.terminal && env.terminal in NATIVE_CSIU_TERMINALS) {
-        const message = `Shift+Enter is natively supported in ${NATIVE_CSIU_TERMINALS[env.terminal]}.
-
+        const message = `Shift+Enter is natively supported in ${NATIVE_CSIU_TERMINALS[env.terminal]}.
+
 No configuration needed. Just use Shift+Enter to add newlines.`;
         onDone(message);
         return null;
@@ -156,18 +156,18 @@ No configuration needed. Just use Shift+Enter to add newlines.`;
         }
         // For Linux and other platforms, we don't show native terminal options
         // since they're not currently supported
-        const message = `Terminal setup cannot be run from ${terminalName}.
-
-This command configures a convenient Shift+Enter shortcut for multi-line prompts.
-${chalk.dim('Note: You can already use backslash (\\\\) + return to add newlines.')}
-
-To set up the shortcut (optional):
-1. Exit tmux/screen temporarily
-2. Run /terminal-setup directly in one of these terminals:
-${platformTerminals}   • IDE: VSCode, Cursor, Windsurf, Zed
-   • Other: Alacritty
-3. Return to tmux/screen - settings will persist
-
+        const message = `Terminal setup cannot be run from ${terminalName}.
+
+This command configures a convenient Shift+Enter shortcut for multi-line prompts.
+${chalk.dim('Note: You can already use backslash (\\\\) + return to add newlines.')}
+
+To set up the shortcut (optional):
+1. Exit tmux/screen temporarily
+2. Run /terminal-setup directly in one of these terminals:
+${platformTerminals}   • IDE: VSCode, Cursor, Windsurf, Zed
+   • Other: Alacritty
+3. Return to tmux/screen - settings will persist
+
 ${chalk.dim('Note: iTerm2, WezTerm, Ghostty, Kitty, and Warp support Shift+Enter natively.')}`;
         onDone(message);
         return null;
@@ -180,13 +180,13 @@ async function installBindingsForVSCodeTerminal(editor = 'VSCode', theme) {
     // Check if we're running in a VSCode Remote SSH session
     // In this case, keybindings need to be installed on the LOCAL machine
     if (isVSCodeRemoteSSH()) {
-        return `${color('warning', theme)(`Cannot install keybindings from a remote ${editor} session.`)}${EOL}${EOL}${editor} keybindings must be installed on your local machine, not the remote server.${EOL}${EOL}To install the Shift+Enter keybinding:${EOL}1. Open ${editor} on your local machine (not connected to remote)${EOL}2. Open the Command Palette (Cmd/Ctrl+Shift+P) → "Preferences: Open Keyboard Shortcuts (JSON)"${EOL}3. Add this keybinding (the file must be a JSON array):${EOL}${EOL}${chalk.dim(`[
-  {
-    "key": "shift+enter",
-    "command": "workbench.action.terminal.sendSequence",
-    "args": { "text": "\\u001b\\r" },
-    "when": "terminalFocus"
-  }
+        return `${color('warning', theme)(`Cannot install keybindings from a remote ${editor} session.`)}${EOL}${EOL}${editor} keybindings must be installed on your local machine, not the remote server.${EOL}${EOL}To install the Shift+Enter keybinding:${EOL}1. Open ${editor} on your local machine (not connected to remote)${EOL}2. Open the Command Palette (Cmd/Ctrl+Shift+P) → "Preferences: Open Keyboard Shortcuts (JSON)"${EOL}3. Add this keybinding (the file must be a JSON array):${EOL}${EOL}${chalk.dim(`[
+  {
+    "key": "shift+enter",
+    "command": "workbench.action.terminal.sendSequence",
+    "args": { "text": "\\u001b\\r" },
+    "when": "terminalFocus"
+  }
 ]`)}${EOL}`;
     }
     const editorDir = editor === 'VSCode' ? 'Code' : editor;
@@ -336,9 +336,9 @@ async function enableOptionAsMetaForTerminal(theme) {
     }
 }
 async function installBindingsForAlacritty(theme) {
-    const ALACRITTY_KEYBINDING = `[[keyboard.bindings]]
-key = "Return"
-mods = "Shift"
+    const ALACRITTY_KEYBINDING = `[[keyboard.bindings]]
+key = "Return"
+mods = "Shift"
 chars = "\\u001B\\r"`;
     // Get Alacritty config file paths in order of preference
     const configPaths = [];

package/dist/src/commands/usage/index.js

@@ -0,0 +1,7 @@
+export default {
+    type: 'local-jsx',
+    name: 'usage',
+    description: 'Muestra los límites de uso del plan',
+    availability: ['claude-ai'],
+    load: () => import('./usage.js'),
+};

package/dist/src/commands/usage/usage.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Settings } from '../../components/Settings/Settings.js';
+export const call = async (onDone, context) => {
+    return _jsx(Settings, { onClose: onDone, context: context, defaultTab: "Usage" });
+};