@softize/opus 8.8.1 → 8.9.0

package/registry/skills/create-opus-action/SKILL.md

@@ -0,0 +1,43 @@
+---
+name: create-opus-action
+description: Cria uma action Opus no split canônico de defineContract e bindAction, incluindo registro e validação. Use ao adicionar endpoint, comando, consulta ou operação de domínio em projeto baseado no Opus.
+---
+
+# Criar action Opus
+
+## Resultado
+
+Criar contrato compartilhável e binding server-only que passam no `opus check` e ficam
+registrados no runtime do projeto.
+
+## Entradas
+
+- nome `<resource>.<verb>` e `kind` (`simple`, `form`, `list` ou `view`);
+- comportamento, autorização, input, output, erros e efeitos esperados;
+- caminhos reais de `shared` e `api` adotados pelo repo.
+
+## Procedimento
+
+1. Rodar `node scripts/scaffold.mjs <resource> <verb> <kind>` a partir desta skill.
+2. Colocar o contrato em módulo importável pelos consumidores e o binding no lado servidor.
+3. Substituir os exemplos do scaffold por schemas, descrições e comportamento do domínio.
+4. Declarar `requires` somente com `authorize` efetivo; `requires` sozinho não protege a action.
+5. Exportar e registrar o binding no domínio/runtime existente.
+6. Acionar `test-opus-action` para cobrir contrato, sucesso, erros e efeitos relevantes.
+
+## Verificação
+
+Rodar `opus check <escopo>`, typecheck e testes do domínio. Se o projeto gera manifest,
+OpenAPI ou docs, regenerar e conferir o diff.
+
+## Limites
+
+- Não colocar banco, segredo ou driver no arquivo de contrato compartilhado.
+- Não duplicar input/output em tipos manuais, cliente ou documentação paralela.
+- Não criar autorização fictícia apenas para satisfazer o check.
+
+## Recursos
+
+- Leia [contrato e binding](references/contract-and-binding.md) quando houver dúvida de fronteira.
+- Use [avaliações](references/evaluations.md) ao evoluir esta skill.
+- Execute [scaffold.mjs](scripts/scaffold.mjs) para gerar os dois arquivos iniciais.

package/registry/skills/create-opus-action/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Criar action Opus"
+  short_description: "Cria contrato e binding canônicos de uma action"
+  default_prompt: "Use $create-opus-action para criar esta action Opus."

package/registry/skills/create-opus-action/references/contract-and-binding.md

@@ -0,0 +1,12 @@
+# Contrato e binding
+
+O contrato contém `name`, `kind`, documentação, schemas, metadata de UI, autorização
+declarativa compartilhável e `mockHandler` de design quando aplicável.
+
+O binding contém `handler`, `loads`, autorização dependente de dados carregados, execução
+em background, eventos e idempotência. `bindAction(contract, binding)` produz o `ActionDef`
+registrado no runtime.
+
+Ordem cobrada pelo check: identidade → documentação → input/output → autorização →
+handler/mock → comportamento. Campos específicos do kind permanecem junto do grupo ao qual
+servem e o scaffold acompanha a forma atual do SDK.

package/registry/skills/create-opus-action/references/evaluations.md

@@ -0,0 +1,5 @@
+# Avaliações
+
+- Dispara: “Crie a action `invoice.approve` no Opus.”
+- Não dispara: “Crie uma função TypeScript que soma duas parcelas.”
+- Execução: gerar contrato e binding para cada kind e obter zero findings no `opus check`.

