super-opencode 1.1.2 → 1.2.0

package/.opencode/commands/soc-improve.md

@@ -5,9 +5,11 @@ description: Code improvement and optimization
 # /soc-improve
 
 ## 1. Command Overview
+
 The `/soc-improve` command is the "Optimizer." Unlike `implement` (which builds new things) or `cleanup` (which removes dead things), `improve` makes existing *working* code *better*. It focuses on performance, readability, security, and quality benchmarks.
 
 ## 2. Triggers & Routing
+
 The command routes to specialized agents based on the `--focus` flag.
 
 | Trigger Scenario | Flag | Target Agent | Goal |
@@ -18,35 +20,42 @@ The command routes to specialized agents based on the `--focus` flag.
 | **UX Polish** | `--focus ux` | `[frontend]` | A11y, animations |
 
 ## 3. Usage & Arguments
+
 ```bash
 /soc-improve [target] [flags]
 ```
 
 ### Arguments
--   **`[target]`**: File or component to optimize.
+
+- **`[target]`**: File or component to optimize.
 
 ### Flags
--   **`--focus [perf|quality|security|ux]`**: **MANDATORY**.
--   **`--metric [target]`**: Optional goal (e.g., `< 100ms`).
+
+- **`--focus [perf|quality|security|ux]`**: **MANDATORY**.
+- **`--metric [target]`**: Optional goal (e.g., `< 100ms`).
 
 ## 4. Behavioral Flow (Orchestration)
 
 ### Phase 1: Benchmark (The Baseline)
-1.  **Measure**: Analyze current state (LOC, Complexity, or approximate Perf).
-2.  **Identify**: Find bottlenecks or anti-patterns.
+
+1. **Measure**: Analyze current state (LOC, Complexity, or approximate Perf).
+2. **Identify**: Find bottlenecks or anti-patterns.
 
 ### Phase 2: Plan (The Upgrade)
--   Propose specific refactors.
--   Estimate impact (e.g., "Replacing nested loop will reduce O(n^2) to O(n)").
+
+- Propose specific refactors.
+- Estimate impact (e.g., "Replacing nested loop will reduce O(n^2) to O(n)").
 
 ### Phase 3: Execute (The Refactor)
-1.  **Edit**: Apply changes safely.
-2.  **Verify**: Ensure tests still pass (Regression Check).
-3.  **Compare**: Show Before vs After stats.
+
+1. **Edit**: Apply changes safely.
+2. **Verify**: Ensure tests still pass (Regression Check).
+3. **Compare**: Show Before vs After stats.
 
 ## 5. Output Guidelines (The Contract)
 
 ### Improvement Report
