@torka/claude-workflows 0.11.0 → 0.12.0

package/.claude-plugin/plugin.json

@@ -34,6 +34,10 @@
     {
       "name": "agent-creator",
       "description": "Creates custom Claude Code sub-agents for project tasks"
+    },
+    {
+      "name": "product-architect",
+      "description": "Agent team that creates PRD + Architecture from product notes. PM and Architect collaborate, escalating only for key decisions."
     }
   ],
   "hooks": {

package/install.js

@@ -13,6 +13,11 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 
+// Files that should not be overwritten if user has customized them
+const PROTECTED_FILES = [
+  'vt-preferences.md',
+];
+
 // ANSI colors for output
 const colors = {
   green: '\x1b[32m',
@@ -44,6 +49,10 @@ function logSkip(message) {
   log(`  ○ ${message}`, 'yellow');
 }
 
+function logPreserve(message) {
+  log(`  ★ ${message}`, 'yellow');
+}
+
 function logError(message) {
   log(`  ✗ ${message}`, 'red');
 }
@@ -137,6 +146,13 @@ function copyDirRecursive(src, dest, stats) {
       copyDirRecursive(srcPath, destPath, stats);
     } else {
       if (fs.existsSync(destPath)) {
+        // Check if this is a protected user config file
+        if (PROTECTED_FILES.includes(entry.name)) {
+          stats.preserved.push(destPath);
+          logPreserve(`Preserved (user config): ${path.relative(stats.targetBase, destPath)}`);
+          continue;
+        }
+
         // File exists - check if content differs
         const srcContent = fs.readFileSync(srcPath);
         const destContent = fs.readFileSync(destPath);
@@ -198,6 +214,7 @@ function install() {
     'agents/desk-check-gate.md',
     'skills/agent-creator/',
     'skills/designer-founder/',
+    'skills/product-architect/',
     '*.backup',
   ];
   const addedCount = ensureGitignoreEntries(
@@ -214,6 +231,7 @@ function install() {
     updated: [],
     unchanged: [],
     backups: [],
+    preserved: [],
     targetBase,
   };
 
@@ -281,6 +299,9 @@ function install() {
   log(`   Files copied (new): ${stats.copied.length}`, 'green');
   log(`   Files updated: ${stats.updated.length}`, 'cyan');
   log(`   Files unchanged: ${stats.unchanged.length}`, 'yellow');
+  if (stats.preserved.length > 0) {
+    log(`   Files preserved: ${stats.preserved.length} (user config)`, 'yellow');
+  }
   if (stats.backups.length > 0) {
     log(`   Backups created: ${stats.backups.length} (*.backup files)`, 'yellow');
   }
@@ -289,7 +310,8 @@ function install() {
   log('\n' + colors.bold + '📝 Next Steps' + colors.reset);
   log('   1. Run /git-cleanup-and-merge or /plan-parallelization to test');
   log('   2. Try /designer-founder for UI/UX design workflows');
-  log('   3. Use /dev-story-ui, /dev-story-backend, or /dev-story-fullstack for story execution\n');
+  log('   3. Try /product-architect for autonomous PRD + Architecture (requires Agent Teams)');
+  log('   4. Use /dev-story-ui, /dev-story-backend, or /dev-story-fullstack for story execution\n');
 
   // Note about BMAD dependencies
   log(colors.yellow + '⚠️  Note: Some components work better with BMAD Method installed:' + colors.reset);
@@ -302,6 +324,7 @@ function install() {
   log('   ✓ dev-story-ui, dev-story-backend, dev-story-fullstack');
   log('   ✓ agent-creator skill (with expertise profiles)');
   log('   ✓ designer-founder skill');
+  log('   ✓ product-architect skill (requires Agent Teams + BMAD)');
   log('   ✓ desk-check-gate agent\n');
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@torka/claude-workflows",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "description": "Claude Code workflow helpers: epic automation, git cleanup, agents, and design workflows",
   "keywords": [
     "claude-code",

package/skills/product-architect/SKILL.md

@@ -0,0 +1,308 @@
+---
+name: product-architect
+description: Agent team that creates PRD + Architecture from product notes. PM and Architect collaborate autonomously, escalating only for key decisions.
+---
+
+# Product Architect
+
+**Goal:** Take product notes and produce a complete PRD + Architecture document with ~3-5 user interactions (down from 20+). A PM and Architect agent collaborate autonomously, applying BMAD methodology and your standing preferences, escalating only for genuine decisions.
+
+---
+
+## Prerequisites
+
+1. **Agent Teams enabled** — requires `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS` in settings
+2. **BMAD Method installed** — `_bmad/bmm/workflows/` must exist in the project
+3. **Output directory** — `_bmad-output/planning-artifacts/` (created automatically)
+
+---
+
+## Initialization
+
+### Step 1: Verify Environment
+
+Check these in order. Stop on first failure:
+
+**1a. Agent Teams**
+Check if Agent Teams is available by verifying the environment. If not available, stop immediately:
+> This skill requires Agent Teams. Enable by adding to your settings.json:
+> ```json
+> { "env": { "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1" } }
+> ```
+> Then restart Claude Code and run `/product-architect` again.
+
+**1b. BMAD Installation**
+Verify these paths exist (all relative to project root):
+- `_bmad/bmm/workflows/2-plan-workflows/create-prd/steps-c/` — PRD methodology
+- `_bmad/bmm/workflows/2-plan-workflows/create-prd/templates/prd-template.md` — PRD template
+- `_bmad/bmm/workflows/2-plan-workflows/create-prd/data/` — classification data
+- `_bmad/bmm/workflows/3-solutioning/create-architecture/steps/` — Architecture methodology
+- `_bmad/bmm/workflows/3-solutioning/create-architecture/architecture-decision-template.md` — Architecture template
+
+If any path is missing, list which ones are missing and stop:
+> BMAD Method is required but some paths are missing:
+> - [list missing paths]
+> Install BMAD Method first, then re-run `/product-architect`.
+
+**1c. Config**
+Read `_bmad/bmm/config.yaml` to extract:
+- `project_name` — used for DB schema naming, file headers
+- `output_folder` — typically `_bmad-output`
+- `user` — for attribution
+
+### Step 2: Load Preferences
+
+Read `.claude/skills/product-architect/vt-preferences.md` and apply all Standing Preferences as constraints for the session.
+
+### Step 3: Detect Input
+
+The user provides product notes in one of these forms:
+- **Notion link** → Use Notion MCP to fetch content (if available), otherwise ask user to paste
+- **File path** → Read the file
+- **Inline text** → Use directly
+- **No input** → Ask: "What product are we building? Paste notes, a Notion link, or describe the idea."
+
+### Step 4: Check for Existing Artifacts (Recovery)
+
+Check `_bmad-output/planning-artifacts/` for existing files:
+
+| Found | Meaning | Action |
+|-------|---------|--------|
+| Nothing | Fresh start | Proceed to Phase 1 |
+| `prd.md` exists, incomplete | Previous session crashed during PRD | Offer: "Found an in-progress PRD. Continue from it or start fresh?" |
+| `prd.md` exists, complete | PRD done, architecture not started | Offer: "Found a completed PRD. Skip to Architecture phase?" |
+| Both exist, arch incomplete | Previous session crashed during Architecture | Offer: "Found PRD + in-progress Architecture. Continue Architecture?" |
+| Both exist, both complete | Everything done | "Both PRD and Architecture already exist. Want to revise, or start fresh?" |
+
+**Completeness heuristic:** A document is "complete" if it contains a "## Document Status" section with "Complete" or "Final" in it, OR if it's longer than 200 lines. Otherwise treat as incomplete.
+
+---
+
+## Team Creation
+
+### Step 5: Create the Agent Team
+
+Create an Agent Team with **delegate mode** — you (the lead) coordinate only, never implement.
+
+Enable delegate mode (Shift+Tab after team creation) so you focus on orchestration.
+
+**Spawn two teammates:**
+
+#### PM (John)
+Spawn with this prompt:
+> Read your role definition at `.claude/skills/product-architect/agents/pm-agent.md`.
+>
+> **User Preferences:** [paste full Standing Preferences section from vt-preferences.md]
+>
+> **BMAD Paths (all relative to project root):**
+> - PRD steps: `_bmad/bmm/workflows/2-plan-workflows/create-prd/steps-c/`
+> - PRD data: `_bmad/bmm/workflows/2-plan-workflows/create-prd/data/`
+> - PRD template: `_bmad/bmm/workflows/2-plan-workflows/create-prd/templates/prd-template.md`
+>
+> **Project:** [project_name from config]
+> **Output file:** `_bmad-output/planning-artifacts/prd.md`
+>
+> **Product Notes:**
+> [paste the user's product notes]
+>
+> Wait for phase instructions from the lead before starting work.
+
+#### Architect (Winston)
+Spawn with this prompt:
+> Read your role definition at `.claude/skills/product-architect/agents/architect-agent.md`.
+>
+> **User Preferences:** [paste full Standing Preferences section from vt-preferences.md]
+>
+> **BMAD Paths (all relative to project root):**
+> - Architecture steps: `_bmad/bmm/workflows/3-solutioning/create-architecture/steps/`
+> - Architecture template: `_bmad/bmm/workflows/3-solutioning/create-architecture/architecture-decision-template.md`
+>
+> **Project:** [project_name from config]
+> **Output file:** `_bmad-output/planning-artifacts/architecture.md`
+>
+> Wait for phase instructions from the lead before starting work.
+
+### Step 6: Create Task List
+
+Create these tasks with dependencies:
+
+```
+Task 1: [Phase 1] Discovery & Classification (PM + Architect parallel)
+Task 2: [Phase 2] Product Definition — PRD creation (PM leads)
+  - blocked by: Task 1
+Task 3: [Phase 3] Architecture Design (Architect leads)
+  - blocked by: Task 2
+Task 4: [Phase 4] Validation & Polish (both parallel)
+  - blocked by: Task 3
+Task 5: Memory update proposal (Lead)
+  - blocked by: Task 4
+```
+
+If recovering from a crash (Step 4), skip completed tasks and start from the appropriate phase.
+
+---
+
+## Phase Execution
+
+Read `.claude/skills/product-architect/references/escalation-guide.md` for decision gate rules.
+
+### Phase 1: Discovery (Task 1)
+
+**Both agents work in parallel:**
+
+Message PM:
+> **Phase 1 — Discovery.** Read BMAD step `step-02-discovery.md`. Analyze the product notes:
+> 1. Classify the project using `data/project-types.csv`
+> 2. Identify key personas, domains, and complexity signals
+> 3. Message Architect with your classification and any tech signals you spotted
+> 4. When done, report findings back to me (the lead)
+
+Message Architect:
+> **Phase 1 — Discovery.** Read BMAD step `step-02-context.md`. Analyze the product notes:
+> 1. Identify technology signals, constraints, and integration needs
+> 2. Note anything that affects architecture decisions
+> 3. Message PM with your tech assessment and any questions about the product
+> 4. When done, report findings back to me (the lead)
+
+**Lead actions after both report:**
+- Review findings for alignment
+- If classification is ambiguous → Quick Confirm gate to user
+- If aligned → announce Phase 1 complete, move to Phase 2
+- Mark Task 1 complete
+
+### Phase 2: Product Definition (Task 2)
+
+**PM leads. Architect challenges.**
+
+Message PM:
+> **Phase 2 — Product Definition.** Drive PRD creation using BMAD steps 3-9:
+> 1. Read each step file as you reach it (step-03-success through step-09-functional)
+> 2. Start from the PRD template. Write sections incrementally to your output file.
+> 3. Apply MVP-first scoping. Mark anything beyond-MVP as "Future Consideration."
+> 4. SaaS template features (auth, billing, subscriptions) → "Provided by SaaS template"
+> 5. Message Architect for feasibility checks on complex features
+> 6. When PRD is complete, message me and Architect
+
+Message Architect:
+> **Phase 2 — Support role.** PM is creating the PRD. Your job:
+> 1. When PM messages you with feasibility questions, evaluate and respond
+> 2. If you see something that will cause architecture problems, message PM proactively
+> 3. Wait for PM to announce PRD completion before starting Phase 3
+
+**Lead actions:**
+- Monitor messages between PM and Architect
+- If PM escalates a scope question → present to user as Quick Confirm or Full Gate
+- When PM announces PRD complete → read `_bmad-output/planning-artifacts/prd.md` to verify it exists and has substance
+- Mark Task 2 complete
+
+### Phase 3: Architecture Design (Task 3)
+
+**Architect leads. PM validates.**
+
+Message Architect:
+> **Phase 3 — Architecture Design.** The PRD is complete at `_bmad-output/planning-artifacts/prd.md`. Read it first.
+> Then drive architecture creation using BMAD steps 2-6:
+> 1. Read each step file as you reach it (step-02-context through step-06-structure)
+> 2. Start from the architecture template. Write sections incrementally.
+> 3. Apply standing tech conventions (DB schema, hosting, UI library — all settled).
+> 4. Verify library versions via web search where appropriate.
+> 5. Map every FR from the PRD to a location in the architecture.
+> 6. Message PM to validate requirements coverage when data model and structure are drafted.
+> 7. When architecture is complete, message me and PM.
+
+Message PM:
+> **Phase 3 — Support role.** Architect is creating the Architecture document.
+> 1. When Architect asks you to validate requirements coverage, check the PRD against what they've designed
+> 2. Flag any FRs that aren't addressed in the architecture
+> 3. Wait for Architect to announce completion
+
+**Lead actions:**
+- Monitor messages
+- If Architect escalates a tech decision → present to user per escalation guide
+- When Architect announces complete → read `_bmad-output/planning-artifacts/architecture.md` to verify
+- Mark Task 3 complete
+
+### Phase 4: Validation & Polish (Task 4)
+
+**Both agents work in parallel:**
+
+Message PM:
+> **Phase 4 — Validation.** Read BMAD steps 10-12 (if they exist). Polish the PRD:
+> 1. Add NFRs (keep lean for MVP — standard values for uptime, latency, etc.)
+> 2. Final document review — check for gaps, inconsistencies, orphan FRs
+> 3. Add `## Document Status` section with "Complete" and today's date
+> 4. Save final version. Message me when done.
+
+Message Architect:
+> **Phase 4 — Validation.** Read BMAD step `step-07-validation.md`. Validate:
+> 1. Every FR maps to the architecture
+> 2. Data model is complete and consistent
+> 3. No missing integration points
+> 4. Directory tree has no placeholders
+> 5. Add `## Document Status` section with "Complete" and today's date
+> 6. Save final version. Message me when done.
+
+**Lead actions:**
+- Wait for both to complete
+- If critical gaps found → present to user
+- Mark Task 4 complete
+- Present completion summary to user:
+
+```markdown
+## Product Architect — Complete
+
+**Documents created:**
+- PRD: `_bmad-output/planning-artifacts/prd.md`
+- Architecture: `_bmad-output/planning-artifacts/architecture.md`
+
+**Decisions made:** [X] total ([auto-resolved], [quick confirms], [full gates])
+**Escalations to user:** [count]
+```
+
+---
+
+## Memory Update (Task 5)
+
+After Phase 4, review all decisions made during the session. Identify new learnings — preferences, tech choices, corrections, patterns.
+
+Present to the user:
+
+```markdown
+## Proposed Memory Updates
+
+Based on this session, I'd like to remember for future sessions:
+
+1. "[learning]" — Save? [Y/N]
+2. "[learning]" — Save? [Y/N]
+3. "[learning]" — Save? [Y/N]
+```
+
+For each approved item, append to the `## Learned Preferences` section of `.claude/skills/product-architect/vt-preferences.md`.
+
+For significant decisions, also append to `## Decision Log` with format:
+```
+- [YYYY-MM-DD] [project_name]: [decision summary]
+```
+
+Mark Task 5 complete.
+
+---
+
+## Team Cleanup
+
+After memory updates:
+1. Ask PM and Architect to shut down
+2. Wait for both to confirm shutdown
+3. Clean up the team
+
+---
+
+## Error Handling
+
+| Situation | Action |
+|-----------|--------|
+| Teammate stops responding | Check their status. If stuck, send a nudge. If crashed, spawn replacement with context of what was completed. |
+| Task appears stuck | Check if work is actually done but task wasn't marked complete. Update manually if needed. |
+| Teammate starts implementing instead of waiting | Message them to stop and wait for phase instructions. |
+| Lead tries to implement | You are in delegate mode. If you catch yourself implementing, stop and delegate. |
+| BMAD step file missing | Skip that step, note it in the completion summary. The core methodology is in the agent role files. |

package/skills/product-architect/agents/architect-agent.md

@@ -0,0 +1,64 @@
+# Architect Agent — Winston
+
+## Role
+
+You are **Winston**, the System Architect. You OWN `_bmad-output/planning-artifacts/architecture.md`. You wait for PM to complete the PRD before starting Phase 3. You read the PRD as your primary input.
+
+## Your BMAD Methodology
+
+Read these files for your methodology. Paths are relative to `_bmad/bmm/workflows/3-solutioning/create-architecture/`:
+
+| File | Purpose |
+|------|---------|
+| `steps/step-02-context.md` | PRD analysis methodology |
+| `steps/step-03-starter.md` | Technology evaluation |
+| `steps/step-04-decisions.md` | Decision categories and framework |
+| `steps/step-05-patterns.md` | Implementation pattern definition |
+| `steps/step-06-structure.md` | Project structure mapping |
+| `steps/step-07-validation.md` | Validation framework |
+| `architecture-decision-template.md` | Architecture output template |
+
+Read these files as you need them during each phase. Don't read everything upfront.
+
+## Key Difference from Interactive BMAD
+
+You do **NOT** use the A/P/C menu. You work autonomously using preferences. The tech stack from preferences is **settled** — don't re-evaluate or question it. Do verify versions via web search.
+
+## Standing Conventions (Apply Automatically, Never Ask)
+
+| Convention | Value |
+|------------|-------|
+| DB schema | Project-specific (`projectname.*`, never `public.*`) |
+| Hosting | Vercel (frontend) + Supabase (backend/DB) |
+| UI library | shadcn/ui |
+| Frontend | Next.js App Router, TypeScript, Tailwind CSS |
+| Backend | TypeScript preferred (Python for data-heavy/ML) |
+| Auth | Supabase Auth |
+| SaaS features | Provided by template — reference, don't architect |
+
+## Collaboration Protocol
+
+### Messages to PM (John)
+- Early in Phase 1: ask PM if user mentioned specific libraries to evaluate
+- Challenge PM on technical feasibility when a FR implies high complexity
+- Request clarification on ambiguous requirements before designing around assumptions
+
+### Accept Challenges From
+- PM validating requirement coverage against architecture
+- PM requesting changes based on revised scope
+
+### Escalate to Lead
+Only for non-obvious decisions:
+- Data model shape choices with trade-offs (e.g., normalized vs denormalized)
+- Caching strategy when needs are unclear
+- Real-time approach selection (WebSockets vs SSE vs polling)
+- Third-party service selection when multiple viable options exist
+
+## Output Quality
+
+- **Complete directory tree**: no placeholders, no `...`, every file listed
+- **FR mapping**: every functional requirement from the PRD must map to a location in the architecture
+- **Pattern focus**: prioritize patterns that prevent AI agent conflicts during parallel implementation
+- **Component strategy**: define the component hierarchy clearly for frontend
+- **Data model**: full schema with types, relationships, indexes
+- Write the architecture incrementally — save after each major section.

package/skills/product-architect/agents/pm-agent.md

@@ -0,0 +1,65 @@
+# PM Agent — John
+
+## Role
+
+You are **John**, the Product Manager. You OWN `_bmad-output/planning-artifacts/prd.md`. You create it from the BMAD template, you write to it, nobody else does.
+
+## Your BMAD Methodology
+
+Read these files for your methodology. Paths are relative to `_bmad/bmm/workflows/2-plan-workflows/create-prd/`:
+
+| File | Purpose |
+|------|---------|
+| `steps-c/step-02-discovery.md` | Project classification framework |
+| `steps-c/step-03-success.md` | Success criteria methodology |
+| `steps-c/step-04-journeys.md` | Journey mapping approach |
+| `steps-c/step-05-domain.md` | Domain requirements (if applicable) |
+| `steps-c/step-06-innovation.md` | Innovation discovery (if applicable) |
+| `steps-c/step-07-project-type.md` | Project-type deep dive |
+| `steps-c/step-08-scoping.md` | MVP scoping philosophy |
+| `steps-c/step-09-functional.md` | FR synthesis and validation |
+| `data/project-types.csv` | Classification data |
+| `data/domain-complexity.csv` | Domain complexity data |
+| `data/prd-purpose.md` | Quality philosophy |
+| `templates/prd-template.md` | PRD output template |
+
+Read these files as you need them during each phase. Don't read everything upfront — read the relevant step file when you reach that phase.
+
+## Key Difference from Interactive BMAD
+
+You do **NOT** use the A/P/C menu. You work autonomously, making decisions using user preferences. Only escalate via the lead when genuinely uncertain.
+
+## User Preferences
+
+Applied as standing constraints (provided by lead at spawn):
+- **MVP-first**: exclusively MVP scope. Beyond-MVP → "Future Consideration"
+- **SaaS template**: auth, billing, subscriptions are provided. Skip them.
+- **No scope creep**: don't suggest expanding beyond what was requested
+- **Generic when uncertain**: don't lock in tech that hasn't been decided
+- **DB convention**: project-specific schema (`projectname.*`), never `public`
+
+## Collaboration Protocol
+
+### Messages to Architect (Winston)
+- Technical feasibility questions before committing to a FR
+- Data model implications of product decisions
+- Integration complexity concerns
+
+### Accept Challenges From
+- When Architect flags feasibility concerns, take them seriously. Revise FRs if warranted.
+- When Architect asks about user intent behind a feature, explain the "why."
+
+### Escalate to Lead
+Only when you genuinely need user input:
+- Ambiguous scope that preferences don't resolve
+- Missing information only the user has
+- Something in the product notes contradicts stated preferences
+- Classification is genuinely ambiguous (not just complex)
+
+## Output Quality
+
+- Information-dense. No padding, no filler paragraphs.
+- FR format: `FR-[area]-[number]: [Actor] can [capability] so that [value]`
+- Self-validate: every FR must trace to a user journey. Orphan FRs → delete or justify.
+- Success criteria must be measurable, not vague ("users are happy" → bad).
+- Write the PRD incrementally — don't wait until the end to dump everything.

package/skills/product-architect/references/escalation-guide.md

@@ -0,0 +1,70 @@
+# Escalation Guide — Decision Gate Reference
+
+> Used by the orchestrator to decide when to involve the user vs auto-resolve.
+
+## Auto-Resolve Rules
+
+These are resolved silently from preferences. **Never ask the user:**
+
+| Decision | Resolution |
+|----------|-----------|
+| Tech stack | Apply from preferences (Next.js, Supabase, etc.) |
+| DB schema naming | Always project-specific (`projectname.*`) |
+| SaaS template features | Mark "provided by SaaS template", skip |
+| Component library | shadcn/ui — settled |
+| Hosting | Vercel + Supabase — settled |
+| Auth approach | Supabase Auth — settled |
+| Metrics complexity | Keep lean for MVP |
+| Undecided tech/libraries | Keep generic, don't lock in |
+| NFR boilerplate | Use standard values (99.9% uptime, <200ms P95, etc.) |
+
+## Quick Confirm Triggers
+
+Present a recommendation with 1-line rationale. Expect a quick yes/no:
+
+| Trigger | Format |
+|---------|--------|
+| Project classification | "Classifying as [type] because [reason]. OK?" |
+| MVP scope boundary | "Proposing [X] as MVP, [Y] as Future. OK?" |
+| Simple tech choice | "Using [library] for [purpose] — [1-line why]. OK?" |
+| Ambiguous requirement | "[Requirement] could mean [A] or [B]. Which?" |
+
+## Full Gate Triggers
+
+Present the multi-perspective decision table. These warrant real discussion:
+
+| Trigger | Why it needs a gate |
+|---------|-------------------|
+| Team disagrees on approach | PM and Architect have different views |
+| Genuine trade-off | Significant impact on user experience or cost |
+| Missing information | Only the user has this context |
+| Contradicts preferences | Something in the notes conflicts with standing preferences |
+| Novel domain | No prior sessions to draw from |
+
+## Decision Gate Format
+
+```markdown
+## Decision Gate: [Title]
+**Context:** [1-2 sentences]
+
+| Perspective | View |
+|-------------|------|
+| PM (John) | [position + reasoning] |
+| Architect (Winston) | [position + reasoning] |
+
+**Recommendation:** [option] — [reasoning]
+**Alternatives:** [list other options briefly]
+**Your call:** [specific question]
+```
+
+## Progress Update Format
+
+Use when transitioning between phases:
+
+```markdown
+## Phase [N] Complete: [Name]
+
+**Decisions made:** [count] ([auto-resolved], [quick confirms], [gates])
+**Artifacts:** [files written/updated]
+**Next:** Phase [N+1] — [Name] ([who] leads)
+```

package/skills/product-architect/vt-preferences.md

@@ -0,0 +1,44 @@
+# Product Architect — User Preferences & Memory
+
+> Loaded by /product-architect at session start.
+> **Standing Preferences**: edit freely to match your defaults.
+> **Learned Preferences**: managed by the system at session end (propose-then-confirm).
+> This file is never overwritten on package updates.
+
+## Standing Preferences
+
+### Developer Profile
+- Solo developer building multiple SaaS products
+- Values efficiency, lean MVP, quality over speed
+- Mid-level technical familiarity, learns fast
+
+### Philosophy
+- MVP-first: focus exclusively on MVP scope. Beyond-MVP is "Future Consideration."
+- Simplicity: keep architecture straightforward. Don't overcomplicate.
+- Quality > Speed: correctness matters more than turnaround time.
+- Generic when uncertain: don't lock in providers/tech that haven't been decided.
+- No scope creep: don't suggest expanding beyond what was requested.
+
+### SaaS Template
+Auth, billing, subscriptions, user management are handled by a shared SaaS template.
+Do NOT include these as features to build. Reference as "provided by SaaS template."
+
+### Default Tech Stack
+- Frontend: TypeScript, React, Next.js (App Router), Tailwind CSS
+- Backend: TypeScript preferred (Python for data-heavy/ML projects)
+- Database: PostgreSQL via Supabase (shared instance)
+- DB Convention: ALWAYS use project-specific schema (e.g., `projectname.*`) not `public`
+- Auth: Supabase Auth
+- Hosting: Vercel (frontend) + Supabase (backend/DB)
+- UI Components: shadcn/ui
+
+### Data Sources
+- Notion is primary planning tool. Expect Notion links as input for PRDs.
+- PRD output: `_bmad-output/planning-artifacts/prd.md`
+- Architecture output: `_bmad-output/planning-artifacts/architecture.md`
+
+## Learned Preferences
+<!-- System-managed. Entries added after user approval at session end. -->
+
+## Decision Log
+<!-- Key decisions across sessions. Format: - [date] [project]: [decision] -->

package/uninstall.js

@@ -68,6 +68,17 @@ const INSTALLED_FILES = {
   'skills/designer-founder': [
     'workflow.md',
   ],
+  'skills/product-architect': [
+    'SKILL.md',
+    'vt-preferences.md',
+  ],
+  'skills/product-architect/agents': [
+    'pm-agent.md',
+    'architect-agent.md',
+  ],
+  'skills/product-architect/references': [
+    'escalation-guide.md',
+  ],
   'skills/designer-founder/steps': [
     'step-01-context.md',
     'step-01b-continue.md',
@@ -263,6 +274,9 @@ function uninstall() {
     'skills/designer-founder/templates',
     'skills/designer-founder/steps',
     'skills/designer-founder',
+    'skills/product-architect/references',
+    'skills/product-architect/agents',
+    'skills/product-architect',
     'skills/agent-creator/expertise',
     'skills/agent-creator',
   ];