package/registry/skills/create-opus-action/scripts/scaffold.mjs

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+
+const KINDS = new Set(['simple', 'form', 'list', 'view'])
+const cap = (value) => value.charAt(0).toUpperCase() + value.slice(1)
+const constant = (resource, verb) => resource + verb.split('-').map(cap).join('')
+
+function contractBody({ resource, verb, kind }) {
+  const name = `${resource}.${verb}`
+  const identifier = constant(resource, verb)
+  const common = `  name: '${name}',\n  kind: '${kind}',`
+
+  if (kind === 'list') {
+    return `export const ${identifier} = defineContract({
+${common}
+  summary: 'Descreva o que esta consulta lista.',
+  description: 'Descreva o comportamento de negócio e seus limites.',
+  input: z.object({}),
+  output: z.object({ id: z.string() }),
+  paginate: 'cursor',
+  mockHandler: async () => ({ items: [], cursor: { next: null }, total: 0 }),
+})`
+  }
+  if (kind === 'form') {
+    return `export const ${identifier} = defineContract({
+${common}
+  label: 'Descreva a ação.',
+  description: 'Descreva o comportamento de negócio e seus limites.',
+  messages: { success: 'Operação concluída.', error: 'Não foi possível concluir.' },
+  input: z.object({ id: z.string() }),
+  output: z.object({ id: z.string() }),
+  fields: { id: { label: 'Identificador' } },
+  mockHandler: async (_ctx, input) => ({ id: input.id }),
+})`
+  }
+  if (kind === 'view') {
+    return `export const ${identifier} = defineContract({
+${common}
+  summary: 'Descreva o que esta consulta retorna.',
+  description: 'Descreva o comportamento de negócio e seus limites.',
+  input: z.object({ id: z.string() }),
+  output: z.object({ id: z.string() }),
+  mockHandler: async (_ctx, input) => ({ id: input.id }),
+})`
+  }
+  return `export const ${identifier} = defineContract({
+${common}
+  label: 'Descreva a ação.',
+  description: 'Descreva o comportamento de negócio e seus limites.',
+  messages: { success: 'Operação concluída.', error: 'Não foi possível concluir.' },
+  input: z.object({ id: z.string() }),
+  output: z.object({ ok: z.boolean() }),
+  mockHandler: async () => ({ ok: true }),
+})`
+}
+
+export function actionFiles({ resource, verb, kind = 'simple' }) {
+  if (!/^[a-z][a-z0-9-]*$/.test(resource) || !/^[a-z][a-z0-9-]*$/.test(verb)) {
+    throw new Error('resource e verb devem usar lowercase kebab-case')
+  }
+  if (!KINDS.has(kind)) throw new Error(`kind inválido: ${kind}`)
+  const identifier = constant(resource, verb)
+  return {
+    contract: `import { z } from 'zod'
+import { defineContract } from '@softize/opus/core'
+
+${contractBody({ resource, verb, kind })}
+`,
+    binding: `import { bindAction } from '@softize/opus/core'
+
+import { ${identifier} } from './${verb}.contract.js'
+
+export const ${identifier}Impl = bindAction(${identifier}, {
+  handler: async (_ctx, _input) => {
+    throw new Error('Implemente o comportamento de ${resource}.${verb}.')
+  },
+})
+`,
+  }
+}
+
+export function actionFileNames(verb) {
+  return { contract: `${verb}.contract.ts`, binding: `${verb}.ts` }
+}
+
+const isMain = process.argv[1] !== undefined && import.meta.url === new URL(`file://${process.argv[1]}`).href
+if (isMain) {
+  const [resource, verb, kind = 'simple'] = process.argv.slice(2)
+  if (resource === undefined || verb === undefined) {
+    console.error('uso: node scaffold.mjs <resource> <verb> [simple|form|list|view]')
+    process.exit(1)
+  }
+  try {
+    const generated = actionFiles({ resource, verb, kind })
+    const names = actionFileNames(verb)
+    process.stdout.write(`// ${names.contract}\n${generated.contract}\n// ${names.binding}\n${generated.binding}`)
+  } catch (error) {
+    console.error(error.message)
+    process.exit(1)
+  }
+}

package/registry/skills/implement-opus-change/SKILL.md

