@semacode/cli 1.5.55 → 2.0.1

package/dist/workspaceWrite.js

@@ -0,0 +1,332 @@
+// SEMA-GOVERNED: sema.produto.escrita_segura_workspace
+// Descrição: valida e executa escritas locais sem atravessar symlink, junction ou a base escolhida.
+import { constants } from "node:fs";
+import { lstat, mkdir, open, realpath, rename, stat, unlink, } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import path from "node:path";
+const IDENTIDADE_DESTINO = Symbol("sema.identidade-destino-workspace");
+const IDENTIDADE_BASE_DESTINO = Symbol("sema.identidade-base-workspace");
+class ErroIntegridadeWorkspace extends Error {
+    code = "SEMA_WORKSPACE_TOCTOU";
+    constructor(mensagem) {
+        super(`Integridade do workspace mudou durante a escrita (TOCTOU): ${mensagem}`);
+        this.name = "ErroIntegridadeWorkspace";
+    }
+}
+function caminhoEstaContido(base, alvo) {
+    const relativo = path.relative(base, alvo);
+    return relativo === "" || (relativo !== ".." &&
+        !relativo.startsWith(`..${path.sep}`) &&
+        !path.isAbsolute(relativo));
+}
+function identidadeDe(info) {
+    return { dev: info.dev, ino: info.ino };
+}
+function mesmaIdentidade(esquerda, direita) {
+    return esquerda.dev === direita.dev && esquerda.ino === direita.ino;
+}
+async function lstatSeguro(caminho) {
+    try {
+        return await lstat(caminho, { bigint: true });
+    }
+    catch (erro) {
+        if (["ENOENT", "ENOTDIR"].includes(erro.code ?? "")) {
+            return null;
+        }
+        throw erro;
+    }
+}
+function validarRelativo(caminhoRelativo) {
+    if (!caminhoRelativo.trim() || path.isAbsolute(caminhoRelativo)) {
+        throw new Error(`Destino de workspace deve ser relativo: ${caminhoRelativo}`);
+    }
+    if (caminhoRelativo.includes("\0")) {
+        throw new Error("Destino de workspace não pode conter byte nulo.");
+    }
+    if (caminhoRelativo.split(/[\\/]+/u).includes("..")) {
+        throw new Error(`Destino de workspace não pode conter traversal: ${caminhoRelativo}`);
+    }
+}
+async function resolverBaseReal(base) {
+    const baseAbsoluta = path.resolve(base);
+    const baseInfo = await stat(baseAbsoluta).catch(() => null);
+    if (!baseInfo?.isDirectory()) {
+        throw new Error(`Base de escrita não existe ou não é diretório: ${baseAbsoluta}`);
+    }
+    const baseReal = await realpath(baseAbsoluta);
+    const baseRealInfo = await lstatSeguro(baseReal);
+    if (!baseRealInfo?.isDirectory() || baseRealInfo.isSymbolicLink()) {
+        throw new Error(`Base real de escrita não é diretório confiável: ${baseReal}`);
+    }
+    return baseReal;
+}
+function resolverDestino(baseReal, caminhoRelativo) {
+    validarRelativo(caminhoRelativo);
+    const caminhoAbsoluto = path.resolve(baseReal, caminhoRelativo);
+    if (!caminhoEstaContido(baseReal, caminhoAbsoluto)) {
+        throw new Error(`Destino escapa da base de escrita: ${caminhoRelativo}`);
+    }
+    return caminhoAbsoluto;
+}
+async function revalidarGuardasDiretorio(guardas) {
+    for (const guarda of guardas) {
+        const [porCaminho, porHandle] = await Promise.all([
+            lstatSeguro(guarda.caminho),
+            guarda.handle.stat({ bigint: true }),
+        ]);
+        if (!porCaminho?.isDirectory() ||
+            porCaminho.isSymbolicLink() ||
+            !porHandle.isDirectory() ||
+            !mesmaIdentidade(guarda.identidade, identidadeDe(porCaminho)) ||
+            !mesmaIdentidade(guarda.identidade, identidadeDe(porHandle))) {
+            throw new ErroIntegridadeWorkspace(`diretório substituído: ${guarda.caminho}`);
+        }
+    }
+}
+async function abrirEGuardarDiretorio(caminho, guardasAnteriores) {
+    await revalidarGuardasDiretorio(guardasAnteriores);
+    const antes = await lstatSeguro(caminho);
+    if (!antes?.isDirectory() || antes.isSymbolicLink()) {
+        throw new Error(`Destino atravessa symlink, junction ou não-diretório: ${caminho}`);
+    }
+    const handle = await open(caminho, constants.O_RDONLY);
+    try {
+        const [depois, porHandle] = await Promise.all([
+            lstatSeguro(caminho),
+            handle.stat({ bigint: true }),
+        ]);
+        const identidadeAntes = identidadeDe(antes);
+        if (!depois?.isDirectory() ||
+            depois.isSymbolicLink() ||
+            !porHandle.isDirectory() ||
+            !mesmaIdentidade(identidadeAntes, identidadeDe(depois)) ||
+            !mesmaIdentidade(identidadeAntes, identidadeDe(porHandle))) {
+            throw new ErroIntegridadeWorkspace(`diretório mudou ao ser aberto: ${caminho}`);
+        }
+        await revalidarGuardasDiretorio(guardasAnteriores);
+        return { caminho, handle, identidade: identidadeAntes };
+    }
+    catch (erro) {
+        await handle.close().catch(() => undefined);
+        throw erro;
+    }
+}
+async function fecharGuardasDiretorio(guardas) {
+    await Promise.all(guardas.map((guarda) => guarda.handle.close().catch(() => undefined)));
+}
+function segmentosEntre(baseReal, alvo) {
+    if (!caminhoEstaContido(baseReal, alvo)) {
+        throw new Error(`Destino resolve fora da base de escrita: ${alvo}`);
+    }
+    return path.relative(baseReal, alvo).split(path.sep).filter(Boolean);
+}
+async function garantirDiretoriosDestino(baseReal, diretorioDestino, identidadeBaseEsperada) {
+    const guardas = [];
+    try {
+        guardas.push(await abrirEGuardarDiretorio(baseReal, guardas));
+        if (!mesmaIdentidade(guardas[0].identidade, identidadeBaseEsperada)) {
+            throw new ErroIntegridadeWorkspace(`base substituída: ${baseReal}`);
+        }
+        let atual = baseReal;
+        for (const segmento of segmentosEntre(baseReal, diretorioDestino)) {
+            atual = path.join(atual, segmento);
+            await revalidarGuardasDiretorio(guardas);
+            let info = await lstatSeguro(atual);
+            if (!info) {
+                try {
+                    await mkdir(atual);
+                }
+                catch (erro) {
+                    if (erro.code !== "EEXIST") {
+                        throw erro;
+                    }
+                }
+                await revalidarGuardasDiretorio(guardas);
+                info = await lstatSeguro(atual);
+            }
+            if (!info?.isDirectory() || info.isSymbolicLink()) {
+                throw new Error(`Destino atravessa symlink, junction ou não-diretório: ${atual}`);
+            }
+            guardas.push(await abrirEGuardarDiretorio(atual, guardas));
+        }
+        await revalidarGuardasDiretorio(guardas);
+        return guardas;
+    }
+    catch (erro) {
+        await fecharGuardasDiretorio(guardas);
+        throw erro;
+    }
+}
+async function confirmarArquivoPorHandle(caminho, handle, guardas) {
+    await revalidarGuardasDiretorio(guardas);
+    const [porCaminho, porHandle] = await Promise.all([
+        lstatSeguro(caminho),
+        handle.stat({ bigint: true }),
+    ]);
+    if (!porCaminho?.isFile() ||
+        porCaminho.isSymbolicLink() ||
+        !porHandle.isFile() ||
+        !mesmaIdentidade(identidadeDe(porCaminho), identidadeDe(porHandle)) ||
+        porHandle.nlink !== 1n) {
+        throw new ErroIntegridadeWorkspace(`arquivo substituído, ocultado ou ligado externamente: ${caminho}`);
+    }
+    await revalidarGuardasDiretorio(guardas);
+}
+async function confirmarEstadoInicialDestino(destino, guardas) {
+    await revalidarGuardasDiretorio(guardas);
+    const atual = await lstatSeguro(destino.caminhoAbsoluto);
+    const esperada = destino[IDENTIDADE_DESTINO] ?? null;
+    if (atual?.isSymbolicLink()) {
+        throw new ErroIntegridadeWorkspace(`destino virou symlink ou junction: ${destino.caminhoAbsoluto}`);
+    }
+    if ((esperada === null && atual !== null) ||
+        (esperada !== null && (atual === null || !mesmaIdentidade(esperada, identidadeDe(atual))))) {
+        throw new ErroIntegridadeWorkspace(`destino mudou desde a validação: ${destino.caminhoAbsoluto}`);
+    }
+}
+async function escreverConteudoConfirmado(caminho, handle, guardas, conteudo) {
+    await confirmarArquivoPorHandle(caminho, handle, guardas);
+    await handle.writeFile(conteudo, { encoding: "utf8" });
+    await handle.sync();
+    await confirmarArquivoPorHandle(caminho, handle, guardas);
+}
+async function removerArquivoSeAindaForMesmo(caminho, handle, guardas) {
+    try {
+        await confirmarArquivoPorHandle(caminho, handle, guardas);
+        await unlink(caminho);
+        await revalidarGuardasDiretorio(guardas);
+    }
+    catch {
+        // Falha fechada: não removemos um caminho cuja identidade já não pode ser provada.
+    }
+}
+export async function validarDestinosEscritaWorkspace(base, caminhosRelativos) {
+    const baseReal = await resolverBaseReal(base);
+    const destinos = [];
+    const guardaBase = await abrirEGuardarDiretorio(baseReal, []);
+    try {
+        for (const caminhoRelativo of [...new Set(caminhosRelativos)]) {
+            const caminhoAbsoluto = resolverDestino(baseReal, caminhoRelativo);
+            const segmentos = segmentosEntre(baseReal, caminhoAbsoluto);
+            const guardas = [guardaBase];
+            let atual = baseReal;
+            let infoFinal = null;
+            try {
+                for (let indice = 0; indice < segmentos.length; indice += 1) {
+                    atual = path.join(atual, segmentos[indice]);
+                    await revalidarGuardasDiretorio(guardas);
+                    const info = await lstatSeguro(atual);
+                    if (!info) {
+                        infoFinal = null;
+                        break;
+                    }
+                    if (info.isSymbolicLink()) {
+                        throw new Error(`Destino atravessa symlink ou junction: ${caminhoRelativo}`);
+                    }
+                    const ultimo = indice === segmentos.length - 1;
+                    if (ultimo) {
+                        infoFinal = info;
+                        break;
+                    }
+                    if (!info.isDirectory()) {
+                        // O validador também é usado por migrações que sondam caminhos
+                        // legados alternativos (arquivo único versus diretório). Um
+                        // componente regular torna o descendente inexistente; a escrita,
+                        // se tentada, continua bloqueada em garantirDiretoriosDestino.
+                        infoFinal = null;
+                        break;
+                    }
+                    guardas.push(await abrirEGuardarDiretorio(atual, guardas));
+                }
+                await revalidarGuardasDiretorio(guardas);
+            }
+            finally {
+                await fecharGuardasDiretorio(guardas.slice(1));
+            }
+            const destino = {
+                caminhoRelativo,
+                caminhoAbsoluto,
+                existe: infoFinal !== null,
+            };
+            destino[IDENTIDADE_DESTINO] = infoFinal ? identidadeDe(infoFinal) : null;
+            destino[IDENTIDADE_BASE_DESTINO] = guardaBase.identidade;
+            destinos.push(destino);
+        }
+    }
+    finally {
+        await fecharGuardasDiretorio([guardaBase]);
+    }
+    return destinos;
+}
+export async function escreverArquivoWorkspaceSeguro(base, caminhoRelativo, conteudo, opcoes = {}) {
+    const [destino] = await validarDestinosEscritaWorkspace(base, [caminhoRelativo]);
+    if (destino.existe && !opcoes.sobrescrever) {
+        return { status: "preservado", caminho: destino.caminhoAbsoluto };
+    }
+    const baseReal = await resolverBaseReal(base);
+    const identidadeBaseEsperada = destino[IDENTIDADE_BASE_DESTINO];
+    if (!identidadeBaseEsperada) {
+        throw new ErroIntegridadeWorkspace("a validação inicial não registrou a identidade da base");
+    }
+    if (!caminhoEstaContido(baseReal, destino.caminhoAbsoluto)) {
+        throw new ErroIntegridadeWorkspace("a base real mudou desde a validação inicial");
+    }
+    const guardas = await garantirDiretoriosDestino(baseReal, path.dirname(destino.caminhoAbsoluto), identidadeBaseEsperada);
+    try {
+        await confirmarEstadoInicialDestino(destino, guardas);
+        if (!opcoes.sobrescrever) {
+            let handle;
+            try {
+                handle = await open(destino.caminhoAbsoluto, "wx", 0o600);
+            }
+            catch (erro) {
+                if (erro.code === "EEXIST") {
+                    return { status: "preservado", caminho: destino.caminhoAbsoluto };
+                }
+                throw erro;
+            }
+            try {
+                await escreverConteudoConfirmado(destino.caminhoAbsoluto, handle, guardas, conteudo);
+            }
+            catch (erro) {
+                if (!(erro instanceof ErroIntegridadeWorkspace)) {
+                    await removerArquivoSeAindaForMesmo(destino.caminhoAbsoluto, handle, guardas);
+                }
+                throw erro;
+            }
+            finally {
+                await handle.close().catch(() => undefined);
+            }
+        }
+        else {
+            const temporario = path.join(path.dirname(destino.caminhoAbsoluto), `.${path.basename(destino.caminhoAbsoluto)}.sema-${randomUUID()}.tmp`);
+            const handle = await open(temporario, "wx", 0o600);
+            let renomeado = false;
+            try {
+                await escreverConteudoConfirmado(temporario, handle, guardas, conteudo);
+                await confirmarEstadoInicialDestino(destino, guardas);
+                await confirmarArquivoPorHandle(temporario, handle, guardas);
+                await rename(temporario, destino.caminhoAbsoluto);
+                renomeado = true;
+                await confirmarArquivoPorHandle(destino.caminhoAbsoluto, handle, guardas);
+            }
+            catch (erro) {
+                if (!renomeado && !(erro instanceof ErroIntegridadeWorkspace)) {
+                    await removerArquivoSeAindaForMesmo(temporario, handle, guardas);
+                }
+                throw erro;
+            }
+            finally {
+                await handle.close().catch(() => undefined);
+            }
+        }
+    }
+    finally {
+        await fecharGuardasDiretorio(guardas);
+    }
+    return {
+        status: destino.existe ? "atualizado" : "criado",
+        caminho: destino.caminhoAbsoluto,
+    };
+}
+//# sourceMappingURL=workspaceWrite.js.map

