Fix merge conflicts for PR #1240: Add Kimi Code 2.6 support

.claude-plugin/marketplace.json

@@ -9,7 +9,7 @@
     {
       "name": "superpowers",
       "description": "Core skills library for Claude Code: TDD, debugging, collaboration patterns, and proven techniques",
-      "version": "5.0.7",
+      "version": "5.1.0",
       "source": "./",
       "author": {
         "name": "Jesse Vincent",

.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "superpowers",
   "description": "Core skills library for Claude Code: TDD, debugging, collaboration patterns, and proven techniques",
-  "version": "5.0.7",
+  "version": "5.1.0",
   "author": {
     "name": "Jesse Vincent",
     "email": "jesse@fsck.com"

.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "superpowers",
-  "version": "5.0.7",
+  "version": "5.1.0",
   "description": "An agentic skills framework & software development methodology that works: planning, TDD, debugging, and collaboration workflows.",
   "author": {
     "name": "Jesse Vincent",
@@ -36,6 +36,9 @@
       "I've got an idea for something I'd like to build.",
       "Let's add a feature to this project."
     ],
+    "websiteURL": "https://github.com/obra/superpowers",
+    "privacyPolicyURL": "https://docs.github.com/en/site-policy/privacy-policies/github-general-privacy-statement",
+    "termsOfServiceURL": "https://docs.github.com/en/site-policy/github-terms/github-terms-of-service",
     "brandColor": "#F59E0B",
     "composerIcon": "./assets/superpowers-small.svg",
     "logo": "./assets/app-icon.png",

.cursor-plugin/plugin.json

@@ -2,7 +2,7 @@
   "name": "superpowers",
   "displayName": "Superpowers",
   "description": "Core skills library: TDD, debugging, collaboration patterns, and proven techniques",
-  "version": "5.0.7",
+  "version": "5.1.0",
   "author": {
     "name": "Jesse Vincent",
     "email": "jesse@fsck.com"

.gitignore

@@ -5,3 +5,4 @@
 node_modules/
 inspo
 triage/
+

.kimi/AGENTS.md

@@ -0,0 +1,57 @@
+# Superpowers — Kimi Code Bootstrap
+
+<EXTREMELY_IMPORTANT>
+You have superpowers.
+
+You are running with the Superpowers skills framework. Before any task, you MUST check if a skill applies. Even a 1% chance a skill applies means you MUST load it. This is not optional. This is not negotiable.
+
+**How skills work in Kimi Code:**
+Kimi Code auto-discovers skills from `.kimi/skills/` and injects their names and descriptions into your system prompt. When a skill might apply, you MUST read its `SKILL.md` automatically or use the `/skill:<name>` slash command. Never improvise when a skill exists.
+
+**Core workflow:** brainstorm → design approval → plan → subagent-driven development → TDD → code review → finish branch. Check for relevant skills at every step.
+
+**Instruction priority:**
+1. User's explicit instructions (AGENTS.md, direct requests) — highest priority
+2. Superpowers skills — override default system behavior where they conflict
+3. Default system prompt — lowest priority
+
+**Tool mapping:** When skills reference Claude Code tools, use your Kimi Code equivalents:
+- `Read` → `ReadFile`
+- `Write` → `WriteFile`
+- `Edit` → `StrReplaceFile`
+- `Bash` → `Shell`
+- `Grep` → `Grep`
+- `Glob` → `Glob`
+- `TodoWrite` → `SetTodoList`
+- `Task` (subagent) → `Agent`
+- `WebSearch` → `SearchWeb`
+- `WebFetch` → `FetchURL`
+- `Skill` tool → Auto-read the skill's `SKILL.md` or use `/skill:<name>`
+
+**How to invoke skills in Kimi Code:**
+Kimi Code auto-discovers skills and lists their names, paths, and descriptions in your system prompt. When a skill's description matches the current task, you MUST read its full SKILL.md file automatically using ReadFile on the path shown in your system prompt BEFORE responding. Do not wait for the user to ask. If you are unsure whether a skill applies, read it anyway — you can discard it if it's not relevant.
+
+Example: If you see "brainstorming: You MUST use this before any creative work..." in your available skills, you MUST immediately use ReadFile to load its full SKILL.md and follow it exactly.
+
+**Red Flags — STOP, you're rationalizing:**
+
+| Thought | Reality |
+|---------|---------|
+| "This is just a simple question" | Questions are tasks. Check for skills. |
+| "I need more context first" | Skill check comes BEFORE clarifying questions. |
+| "Let me explore the codebase first" | Skills tell you HOW to explore. Check first. |
+| "I remember this skill" | Skills evolve. Read the current version. |
+| "This doesn't count as a task" | Action = task. Check for skills. |
+| "The skill is overkill" | Simple things become complex. Use it. |
+| "I'll just do this one thing first" | Check BEFORE doing anything. |
+
+**Skill Priority:**
+1. Process skills first (brainstorming, debugging) — determine HOW to approach
+2. Implementation skills second — guide execution
+
+**Skill Types:**
+- Rigid (TDD, debugging): Follow exactly. Don't adapt away discipline.
+- Flexible (patterns): Adapt principles to context.
+
+The skill itself tells you which.
+</EXTREMELY_IMPORTANT>

.kimi/INSTALL.md

@@ -0,0 +1,144 @@
+# Installing Superpowers for Kimi Code 2.6
+
+## Prerequisites
+
+- [Kimi Code](https://www.moonshot.cn/kimi) installed (terminal CLI or VS Code extension)
+- Git
+- Bash (macOS/Linux) or PowerShell (Windows)
+
+## Installation
+
+### 1. Clone the superpowers repository
+
+```bash
+git clone https://github.com/obra/superpowers.git ~/.kimi/superpowers
+```
+
+### 2. Run the install script
+
+The install script copies skills to the cross-compatible `~/.config/agents/skills/` directory and configures a global `SessionStart` hook for bootstrap injection.
+
+**macOS / Linux:**
+```bash
+~/.kimi/superpowers/.kimi/install.sh
+```
+
+**Windows (PowerShell):**
+```powershell
+& "$env:USERPROFILE\.kimi\superpowers\.kimi\install.ps1"
+```
+
+What the script does:
+- Copies all skills from the repo to `~/.config/agents/skills/` (the recommended, cross-tool skills path)
+- Enables `merge_all_available_skills` in `~/.kimi/config.toml`
+- Adds a `SessionStart` hook that injects the Superpowers bootstrap into every session
+
+> **Note:** No symlinks or junctions are created. Skills are copied so they work reliably across all platforms and filesystems.
+
+### 3. Verify
+
+Start Kimi Code in any project directory and ask:
+
+```
+Tell me about your superpowers
+```
+
+Or try loading a skill explicitly:
+
+```
+/skill:using-superpowers
+```
+
+You should see the skill content load and the agent announce it.
+
+## What `/init` Does (and Doesn't Do)
+
+Kimi Code's `/init` command analyzes the project and generates a root `AGENTS.md` file. **It does not touch `.kimi/AGENTS.md` or the global SessionStart hook.** If you run `/init` after installing Superpowers:
+
+- Root `AGENTS.md` gets overwritten with Kimi-generated project context
+- The global SessionStart hook remains active
+- Your skills remain installed in `~/.config/agents/skills/`
+
+## Project-Level Bootstrap (Optional)
+
+If you prefer project-level bootstrap instead of (or in addition to) the global hook, copy the bootstrap file into your project:
+
+```bash
+mkdir -p .kimi
+cp ~/.kimi/superpowers/.kimi/AGENTS.md .kimi/AGENTS.md
+```
+
+**Windows (PowerShell):**
+```powershell
+New-Item -ItemType Directory -Force -Path ".kimi"
+Copy-Item "$env:USERPROFILE\.kimi\superpowers\.kimi\AGENTS.md" ".kimi\AGENTS.md"
+```
+
+This file is **not** overwritten by `/init` and is auto-merged into Kimi Code's system prompt at session start.
+
+## Updating
+
+Pull the latest changes and re-run the install script:
+
+**macOS / Linux:**
+```bash
+~/.kimi/superpowers/.kimi/update.sh
+```
+
+**Windows (PowerShell):**
+```powershell
+& "$env:USERPROFILE\.kimi\superpowers\.kimi\update.ps1"
+```
+
+This re-copies skills from the latest repo state and ensures your hook is up to date.
+
+## Uninstalling
+
+Remove the copied skills and hook configuration:
+
+```bash
+# Remove copied skills
+rm -rf ~/.config/agents/skills
+
+# Remove the SessionStart hook from ~/.kimi/config.toml
+# (edit the file manually to remove the [[hooks]] block for SessionStart)
+
+# Remove the cloned repo
+rm -rf ~/.kimi/superpowers
+```
+
+**Windows (PowerShell):**
+```powershell
+Remove-Item -Recurse -Force "$env:USERPROFILE\.config\agents\skills"
+Remove-Item -Recurse -Force "$env:USERPROFILE\.kimi\superpowers"
+# Edit $env:USERPROFILE\.kimi\config.toml to remove the SessionStart hook block
+```
+
+## Troubleshooting
+
+### Bootstrap not appearing
+
+1. Confirm the SessionStart hook is in `~/.kimi/config.toml`
+2. Restart Kimi Code (hooks are read at session start)
+3. If using the VS Code extension, run "Developer: Reload Window" from the Command Palette
+4. As a fallback, copy `.kimi/AGENTS.md` into your project directory
+
+### Skills not showing up
+
+1. Verify skills exist: `ls ~/.config/agents/skills/` or `dir $env:USERPROFILE\.config\agents\skills\`
+2. Check that `merge_all_available_skills = true` is set in `~/.kimi/config.toml`
+3. Restart Kimi Code — skills are discovered at startup
+4. Try `/skill:using-superpowers` to confirm skills are accessible
+
+### Subagent skills not working
+
+Ensure your Kimi Code version supports the `Agent` tool. Subagent-driven development requires true subagent dispatch.
+
+### Tool mapping confusion
+
+See `.kimi/TOOL_MAPPING.md` for the complete mapping of Claude Code tools to Kimi Code equivalents.
+
+## Getting Help
+
+- Report issues: https://github.com/obra/superpowers/issues
+- Full documentation: [docs/README.kimi.md](../docs/README.kimi.md)

.kimi/TOOL_MAPPING.md

@@ -0,0 +1,59 @@
+# Kimi Code 2.6 Tool Mapping
+
+Skills use Claude Code tool names. When you encounter these in a skill, use your platform equivalent:
+
+| Skill references | Kimi Code 2.6 equivalent |
+|-----------------|--------------------------|
+| `Read` (file reading) | `ReadFile` |
+| `Write` (file creation) | `WriteFile` |
+| `Edit` (file editing) | `StrReplaceFile` |
+| `Bash` (run commands) | `Shell` |
+| `Grep` (search file content) | `Grep` |
+| `Glob` (search files by name) | `Glob` |
+| `TodoWrite` (task tracking) | `SetTodoList` |
+| `Skill` tool (invoke a skill) | Auto-discovery + `/skill:<name>` slash command |
+| `WebSearch` | `SearchWeb` |
+| `WebFetch` | `FetchURL` |
+| `Task` tool (dispatch subagent) | `Agent` |
+| `EnterPlanMode` / `ExitPlanMode` | `EnterPlanMode` / `ExitPlanMode` |
+
+## Skill Discovery and Loading
+
+Kimi Code 2.6 has native skill discovery. When Superpowers is installed:
+
+1. **Auto-discovery**: Kimi Code scans `~/.config/agents/skills/` at startup, parses `SKILL.md` frontmatter, and injects skill names and descriptions into the system prompt.
+2. **Auto-triggering**: The AI automatically reads skill content when it determines a skill is relevant to the current task.
+3. **Explicit loading**: Use `/skill:<name>` to force-load a skill. Examples:
+   - `/skill:using-superpowers`
+   - `/skill:brainstorming`
+   - `/skill:test-driven-development`
+
+When a skill references the `Skill` tool (Claude Code's native skill invocation), interpret it as: "Ensure the skill is loaded and follow its instructions." Kimi Code handles this via auto-discovery or `/skill:<name>`.
+
+## Subagent Support
+
+Kimi Code 2.6 **does** support true subagent dispatch via the `Agent` tool:
+
+- Isolated context per subagent instance
+- Built-in types: `coder`, `explore`, `plan`
+- Supports `run_in_background=true` for parallel execution
+- Use `subagent_type="explore"` for read-only research tasks
+- Use `subagent_type="coder"` for implementation tasks
+
+Skills like `subagent-driven-development` and `dispatching-parallel-agents` work correctly with Kimi Code's `Agent` tool.
+
+## Additional Kimi Code 2.6 Tools
+
+These tools are available in Kimi Code but have no Claude Code equivalent:
+
+| Tool | Purpose |
+|------|---------|
+| `AskUserQuestion` | Request structured input from the user with multiple-choice options |
+| `Think` | Record thinking process for complex reasoning |
+| `TaskList` | List background tasks |
+| `TaskOutput` | Retrieve output from background tasks |
+| `TaskStop` | Stop a running background task |
+
+## Background Tasks
+
+Kimi Code supports background task execution via `Shell` with `run_in_background=true` or `Agent` with `run_in_background=true`. Use `TaskList`, `TaskOutput`, and `TaskStop` to manage long-running processes.