opencode-starterkit 1.0.1

package/baseline/command/init-context.md

@@ -0,0 +1,273 @@
+---
+description: Initialize GSD-style project planning context with integrated skill usage
+argument-hint: "[--skip-questions] [--brownfield]"
+agent: build
+---
+
+# Init-Context: $ARGUMENTS
+
+Initialize GSD-style project planning with integrated skill usage.
+
+`tech-stack.md` is the default baseline project memory file. This command adds the optional planning files (`project.md`, `roadmap.md`, `state.md`) used for richer multi-session project context.
+
+## Load Skills
+
+```typescript
+skill({ name: "context-initialization" });
+skill({ name: "brainstorming" });
+skill({ name: "verification-before-completion" });
+```
+
+## Parse Arguments
+
+```typescript
+const args = {
+  skipQuestions: $ARGUMENTS.includes("--skip-questions"),
+  brownfield: $ARGUMENTS.includes("--brownfield"),
+  focus: $ARGUMENTS.match(/--focus=(\w+)/)?.[1], // Optional: api, ui, db, etc.
+};
+```
+
+## Phase 1: Discovery
+
+### 1.1 Check Existing Context
+
+```bash
+ls .opencode/memory/project/ 2>/dev/null && HAS_CONTEXT=true || HAS_CONTEXT=false
+cat .opencode/memory/project/project.md 2>/dev/null | head -20
+```
+
+**If planning context exists:**
+
+```
+Existing optional planning context found:
+- project.md: [exists/size]
+- roadmap.md: [exists/size]
+- state.md: [exists/size]
+
+Options:
+1. Refresh - Delete and recreate from templates
+2. Update - Keep existing, only update state.md
+3. Skip - Use existing context as-is
+```
+
+Wait for user selection.
+
+### 1.2 Brownfield Codebase Analysis (if --brownfield)
+
+If `--brownfield` flag is set:
+
+```typescript
+// Spawn parallel analysis agents (like GSD map-codebase)
+skill({ name: "swarm-coordination" });
+
+// Agent 1: Map tech stack
+Task({
+  subagent_type: "explore",
+  description: "Analyze tech stack",
+  prompt:
+    "Analyze the codebase technology stack. Write findings to .opencode/memory/project/codebase/tech-analysis.md covering: languages, frameworks, dependencies, build tools. Return file path and line count only.",
+});
+
+// Agent 2: Map architecture
+Task({
+  subagent_type: "explore",
+  description: "Analyze architecture",
+  prompt:
+    "Analyze the codebase architecture. Write findings to .opencode/memory/project/codebase/arch-analysis.md covering: patterns, directory structure, entry points. Return file path and line count only.",
+});
+
+// Wait for agents and collect confirmations
+```
+
+## Phase 2: Requirements Gathering
+
+### 2.1 Load Brainstorming Skill (if not --skip-questions)
+
+```typescript
+if (!args.skipQuestions) {
+  skill({ name: "brainstorming" });
+
+  // Follow brainstorming process for project vision
+  // Ask questions one at a time (as per brainstorming skill)
+  // Output: Refined vision, success criteria, target users
+}
+```
+
+### 2.2 Quick Mode (if --skip-questions)
+
+Use template defaults with placeholders for:
+
+- Project vision
+- Success criteria
+- Target users
+- Phases
+- Current phase
+
+## Phase 3: Document Creation
+
+### 3.1 Create project.md
+
+**Load template:**
+
+```bash
+cat .opencode/memory/_templates/project.md
+```
+
+**Fill with gathered data:**
+
+- Vision from brainstorming OR template placeholder
+- Success criteria (3-7 measurable outcomes)
+- Target users (primary/secondary)
+- Core principles (convention over config, minimal, extensible)
+- Current phase (from user input or template default)
+
+**Write to:** `.opencode/memory/project/project.md`
+
+### 3.2 Create roadmap.md
+
+**Parse phases from input:**
+
+```typescript
+// Convert user-provided phases into structured roadmap
+// Example: "Discovery, MVP, Launch, Scale" → table rows
+```
+
+**Structure:**
+
+```markdown
+| Phase     | Goal   | Status   | Beads |
+| --------- | ------ | -------- | ----- |
+| [Phase 1] | [Goal] | [Status] | [#]   |
+```
+
+**Write to:** `.opencode/memory/project/roadmap.md`
+
+### 3.3 Create state.md
+
+**Initialize with:**
+
+- Active Bead: (blank or from bead context)
+- Status: In Progress
+- Started: [current date]
+- Phase: [from roadmap]
+- Recent Completed Work: (empty table)
+- Active Decisions: (empty table)
+- Blockers: (empty table)
+- Open Questions: (empty table)
+- Next Actions: (empty list)
+
+**Write to:** `.opencode/memory/project/state.md`
+
+### 3.4 Brownfield Analysis Integration (if applicable)
+
+If `--brownfield` analysis was run:
+
+```typescript
+// Append tech/arch findings to project.md Context Notes section
+// Or create separate .opencode/memory/project/codebase/ documents
+// (similar to GSD's .planning/codebase/ approach)
+```
+
+## Phase 4: Verification & Security
+
+### 4.1 Verify Documents Created
+
+```bash
+ls -la .opencode/memory/project/
+wc -l .opencode/memory/project/*.md
+```
+
+**Check:**
+
+- [ ] project.md exists and >20 lines
+- [ ] roadmap.md exists and >20 lines
+- [ ] state.md exists and >20 lines
+- [ ] All files are readable
+
+### 4.2 Secret Scan (Critical - from GSD pattern)
+
+```bash
+# Scan for accidentally leaked secrets in generated docs
+grep -E '(sk-[a-zA-Z0-9]{20,}|sk_live_[a-zA-Z0-9]+|AKIA[A-Z0-9]{16}|ghp_[a-zA-Z0-9]{36}|-----BEGIN.*PRIVATE KEY)' .opencode/memory/project/*.md 2>/dev/null && SECRETS_FOUND=true || SECRETS_FOUND=false
+```
+
+**If secrets found:** Alert user and pause before proceeding.
+
+### 4.3 Load Verification Skill
+
+```typescript
+skill({ name: "verification-before-completion" });
+
+// Run verification checklist:
+// 1. IDENTIFY: Files created, structure valid
+// 2. RUN: Validation commands
+// 3. READ: Check file contents
+// 4. VERIFY: All success criteria met
+// 5. CLAIM: Context initialization complete
+```
+
+## Phase 5: Beads Integration
+
+### 5.1 Create Initialization Bead (optional)
+
+```bash
+# If user wants to track context setup as a bead
+br create "Initialize project context" --type=task
+br update <bead-id> --status closed --reason="Context files created"
+```
+
+## Output
+
+Creates optional planning context in `.opencode/memory/project/`:
+
+| File         | Purpose                                  | Lines (typical) |
+| ------------ | ---------------------------------------- | --------------- |
+| `project.md` | Vision, success criteria, principles     | 50-100          |
+| `roadmap.md` | Phases, milestones, bead planning        | 80-150          |
+| `state.md`   | Current position, blockers, next actions | 60-100          |
+
+**If `--brownfield`:**
+Additional files in `.opencode/memory/project/codebase/`:
+
+- `tech-analysis.md` - Stack and dependencies
+- `arch-analysis.md` - Architecture patterns
+
+## Success Criteria
+
+- [ ] All `/init-context` planning documents created from templates
+- [ ] Documents follow template structure
+- [ ] No secrets leaked in generated files
+- [ ] Files pass basic validation (readable, non-empty)
+- [ ] User informed of next steps
+
+## Phase 6: Custom Context (Optional)
+
+Inform user about `.opencode/context/` for additional project-specific context:
+
+```
+Custom context folder available at .opencode/context/
+- Add .md files with architecture decisions, domain knowledge, team agreements
+- Add file paths to opencode.json → instructions[] for AI prompt injection
+- This folder is preserved during init --force and upgrade
+```
+
+## Next Steps
+
+After init-context completes:
+
+1. **For new projects:** Use `/plan` to create first implementation plan
+2. **For brownfield:** Review codebase analysis, then `/plan`
+3. **For existing beads:** Use `/resume` to continue tracked work
+4. **For custom context:** Add `.md` files to `.opencode/context/` and reference in `opencode.json` instructions
+
+---
+
+## Skill Integration Summary
+
+| Skill                            | When Used                         | Purpose                        |
+| -------------------------------- | --------------------------------- | ------------------------------ |
+| `brainstorming`                  | Phase 2 (if not --skip-questions) | Refine vision and requirements |
+| `swarm-coordination`             | Phase 1.2 (if --brownfield)       | Parallel codebase analysis     |
+| `verification-before-completion` | Phase 4                           | Validate created files         |
+| `beads`                          | Phase 5                           | Track as bead if desired       |