package/docs/README.md

@@ -1,10 +1,15 @@
 # Sema Documentation
 
-These docs describe the public local CLI distribution of Sema.
+These docs describe the public Codex-native local CLI distribution of Sema.
 
-Sema is local-first: agents run the CLI inside a project folder, read `.sema`
-contracts, check drift, map impact, and close changes with documentation
-evidence. Public docs are written in English.
+Sema is local-first: Codex runs the CLI inside a project folder, reads `.sema`
+contracts, checks drift, maps impact, and closes changes with documentation
+evidence. `AGENTS.md` is the official Codex entrypoint. Public docs are written
+in English.
+
+Sema is an independent product and is not affiliated with or endorsed by
+OpenAI. Codex-native describes Sema's product direction, not an official OpenAI
+program or submission.
 
 Start here:
 
@@ -15,5 +20,6 @@ Start here:
 - [Documentation Governance](./documentation.md)
 - [Repository Boundary](./repositories.md)
 - [Security](./security.md)
+- [Codex Integration](./ai-integration.md)
 
 Official support: [suporte@otimitare.online](mailto:suporte@otimitare.online)

package/docs/ai-integration.md

@@ -1,9 +1,28 @@
-# AI Integration
+# Codex Integration
 
-Sema is designed for AI agents with different context sizes and discipline
-levels. The public repository documents the local CLI flow only: agents run the
-CLI inside the project, read contracts, check drift, map impact, and close the
-change with evidence.
+The official Sema agent integration is Codex through the repository-level
+`AGENTS.md`. Codex loads that file automatically and runs the local Sema CLI
+inside the project to read contracts, check drift, map impact, and close changes
+with evidence.
+
+Sema is an independent project and is not affiliated with or endorsed by OpenAI.
+Codex surfaces and `AGENTS.md` behavior are documented at
+https://learn.chatgpt.com/docs/agent-configuration/agents-md.
+
+## Before AGENTS.md Exists
+
+The official Sema skill is the required first-contact bootstrap for Codex in a
+project that does not have Sema yet. Install it explicitly:
+
+```bash
+codex plugin marketplace add gerlanss/Sema
+codex plugin add sema@sema
+```
+
+The skill locates the local CLI, runs `sema iniciar`, generates `AGENTS.md`, and
+then delegates all ongoing workspace governance to that file. It contains no
+MCP server, remote workspace bridge, login, license, billing, token, credit,
+panel, or authorization gate.
 
 Supported capacity labels: fraca, pequena, media, forte, grande.
 
