wize-dev-kit 0.16.0 → 0.17.0

package/src/core-skills/wize-pre-pr-check/skill.md

@@ -0,0 +1,134 @@
+---
+code: wize-pre-pr-check
+name: wize-pre-pr-check
+module: core
+description: "Quando for abrir um Pull Request ou PR leia"
+---
+
+# Pre-PR Check
+
+**Goal.** Rodar os checks obrigatórios localmente antes de abrir um PR, falhando cedo e rápido. Evita ciclagem cara de CI no Actions — principalmente lint, format, build e testes rápidos. O objetivo é ser um portão (gate) antes de submeter código.
+
+**Agnóstica de tecnologia.** Não prescreve ferramentas específicas; lê os comandos disponíveis no repositório e executa o que for aplicável.
+
+## When to run
+
+- Imediatamente antes de `git push` para uma branch de PR.
+- Antes de abrir o PR no GitHub/GitLab.
+- Após `git commit` na branch de feature, como sanity check.
+- A qualquer momento durante o desenvolvimento — fail fast.
+
+## When NOT to run
+
+- Quando o CI já está verde e o PR está em revisão (o gate já passou).
+- Quando o repositório não tem scripts/ferramentas de lint/test configurados.
+
+## Operating contract
+
+- **Leia o projeto antes de rodar.** Procura por `package.json`, `composer.json`, `Makefile`, `justfile`, `pyproject.toml`, `Cargo.toml`, etc. para descobrir os comandos de check existentes.
+- **Só execute o que existir.** Se não houver `eslint`, pule o passo de lint. Se não houver `phpstan`, pule o passo de análise estática. Nunca exija uma ferramenta que não esteja configurada no repo.
+- **Pare no primeiro erro.** A menos que o usuário peça `--continue`, um check que falha interrompe a cadeia — corrija antes de continuar.
+- **Não seja um substituto completo do CI.** O CI continua sendo a fonte da verdade para testes de integração, e2e, banco de dados, Docker, etc. Este gate é para checks rápidos e baratos.
+- **Custo zero no Actions.** Tudo roda localmente.
+
+## Inputs
+
+- Estado atual do working tree (staged + unstaged).
+- Arquivos de config do projeto para descobrir comandos.
+
+## Outputs
+
+- Relatório compacto de quais checks passaram/falharam.
+- Se falhou: mensagem de erro + arquivo(s) sugerido(s) para corrigir.
+- Se passou: confirmação pronta para PR.
+
+## Steps
+
+### 1. Detectar stack
+
+Procurar nos arquivos de config do projeto quais ferramentas estão disponíveis:
+
+| Fonte | O que extrair |
+|-------|---------------|
+| `package.json` → `scripts` | `lint`, `format`, `format:check`, `type-check`, `build`, `test`, `test:unit` |
+| `composer.json` → `scripts` | `test`, `phpstan`, `pint`, `phpcs` |
+| `Makefile` / `justfile` | targets `lint`, `format`, `check`, `test` |
+| `pyproject.toml` / `setup.cfg` | `flake8`, `black`, `mypy`, `pytest` |
+| `Cargo.toml` | `cargo check`, `cargo test`, `cargo clippy`, `cargo fmt` |
+| `.github/workflows/*.yml` | steps de `lint`, `format`, `build`, `test` (como referência, não para rodar) |
+
+Heurística de prioridade: scripts do gerenciador de pacote local (`npm run`, `composer run`) > binários diretos (`vendor/bin/pint`) > comandos genéricos (`cargo clippy`).
+
+### 2. Selecionar checks por velocidade
+
+Separar em **rápido** (executa em segundos) e **lento** (minutos):
+
+**Rápido (executar sempre):**
+- Lint (ESLint, PHPStan, Clippy, Ruff, etc.)
+- Format check (Prettier, Pint, Black, rustfmt)
+- Type check (tsc, mypy)
+- Análise estática (PHPStan, Psalm)
+
+**Lento (executar quando houver mudanças relevantes):**
+- Build (Vite, Webpack, Cargo build)
+- Testes unitários (Vitest, Jest, Pest, pytest, `cargo test`)
+- Guard-rails custom (scripts próprios do projeto, ex: `check:orphans`)
+
+**Muito lento (opcional / em dia de merge):**
+- Testes de integração
+- E2E (Playwright, Cypress)
+- Build de Docker
+
+### 3. Rodar o gate
+
+Na ordem: format → lint → type-check → build → testes unitários → guard-rails.
+
+Comandos típicos por stack (detectados em tempo real, não hardcoded):
+
+| Stack | Comandos comuns |
+|-------|-----------------|
+| Node/JS/TS | `npm run format:check`, `npm run lint`, `npm run check:type` (ou `tsc --noEmit`), `npm run build`, `npm run test` |
+| PHP/Laravel | `vendor/bin/pint --test`, `vendor/bin/phpstan analyse`, `php artisan test` |
+| Python | `black --check`, `ruff check`, `mypy`, `pytest` |
+| Rust | `cargo fmt -- --check`, `cargo clippy`, `cargo check`, `cargo test` |
+| Go | `gofmt -l`, `golangci-lint run`, `go test ./...` |
+
+Se um check falhar, pare e reporte. Não prossiga para o próximo.
+
+### 4. Reportar
+
+Formato compacto, uma linha por check:
+
+```
+✓ format:check   (npm run format:check)     — 0.8s
+✓ lint           (vendor/bin/pint --test)   — 2.1s
+✗ phpstan        (vendor/bin/phpstan)       — 4.5s → FAIL
+  app/Http/Controllers/LegalController.php:11 — FQCN não importado
+→ Corrija antes de abrir o PR.
+```
+
+Se tudo passar:
+
+```
+✓ format:check   — PASS  (0.8s)
+✓ lint           — PASS  (2.1s)
+✓ phpstan        — PASS  (4.5s)
+✓ build          — PASS  (32s)
+✓ test:unit      — PASS  (30s)
+─────────────────────────────
+Gate limpo. Pode abrir o PR.
+```
+
+## Anti-patterns
+
+- **Rodar checks que não existem no repo.** Se não há `composer.json`, não tente `vendor/bin/pint`.
+- **Ignorar falhas de lint.** Lint fail = PR fail. Corrija antes.
+- **Executar E2E localmente toda vez.** E2E é caro; deixe para o CI ou rode antes de merge.
+- **Substituir o CI.** Este gate é complementar, não substituto.
+
+## Hand-off
+
+> Gate `wize-pre-pr-check` concluído. `{passados}/{total}` checks passaram. `{tempo_total}s`. Pronto para PR.
+
+Se houve falha:
+> Gate `wize-pre-pr-check` interrompido em `{check_falho}`. Corrija e re-execute antes de abrir o PR.

