@lucashca/claudecontrol 0.3.30 → 0.3.32

package/backend/agents/canUseTool.ts

@@ -45,11 +45,6 @@ export function createBypassCanUseTool(agentId: string, workspaceId: string) {
  */
 export function createCanUseTool(agentId: string, workspaceId: string, isOrchestrator = false) {
   return (toolName: string, input: Record<string, unknown>, options: CanUseToolOptions) => {
-    if (toolName === 'Task' && !isOrchestrator) {
-      const session = agents.get(agentId);
-      if (session) pushLog(session, { type: 'system', text: 'Subagente bloqueado: apenas orquestradores podem iniciar subagentes', timestamp: new Date().toISOString() });
-      return Promise.resolve({ behavior: 'deny' as const, message: 'Apenas orquestradores podem iniciar subagentes' });
-    }
     const requestId = genId();
     const session = agents.get(agentId);
 

package/backend/agents/lifecycle.ts

@@ -368,8 +368,9 @@ export async function runAgentQuery(session: AgentSession, task: string, bypass
   const isOrchestrator = session.isOrchestrator === true || session.role === getOrchestratorRole(session.workspaceId);
   const subagents = (isOrchestrator && runtime.enableSubagents) ? buildSubagents(cwd, session.role) : {};
   const poolContext = (!runtime.enableSubagents && isOrchestrator) ? buildPoolContext(session.workspaceId, session.id) : '';
+  const specialistCtx = !isOrchestrator && !session.canSpawnSubagents ? '[INSTRUCAO] Voce e um especialista. Execute suas tarefas diretamente usando suas proprias ferramentas. Nao use o Agent tool nem inicie subagentes.' : '';
   // poolContext first so the model sees the delegation rules before the role instructions
-  const systemAppend = [poolContext, customContext, context].filter(Boolean).join('\n\n');
+  const systemAppend = [poolContext, specialistCtx, customContext, context].filter(Boolean).join('\n\n');
   const prompt = task;
 
   const abortController = new AbortController();

package/backend/routes/agents.ts

@@ -24,6 +24,7 @@ export async function handleAgentRoutes(
     const role = body.role as string;
     if (!role) { jsonError(res, 'role is required'); return true; }
 
+    const template = workspace.roleTemplates?.[role];
     const task = (body.task as string) || `Voce e o agente ${role}. Leia o CLAUDE.md. Diga que esta pronto.`;
     const bypass = body.bypass === true;
     const spawnedBy = (body.spawnedBy as string) || undefined;
@@ -54,6 +55,9 @@ export async function handleAgentRoutes(
       lastActivity: new Date().toISOString(),
       currentTask: task,
       log: [initEntry],
+      ...(template?.model && { model: template.model }),
+      ...(template?.isOrchestrator !== undefined && { isOrchestrator: template.isOrchestrator }),
+      ...(template?.canSpawnSubagents !== undefined && { canSpawnSubagents: template.canSpawnSubagents }),
     };
 
     addAgentToIndex(agentSession);
@@ -75,6 +79,7 @@ export async function handleAgentRoutes(
     const body = await parseBody(req);
     if (body.customName !== undefined) agent.customName = body.customName as string;
     if (body.isOrchestrator !== undefined) agent.isOrchestrator = body.isOrchestrator as boolean;
+    if (body.canSpawnSubagents !== undefined) agent.canSpawnSubagents = body.canSpawnSubagents as boolean;
     persistAgents();
     broadcast({ type: 'agent_updated', agentId: agent.id, workspaceId: agent.workspaceId, agent });
     json(res, agent);

package/backend/routes/workspaces.ts

@@ -3,7 +3,7 @@ import { readdirSync, statSync, mkdirSync } from 'fs';
 import { resolve } from 'path';
 import { homedir } from 'os';
 import { listExistingSessions } from '../sessions.js';
-import { loadWorkspaces, addWorkspace, removeWorkspace, updateWorkspace, getWorkspaceById, type Workspace } from '../workspaces.js';
+import { loadWorkspaces, addWorkspace, removeWorkspace, updateWorkspace, getWorkspaceById, type Workspace, type RoleTemplate } from '../workspaces.js';
 import { json, jsonError, parseBody, matchRoute } from '../http.js';
 import { broadcast } from '../ws.js';
 import { genId, agentsByWorkspace, removeAgentFromIndex, getAgentsForWorkspace } from '../agents/store.js';
@@ -142,6 +142,33 @@ export async function handleWorkspaceRoutes(
     return true;
   }
 
+  // ── GET /api/workspaces/:id/role-template/:role ──
+  // ── PUT /api/workspaces/:id/role-template/:role ──
+  const roleTemplateParams = matchRoute(path, '/api/workspaces/:id/role-template/:role');
+  if (roleTemplateParams) {
+    const workspace = getWorkspaceById(roleTemplateParams.id);
+    if (!workspace) { jsonError(res, 'Workspace not found', 404); return true; }
+
+    if (method === 'GET') {
+      const tpl = workspace.roleTemplates?.[roleTemplateParams.role] ?? {};
+      json(res, tpl);
+      return true;
+    }
+
+    if (method === 'PUT') {
+      const body = await parseBody(req);
+      const tpl: RoleTemplate = {
+        model: (body.model as string) || undefined,
+        isOrchestrator: body.isOrchestrator as boolean | undefined,
+        canSpawnSubagents: body.canSpawnSubagents as boolean | undefined,
+      };
+      const templates = { ...(workspace.roleTemplates || {}), [roleTemplateParams.role]: tpl };
+      updateWorkspace(roleTemplateParams.id, { roleTemplates: templates });
+      json(res, tpl);
+      return true;
+    }
+  }
+
   // ── DELETE /api/workspaces/:id ──
   const wsDeleteParams = matchRoute(path, '/api/workspaces/:id');
   if (wsDeleteParams && method === 'DELETE') {

package/backend/types.ts

@@ -92,4 +92,5 @@ export interface AgentSession {
   lastContextTokens?: number; // cache_read_input_tokens from last turn = current context size
   model?: string;             // per-agent model override
   isOrchestrator?: boolean;   // only orchestrators can delegate to other agents
+  canSpawnSubagents?: boolean; // allows using Agent tool even for non-orchestrators
 }

package/backend/workspaces.ts

@@ -6,6 +6,12 @@ function workspacesFile(): string {
   return resolve(getDataDir(), 'workspaces.json');
 }
 
+export interface RoleTemplate {
+  model?: string;
+  isOrchestrator?: boolean;
+  canSpawnSubagents?: boolean;
+}
+
 export interface Workspace {
   id: string;
   name: string;
@@ -13,6 +19,7 @@ export interface Workspace {
   agents: string[];  // roles disponiveis neste workspace
   color: string;
   orchestratorRole?: string; // role that acts as orchestrator (gets subagent tools + pool context)
+  roleTemplates?: Record<string, RoleTemplate>; // per-role default config
 }
 
 const DEFAULT_WORKSPACES: Workspace[] = [];

package/frontend/src/api.ts

@@ -116,6 +116,12 @@ export const api = {
   getClaudeAccount: () => get('/settings/claude-account'),
   openVSCode: (wsId: string) => post(`/workspaces/${wsId}/open-vscode`),
 
+  getRoleTemplate: (wsId: string, role: string) =>
+    get(`/workspaces/${wsId}/role-template/${encodeURIComponent(role)}`) as Promise<import('./types').RoleTemplate>,
+
+  updateRoleTemplate: (wsId: string, role: string, template: import('./types').RoleTemplate) =>
+    put(`/workspaces/${wsId}/role-template/${encodeURIComponent(role)}`, template) as Promise<import('./types').RoleTemplate>,
+
   respondSpawnRequest: (requestId: string, approved: boolean, maxCount?: number, approvedRoles?: string[]) =>
     post(`/agents/spawn-request/${requestId}/respond`, { approved, maxCount, approvedRoles }),
 

package/frontend/src/components/ChatPanel.tsx

@@ -1,5 +1,5 @@
 import type { LucideIcon } from 'lucide-react';
-import { Blocks, Code2, TestTube2, Cloud, Database, Layout, ChevronRight, Loader2, GitBranch, Square } from 'lucide-react';
+import { Blocks, Code2, TestTube2, Cloud, Database, Layout, ChevronRight, Loader2, GitBranch, Square, Network } from 'lucide-react';
 import { useAtomValue } from 'jotai';
 import { useState } from 'react';
 import { agentsMapAtom } from '@/atoms';
@@ -59,6 +59,10 @@ export function ChatPanel({ agentId, compact }: { agentId: string; compact?: boo
     api.patchAgent(agentId, { isOrchestrator: !agent!.isOrchestrator }).catch(() => {});
   }
 
+  function handleToggleSubagents() {
+    api.patchAgent(agentId, { canSpawnSubagents: !agent!.canSpawnSubagents }).catch(() => {});
+  }
+
   return (
     <div className="flex flex-1 flex-col min-w-0 min-h-0 h-full overflow-hidden bg-cc-panel">
       {/* Header */}
@@ -79,6 +83,18 @@ export function ChatPanel({ agentId, compact }: { agentId: string; compact?: boo
           </div>
         </div>
         <div className="flex items-center gap-2">
+          <Tooltip text={agent.canSpawnSubagents ? 'Subagentes ativados' : 'Ativar subagentes'} position="bottom">
+            <button
+              onClick={handleToggleSubagents}
+              className={`inline-flex items-center justify-center w-6 h-6 rounded-md border-none cursor-pointer transition-colors ${
+                agent.canSpawnSubagents
+                  ? 'text-cc-info bg-cc-info/15 hover:bg-cc-info/25'
+                  : 'text-cc-muted hover:text-cc-text-secondary hover:bg-cc-surface'
+              }`}
+            >
+              <Network size={12} />
+            </button>
+          </Tooltip>
           <Tooltip text={agent.isOrchestrator ? 'Orquestrador — pode delegar' : 'Marcar como orquestrador'} position="bottom">
             <button
               onClick={handleToggleOrchestrator}

package/frontend/src/components/side/RoleItem.tsx

@@ -1,11 +1,18 @@
-import { useState } from 'react';
+import { useState, useEffect } from 'react';
 import type { LucideIcon } from 'lucide-react';
 import {
   Blocks, Code2, TestTube2, Cloud, Database, Layout,
-  MessageCircle, Bot, Plus, ArrowRightFromLine,
+  MessageCircle, Bot, Plus, ArrowRightFromLine, Settings, Check,
 } from 'lucide-react';
+import { useAtomValue } from 'jotai';
+import { getDefaultStore } from 'jotai';
 import { AGENT_LABELS } from '@/types';
-import type { RoleInfo } from '@/types';
+import type { RoleInfo, RoleTemplate } from '@/types';
+import { activeWorkspaceAtom, workspacesAtom } from '@/atoms';
+import { api } from '@/api';
+import { Dialog } from '@/ui';
+
+const store = getDefaultStore();
 
 const ROLE_ICON: Record<string, LucideIcon> = {
   arquiteto: Blocks, dev: Code2, qa: TestTube2,
@@ -13,6 +20,13 @@ const ROLE_ICON: Record<string, LucideIcon> = {
   chat: MessageCircle,
 };
 
+const MODEL_OPTIONS = [
+  { value: '', label: 'Padrão do sistema' },
+  { value: 'claude-opus-4-5', label: 'Opus 4.5 — mais capaz' },
+  { value: 'claude-sonnet-4-5', label: 'Sonnet 4.5 — equilibrado' },
+  { value: 'claude-haiku-4-5', label: 'Haiku 4.5 — mais rápido' },
+];
+
 function label(name: string) {
   return AGENT_LABELS[name] || name.replace(/^agent-/, '').replace(/-/g, ' ');
 }
@@ -23,10 +37,114 @@ interface RoleItemProps {
   onInject: (name: string, type?: 'agent' | 'command') => void;
 }
 
+function Toggle({ value, onChange, children }: { value: boolean; onChange: (v: boolean) => void; children: string }) {
+  return (
+    <label className="flex items-center justify-between cursor-pointer py-0.5">
+      <span className="text-sm text-cc-text-secondary">{children}</span>
+      <div
+        onClick={() => onChange(!value)}
+        className={`w-8 h-4.5 rounded-full transition-colors flex items-center px-0.5 cursor-pointer shrink-0 ${value ? 'bg-cc-accent' : 'bg-cc-border'}`}
+        style={{ height: '18px', width: '32px' }}
+      >
+        <div className={`w-3 h-3 rounded-full bg-white transition-transform ${value ? 'translate-x-3.5' : 'translate-x-0'}`} />
+      </div>
+    </label>
+  );
+}
+
+function TemplateDialog({ roleName, wsId, open, onClose }: {
+  roleName: string;
+  wsId: string;
+  open: boolean;
+  onClose: () => void;
+}) {
+  const [model, setModel] = useState('');
+  const [isOrch, setIsOrch] = useState(false);
+  const [subagents, setSubagents] = useState(false);
+  const [loading, setLoading] = useState(false);
+  const [saving, setSaving] = useState(false);
+
+  useEffect(() => {
+    if (!open) return;
+    setLoading(true);
+    api.getRoleTemplate(wsId, roleName).then(tpl => {
+      setModel(tpl.model || '');
+      setIsOrch(tpl.isOrchestrator ?? false);
+      setSubagents(tpl.canSpawnSubagents ?? false);
+    }).finally(() => setLoading(false));
+  }, [open, wsId, roleName]);
+
+  async function save() {
+    setSaving(true);
+    try {
+      const tpl: RoleTemplate = {
+        model: model || undefined,
+        isOrchestrator: isOrch,
+        canSpawnSubagents: subagents,
+      };
+      const saved = await api.updateRoleTemplate(wsId, roleName, tpl);
+      const ws = store.get(workspacesAtom);
+      store.set(workspacesAtom, ws.map(w =>
+        w.id === wsId ? { ...w, roleTemplates: { ...(w.roleTemplates || {}), [roleName]: saved } } : w,
+      ));
+      onClose();
+    } finally {
+      setSaving(false);
+    }
+  }
+
+  return (
+    <Dialog open={open} onClose={onClose} title={`Template — ${label(roleName)}`}>
+      {loading ? (
+        <div className="py-6 flex justify-center text-sm text-cc-muted">Carregando...</div>
+      ) : (
+        <div className="flex flex-col gap-4">
+          <div className="flex flex-col gap-1.5">
+            <label className="text-xs font-medium text-cc-text-secondary">Modelo</label>
+            <select
+              value={model}
+              onChange={e => setModel(e.target.value)}
+              className="text-sm bg-cc-bg border border-cc-border rounded-lg px-3 py-2 text-cc-text outline-none focus:border-cc-accent/60 cursor-pointer"
+            >
+              {MODEL_OPTIONS.map(o => (
+                <option key={o.value} value={o.value}>{o.label}</option>
+              ))}
+            </select>
+          </div>
+
+          <div className="flex flex-col gap-2 border-t border-cc-border/40 pt-3">
+            <Toggle value={isOrch} onChange={setIsOrch}>Orquestrador — pode delegar tarefas</Toggle>
+            <Toggle value={subagents} onChange={setSubagents}>Subagentes — pode usar Agent tool</Toggle>
+          </div>
+
+          <div className="flex justify-end gap-2 pt-1">
+            <button
+              onClick={onClose}
+              className="px-4 py-1.5 rounded-lg text-sm text-cc-muted hover:text-cc-text-secondary hover:bg-cc-surface transition-colors"
+            >
+              Cancelar
+            </button>
+            <button
+              onClick={save}
+              disabled={saving}
+              className="flex items-center gap-1.5 px-4 py-1.5 rounded-lg text-sm bg-cc-accent text-cc-bg font-medium hover:opacity-90 transition-opacity disabled:opacity-50"
+            >
+              <Check size={13} /> {saving ? 'Salvando...' : 'Salvar'}
+            </button>
+          </div>
+        </div>
+      )}
+    </Dialog>
+  );
+}
+
 export function RoleItem({ role, onSpawn, onInject }: RoleItemProps) {
   const [open, setOpen] = useState(false);
+  const [dialogOpen, setDialogOpen] = useState(false);
+  const workspace = useAtomValue(activeWorkspaceAtom);
   const Icon = ROLE_ICON[role.name] || Bot;
   const t = role.type as 'agent' | 'command';
+  const hasTemplate = workspace?.roleTemplates?.[role.name] !== undefined;
 
   return (
     <div>
@@ -36,6 +154,7 @@ export function RoleItem({ role, onSpawn, onInject }: RoleItemProps) {
       >
         <Icon size={12} className="text-cc-muted shrink-0" />
         <span className="flex-1 text-[11px] truncate">{label(role.name)}</span>
+        {hasTemplate && <span className="w-1.5 h-1.5 rounded-full bg-cc-accent/60 shrink-0" title="Template configurado" />}
       </div>
       {open && (
         <div className="ml-5 mb-1 flex flex-col gap-0.5">
@@ -51,8 +170,22 @@ export function RoleItem({ role, onSpawn, onInject }: RoleItemProps) {
           >
             <Plus size={10} /> Novo chat
           </button>
+          <button
+            onClick={() => { setDialogOpen(true); setOpen(false); }}
+            className="flex items-center gap-1.5 px-2 py-1 rounded text-[10px] text-cc-muted hover:text-cc-text-secondary hover:bg-cc-surface transition-colors text-left"
+          >
+            <Settings size={10} /> Configurar template
+          </button>
         </div>
       )}
+      {workspace && (
+        <TemplateDialog
+          roleName={role.name}
+          wsId={workspace.id}
+          open={dialogOpen}
+          onClose={() => setDialogOpen(false)}
+        />
+      )}
     </div>
   );
 }

package/frontend/src/types/index.ts

@@ -1,3 +1,9 @@
+export interface RoleTemplate {
+  model?: string;
+  isOrchestrator?: boolean;
+  canSpawnSubagents?: boolean;
+}
+
 export interface Workspace {
   id: string;
   name: string;
@@ -5,6 +11,7 @@ export interface Workspace {
   agents: string[];
   color: string;
   orchestratorRole?: string;
+  roleTemplates?: Record<string, RoleTemplate>;
 }
 
 export interface Agent {
@@ -19,6 +26,7 @@ export interface Agent {
   customName?: string;
   closed?: boolean;
   isOrchestrator?: boolean;
+  canSpawnSubagents?: boolean;
   todos?: Array<{ content: string; status: 'pending' | 'in_progress' | 'completed'; activeForm: string }>;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lucashca/claudecontrol",
-  "version": "0.3.30",
+  "version": "0.3.32",
   "description": "AI Agent Dashboard — manage multiple Claude Code agents across projects",
   "type": "module",
   "bin": {

package/version.json

@@ -1 +1 @@
-{"version":"0.3.30","build":"2026-04-03T23:54:10.502Z"}
+{"version":"0.3.32","build":"2026-04-04T00:22:18.525Z"}