@@ -13,12 +32,12 @@ For a local workspace, use the local CLI:
 
 ```bash
 sema --version
-sema preflight resumo --json
 sema resumo
 ```
 
-Continue only when preflight returns `use_cli_local`. Do not replace the local
-CLI with an external workspace source, external sync, or project-name guessing.
+A successful `sema --version` is enough to use the local CLI directly. Local
+commands require no login, activation key, license check, token, credits, billing
+service, control panel, or external authorization request.
 
 ## Before Editing
 
@@ -32,19 +51,19 @@ sema impacto contratos/example.sema --alvo app.example --mudanca "describe the c
 Read every document listed by `docs-impacto` before changing code, contracts,
 operational docs, generated artifacts, workflows, profiles, or release material.
 
-## Capacity Tiers
+## Codex Context Tiers
 
-Weak agents should start with `SEMA_BOOT.md`,
+Codex with a small context budget should start with `SEMA_BOOT.md`,
 `SEMA_SMALL_MODEL.md`, `SEMA_BRIEF.micro.txt`,
 `AGENT_CONTEXT_PACK.json`, and `SEMA_INDEX.json`. They should stop early
 when a gate is unclear.
 
-Medium agents should start with `SEMA_BOOT.md`,
+Codex with a medium context budget should start with `SEMA_BOOT.md`,
 `AGENT_CONTEXT_PACK.json`, `SEMA_BRIEF.curto.txt`,
 `SEMA_INDEX.json`, and `AGENTS.md`. They must run docs-impact, drift, and
 impact before edits.
 
