@brunosps00/dev-workflow 1.0.6 → 1.1.0

package/scaffold/en/commands/dw-secure-audit.md

@@ -1,7 +1,13 @@
 <system_instructions>
-You are the security audit orchestrator. Runs OWASP static review + supply-chain CVE/secret/IaC scanning + dependency outdated check + supply-chain compromise detection in one pass. Hard-gates downstream commands when CRITICAL or HIGH findings exist.
+You are the security audit orchestrator — the **Security Gate**. Runs OWASP static review + SAST
+(Semgrep, diff-focused on the generated code) + dedicated secret scanning (gitleaks) + supply-chain
+CVE/secret/IaC scanning (Trivy + native lockfile audit) + supply-chain compromise detection + outdated
+check, in one pass. Hard-gates downstream commands when any blocking finding exists.
 
-Auto-invoked by `/dw-review` and `/dw-generate-pr` for TS/Python/C#/Rust projects. Standalone invocation available for manual audit.
+It is **auto-invoked by `/dw-review` and `/dw-generate-pr`** (for TS/Python/C#/Rust), runs as an **explicit,
+named phase in `/dw-autopilot`** (after review + QA, before commit/PR), and is **runnable standalone** any
+time. `/dw-generate-pr` re-enforces the verdict as a final hard gate. All three keep gating on security —
+the standalone command and the named phase are additive, not a replacement.
 
 ## When to Use
 - Auto-invoked: `/dw-review` and `/dw-generate-pr` for supported languages.
@@ -10,7 +16,7 @@ Auto-invoked by `/dw-review` and `/dw-generate-pr` for TS/Python/C#/Rust project
 - Do NOT use as a substitute for human security review on high-stakes auth/payment code (use `security-review` skill PLUS this).
 
 ## Pipeline Position
-**Predecessor:** any time; auto-invoked by `/dw-review`, `/dw-generate-pr` | **Successor:** `/dw-bugfix` to address findings, or `/dw-commit` if APPROVED
+**Predecessor:** `/dw-review` + `/dw-qa` (the Security Gate runs after they pass) | **Successor:** `/dw-commit` / `/dw-generate-pr` if APPROVED, or `/dw-bugfix` to address findings. Can also run standalone any time.
 
 ## Modes
 
@@ -33,10 +39,20 @@ Auto-invoked by `/dw-review` and `/dw-generate-pr` for TS/Python/C#/Rust project
 
 ## Required Dependencies
 
-- **Trivy** — must be installed (via `npx @brunosps00/dev-workflow install-deps`).
+- **Trivy** — SCA / secrets / IaC (via `npx @brunosps00/dev-workflow install-deps`).
+- **Semgrep** — SAST layer (optional but recommended). If absent, the SAST layer is skipped and noted.
+- **gitleaks** — dedicated secret scan (optional but recommended). If absent, falls back to Trivy secrets.
 - **Context7 MCP** — for framework-version-specific security best practices.
 
-## Three Detection Layers
+All scanners are optional individually: a missing tool degrades that layer and is **reported** in the
+summary (the gate never crashes for a missing scanner), but the missing coverage is visible. Install via
+`npx @brunosps00/dev-workflow install-deps`.
+
+## Detection Layers
+
+**Diff focus (the generated code):** layers that support it scope to the diff against the PR base
+(`git merge-base HEAD origin/main`) so the gate concentrates on the code just written, without noise from
+pre-existing code. A `--full` periodic pass scans the whole tree.
 
 ### Layer 1: OWASP Static Review (via `security-review` skill)
 
@@ -72,6 +88,23 @@ Cross-references the dependency tree against:
 
 Output: `.dw/secure-audit/compromise-findings.md` per affected package: COMPROMISED / suspicious / clean.
 
+### Layer 4: SAST — Semgrep (semantic analysis of generated code)
+
+Deterministic, semantic static analysis of the **diff** (`--baseline-commit`), complementing the human-style
+Layer 1. Pinned rulesets: `p/security-audit`, `p/owasp-top-ten`, `p/secrets` (+ language packs as detected).
+Map Semgrep `ERROR`→HIGH (or CRITICAL for RCE/authn-bypass/SQLi CWEs), `WARNING`→MEDIUM, `INFO`→LOW. Apply
+the **fp-check** reachability discipline before a finding blocks (see `security-review/references/sast.md`).
+
+Output: `.dw/secure-audit/sast-findings.md`. If `semgrep` is absent: skipped + noted in the summary.
+
+### Layer 5: Dedicated secret scan — gitleaks
+
+`gitleaks protect --staged` (uncommitted) or `gitleaks detect --log-opts <base>..HEAD` (branch), `--redact`.
+Authoritative for the diff; complements Trivy secrets (dedupe by `file:line`). **Any hit = REJECTED, no ADR
+exception** — secrets are removed and rotated, not justified. See `security-review/references/secrets.md`.
+
+Output: `.dw/secure-audit/secret-findings.md`. If `gitleaks` is absent: falls back to Trivy secrets + noted.
+
 ### Plus: outdated check
 
 `npm outdated` / `pip list --outdated` / `dotnet list outdated` / `cargo outdated` to identify packages behind by minor or major versions.
@@ -84,9 +117,11 @@ All findings are classified into one of these tiers in `.dw/secure-audit/audit-s
 
 | Tier | Criteria | Block | Suggested Action |
 |------|----------|-------|------------------|
+| **SECRET** | Hardcoded credential/key/token (gitleaks or Trivy), survives allowlist | YES — **no ADR exception** | Remove from code + history, rotate, move to a secret store |
 | **COMPROMISED** | Package known to be malicious in this version range | YES | Immediate remove / pin to safe version |
-| **CRITICAL** | CVE CVSS ≥9.0 OR exploits in the wild OR auth bypass | YES | Update or replace within 24h |
-| **HIGH** | CVE CVSS 7.0–8.9 OR exploitable in current context | YES | Update or replace within 1 week |
+| **CRITICAL** | CVE CVSS ≥9.0 OR exploits in the wild OR auth bypass; OR SAST high-impact CWE (SQLi/RCE/authn-bypass/SSRF/deserialization) reachable | YES | Update/replace or fix within 24h |
+| **HIGH** | CVE CVSS 7.0–8.9 OR exploitable in context; OR Semgrep `ERROR` reachable (fp-check passed) | YES | Update/replace or fix within 1 week |
+| **MEDIUM / LOW** | CVE CVSS <7.0; OR Semgrep `WARNING`/`INFO`; OR unreachable finding downgraded by fp-check | NO (advisory) | Track and fix routinely |
 | **OUTDATED-MAJOR** | ≥1 major version behind (e.g., React 17 → 19) | NO | Plan migration in next quarter |
 | **OUTDATED-MINOR** | Minor/patch behind | NO | Update routinely |
 | **CLEAN** | No findings | NO | — |
@@ -94,19 +129,26 @@ All findings are classified into one of these tiers in `.dw/secure-audit/audit-s
 ## Hard Gates
 
 The verdict is one of:
-- **APPROVED** — no CRITICAL or HIGH or COMPROMISED findings. Verdict file `.dw/secure-audit/audit-summary.md` status: APPROVED.
-- **REJECTED** — ≥1 CRITICAL, HIGH, or COMPROMISED finding without explicit ADR or remediation in flight. Verdict file status: REJECTED.
+- **APPROVED** — no SECRET, COMPROMISED, CRITICAL, or HIGH findings. Verdict file `.dw/secure-audit/audit-summary.md` status: APPROVED. (MEDIUM/LOW/outdated may be present as advisory.)
+- **REJECTED** — ≥1 SECRET (always), or ≥1 COMPROMISED/CRITICAL/HIGH without explicit ADR or remediation in flight. Verdict file status: REJECTED.
+
+**Rigoroso threshold:** SECRET and COMPROMISED always block. CRITICAL/HIGH (CVE or reachable SAST) block unless an ADR justifies acceptance. MEDIUM/LOW and outdated are advisory. A SECRET is the one tier with **no ADR escape** — rotate, don't justify.
 
 **`/dw-review` and `/dw-generate-pr` enforce:** if the project's language is supported AND the most recent `.dw/secure-audit/audit-summary.md` is missing OR REJECTED, those commands themselves return REJECTED. No exception. No bypass flag.
 
 ## Mode 1: Default (`/dw-secure-audit`)
 
 1. **Detect stack**: check for package.json / requirements.txt / *.csproj / Cargo.toml.
-2. **Run all three layers in parallel** (where possible):
-   - OWASP static (via `security-review` skill).
+2. **Run all detection layers in parallel** (where possible):
+   - OWASP static (via `security-review` skill) — diff-focused.
+   - SAST — Semgrep on the diff (`--baseline-commit`).
+   - Dedicated secret scan — gitleaks on the diff.
    - Trivy + lockfile audit.
    - Supply-chain compromise check.
 3. **Run outdated check.**
+   **fp-check:** before finalizing, run reachability validation on each blocking SAST/OWASP finding
+   (see `security-review` SKILL.md); downgrade provably-unreachable ones to advisory with a logged reason.
+   Secrets are exempt from downgrade.
 4. **Aggregate findings** per classification tier.
 5. **Write summary** at `.dw/secure-audit/audit-summary.md`:
 
@@ -118,14 +160,26 @@ The verdict is one of:
 ## Tier Summary
 | Tier | Count | Detail |
 |------|-------|--------|
+| SECRET | N | <list> |
 | COMPROMISED | N | <list> |
 | CRITICAL | N | <list> |
 | HIGH | N | <list> |
+| MEDIUM/LOW (advisory) | N | <list> |
 | OUTDATED-MAJOR | N | <list> |
 | OUTDATED-MINOR | N | <list> |
 
+## Scanners
+| Layer | Tool | Status |
+|-------|------|--------|
+| OWASP | security-review | run |
+| SAST | semgrep | run / skipped (not installed) |
+| Secrets | gitleaks | run / fallback to trivy (not installed) |
+| SCA/IaC | trivy | run |
+
 ## Layer reports
 - OWASP findings: `owasp-findings.md`
+- SAST findings: `sast-findings.md`
+- Secret findings: `secret-findings.md`
 - Trivy findings: `trivy-findings.md`
 - Lockfile findings: `lockfile-findings.md`
 - Compromise findings: `compromise-findings.md`
@@ -164,7 +218,7 @@ For each user-approved remediation:
 ## Mode 4: CI mode (`/dw-secure-audit --scan-only`)
 
 Minimal output:
-- Runs all three layers.
+- Runs all detection layers.
 - Writes findings to disk.
 - Exits with code 0 if APPROVED, 1 if REJECTED.
 - No remediation planning.
@@ -182,8 +236,9 @@ For pre-merge CI gates.
 ## Constitution Gate
 
 <critical>
-- A CRITICAL or COMPROMISED finding without an ADR justifying explicit acceptance → verdict cannot be APPROVED.
-- Constitution principle violations (security-related principles like P-009 server-side auth, P-010 secrets-in-repo) escalate findings — a `severity: info` principle violation surfaced here becomes a HIGH classification.
+- A SECRET finding → verdict cannot be APPROVED, EVER (no ADR escape). Rotate and remove.
+- A CRITICAL/HIGH/COMPROMISED finding (CVE or reachable SAST) without an ADR justifying explicit acceptance → verdict cannot be APPROVED.
+- Constitution principle violations (security principles like P-009 server-side auth, P-010 secrets-in-repo, P-011 no high-severity SAST) escalate findings — a `severity: info` principle violation surfaced here becomes a HIGH classification.
 </critical>
 
 ## Anti-patterns
@@ -198,8 +253,10 @@ For pre-merge CI gates.
 
 ```
 .dw/secure-audit/
-├── audit-summary.md           # verdict + tier summary
+├── audit-summary.md           # verdict + tier summary + scanner status
 ├── owasp-findings.md          # Layer 1
+├── sast-findings.md           # Layer 4 (Semgrep)
+├── secret-findings.md         # Layer 5 (gitleaks, redacted)
 ├── trivy-findings.md          # Layer 2 (SCA + secrets + IaC)
 ├── lockfile-findings.md       # Layer 2 (native auditor)
 ├── compromise-findings.md     # Layer 3

package/scaffold/en/templates/constitution-template.md

@@ -80,12 +80,17 @@ mode: defaults | custom
 **P-009 — Server-side authorization on every state-changing endpoint** (severity: info)
 **Rule:** Any endpoint that creates, updates, or deletes data must verify caller authorization on the server. UI-level gating (hidden buttons, disabled forms) is not security.
 **Why:** Browsers are untrusted (see `dw-testing-discipline/references/security-boundary.md`). UI gating is convenience; only server checks protect data.
-**Enforcement:** `dw-code-review` and `dw-security-check` require an explicit auth check (decorator, middleware, or in-handler assertion) on POST/PUT/PATCH/DELETE routes.
+**Enforcement:** `dw-review` and the `dw-secure-audit` Security Gate require an explicit auth check (decorator, middleware, or in-handler assertion) on POST/PUT/PATCH/DELETE routes.
 
-**P-010 — Secrets never enter the repository** (severity: info)
+**P-010 — Secrets never enter the repository** (severity: high)
 **Rule:** No API keys, passwords, signing keys, tokens, or production endpoints checked into source. `.env.example` documents shape only.
 **Why:** Repository history is permanent. A secret committed once is leaked even if reverted next commit.
-**Enforcement:** `dw-security-check` runs Trivy + secret scanners on the diff.
+**Enforcement:** the `dw-secure-audit` Security Gate runs gitleaks + Trivy secret scanners on the diff. Any hit blocks — with **no ADR exception** (rotate, don't justify).
+
+**P-011 — No high-severity SAST finding ships unreviewed** (severity: high)
+**Rule:** Generated/changed code must pass the SAST layer (Semgrep) of the Security Gate. A reachable high-severity finding (SQLi, command/code injection, SSRF, insecure deserialization, authn bypass) blocks unless an ADR justifies acceptance.
+**Why:** AI-generated code reproduces insecure patterns at scale; deterministic SAST on the diff catches what review by reading misses.
+**Enforcement:** `dw-secure-audit` runs Semgrep on the diff (`--baseline-commit`); findings survive an fp-check reachability validation before blocking.
 
 ---
 

package/scaffold/en/templates/functional-doc/playwright.flow.mjs.tpl

@@ -0,0 +1,17 @@
+// Functional-doc flow module. Driven by .dw/scripts/functional-doc/run-playwright-flow.mjs
+// through the Playwright Node API, so video is captured with page.screencast (works both
+// for a launched browser and over connectOverCDP). No imports are needed here — the runner
+// injects page, context, expect, baseURL and the step()/shot() helpers.
+
+export default async function flow({ page, expect, baseURL, step, shot }) {
+  await step("Open target route", async () => {
+    await page.goto(`${baseURL}{{routePath}}`);
+    await expect(page).toHaveURL(new RegExp("{{routeRegex}}"));
+  });
+
+{{testSteps}}
+
+  await step("Record final context", async () => {
+    await expect(page.locator("body")).toBeVisible();
+  });
+}

package/scaffold/pt-br/commands/dw-analyze-project.md

@@ -767,6 +767,27 @@ Se após as heurísticas nada cruzar a barra (codebase pequeno, churn baixo, sem
 
 **Cadência de refresh:** usuários re-rodam `/dw-analyze-project` quando rules ficam desatualizadas. O Passo 9 atualiza seções auto mantendo entradas preservadas. Não existe comando separado só de refresh.
 
+### Passo 10: Autoridade de design (DESIGN.md) — só projetos frontend
+
+Rode quando um frontend for detectado (React/Vue/Angular/Svelte/Tailwind/CSS), para que a grounding
+question 1 do `dw-ui-discipline` ("de onde vêm as decisões de design?") tenha uma autoridade do projeto
+para seguir. Isso fecha o loop que hoje a grounding apenas *lê*.
+
+1. **Cheque uma autoridade existente primeiro.** Se `DESIGN.md`, `BRAND.md` ou `STYLE_GUIDE.md` já existe
+   na raiz do projeto (ou do módulo frontend), NÃO sobrescreva — registre a localização e pare.
+2. **Detecte design tokens** em ordem de prioridade: `theme`/`@theme` do Tailwind (cores, fontFamily,
+   spacing, radius), CSS custom properties em `globals.css`/`theme.css`/`tokens.css`, theme exports de
+   MUI/Chakra, `components.json` do shadcn, theme do Storybook. Leia os valores reais — não invente.
+3. **Se houver tokens:** sintetize `DESIGN.md` na raiz do frontend capturando o que o projeto JÁ usa —
+   paleta (com os valores hex/oklch reais e nomes dos tokens), tipografia (famílias, escala, pesos),
+   escala de spacing/radius e convenções de componente observadas. Inicie com:
+   `> Gerado por /dw-analyze-project a partir de tokens existentes em <data>. Cure antes de tratar como canon.`
+4. **Se não houver tokens:** NÃO fabrique paleta. Recomende bootstrap a partir de
+   `dw-ui-discipline/references/curated-defaults.md` e registre essa recomendação no índice de rules.
+5. Referencie o novo `DESIGN.md` a partir de `.dw/rules/<módulo-frontend>.md` para os comandos downstream acharem.
+
+Este passo é aditivo e reversível; nunca edita código de componente, só documenta o que existe.
+
 ## Checklist de Qualidade
 
 - [ ] Estrutura do repositório escaneada
@@ -797,6 +818,7 @@ Se após as heurísticas nada cruzar a barra (codebase pequeno, churn baixo, sem
 - [ ] Convenções de teste documentadas (framework, padrões, cobertura)
 - [ ] Step 8 (constitution) oferecido e resolvido (A/B/C)
 - [ ] Step 9 (mapa de concerns) apresentou candidatos, aguardou aprovação, escreveu `.dw/rules/concerns.md` (ou anotou que não há sinais)
+- [ ] Passo 10 (autoridade de design) rodou para projetos frontend: autoridade existente respeitada, ou `DESIGN.md` gerado a partir de tokens reais, ou bootstrap via curated-defaults recomendado
 - [ ] Blocos com marker preserved em concerns.md mantidos verbatim no refresh
 
 ## Exemplo de Uso

package/scaffold/pt-br/commands/dw-autopilot.md

@@ -152,10 +152,11 @@ Quando `autopilot-state.json status=plan_complete`, invoque formalmente:
 O goal e dono desta sequencia:
 
 1. `/dw-run <prd-path>`
-2. `/dw-review <prd-path>` (review completo: cobertura, qualidade, convencoes, seguranca, constitution, verify)
+2. `/dw-review <prd-path>` (review completo: cobertura, qualidade, convencoes, constitution, verify)
 3. `/dw-qa <prd-path>`
 4. `/dw-qa --fix <prd-path>` se QA encontrou bugs Open
 5. `/dw-review <prd-path>` novamente apos QA/fixes
+6. **Security Gate** — o `/dw-review` pós-QA (passo 5) aciona o `/dw-secure-audit`, produzindo um `.dw/secure-audit/audit-summary.md` fresco. Este passo **garante** que o verdict é APROVADO: se ausente/desatualizado/REPROVADO, rode `/dw-secure-audit <prd-path>` standalone, depois volte pro `/dw-bugfix` por finding e re-cheque. Findings SECRET sempre bloqueiam (sem escape de ADR). Não force um segundo scan completo quando já existe um summary APROVADO fresco.
 
 <critical>Nao substitua os reviews do goal por `/dw-review --coverage-only`. O goal de qualidade do autopilot exige `/dw-review` completo antes do QA e depois dos fixes de QA.</critical>
 
@@ -175,6 +176,7 @@ Antes de `/dw-commit`, verifique:
 - `.dw/goals/autopilot-<prd-slug>/status.json` esta completo.
 - `<prd-path>/QA/review-consolidated.md` existe a partir do review final pos-QA.
 - `<prd-path>/QA/qa-report.md` e `<prd-path>/QA/bugs.md` existem.
+- **Security Gate passou:** `.dw/secure-audit/audit-summary.md` existe, esta fresco (pos-ultima-edicao) e status APROVADO. Se ausente/desatualizado/REPROVADO → PARE (nao commite).
 - `autopilot-state.json` registra artefatos de planejamento e o goal completo.
 
 Se algo estiver faltando, PARE e re-execute o comando formal ausente. Nao faca commit parcial.

package/scaffold/pt-br/commands/dw-functional-doc.md

@@ -114,7 +114,7 @@ Arquivos mínimos:
 - `case-matrix.md`
 - `e2e-runbook.md`
 - `manifest.json`
-- `scripts/*.spec.ts`
+- `scripts/*.flow.mjs`
 - `captions/*.srt`
 
 Se houver execução:
@@ -291,8 +291,16 @@ Se já existir no workspace um script de shell funcional (ex: `record-human-tour
 ## Scripts utilitários
 
 Use os utilitários do workspace quando fizer sentido:
-- `node .dw/scripts/dw-functional-doc/generate-dossier.mjs --target <URL> [--lang en|pt-br] [--project <nome>] [--base-url <url>]`
-- `node .dw/scripts/dw-functional-doc/run-playwright-flow.mjs --flow-dir <caminho> [--browser-name chromium|firefox] [--video-resolution fullhd|1920x1080]`
+- `node .dw/scripts/functional-doc/generate-dossier.mjs --target <URL> [--lang en|pt-br] [--project <nome>] [--base-url <url>]`
+- `node .dw/scripts/functional-doc/run-playwright-flow.mjs --flow-dir <caminho> [--video-resolution fullhd|1920x1080] [--list-only]`
+
+O runner dirige o Playwright pela API Node e grava vídeo com `page.screencast` (único mecanismo que
+funciona via CDP). Ele gera `scripts/<slug>.flow.mjs` — um módulo ESM simples que exporta
+`async function flow({ page, context, expect, baseURL, step, shot })`, não um spec `@playwright/test`,
+então dispensa o `playwright.config.*` do projeto. O browser é escolhido por `.dw/scripts/lib/resolve-browser.mjs`
+(resiliente no WSL: Chromium headless full por padrão; defina `BROWSER_TEST` com o caminho do exe do browser do Windows para dirigi-lo via CDP — em NAT rode `npx @brunosps00/dev-workflow setup-wsl-browser` uma vez para o cdp-relay.exe + regra Hyper-V, em mirrored funciona direto);
+veja a seção "Browser on WSL" de `dw-testing-discipline/references/playwright-recipes.md`. Só Chromium —
+`screencast`/CDP não suportam Firefox/WebKit.
 
 ## Critérios de completude
 

package/scaffold/pt-br/commands/dw-generate-pr.md

@@ -15,11 +15,11 @@
     |-------|---------|
     | `dw-verify` | **SEMPRE** — invocada antes do `git push`. Sem VERIFICATION REPORT PASS na sessão após a última edição de código, o PR **NÃO** pode ser criado. |
     | `dw-git-discipline` | **SEMPRE** — valida naming de branch (`<tipo>/<escopo>` kebab-case), histórico atomic-commit (cada commit single-intent, mensagem conventional), tempo de vida da branch (flag se >7 dias) e escopo da PR (sugere split se diff > ~400 linhas). Descrição da PR segue summary + test plan, não dump de `git log`. |
-    | `/dw-secure-audit` | **SEMPRE para projetos TS/Python/C#/Rust** — `security-check.md` com status ≠ REJECTED é obrigatório para projetos em linguagem suportada. |
+    | `/dw-secure-audit` | **SEMPRE para projetos TS/Python/C#/Rust** — um `.dw/secure-audit/audit-summary.md` fresco com status ≠ REJECTED é obrigatório para projetos em linguagem suportada. |
 
     <critical>Hard gate 1 (verify): se a sessão atual não tem um VERIFICATION REPORT PASS de `dw-verify` produzido APÓS a última edição/commit, PARAR e invocar `dw-verify` antes de prosseguir. PR é um artefato permanente — exige o maior rigor de verificação.</critical>
 
-    <critical>Hard gate 2 (security): para projetos TS/Python/C#/Rust, se `{{PRD_PATH}}/security-check.md` não existir OU tiver status REJECTED, PARAR e invocar `/dw-secure-audit` antes de prosseguir. Vulnerabilidades HIGH/CRITICAL NÃO podem chegar ao PR. Para outras linguagens (Go, Java, etc.), este gate é pulado com nota.</critical>
+    <critical>Hard gate 2 (security): para projetos TS/Python/C#/Rust, se `.dw/secure-audit/audit-summary.md` não existir, estiver desatualizado (anterior à última edição) OU tiver status REJECTED, PARAR e invocar `/dw-secure-audit` antes de prosseguir. Findings SECRET e vulnerabilidades HIGH/CRITICAL NÃO podem chegar ao PR. Para outras linguagens (Go, Java, etc.), este gate é pulado com nota.</critical>
 
     ## Uso
 

package/scaffold/pt-br/commands/dw-qa.md

@@ -83,7 +83,7 @@ Quando disponíveis em `./.agents/skills/`, invocadas operacionalmente:
 
 1. **Pre-flight**: confirmar que dev server do projeto pode rodar. Confirmar `.dw/spec/<prd>/` tem PRD + TechSpec + tasks.
 2. **Mapear FRs para test plan**: pra cada FR, identificar fluxo user-facing que exercita.
-3. **Dirigir Playwright MCP** (ou fallback pra Playwright local per `dw-testing-discipline/references/playwright-recipes.md`):
+3. **Dirigir Playwright MCP** (se indisponível ou bloqueado — comum no WSL — use o fallback local resiliente `node .dw/scripts/lib/capture-screenshots.mjs`, que escolhe o browser via `.dw/scripts/lib/resolve-browser.mjs`; veja a seção "Browser on WSL" de `dw-testing-discipline/references/playwright-recipes.md`):
    - Happy paths pra cada FR.
    - Edge cases (boundary inputs, falha de rede, erros de validação).
    - Fluxos negativos (ações não autorizadas, input malformado).

package/scaffold/pt-br/commands/dw-redesign-ui.md

@@ -56,12 +56,12 @@ Utilize ferramentas de diagnóstico conforme o framework do projeto:
 ## Comportamento Obrigatório
 
 1. Identifique o alvo: página, componente ou rota que será redesenhada.
-2. **AUDITAR**: leia a implementação atual, identifique stack CSS (Tailwind, CSS Modules, styled-components, etc.), capture screenshot usando `dw-testing-discipline`/playwright-recipes se disponível, rode react-doctor se projeto React.
+2. **AUDITAR**: leia a implementação atual, identifique stack CSS (Tailwind, CSS Modules, styled-components, etc.), capture o screenshot do estado-antes (Playwright MCP, ou `node .dw/scripts/lib/capture-screenshots.mjs` como fallback resiliente no WSL), rode react-doctor se projeto React.
 3. Faça 3 a 5 perguntas sobre objetivos do redesign: direção de estilo, constraints de marca, inspirações, público-alvo, dispositivos prioritários.
 4. **PROPOR**: apresente 2 a 3 direções de design depois de passar pelo hard-gate de `dw-ui-discipline` (brand authorities ou curated defaults; surface job sentence; state matrix enumerada; scene sentence). Cada direção lista paleta de cores, par tipográfico, estilo de layout e racional. Self-check de cada direção contra os 14 anti-slop patterns. Para CADA direção, descreva explicitamente o layout mobile (<=768px) e o layout desktop (>=1024px), incluindo como os elementos se reorganizam, empilham ou escondem entre breakpoints.
 5. Espere aprovação explícita do usuário antes de implementar.
 6. **IMPLEMENTAR**: aplique o design escolhido com abordagem mobile-first — implemente primeiro o layout mobile e depois adicione media queries/breakpoints para tablet e desktop. Respeite a stack existente. Use `vercel-react-best-practices` para React/Next.js. Mantenha a metodologia CSS do projeto.
-7. **VALIDAR**: capture estado depois em AMBAS as resoluções (mobile e desktop), compare antes/depois, verifique acessibilidade contra `dw-ui-discipline/references/accessibility-floor.md` (WCAG 2.2 AA — não-negociável: contraste, focus-visible, keyboard nav, ARIA, sem traps), rode react-doctor `--diff` se React. Use `dw-testing-discipline/references/playwright-recipes.md` para capturar screenshots em viewport 375px (mobile) e 1440px (desktop).
+7. **VALIDAR**: capture estado depois em AMBAS as resoluções (mobile e desktop), compare antes/depois, verifique acessibilidade contra `dw-ui-discipline/references/accessibility-floor.md` (WCAG 2.2 AA — não-negociável: contraste, focus-visible, keyboard nav, ARIA, sem traps), rode react-doctor `--diff` se React. Capture screenshots em 375px (mobile) e 1440px (desktop) — `node .dw/scripts/lib/capture-screenshots.mjs --url <url> --widths 375,1440` é o caminho resiliente no WSL; veja a seção "Browser on WSL" de `dw-testing-discipline/references/playwright-recipes.md`.
 8. **PERSISTIR CONTRATO**: se o usuário aprovou uma direção, gere `design-contract.md` no diretório do PRD (`.dw/spec/prd-[nome]/design-contract.md`) com: direção aprovada, paleta de cores, par tipográfico, regras de layout, regras de acessibilidade e regras de componentes. Este contrato será lido por `dw-run-task` e `dw-run-plan` para garantir consistência visual.
 
 ## Inteligência do Codebase

package/scaffold/pt-br/commands/dw-review.md

@@ -44,9 +44,10 @@ Quando disponíveis em `./.agents/skills/`, são invocadas como apoio analítico
 
 - `dw-review-rigor`: **SEMPRE** — aplica de-duplication (mesmo pattern em N arquivos = 1 finding), severity ordering (critical → high → medium → low), verify-before-flag, skip-what-linter-catches, signal-over-volume. A tabela "Problemas Encontrados" segue essa disciplina.
 - `dw-verify`: **SEMPRE** — invocada antes de emitir `APROVADO` ou `APROVADO COM RESSALVAS`. Sem VERIFICATION REPORT PASS (test + lint + build), verdict não pode ser APROVADO.
-- `dw-secure-audit`: **SEMPRE para projetos TS/Python/C#/Rust** — security gate. Se projeto usa linguagem suportada e `secure-audit.md` recente está ausente OU REJECTED, verdict é **REPROVADO** — sem exceção.
+- `dw-secure-audit` (**Security Gate**): **SEMPRE para projetos TS/Python/C#/Rust** — acionado aqui e o verdict é enforced. Se a linguagem é suportada e `.dw/secure-audit/audit-summary.md` fresco está ausente OU REPROVADO, o verdict do review é **REPROVADO** — sem exceção. O mesmo gate também é comando standalone (`/dw-secure-audit`) e fase explícita no `/dw-autopilot`. Agora soma Semgrep SAST (diff) + gitleaks secrets sobre OWASP/Trivy/SCA.
+- `security-review`: a skill OWASP nível-diff que o gate usa (injection, authz, secrets, SSRF, crypto — só HIGH CONFIDENCE).
 - `dw-simplification`: use quando diff toca código denso — aplica Chesterton's Fence, protocolo de refactor preservando comportamento, métricas de complexidade.
-- `dw-ui-discipline`: use quando diff toca UI — roda os 14 visual-slop patterns + accessibility floor.
+- `dw-ui-discipline`: use quando diff toca UI — roda os 14 visual-slop patterns + accessibility floor. Para um gate determinístico, rode também `node .dw/scripts/lib/ui-slop-detect.mjs <paths-ui-alterados> --fail-on error` (wrapper sobre o detector do impeccable); trate findings bloqueantes como **REJECTED** e reporte os warnings.
 - `dw-testing-discipline`: use quando diff toca testes — aplica catálogo de 25 anti-patterns + 6 agent guardrails (quando testes foram agent-authored).
 - `dw-llm-eval`: **OBRIGATÓRIO quando diff toca código de feature AI/LLM**. Reference dataset + ≥2 oracle rungs + judge calibration (se rung 4 usado) + eval run results DEVEM estar no PR. Faltando → REPROVADO.
 - `security-review`: use quando diff toca auth, autorização, input externo, upload, SQL, secrets, SSRF, XSS ou superfícies sensíveis.
@@ -161,9 +162,10 @@ Se FALTANDO > 0, o veredicto sugere revisitar `/dw-plan tasks` pra escopar ou `/
    - Rodar dw-verify pra produzir VERIFICATION REPORT (test + lint + build GREEN).
    - Sem PASS, verdict não pode ser APROVADO.
 
-8. **Security Layer (`dw-secure-audit` para TS/Python/C#/Rust):**
-   - Rodar `/dw-secure-audit` contra o PR. Scan mais recente deve estar presente e não REPROVADO.
-   - Se linguagem suportada e audit faltando OU REPROVADO → verdict **REPROVADO**.
+8. **Security Gate (`dw-secure-audit` para TS/Python/C#/Rust):**
+   - Acione `/dw-secure-audit` contra o diff (OWASP + Semgrep SAST + gitleaks + Trivy/SCA + supply-chain). Ele produz/atualiza `.dw/secure-audit/audit-summary.md`.
+   - Scan mais recente deve estar presente, fresco (pós-última-edição) e não REPROVADO. Se linguagem suportada e audit ausente OU REPROVADO → verdict do review **REPROVADO**. Findings SECRET sempre bloqueiam (sem escape de ADR).
+   - O mesmo gate também roda standalone (`/dw-secure-audit`) e é fase explícita no `/dw-autopilot`; `/dw-generate-pr` re-enforça o verdict antes do PR.
 
 ### Output
 

package/scaffold/pt-br/commands/dw-secure-audit.md

@@ -1,7 +1,13 @@
 <system_instructions>
-Você é o orquestrador de security audit. Roda OWASP static review + supply-chain CVE/secret/IaC scanning + outdated check + supply-chain compromise detection em uma passada. Hard-gates comandos downstream quando há findings CRITICAL ou HIGH.
+Você é o orquestrador de security audit — o **Security Gate**. Roda OWASP static review + SAST (Semgrep,
+focado no diff do código gerado) + secret scan dedicado (gitleaks) + supply-chain CVE/secret/IaC (Trivy +
+native lockfile audit) + supply-chain compromise detection + outdated check, em uma passada. Hard-gates
+comandos downstream quando há qualquer finding bloqueante.
 
-Auto-invocado por `/dw-review` e `/dw-generate-pr` em projetos TS/Python/C#/Rust. Invocação standalone disponível pra audit manual.
+É **auto-invocado por `/dw-review` e `/dw-generate-pr`** (em TS/Python/C#/Rust), roda como **fase explícita e
+nomeada no `/dw-autopilot`** (após review + QA, antes de commit/PR), e é **executável standalone** a qualquer
+momento. O `/dw-generate-pr` re-enforça o verdict como hard gate final. Os três continuam gating em segurança
+— o comando standalone e a fase nomeada são aditivos, não substituem.
 
 ## Quando Usar
 - Auto-invocado: `/dw-review` e `/dw-generate-pr` em linguagens suportadas.
@@ -10,7 +16,7 @@ Auto-invocado por `/dw-review` e `/dw-generate-pr` em projetos TS/Python/C#/Rust
 - NÃO use como substituto pra review humano em código auth/payment de alto risco (use skill `security-review` JUNTO com este).
 
 ## Posição no Pipeline
-**Antecessor:** qualquer momento; auto-invocado por `/dw-review`, `/dw-generate-pr` | **Sucessor:** `/dw-bugfix` pra atacar findings, ou `/dw-commit` se APROVADO
+**Antecessor:** `/dw-review` + `/dw-qa` (o Security Gate roda depois deles passarem) | **Sucessor:** `/dw-commit` / `/dw-generate-pr` se APROVADO, ou `/dw-bugfix` pra atacar findings. Também roda standalone a qualquer momento.
 
 ## Modos
 
@@ -33,10 +39,20 @@ Auto-invocado por `/dw-review` e `/dw-generate-pr` em projetos TS/Python/C#/Rust
 
 ## Dependências Necessárias
 
-- **Trivy** — deve estar instalado (via `npx @brunosps00/dev-workflow install-deps`).
+- **Trivy** — SCA / secrets / IaC (via `npx @brunosps00/dev-workflow install-deps`).
+- **Semgrep** — camada SAST (opcional mas recomendado). Se ausente, a camada SAST é pulada e anotada.
+- **gitleaks** — secret scan dedicado (opcional mas recomendado). Se ausente, cai pro Trivy secrets.
 - **Context7 MCP** — pra best practices específicas de versão.
 
-## Três Camadas de Detecção
+Todos os scanners são opcionais individualmente: uma tool ausente degrada aquela camada e é **reportada**
+no summary (o gate nunca quebra por falta de scanner), mas a cobertura faltante fica visível. Instale via
+`npx @brunosps00/dev-workflow install-deps`.
+
+## Camadas de Detecção
+
+**Foco no diff (código gerado):** camadas que suportam isso focam no diff contra a base do PR
+(`git merge-base HEAD origin/main`), concentrando o gate no código recém-escrito, sem ruído do código
+pré-existente. Um pass periódico `--full` varre a árvore inteira.
 
 ### Camada 1: OWASP Static Review (via skill `security-review`)
 
@@ -72,6 +88,23 @@ Cruza dependency tree contra:
 
 Output: `.dw/secure-audit/compromise-findings.md` por pacote afetado: COMPROMISED / suspicious / clean.
 
+### Camada 4: SAST — Semgrep (análise semântica do código gerado)
+
+Análise estática semântica e determinística do **diff** (`--baseline-commit`), complementando a Camada 1.
+Rulesets fixados: `p/security-audit`, `p/owasp-top-ten`, `p/secrets` (+ packs de linguagem detectados).
+Mapeie Semgrep `ERROR`→HIGH (ou CRITICAL pra CWEs RCE/authn-bypass/SQLi), `WARNING`→MEDIUM, `INFO`→LOW.
+Aplique a disciplina **fp-check** (reachability) antes de um finding bloquear (ver `security-review/references/sast.md`).
+
+Output: `.dw/secure-audit/sast-findings.md`. Se `semgrep` ausente: pulado + anotado no summary.
+
+### Camada 5: Secret scan dedicado — gitleaks
+
+`gitleaks protect --staged` (não-commitado) ou `gitleaks detect --log-opts <base>..HEAD` (branch), `--redact`.
+Autoritativo no diff; complementa Trivy secrets (dedupe por `file:line`). **Qualquer hit = REPROVADO, sem
+exceção de ADR** — secrets são removidos e rotacionados, não justificados. Ver `security-review/references/secrets.md`.
+
+Output: `.dw/secure-audit/secret-findings.md`. Se `gitleaks` ausente: cai pro Trivy secrets + anotado.
+
 ### Plus: outdated check
 
 `npm outdated` / `pip list --outdated` / `dotnet list outdated` / `cargo outdated` pra identificar pacotes atrás em minor ou major.
@@ -84,9 +117,11 @@ Todos os findings são classificados num desses tiers em `.dw/secure-audit/audit
 
 | Tier | Critério | Bloqueia | Ação Sugerida |
 |------|----------|----------|---------------|
+| **SECRET** | Credencial/chave/token hardcoded (gitleaks ou Trivy), sobrevive ao allowlist | SIM — **sem exceção de ADR** | Remover do código + histórico, rotacionar, mover pra secret store |
 | **COMPROMISED** | Pacote conhecido como malicioso nessa faixa de versão | SIM | Remover imediato / pin pra versão segura |
-| **CRITICAL** | CVE CVSS ≥9.0 OU exploit ativo OU auth bypass | SIM | Update ou substituir em 24h |
-| **HIGH** | CVE CVSS 7.0–8.9 OU exploitável no contexto atual | SIM | Update ou substituir em 1 semana |
+| **CRITICAL** | CVE CVSS ≥9.0 OU exploit ativo OU auth bypass; OU SAST de CWE alto-impacto (SQLi/RCE/authn-bypass/SSRF/deserialization) alcançável | SIM | Update/substituir ou corrigir em 24h |
+| **HIGH** | CVE CVSS 7.0–8.9 OU exploitável no contexto; OU Semgrep `ERROR` alcançável (fp-check passou) | SIM | Update/substituir ou corrigir em 1 semana |
+| **MEDIUM / LOW** | CVE CVSS <7.0; OU Semgrep `WARNING`/`INFO`; OU finding inalcançável rebaixado pelo fp-check | NÃO (advisory) | Rastrear e corrigir rotineiramente |
 | **OUTDATED-MAJOR** | ≥1 major version atrás (ex: React 17 → 19) | NÃO | Planejar migração próximo trimestre |
 | **OUTDATED-MINOR** | Minor/patch atrás | NÃO | Update rotineiro |
 | **CLEAN** | Sem findings | NÃO | — |
@@ -94,19 +129,26 @@ Todos os findings são classificados num desses tiers em `.dw/secure-audit/audit
 ## Hard Gates
 
 Verdict é um de:
-- **APROVADO** — sem CRITICAL, HIGH ou COMPROMISED. Arquivo verdict `.dw/secure-audit/audit-summary.md` status: APROVADO.
-- **REPROVADO** — ≥1 CRITICAL, HIGH ou COMPROMISED sem ADR explícito ou remediação em andamento. Status: REPROVADO.
+- **APROVADO** — sem SECRET, COMPROMISED, CRITICAL ou HIGH. Arquivo verdict `.dw/secure-audit/audit-summary.md` status: APROVADO. (MEDIUM/LOW/outdated podem aparecer como advisory.)
+- **REPROVADO** — ≥1 SECRET (sempre), ou ≥1 COMPROMISED/CRITICAL/HIGH sem ADR explícito ou remediação em andamento. Status: REPROVADO.
+
+**Limiar Rigoroso:** SECRET e COMPROMISED sempre bloqueiam. CRITICAL/HIGH (CVE ou SAST alcançável) bloqueiam salvo ADR justificando aceitação. MEDIUM/LOW e outdated são advisory. SECRET é o único tier **sem escape via ADR** — rotacione, não justifique.
 
 **`/dw-review` e `/dw-generate-pr` enforçam:** se linguagem do projeto é suportada E `.dw/secure-audit/audit-summary.md` mais recente está faltando OU REPROVADO, esses comandos retornam REPROVADO. Sem exceção. Sem flag bypass.
 
 ## Modo 1: Default (`/dw-secure-audit`)
 
 1. **Detectar stack**: checar package.json / requirements.txt / *.csproj / Cargo.toml.
-2. **Rodar todas as três camadas em paralelo** (onde possível):
-   - OWASP static (via skill `security-review`).
+2. **Rodar todas as camadas de detecção em paralelo** (onde possível):
+   - OWASP static (via skill `security-review`) — focado no diff.
+   - SAST — Semgrep no diff (`--baseline-commit`).
+   - Secret scan dedicado — gitleaks no diff.
    - Trivy + lockfile audit.
    - Supply-chain compromise check.
 3. **Rodar outdated check.**
+   **fp-check:** antes de finalizar, rode validação de reachability em cada finding SAST/OWASP bloqueante
+   (ver `security-review` SKILL.md); rebaixe os comprovadamente inalcançáveis pra advisory com razão logada.
+   Secrets são isentos de rebaixamento.
 4. **Agregar findings** por tier.
 5. **Escrever summary** em `.dw/secure-audit/audit-summary.md`:
 
@@ -118,14 +160,26 @@ Verdict é um de:
 ## Resumo por Tier
 | Tier | Contagem | Detalhe |
 |------|----------|---------|
+| SECRET | N | <lista> |
 | COMPROMISED | N | <lista> |
 | CRITICAL | N | <lista> |
 | HIGH | N | <lista> |
+| MEDIUM/LOW (advisory) | N | <lista> |
 | OUTDATED-MAJOR | N | <lista> |
 | OUTDATED-MINOR | N | <lista> |
 
+## Scanners
+| Camada | Tool | Status |
+|--------|------|--------|
+| OWASP | security-review | rodou |
+| SAST | semgrep | rodou / pulado (não instalado) |
+| Secrets | gitleaks | rodou / fallback trivy (não instalado) |
+| SCA/IaC | trivy | rodou |
+
 ## Relatórios das camadas
 - OWASP: `owasp-findings.md`
+- SAST: `sast-findings.md`
+- Secrets: `secret-findings.md`
 - Trivy: `trivy-findings.md`
 - Lockfile: `lockfile-findings.md`
 - Compromise: `compromise-findings.md`
@@ -164,7 +218,7 @@ Pra cada remediação aprovada:
 ## Modo 4: CI (`/dw-secure-audit --scan-only`)
 
 Output mínimo:
-- Roda todas as três camadas.
+- Roda todas as camadas de detecção.
 - Escreve findings em disco.
 - Exit code 0 se APROVADO, 1 se REPROVADO.
 - Sem planejamento.
@@ -182,8 +236,9 @@ Pra gates pre-merge em CI.
 ## Constitution Gate
 
 <critical>
-- CRITICAL ou COMPROMISED finding sem ADR justificando aceitação explícita → verdict não pode ser APROVADO.
-- Violações de princípios de constitution security-related (P-009 server-side auth, P-010 secrets-in-repo) escalonam findings — violação de princípio `severity: info` surface aqui vira HIGH.
+- Finding SECRET → verdict NUNCA pode ser APROVADO (sem escape via ADR). Rotacione e remova.
+- Finding CRITICAL/HIGH/COMPROMISED (CVE ou SAST alcançável) sem ADR justificando aceitação explícita → verdict não pode ser APROVADO.
+- Violações de princípios de constitution security-related (P-009 server-side auth, P-010 secrets-in-repo, P-011 sem SAST high-severity) escalonam findings — violação de princípio `severity: info` surface aqui vira HIGH.
 </critical>
 
 ## Anti-patterns
@@ -198,8 +253,10 @@ Pra gates pre-merge em CI.
 
 ```
 .dw/secure-audit/
-├── audit-summary.md           # verdict + resumo de tiers
+├── audit-summary.md           # verdict + resumo de tiers + status dos scanners
 ├── owasp-findings.md          # Camada 1
+├── sast-findings.md           # Camada 4 (Semgrep)
+├── secret-findings.md         # Camada 5 (gitleaks, redacted)
 ├── trivy-findings.md          # Camada 2 (SCA + secrets + IaC)
 ├── lockfile-findings.md       # Camada 2 (native auditor)
 ├── compromise-findings.md     # Camada 3

package/scaffold/pt-br/templates/constitution-template.md

@@ -80,12 +80,17 @@ mode: defaults | custom
 **P-009 — Authorization server-side em todo endpoint que altera estado** (severity: info)
 **Regra:** Endpoint que cria, atualiza ou deleta dado deve verificar autorização do caller no servidor. Gating em UI (botões escondidos, formulários disabled) não é segurança.
 **Why:** Browsers são untrusted (ver `dw-testing-discipline/references/security-boundary.md`). Gating em UI é conveniência; só checks server-side protegem dado.
-**Enforcement:** `dw-code-review` e `dw-security-check` exigem check de auth explícito (decorator, middleware ou assertion in-handler) em rotas POST/PUT/PATCH/DELETE.
+**Enforcement:** `dw-review` e o Security Gate `dw-secure-audit` exigem check de auth explícito (decorator, middleware ou assertion in-handler) em rotas POST/PUT/PATCH/DELETE.
 
-**P-010 — Secrets nunca entram no repositório** (severity: info)
+**P-010 — Secrets nunca entram no repositório** (severity: high)
 **Regra:** Nenhuma API key, password, signing key, token ou endpoint de produção commitado em source. `.env.example` documenta forma apenas.
 **Why:** Histórico de repositório é permanente. Um secret commitado uma vez está vazado mesmo que revertido no commit seguinte.
-**Enforcement:** `dw-security-check` roda Trivy + secret scanners no diff.
+**Enforcement:** o Security Gate `dw-secure-audit` roda gitleaks + Trivy no diff. Qualquer hit bloqueia — **sem exceção de ADR** (rotacione, não justifique).
+
+**P-011 — Nenhum finding SAST high-severity passa sem revisão** (severity: high)
+**Regra:** Código gerado/alterado deve passar na camada SAST (Semgrep) do Security Gate. Um finding high-severity alcançável (SQLi, command/code injection, SSRF, deserialization insegura, authn bypass) bloqueia salvo ADR justificando aceitação.
+**Why:** Código gerado por IA reproduz padrões inseguros em escala; SAST determinístico no diff pega o que o review por leitura perde.
+**Enforcement:** `dw-secure-audit` roda Semgrep no diff (`--baseline-commit`); findings sobrevivem a uma validação fp-check de reachability antes de bloquear.
 
 ---
 

package/scaffold/pt-br/templates/functional-doc/playwright.flow.mjs.tpl

@@ -0,0 +1,17 @@
+// Módulo de fluxo do functional-doc. Executado por .dw/scripts/functional-doc/run-playwright-flow.mjs
+// através da API Node do Playwright, para que o vídeo seja gravado com page.screencast (funciona tanto
+// com browser lançado quanto via connectOverCDP). Não precisa de imports aqui — o runner injeta
+// page, context, expect, baseURL e os helpers step()/shot().
+
+export default async function flow({ page, expect, baseURL, step, shot }) {
+  await step("Abrir rota alvo", async () => {
+    await page.goto(`${baseURL}{{routePath}}`);
+    await expect(page).toHaveURL(new RegExp("{{routeRegex}}"));
+  });
+
+{{testSteps}}
+
+  await step("Registrar contexto final", async () => {
+    await expect(page.locator("body")).toBeVisible();
+  });
+}

package/scaffold/scripts/cdp-relay/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "cdp-relay"
+version = "0.1.0"
+edition = "2021"
+description = "Tiny TCP forwarder so WSL can reach a Windows browser's CDP debug port in NAT mode. Built on Windows by dev-workflow; no runtime dependency."
+
+[[bin]]
+name = "cdp-relay"
+path = "src/main.rs"
+
+[profile.release]
+opt-level = "z"
+lto = true
+strip = true
+panic = "abort"
+codegen-units = 1