@pzy560117/opensuper 0.2.6

package/assets/skills/opensuper/scripts/opensuper-yaml-validate.sh

@@ -0,0 +1,157 @@
+#!/bin/bash
+# OpenSuper YAML Schema Validator — validates .opensuper.yaml structure
+# Usage: opensuper-yaml-validate.sh <change-name>
+# Exit 0 = valid, exit 1 = errors found (printed to stderr)
+
+set -euo pipefail
+
+red()   { echo -e "\033[31m$1\033[0m" >&2; }
+green() { echo -e "\033[32m$1\033[0m" >&2; }
+warn()  { echo -e "\033[33m$1\033[0m" >&2; }
+
+# Input validation - prevent path traversal
+validate_change_name() {
+  local name="$1"
+  # Reject empty names
+  if [ -z "$name" ]; then
+    red "ERROR: Change name cannot be empty" >&2
+    exit 1
+  fi
+  # Only allow alphanumeric, hyphens, and underscores
+  if [[ ! "$name" =~ ^[a-zA-Z0-9_-]+$ ]]; then
+    red "ERROR: Invalid change name: '$name'" >&2
+    red "Valid characters: a-z, A-Z, 0-9, -, _" >&2
+    exit 1
+  fi
+  # Reject path traversal attempts
+  if [[ "$name" =~ \.\. ]]; then
+    red "ERROR: Change name cannot contain '..' (path traversal not allowed)" >&2
+    exit 1
+  fi
+}
+
+validate_change_name "$1"
+
+CHANGE="$1"
+CHANGE_DIR="openspec/changes/$CHANGE"
+if [ ! -d "$CHANGE_DIR" ] && [ -d "openspec/changes/archive/$CHANGE" ]; then
+  CHANGE_DIR="openspec/changes/archive/$CHANGE"
+fi
+YAML="$CHANGE_DIR/.opensuper.yaml"
+
+ERRORS=0
+WARNINGS=0
+
+# Helper: get value of a top-level field (handles null, empty, quoted)
+field_value() {
+  local value
+  value=$(grep "^${1}:" "$YAML" 2>/dev/null | sed "s/^${1}: *//" || true)
+  strip_wrapping_quotes "$value"
+}
+
+strip_wrapping_quotes() {
+  local value="$1"
+  case "$value" in
+    \"*\")
+      printf '%s\n' "${value:1:${#value}-2}"
+      ;;
+    \'*\')
+      printf '%s\n' "${value:1:${#value}-2}"
+      ;;
+    *)
+      printf '%s\n' "$value"
+      ;;
+  esac
+}
+
+fail()  { red "  FAIL: $1"; ERRORS=$((ERRORS + 1)); }
+warn_msg() { warn "  WARN: $1"; WARNINGS=$((WARNINGS + 1)); }
+
+echo "[VALIDATE] $YAML" >&2
+
+# --- Required fields ---
+REQUIRED_FIELDS="workflow phase design_doc plan build_mode isolation verify_mode verify_result verified_at archived"
+for field in $REQUIRED_FIELDS; do
+  if ! grep -q "^${field}:" "$YAML" 2>/dev/null; then
+    fail "missing required field '$field'"
+  fi
+done
+
+# --- Enum validation ---
+validate_enum() {
+  local field="$1" value="$2"
+  shift 2
+  local valid_values="$*"
+
+  # null or empty is always acceptable
+  if [ -z "$value" ] || [ "$value" = "null" ]; then
+    return 0
+  fi
+
+  for v in $valid_values; do
+    if [ "$value" = "$v" ]; then
+      return 0
+    fi
+  done
+  fail "$field='$value' is not valid. Expected: $valid_values"
+}
+
+workflow=$(field_value "workflow")
+phase=$(field_value "phase")
+build_mode=$(field_value "build_mode")
+isolation=$(field_value "isolation")
+verify_mode=$(field_value "verify_mode")
+verify_result=$(field_value "verify_result")
+branch_status=$(field_value "branch_status")
+archived=$(field_value "archived")
+direct_override=$(field_value "direct_override")
+design_doc=$(field_value "design_doc")
+plan=$(field_value "plan")
+
+validate_enum "workflow"      "$workflow"      "full hotfix tweak"
+validate_enum "phase"         "$phase"          "open design build verify archive"
+validate_enum "build_mode"    "$build_mode"     "subagent-driven-development executing-plans direct"
+validate_enum "isolation"     "$isolation"      "branch worktree"
+validate_enum "verify_mode"   "$verify_mode"    "light full"
+validate_enum "verify_result" "$verify_result"  "pending pass fail"
+validate_enum "branch_status" "$branch_status"  "pending handled"
+validate_enum "archived"      "$archived"       "true false"
+validate_enum "direct_override" "$direct_override" "true false"
+
+# --- Path validation ---
+
+if [ -n "$design_doc" ] && [ "$design_doc" != "null" ]; then
+  if [ ! -f "$design_doc" ]; then
+    fail "design_doc='$design_doc' does not exist on disk"
+  fi
+fi
+
+if [ -n "$plan" ] && [ "$plan" != "null" ]; then
+  if [ ! -f "$plan" ]; then
+    fail "plan='$plan' does not exist on disk"
+  fi
+fi
+
+# --- Unknown keys check ---
+KNOWN_KEYS="workflow phase design_doc plan build_mode isolation verify_mode verify_result verification_report branch_status verified_at archived direct_override build_command verify_command"
+while IFS=: read -r key _; do
+  key="${key// /}"
+  [ -z "$key" ] && continue
+  found=0
+  for known in $KNOWN_KEYS; do
+    [ "$key" = "$known" ] && found=1 && break
+  done
+  if [ "$found" -eq 0 ]; then
+    warn_msg "unknown field '$key' found"
+  fi
+done < "$YAML"
+
+# --- Summary ---
+echo "" >&2
+if [ "$ERRORS" -gt 0 ]; then
+  red "$ERRORS error(s), $WARNINGS warning(s) — validation FAILED"
+  exit 1
+else
+  green "0 errors, $WARNINGS warning(s) — validation PASSED"
+  exit 0
+fi