-Strong agents may consume `AGENT_CONTEXT_PACK.json`, `SEMA_BRIEF.md`,
+Codex with a large context budget may consume `AGENT_CONTEXT_PACK.json`, `SEMA_BRIEF.md`,
 `SEMA_INDEX.json`, AST, IR, drift, and impact outputs, but larger context does
 not remove the contract-first rule.
 

package/docs/ai-onboarding.md

@@ -1,7 +1,29 @@
-# Teaching Sema To AI Agents
+# Codex Onboarding
 
-Give agents a short rule: contracts come first, and the local CLI is the source
-of truth.
+The official Sema skill is required for Codex to recognize and initialize Sema
+before a project has its own protocol:
+
+```bash
+codex plugin marketplace add gerlanss/Sema
+codex plugin add sema@sema
+```
+
+Open a new Codex task in the target repository after installation. Codex loads
+the plugin/skill catalog at task start, so `$sema` is not added retroactively to
+an already-open task. Invoke `$sema` in the new task; it bootstraps the project,
+reads the generated `AGENTS.md`, and later tasks load that protocol
+automatically.
+
+`AGENTS.md` is the official Sema entrypoint for Codex. It gives Codex the durable
+repository rule that contracts come first and the local CLI is the source of
+truth. Once the file exists, the skill delegates to it instead of carrying a
+second copy of the governed workflow.
+
+Create or refresh the entrypoint with:
+
+```bash
+sema sync-codex --json
+```
 
 ## Minimal Prompt
 
