Executar o projeto (F5)

Pressione F5 e o Context Code inicia o seu projeto. Não uma lista de coisas compiláveis: uma configuração concreta, a que você marcou como projeto de inicialização, igual ao Visual Studio.

Configurações de lançamento

Ao abrir um projeto, o app percorre suas pastas (até três níveis, pulando node_modules, target, dist, build, .git…) e deduz tudo o que pode ser executado:

Pista no disco	Configuração oferecida
`*.sln`	uma por cada projeto executável da solução (`OutputType Exe` ou SDK Web/Worker)
`.csproj` / `.fsproj` / `*.vbproj`	`dotnet run --project …`
`package.json` com `dev`, `start` ou `serve`	`pnpm/npm/yarn/bun run <script>` (o gerenciador vem do lockfile mais próximo)
`src-tauri/tauri.conf.json`	`tauri dev`
`angular.json` / `ionic.config.json`	`ng serve` / `ionic serve`
`vite.config.*` sem script `dev`	`vite`
`Cargo.toml`	`cargo run`, ou um `cargo run --bin <bin>` por binário
`manage.py`, `main.py`, `app.py`, `pyproject.toml`	`manage.py runserver`, `python <arquivo>`, `python -m uvicorn main:app --reload`, `python -m <módulo>`
`go.mod`	`go run .` e um `go run ./cmd/<x>` por cada `cmd/*`
`pom.xml` / `build.gradle`	`mvn spring-boot:run` (ou `exec:java`), `gradlew bootRun` (ou `run`)
`pubspec.yaml`	`flutter run`
`.vscode/launch.json`	as entradas `launch` de tipo `node`, `coreclr`, `python` ou `go`, traduzidas em comando

Uma linha por configuração

Num ERP com vinte projetos a lista tem de se ler num relance, então cada configuração é uma única linha:

[C#] Security · [Node] Mobile start · [Ionic] Mobile ionic serve

O ícone da linguagem — o mesmo da árvore de arquivos: C#, TypeScript, Angular, Ionic, Node, Gradle, Maven, Rust, Python, Go, Dart, Tauri — substitui o antigo chip de texto («DOTNET», «ANGULAR»). O tipo exato está no seu tooltip.
O nome curto é só o projeto: ApiGateway, Security, Frontend, Mobile, android. Nunca «Security · dotnet run · Security».
O verbo (atenuado, à direita) só aparece quando faz falta para distinguir: se em Mobile há três formas de arrancar você verá start, ng serve e ionic serve; se um projeto .NET é único na sua solução, «dotnet run» não se repete em seis linhas.
O comando completo, a pasta e o arquivo de origem já não ocupam a lista: estão no tooltip da linha e no painel de detalhe do seletor, que acompanha a linha destacada — «Comando: dotnet run --project Security.csproj · Pasta: Backend/Security · Solução: Backend/AspidaERP.sln».

Grupos: solução e pacote, não subpasta

Os cabeçalhos são a unidade real do projeto, com seu ícone e o número de configurações:

.NET agrupa por .sln: o app lê as linhas Project(…) = "…", "caminho.csproj" de cada solução, então os seis serviços de AspidaERP.sln ficam juntos mesmo vivendo em seis pastas. Quando um .csproj aparece em duas soluções (uma aninhada), ganha a mais externa. O que não está em nenhuma cai em «Sem solução».
Node / Angular / Ionic / Tauri e Rust agrupam pelo manifesto raiz (package.json, Cargo.toml), não pelo pacote solto. Gradle agrupa pelo settings.gradle mais externo, que é a raiz real do projeto Android.
Os grupos se recolhem, e o que você deixar recolhido é lembrado por projeto.
O pouco útil fica escondido por padrão atrás de «Mostrar tudo (N)»: projetos de testes, pastas e2e, o gradle run de capacitor-cordova-android-plugins, bin, obj.

Projeto de inicialização

O botão ▶ da barra do modo IDE mostra o ícone e o nome curto do projeto de inicialização (▶ Security), e F5 o executa.

Se houver só uma configuração, ela é o projeto de inicialização e o F5 a lança sem perguntar.
Se houver várias e você ainda não escolheu, o F5 abre o seletor: a lista agrupada por solução ou pacote, com busca e a caixa «Definir como projeto de inicialização» (marcada por padrão). Ao aceitar, ela é executada e fica fixada; nas próximas vezes o F5 vai direto.
O menu suspenso ao lado do ▶ troca o projeto de inicialização a qualquer momento. Usa as mesmas linhas compactas (ícone + nome curto, com o ✓ no de inicialização) e oferece Detectar novamente, Escolher projeto de inicialização… e Editar configurações….

A escolha é salva por projeto, em .context/run.json. Trocar o projeto de inicialização não mexe em nada mais.

Atalhos

Atalho	O que faz
F5	executa o projeto de inicialização. Se já estiver rodando não duplica: foca a aba de saída dele
Shift+F5	para tudo o que estiver em execução
Ctrl+F5	abre o seletor para executar outra configuração sem trocar o projeto de inicialização (aqui não há depurador, então este é o equivalente útil de «Iniciar sem depurar»)
Ctrl+Shift+B	compilar os targets de build, que era o que o F5 disparava antes

Saída do projeto

A execução vai para o painel Saída do projeto, com uma aba por configuração em andamento. Cada aba tem ⏹ parar, ↺ reiniciar, 🗑 limpar, e fecha com ✕ quando o processo terminou. O ponto colorido diz se ainda está vivo (verde), terminou bem (cinza) ou falhou (vermelho).

A aba Problemas analisa essa mesma saída e extrai os arquivo:linha:coluna dos formatos habituais (rustc, tsc, gcc/clang, webpack): um vite dev ou um cargo run que falham ao compilar aparecem ali, sem garimpar no log.

Perguntar sempre

No menu do ▶ existe «Perguntar sempre o que executar» (desligado por padrão). Com isso ativo, o F5 abre o seletor todas as vezes, mesmo havendo projeto de inicialização. Útil quando você trabalha em dois serviços do mesmo monorepo ao mesmo tempo.

`run.json`: configurações à mão

Editar configurações… abre .context/run.json no editor, criando-o se não existia. O arquivo aceita comentários (//) e vírgulas finais, e seu cabeçalho documenta o formato:

{
  "proyectoDeInicio": "node:apps/web:pnpm-run-dev",
  "preguntarSiempre": false,
  "configuraciones": [
    {
      "id": "api-local",
      "nombre": "API (local)",
      "cwd": "servicos/api",
      "comando": "node",
      "args": ["server.js"],
      "env": { "PORT": "3001" }
    }
  ]
}

proyectoDeInicio — o id da configuração que o F5 inicia.
preguntarSiempre — true faz o F5 abrir sempre o seletor.
configuraciones — as suas, que se somam às detectadas (aparecem marcadas como manual). De cada uma só id e comando são obrigatórios: nombre cai no id, cwd na raiz do projeto e tipo em custom.
cwd é relativo à raiz do projeto ("." é a raiz) e args já vem separado, sem aspas de shell.

Uma entrada mal escrita é descartada sozinha: o resto do arquivo — e o seu projeto de inicialização — continuam funcionando.