+
 ```markdown
 ## Improvement: [Target]
 
@@ -69,37 +78,50 @@ The command routes to specialized agents based on the `--focus` flag.
 ## 6. Examples
 
 ### A. Performance Tuning
+
 ```bash
 /soc-improve src/utils/sort.ts --focus perf
 ```
+
 *Effect:* Replaces bubble sort with quicksort or uses a native method.
 
 ### B. Security Hardening
+
 ```bash
 /soc-improve src/api/user.ts --focus security
 ```
+
 *Effect:* Adds input validation (Zod) and rate limiting to an existing endpoint.
 
 ## 7. Dependencies & Capabilities
 
 ### Agents
--   **Architect**: `@[.opencode/agents/architect.md]` - Performance strategy.
--   **Quality**: `@[.opencode/agents/quality.md]` - Code structure.
--   **Security**: `@[.opencode/agents/security.md]` - Hardening.
+
+- **Architect**: `@[.opencode/agents/architect.md]` - Performance strategy.
+- **Quality**: `@[.opencode/agents/quality.md]` - Code structure.
+- **Security**: `@[.opencode/agents/security.md]` - Hardening.
 
 ### Skills
--   **Reflexion**: `@[.opencode/skills/reflexion/SKILL.md]` - Ensuring improvements don't break logic.
+
+- **Reflexion**: `@[.opencode/skills/reflexion/SKILL.md]` - Ensuring improvements don't break logic.
 
 ### MCP Integration
--   **`context7`**: Checking for modern language features (e.g., utilizing new node.js APIs).
+
+- **`context7`**: Checking for modern language features (e.g., utilizing new node.js APIs).
 
 ## 8. Boundaries
 
 **Will:**
--   Refactor code structure.
--   Optimize algorithms.
--   Add comments/documentation.
+
+- Refactor code structure.
+- Optimize algorithms.
+- Add comments/documentation.
 
 **Will Not:**
--   **Change Behavior**: The external API/output must remain identical (unless fixing a bug).
--   **Delete Features**: Use `/soc-cleanup` for removal.
+
+- **Change Behavior**: The external API/output must remain identical (unless fixing a bug).
+- **Delete Features**: Use `/soc-cleanup` for removal.
+
+## User Instruction
+
+The user have executed the `/soc-improve` command by parsing the user's arguments provided in `<user-instruction>$ARGUMENTS</user-inference>$ARGUMENTS</user-instruction>`, then route to the appropriate specialized agent based on the extracted `--focus` flag (perf, quality, security, or ux), establish a baseline by measuring current state and identifying bottlenecks or anti-patterns in the specified target, propose specific refactoring or optimization strategies with estimated impact, apply changes safely while ensuring external APIs remain unchanged, verify that tests still pass for regression checking, compare before and after metrics to demonstrate improvement, and generate an improvement report documenting all changes applied and metrics achieved.

package/.opencode/commands/soc-onboard.md

@@ -0,0 +1,329 @@
+---
+description: "Project initialization, tech stack setup, and development environment scaffolding"
+---
+
+# /soc-onboard
+
+## 1. Command Overview
+
+The `/soc-onboard` command is the "Project Bootstrapper." It transforms an empty repository (or vague idea) into a fully-configured development environment ready for the first commit. It handles repository setup, tech stack selection, development environment configuration, and initial project structure scaffolding. This is always the **first command** for any new project.
+
+## 2. Triggers & Routing
+
+The command activates onboarding modes based on project type and maturity.
+
+| Trigger Scenario | Flag | Target Agent | Context Injected |
+| :--- | :--- | :--- | :--- |
+| **New Project** | `--type new` | `[architect]` + `[pm-agent]` | Greenfield setup, Tech selection |
+| **Existing Repo** | `--type existing` | `[architect]` | Analysis, Documentation, Setup |
+| **Team Onboarding** | `--type team` | `[pm-agent]` | Developer guides, Standards, Workflows |
+| **Tech Stack Setup** | `--type stack` | `[architect]` + `[backend]` + `[frontend]` | Framework selection, Configuration |
+
+## 3. Usage & Arguments
+
+```bash
+/soc-onboard [project-name] [flags]
+```
+
+### Arguments
+
+- **`[project-name]`**: Name of the project (e.g., "my-app", "api-service"). Used for repo naming, package naming, etc.
+
+### Flags
+
+- **`--type [new|existing|team|stack]`**: **MANDATORY**. Specifies onboarding phase.
+- **`--template [template]`**: Starter template to use (e.g., "nextjs-fullstack", "express-api", "react-native").
+- **`--stack [stack]`**: Tech stack preset (e.g., "typescript-react-node", "python-fastapi", "go-microservices").
+- **`--package-manager [npm|yarn|pnpm|bun]`**: Package manager preference (auto-detected if not specified).
+- **`--git [true|false]`**: Initialize git repository (default: true).
+- **`--install`**: Automatically install dependencies after setup.
+- **`--ci [provider]`**: CI/CD provider setup (e.g., "github-actions", "gitlab-ci").
+
+## 4. Behavioral Flow (Orchestration)
+
+### Phase 1: Analysis & Planning
+
+#### For New Projects (`--type new`):
+1. **Requirements Gathering**: Ask clarifying questions if stack/template not provided.
+2. **Tech Stack Selection**: Recommend stack based on project type.
+3. **Architecture Preview**: Generate high-level folder structure.
+4. **Package Manager Detection**: Analyze environment and recommend best option.
+
+#### For Existing Repos (`--type existing`):
+1. **Codebase Analysis**: Parse existing structure, identify patterns.
+2. **Documentation Audit**: Check for README, CONTRIBUTING, docs.
+3. **Setup Verification**: Verify dependencies install, tests run, builds succeed.
+4. **Gap Analysis**: Identify missing configuration files, linting, etc.
+
+### Phase 2: Environment Setup
+
+#### Repository Initialization:
+- Create directory structure.
+- Initialize git (if `--git true`).
+- Create `.gitignore` appropriate for stack.
+- Set up branch protection rules template.
+
+#### Tech Stack Configuration:
+- **Frontend**: React/Next.js/Vue config, Tailwind setup, TypeScript.
+- **Backend**: Express/FastAPI/Gin setup, database config, API structure.
+- **Shared**: ESLint, Prettier, TypeScript, Husky pre-commit hooks.
+- **Testing**: Jest/Vitest/Playwright configuration.
+
+#### Package Manager Setup (via `package-manager` skill):
+- Detect available package managers (npm, yarn, pnpm, bun).
+- Check version compatibility.
+- Create lockfile (respecting user's preference).
+- Configure workspace if monorepo detected.
+
+### Phase 3: Documentation & Templates
+
+- **README.md**: Project description, setup instructions, scripts.
+- **CONTRIBUTING.md**: PR process, coding standards, commit conventions.
+- **AGENTS.md**: OpenCode configuration for the project (this is crucial!).
+- **LICENSE**: Template license file.
+- **.env.example**: Environment variable template.
+
+### Phase 4: Verification
+
+- Run initial build to verify setup.
+- Run linting to ensure configuration valid.
+- Run tests (should pass with 0 tests initially).
+- Generate onboarding completion report.
+
+## 5. Output Guidelines (The Contract)
+
+### Project Structure Output
+
+```
+my-app/
+├── .github/
+│   └── workflows/
+│       └── ci.yml              # CI/CD pipeline
+├── .husky/                     # Git hooks
+│   └── pre-commit
+├── .opencode/                  # OpenCode configuration
+│   ├── agents/
+│   │   └── custom-agent.md
+│   └── memory/
+│       └── patterns.md
+├── docs/
+│   ├── ADR/                    # Architecture Decision Records
+│   ├── api/
+│   └── setup.md
+├── src/
+│   ├── components/             # UI components
+│   ├── lib/                    # Utilities, helpers
+│   ├── hooks/                  # Custom React hooks
+│   ├── types/                  # TypeScript types
+│   └── app/                    # App routes/pages
+├── tests/
+│   ├── unit/
+│   └── e2e/
+├── .env.example
+├── .eslintrc.js
+├── .gitignore
+├── .prettierrc
+├── AGENTS.md                   # OpenCode project guide
+├── CONTRIBUTING.md
+├── LICENSE
+├── package.json
+├── README.md
+├── tsconfig.json
+└── vite.config.ts
+```
+
+### Onboarding Report Template
+
+```markdown
+# Project Onboarding Report: [Project Name]
+
+## Summary
+**Type**: New Project  
+**Template**: nextjs-fullstack  
+**Stack**: TypeScript + React + Next.js + Node.js  
+**Package Manager**: pnpm (v8.15.0)  
+**Status**: ✅ COMPLETE
+
+## Tech Stack Details
+
+### Frontend
+- **Framework**: Next.js 14 (App Router)
+- **Language**: TypeScript 5.3
+- **Styling**: Tailwind CSS + shadcn/ui
+- **State**: Zustand + React Query
+- **Testing**: Vitest + React Testing Library + Playwright
+
+### Backend
+- **Runtime**: Node.js 20 LTS
+- **Framework**: Next.js API Routes
+- **Database**: PostgreSQL (Prisma ORM)
+- **Auth**: NextAuth.js
+- **Validation**: Zod
+
+### DevOps
+- **CI/CD**: GitHub Actions
+- **Linting**: ESLint + Prettier
+- **Hooks**: Husky + lint-staged
+- **Type Checking**: TypeScript strict mode
+
+## Package Manager Selection
+**Selected**: pnpm  
+**Rationale**: 
+- ✅ Disk space efficient (content-addressable store)
+- ✅ Fast installation (parallelized)
+- ✅ Strict dependency resolution (prevents phantom deps)
+- ✅ Workspace support built-in
+- ✅ Lockfile reliable and deterministic
+
+**Alternatives Considered**:
+- npm: Slower, larger node_modules
+- yarn: Good but pnpm preferred for monorepos
+- bun: Fast but newer, less ecosystem maturity
+
+## Generated Files
+
+### Configuration
+- ✅ package.json (with scripts)
+- ✅ tsconfig.json (strict mode)
+- ✅ tailwind.config.ts
+- ✅ next.config.js
+- ✅ .eslintrc.js (recommended + typescript)
+- ✅ .prettierrc (consistent formatting)
+- ✅ vite.config.ts (for vitest)
+- ✅ playwright.config.ts
+
+### Project Structure
+- ✅ src/app/ (Next.js app router)
+- ✅ src/components/ui/ (shadcn base)
+- ✅ src/lib/ (utilities)
+- ✅ src/hooks/ (custom hooks)
+- ✅ src/types/ (global types)
+- ✅ tests/unit/ (Vitest tests)
+- ✅ tests/e2e/ (Playwright tests)
+
+### Documentation
+- ✅ README.md (setup, scripts, structure)
+- ✅ CONTRIBUTING.md (PR process, standards)
+- ✅ AGENTS.md (OpenCode configuration)
+- ✅ LICENSE (MIT)
+- ✅ .env.example (environment variables)
+
+### OpenCode Integration
+- ✅ .opencode/agents/ (custom agent definitions)
+- ✅ .opencode/memory/ (project patterns)
+
+## Verification Results
+
+| Check | Command | Status |
+|:------|:--------|:------:|
+| Dependencies Install | pnpm install | ✅ |
+| Type Check | pnpm typecheck | ✅ |
+| Lint | pnpm lint | ✅ |
+| Build | pnpm build | ✅ |
+| Test | pnpm test | ✅ (0 tests) |
+
+## Next Steps
+
+1. **Configure Environment**: Copy `.env.example` to `.env.local` and fill in values.
+2. **Database Setup**: Run `pnpm db:setup` to initialize PostgreSQL.
+3. **First Feature**: Use `/soc-brainstorm` to plan your first feature.
+4. **Team Onboarding**: Share this repo—team members just run `pnpm install`.
+
+## Quick Commands
+
+```bash
+# Development
+pnpm dev              # Start dev server
+pnpm test             # Run unit tests
+pnpm test:e2e         # Run E2E tests
+
+# Code Quality
+pnpm lint             # Run ESLint
+pnpm lint:fix         # Fix auto-fixable issues
+pnpm format           # Run Prettier
+pnpm typecheck        # TypeScript check
+
+# Database
+pnpm db:generate      # Generate Prisma client
+pnpm db:migrate       # Run migrations
+pnpm db:studio        # Open Prisma Studio
+```
+```
+
+## 6. Examples
+
+### A. New Full-Stack Project
+
+```bash
+/soc-onboard "my-saas-app" --type new --template nextjs-fullstack --package-manager pnpm --ci github-actions
+```
+
+*Effect:* Creates complete Next.js 14 project with TypeScript, Tailwind, Prisma, PostgreSQL, NextAuth, testing setup, CI/CD, and OpenCode configuration.
+
+### B. API-Only Project
+
+```bash
+/soc-onboard "payment-api" --type new --stack express-typescript --package-manager npm
+```
+
+*Effect:* Sets up Express.js API with TypeScript, Zod validation, Prisma ORM, Swagger docs, and testing framework.
+
+### C. Existing Repository Analysis
+
+```bash
+/soc-onboard "legacy-project" --type existing
+```
+
+*Effect:* Analyzes existing codebase, identifies tech stack, verifies setup, and generates missing configuration files and documentation.
+
+### D. Team Onboarding Guide
+
+```bash
+/soc-onboard "team-setup" --type team
+```
+
+*Effect:* Creates comprehensive team onboarding documentation: development standards, PR process, architecture overview, and troubleshooting guides.
+
+## 7. Dependencies & Capabilities
+
+### Agents
+
+- **Architecture Lead**: `[architect]` - Tech stack selection and project structure.
+- **PM Coordinator**: `[pm-agent]` - Documentation standards and team workflows.
+- **Backend Setup**: `[backend]` - Server configuration, database setup.
+- **Frontend Setup**: `[frontend]` - UI framework configuration, styling.
+
+### Skills
+
+- **Package Manager**: `@[.opencode/skills/package-manager/SKILL.md]` - **MANDATORY** for detecting and configuring the optimal package manager.
+- **Confidence Check**: `@[.opencode/skills/confidence-check/SKILL.md]` - Validates setup choices.
+- **Self Check**: `@[.opencode/skills/self-check/SKILL.md]` - Verifies everything works after setup.
+
+### MCP Integration
+
+- **`tavily`**: Research latest framework versions and best practices.
+- **`context7`**: Access framework documentation for setup instructions.
+- **`filesystem`**: Create directory structure and files.
+
+## 8. Boundaries
+
+**Will:**
+
+- Initialize new projects with complete tech stack.
+- Analyze and document existing repositories.
+- Set up development environments with proper tooling.
+- Configure package managers (auto-detect or user preference).
+- Generate project documentation (README, CONTRIBUTING, AGENTS.md).
+- Verify setup by running builds and tests.
+
+**Will Not:**
+
+- **Deploy to Production**: Only sets up local development environment.
+- **Write Business Logic**: Creates scaffolding only—no feature implementation.
+- **Choose Without Consent**: Recommends stack but asks for confirmation.
+- **Override Existing Files**: Warns and backs up before overwriting.
+- **Skip Verification**: Always runs checks to ensure setup works.
+
+## User Instruction
+
+The user have executed the `/soc-onboard` command by parsing the user's arguments provided in `<user-instruction>$ARGUMENTS</user-instruction>`, then route to the appropriate onboarding type (new, existing, team, or stack), for new projects: gather requirements, recommend and confirm tech stack, for existing projects: analyze codebase structure and configuration, use the `package-manager` skill to detect and configure the optimal package manager (never assume npm), create complete directory structure with configuration files, set up linting, testing, and CI/CD tooling, generate all documentation (README, CONTRIBUTING, AGENTS.md), initialize git repository with appropriate .gitignore, verify setup by running install, build, lint, and test commands, and generate comprehensive onboarding report with next steps and quick commands.

package/.opencode/commands/soc-plan.md

@@ -0,0 +1,215 @@
+---
+description: "Sprint planning, roadmap creation, and milestone tracking with dependency mapping"
+---
+
+# /soc-plan
+
+## 1. Command Overview
+
+The `/soc-plan` command bridges the gap between **brainstorming** (ideas) and **design** (architecture). It transforms high-level requirements into actionable sprints, milestones, and dependency trees. It is the "Project Navigator" that ensures the right work happens in the right order.
+
+## 2. Triggers & Routing
+
+The command activates specific planning modes based on project phase and scope.
+
+| Trigger Scenario | Flag | Target Agent | Context Injected |
+| :--- | :--- | :--- | :--- |
+| **Sprint Planning** | `--mode sprint` | `[pm-agent]` | User Stories, Capacity, Velocity |
+| **Roadmap Creation** | `--mode roadmap` | `[pm-agent]` + `[architect]` | Quarterly Goals, Tech Debt |
+| **Milestone Tracking** | `--mode milestone` | `[pm-agent]` | Critical Path, Blockers |
+| **Dependency Analysis** | `--mode dependencies` | `[architect]` | Service Dependencies, APIs |
+
+## 3. Usage & Arguments
+
+```bash
+/soc-plan [scope] [flags]
+```
+
+### Arguments
+
+- **`[scope]`**: The planning scope (e.g., "Q1 2026 Features", "User Auth Epic", "v2.0 Release").
+
+### Flags
+
+- **`--mode [sprint|roadmap|milestone|dependencies]`**: **MANDATORY**. Specifies the planning granularity.
+- **`--duration [weeks]`**: Sprint/roadmap duration (default: 2 weeks for sprint, 12 weeks for roadmap).
+- **`--capacity [hours]`**: Team capacity in hours for sprint planning.
+- **`--priority [must|should|could]`**: Filters tasks by MoSCoW priority.
+- **`--output [markdown|json|csv]`**: Output format for the plan (default: markdown).
+
+## 4. Behavioral Flow (Orchestration)
+
+### Phase 1: Context Gathering
+
+1. **Read**: Parse existing `requirements.md`, `task_queue.md`, and `project_status.md`.
+2. **Analyze**: Identify completed work, in-progress items, and pending backlog.
+3. **Constraint Check**: Review technical constraints from `architect` ADRs.
+
+### Phase 2: Planning Generation
+
+#### For Sprint Mode (`--mode sprint`):
+- Break down epics into sprint-sized tasks (≤8 hours each).
+- Assign story points using Fibonacci scale.
+- Calculate velocity based on historical data.
+- Identify dependencies that block sprint completion.
+
+#### For Roadmap Mode (`--mode roadmap`):
+- Map epics to quarters/months.
+- Align technical milestones with business goals.
+- Schedule tech debt reduction sprints.
+- Identify hiring/resource needs.
+
+#### For Dependency Mode (`--mode dependencies`):
+- Map service-to-service dependencies.
+- Identify circular dependencies and coupling.
+- Create critical path visualization.
+- Flag external API dependencies and SLAs.
+
+### Phase 3: Validation & Output
+
+- **Validate**: Check for overloaded sprints (>100% capacity).
+- **Export**: Generate `sprint_plan.md` or `roadmap.md`.
+- **Sync**: Update `project_status.md` with new milestones.
+
+## 5. Output Guidelines (The Contract)
+
+### Sprint Plan Template
+
+```markdown
+# Sprint Plan: [Sprint Name]
+
+## Overview
+**Duration**: [Start Date] - [End Date]  
+**Capacity**: [X] hours  
+**Velocity**: [Y] story points  
+**Goal**: [One-line sprint objective]
+
+## Sprint Backlog
+
+### Must Have (MoSCoW)
+| ID | Task | Story Points | Assignee | Dependencies | Status |
+|:---|:-----|:------------:|:--------:|:-------------|:------:|
+| US-001 | Implement OAuth login | 5 | backend | DB Schema | ⬜ |
+| US-002 | Create login UI | 3 | frontend | US-001 API | ⬜ |
+
+### Should Have
+| ID | Task | Story Points | Assignee | Dependencies | Status |
+|:---|:-----|:------------:|:--------:|:-------------|:------:|
+| US-003 | Add password reset | 3 | backend | Email Service | ⬜ |
+
+### Could Have
+| ID | Task | Story Points | Assignee | Dependencies | Status |
+|:---|:-----|:------------:|:--------:|:-------------|:------:|
+| US-004 | Social login buttons | 2 | frontend | US-002 | ⬜ |
+
+## Risks & Blockers
+- ⚠️ **BLOCKER**: Waiting for AWS account setup (affects US-001)
+- 🟡 **RISK**: Email service API rate limits
+
+## Definition of Done
+- [ ] All "Must Have" tasks completed
+- [ ] Code reviewed and merged
+- [ ] Tests passing (>80% coverage)
+- [ ] Documentation updated
+```
+
+### Roadmap Template
+
+```markdown
+# Product Roadmap: [Project Name]
+
+## Q1 2026: Foundation
+- **Theme**: Core Platform & Auth
+- **Key Deliverables**:
+  - User authentication system
+  - Database schema v1
+  - CI/CD pipeline
+- **Milestone**: Beta Launch (March 15)
+
+## Q2 2026: Growth
+- **Theme**: Features & Scale
+- **Key Deliverables**:
+  - Payment integration
+  - Admin dashboard
+  - Performance optimization
+- **Milestone**: Public Launch (June 1)
+
+## Dependencies Map
+```mermaid
+gantt
+    title Critical Path
+    dateFormat  YYYY-MM-DD
+    section Backend
+    DB Schema      :done, db, 2026-01-01, 5d
+    API Development :active, api, after db, 10d
+    section Frontend
+    UI Components  :ui, after db, 7d
+    Integration    :int, after api, 5d
+```
+```
+
+## 6. Examples
+
+### A. Sprint Planning
+
+```bash
+/soc-plan "User Authentication Epic" --mode sprint --duration 2 --capacity 80
+```
+
+*Effect:* Creates a 2-week sprint plan with tasks broken down from the auth epic, estimated at 80 hours capacity, with dependency chains identified.
+
+### B. Quarterly Roadmap
+
+```bash
+/soc-plan "Q1 2026 Product Roadmap" --mode roadmap --duration 12
+```
+
+*Effect:* Generates a 12-week roadmap with monthly milestones, resource allocation, and tech debt sprints scheduled.
+
+### C. Dependency Analysis
+
+```bash
+/soc-plan "Microservices Architecture" --mode dependencies
+```
+
+*Effect:* Maps all service dependencies, identifies circular dependencies, and creates a critical path diagram.
+
+## 7. Dependencies & Capabilities
+
+### Agents
+
+- **Orchestrator**: `[pm-agent]` - Sprint breakdown, capacity planning, and milestone tracking.
+- **Technical Consultant**: `[architect]` - Dependency mapping and technical feasibility.
+- **Support**: `[backend]`, `[frontend]` - Effort estimation for implementation tasks.
+
+### Skills
+
+- **Sequential Thinking**: `@[.opencode/skills/sequential-thinking/SKILL.md]` - For dependency tree analysis and critical path calculation.
+- **Simplification**: `@[.opencode/skills/simplification/SKILL.md]` - Ensures plans are realistic and not over-committed.
+- **Confidence Check**: `@[.opencode/skills/confidence-check/SKILL.md]` - Validates plan feasibility before commitment.
+
+### MCP Integration
+
+- **`sequential-thinking`**: **MANDATORY** for complex dependency mapping.
+- **`read_file` / `write_file`**: Updates `project_status.md`, `sprint_plan.md`, `roadmap.md`.
+- **`tavily`**: Research industry-standard story point baselines and velocity benchmarks.
+
+## 8. Boundaries
+
+**Will:**
+
+- Create detailed sprint and roadmap documents.
+- Calculate capacity and velocity metrics.
+- Map dependencies and critical paths.
+- Identify risks and blockers.
+
+**Will Not:**
+
+- **Assign Specific People**: Suggests agent types (backend/frontend) but not individual humans.
+- **Guarantee Delivery Dates**: Provides estimates with confidence intervals, not promises.
+- **Ignore Constraints**: Will flag if requested scope exceeds capacity.
+- **Execute Work**: Planning only—use `/soc-implement` for execution.
+
+## User Instruction
+
+The user have executed the `/soc-plan` command by parsing the user's arguments provided in `<user-instruction>$ARGUMENTS</user-instruction>`, then route to the appropriate mode (sprint, roadmap, milestone, or dependencies), read existing project context from `requirements.md`, `task_queue.md`, and `project_status.md`, generate a comprehensive plan document with task breakdowns, estimates, and dependency mapping, validate the plan against capacity constraints and technical feasibility, identify risks and blockers, and output the plan in the requested format while updating `project_status.md` with new milestones and timelines.