@@ -10,19 +32,19 @@ This workspace is governed by Sema. Before editing code, contracts, docs,
 workflows, profiles, or release scripts, run:
 
 1. sema --version
-2. sema preflight resumo --json
-3. sema resumo
-4. sema docs-impacto --intencao "<change>" --json
-5. sema inspecionar on the applicable .sema contract
-6. sema drift before editing existing code
-7. sema impacto before changing behavior
-8. sema finalizar-mudanca before closing
-
-If the CLI is unavailable or preflight does not return use_cli_local, stop.
-Do not replace Sema with manual search or guessed contracts.
+2. sema resumo
+3. sema docs-impacto --intencao "<change>" --json
+4. sema inspecionar on the applicable .sema contract
+5. sema drift before editing existing code
+6. sema impacto before changing behavior
+7. sema finalizar-mudanca before closing
+
+If the CLI is unavailable, stop and install or repair @semacode/cli. There is
+no separate Sema login, license activation, or authorization gate. Do not
+replace Sema with manual search or guessed contracts.
 ```
 
-## What Agents Should Not Do
+## What Codex Should Not Do
 
 - Do not invent `.sema` contracts.
 - Do not implement code without an applicable contract.
@@ -30,4 +52,11 @@ Do not replace Sema with manual search or guessed contracts.
 - Do not publish private or sensitive operational material.
 - Do not replace the local CLI when the local workspace is available.
 
+Other AI clients can invoke the public CLI manually, but Sema does not ship or
+manage an official repository entrypoint for them. The supported product path
+is Codex plus `AGENTS.md`.
+
+Sema is an independent product and is not affiliated with or endorsed by
+OpenAI.
+
 Support: suporte@otimitare.online

package/docs/ai-workflow.md

@@ -1,19 +1,18 @@
 <!-- sema:agent-entrypoint:start -->
-# Practical AI + Sema Workflow
-
-This is the minimum workflow for agents in a local workspace.
-
-1. Leia `SEMA_BOOT.md`.
-2. Rode `sema --version`.
-3. Rode `sema preflight resumo --json` e continue apenas se retornar `use_cli_local`.
-4. Rode `sema resumo`.
-5. Rode `sema docs-impacto --intencao "<acao>" --json`.
-6. Leia a documentacao obrigatoria retornada.
-7. Antes de escolher comando ou interpretar `--saida`, leia `docs/commands.md`.
-8. Antes de criar ou editar contrato, use `exemplos/` e `docs/syntax.md`.
-9. Antes de editar codigo existente, rode `sema drift` e `sema impacto`.
-10. Depois de alterar `.sema`, rode `sema formatar` e `sema validar`.
-11. Antes de concluir, rode `sema finalizar-mudanca` com as docs lidas.
+# Practical Codex + Sema Workflow
+
+This is the minimum workflow for Codex in a local workspace.
+
+1. Read `SEMA_BOOT.md`.
+2. Run `sema --version`. Success enables direct local execution; there is no login, license, token, billing, panel, or authorization gate.
+3. Run `sema resumo`.
+4. Run `sema docs-impacto --intencao "<change>" --json`.
+5. Read every required document returned by the command.
+6. Read `docs/commands.md` before selecting a command or interpreting `--saida`.
+7. Use `exemplos/` and `docs/syntax.md` before creating or editing a contract.
+8. Run `sema drift` and `sema impacto` before editing existing code.
+9. Run `sema formatar` and `sema validar` after changing a `.sema` contract.
+10. Run `sema finalizar-mudanca` with the documents read before closure.
 
 Contract edit rule: `.sema` has its own size budget. Above 300 lines, plan a split by domain/capability; above 500, do not create or edit before splitting. Do not use parte_1/parte_2 and do not force a 1:1 contract-to-file relationship; several contracts can govern the same file through `vinculos`.
 
@@ -21,11 +20,11 @@ Closing rule: `sema drift --json` must return `sucesso:true`. If it reports `suc
 
 UI rule: if the task involves an interface, minimum evidence includes desktop and mobile. On a narrow viewport such as 390px, `document.documentElement.scrollWidth <= document.documentElement.clientWidth` must pass; horizontal scroll blocks closure.
 