package/assets/skills/opensuper-archive/SKILL.md

@@ -0,0 +1,69 @@
+---
+name: opensuper-archive
+description: "OpenSuper Phase 5: Archive. Invoke with /opensuper-archive. Sync delta spec to main spec, archive change."
+---
+
+# OpenSuper Phase 5: Archive (Archive)
+
+## Prerequisites
+
+- Verification passed (Phase 4 complete)
+- Branch handled
+- `verify_result: pass` in `openspec/changes/<name>/.opensuper.yaml`
+
+## Steps
+
+### 0. Entry State Verification (Entry Check)
+
+Execute entry verification:
+
+```bash
+OPENSUPER_SEARCH_ROOTS=("." "$HOME/.claude/skills" "$HOME/.codex/skills" "$HOME/.cursor/skills")
+OPENSUPER_STATE="${OPENSUPER_STATE:-$(find "${OPENSUPER_SEARCH_ROOTS[@]}" -path '*/opensuper/scripts/opensuper-state.sh' -type f -print -quit 2>/dev/null)}"
+bash "$OPENSUPER_STATE" check <name> archive
+```
+
+Proceed to Step 1 after verification passes. The script outputs specific failure reasons when verification fails.
+
+### 1. Execute Archive
+
+Run the archive script to automatically complete all steps:
+
+```bash
+bash "$OPENSUPER_ARCHIVE" "<change-name>"
+```
+
+The script automatically executes:
+1. Entry state validation (phase=archive, verify_result=pass, archived=false)
+2. Delta spec sync to main spec (overwrite)
+3. Design doc frontmatter annotation (archived-with, status)
+4. Plan frontmatter annotation (archived-with)
+5. Move change to archive directory
+6. Update `archived: true` through `opensuper-state transition <archive-name> archived`
+
+If script returns non-zero exit code, report error and stop.
+If script returns zero exit code, archive is complete.
+The summary `X/Y steps succeeded` counts real executed steps and does not double-count delta spec sync or document annotation.
+
+When a delta spec differs from an existing main spec, the script prints a unified diff before overwrite so the archive sync content is visible.
+
+Use `--dry-run` flag to preview without executing.
+
+### 2. Lifecycle Closed Loop
+
+Spec lifecycle completes here:
+```
+brainstorming → delta spec → implementation → verification → main spec overwrite → design doc annotation → archive
+```
+
+## Exit Conditions
+
+- Archive script executed successfully (exit code 0)
+- Archive directory `openspec/changes/archive/YYYY-MM-DD-<change-name>/` exists
+- Archived `.opensuper.yaml` contains `archived: true`
+
+The archive script moves `openspec/changes/<name>/` to `openspec/changes/archive/YYYY-MM-DD-<name>/`. After successful archive, do not run `bash "$OPENSUPER_GUARD" <change-name> archive` against the old active change name; the active directory no longer exists. Archive completeness is determined by the script exit code and archived directory state.
+
+## Complete
+
+OpenSuper workflow complete. To start new work, invoke `/opensuper` or `/opensuper-open`.

