一人即团队：用 OpenSpec + Superpowers 搭起极简开发工作流

propose → apply → archive
  |          |         |
  v          v         v
创建产物    实现任务   合并规格

[OpenSpec 负责]                     [Superpowers 负责]
 
/opsx:propose
    ↓
生成 proposal / specs / design / tasks
    ↓
架构师审查文档                        brainstorming（自动触发）
    ↓                                    ↓
架构师将文档内容作为上下文，        writing-plans → 自动生成实现计划
告诉 AI "按照这些规格来实现"           ↓
    ↓                               subagent-driven-development
  手动桥接 ──────────────────→       （子代理逐任务执行 TDD）
                                        ↓
                                    finishing-a-development-branch
                                        ↓
架构师回到 OpenSpec 执行 ←──────     实现完成
/opsx:archive

/opsx:propose "创建看板管理系统，包含 Column(name, position) 和 Task(title, description, status) 实体"

# Proposal: Kanban Board System
 
## Summary
Build a kanban board management system with two core entities:
Column and Task, supporting full CRUD operations.
 
## Motivation
Need a lightweight project management tool that supports
task organization across customizable columns.

## ADDED Requirements
 
### Requirement: Column CRUD
The system SHALL support creating, reading, updating,
and deleting board columns.
 
#### Scenario: Create a new column
- GIVEN no column exists with the name "Todo"
- WHEN the user creates a column with name "Todo"
  and position 1
- THEN the column is persisted with the correct
  name and position
 
#### Scenario: Reorder columns
- GIVEN two columns exist: "Todo" (position 1),
  "Done" (position 2)
- WHEN the user updates "Todo" position to 2
- THEN "Todo" has position 2 and "Done" shifts
  to position 1
 
### Requirement: Task CRUD
The system SHALL support creating, reading, updating,
and deleting tasks within columns.
 
#### Scenario: Create a task in a column
- GIVEN a column "Todo" exists
- WHEN the user creates a task with title "Setup DB"
- THEN the task is linked to "Todo" column
  with status "todo"

请帮我实现这个看板系统，技术栈用 Go + SQLite + React。
我已经用 OpenSpec 定义好了需求，规格文档在 openspec/changes/create-kanban/ 目录下。

# Kanban Board Implementation Plan
 
> **For agentic workers:** REQUIRED SUB-SKILL:
> Use superpowers:subagent-driven-development
 
**Goal:** Build a kanban board with Column and Task CRUD,
backed by SQLite, served via Go REST API, rendered in React.
 
**Architecture:** Three-tier - SQLite storage layer,
Go HTTP API layer, React SPA frontend.
 
**Tech Stack:** Go 1.22, SQLite3, gorilla/mux,
React 18, TypeScript, React Testing Library
 
### Task 1: Database Schema & Models
 
**Files:**
- Create: `internal/models/column.go`
- Create: `internal/models/task.go`
- Create: `internal/db/schema.sql`
- Test: `internal/models/column_test.go`
- Test: `internal/models/task_test.go`
 
- [ ] Step 1: Write failing tests for Column model
- [ ] Step 2: Run test to verify it fails (RED)
- [ ] Step 3: Write minimal Column model implementation
- [ ] Step 4: Run test to verify it passes (GREEN)
- [ ] Step 5: Repeat for Task model
- [ ] Step 6: Commit
 
### Task 2: Column API Endpoints
...

> **For agentic workers:** REQUIRED SUB-SKILL:
> Use superpowers:subagent-driven-development

package models
 
import (
    "database/sql"
    "os"
    "testing"
 
    _ "github.com/mattn/go-sqlite3"
)
 
func setupTestDB(t *testing.T) *sql.DB {
    t.Helper()
    db, err := sql.Open("sqlite3", ":memory:")
    if err != nil {
        t.Fatalf("Failed to open test db: %v", err)
    }
 
    schema, err := os.ReadFile("../../internal/db/schema.sql")
    if err != nil {
        t.Fatalf("Failed to read schema: %v", err)
    }
    if _, err := db.Exec(string(schema)); err != nil {
        t.Fatalf("Failed to exec schema: %v", err)
    }
    return db
}
 
