super-opencode 1.1.0

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

@@ -0,0 +1,105 @@
+---
+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 |
+| :--- | :--- | :--- | :--- |
+| **Performance** | `--focus perf` | `[architect]` | Reduce latency/memory |
+| **Code Quality** | `--focus quality` | `[quality]` | Refactor/Clean Clean |
+| **Security Hardening** | `--focus security` | `[security]` | Patch vulnerabilities |
+| **UX Polish** | `--focus ux` | `[frontend]` | A11y, animations |
+
+## 3. Usage & Arguments
+```bash
+/soc-improve [target] [flags]
+```
+
+### Arguments
+-   **`[target]`**: File or component to optimize.
+
+### Flags
+-   **`--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.
+
+### Phase 2: Plan (The Upgrade)
+-   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.
+
+## 5. Output Guidelines (The Contract)
+
+### Improvement Report
+```markdown
+## Improvement: [Target]
+
+### Focus: [Focus Area]
+
+### Changes Applied
+1.  **Refactor**: Extracted `LargeComponent` into 3 sub-components.
+2.  **Performance**: Memoized calculation of expensive value.
+
+### Metrics
+| Metric | Before | After | Delta |
+| :--- | :--- | :--- | :--- |
+| **Complexity** | 15 | 8 | -47% |
+| **Lines** | 200 | 120 | -40% |
+
+### Verification
+✅ Tests Passed
+```
+
+## 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.
+
+### Skills
+-   **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).
+
+## 8. Boundaries
+
+**Will:**
+-   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.

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

@@ -0,0 +1,99 @@
+---
+description: Project management and orchestration
+---
+
+# /soc-pm
+
+## 1. Command Overview
+The `/soc-pm` command is the "Orchestrator." It manages the high-level state of the project. It uses the PDCA (Plan-Do-Check-Act) cycle to break down complex goals into `tasks`, track progress, and unblock other agents. It is the owner of `task.md`.
+
+## 2. Triggers & Routing
+The command is the primary interface for the `pm-agent`.
+
+| Trigger Scenario | Flag | Target Agent | Action |
+| :--- | :--- | :--- | :--- |
+| **New Project** | `plan` | `[pm-agent]` | Create `task.md` |
+| **Progress Check** | `status` | `[pm-agent]` | Read/Update `task.md` |
+| **Verify Work** | `review` | `[pm-agent]` | Check deliverables |
+
+## 3. Usage & Arguments
+```bash
+/soc-pm [action] [target] [flags]
+```
+
+### Arguments
+-   **`[action]`**: `plan`, `status`, `review`, `checkpoint`.
+-   **`[target]`**: (Optional) Specific feature or milestone.
+
+### Flags
+-   **`--detail`**: Show full task history.
+
+## 4. Behavioral Flow (Orchestration)
+
+### Phase 1: Plan (The Roadmap)
+1.  **Analyze**: Read User Request -> Break into Epics/Stories.
+2.  **Document**: updates `task.md` with checkboxes `[ ]`.
+
+### Phase 2: Do (Tracking)
+-   Monitors tool usage.
+-   Updates task status to `[/]` (In Progress) or `[x]` (Done).
+
+### Phase 3: Check (The Audit)
+-   **Review**: Did we meet the acceptance criteria?
+-   **Reflect**: Use `reflexion` skill if blocked.
+
+## 5. Output Guidelines (The Contract)
+
+### Project Status Report
+```markdown
+## Project Status: [Phase]
+
+### Progress
+-   **Completed**: 3/5 Tasks (60%)
+-   **Current Focus**: Implementing API Auth
+
+### Task List
+-   [x] Setup DB Schema
+-   [/] **Implement Login Route** (Active)
+-   [ ] Write Tests
+
+### Blockers
+-   Waiting for API Key from user.
+```
+
+## 6. Examples
+
+### A. Initial Planning
+```bash
+/soc-pm plan "Build User Dashboard"
+```
+*Effect:* Creates `task.md` with breakdown: "Design UI", "Setup API", "Integrate Frontend".
+
+### B. Status Update
+```bash
+/soc-pm status
+```
+*Effect:* Reads current state and summarizes what has been done vs what is left.
+
+## 7. Dependencies & Capabilities
+
+### Agents
+-   **PM Agent**: `@[.opencode/agents/pm-agent.md]` - Self-referential.
+-   **All Agents**: Delegates work to them.
+
+### Skills
+-   **Reflexion**: `@[.opencode/skills/reflexion/SKILL.md]` - For unblocking the team.
+
+### MCP Integration
+-   **`filesystem`**: Managing `task.md` and `implementation_plan.md`.
+
+## 8. Boundaries
+
+**Will:**
+-   Manage `task.md`.
+-   Delegate tasks to other agents.
+-   Track overall progress.
+
+**Will Not:**
+-   **Write Code**: It manages those who write code.
+-   **Solve Technical Bugs**: It assigns `[backend]` or `[quality]` to solve them.

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

@@ -0,0 +1,105 @@
+---
+description: Deep web research and documentation lookup
+---
+
+# /soc-research
+
+## 1. Command Overview
+The `/soc-research` command is the "Archive." It scours the web and internal docs to find definitive truth. It operates on the "Cite or Die" principle: every claim must optionally be backed by a source. It does not hallucinate; it verifies.
+
+## 2. Triggers & Routing
+The command routes to the `researcher` agent.
+
+| Trigger Scenario | Flag | Target Agent | Tool Used |
+| :--- | :--- | :--- | :--- |
+| **Quick Fact** | `--depth quick` | `[researcher]` | DuckDuckGo/Tavily |
+| **Docs Lookup** | `[topic]` | `[researcher]` | `context7` |
+| **Deep Dive** | `--depth deep` | `[researcher]` | Recursive Search |
+
+## 3. Usage & Arguments
+```bash
+/soc-research [topic] [flags]
+```
+
+### Arguments
+-   **`[topic]`**: The question or technology to investigate.
+
+### Flags
+-   **`--depth [quick|standard|deep]`**: (Default: `standard`).
+-   **`--domain [url]`**: Restrict search to specific site (e.g., `github.com`).
+
+## 4. Behavioral Flow (Orchestration)
+
+### Phase 1: Parsing
+1.  **Decompose**: Break query into keywords.
+2.  **Select**: Choose tool (`tavily` for web, `context7` for docs).
+
+### Phase 2: Execution (The Hunt)
+-   **Broad Search**: Find candidate URLs.
+-   **Deep Read**: Scrape content.
+-   **Synthesize**: Cross-reference facts to find consensus.
+
+### Phase 3: Reporting
+-   Construct "Review of Literature."
+-   Flag conflicting info ("Source A says X, Source B says Y").
+
+## 5. Output Guidelines (The Contract)
+
+### Research Report
+```markdown
+## Research: [Topic]
+
+### Executive Summary
+[Direct Answer]
+
+### Key Findings
+1.  **[Fact 1]**: [Detail]
+    *   *Source*: [Link]
+2.  **[Fact 2]**: [Detail]
+
+### Code Patterns (if applicable)
+```typescript
+// Verified pattern from docs
+const x = new Library();
+```
+
+### Conflicting Info
+-   StackOverflow suggests X, but Official Docs say Y (Deprecated).
+```
+
+## 6. Examples
+
+### A. Library Selection
+```bash
+/soc-research "Best React form library 2025" --depth deep
+```
+*Effect:* Compares React Hook Form vs TanStack Form based on bundle size and weekly downloads.
+
+### B. Bug Hunting
+```bash
+/soc-research "Prisma error P2002" --domain github.com
+```
+*Effect:* Finds specific GitHub issues related to Unique Constraint violations.
+
+## 7. Dependencies & Capabilities
+
+### Agents
+-   **Researcher**: `@[.opencode/agents/researcher.md]` - Primary persona.
+
+### Skills
+-   **Sequential Thinking**: `@[.opencode/skills/sequential-thinking/SKILL.md]` - For resolving conflicts.
+
+### MCP Integration
+-   **`tavily`**: Real-time web search.
+-   **`context7`**: Documentation retrieval.
+
+## 8. Boundaries
+
+**Will:**
+-   Find official documentation.
+-   Summarize community consensus.
+-   Provide direct links.
+
+**Will Not:**
+-   **Execute Info**: It finds the code, but does not run it.
+-   **Make Decisions**: It informs decisions, but `architect` decides.

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

@@ -0,0 +1,102 @@
+---
+description: Code review and quality assessment
+---
+
+# /soc-review
+
+## 1. Command Overview
+The `/soc-review` command is the "Critic." It acts as a second pair of eyes before code is merged. It checks for logic errors, security vulnerabilities (OWASP), and adherence to the "Intentional Minimalism" design philosophy.
+
+## 2. Triggers & Routing
+The command routes to specialized reviewers.
+
+| Trigger Scenario | Flag | Target Agent | Focus |
+| :--- | :--- | :--- | :--- |
+| **Logic/Bugs** | `--scope full` | `[reviewer]` | Correctness |
+| **Security** | `--security` | `[security]` | Injection, AuthZ |
+| **Style/Lint** | `--quick` | `[reviewer]` | Formatting, Naming |
+
+## 3. Usage & Arguments
+```bash
+/soc-review [target] [flags]
+```
+
+### Arguments
+-   **`[target]`**: File, directory, or Pull Request ID to review.
+
+### Flags
+-   **`--scope [full|quick]`**: (Default: `full`).
+-   **`--security`**: Triggers explicit security scan protocol.
+
+## 4. Behavioral Flow (Orchestration)
+
+### Phase 1: Context Loading
+1.  **Read**: Load the target code.
+2.  **Context**: Load `implementation_plan.md` (to see what was intended).
+
+### Phase 2: Analysis (The Audit)
+-   **Static Analysis**: Grep for "smells" (`any`, `eval`, `console.log`).
+-   **Logic Check**: Trace variable data flow.
+-   **Design Check**: Does it match the Project Persona (Minimalism)?
+
+### Phase 3: Reporting
+-   Categorize findings by Severity (Critical, Warning, Info).
+-   Reject if Critical issues exist.
+
+## 5. Output Guidelines (The Contract)
+
+### Code Review
+```markdown
+## Review: [Target]
+
+### Verdict
+❌ **Changes Requested** (1 Critical Issue)
+
+### Findings
+
+#### 🔴 Critical: SQL Injection
+-   **File**: `src/api/search.ts:15`
+-   **Code**: `db.query("SELECT * FROM users WHERE name = " + req.query.name)`
+-   **Fix**: Use parameterized query `$1`.
+
+#### 🟡 Warning: Performance
+-   **File**: `src/utils.ts:40`
+-   **Issue**: `README.md` parsing is synchronous. Use `fs.promises`.
+
+### Summary
+Solid logic, but the SQL injection must be fixed before merge.
+```
+
+## 6. Examples
+
+### A. Pre-Merge Review
+```bash
+/soc-review src/features/payments --security
+```
+*Effect:* Triggers `security` agent to specifically look for PCI compliance issues and raw secrets.
+
+### B. Quick Sanity Check
+```bash
+/soc-review --quick
+```
+*Effect:* Scans changed files for obvious errors (lint, types) before commit.
+
+## 7. Dependencies & Capabilities
+
+### Agents
+-   **Reviewer**: `@[.opencode/agents/reviewer.md]` - General code quality.
+-   **Security**: `@[.opencode/agents/security.md]` - Vulnerability scanning.
+
+### Skills
+-   **Security Audit**: `@[.opencode/skills/security-audit/SKILL.md]` - Automated checking.
+
+## 8. Boundaries
+
+**Will:**
+-   Point out specific lines of code.
+-   Suggest concrete fixes.
+-   Block "unsafe" code.
+
+**Will Not:**
+-   **Fix the code**: It only comments. Use `/soc-improve` to fix.
+-   **Judge Aesthetics**: Unless it violates "Intentional Minimalism."

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

@@ -0,0 +1,109 @@
+---
+description: Test generation and execution
+---
+
+# /soc-test
+
+## 1. Command Overview
+The `/soc-test` command is the "Quality Gatekeeper." It generates, runs, and reports on tests. It ensures that no code is shipped without verification. It triggers the `quality` agent to write unit, integration, or E2E tests and uses the `reviewer` agent to analyze coverage.
+
+## 2. Triggers & Routing
+The command determines the scope and tool based on the arguments.
+
+| Trigger Scenario | Flag | Target Agent | Tool Used |
+| :--- | :--- | :--- | :--- |
+| **Unit Testing** | `--type unit` | `[quality]` | Jest/Vitest |
+| **Integration** | `--type integration` | `[quality]` | Supertest/Pytest |
+| **E2E Flows** | `--type e2e` | `[quality]` | Playwright/Cypress |
+| **Coverage Check**| `--coverage` | `[reviewer]` | Istanbul/C8 |
+
+## 3. Usage & Arguments
+```bash
+/soc-test [target] [flags]
+```
+
+### Arguments
+-   **`[target]`**: File or directory to test (e.g., `src/utils/math.ts`).
+
+### Flags
+-   **`--type [unit|integration|e2e]`**: (Optional) Default: `unit`.
+-   **`--coverage`**: Generates a coverage report.
+-   **`--watch`**: Runs in watch mode (interactive).
+
+## 4. Behavioral Flow (Orchestration)
+
+### Phase 1: Context & Gap Analysis
+1.  **Read**: Analyzes the source code in `[target]`.
+2.  **Scan**: Checks for existing `.test.ts` or `_test.py` files.
+3.  **Plan**: Identifies missing test cases (Edge cases, Error states, Happy path).
+
+### Phase 2: Generation (The Writer)
+The command prompts the `quality` agent:
+> "Generate **[Type]** tests for **[Target]**.
+> Ensure **[Coverage]**.
+> Mock dependencies: **[External Services]**."
+
+### Phase 3: Execution (The Runner)
+1.  **Run**: Executes the test command (e.g., `npm test`).
+2.  **Report**: Captures `stdout/stderr`.
+3.  **Reflect**: If tests fail, it suggests fixes (or fixes them if in `implement` mode).
+
+## 5. Output Guidelines (The Contract)
+
+### Test Execution Report
+```markdown
+## Test Report: [Target]
+
+### 1. Summary
+-   **Status**: ❌ FAILED (2/10 failed)
+-   **Time**: 1.2s
+
+### 2. Failures
+-   **Test**: `should return 400 on invalid email`
+    -   **Expected**: `400`
+    -   **Received**: `500`
+    -   **Diagnosis**: Unhandled exception in controller.
+
+### 3. Coverage
+-   **Line**: 85%
+-   **Branch**: 70% (Missing: `if (!user)`)
+```
+
+## 6. Examples
+
+### A. Unit Test Generation
+```bash
+/soc-test src/utils/currency.ts --type unit
+```
+*Effect:* Generates `src/utils/currency.test.ts` covering rounding logic and currency codes.
+
+### B. Integration Test
+```bash
+/soc-test src/api/auth --type integration
+```
+*Effect:* Sets up a mock database and tests the `/login` flow including DB persistence.
+
+## 7. Dependencies & Capabilities
+
+### Agents
+-   **Quality Assurance**: `@[.opencode/agents/quality.md]` - Primary agent for test generation.
+-   **Reviewer**: `@[.opencode/agents/reviewer.md]` - For evaluating test coverage and effectiveness.
+
+### Skills
+-   **Self Check**: `@[.opencode/skills/self-check/SKILL.md]` - Verifying test results against requirements.
+-   **Debug Protocol**: `@[.opencode/skills/debug-protocol/SKILL.md]` - Analyzing test failures.
+
+### MCP Integration
+-   **`run_command`**: Executing test runners (Jest, Vitest, Pytest).
+-   **`filesystem`**: processing integration test artifacts or coverage reports.
+
+## 8. Boundaries
+
+**Will:**
+-   Generate standard test files using the project's framework.
+-   Run tests and parse output.
+-   Mock external dependencies (S3, Stripe) to prevent flake.
+
+**Will Not:**
+-   **Guarantee 100% Logic Coverage**: It covers code paths, not necessarily business intent.
+-   **Debug Production**: Tests run in `test` environment only.

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

@@ -0,0 +1,97 @@
+---
+description: Custom workflow creation and execution
+---
+
+# /soc-workflow
+
+## 1. Command Overview
+The `/soc-workflow` command is the "Factory." It allows users to create, list, and run custom sequences of agent commands. It turns a manual, multi-step process (e.g., "Check status -> Pull -> Build -> Deploy") into a single executable command.
+
+## 2. Triggers & Routing
+The command is a meta-orchestrator.
+
+| Trigger Scenario | Flag | Action |
+| :--- | :--- | :--- |
+| **New Automation** | `create` | Templates a new `.md` file in `.agent/workflows/` |
+| **Run Automation** | `run` | Parses and executes the steps in order |
+| **List Available** | `list` | Scans directory for `.md` files |
+
+## 3. Usage & Arguments
+```bash
+/soc-workflow [action] [name]
+```
+
+### Arguments
+-   **`[action]`**: `create`, `run`, `list`, `edit`, `delete`.
+-   **`[name]`**: Name of the workflow (e.g., `deploy`).
+
+## 4. Behavioral Flow (Orchestration)
+
+### Phase 1: Definition (Create)
+1.  **Template**: Creates a standard markdown file with "Steps."
+2.  **Define**: User fills in shell commands or agent commands (`/soc-git`, `/soc-test`).
+
+### Phase 2: Execution (Run)
+1.  **Parse**: Reads the markdown.
+2.  **Step**: Executes step 1.
+3.  **Check**: If step 1 fails, stop (unless `continue_on_error: true`).
+4.  **Next**: Proceed to step 2.
+
+## 5. Output Guidelines (The Contract)
+
+### Workflow Definition (Template)
+```markdown
+---
+description: Deploy to Staging
+---
+# Deploy Staging
+1.  **Test**: `/soc-test --type e2e`
+2.  **Build**: `npm run build`
+3.  **Deploy**: `/soc-git push origin staging`
+```
+
+### Execution Log
+```markdown
+## Workflow: Deploy Staging
+1.  [x] **Test**: Passed (2s)
+2.  [x] **Build**: Passed (15s)
+3.  [x] **Deploy**: Pushed a1b2c3d
+✅ Workflow Complete
+```
+
+## 6. Examples
+
+### A. Create Release Workflow
+```bash
+/soc-workflow create release
+```
+*Effect:* Creates `.agent/workflows/release.md` for the user to edit.
+
+### B. Run Nightly Build
+```bash
+/soc-workflow run nightly
+```
+*Effect:* Runs the sequence defined in `nightly.md`.
+
+## 7. Dependencies & Capabilities
+
+### Agents
+-   **PM Agent**: `@[.opencode/agents/pm-agent.md]` - For oversight.
+
+### Skills
+-   **None**: It relies on other commands.
+
+### MCP Integration
+-   **`filesystem`**: Reading/Writing workflow files.
+-   **`run_command`**: Executing shell steps.
+
+## 8. Boundaries
+
+**Will:**
+-   Execute commands in sequence.
+-   Stop on error.
+-   Pass context between steps.
+
+**Will Not:**
+-   **Auto-Debug**: If a step fails, the workflow just stops.
+-   **Parallize**: Steps are currently sequential only.

package/.opencode/settings.json

@@ -0,0 +1,3 @@
+{
+  "version": "1.1.0"
+}