package/assets/skills/opensuper-build/SKILL.md

@@ -0,0 +1,194 @@
+---
+name: opensuper-build
+description: "OpenSuper Phase 3: Plan and Build. Invoke with /opensuper-build. Create plans and choose execution method (subagent or direct) for implementation."
+---
+
+# OpenSuper Phase 3: Plan and Build (Build)
+
+## Prerequisites
+
+- Design Doc has been created (Phase 2 complete)
+- Active change exists
+
+## Steps
+
+### 0. Entry State Verification (Entry Check)
+
+Execute entry verification:
+
+```bash
+OPENSUPER_SEARCH_ROOTS=("." "$HOME/.claude/skills" "$HOME/.codex/skills" "$HOME/.cursor/skills")
+OPENSUPER_STATE="${OPENSUPER_STATE:-$(find "${OPENSUPER_SEARCH_ROOTS[@]}" -path '*/opensuper/scripts/opensuper-state.sh' -type f -print -quit 2>/dev/null)}"
+OPENSUPER_GUARD="${OPENSUPER_GUARD:-$(find "${OPENSUPER_SEARCH_ROOTS[@]}" -path '*/opensuper/scripts/opensuper-guard.sh' -type f -print -quit 2>/dev/null)}"
+bash "$OPENSUPER_STATE" check <name> build
+```
+
+Proceed to Step 1 after verification passes. The script outputs specific failure reasons when verification fails.
+
+### 1. Create Plan
+
+**Immediately execute:** Use the Skill tool to load the `superpowers:writing-plans` skill. Skipping this step is prohibited.
+
+After the skill loads, follow its guidance to create a plan. Plan requirements:
+- Save to `docs/superpowers/plans/YYYY-MM-DD-<feature>.md`
+- Reference design document, break down into executable tasks
+- **Plan file header must contain associated metadata**:
+
+```yaml
+---
+change: <openspec-change-name>
+design-doc: docs/superpowers/specs/YYYY-MM-DD-<topic>-design.md
+base-ref: <git rev-parse HEAD before implementation>
+---
+```
+
+`base-ref` is used during verification to measure committed changes across the full implementation range. Record the current commit when creating the plan:
+
+```bash
+git rev-parse HEAD
+```
+
+### 2. Update Plan Status
+
+Record plan path:
+
+```bash
+bash "$OPENSUPER_STATE" set <name> plan docs/superpowers/plans/YYYY-MM-DD-feature.md
+```
+
+No manual phase update needed — guard auto-transitions when exit conditions are met.
+
+### 3. Workspace Isolation
+
+Plan has been written to the current branch. Before starting execution, choose workspace isolation method:
+
+| Option | Method | Description |
+|--------|--------|-------------|
+| A | Create branch | Create a new branch in the current repo, simple and fast |
+| B | Create Worktree | Isolated workspace, fully independent, suitable for parallel development |
+
+**Recommendation rules**:
+- Change involves ≤ 3 files → Recommend A
+- Need parallel development, current branch has uncommitted work → Recommend B
+
+After user selection, update `isolation` field. `isolation` only allows one of the following values:
+
+```bash
+bash "$OPENSUPER_STATE" set <name> isolation <value>
+```
+
+- `branch`
+- `worktree`
+
+<IMPORTANT>
+This is a script-enforced hard constraint, not a suggestion. Full workflow init may temporarily leave `isolation` as `null`, but only before this step.
+Before implementation starts, stop and ask the user, then write either `branch` or `worktree`. If it remains `null`, both the `build → verify` guard and `opensuper-state transition build-complete` will fail.
+</IMPORTANT>
+
+**Execute isolation**:
+
+- **branch**: Run `git checkout -b <change-name>`, subsequent work on the new branch
+- **worktree**: Invoke `superpowers:using-git-worktrees` skill or use native `EnterWorktree` tool to create isolated workspace
+
+After creating isolation, confirm plan file is accessible (naturally accessible with branch method; for worktree method, confirm plan has been committed).
+
+### 4. Select Execution Method
+
+Present plan summary to user (task count, involved modules), then ask for execution method:
+
+| Option | Skill | Applicable Scenario |
+|------|------|-------------------|
+| A | `superpowers:subagent-driven-development` | Independent tasks, high complexity, requires two-phase review |
+| B | `superpowers:executing-plans` | Simple tasks, no subagent environment, lightweight and fast |
+
+**Recommendation rules**:
+- Task count ≥ 3 → Recommend A
+- Task count ≤ 2 and no cross-module dependencies → Recommend B
+- From hotfix path → Recommend B
+
+After user selection, update `build_mode` field. `build_mode` only allows one of the following values:
+
+```bash
+bash "$OPENSUPER_STATE" set <name> build_mode <value>
+```
+
+- `subagent-driven-development`
+- `executing-plans`
+- `direct` (default only for hotfix/tweak preset use)
+
+Full workflow must not default to `direct`. Use it only when the user explicitly asks to bypass the plan execution skills and you record an explicit override:
+
+```bash
+bash "$OPENSUPER_STATE" set <name> direct_override true
+bash "$OPENSUPER_STATE" set <name> build_mode direct
+```
+
+Without `direct_override: true`, `build_mode=direct` in full workflow is blocked by both guard and state transition.
+
+Then, **immediately execute:** Use the Skill tool to load the corresponding skill. Skipping this step is prohibited.
+
+If the selected Superpowers skill is unavailable, stop the process and prompt to install or enable the corresponding skill. Do not substitute this step with normal conversation.
+
+After the skill loads, follow its guidance to execute:
+- Execute tasks according to plan
+- Complete tasks.md check (`- [ ]` → `- [x]`)
+- Commit code after each task completion
+
+### 5. Spec Incremental Updates
+
+When the initial spec is found incomplete during implementation, handle by scale:
+
+| Scale | Trigger Conditions | Approach |
+|------|-------------------|----------|
+| Small | Missing acceptance scenarios, edge cases | Directly edit delta spec + design.md, append tasks.md tasks |
+| Medium | Interface changes, new components, data flow changes | Re-run `superpowers:brainstorming` to update Design Doc + delta spec |
+| Large | Brand-new capability requirements | `/opsx:new` to create independent change |
+
+**50% Threshold Determination**: Using initial task count in tasks.md as baseline, if new tasks exceed half of that total, it's considered outside original plan scope, should consider splitting into new change.
+
+**Principles**:
+- Delta spec is a living document, can be modified at any time during this phase
+- Each update should be committed with commit message explaining the change reason
+- Do not sync to main spec in advance, sync uniformly during archiving
+- For small-scale incremental direct delta spec edits, note in commit message to facilitate design doc drift assessment during archiving
+
+### 6. Context Management
+
+Build is the longest phase and may span many tasks. To support resume after context compaction:
+
+- **After each task**: immediately check off tasks.md and commit code so `.opensuper.yaml` and file state are durable
+- **After context compaction**: read `.opensuper.yaml` to confirm the phase is still build, read the plan header `base-ref`, then read tasks.md to find the next unchecked task
+- **Long task split**: if a single task exceeds 200 lines of code changes, consider splitting it into multiple subtasks and commits
+
+## Exit Conditions
+
+- All tasks.md checked
+- Code committed
+- Project-specific build/tests explicitly run and pass; do not rely only on guard auto-detection
+- `isolation` has been written as `branch` or `worktree`
+- `build_mode` has been written as `subagent-driven-development`, `executing-plans`, or `direct` with explicit override
+- **Phase guard**: Run `bash "$OPENSUPER_GUARD" <change-name> build --apply`; after all PASS, state advances to `phase: verify`
+
+Guard reads project command configuration first:
+
+```yaml
+build_command: <build command>
+verify_command: <verify command>
+```
+
+Configuration can live in the change `.opensuper.yaml`, or in repo-root `.opensuper.yaml` / `opensuper.yaml` / `.opensuper.yml` / `opensuper.yml`.
+Only when no command is configured does guard fall back to `npm run build`, Maven, or Cargo auto-detection. When a command fails, guard prints the command output as evidence for debugging.
+
+Before exit, run guard to auto-transition:
+
+```bash
+bash "$OPENSUPER_GUARD" <change-name> build --apply
+```
+
+State file is automatically updated to `phase: verify`, `verify_result: pending`.
+
+## Automatic Transition
+
+After exit conditions are met, **proceed immediately to the next phase without waiting for user input**:
+
+> **REQUIRED NEXT SKILL:** Invoke `opensuper-verify` skill to enter the verification and completion phase.