func TestCreateColumn(t *testing.T) {
    db := setupTestDB(t)
    defer db.Close()
 
    col := &Column{Name: "Todo", Position: 1}
    err := col.Create(db)
    if err != nil {
        t.Fatalf("Create column failed: %v", err)
    }
 
    if col.ID == 0 {
        t.Error("Expected non-zero ID after create")
    }
}

-- internal/db/schema.sql
CREATE TABLE IF NOT EXISTS columns (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    name TEXT NOT NULL,
    position INTEGER NOT NULL DEFAULT 0
);
 
CREATE TABLE IF NOT EXISTS tasks (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    title TEXT NOT NULL,
    description TEXT DEFAULT '',
    status TEXT NOT NULL DEFAULT 'todo',
    column_id INTEGER NOT NULL,
    FOREIGN KEY (column_id) REFERENCES columns(id)
);

// internal/models/column.go
package models
 
import "database/sql"
 
type Column struct {
    ID       int64  `json:"id"`
    Name     string `json:"name"`
    Position int    `json:"position"`
}
 
func (c *Column) Create(db *sql.DB) error {
    result, err := db.Exec(
        "INSERT INTO columns (name, position) VALUES (?, ?)",
        c.Name, c.Position,
    )
    if err != nil {
        return err
    }
    id, _ := result.LastInsertId()
    c.ID = id
    return nil
}

/opsx:propose "在 Task 实体中增加 Priority 字段（High/Medium/Low，默认 Medium）；前端 Card 组件需根据优先级渲染边框颜色"

## MODIFIED Requirements
 
### Requirement: Task Entity
The system SHALL support a Priority field on Task entities.
 
#### Scenario: Create task with explicit priority
- GIVEN a column "Todo" exists
- WHEN the user creates a task with priority "High"
- THEN the task is persisted with priority "High"
 
## ADDED Requirements
 
### Requirement: Priority-Based Card Styling
The system SHALL render task cards with colored borders
based on priority level.
 
#### Scenario: High priority card display
- GIVEN a task with priority "High" exists
- WHEN the kanban board is rendered
- THEN the task card displays a red border

ALTER TABLE tasks ADD COLUMN priority TEXT NOT NULL DEFAULT 'medium';

type Task struct {
    ID          int64  `json:"id"`
    Title       string `json:"title"`
    Description string `json:"description"`
    Status      string `json:"status"`
    Priority    string `json:"priority"` // 新增字段
    ColumnID    int64  `json:"column_id"`
}
 
func isValidPriority(p string) bool {
    return p == "high" || p == "medium" || p == "low"
}

export interface Task {
  id: number;
  title: string;
  description: string;
  status: string;
  priority: "high" | "medium" | "low"; // 新增
  columnId: number;
}

const priorityColors: Record<Task["priority"], string> = {
  high: "#ef4444",
  medium: "#f59e0b",
  low: "#22c55e",
};
 
export const TaskCard: React.FC<{ task: Task }> = ({ task }) => (
  <div style={{ borderLeft: `4px solid ${priorityColors[task.priority]}` }}>
    <h4>{task.title}</h4>
    <p>{task.description}</p>
  </div>
);

func TestCreateTaskWithPriority(t *testing.T) {
    db := setupTestDB(t)
    defer db.Close()
 
    col := &Column{Name: "Todo", Position: 1}
    col.Create(db)
 
    t.Run("explicit priority", func(t *testing.T) {
        task := &Task{
            Title: "Bug fix", Status: "todo",
            Priority: "high", ColumnID: col.ID,
        }
        if err := task.Create(db); err != nil {
            t.Fatalf("Create task failed: %v", err)
        }
        got, _ := GetTask(db, task.ID)
        if got.Priority != "high" {
            t.Errorf("Expected priority 'high', got '%s'", got.Priority)
        }
    })
 
    t.Run("default priority", func(t *testing.T) {
        task := &Task{Title: "Refactor", Status: "todo", ColumnID: col.ID}
        task.Create(db)
        got, _ := GetTask(db, task.ID)
        if got.Priority != "medium" {
            t.Errorf("Expected default 'medium', got '%s'", got.Priority)
        }
    })
 
    t.Run("invalid priority rejected", func(t *testing.T) {
        task := &Task{Title: "Hack", Status: "todo",
            Priority: "urgent", ColumnID: col.ID}
        if err := task.Create(db); err == nil {
            t.Error("Expected error for invalid priority")
        }
    })
}

/opsx:archive add-priority