wize-dev-kit 0.4.0 → 0.5.0

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

@@ -8,92 +8,79 @@ status: ready
 
 # Sprint Planning
 
-**Goal.** Pick what enters this sprint. Capacity-honest, priority-honest, risk-honest. The sprint is a commitment about a small slice of the future, not a wish list.
+**Goal.** Pick what enters this sprint. Capacity-honest, priority-honest, risk-honest.
 
-Maria Hill chairs. Tony advises on slicing. Hawkeye flags risk on stories. Shuri commits to the load.
+Maria Hill chairs. Tony advises on slicing. Hawkeye flags risk. Shuri commits to the load.
 
 ## Inputs
 
 - Story backlog: `.wize/solutioning/stories/`
-- Velocity history: `.wize/implementation/sprint-status.md` (previous sprints) — when present.
+- Previous sprint state: `.wize/implementation/sprint-status.yaml`
 - `.wize/implementation/tea/risk-profile.md`
-- Open `tea-gate` outcomes from last sprint.
-- Team availability for the next interval (vacations, on-call rotation, planned meetings).
+- Team availability for the next interval.
 
 ## Output
 
-- New sprint block appended to `.wize/implementation/sprint-status.md`.
-- Story files updated `priority: 1` for chosen stories.
-
-## Rules
-
-1. **Capacity = min(history velocity, declared availability).** Not the average of optimistic estimates.
-2. **High-risk stories** (linked to `R-x` HIGH in risk profile) get TEA design done in the planning meeting, not at story start.
-3. **Stretch goals** are explicit, named, not silent. If a stretch ships, great. If not, the sprint isn't a failure.
-4. **Don't carry over without reason.** A carried-over story gets a one-line "why" in the sprint log.
+- Updated `.wize/implementation/sprint-status.yaml`.
+- Story files updated with `priority: 1` for chosen stories.
 
 ## Steps
 
-### 1. Look back (3 min)
-
-Last sprint: what shipped, what slipped, what surprised. Don't relitigate; observe.
-
-### 2. Refresh capacity
-
-- Person-days available this sprint = sum(working days) × (1 - meetings load).
-- Subtract on-call burden, oncall handoff time, planned reviews.
-
-### 3. Pull stories (in priority order)
-
-Default selection algorithm:
-- Always pull continuation stories (in-flight from last sprint) first.
-- Then highest-priority stories that fit the capacity.
-- Then risk-driven: high-risk stories (R-HIGH) preferred over more low-risk ones when capacity is tight.
-
-For each pulled story, confirm INVEST still holds; re-slice if needed.
-
-### 4. Reserve buffer
-
-10–15% buffer for unknowns (bug fixes, support escalations). Don't fill the sprint to 100% — you'll always pay.
-
-### 5. Walk the gate plan
-
-For each story pulled, what's the TEA gate cadence? Most stories: design at start, trace + review + gate at end. High-risk: include NFR re-check at epic close.
-
-### 6. Commit (verbal + written)
-
-Each engineer reads back the stories they're owning. Hill writes them into the sprint block. Sprint starts.
-
-## Sprint block template (appended to `sprint-status.md`)
-
-```markdown
-## Sprint 7 — 2026-06-12 → 2026-06-25
-
-**Capacity:** 24 person-days (3 engineers × 10 days × 0.8 utilization)
-**Carry-over:** E01-S05 (90% done; Shuri); E03-S01 (TEA review pending)
-**Pulled:**
-- E01-S06 — M — owner: Shuri — gate cadence: design+gate
-- E02-S02 — L — owner: Shuri — gate cadence: design+trace+review+gate (R-3)
-- E03-S02 — M — owner: Aaliyah — gate cadence: design+trace+review+gate (R-1)
-- E04-S01 — S — owner: Shuri — gate cadence: smoke (quick-dev pattern)
-- E02-S03 — S — stretch
-
-**Out (deferred to Sprint 8):**
-- E03-S03 — reason: depends on E03-S02 ADR
-- E05-S01 — reason: out of NFR-cost budget; revisit
-
-**Risks flagged:**
-- E02-S02 — auth refresh story; high-risk; TEA design done at planning.
+1. **Look back** — what shipped, what slipped, what surprised.
+2. **Refresh capacity** — person-days × utilization − overhead.
+3. **Pull stories** — continuation first, then priority, then risk.
+4. **Reserve 10–15% buffer** for unknowns.
+5. **Walk the gate plan** — design/trace/review/gate per story.
+6. **Commit** — verbal + written into YAML.
+
+## Status state machine
+
+- Epic: `backlog` → `in-progress` → `done`
+- Story: `backlog` → `ready-for-dev` → `in-progress` → `review` → `done`
+- Retrospective: `optional` ↔ `done`
+
+## Sprint block template
+
+```yaml
+# generated: YYYY-MM-DD
+# last_updated: YYYY-MM-DD
+# project: {project_name}
+# project_key: {project_key}
+# tracking_system: file-system
+# story_location: .wize/solutioning/stories
+
+generated: YYYY-MM-DD
+last_updated: YYYY-MM-DD
+project: {project_name}
+project_key: {project_key}
+tracking_system: file-system
+story_location: .wize/solutioning/stories
+
+development_status:
+  epic-1: backlog
+  1-1-story-one: backlog
+  1-2-story-two: backlog
+  epic-1-retrospective: optional
 ```
 
-## Anti-patterns Hill rejects
+## Anti-patterns
 
-- **"Optimistic" velocity that ignores history.** Use observed velocity.
-- **Stories pulled without owners.** Don't aspire; commit.
-- **Stretch goals so big they're really plan.** Stretch = optional, not "we hope we can."
-- **Pulling a story when its dependency hasn't shipped.** It will sit blocked.
-- **No buffer.** Real sprints have surprises.
+- Optimistic velocity.
+- Stories without owners.
+- Stretch goals that are really plan.
+- Pulling blocked dependencies.
+- Zero buffer.
 
 ## Hand-off
 
-> Sprint 7 committed at `.wize/implementation/sprint-status.md`. Shuri owns most; Aaliyah picks up E03-S02. Hawkeye, NFR gate due on E03 at sprint end. Wizer, retro on the 25th.
+> Sprint committed at `.wize/implementation/sprint-status.yaml`. Stories in `ready-for-dev` are now eligible for the dev loop.
+>
+> **Recommended next loop:**
+>
+> ```
+> /loop /wize-dev-story
+> ```
+>
+> `/loop /wize-dev-story` drives one story at a time: TDD red-green-refactor, AC IDs in commits, `tea-design.md` contract, knowledge update on the 5 baseline axes, and a clean gate at the end. `/loop` keeps it going across the sprint's `ready-for-dev` queue until the user pauses.
+>
+> Next: `/wize-sprint-status` (Maria Hill) to acompanhar o progresso.

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,