-## Agent Capacity
+## Codex Context Capacity
 
-- Weak agent: `SEMA_SMALL_MODEL.md`, `SEMA_BRIEF.micro.txt`, `AGENT_CONTEXT_PACK.json`, `SEMA_INDEX.json`.
-- Medium agent: `SEMA_BOOT.md`, `AGENT_CONTEXT_PACK.json`, `SEMA_BRIEF.curto.txt`, `SEMA_INDEX.json`, `AGENTS.md`.
-- Strong agent: `SEMA_BOOT.md`, `AGENT_CONTEXT_PACK.json`, `SEMA_BRIEF.md`, `SEMA_INDEX.json`, AST, IR, drift, and impact.
+- Small context: `SEMA_SMALL_MODEL.md`, `SEMA_BRIEF.micro.txt`, `AGENT_CONTEXT_PACK.json`, `SEMA_INDEX.json`.
+- Medium context: `SEMA_BOOT.md`, `AGENT_CONTEXT_PACK.json`, `SEMA_BRIEF.curto.txt`, `SEMA_INDEX.json`, `AGENTS.md`.
+- Large context: `SEMA_BOOT.md`, `AGENT_CONTEXT_PACK.json`, `SEMA_BRIEF.md`, `SEMA_INDEX.json`, AST, IR, drift, and impact.
 
 ## When to Generate Code
 