package/baseline/command/init-user.md

@@ -0,0 +1,105 @@
+---
+description: Create user profile for personalized AI interactions
+argument-hint: "[--skip-questions]"
+agent: build
+---
+
+# Init-User: $ARGUMENTS
+
+Create personalized user profile. Optional but recommended for better AI responses.
+
+> **Prerequisite:** Run `/init` first for core setup
+> **Related:** `/init-context` for project planning setup
+
+## Load Skills
+
+```typescript
+skill({ name: "memory-system" });
+```
+
+## Options
+
+| Argument           | Default | Description                         |
+| ------------------ | ------- | ----------------------------------- |
+| `--skip-questions` | false   | Infer from git config, skip prompts |
+
+## Phase 1: Gather Preferences
+
+Unless `--skip-questions`, ask in one message:
+
+1. **Identity**: "Which git contributor are you?" (show top 5 from `git shortlog -sn --all`)
+2. **Communication**: "Terse or detailed responses?"
+3. **Workflow**: "Auto-commit or ask-first?"
+4. **Rules**: "Any rules I should always follow?"
+5. **Technical**: "Preferred languages/frameworks?"
+
+If skipped, infer from `git config user.name` and `git config user.email`.
+
+## Phase 2: Create user.md
+
+From template `.opencode/memory/_templates/user.md`:
+
+```bash
+cp .opencode/memory/_templates/user.md .opencode/memory/project/user.md
+```
+
+Fill in gathered answers:
+
+```markdown
+---
+purpose: User identity, preferences, communication style
+updated: [today]
+---
+
+# User Profile
+
+## Identity
+
+- Name: [from answers]
+- Git email: [user.email]
+
+## Communication Preferences
+
+- Style: [Terse/Detailed]
+- Tone: [Professional/Casual]
+
+## Workflow Preferences
+
+- Git commits: [Auto/Ask-first]
+- Beads updates: [Auto/Ask-first]
+
+## Technical Preferences
+
+- Languages/frameworks: [Preferred languages/frameworks]
+
+## Things to Remember
+
+- [Rule 1]
+- [Rule 2]
+- [Rule 3]
+```
+
+## Phase 3: Update opencode.json
+
+Ensure `user.md` is loaded in `instructions` (bare paths, no `file://` prefix).
+
+`tech-stack.md` is the core project memory file. Other files such as `project.md`, `roadmap.md`, `state.md`, and `gotchas.md` are optional/project-specific and should only be added if they actually exist and you want them injected.
+
+Example minimal setup:
+
+```json
+{
+  "instructions": [".opencode/memory/project/user.md", ".opencode/memory/project/tech-stack.md"]
+}
+```
+
+## Phase 4: Report
+
+Output:
+
+1. user.md created at `.opencode/memory/project/user.md`
+2. Preferences captured
+3. `tech-stack.md` is the only required project memory file by default
+4. Additional project memory files are optional and can be added later
+5. Custom context available at `.opencode/context/` (preserved during init --force and upgrade)
+6. Next step: `/init-context` if the user wants fuller project-planning memory files