@@ -0,0 +1,43 @@
+---
+name: implement-opus-change
+description: Implementa uma mudança em projeto baseado no Opus preservando contrato, binding, registro e projeções. Use ao alterar domínio, action, runtime ou integração que utilize @softize/opus.
+---
+
+# Implementar mudança Opus
+
+## Resultado
+
+Entregar a mudança coerente com o protocolo do projeto, com contratos consumíveis sem
+dependências server-only, bindings registrados, testes e gates verdes.
+
+## Entradas
+
+- critérios de aceite e instruções locais;
+- `opus.json`, `opus.config.ts` e estrutura real do domínio afetado;
+- versão instalada de `@softize/opus` e APIs que o repo já usa.
+
+## Procedimento
+
+1. Localizar contrato, binding, registro e consumidores da capacidade afetada.
+2. Modelar primeiro o contrato observável: nome, descrição, input, output, erros e metadata.
+3. Manter código compartilhável fora de banco, segredo, filesystem e drivers server-only.
+4. Implementar o binding e registrar o `ActionDef` no domínio/runtime conforme a topologia local.
+5. Usar `create-opus-action`, `test-opus-action` ou `build-opus-ui` quando a mudança entrar
+   nesses workflows especializados.
+6. Atualizar manifest, docs geradas e exemplos somente pelos comandos do repo.
+
+## Verificação
+
+Rodar `opus check` no escopo correto, testes afetados, typecheck e os geradores que o
+projeto declara. Conferir o diff gerado antes do handoff.
+
+## Limites
+
+- Opus é SDK/protocolo; não atribuir a ele DDD, arquitetura ou regra de negócio universal.
+- Não criar fetch, tipo de transporte ou validação paralela quando o contrato já os fornece.
+- Não supor caminhos fixos quando o repo adotou outra topologia válida.
+
+## Recursos
+
+- Leia [fronteiras do protocolo](references/protocol-boundaries.md) ao decidir onde o código mora.
+- Use [avaliações](references/evaluations.md) ao evoluir esta skill.

package/registry/skills/implement-opus-change/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Implementar mudança Opus"
+  short_description: "Implementa mudanças usando contratos e gates do Opus"
+  default_prompt: "Use $implement-opus-change para implementar esta mudança no projeto Opus."

package/registry/skills/implement-opus-change/references/evaluations.md

@@ -0,0 +1,5 @@
+# Avaliações
+
+- Dispara: “Implemente a mudança de cancelamento no domínio de pedidos que usa Opus.”
+- Não dispara: “Atualize uma função utilitária sem relação com Opus.”
+- Execução: alterar uma action existente, provar `opus check`, teste e projeção gerada sem diff inesperado.

package/registry/skills/implement-opus-change/references/protocol-boundaries.md

@@ -0,0 +1,11 @@
+# Fronteiras do protocolo
+
+- `defineContract`: identidade e superfície declarativa compartilhável.
+- `bindAction`: execução server-only, loaders, autorização por linha e efeitos.
+- domínio/runtime: composição e registro; não é fonte duplicada da documentação.
+- `description`: explicação de negócio próxima da declaração e fonte das projeções.
+- manifest/OpenAPI/docs: saídas geradas, nunca fonte editada em paralelo.
+
+Use `defineAction` junto apenas quando o código não cruzar fronteira cliente/servidor e o
+projeto já adotar explicitamente esse formato. Para uma action consumida pela UI, prefira
+contrato separado do binding.

package/registry/skills/test-opus-action/SKILL.md

@@ -0,0 +1,38 @@
+---
+name: test-opus-action
+description: Testa actions Opus pela fronteira do contrato, cobrindo validação, autorização, handler e efeitos observáveis. Use ao criar ou alterar defineContract, bindAction, defineAction ou comportamento executado pelo runtime Opus.
+---
+
+# Testar action Opus
+
+## Resultado
+
+Provar o comportamento público da action e suas regressões sem depender de transporte ou
+infraestrutura real quando a unidade é o contrato.
+
+## Procedimento
+
+1. Importar o `ActionDef` produzido pelo binding; para contrato puro, testar `mockHandler`
+   apenas no modo design.
+2. Executar com `runAction` e fornecer `user`, `can`, `loaded`, storage ou outros adapters
+   pelas opções do harness.
+3. Cobrir sucesso, input inválido, autorização negada e erros de negócio materiais.
+4. Afirmar output e efeitos observáveis como `emitted`, `logged` e estado do adapter fake.
+5. Adicionar integração somente para a fronteira não provada pela unidade: banco, transporte,
+   registro real ou wiring entre actions.
+
+## Verificação
+
+Rodar o teste focado, a suíte do pacote e `opus check` no domínio. Um teste não substitui
+typecheck nem freshness de manifest.
+
+## Limites
+
+- Não chamar handler diretamente quando isso pula validação/autorização do runtime.
+- Não mockar o próprio contrato que deveria estar sob teste.
+- Não usar snapshot amplo no lugar de invariantes observáveis.
+
+## Recursos
+
+- Leia [harness](references/harness.md) para escolher os fakes.
+- Use [avaliações](references/evaluations.md) ao evoluir esta skill.