@@ -39,24 +38,8 @@ Replace `javascript` with `typescript`, `python`, `php`, `dart`, `lua`, `html`,
 
 ## Fail Closed
 
-- Se não conseguir chamar Sema, pare e declare bloqueio em vez de editar código ou contrato.
-- Se não houver contrato aplicável ou vínculo semântico do arquivo, inspecione o arquivo, descubra ou crie o .sema aplicável e vincule antes do código.
-- Em IDE local, rode sema --version; se falhar, pare. A IA não acessa o painel Sema: peça ao humano para instalar a CLI pelo painel. Depois rode sema preflight <comando> --json; só continue com use_cli_local; não use fonte externa de workspace para substituir a CLI local.
-- Se não houver workspace local em disco, pare bloqueado e peça o fluxo apropriado; não invente caminho nem substitua a CLI local por ferramenta paralela.
-- Se arquivos_codigo.conteudo ou conteudo inline passar de 262144 caracteres, não aumente timeout para forçar: divida por responsabilidade ou use anexo/caminho de servidor autorizado.
-- Se for criar ou corrigir .sema, use sema_exemplos antes de escrever sintaxe.
-- Se a resposta humana estiver em PT-BR, use vocabulário Sema canônico e preserve acentos mesmo que a DSL use ASCII.
-- Se um arquivo de código tiver SEMA-GOVERNED, consulte Sema e o contrato aplicável antes de editar.
-- Se codigo governado passar de 1000 linhas, planeje divisao; se passar de 2000, pare e divida antes de concluir. Documentacao Markdown nao entra nesse limite de codigo.
-- Se contrato .sema passar de 300 linhas, planeje split por dominio/capacidade; acima de 500, criacao e edicao ficam bloqueadas. Nao use parte_1/parte_2 e nao remova guarantees, tests ou vinculos so para caber.
-- Um mesmo arquivo de codigo pode ser governado por varios contratos .sema via vinculos; Sema Codigo deve preservar essa rastreabilidade.
-- Se score, achados ou decisaoAgente parecerem bons, trate como sinal de triagem e confira evidência concreta no contrato e no código.
-- Se validar artefato inline com 100/100, ainda preserve cabeçalho SEMA-GOVERNED no arquivo físico sincronizado.
-- Se `sema drift` retornar sucesso:false, `vinculos_quebrados`, `rotas_divergentes` ou impls quebradas, a mudanca nao pode ser declarada concluida; corrija contrato/codigo e rode drift de novo.
-- Se a tarefa tiver site, sistema, app, UI, painel, jogo, CLI/TUI ou terminal, nao conclua sem acabamento moderno, contextual e evidenciado; em UI mobile estreita (ex. 390px), `document.documentElement.scrollWidth <= document.documentElement.clientWidth` precisa ser verdadeiro.
-- Se texto visivel PT-BR perder acento ou cedilha em termos como descricao, lancamentos, saude ou alimentacao, trate como defeito bloqueante quando houver i18n/idioma declarado.
-- Se aparecer caminho que não pertence ao workspace local aberto pelo usuário, pare e confirme a fonte antes de agir.
-- Se uma chamada Sema estourar por timeout local, aumente o timeout e tente de novo; timeout do agente não libera ação sem Sema.
-- Se a plataforma bloquear ou alertar política, trate como bloqueio externo ou falso positivo possível; explique sem tentar contornar filtro.
-- Se a tarefa tiver experiência de uso e você não conseguir garantir padrão moderno, contextual e não genérico, pare e peça revisão em vez de entregar coisa engessada.
+- If the local CLI is unavailable, stop before editing governed code or contracts and ask for `@semacode/cli` installation.
+- If the applicable contract or semantic link is missing, create or repair it before code.
+- If validation or drift reports failure, broken links, divergent routes, or broken implementations, fix the evidence and run the gate again.
+- A local timeout is not authorization to skip Sema; retry with a larger timeout or a narrower scope.
 <!-- sema:agent-entrypoint:end -->

package/docs/auth.md

@@ -1,15 +1,25 @@
-# Authentication Boundary
+# Local Runtime Boundary
 
-The public Sema CLI does not require authentication.
+The public Sema CLI executes directly against the local workspace. It does not
+require a Sema login, user authentication, product authorization, license
+activation, install key, token, credits, billing service, control panel, or an
+external request.
 
 Use local commands:
 
 ```bash
 sema --version
-sema preflight resumo --json
+sema resumo
 sema validar contratos/example.sema --json
 ```
 
+The repository license governs use and redistribution. It is not checked as a
+runtime activation mechanism.
+
+An `authz` block inside a `.sema` contract describes authorization in the
+application being governed. It does not authenticate a person before the Sema
+CLI can run.
+
 Do not put private or sensitive operational material in this repository.
 
 Application-specific authentication belongs in the application repository that