wize-dev-kit 0.16.0 → 0.17.0

package/src/security-overlay/skills/wize-sec-scope/scripts/generate-scope.js

@@ -0,0 +1,106 @@
+'use strict';
+
+// generate-scope.js — creates a valid .wize/security/scope.md from CLI args.
+// Zero-dep. Computes scope_sha256 from the body (including the leading newline
+// separator, matching parseScope's convention).
+
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+
+function parseArgv(argv) {
+  const out = { url: null, hosts: [], paths: [], acceptedBy: null, outPath: null };
+  for (let i = 0; i < (argv || []).length; i++) {
+    const a = argv[i];
+    if (a === '--url' && argv[i + 1]) { out.url = argv[i + 1]; i++; }
+    else if (a.startsWith('--url=')) out.url = a.slice('--url='.length);
+    else if (a === '--hosts' && argv[i + 1]) { out.hosts = argv[i + 1].split(',').map(s => s.trim()).filter(Boolean); i++; }
+    else if (a.startsWith('--hosts=')) out.hosts = a.slice('--hosts='.length).split(',').map(s => s.trim()).filter(Boolean);
+    else if (a === '--paths' && argv[i + 1]) { out.paths = argv[i + 1].split(',').map(s => s.trim()).filter(Boolean); i++; }
+    else if (a.startsWith('--paths=')) out.paths = a.slice('--paths='.length).split(',').map(s => s.trim()).filter(Boolean);
+    else if (a === '--accepted-by' && argv[i + 1]) { out.acceptedBy = argv[i + 1]; i++; }
+    else if (a.startsWith('--accepted-by=')) out.acceptedBy = a.slice('--accepted-by='.length);
+    else if (a === '--out' && argv[i + 1]) { out.outPath = argv[i + 1]; i++; }
+    else if (a.startsWith('--out=')) out.outPath = a.slice('--out='.length);
+  }
+  if (!out.outPath) out.outPath = path.join(process.cwd(), '.wize', 'security', 'scope.md');
+  return out;
+}
+
+function buildBody({ url, hosts, paths }) {
+  const lines = [];
+
+  lines.push('## allowlist');
+
+  lines.push('hosts:');
+  for (const h of hosts) lines.push(`  - ${h}`);
+
+  lines.push('urls:');
+  if (url) lines.push(`  - ${url.replace(/\/+$/, '')}/`);
+
+  lines.push('paths:');
+  if (paths.length > 0) {
+    for (const p of paths) lines.push(`  - ${p}`);
+  } else {
+    lines.push('  - /');
+  }
+
+  lines.push('');
+  lines.push('## dast_target');
+  if (url) lines.push(`url: ${url}`);
+  lines.push('');
+  lines.push('## notes');
+  lines.push(`Scope gerado por wize-sec-scope em ${new Date().toISOString()}.`);
+  lines.push('');
+
+  return lines.join('\n');
+}
+
+function generateScope({ url, hosts, paths, acceptedBy, outPath }) {
+  const body = buildBody({ url, hosts, paths });
+
+  // The hash is computed on the body as parseScope returns it: with the
+  // leading newline separator between the closing --- and the body.
+  const signedBody = '\n' + body;
+  const scopeSha256 = crypto.createHash('sha256').update(signedBody, 'utf8').digest('hex');
+  const acceptedAt = new Date().toISOString();
+
+  const fm = [
+    `accepted_by: ${acceptedBy || 'unknown'}`,
+    `accepted_at: ${acceptedAt}`,
+    `scope_sha256: ${scopeSha256}`
+  ].join('\n');
+
+  const content = `---\n${fm}\n---\n${signedBody}`;
+
+  const dir = path.dirname(outPath);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(outPath, content, 'utf8');
+
+  return { path: outPath, sha256: scopeSha256, acceptedBy, acceptedAt };
+}
+
+function main() {
+  const args = parseArgv(process.argv.slice(2));
+
+  if (!args.url) {
+    console.error('✖ --url é obrigatório (ex: --url=http://localhost:8080)');
+    process.exit(2);
+  }
+  if (!args.acceptedBy) {
+    console.error('✖ --accepted-by é obrigatório (ex: --accepted-by="Seu Nome")');
+    process.exit(2);
+  }
+
+  const result = generateScope(args);
+  console.log(`✓ scope.md gerado em ${result.path}`);
+  console.log(`  SHA-256: ${result.sha256}`);
+  console.log(`  aceite por: ${result.acceptedBy}`);
+  console.log(`  aceite em: ${result.acceptedAt}`);
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = { generateScope, buildBody, parseArgv };

package/src/security-overlay/skills/wize-sec-scope/skill.md

@@ -0,0 +1,52 @@
+---
+
+code: wize-sec-scope
+description: "Use para criar ou re-assinar o scope.md de segurança. Guia o usuário com perguntas e gera o arquivo com hash SHA-256."
+name: wize-sec-scope
+overlay: security
+module: security-overlay
+owner: wize-sec-red-teamer  # Natasha Romanoff
+status: ready
+---
+
+# wize-sec-scope — Criação guiada de scope.md
+
+Cria o arquivo `.wize/security/scope.md` a partir de perguntas interativas. Gera o frontmatter com `accepted_by`, `accepted_at`, e `scope_sha256` (SHA-256 do corpo). O arquivo gerado passa na validação do `loadScope()` sem intervenção manual.
+
+## Uso
+
+```bash
+/wize-sec-scope
+```
+
+## Fluxo guiado
+
+O agente faz uma pergunta por vez:
+
+1. **URL base do alvo** — ex: `http://localhost:8080`
+2. **Hosts adicionais no escopo** — um por linha, Enter para pular
+3. **Paths no escopo** — ex: `/api/*`, Enter para todos (`/`)
+4. **Nome para o aceite** — quem está autorizando o pentest
+
+Ao final, gera `scope.md` com:
+
+- Frontmatter: `accepted_by`, `accepted_at` (ISO-8601), `scope_sha256`
+- Corpo: `## allowlist` com hosts, urls e paths
+- `## dast_target` com a URL base
+- `## notes` com o timestamp de criação
+
+## Re-assinatura
+
+Se o `scope.md` já existe e foi editado, use `--sign-scope` para recomputar o hash:
+
+```bash
+/wize-sec-pentest --sign-scope
+```
+
+## Script
+
+`scripts/generate-scope.js` — gera o arquivo programaticamente (usado pelo agente ou chamado diretamente).
+
+```bash
+node scripts/generate-scope.js --url=http://localhost:8080 --hosts=localhost,127.0.0.1 --paths=/api,/admin --accepted-by="Seu Nome"
+```

package/src/tea-skills/wize-qa-generate-e2e-tests/workflow.md

@@ -0,0 +1,121 @@
+---
+
+code: wize-qa-generate-e2e-tests
+description: "Use quando o UX design e PRD estiverem validados e precisar gerar casos de teste E2E a partir das telas e ACs."
+name: Generate E2E Tests
+owner: wize-agent-test-architect   # Hawkeye
+status: ready
+---
+
+# Generate E2E Tests
+
+**Goal.** Translate UX screens + PRD ACs into concrete E2E test cases. Hawkeye produces the cases (names, steps, selectors, expected outcome); the user (or Shuri) writes the actual test bodies in the chosen framework.
+
+Hawkeye drives. Mantis confirms UX fidelity. Shuri confirms selectors match the design system.
+
+## When to run
+
+- After `wize-ux-design` and `wize-create-prd` are validated.
+- Before a story enters `in-progress` if the ACs are E2E-heavy.
+- When the team adopts a new E2E framework and needs a baseline.
+
+## When NOT to run
+
+- Before UX design is ready (no screens = no cases).
+- For unit tests (covered by `wize-tea-design`).
+- For visual / a11y (separate audit, out of scope here).
+
+## Inputs
+
+- `.wize/planning/ux/ux-design/{screen}.md` — page specs.
+- `.wize/planning/prd.md` — ACs.
+- `.wize/solutioning/design-system/` — component + testid names.
+- The active profile (web-overlay → Playwright; app-overlay → Detox; core-only → propose and let user pick).
+
+## Output
+
+- `.wize/implementation/tea/e2e-cases/{screen}.md` — one file per screen with the test cases.
+
+## Steps
+
+### 1. Map (UX screen → ACs)
+
+For each screen, list the ACs that touch it. Cross-reference the PRD. If a screen has no ACs, flag it (gap).
+
+### 2. Cases (3-10 per screen)
+
+For each screen, generate 3-10 cases. For each case:
+- **Name:** verb-led, in 1 line.
+- **Pre-conditions:** setup (logged in, on screen X, etc.).
+- **Steps:** numbered, observable actions.
+- **Selectors:** `data-testid` values from the design system. If none exist, propose new ones.
+- **Expected outcome:** what the test asserts.
+- **Priority:** P0 (must pass before release) / P1 (should pass) / P2 (nice to have).
+
+### 3. Selectors
+
+Derive selectors from `design-system/` tokens + story notes. If a story has a `data-testid` map, prefer that. New selectors go into a "proposed testids" section; Mantis signs off in the next design-system sync.
+
+### 4. Triage
+
+Mark each case P0/P1/P2. P0 is the minimum viable E2E coverage. P1 expands happy paths. P2 covers edge cases.
+
+### 5. Hand off
+
+Notify the next workflow:
+- Shuri → implement the P0 cases first.
+- Mantis → sign off on the new testids.
+- The user → confirm the framework choice if it is ambiguous.
+
+## Output template
+
+```markdown
+---
+screen: sign-in
+generated: 2026-06-16
+linked_acs: [AC-01-1, AC-01-2]
+framework: playwright
+---
+
+# E2E cases — sign-in
+
+## Map
+- AC-01-1: user enters valid email + password
+- AC-01-2: user enters invalid email → error message
+
+## Cases
+
+### P0 — happy path
+- **Name:** Sign in with valid credentials
+- **Pre-conditions:** not signed in; on /signin
+- **Steps:** enter email; enter password; click "Sign in"
+- **Selectors:** data-testid="email-input", data-testid="password-input", data-testid="signin-cta"
+- **Expected outcome:** redirect to /dashboard; token in localStorage
+
+### P0 — invalid email
+- **Name:** Sign in with invalid email
+- **Pre-conditions:** not signed in; on /signin
+- **Steps:** enter "not-an-email"; enter password; click "Sign in"
+- **Selectors:** data-testid="email-input", data-testid="email-error"
+- **Expected outcome:** error text appears within 200ms; no redirect
+
+## Proposed testids
+- (none — using existing design system)
+
+## Triage summary
+- P0: 2
+- P1: 0
+- P2: 0
+```
+
+## Anti-patterns Hawkeye rejects
+
+- Generating 50 cases per screen. (Cap at 10; surface the rest as out-of-scope.)
+- Skipping the priority. (P0 is the contract; the rest is optional.)
+- Inventing selectors not present in the design system. (Propose them, but flag for Mantis.)
+- Auto-writing Playwright code. (Hawkeye proposes cases; the human writes the bodies.)
+- Skipping the screen-to-AC mapping. (Coverage gap = bug.)
+
+## Hand-off
+
+> "E2E cases generated for {N} screens. {N0} P0, {N1} P1, {N2} P2. Files at `.wize/implementation/tea/e2e-cases/`. Next: implement P0 (Shuri), sign off new testids (Mantis)."

package/src/tea-skills/wize-tea-design/workflow.md

@@ -1,38 +1,132 @@
 ---
+
 code: wize-tea-design
+description: "Use quando uma story entrar em desenvolvimento e precisar do contrato de testes (split, fixtures, mocks, assertions) que a Shuri implementará."
 name: TEA Test Design
+phase: 4-implementation
 gate: design
 owner: wize-agent-test-architect   # Hawkeye
 when: per-story-start
-status: stub
+status: ready
 ---
 
 # TEA — Test Design
 
-**Goal.** For one story: declare the test split (unit / integration / e2e), required fixtures, mocks, environments.
+**Goal.** For **one story**: declare the test split, the fixtures, the mocks, the environments, and the assertion targets. This is Hawkeye's contract Shuri implements against. No story enters dev without one.
+
+Hawkeye drives. Runs at the start of every story (advisory; can be relaxed only when `tea.toml` says so).
 
 ## Inputs
+
 - `.wize/solutioning/stories/{epic}/{story}.md`
 - `.wize/solutioning/architecture.md`
+- `.wize/implementation/tea/risk-profile.md`
+- Overlay test playbooks if active:
+  - `web-overlay/playbooks/playwright-vitest.md`
+  - `app-overlay/playbooks/detox-maestro.md`
 
 ## Output
+
 - `.wize/implementation/tea/{epic}/{story}/design.md`
 
-## YAML frontmatter
+## Steps
+
+### 1. Read the story; map every AC
+
+For each AC, write **one assertion-shape sentence**: *"There will be a {kind} test that does {what} and expects {observable}."*
+
+### 2. Pick the test split
+
+Defaults (from `playwright-vitest.md` / `detox-maestro.md`):
+- **Low-risk story:** 70% unit / 20% integration / 10% E2E.
+- **Risk-profile flagged story (R-1..R-3):** add 1–2 dedicated E2E + integration for the risk area.
+- **UI-only story:** 60% unit / 30% component (Testing Library) / 10% E2E.
+- **Server-only story:** 80% unit / 20% integration; no E2E unless an upstream consumer story bundles it.
+
+### 3. Declare fixtures + mocks
+
+- Fixtures: known users, known DB rows, known files.
+- Mocks: external services at the network boundary (MSW). Don't mock the unit under test.
+
+### 4. Environment
+
+- Where it runs (local sim, headless emulator, real device farm).
+- Network conditions (offline / 3G slow / lossy WiFi).
+- OS / browser matrix (from `device-matrix.md` or playwright projects).
+
+### 5. Edge cases (cheap; pay back × 10)
+
+List 3–7 edge cases the ACs don't name but the user might hit:
+- Empty / max-length inputs.
+- IME / paste / autofill.
+- Offline mid-action.
+- Concurrent users on the same resource.
+- Time-zone / DST.
+- Localized number/currency.
+
+Each gets a test of its own (usually unit).
+
+### 6. Hand off
+
+Mark `status: ready-for-dev` in the design.md frontmatter. Shuri reads before starting.
+
+## YAML frontmatter (canonical)
+
 ```yaml
 ---
 gate: design
-story_id: …
-ac_ids: [AC-1, AC-2, …]
+story_id: E01-S03
+ac_ids: [AC-02-1, AC-02-2]
+status: PASS
+created_at: 2026-06-11T12:00:00Z
 test_split:
-  unit: count + brief description
-  integration: count + brief description
-  e2e: count + brief description
-fixtures: [...]
-mocks: [...]
-environment: dev|staging|isolated
+  unit: { count: 4, description: "validation, server-action contract, error mapper, mailer payload" }
+  integration: { count: 1, description: "server action calls mailer with right args, against MSW" }
+  e2e: { count: 1, description: "happy path; Playwright @chromium @ios" }
+fixtures:
+  - "new-admin user"
+  - "empty team"
+mocks:
+  - "Resend via MSW"
+  - "Auth session via fixture cookie"
+environment: "local + Playwright project chromium + ios"
+risk_links: [R-1]
+edges:
+  - "invalid email rules: blank, missing @, weird IME chars"
+  - "duplicate teammate email"
+  - "offline at submit time"
 ---
 ```
 
-## Body
-Plain-English rationale + edge-case list.
+## Body of `design.md`
+
+```markdown
+## Per-AC assertion shapes
+
+- **AC-02-1**: Vitest unit on `validateInviteEmail()` → returns `{ ok: true }` for `name+tag@example.com`. Vitest integration on `inviteTeammate()` server action → asserts `mailer.send` called once with `{ to: 'name@example.com', template: 'team-invite' }`. Playwright E2E → clicks "Send invite", asserts `[data-testid="invite-sent-banner"]` appears within 1s.
+
+- **AC-02-2**: Vitest unit on `validateInviteEmail()` → returns `{ ok: false, code: 'invalid_format', field: 'email' }` for empty/no-@. Component test (Testing Library) on `<InviteForm>` → asserts the input's `aria-describedby` error region announces "Enter a valid email."
+
+## Edge cases (additional tests)
+
+- E1: Empty email — `validateInviteEmail('')` → `invalid_format`.
+- E2: 254-char local part — boundary check; expect graceful clipping.
+- E3: Same email submitted twice — second call hits `inviteTeammate()`, asserts second insert is a no-op (idempotency key based on `(team_id, email)`).
+- E4: Offline at submit — Playwright `context.setOffline(true)` after click; banner shows "We'll retry when you're back online."
+
+## Run plan
+- On every PR: full unit + integration; E2E `@smoke` tag only (≤ 30s).
+- Nightly: full E2E suite + Lighthouse baseline.
+```
+
+## Anti-patterns Hawkeye rejects
+
+- **`design.md` written after dev started.** Then the story slipped through; flag.
+- **One test per AC, no edges.** Edges are where users live.
+- **Mocking the unit under test.** You'd be testing the mock.
+- **E2E that test the happy path only.** Cover failure too.
+- **Selectors by visible text in a multilingual app.** Use `data-testid` or `role` with locale-aware patterns.
+
+## Hand-off
+
+> Test design for E01-S03 at `.wize/implementation/tea/E01-S03/design.md`. 4 unit, 1 integration, 1 E2E, plus 4 edges. Shuri can start; I'll check `tea-trace.md` against this when the PR opens.

package/src/tea-skills/wize-tea-gate/workflow.md

@@ -1,51 +1,144 @@
 ---
+
 code: wize-tea-gate
+description: "Use quando uma story chegar ao final e precisar da decisão de gate (PASS/CONCERNS/FAIL/WAIVED) com rationale documentado."
 name: TEA Gate Decision
+phase: 4-implementation
 gate: gate
 owner: wize-agent-test-architect   # Hawkeye
 when: story-final
-status: stub
+status: ready
 ---
 
 # TEA — Gate Decision
 
-**Goal.** Final per-story gate. PASS / CONCERNS / FAIL / WAIVED with documented rationale.
+**Goal.** Final per-story decision. **PASS / CONCERNS / FAIL / WAIVED** with documented rationale, score, and policy mode. This is the line: a story doesn't advance past it without a recorded gate.
+
+Hawkeye drives. The four inputs (`design`, `trace`, `review`, plus `nfr` at epic boundary) feed in. Policy is read from `.wize/config/tea.toml`.
 
 ## Inputs
-- `design.md`, `trace.md`, `review.md` for the story
-- `nfr/{epic}.md` if applicable
-- Story file
+
+- `.wize/implementation/tea/{epic}/{story}/design.md`
+- `.wize/implementation/tea/{epic}/{story}/trace.md`
+- `.wize/implementation/tea/{epic}/{story}/review.md`
+- `.wize/implementation/tea/nfr/{epic}.md` (when the story is the last of its epic)
+- `.wize/config/tea.toml`
 
 ## Output
+
 - `.wize/implementation/tea/{epic}/{story}/gate.md`
 
+## Decision rules
+
+| Inputs | Recommendation |
+|---|---|
+| All ACs `met`, no findings | **PASS** |
+| All ACs `met`, only low/medium non-blocking findings | **PASS** with notes (or **CONCERNS** depending on count) |
+| Any AC `partial` | **CONCERNS** |
+| Any AC `not-met` | **FAIL** |
+| NFR `FAIL` on the epic (last story) | **FAIL** |
+| `tea-review` flagged `knowledge_axes_touched` ≠ `knowledge_axes_updated` (any axis touched without update) | **CONCERNS** (advisory mode) / **FAIL** (enforcing mode) — adds finding `KN-NN` |
+| Failing AC OR non-neg NFR with documented business rationale + senior signoff | **WAIVED** |
+
+Score (0–100): heuristic. `100 - (10 × high) - (5 × medium) - (2 × low)`. Floor 0.
+
+## Policy
+
+`.wize/config/tea.toml` sets `policy = "advisory"` (default) or `"enforcing"`.
+
+- **Advisory:** `FAIL` is a visible warning in PR; merge isn't auto-blocked. The team decides.
+- **Enforcing:** `FAIL` blocks merge via CI status check (`tea-gate`). PASS / CONCERNS allowed through.
+
+## Steps
+
+### 1. Read the three inputs
+
+If trace shows `partial`, you know the recommendation. If review recommends FAIL, you've got your decision. The gate doc just records it.
+
+### 2. Compute score
+
+Don't game it. The score communicates magnitude to humans skimming a backlog.
+
+### 3. Write the doc
+
+Frontmatter is the structured truth. The body is the narrative for humans.
+
+### 4. Notify
+
+Update the PR description with the gate verdict + link to the doc. Maria Hill watches the gate status in `sprint-status.md`.
+
 ## YAML frontmatter (canonical)
+
 ```yaml
 ---
 gate: gate
-story_id: …
-status: PASS | CONCERNS | FAIL | WAIVED
-score: 0-100
-policy: advisory | enforcing
+story_id: E01-S03
+status: PASS
+score: 95
+policy: advisory
 inputs:
-  - design.md: …
-  - trace.md: …
-  - review.md: …
-  - nfr/{epic}.md: …
+  design: ".wize/implementation/tea/E01-S03/design.md"
+  trace:  ".wize/implementation/tea/E01-S03/trace.md"
+  review: ".wize/implementation/tea/E01-S03/review.md"
+  nfr:    null   # not the last story of E01
 findings:
-  - id: G-1
-    severity: low | medium | high
-    summary: …
-    recommendation: …
-waived_by: null | "wizer"
-waived_reason: null | "…"
-created_at: ISO-8601
+  - id: REV-01
+    severity: low
+    summary: "Empty-state copy slightly differs from Mantis' spec."
+    recommendation: "Update `<EmptyTeamPanel>` heading in a follow-up."
+  - id: KN-01
+    severity: medium
+    summary: "Story added a new component (`<InviteForm>`) but architecture-snapshot.md was not updated."
+    recommendation: "Add 2 lines to `.wize/knowledge/document-project/architecture-snapshot.md` under a dated bullet referencing the new component + its public testid contract."
+    owner: shuri
+    blocking: false   # advisory mode; would be true under enforcing
+waived_by: null
+waived_reason: null
+created_at: 2026-06-11T20:30:00Z
 ---
 ```
 
-## Body
-Narrative explanation; structured data is the YAML.
+## Body of `gate.md`
 
-## Policy
-- **advisory** (default): FAIL is a warning. Merge proceeds.
-- **enforcing**: FAIL blocks merge via CI. Configured in `.wize/config/tea.toml`.
+```markdown
+## Verdict
+**PASS** (score 95)
+
+## Why
+- All ACs met with observed evidence.
+- Trace clean; coverage 100% on ACs, partial on edges (E3, E4) — tracked for follow-up.
+- Review found one low-severity copy finding (REV-01).
+- Story is not the last in epic 01; NFR gate runs separately at epic boundary.
+
+## Notes for follow-up
+- Open a tiny story (or include in next sprint planning) to fix REV-01 and close edges E3, E4.
+
+## Trail
+- design.md → 4/1/1 split (unit/integration/e2e) + 4 edges declared.
+- trace.md → all ACs `covered`; E3 `partial`, E4 `missing` (follow-up).
+- review.md → ACs `met`, scope mostly disciplined, copy nit.
+- nfr.md → N/A (mid-epic).
+```
+
+## When to WAIVE
+
+Rare. Examples:
+- A failing E2E that depends on a flaky external sandbox; the production code is unaffected; sign-off by Tony + Hill.
+- A non-negotiable temporarily slipped because of an external integration blocker; we ship with mitigation in place; sign-off by Fury.
+
+A WAIVE always lists:
+- Who waived (`waived_by`).
+- Why (`waived_reason`).
+- The compensating control (a follow-up story, an SLA monitor, a feature flag).
+
+## Anti-patterns Hawkeye rejects
+
+- **Gating without `review.md`.** No review → no gate.
+- **PASS with a `not-met` AC.** Auto-fail.
+- **WAIVED with no `waived_by` field.** Reject.
+- **Scoring jiggered to clear a threshold.** Trust trumps point-scoring; if the count says 70, don't write 91.
+- **Enforcing mode gates without CI check wiring.** Ghost gate; remove or wire it.
+
+## Hand-off
+
+> Gate for E01-S03: **PASS** (score 95). One low-severity finding logged for follow-up. Maria Hill, sprint-status updated; Shuri, ready to start the next story.