wize-dev-kit 0.4.1 → 0.5.0

package/src/method-skills/4-implementation/wize-sprint-status/workflow.md

@@ -8,103 +8,50 @@ status: ready
 
 # Sprint Status
 
-**Goal.** Keep a snapshot of in-flight work that the team and stakeholders can read in 60 seconds. Sprint status is read by everyone, written by Hill (or delegated to Wizer); the source of truth is the file, not Slack.
-
-Update **daily** during a sprint, or after any state change (story moves, blocker appears, gate fails).
+**Goal.** Read `.wize/implementation/sprint-status.yaml` in 60 seconds and say what to do next.
 
 ## Inputs
 
-- `.wize/solutioning/stories/` (current statuses)
-- `.wize/implementation/tea/{epic}/{story}/gate.md` (gate outcomes)
-- The team (verbal stand-up or async update)
+- `.wize/implementation/sprint-status.yaml`
+- `.wize/implementation/tea/{epic}/{story}/gate.md`
 
 ## Output
 
-- Updated entry in `.wize/implementation/sprint-status.md`.
+- Updated sprint-status.yaml (if statuses changed).
+- One recommended next workflow.
 
 ## Steps
 
-### 1. Per story, name a status
-
-| Status | Meaning |
-|---|---|
-| `pulled` | Committed for this sprint, not started yet |
-| `in-progress` | Engineer actively working it (or paused < 1 day) |
-| `paused` | Started, paused > 1 day, reason listed |
-| `blocked` | Cannot proceed; depends on a named external resolution |
-| `in-review` | PR open; Hawkeye running design → trace → review |
-| `gate-PASS` / `gate-CONCERNS` / `gate-FAIL` | TEA gate outcome |
-| `shipped` | Merged to main + deployed (when applicable) |
-
-### 2. Blockers up front
-
-Blockers always appear in the top section. Each gets:
-- Owner (the person who can unblock it).
-- Specific ask (the action they should take).
-- Deadline.
-
-If a blocker sits longer than 2 days, Hill escalates. Stalled blockers are how sprints fail silently.
-
-### 3. Trend
-
-Daily, write a one-line trend: *"On track."* / *"At risk for E03-S02 due to vendor outage."* / *"Slipping; will defer E04-S01 to next sprint."*
-
-### 4. Capture decisions
-
-If something material was decided during the sprint that affects the plan (story sliced, scope dropped, ADR opened), append a one-line entry.
-
-## File template
+1. **Load YAML.** Parse `development_status`.
+2. **Classify** each key: epic, story, retrospective.
+3. **Count** statuses.
+4. **Detect risks:**
+   - Story `in-progress` older than 2 days with no update.
+   - Blocked story without owner/deadline.
+   - Epic `in-progress` with no stories.
+5. **Recommend next step** (in priority order):
+   1. Story `in-progress` → `/wize-dev-story`
+   2. Story `review` → `/wize-tea-review`
+   3. Story `ready-for-dev` → `/wize-dev-story`
+   4. Story `backlog` → `/wize-create-story`
+   5. Retrospective `optional` → `/wize-retrospective`
+   6. All done → congratulate team.
+
+## Summary output
 
 ```markdown
-# Sprint status
+## Sprint Status
 
-## Sprint 7 — 2026-06-12 → 2026-06-25
+- Project: {project} ({project_key})
+- Tracking: {tracking_system}
+- Status file: .wize/implementation/sprint-status.yaml
 
-### Day 4 (2026-06-15)
-**Trend:** On track.
+**Stories:** backlog {n} | ready-for-dev {n} | in-progress {n} | review {n} | done {n}
+**Epics:** backlog {n} | in-progress {n} | done {n}
 
-**Blockers:**
-- (none)
-
-**Stories:**
-- E01-S05 — gate-PASS — shipped (carry-over from S6).
-- E01-S06 — in-progress — Shuri.
-- E02-S02 — in-review — PR #418; Hawkeye doing trace.
-- E03-S02 — in-progress — Aaliyah.
-- E04-S01 — pulled — Shuri starts after E01-S06.
-- E02-S03 (stretch) — pulled — Aaliyah picks up if capacity allows.
-
-**Decisions:**
-- E03-S03 sliced into two stories (E03-S03a, E03-S03b) — ADR-009 incoming.
-
-### Day 5 (2026-06-16)
-**Trend:** At risk on E02-S02 (vendor sandbox down; Hawkeye unblocked at 14:00).
-**Blockers:** Resolved.
-**Stories:** (changes from Day 4)
-- E02-S02 — gate-PASS at 16:30; merged.
-- E01-S06 — in-review — PR #419.
-
-## Sprint 6 — 2026-05-29 → 2026-06-11
-{{archived}}
+**Next:** /{next_workflow} ({next_story_id})
 ```
 