package/registry/skills/test-opus-action/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Testar action Opus"
+  short_description: "Testa contratos, bindings e comportamento de actions"
+  default_prompt: "Use $test-opus-action para testar esta action Opus."

package/registry/skills/test-opus-action/references/evaluations.md

@@ -0,0 +1,5 @@
+# Avaliações
+
+- Dispara: “Cubra com testes a action Opus de arquivar cliente.”
+- Não dispara: “Teste este parser CSV que não usa action.”
+- Execução: provar input inválido, autorização e efeitos com `runAction`, sem rede real.

package/registry/skills/test-opus-action/references/harness.md

@@ -0,0 +1,10 @@
+# Harness Opus
+
+- `runAction(action, input, options)`: aplica validação, autenticação, autorização, execução
+  e validação de output como o runtime.
+- `testContext(options)`: cria `ActionContext` com `emit` e `log` observáveis.
+- `memStorage()`: adapter de storage em memória com inspeção de chaves.
+- `fake` e `fakeMany`: dados determinísticos derivados de schema.
+
+Prefira o binding completo em testes de execução. Um contrato sem handler só executa via
+`mockHandler` quando `OPUS_MODE=design`.

package/registry/skills/upgrade-opus/SKILL.md

@@ -0,0 +1,37 @@
+---
+name: upgrade-opus
+description: Atualiza @softize/opus com leitura de changelog, materialização, migrações e gates reproduzíveis. Use ao alterar a versão do Opus ou corrigir drift após um upgrade do pacote.
+---
+
+# Atualizar Opus
+
+## Resultado
+
+Resolver a nova versão no lockfile, aplicar suas migrações e deixar código, artefatos
+materializados e projeções geradas consistentes no mesmo diff.
+
+## Procedimento
+
+1. Registrar versão atual e alvo e ler todas as entradas intermediárias do `CHANGELOG.md`,
+   priorizando seções Breaking e instruções de migração.
+2. Atualizar a dependência com o package manager do repo.
+3. Executar `opus setup` para materializar exatamente a versão resolvida.
+4. Aplicar migrações no código por domínio, sem compatibilidade temporária silenciosa.
+5. Rodar `opus check`, typecheck, testes, build e geradores declarados pelo projeto.
+6. Conferir `base.json`, lockfile, skills, hooks, instruções e outputs gerados no diff.
+
+## Verificação
+
+Executar `opus check` novamente em checkout limpo com instalação frozen. Nenhum arquivo
+gerenciado ou manifest pode mudar depois dos gates.
+
+## Limites
+
+- Não pular versões intermediárias do changelog.
+- Não editar projeção gerenciada para contornar o setup; corrigir fonte ou colisão.
+- Não publicar nem fazer deploy como consequência implícita do upgrade.
+
+## Recursos
+
+- Leia [checklist de upgrade](references/upgrade-checklist.md) antes do handoff.
+- Use [avaliações](references/evaluations.md) ao evoluir esta skill.

package/registry/skills/upgrade-opus/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Atualizar Opus"
+  short_description: "Atualiza o SDK com migração e gates reproduzíveis"
+  default_prompt: "Use $upgrade-opus para atualizar o Opus neste projeto."

package/registry/skills/upgrade-opus/references/evaluations.md

@@ -0,0 +1,5 @@
+# Avaliações
+
+- Dispara: “Atualize o Opus 8.8 para 9.0 e aplique as migrações.”
+- Não dispara: “Atualize apenas o Vitest.”
+- Execução: upgrade entre versões com breaking e checkout final sem drift após `opus setup`.

package/registry/skills/upgrade-opus/references/upgrade-checklist.md

@@ -0,0 +1,8 @@
+# Checklist de upgrade
+
+- versão alvo presente em `package.json`, lockfile, `base.json` e `opus.json` aplicáveis;
+- `opus setup` e `opus check` verdes;
+- breakings intermediários tratados;
+- typecheck, testes e build verdes;
+- manifest, OpenAPI e docs regenerados quando configurados;
+- diff sem edição manual de arquivo gerenciado e sem compatibilidade morta.