package/src/core-skills/wize-review-adversarial/skill.md

@@ -1,8 +1,11 @@
 ---
+
 code: wize-review-adversarial
+description: "Use quando um artefato (story, arquitetura, PRD) precisar de revisão adversarial — testar a ideia sob quatro personas hostis."
 name: Adversarial Review
 module: core
 status: stub
+subtask: true
 ---
 
 # Adversarial Review

package/src/core-skills/wize-review-edge-case-hunter/skill.md

@@ -0,0 +1,115 @@
+---
+
+code: wize-review-edge-case-hunter
+description: "Use quando um código ou PR precisar de caça sistemática de edge cases ranqueados por probabilidade × impacto."
+name: Edge Case Hunter
+module: core
+status: ready
+subtask: true
+---
+
+# Edge Case Hunter
+
+**Goal.** Focused edge-case pass on a code change. Returns a structured list of edge cases, ranked by likelihood × impact, with a hand-off to test or guard each one.
+
+Shuri runs the hunt. Hawkeye on call for test design. Wizer on call for cross-cutting risk.
+
+## When to use
+
+- "Hunt edge cases in this PR."
+- "What can break in this code?"
+- "Give me the edge case list before I refactor."
+
+## When NOT to use
+
+- Full adversarial code review → use `wize-code-review`.
+- Generate E2E test cases → use `wize-qa-generate-e2e-tests`.
+- Quick-dev fix → use `wize-quick-dev`.
+
+## Inputs
+
+- A code change (diff, file, or story reference).
+- A short scope statement (one sentence: what is this code trying to do?).
+- Optional: the relevant story file (`.wize/solutioning/stories/{epic}/{story}.md`).
+
+## Output
+
+- A markdown list of edge cases, grouped by category, with line-level `file:line` references when possible.
+- Suggested action per case: write a test, add a guard, accept, or defer.
+
+## Steps
+
+### 1. Scope
+
+Read the change + the one-line scope statement. Confirm the boundary: what is in scope (changed code) and what is not (existing dependencies, framework). Reject if the scope is too broad (> 500 LOC); suggest slicing first.
+
+### 2. Hunt (per area)
+
+Walk 4 areas in order:
+
+- **Input edges.** Empty, null, unicode, max length, malformed, wrong type, wrong encoding. Boundary values (0, 1, max, max+1).
+- **State edges.** Concurrent writes, stale reads, missing state, mixed state (some fields set, others not), partial failure.
+- **Time / race.** Timeouts, retries, clock skew, ordering, idempotency.
+- **Integration edges.** Vendor down, slow vendor, malformed vendor response, network partition, version skew.
+
+For each area, list specific cases in 1 line each. Cite `file:line` when relevant.
+
+### 3. Rank
+
+For each case, score:
+
+- **Likelihood** (low / medium / high): probability of triggering.
+- **Impact** (low / medium / high): what happens when it triggers.
+
+Order cases by `(likelihood + impact)`. The top 5 are P0; the rest P1/P2.
+
+### 4. Hand off
+
+For each P0 case, propose an action:
+
+- **Test** → the user adds a test.
+- **Guard** → the user adds input validation or a defensive check.
+- **Accept** → the user documents the risk and moves on.
+- **Defer** → the user opens a follow-up story.
+
+Output is a markdown table. The user picks what to apply.
+
+## Output template
+
+```markdown
+---
+date: 2026-06-17
+scope: "Refactor of validateInviteEmail — split into 3 helpers"
+author: Shuri
+---
+
+# Edge cases — {scope}
+
+## Top 5 (P0)
+
+| # | Case | Likelihood | Impact | Action | Location |
+|---|---|---|---|---|---|
+| 1 | Empty email string | high | medium | test | src/validate.ts:42 |
+| 2 | Email with leading/trailing whitespace | high | low | guard | src/validate.ts:55 |
+| 3 | Email with internationalized TLD (e.g. .中国) | medium | medium | test | src/validate.ts:48 |
+| 4 | Email longer than 254 chars | low | medium | guard | src/validate.ts:48 |
+| 5 | Null vs undefined | high | low | test | src/validate.ts:33 |
+
+## Other (P1/P2)
+
+- Unicode normalization mismatch — P1 — test
+- Two plus signs in local part — P2 — accept
+- Trailing dot in domain — P2 — defer (open E06-S05)
+```
+
+## Anti-patterns Shuri rejects
+
+- Listing 50 cases per area. (Top 5 P0; cap at 15 total.)
+- Auto-fixing (hunt, don't fix).
+- Skipping the rank step. (Without rank, the user cannot prioritize.)
+- Skipping the action per case. (An edge case without an action is just noise.)
+- Hunting only one area (e.g., only input). (All 4 areas.)
+
+## Hand-off
+
+> "Edge case hunt complete. {N} cases ranked. P0: {M}. Next: implement P0 (Shuri) or open follow-up stories (Hill)."

package/src/core-skills/wize-shard-doc/skill.md

@@ -1,5 +1,7 @@
 ---
+
 code: wize-shard-doc
+description: "Use quando um documento markdown grande (PRD, arquitetura) precisar ser dividido em shards endereçáveis por ID."
 name: Shard Doc
 module: core
 status: stub

package/src/core-skills/wize-spec/assets/headless-schemas.md

@@ -0,0 +1,39 @@
+# Headless response schemas for wize-spec
+
+Used when `wize-spec` is invoked non-interactively (headless).
+
+## Create / Update
+
+```json
+{
+  "error_code": null,
+  "spec_path": "{project-root}/.wize/specs/spec-{slug}/SPEC.md",
+  "slug": "{slug}",
+  "capabilities": ["CAP-1", "CAP-2"],
+  "companions": ["glossary.md"],
+  "assumptions": [],
+  "open_questions": [],
+  "verdict": "Coherence: pass. Preservation: pass."
+}
+```
+
+## Error codes
+
+- `missing_slug` — headless caller did not provide a slug and it could not be derived.
+- `insufficient_intent` — no input content provided.
+- `too_sparse` — input too thin to distill; suggest `wize-product-brief` or `wize-create-prd`.
+
+## Validate
+
+```json
+{
+  "error_code": null,
+  "violations": [
+    {
+      "rule": "4",
+      "message": "No explicit non-goals found."
+    }
+  ],
+  "verdict": "Coherence: 1 issue. Preservation: pass."
+}
+```

package/src/core-skills/wize-spec/assets/spec-template.md

@@ -0,0 +1,40 @@
+---
+slug: "{{slug}}"
+status: draft
+owner: "{{owner}}"
+companions: []
+sources: []
+assumptions: []
+open_questions: []
+---
+
+# SPEC — {{slug}}
+
+## Why
+
+{{One paragraph: what problem this thing exists to solve and for whom.}}
+
+## Capabilities
+
+| ID | Intent | Success |
+|---|---|---|
+| CAP-1 | {{what the system does for the user}} | {{observable outcome that proves it works}} |
+| CAP-2 | … | … |
+
+## Constraints
+
+- {{Constraint that bends a design decision.}}
+- …
+
+## Non-goals
+
+- {{Explicitly out of scope.}}
+- …
+
+## Success signal
+
+{{Concrete, testable or demonstrable signal that the spec is satisfied.}}
+
+## Decision log
+
+See `.decision-log.md`.

package/src/core-skills/wize-spec/customize.toml

@@ -0,0 +1,20 @@
+# Wize Dev Kit — overrides for the built-in skill "wize-spec".
+# DO NOT EDIT in the installed kit; copy to .wize/custom/skills/wize-spec/
+# for project-level overrides.
+
+[workflow]
+
+# Steps to run before standard activation (config load, greet).
+activation_steps_prepend = []
+
+# Steps to run after greet but before the workflow begins.
+activation_steps_append = []
+
+# Persistent facts the skill keeps in mind for the whole run.
+persistent_facts = [
+  "file:{project-root}/.wize/knowledge/document-project/conventions.md",
+]
+
+# Scalar executed when the spec is finalized and the decision-log verdict is written.
+# Override wins. Leave empty for no custom post-completion behavior.
+on_complete = ""

package/src/core-skills/wize-spec/skill.md

@@ -0,0 +1,112 @@
+---
+
+code: wize-spec
+description: "Use quando precisar destilar qualquer entrada de intenção (ideia, PRD, RFC, transcrição) em um contrato canônico SPEC.md para consumo downstream."
+name: Spec
+module: core
+status: ready
+---
+
+# Spec
+
+**Goal.** Distill any intent input into a canonical, preservation-validated machine contract for downstream Wize work.
+
+Takes any intent input — vague idea, brain dump, PRD, RFC, brief, Slack thread, customer email, meeting transcript, mockups, mixed multi-source — and produces `SPEC.md` carrying the five-field kernel (Why, Capabilities, Constraints, Non-goals, Success signal) plus companion files for load-bearing content that does not fit or would bloat the kernel.
+
+Peggy Carter edits prose; Tony, Maria Hill, and Shuri consume the spec downstream.
+
+## When to use
+
+- "Create a spec for this idea."
+- "Distill this PRD into a spec."
+- "Validate this spec."
+- "Update the spec."
+
+Multiple skills may call to update the same spec over time.
+
+## Workspace
+
+The spec is **always a folder** named `{output_folder}/specs/spec-{slug}/`.
+
+`{slug}` describes the thing being specced, not the input shape:
+
+- Source artifact already carries a slug (e.g., `prd-foo-bar-2026-05-23/`): inherit (`foo-bar`).
+- Sparse, in-chat, or multi-source input: ask interactively. Headless callers must provide it.
+- Same slug = same folder. A second invocation updates in place, preserving capability IDs.
+
+Inside the spec folder:
+
+```
+<spec-folder>/
+  SPEC.md                  ← uppercase, the kernel
+  <companion-1>.md         ← optional, content-typed
+  <companion-2>.md
+  .decision-log.md         ← canonical memory for this spec
+```
+
+## The Operation
+
+1. Read the input and its ancillary linked materials. If no input, ask or block.
+2. If a prior `SPEC.md` exists at the target folder, read it — the operation becomes an **update**. Preserve capability IDs; new capabilities get the next unused `CAP-N`; never reuse retired IDs.
+3. When input is structured and pre-sorted (PRD with addendum, brief from Pepper, UX spec from Mantis), trust the authored separation.
+4. When input is mixed (brain dump, transcript, email), sort claims using the three-lens load-bearing test and route to the kernel field or a companion.
+5. Distill into the five-field kernel using `assets/spec-template.md`. When input is rich, extract directly. When input is sparse, choose:
+   - **express** — best-effort distill, every gap becomes an `open_questions[]` entry
+   - **guided** — walk the five fields with the user one at a time, `wize-grill` style: one question per turn, recommendation attached
+6. Write lean: every sentence must earn its place.
+7. If input is genuinely too thin (e.g. "an app for hikers" with no context), stop and suggest `wize-product-brief` or `wize-create-prd`.
+
+## Load-bearing
+
+A claim is **load-bearing** if any downstream consumer (skill, implementing agent, verification pass) would change a decision without it.
+
+## Companions
+
+When load-bearing content does not fit the five-field kernel, it lives in a companion. The kernel cites it; the companion holds it. Companions are part of the contract; every consumer reads `companions:` in `SPEC.md` frontmatter to discover them.
+
+**Spawn a companion when the content needs more than one kernel-shape line:** multi-item catalogs (archetypes, modes, routes, entity matrices), tables, diagrams (always), editorial voice rules, long-form reference material the kernel cites by name.
+
+Companions are either:
+
+- **Spec-authored** — written by `wize-spec` and live as siblings of `SPEC.md` (e.g., `glossary.md`, `patron-archetypes.md`, `stack.md`, `conventions.md`, `brownfield.md`, `architecture-diagrams.md`, `state-machines.md`, `failure-modes.md`).
+- **Adopted** — load-bearing artifacts written by upstream skills that downstream still needs to read (e.g., a `DESIGN.md` from Mantis, an API spec from a partner). The originating skill owns them; `wize-spec` references them in `companions:` but does not edit them.
+
+Two rules govern companions:
+
+1. Name spec-authored companions for the content type they hold.
+2. Diagrams always land in a companion, regardless of size. Mermaid/ASCII/image references live there; `SPEC.md` holds prose only.
+
+Pre-existing project-wide docs (e.g., `.wize/knowledge/document-project/conventions.md`) that downstream needs are listed as **adopted companions**, never duplicated.
+
+## Spec Law
+
+1. Each capability has both `intent` and `success`.
+2. Intents describe WHAT, not HOW.
+3. Constraints actually bend design decisions.
+4. Non-goals are explicit — at least one.
+5. Success signal is concrete enough to test or demonstrate against.
+6. Capability IDs are stable and unique — never reused, never renumbered.
+7. Preservation — every load-bearing source claim lands in `SPEC.md` or a companion.
+8. Lean prose — every sentence carries load-bearing content.
+
+## Self-Validate
+
+After every create or update, sweep the artifact in two passes:
+
+- **Pass 1 — Coherence.** Judge against Spec Law rules 1–6 and 8. Calls made without direct confirmation become `assumptions[]`; gaps become `open_questions[]`.
+- **Pass 2 — Preservation.** Walk source claims; confirm each landed in `SPEC.md` or a companion. Wrapper-only drops are logged under "Wrapper-only content" so the drop is on the record.
+
+Append a one-paragraph verdict to `.decision-log.md`.
+
+## Output
+
+- **Interactive** — share the spec folder path, name capability count, companions produced, and verdict in one or two sentences. List `assumptions[]` and `open_questions[]` if non-empty.
+- **Headless** — return JSON per `assets/headless-schemas.md`.
+
+## After the spec is output
+
+Any update to assumptions, open questions, or other changes is appended to `.decision-log.md` and, when applicable, to the source artifact's decision log.
+
+## Hand-off
+
+> Spec `{slug}` distilled into `{output_folder}/specs/spec-{slug}/SPEC.md` with `{n}` capabilities and `{m}` companions. Verdict: `{verdict}`. Open questions: `{list}`.

package/src/method-skills/1-analysis/wize-agent-analyst/agent.yaml

@@ -23,6 +23,9 @@ absorbs:
 skills:
   - wize-product-brief
   - wize-research
+  - wize-market-research
+  - wize-domain-research
+  - wize-technical-research
   - wize-trigger-map
   - wize-prfaq
   - wize-document-project

package/src/method-skills/1-analysis/wize-document-project/documentation-requirements.csv

@@ -0,0 +1,12 @@
+project_type_id,requires_api_scan,requires_data_models,requires_state_management,requires_ui_components,requires_deployment_config,key_file_patterns,critical_directories,integration_scan_patterns,test_file_patterns,config_patterns,auth_security_patterns,schema_migration_patterns,entry_point_patterns,shared_code_patterns,monorepo_workspace_patterns,async_event_patterns,ci_cd_patterns,asset_patterns,hardware_interface_patterns,protocol_schema_patterns,localization_patterns,requires_hardware_docs,requires_asset_inventory
+web,true,true,true,true,true,package.json;tsconfig.json;*.config.js;*.config.ts;vite.config.*;webpack.config.*;next.config.*;nuxt.config.*,src/;app/;pages/;components/;api/;lib/;styles/;public/;static/,*client.ts;*service.ts;*api.ts;fetch*.ts;axios*.ts;*http*.ts,*.test.ts;*.spec.ts;*.test.tsx;*.spec.tsx;**/__tests__/**;**/*.test.*;**/*.spec.*,.env*;config/*;*.config.*;.config/;settings/,*auth*.ts;*session*.ts;middleware/auth*;*.guard.ts;*authenticat*;*permission*;guards/,migrations/**;prisma/**;*.prisma;alembic/**;knex/**;*migration*.sql;*migration*.ts,main.ts;index.ts;app.ts;server.ts;_app.tsx;_app.ts;layout.tsx,shared/**;common/**;utils/**;lib/**;helpers/**;@*/**;packages/**,pnpm-workspace.yaml;lerna.json;nx.json;turbo.json;workspace.json;rush.json,*event*.ts;*queue*.ts;*subscriber*.ts;*consumer*.ts;*producer*.ts;*worker*.ts;jobs/**,.github/workflows/**;.gitlab-ci.yml;Jenkinsfile;.circleci/**;azure-pipelines.yml;bitbucket-pipelines.yml;.drone.yml,public/**;static/**;assets/**;images/**;media/**,N/A,*.proto;*.graphql;graphql/**;schema.graphql;*.avro;openapi.*;swagger.*,i18n/**;locales/**;lang/**;translations/**;messages/**;*.po;*.pot,false,false
+mobile,true,true,true,true,true,package.json;pubspec.yaml;Podfile;build.gradle;app.json;capacitor.config.*;ionic.config.json,src/;app/;screens/;components/;services/;models/;assets/;ios/;android/,*client.ts;*service.ts;*api.ts;fetch*.ts;axios*.ts;*http*.ts,*.test.ts;*.test.tsx;*_test.dart;*.test.dart;**/__tests__/**,.env*;config/*;app.json;capacitor.config.*;google-services.json;GoogleService-Info.plist,*auth*.ts;*session*.ts;*authenticat*;*permission*;*biometric*;secure-store*,migrations/**;realm/**;*.realm;watermelondb/**;sqlite/**,main.ts;index.ts;App.tsx;App.ts;main.dart,shared/**;common/**;utils/**;lib/**;components/shared/**;@*/**,pnpm-workspace.yaml;lerna.json;nx.json;turbo.json,*event*.ts;*notification*.ts;*push*.ts;background-fetch*,fastlane/**;.github/workflows/**;.gitlab-ci.yml;bitbucket-pipelines.yml;appcenter-*,assets/**;Resources/**;res/**;*.xcassets;drawable*/;mipmap*/;images/**,N/A,*.proto;graphql/**;*.graphql,i18n/**;locales/**;translations/**;*.strings;*.xml,false,true
+backend,true,true,false,false,true,package.json;requirements.txt;go.mod;Gemfile;pom.xml;build.gradle;Cargo.toml;*.csproj,src/;api/;services/;models/;routes/;controllers/;middleware/;handlers/;repositories/;domain/,*client.ts;*repository.ts;*service.ts;*connector*.ts;*adapter*.ts,*.test.ts;*.spec.ts;*_test.go;test_*.py;*Test.java;*_test.rs,.env*;config/*;*.config.*;application*.yml;application*.yaml;appsettings*.json;settings.py,*auth*.ts;*session*.ts;*authenticat*;*authorization*;middleware/auth*;guards/;*jwt*;*oauth*,migrations/**;alembic/**;flyway/**;liquibase/**;prisma/**;*.prisma;*migration*.sql;*migration*.ts;db/migrate,main.ts;index.ts;server.ts;app.ts;main.go;main.py;Program.cs;__init__.py,shared/**;common/**;utils/**;lib/**;core/**;@*/**;pkg/**,pnpm-workspace.yaml;lerna.json;nx.json;go.work,*event*.ts;*queue*.ts;*subscriber*.ts;*consumer*.ts;*producer*.ts;*worker*.ts;*handler*.ts;jobs/**;workers/**,.github/workflows/**;.gitlab-ci.yml;Jenkinsfile;.circleci/**;azure-pipelines.yml;.drone.yml,N/A,N/A,*.proto;*.graphql;graphql/**;*.avro;*.thrift;openapi.*;swagger.*;schema/**,N/A,false,false
+cli,false,false,false,false,false,package.json;go.mod;Cargo.toml;setup.py;pyproject.toml;*.gemspec,src/;cmd/;cli/;bin/;lib/;commands/,N/A,*.test.ts;*_test.go;test_*.py;*.spec.ts;*_spec.rb,.env*;config/*;*.config.*;.*.rc;.*rc,N/A,N/A,main.ts;index.ts;cli.ts;main.go;main.py;__main__.py;bin/*,shared/**;common/**;utils/**;lib/**;helpers/**,N/A,N/A,.github/workflows/**;.gitlab-ci.yml;goreleaser.yml,N/A,N/A,N/A,N/A,false,false
+library,false,false,false,false,false,package.json;setup.py;Cargo.toml;go.mod;*.gemspec;*.csproj;pom.xml,src/;lib/;dist/;pkg/;build/;target/,N/A,*.test.ts;*_test.go;test_*.py;*.spec.ts;*Test.java;*_test.rs,.*.rc;tsconfig.json;rollup.config.*;vite.config.*;webpack.config.*,N/A,N/A,index.ts;index.js;lib.rs;main.go;__init__.py,src/**;lib/**;core/**,N/A,N/A,.github/workflows/**;.gitlab-ci.yml;.circleci/**,N/A,N/A,N/A,N/A,false,false
+desktop,false,false,true,true,true,package.json;Cargo.toml;*.csproj;CMakeLists.txt;tauri.conf.json;electron-builder.yml;wails.json,src/;app/;components/;main/;renderer/;resources/;assets/;build/,*service.ts;ipc*.ts;*bridge*.ts;*native*.ts;invoke*,*.test.ts;*.spec.ts;*_test.rs;*.spec.tsx,.env*;config/*;*.config.*;app.config.*;forge.config.*;builder.config.*,*auth*.ts;*session*.ts;keychain*;secure-storage*,N/A,main.ts;index.ts;main.js;src-tauri/main.rs;electron.ts,shared/**;common/**;utils/**;lib/**;components/shared/**,N/A,*event*.ts;*ipc*.ts;*message*.ts,.github/workflows/**;.gitlab-ci.yml;.circleci/**,resources/**;assets/**;icons/**;static/**;build/resources,N/A,N/A,i18n/**;locales/**;translations/**;lang/**,false,true
+game,false,false,true,false,false,*.unity;*.godot;*.uproject;package.json;project.godot,Assets/;Scenes/;Scripts/;Prefabs/;Resources/;Content/;Source/;src/;scenes/;scripts/,N/A,*Test.cs;*_test.gd;*Test.cpp;*.test.ts,.env*;config/*;*.ini;settings/;GameSettings/,N/A,N/A,main.gd;Main.cs;GameManager.cs;main.cpp;index.ts,shared/**;common/**;utils/**;Core/**;Framework/**,N/A,N/A,.github/workflows/**;.gitlab-ci.yml,Assets/**;Scenes/**;Prefabs/**;Materials/**;Textures/**;Audio/**;Models/**;*.fbx;*.blend;*.shader;*.hlsl;*.glsl;Shaders/**;VFX/**,N/A,N/A,Localization/**;Languages/**;i18n/**,false,true
+data,false,true,false,false,true,requirements.txt;pyproject.toml;dbt_project.yml;airflow.cfg;setup.py;Pipfile,dags/;pipelines/;models/;transformations/;notebooks/;sql/;etl/;jobs/,N/A,test_*.py;*_test.py;tests/**,.env*;config/*;profiles.yml;dbt_project.yml;airflow.cfg,N/A,migrations/**;dbt/models/**;*.sql;schemas/**,main.py;__init__.py;pipeline.py;dag.py,shared/**;common/**;utils/**;lib/**;helpers/**,N/A,*event*.py;*consumer*.py;*producer*.py;*worker*.py;jobs/**;tasks/**,.github/workflows/**;.gitlab-ci.yml;airflow/dags/**,N/A,N/A,*.proto;*.avro;schemas/**;*.parquet,N/A,false,false
+extension,true,false,true,true,false,manifest.json;package.json;wxt.config.ts,src/;popup/;content/;background/;assets/;components/,*message.ts;*runtime.ts;*storage.ts;*tabs.ts,*.test.ts;*.spec.ts;*.test.tsx,.env*;wxt.config.*;webpack.config.*;vite.config.*,*auth*.ts;*session*.ts;*permission*,N/A,index.ts;popup.ts;background.ts;content.ts,shared/**;common/**;utils/**;lib/**,N/A,*message*.ts;*event*.ts;chrome.runtime*;browser.runtime*,.github/workflows/**,assets/**;icons/**;images/**;static/**,N/A,N/A,_locales/**;locales/**;i18n/**,false,false
+infra,false,false,false,false,true,*.tf;*.tfvars;pulumi.yaml;cdk.json;*.yml;*.yaml;Dockerfile;docker-compose*.yml,terraform/;modules/;k8s/;charts/;playbooks/;roles/;policies/;stacks/,N/A,*_test.go;test_*.py;*_test.tf;*_spec.rb,.env*;*.tfvars;config/*;vars/;group_vars/;host_vars/,N/A,N/A,main.tf;index.ts;__main__.py;playbook.yml,modules/**;shared/**;common/**;lib/**,N/A,N/A,.github/workflows/**;.gitlab-ci.yml;.circleci/**,N/A,N/A,N/A,N/A,false,false
+embedded,false,false,false,false,false,platformio.ini;CMakeLists.txt;*.ino;Makefile;*.ioc;mbed-os.lib,src/;lib/;include/;firmware/;drivers/;hal/;bsp/;components/,N/A,test_*.c;*_test.cpp;*_test.c;tests/**,.env*;config/*;sdkconfig;*.json;settings/,N/A,N/A,main.c;main.cpp;main.ino;app_main.c,lib/**;shared/**;common/**;drivers/**,N/A,N/A,.github/workflows/**;.gitlab-ci.yml,N/A,*.h;*.hpp;drivers/**;hal/**;bsp/**;pinout.*;peripheral*;gpio*;*.fzz;schematics/**,*.proto;mqtt*;coap*;modbus*,N/A,true,false

package/src/method-skills/1-analysis/wize-document-project/templates/api-contracts-template.md

@@ -0,0 +1,38 @@
+---
+status: baseline
+owner: Pepper Potts + Tony Stark
+created: {{date}}
+last_refreshed: {{date}}
+---
+
+# {{project_name}} — API Contracts{{#if part_id}} — {{part_id}}{{/if}}
+
+**Date:** {{date}}
+
+## Overview
+
+{{api_overview}}
+
+## Endpoints
+
+{{#each endpoints}}
+### {{name}}
+- **Method:** {{method}}
+- **Path:** `{{path}}`
+- **Description:** {{description}}
+
+#### Request
+{{request_schema}}
+
+#### Response
+{{response_schema}}
+
+#### Errors
+{{#each errors}}
+- **{{status}}** — {{description}}
+{{/each}}
+{{/each}}
+
+---
+
+_Generated using Wize Dev Kit `document-project` workflow_

package/src/method-skills/1-analysis/wize-document-project/templates/architecture-template.md

@@ -0,0 +1,54 @@
+---
+status: baseline
+owner: Pepper Potts + Tony Stark
+created: {{date}}
+last_refreshed: {{date}}
+---
+
+# {{project_name}} — Architecture{{#if part_id}} — {{part_id}}{{/if}}
+
+**Date:** {{date}}
+**Type:** {{project_type}}
+**Architecture Pattern:** {{architecture_pattern}}
+
+## Executive Summary
+
+{{architecture_summary}}
+
+## Entry Points
+
+{{#each entry_points}}
+- **`{{path}}`** — {{description}}
+{{/each}}
+
+## Components
+
+{{#each components}}
+### {{name}}
+- **Responsibility:** {{responsibility}}
+- **Location:** `{{location}}`
+- **Depends on:** {{dependencies}}
+- **Used by:** {{dependents}}
+{{/each}}
+
+## Data Flow
+
+{{data_flow_description}}
+
+## Integrations
+
+{{#each integrations}}
+- **{{name}}** — {{description}}
+- **Type:** {{integration_type}}
+- **Boundary:** {{boundary}}
+{{/each}}
+
+## Decisions & Trade-offs
+
+{{#each decisions}}
+- {{description}}
+{{/each}}
+
+---
+
+_Generated using Wize Dev Kit `document-project` workflow_

package/src/method-skills/1-analysis/wize-document-project/templates/component-inventory-template.md

@@ -0,0 +1,40 @@
+---
+status: baseline
+owner: Pepper Potts + Mantis
+created: {{date}}
+last_refreshed: {{date}}
+---
+
+# {{project_name}} — Component Inventory{{#if part_id}} — {{part_id}}{{/if}}
+
+**Date:** {{date}}
+**Type:** {{project_type}}
+
+## Categorization
+
+{{#each categories}}
+### {{name}}
+{{#each components}}
+- **{{name}}** (`{{location}}`) — {{purpose}}
+{{/each}}
+{{/each}}
+
+## Reuse
+
+{{#each reusable_components}}
+- **{{name}}** — {{usage_guidance}}
+{{/each}}
+
+## Design System
+
+{{design_system_notes}}
+
+## Component Dependencies
+
+{{#each dependency_notes}}
+- {{description}}
+{{/each}}
+
+---
+
+_Generated using Wize Dev Kit `document-project` workflow_