-## Daily cadence (lean)
-
-A daily standup, when present, is 5 minutes max:
-
-- "What did I ship since last time?"
-- "What am I shipping next?"
-- "Anything blocking me?"
-
-Hill updates `sprint-status.md` immediately after; Wizer reads it before any other agent's session that day.
-
-## Anti-patterns Hill rejects
-
-- "Status: in progress" for 4 days with no further detail. Either it really is, in which case slice progress, or it's stuck.
-- Blockers without an owner or a deadline.
-- Sprint goals that drift silently (added stories without removing others).
-- Stale entries in the file. Update daily or delegate the update.
-
 ## Hand-off
 
-> `sprint-status.md` updated. Day 5 trend: at-risk-mitigated. Wizer, if asked about state, the file is the answer. Pepper, brief stays valid; no scope move triggered.
+> Status updated. Run the recommended workflow or call `/wize-sprint-planning` to reprioritize.

package/src/orchestrator-skills/wize-onboarding/workflow.md

@@ -2,27 +2,89 @@
 code: wize-onboarding
 name: Onboarding
 owner: wize-orchestrator   # Wizer
-status: stub
+status: ready
 ---
 
 # Onboarding
 
-**Goal.** Post-install triage. Decide greenfield vs brownfield, profile(s), objective, then delegate.
+**Goal.** First-contact triage after `npx wize-dev-kit install`. Decide greenfield vs brownfield, profile, objective, and route to the right persona. Always ask who the user is so the rest of the session feels personal.
+
+Wizer drives. Each branch ends by handing off to a specific workflow with explicit handoff copy.
 
 ## Inputs
-- `.wize/config/project.toml` (just-created)
-- Repo state (git log, presence of `src/`, `package.json` etc.)
+
+- `.wize/config/project.toml` (always present after install)
+- `.wize/config/user.toml` (per-developer)
+- `.wize/implementation/sprint-status.yaml` (when an active sprint exists)
+- `.wize/planning/brief.md` (when Phase 1 started)
+- `.wize/planning/prd.md` (when Phase 2 finished)
+- Optional: chat message describing the user’s goal.
 
 ## Outputs
-- Updates to `.wize/config/project.toml`
-- A first task handed off to the right agent
+
+- A **single handoff message** naming the next workflow to run, with the user’s name.
+- Optional: `.wize/knowledge/onboarding-summary.md` written when state is ambiguous.
 
 ## Steps
-1. **Greet.** "What are we working on?"
-2. **Detect.** Brownfield? Offer `wize-document-project`.
-3. **Profile check.** Confirm Core/+Web/+App and ask if changes needed.
-4. **Objective.** One sentence: what does success look like in 30 days?
-5. **Route.** 
-   - No brief? → call Pepper (`wize-product-brief`).
-   - Has brief? → call Maria Hill (`wize-create-prd`).
-   - Mid-flight? → resume where we left off (`sprint-status.md`).
+
+### 1. Greet the user
+
+Read `name` from `.wize/config/user.toml`. Greet by name. Speak in `communication_language` from `project.toml`. If `name` is blank, ask once and persist it back to `user.toml` before continuing.
+
+> "Welcome, {name}. You are at Wize onboarding for *{project_name}*."
+
+### 2. Detect project state
+
+Inspect, in order:
+
+| Path | Meaning |
+|---|---|
+| `.wize/implementation/sprint-status.yaml` | Active sprint exists. |
+| `.wize/planning/prd.md` | Phase 2 (PRD) is done. |
+| `.wize/planning/brief.md` | Phase 1 (Brief) is done. |
+| `.wize/knowledge/document-project/*.md` | Brownfield baseline exists. |
+| `package.json`, `src/`, etc. | Brownfield signals (vs. greenfield). |
+
+If multiple artifacts exist, treat the **latest** (PRD > brief > baseline) as the current phase.
+
+### 3. State machine
+
+- **S0 — No artifacts** → greenfield or no planning yet.
+- **S1 — Baseline only** → brownfield, no brief.
+- **S2 — Brief exists** → ready for PRD.
+- **S3 — PRD exists** → ready for sprint planning.
+- **S4 — Active sprint** → resume in-flight.
+
+### 4. Branch by state
+
+| State | Action | Hand-off |
+|---|---|---|
+| S0 | Ask: "What are we building?" Confirm: brownfield or greenfield. Offer `/wize-document-project` (brownfield) or `/wize-product-brief` (greenfield). | "Run `/wize-document-project` (Tony + Peggy) to baseline the repo, or `/wize-product-brief` (Pepper) to write a brief." |
+| S1 | Read `document-project/overview.md`; summarize the project in 3 bullets. Offer brief. | "Repo baselined. Run `/wize-product-brief` (Pepper)." |
+| S2 | Read `brief.md` (3 bullets). Offer PRD. | "Brief ready. Run `/wize-create-prd` (Maria Hill)." |
+| S3 | Read `prd.md` summary + `architecture.md` (if present). Offer sprint planning. | "PRD ready. Run `/wize-sprint-planning` (Maria Hill)." |
+| S4 | Read `sprint-status.yaml` and surface: which stories are in progress, last gate. | "Sprint active. Run `/wize-sprint-status` (Maria Hill) for the full picture." |
+
+### 5. Confirm and exit
+
+End every onboarding session with:
+
+> "Onboarding complete. Next: `/wize-<next-workflow>` ({persona})."
+
+Never auto-launch the next workflow. The user must confirm.
+
+## When to skip
+
+- When the user already knows what they want and explicitly invokes another workflow, route directly. Do not force onboarding.
+- When `WIZE_SKIP_ONBOARDING=1` is set, print a 1-line state summary and exit.
+
+## Anti-patterns Wizer rejects
+
+- Launching the next workflow without confirmation.
+- Re-asking the user’s name when it’s already in `user.toml`.
+- Dumping the full project state to the user. Summarize in ≤ 5 bullets.
+- Suggesting `wize-onboarding` from `/wize-help` once onboarding is complete. (Help should bypass onboarding for return users.)
+
+## Hand-off
+
+> "Onboarding done. You are at **{state}**. Next: `/wize-<next-workflow>` ({persona})."

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