package/assets/skills/opensuper-design/SKILL.md

@@ -0,0 +1,84 @@
+---
+name: opensuper-design
+description: "OpenSuper Phase 2: Deep Design. Invoke with /opensuper-design. Produce Design Doc and delta spec through brainstorming."
+---
+
+# OpenSuper Phase 2: Deep Design (Design)
+
+## Prerequisites
+
+- Active change exists (proposal.md, design.md, tasks.md)
+- No Design Doc (no corresponding file under `docs/superpowers/specs/`)
+
+## Steps
+
+### 0. Entry State Verification (Entry Check)
+
+Execute entry verification:
+
+```bash
+OPENSUPER_SEARCH_ROOTS=("." "$HOME/.claude/skills" "$HOME/.codex/skills" "$HOME/.cursor/skills")
+OPENSUPER_STATE="${OPENSUPER_STATE:-$(find "${OPENSUPER_SEARCH_ROOTS[@]}" -path '*/opensuper/scripts/opensuper-state.sh' -type f -print -quit 2>/dev/null)}"
+OPENSUPER_GUARD="${OPENSUPER_GUARD:-$(find "${OPENSUPER_SEARCH_ROOTS[@]}" -path '*/opensuper/scripts/opensuper-guard.sh' -type f -print -quit 2>/dev/null)}"
+bash "$OPENSUPER_STATE" check <name> design
+```
+
+Proceed to Step 1 after verification passes. The script outputs specific failure reasons when verification fails.
+
+### 1a. Read Existing Context
+
+Read `proposal.md` and `design.md` under the active change, organize core content into summaries:
+- **Proposal summary**: goals, motivation, scope
+- **Design summary**: architectural decisions, high-level design
+
+### 1b. Execute Brainstorming (With Context)
+
+**Immediately execute:** Use the Skill tool to load the `superpowers:brainstorming` skill, ARGUMENTS contains:
+
+```
+Change: <change-name>
+Proposal summary: <proposal core content>
+Design summary: <design.md architectural decisions>
+Skip context exploration, proceed directly to design questioning.
+```
+
+Skipping this step is prohibited, and continuing without loading this skill is prohibited.
+
+If `superpowers:brainstorming` is unavailable, stop the process and prompt to install or enable Superpowers skills. Do not substitute this step with normal conversation.
+
+After the skill loads, follow its guidance to produce:
+- `docs/superpowers/specs/YYYY-MM-DD-<topic>-design.md` — design document (technical RFC)
+- `openspec/changes/<name>/specs/<capability>/spec.md` — capability specification (delta)
+
+### 2. Update OpenSuper State
+
+Record design_doc path, then run guard to auto-transition:
+
+```bash
+# Record design_doc path
+bash "$OPENSUPER_STATE" set <name> design_doc docs/superpowers/specs/YYYY-MM-DD-topic-design.md
+
+# Auto-transition to next phase
+bash "$OPENSUPER_GUARD" <change-name> design --apply
+```
+
+State file is updated automatically. No manual editing of other fields required.
+
+## Exit Conditions
+
+- Design Doc has been created and saved
+- Delta spec has been created if there are new capabilities
+- `design_doc` written to `.opensuper.yaml`
+- **Phase guard**: Run `bash "$OPENSUPER_GUARD" <change-name> design --apply`; after all PASS, state advances to `phase: build`
+
+You must use `--apply` before exiting:
+
+```bash
+bash "$OPENSUPER_GUARD" <change-name> design --apply
+```
+
+## Automatic Transition
+
+After exit conditions are met, **proceed immediately to the next phase without waiting for user input**:
+
+> **REQUIRED NEXT SKILL:** Invoke `opensuper-build` skill to enter the planning and build phase.