package/registry/templates/app/src/domains/tasks/index.ts

@@ -2,7 +2,7 @@ import { defineDomain } from '@softize/opus/core'
 import { taskListImpl } from './actions/list.ts'
 
 /** Domínio-exemplo do esqueleto. Troque pelo seu domínio real — a skill
- *  `create-action` gera actions novas no formato canônico. O domínio registra
+ *  `create-opus-action` gera actions novas no formato canônico. O domínio registra
  *  o BOUND (contrato + handler); o contrato puro é o que a web consome. */
 export const tasksDomain = defineDomain({
   name: 'task',

package/src/ui/components/primitives/select.tsx

@@ -310,10 +310,19 @@ function CustomSelect(props: Exclude<SelectProps, SelectNativeProps>): React.Rea
     <Popover
       open={open}
       onOpenChange={(v) => {
-        // Fechar devolve o foco pro gatilho, e o gatilho abre AO RECEBER FOCO. Sem armar a
-        // guarda em TODO fechamento (não só no Esc), o seletor reabria sozinho — o
-        // "abre, fecha e abre de novo" que aparecia no primeiro clique.
-        if (!v) closingRef.current = true
+        // Fechar devolve o foco pro gatilho, e o gatilho abre AO RECEBER FOCO — sem
+        // guarda, o seletor reabre sozinho ("abre, fecha e abre de novo").
+        //
+        // A guarda vale UM FRAME, não até ser consumida. Fechar clicando noutro lugar da
+        // página não devolve o foco pra cá, então uma trava que espera esse retorno ficaria
+        // armada pra sempre e engoliria a PRÓXIMA abertura por teclado — trocando um
+        // defeito visível por um que só aparece pra quem navega por Tab.
+        if (!v) {
+          closingRef.current = true
+          requestAnimationFrame(() => {
+            closingRef.current = false
+          })
+        }
         setOpen(v)
       }}
     >
@@ -370,9 +379,12 @@ function CustomSelect(props: Exclude<SelectProps, SelectNativeProps>): React.Rea
                   o texto rolava pro fim ao ganhar foco (o browser leva o cursor pro final)
                   e o começo do título sumia — num campo estreito, a pessoa via o meio de
                   uma frase. `<span>` trunca com reticências, que é o certo. */}
-              {!props.multiple && (
+              {/* No MÚLTIPLO os chips ocupam o lugar do rótulo — mas quando não há nenhum,
+                  o gatilho ficaria em branco (o input que carregava o placeholder virou
+                  invisível). Campo mudo é pior que campo vazio: não diz nem o que é. */}
+              {(!props.multiple || selectedValues.length === 0) && (
                 <span data-slot="select-trigger-label" className={cn('min-w-0 flex-1 truncate text-left text-sm', selectedOption === undefined && 'text-muted-foreground')}>
-                  {selectedOption?.triggerLabel ?? (selectedOption?.label ?? placeholder)}
+                  {props.multiple ? placeholder : (selectedOption?.triggerLabel ?? selectedOption?.label ?? placeholder)}
                 </span>
               )}
               <input

package/src/ui/docs/content/actions.md

@@ -52,7 +52,7 @@ export const workspaceCreate = bindAction(workspaceCreateContract, {
 ## Ordem canônica dos campos
 
 > O `opus check` reprova fora desta ordem — é a régua, 0 violação antes de entregar. A skill
-> `create-action` gera o esqueleto certo por construção.
+> `create-opus-action` gera contrato e binding no formato certo por construção.
 
 ```text
 name → kind → (label / summary / messages / tags…)

package/src/ui/docs/content/cli.md

@@ -50,9 +50,9 @@ só os arquivos do app; o que a raiz precisa ter vira aviso, sem clobber).
 
 ## MCP — estado vivo pros agentes
 
-> O server MCP expõe `introspect`/`check`/`create-action`. É como um agente lê a estrutura e cria
+> O server MCP expõe introspecção, check e scaffold de action. É como um agente lê a estrutura e cria
 > action no formato canônico sem decorar convenção.
 
 `opus mcp` sobe o server (configurado em `.mcp.json`): o agente consulta a estrutura, roda o
-check e gera o esqueleto de uma action nova pela skill `create-action` — a mesma régua do
+check e gera o esqueleto de uma action nova pela skill `create-opus-action` — a mesma régua do
 `opus check`, por construção.

package/src/ui/docs/content/customization.md

@@ -107,4 +107,4 @@ const [open, setOpen] = useState(false)
 
 Se uma necessidade real não cabe nas alavancas (tokens · className · slots/asChild · props ·
 contrato), o movimento não é dialeto local: é evoluir o componente **no Opus**, com a divergência
-declarada (skill `opus`) — assim a mudança vale pra casa toda, e esta doc passa a mostrá-la.
+declarada (skill `build-opus-ui`) — assim a mudança vale pra casa toda, e esta doc passa a mostrá-la.

package/src/ui/docs/content/data.md

@@ -32,7 +32,7 @@ export const SkillEntity = defineEntity({
 
 ## Código camelCase, banco snake
 
-> Regra dura (skill `code-style`): uma camada em snake e outra em camel é defeito — não tem meio-termo.
+> Regra dura do protocolo: uma camada em snake e outra em camel é defeito — não tem meio-termo.
 
 O schema tipado do Kysely e **toda** query (select/insert/update/where) usam camelCase
 (`workspaceId`, `ghRepo`). O banco é snake (a DDL no schema idempotente — `db/schema.sql`).

package/src/ui/docs/content/microcopy.md

@@ -6,7 +6,7 @@ title: Microcopy
 
 Código em inglês; o que humano lê (UI, comentário, doc) em pt-BR. Frases começam com
 maiúscula e terminam com ponto; labels curtos em sentence case, sem ponto. **Esta página
-é a fonte** — a skill `code-style` aponta pra cá (regra duplicada em vez de apontada é
+é a fonte** — `build-opus-ui` aplica esta convenção (regra duplicada em vez de apontada é
 defeito).
 
 ## Língua por camada

package/src/ui/docs/content/scroll-area.md

@@ -33,7 +33,7 @@ render(
 Pra rolar na horizontal, acrescente <ScrollBar orientation="horizontal" /> como filho e deixe o conteúdo numa linha que não quebra (flex + w-max).
 
 ```tsx preview col
-const skills = ['clean-code', 'code-style', 'ddd', 'test', 'create-action', 'opus', 'clean-architecture']
+const skills = ['implement-opus-change', 'create-opus-action', 'test-opus-action', 'build-opus-ui', 'upgrade-opus']
 
 render(
   <ScrollArea className="w-full rounded-md border border-border whitespace-nowrap">

package/src/ui/docs/content/tokens.md

@@ -142,7 +142,7 @@ render(
 ## Divergências declaradas vs shadcn
 
 > A regra anti-drift: o que não está declarado aqui (e no `theme.css`) é drift e deve ser
-> sincronizado — skill `opus`.
+> sincronizado — skill `build-opus-ui`.
 
 1. Formato HSL nos tokens (o upstream migrou pra oklch) — legibilidade e ferramentas nossas; os
    valores acompanham o upstream, só o formato difere.

package/src/ui/docs/content/ui.md

@@ -35,6 +35,6 @@ import { Button, Dialog, useAction } from '@softize/opus/ui/react'
 
 - **Origem shadcn** — port curado do shadcn (Radix + cmdk). Toda divergência do upstream é
   DECLARADA no componente ou no tema — o que diverge sem declaração é drift e deve ser
-  sincronizado (skill `opus`).
+  sincronizado (skill `build-opus-ui`).
 - **Nativo do Opus** — nasceu aqui (os patterns de action). Não tem upstream pra acompanhar; a
   referência é esta doc.

package/src/ui/docs/doc-client.tsx

@@ -124,6 +124,8 @@ export const docSessionDelete = defineContract({
   kind: 'simple',
   label: 'Excluir sessão',
   messages: { success: 'Sessão excluída', error: 'Falha ao excluir' },
+  input: z.object({ id: z.string() }),
+  output: z.object({ ok: z.boolean() }),
   // ConfirmSpec DECLARADO no contrato: o ActionTrigger monta o dialog sozinho.
   confirm: {
     title: 'Excluir a sessão?',
@@ -131,8 +133,6 @@ export const docSessionDelete = defineContract({
     confirmLabel: 'Excluir',
     destructive: true,
   },
-  input: z.object({ id: z.string() }),
-  output: z.object({ ok: z.boolean() }),
 })
 
 const sleep = (ms: number): Promise<void> => new Promise((r) => setTimeout(r, ms))

package/src/ui/theme.css

@@ -5,7 +5,7 @@
  * + um `@source` pros componentes do Opus (monorepo), e sobrescreve vars pra identidade.
  *
  * ── DIVERGÊNCIAS DECLARADAS vs shadcn upstream (regra: o que não está aqui é DRIFT
- *    e deve ser sincronizado; ver skill `shadcn-ui`) ─────────────────────────────────
+ *    e deve ser sincronizado; ver skill `build-opus-ui`) ─────────────────────────────
  * 1. Formato HSL nos tokens (upstream migrou pra oklch) — legibilidade/ferramentas
  *    nossas; os VALORES acompanham o upstream, só o formato difere.
  * 2. Elevação dark: --card/--popover ACIMA de --background (10% vs 3.9%) — identidade

package/registry/hooks/hooks.json

@@ -1,26 +0,0 @@
-{
-  "hooks": {
-    "SessionStart": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "command": "node \"$CLAUDE_PROJECT_DIR/.claude/hooks/link-memory-on-start.mjs\"",
-            "timeout": 10
-          }
-        ]
-      }
-    ],
-    "Stop": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "command": "node \"$CLAUDE_PROJECT_DIR/.claude/hooks/opus-check-on-stop.mjs\"",
-            "timeout": 120
-          }
-        ]
-      }
-    ]
-  }
-}