@@ -0,0 +1,119 @@
+---
+code: wize-qa-generate-e2e-tests
+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/tools/installer/render-shared.js

@@ -53,6 +53,42 @@ function ensureDir(dir) {
   fs.mkdirSync(dir, { recursive: true });
 }
 
+// Companion files (steps/, templates/, data/, *.csv, *-template.md,
+// customize.toml, research.template.md, etc.) that micro-file workflows
+// reference from their body. We must copy these alongside the SKILL.md so
+// the IDE can resolve paths like "./steps/step-01-init.md" at runtime.
+const SKIP_NAMES = new Set(['.DS_Store', 'Thumbs.db', 'node_modules', '.git']);
+const SKIP_FILES = new Set([
+  'skill.md', 'workflow.md', 'agent.yaml', 'persona.md',
+  'package.json', 'package-lock.json'
+]);
+
+function isCompanion(entry) {
+  if (entry.name.startsWith('.')) return false;
+  if (SKIP_NAMES.has(entry.name)) return false;
+  if (SKIP_FILES.has(entry.name)) return false;
+  if (entry.name.endsWith('.test.js')) return false;
+  return true;
+}
+
+function copyCompanionFiles(srcDir, destDir, written, relPrefix = '') {
+  if (!srcDir || !fs.existsSync(srcDir)) return;
+  for (const entry of fs.readdirSync(srcDir, { withFileTypes: true })) {
+    if (!isCompanion(entry)) continue;
+    const s = path.join(srcDir, entry.name);
+    const d = path.join(destDir, entry.name);
+    const rel = relPrefix ? `${relPrefix}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) {
+      ensureDir(d);
+      copyCompanionFiles(s, d, written, rel);
+    } else if (entry.isFile()) {
+      ensureDir(path.dirname(d));
+      fs.copyFileSync(s, d);
+      written.push(rel);
+    }
+  }
+}
+
 // Walks the kit and returns a flat array of "assets" the adapters can render.
 // Each asset has: { kind: 'agent'|'workflow'|'skill', code, name, title, description, body, overlay }
 function collectAssets(kitRoot, { profiles = ['core'] } = {}) {
@@ -69,7 +105,7 @@ function collectAssets(kitRoot, { profiles = ['core'] } = {}) {
     if (!code || !name) continue;
     const personaPath = path.join(dir, 'persona.md');
     const persona = fs.existsSync(personaPath) ? fs.readFileSync(personaPath, 'utf-8') : '';
-    out.push({ kind: 'agent', code, name, title, description, body: persona || description, overlay: null });
+    out.push({ kind: 'agent', code, name, title, description, body: persona || description, overlay: null, srcDir: dir });
   }
 
   for (const wfPath of walkWorkflows(kitRoot)) {
@@ -85,7 +121,8 @@ function collectAssets(kitRoot, { profiles = ['core'] } = {}) {
       title: fm.phase || fm.gate || '',
       description: `${fm.phase || fm.gate || 'workflow'}: ${fm.name || fm.code}`,
       body: bodyAfterFrontmatter(content),
-      overlay: fm.overlay || null
+      overlay: fm.overlay || null,
+      srcDir: path.dirname(wfPath)
     });
   }
 
@@ -100,7 +137,8 @@ function collectAssets(kitRoot, { profiles = ['core'] } = {}) {
       title: fm.module || '',
       description: fm.module ? `${fm.module} skill: ${fm.name || fm.code}` : (fm.name || fm.code),
       body: bodyAfterFrontmatter(content),
-      overlay: null
+      overlay: null,
+      srcDir: path.dirname(skPath)
     });
   }
 
@@ -140,6 +178,10 @@ function renderAnthropicSkills(kitRoot, targetDir, opts = {}) {
       ensureDir(skillDir);
       fs.writeFileSync(path.join(skillDir, 'SKILL.md'), content, 'utf-8');
       written.push(`${a.code}/SKILL.md`);
+      // Copy companion files (steps/, templates/, data/, *.csv, customize.toml,
+      // *-template.md, research.template.md, etc.) so micro-file workflows can
+      // resolve relative paths from inside the SKILL body.
+      copyCompanionFiles(a.srcDir, skillDir, written, a.code);
     }
   }
   return { written, skipped: [] };
@@ -178,6 +220,7 @@ module.exports = {
   collectAssets,
   renderAnthropicSkills,
   renderAgentsMd,
+  copyCompanionFiles,
   // Re-exports for adapter authors who need to roll their own format:
   readFrontmatter,
   bodyAfterFrontmatter,

package/tools/installer/wize-cli.js

@@ -140,12 +140,69 @@ function prompt(question) {
 }
 
 async function confirm(question, defaultYes = true) {
+  if (INTERACTIVE) {
+    const { value } = await prompts({
+      type: 'confirm',
+      name: 'value',
+      message: question,
+      initial: defaultYes
+    });
+    if (value === undefined) process.exit(130);
+    return value;
+  }
   const hint = defaultYes ? '[Y/n]' : '[y/N]';
   const ans = (await prompt(`${question} ${hint} `)).toLowerCase();
   if (!ans) return defaultYes;
   return ans.startsWith('y');
 }
 
+async function promptText(question, defaultValue = '') {
+  if (INTERACTIVE) {
+    const { value } = await prompts({
+      type: 'text',
+      name: 'value',
+      message: question,
+      initial: defaultValue
+    });
+    if (value === undefined) process.exit(130);
+    return value.trim();
+  }
+  const ans = (await prompt(`${question} [${defaultValue}]: `)).trim();
+  return ans || defaultValue;
+}
+
+async function promptTextMandatory(question, defaultValue = '') {
+  if (INTERACTIVE) {
+    if (defaultValue) {
+      const { keep } = await prompts({
+        type: 'confirm',
+        name: 'keep',
+        message: `${question} (use "${defaultValue}"?)`,
+        initial: true
+      });
+      if (keep === undefined) process.exit(130);
+      if (keep) return defaultValue;
+    }
+    const { value } = await prompts({
+      type: 'text',
+      name: 'value',
+      message: question
+    });
+    if (value === undefined) process.exit(130);
+    const trimmed = value.trim();
+    if (trimmed) return trimmed;
+    if (defaultValue) return defaultValue;
+    return promptTextMandatory(question, defaultValue);
+  }
+  // Non-TTY: keep asking until non-empty.
+  for (;;) {
+    const ans = (await prompt(`${question}: `)).trim();
+    if (ans) return ans;
+    if (defaultValue) return defaultValue;
+    console.log('Please provide a value.');
+  }
+}
+
 async function select(label, choices, defaultValue) {
   if (INTERACTIVE) {
     const initial = choices.findIndex(c => c.value === defaultValue);
@@ -384,7 +441,7 @@ async function cmdInstall(args) {
     console.log('\nGreenfield repo detected.');
   }
 
-  const project_name = (await prompt(`Project name [${path.basename(cwd)}]: `)) || path.basename(cwd);
+  const project_name = (await promptText(`Project name`, path.basename(cwd))) || path.basename(cwd);
   const profiles = await multiSelect('Select profile(s) to install', PROFILES);
   const targets = await multiSelect('Select IDE target(s)', TARGETS);
 
@@ -398,10 +455,13 @@ async function cmdInstall(args) {
   );
 
   // Personal touch — the user_name lands in .wize/config/user.toml (per-developer).
+  // Always ask; do not silently accept the OS username, because the install must
+  // feel personal and avoid misnaming the user in agent conversations.
   const defaultName = (os.userInfo().username || '').trim();
-  const user_name = (await prompt(
-    `How should the agents call you? [${defaultName || 'leave blank'}]: `
-  )).trim() || defaultName;
+  const user_name = await promptTextMandatory(
+    'How should the agents call you?',
+    defaultName
+  );
 
   // Gitignore — opt-in, idempotent.
   const wantsGitignore = await confirm(