package/assets/skills/opensuper-hotfix/SKILL.md

@@ -0,0 +1,146 @@
+---
+name: opensuper-hotfix
+description: "OpenSuper preset path: Bug fix / hotfix. Skip brainstorming, directly open → build → verify → archive. Applicable for behavior fixes, scenarios not involving new capability design."
+---
+
+# OpenSuper Preset Path: Hotfix
+
+Quick bug fix workflow: open → build → verify → archive. Skip brainstorming and full plan, applicable for behavior fixes not involving new capability design.
+
+**Applicable conditions** (all must be met):
+1. Fix bugs in existing functionality, no new capability
+2. No interface changes or architecture adjustments
+3. Change scope is predictable (usually ≤ 2 files)
+
+**Not applicable**: If fix process discovers need for architecture adjustments, should upgrade to full `/opensuper` workflow.
+
+---
+
+## Process (preset workflow, 4 phases)
+
+Execution chain: open → build → verify → archive. Hotfix provides default decisions for each phase: streamlined open, direct build, scale-based verification, archive after verification passes.
+
+Locate OpenSuper scripts before starting:
+
+```bash
+OPENSUPER_SEARCH_ROOTS=("." "$HOME/.claude/skills" "$HOME/.codex/skills" "$HOME/.cursor/skills")
+OPENSUPER_STATE="${OPENSUPER_STATE:-$(find "${OPENSUPER_SEARCH_ROOTS[@]}" -path '*/opensuper/scripts/opensuper-state.sh' -type f -print -quit 2>/dev/null)}"
+OPENSUPER_GUARD="${OPENSUPER_GUARD:-$(find "${OPENSUPER_SEARCH_ROOTS[@]}" -path '*/opensuper/scripts/opensuper-guard.sh' -type f -print -quit 2>/dev/null)}"
+OPENSUPER_ARCHIVE="${OPENSUPER_ARCHIVE:-$(find "${OPENSUPER_SEARCH_ROOTS[@]}" -path '*/opensuper/scripts/opensuper-archive.sh' -type f -print -quit 2>/dev/null)}"
+```
+
+### 1. Quick Open (preset open)
+
+Reuse OpenSuper open capability to create change, but use hotfix defaults: do not execute `openspec-explore` long exploration, directly enter streamlined change creation.
+
+**Immediately execute:** Use the Skill tool to load the `openspec-new-change` skill. Skipping this step is prohibited.
+
+After the skill loads, follow its guidance to create streamlined artifacts:
+  - `proposal.md` — problem description + root cause analysis + fix goal (no solution comparison needed)
+  - `design.md` — fix solution (one is enough, no multi-solution comparison needed)
+  - `tasks.md` — fix task list
+- **No delta spec needed** (unless fix changes existing spec acceptance scenarios)
+
+Initialize OpenSuper state file:
+
+```bash
+bash "$OPENSUPER_STATE" init <name> hotfix
+```
+
+Run phase guard to transition open → build:
+
+```bash
+bash "$OPENSUPER_GUARD" <change-name> open --apply
+```
+
+### 2. Direct Build (preset build)
+
+Use hotfix defaults: `build_mode: direct`. Skip `superpowers:brainstorming` and `superpowers:writing-plans` (unless tasks > 3; if exceeds 3 tasks, transfer to `/opensuper-build`'s plan and execution method selection).
+
+**Immediately execute:** Execute tasks one by one according to tasks.md:
+
+1. Read `openspec/changes/<name>/tasks.md`, get incomplete task list
+2. For each incomplete task:
+   - Modify code according to task description
+   - Run project formatter (e.g., `mvn spotless:apply`, `npm run format`)
+   - Run related tests to confirm pass
+   - Check corresponding `- [ ]` to `- [x]` in tasks.md
+   - Commit code, commit message format: `fix: <brief fix description>`
+3. After all tasks complete, explicitly run relevant project tests and build commands
+4. Run phase guard to transition build → verify:
+
+```bash
+bash "$OPENSUPER_GUARD" <change-name> build --apply
+```
+
+State automatically updates to `phase: verify`, `verify_result: pending`, then enter verification.
+
+**If fix affects existing spec acceptance scenarios**:
+- Create delta spec in `openspec/changes/<name>/specs/<capability>/spec.md`
+- Only include `## MODIFIED Requirements` section
+
+### 3a. Hotfix-Exclusive Check: Root Cause Elimination
+
+**Execute before loading opensuper-verify**, ensuring the fix actually eliminates the root cause:
+
+1. Read bug description and root cause in proposal.md
+2. Search and verify problem code no longer exists
+3. If root cause not eliminated, return to Step 2 to continue fix
+
+**Upgrade conditions**:
+- Root cause check reveals deep architecture issues → Stop hotfix, upgrade to `/opensuper`
+- Fix requires additional interface changes → Stop hotfix, upgrade to `/opensuper`
+
+### 3b. Verification (preset verify)
+
+After root cause elimination check passes, reuse `/opensuper-verify`, with opensuper-verify's scale assessment deciding lightweight or full verification.
+
+**Immediately execute:** Use the Skill tool to load the `opensuper-verify` skill. Skipping this step is prohibited.
+
+Small-scale hotfixes without delta spec usually meet lightweight verification conditions (≤ 3 tasks, ≤ 2 files), opensuper-verify's scale assessment will select lightweight verification path (5 quick checks). If hotfix created delta spec, enter full verification path according to opensuper-verify's scale assessment rules.
+
+After verification passes, record `.opensuper.yaml` `verify_result` as `pass` according to `/opensuper-verify` rules, must not skip this status before archiving.
+
+### 4. Archive (preset archive)
+
+Reuse `/opensuper-archive`. Must satisfy `verify_result: pass` in `.opensuper.yaml` before archiving.
+
+**Immediately execute:** Use the Skill tool to load the `opensuper-archive` skill to archive. Skipping this step is prohibited.
+If there is delta spec, sync to main spec according to opensuper-archive rules, and handle associated Design Doc and Plan archiving annotations.
+
+---
+
+## Continuous Execution Mode
+
+<IMPORTANT>
+Hotfix workflow is **one-time continuous execution**. After invoking `/opensuper-hotfix`, agent must automatically complete all 4 phases, without pausing to wait for user input mid-way (unless encountering upgrade conditions requiring user confirmation).
+
+Execution order: quick open → direct build → verification → archive → complete
+
+After each phase completes, immediately enter next phase, no need for user input again. Within each phase, must still call corresponding OpenSuper/OpenSpec/Superpowers skill according to above requirements.
+</IMPORTANT>
+
+---
+
+## Upgrade Conditions
+
+Upgrade to full `/opensuper` when **any** of the following conditions are met:
+
+| Condition | Explanation |
+|-----------|-------------|
+| Change involves **3+ files** | Exceeds single-point fix scope |
+| Architecture changes | New modules, new interfaces, new dependencies |
+| Database schema changes | Structural adjustments |
+| Introduces new public API | Fix creates new external interface |
+| Fix scope exceeds single function/module | Requires coordinated changes |
+
+Upgrade method: On current change basis, supplement Design Doc (execute `/opensuper-design`), then proceed normally with full workflow.
+
+---
+
+## Exit Conditions
+
+- Bug fixed, tests pass
+- Change archived
+- If spec changes, synced to main spec
+- **Phase guard**: Before build → verify run `bash "$OPENSUPER_GUARD" <change-name> build --apply`; before verify → archive follow `/opensuper-verify` and run `bash "$OPENSUPER_GUARD" <change-name> verify --apply`