package/registry/hooks/link-memory-on-start.mjs

@@ -1,46 +0,0 @@
-/**
- * Hook SessionStart da base Opus: liga a memória versionada do repo
- * (`.claude/memory`, política da skill `memory`) ao diretório que o Claude Code
- * lê (`~/.claude/projects/<hash>/memory`). Sem isso, sessão em worktree/máquina
- * nova roda AMNÉSICA — recall vazio e memória gravada num diretório órfão que
- * morre com o worktree. É o `link-memory.sh` automatizado: idempotente, com
- * backup de memória local pré-existente, e fail-open (repo sem `.claude/memory`
- * versionado → no-op; qualquer erro → segue sem travar a sessão).
- */
-import { existsSync, lstatSync, mkdirSync, readdirSync, readlinkSync, renameSync, rmdirSync, symlinkSync, unlinkSync } from 'node:fs'
-import { homedir } from 'node:os'
-import { dirname, join } from 'node:path'
-
-try {
-  const root = process.env.CLAUDE_PROJECT_DIR ?? process.cwd()
-  const memRepo = join(root, '.claude', 'memory')
-  // Sem memória versionada → o repo não adota a política; nada a ligar.
-  if (!existsSync(memRepo)) process.exit(0)
-
-  // O hash do projeto é o caminho absoluto com separadores (e pontos) virando '-',
-  // como o Claude Code nomeia ~/.claude/projects/. Espelha o link-memory.sh.
-  const hash = root.replace(/[/.]/g, '-')
-  const dest = join(homedir(), '.claude', 'projects', hash, 'memory')
-
-  let st = null
-  try {
-    st = lstatSync(dest)
-  } catch {
-    /* Não existe → segue pro link. */
-  }
-  if (st?.isSymbolicLink()) {
-    if (readlinkSync(dest) === memRepo) process.exit(0) // Já ligado.
-    unlinkSync(dest) // Aponta pra outro lugar → religa.
-  } else if (st?.isDirectory()) {
-    // Memória local pré-existente: com conteúdo → backup (nunca descarta); vazia → sai.
-    if (readdirSync(dest).length > 0) renameSync(dest, `${dest}.local-${Date.now()}`)
-    else rmdirSync(dest)
-  } else if (st !== null) {
-    unlinkSync(dest) // Arquivo solto no lugar do diretório — afasta.
-  }
-  mkdirSync(dirname(dest), { recursive: true })
-  symlinkSync(memRepo, dest)
-} catch {
-  /* Fail-open: memória desligada é degradação, não motivo pra travar a sessão. */
-}
-process.exit(0)