package/baseline/command/init.md

@@ -0,0 +1,117 @@
+---
+description: Initialize core project setup (AGENTS.md + tech-stack detection only)
+argument-hint: "[--deep]"
+agent: build
+---
+
+# Init: $ARGUMENTS
+
+Core project setup. Creates AGENTS.md and detects tech stack. Run once per project.
+
+> **Next steps:** `/init-user` for personalization, `/init-context` for GSD planning workflow
+
+## Load Skills
+
+```typescript
+skill({ name: "index-knowledge" });
+```
+
+## Options
+
+| Argument | Default | Description                               |
+| -------- | ------- | ----------------------------------------- |
+| `--deep` | false   | Comprehensive research (~100+ tool calls) |
+
+## Phase 1: Detect Project
+
+Detect and validate:
+
+- Package manager and dependencies (with versions)
+- Build, test, lint, dev commands — **validate each actually works**
+- CI/CD configuration
+- Existing AI rules (`.cursor/rules/`, `.cursorrules`, `.github/copilot-instructions.md`)
+- Top-level directory structure
+
+With `--deep`: Also analyze git history, source patterns, subsystem candidates.
+
+## Phase 2: Preview Detection
+
+After detecting project, show summary and ask for confirmation:
+
+```typescript
+question({
+  questions: [
+    {
+      header: "Preview",
+      question: `Detected: ${detectedTechStack}. Create AGENTS.md?`,
+      options: [
+        { label: "Yes, create it (Recommended)" },
+        { label: "Show me what you'll write first" },
+        { label: "Cancel" },
+      ],
+    },
+  ],
+});
+```
+
+**If "Show me":** Display detected values without writing files, then ask again.
+
+## Phase 3: Create AGENTS.md
+
+Create `./AGENTS.md` — **target <60 lines** (max 150). Follow the `index-knowledge` skill format:
+
+- Tech stack with versions
+- File structure
+- Commands (validated)
+- Code example from actual codebase (5-10 lines)
+- Testing conventions
+- Boundaries (always/ask-first/never)
+- Gotchas
+
+**Principles**: Examples > explanations. Pointers > copies. If AGENTS.md exists, improve it — don't overwrite blindly.
+
+## Phase 4: Create tech-stack.md
+
+From template `.opencode/memory/_templates/tech-stack.md`:
+
+```bash
+cp .opencode/memory/_templates/tech-stack.md .opencode/memory/project/tech-stack.md
+```
+
+Fill detected values:
+
+- Framework, language, runtime
+- Styling, components, design system
+- Database, ORM, state management
+- Testing tools
+- Verification commands
+
+## Phase 5: Subsystems (--deep only)
+
+Identify candidates for nested AGENTS.md:
+
+- `packages/*/` in monorepos
+- `frontend/` vs `backend/` directories
+- Significantly different subsystem patterns
+
+Ask user before creating nested files.
+
+## Phase 6: Verify and Report
+
+Verify:
+
+- [ ] AGENTS.md is <60 lines (or justified)
+- [ ] Commands validated and work
+- [ ] Boundaries include Never rules
+- [ ] Code example from actual codebase
+- [ ] tech-stack.md created
+
+Output:
+
+1. Files created (with line counts)
+2. Tech stack detected
+3. Commands validated (yes/no)
+4. Suggested next steps:
+   - `/init-user` — Create user profile
+   - `/init-context` — Set up GSD planning workflow
+   - `/review-codebase` — Deep codebase analysis

package/baseline/command/lfg.md

@@ -0,0 +1,170 @@
+---
+description: Full autonomous chain - Plan → Ship → Review → Compound in one command
+argument-hint: "<bead-id> [--skip-plan]"
+---
+
+# LFG (Let's Fucking Go): $ARGUMENTS
+
+Full compound engineering cycle. One command, all four steps.
+
+> **When to use:** You have a bead in `in_progress` state with a PRD. You want maximum autonomous execution with minimum hand-holding.
+>
+> **Checkpoints happen** at decision points. Everything automatable is automated.
+
+## Parse Arguments
+
+| Argument      | Default  | Description                             |
+| ------------- | -------- | --------------------------------------- |
+| `<bead-id>`   | required | The bead to execute                     |
+| `--skip-plan` | false    | Skip planning if plan.md already exists |
+
+## Phase 0: Preflight
+
+```bash
+br show $BEAD_ID
+ls .beads/artifacts/$BEAD_ID/
+```
+
+Verify:
+
+- Bead exists and is `in_progress`
+- `prd.md` exists
+- If `plan.md` exists and `--skip-plan` not set: ask user whether to replan or use existing
+
+Report:
+
+```
+## LFG: <bead-id> — <title>
+
+Cycle: Plan → Ship → Review → Compound
+Review mode: [Standard 3-agent / Deep 5-agent]
+Plan: [create new / use existing]
+```
+
+## Step 1: PLAN
+
+Load and execute the `/plan` command for this bead:
+
+```typescript
+skill({ name: "writing-plans" });
+// Run full /plan flow including Phase 0 institutional research
+// Output: .beads/artifacts/$BEAD_ID/plan.md
+```
+
+Checkpoint if plan has major unknowns or architecture questions. Otherwise proceed automatically.
+
+## Step 2: WORK
+
+Execute the plan:
+
+```typescript
+skill({ name: "executing-plans" });
+// Load plan.md, execute wave-by-wave
+// Per-task commits after each task passes verification
+```
+
+Follow the [Verification Protocol](../skill/verification-before-completion/references/VERIFICATION_PROTOCOL.md):
+
+- Use **full mode** for final verification
+- Use **incremental mode** between implementation waves
+
+Checkpoint only at `checkpoint:human-verify` or `checkpoint:decision` tasks.
+
+## Step 3: REVIEW
+
+```bash
+BASE_SHA=$(git rev-parse origin/main 2>/dev/null || git rev-parse HEAD~$(git log --oneline | wc -l | tr -d ' '))
+HEAD_SHA=$(git rev-parse HEAD)
+```
+
+Load and run the review skill:
+
+```typescript
+skill({ name: "requesting-code-review" });
+```
+
+Dispatch 5 specialized agents in parallel.
+
+Wait for all agents to return. Synthesize findings.
+
+**Auto-fix rule:**
+
+- Critical issues → fix inline, re-verify, continue
+- Important issues → fix inline, continue
+- Minor issues → add to bead comments, continue
+
+If Critical issues cannot be auto-fixed:
+
+```
+## CHECKPOINT: Review Blocker
+
+Critical issue found that requires architectural decision:
+[description]
+
+Options:
+1. [option A]
+2. [option B]
+
+Awaiting your decision before continuing.
+```
+
+## Step 4: COMPOUND
+
+Load and run the compound command:
+
+```typescript
+// Run /compound $BEAD_ID
+// Extract learnings from the full cycle
+// Store observations to memory
+// Suggest AGENTS.md updates if conventions changed
+```
+
+## Step 5: Report & Next
+
+```
+## LFG Complete: <bead-id>
+
+### Cycle Summary
+
+| Step     | Status | Notes                        |
+|----------|--------|------------------------------|
+| Plan     | ✓      | [N] waves, [M] tasks         |
+| Work     | ✓      | [N] commits, [M] files       |
+| Review   | ✓      | [N] agents, [M] fixes        |
+| Compound | ✓      | [N] observations stored      |
+
+### Learnings Captured
+[list of observation titles]
+
+### Verification
+- typecheck: pass
+- lint: pass
+- tests: pass ([N] passing)
+
+### Next Steps
+- Review the changes: `git diff origin/main`
+- Create PR: `/pr`
+- Or continue with next bead: `/lfg <next-bead-id>`
+```
+
+## Swarm Mode (sLFG)
+
+For large plans with 6+ independent tasks, run Work step in swarm mode:
+
+```typescript
+skill({ name: "swarm-coordination" });
+// Dispatch parallel worker agents per wave
+// Leader monitors and synthesizes
+```
+
+Use when: plan has 2+ independent waves with no shared file mutations.
+
+## Related Commands
+
+| Need            | Command          |
+| --------------- | ---------------- |
+| Plan only       | `/plan <id>`     |
+| Ship only       | `/ship <id>`     |
+| Review only     | `/review`        |
+| Compound only   | `/compound <id>` |
+| Create PR after | `/pr`            |