specrune-claude 0.0.0-stage → 0.9.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 jsfaint
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,133 @@
-# Temporary Holding Version
+# specrune-claude
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+SpecRune 的 Claude Code 宿主适配与安装器。
+
+## 安装
+
+包自带 `specrune` CLI：安装器把平台二进制复制到宿主根下，并把 `settings.json`
+的 hook 命令改写为该绝对路径，不需要另装 CLI。安装器的通用编排在 `specrune`
+包内的 `specrune/lib/installer-core.mjs`（共享核心）；本包只保留 Claude Code 的
+落点、模板与 hooks/env 键级合并。入口命令不变：`specrune-claude install` 仍是
+用户入口。共享核心随 `specrune` 发布，旧版 `specrune` 缺少它时安装器会提示升级。
+默认装到宿主全局目录
+（`~/.claude/`），装一次所有项目共用：
+
+```bash
+npm i -g specrune-claude
+specrune-claude install
+```
+
+`npx specrune-claude install` 只适合一次性试装：包本身住在 npx 的临时缓存里，
+缓存随时会被清理，后续 `status` / 升级都得重新下载。常驻安装请用
+`npm i -g specrune-claude`。
+
+project scope 用于需要随仓库锁版本或全局目录不可写的场景（同样是一等安装模式）：
+
+```bash
+specrune-claude install --scope project --dir <项目根>
+```
+
+### 安装模式与五宿主矩阵
+
+同一宿主在同一台机器上只能选一种模式：两处同时启用会每轮重复注入，技能也会在两处同名出现。`<adapter>` 是宿主适配器标识，不是 OS / 机器名；`specrune-windows-*` 是平台二进制包，不是安装器。下表 global / project 指**插件安装范围**；技能 `--scope` 由 `specrune skills` 单独决定（Codex 的技能可用 global，只有插件必须 project；DSH 技能与插件都只有 global）。
+
+| 适配器 | npm 包 | global | project |
+|---|---|---|---|
+| `opencode` | `specrune-opencode` | ✓ | ✓ |
+| `pi` | `specrune-pi` | ✓ | ✓ |
+| `claude` | `specrune-claude` | ✓ | ✓ |
+| `codex` | `specrune-codex` | —（自动纠正为 project） | ✓ |
+| `dsh` | `specrune-dsh-host` | ✓ | —（自动纠正为 global） |
+
+本适配器是 `claude`，两种 scope 都支持：
+
+- **global**（默认）：项目里只有 `.specrune/`，技能在 `~/.agents/skills/`，并链接到 `~/.claude/skills/`（无权限时回退真实副本）。
+- **project**：`.specrune/`、`.agents/skills/`、`.claude/` 都在项目内。
+
+Windows 完整示例（PowerShell）：
+
+```powershell
+npm i -g specrune-claude
+cd C:\path\to\project
+specrune init --developer "你的名字"
+specrune-claude install --scope project
+```
+
+技能由 CLI 统一安装：`specrune skills install --adapter claude --scope global|project`；切换用 `specrune skills migrate --scope global|project`（整机切换，先写目标再删源，用户改过的文件保留）。项目根放 `.specrune-disabled` 可禁用该项目的自动注入；`specrune-setup` 只能由用户显式调用（`disable-model-invocation`）。
+
+安装器写入五类内容：
+
+| 内容 | 位置（global） | 说明 |
+|---|---|---|
+| `specrune/bin/specrune[.exe]` | `~/.claude/specrune/bin/` | 依赖里的平台二进制，供 hook 直接调用 |
+| `agents/specrune-*.md` | `~/.claude/agents/` | implement / check / research 子代理 |
+| `commands/specrune-*.md` | `~/.claude/commands/` | `/specrune-start` 等斜杠命令 |
+| `skills/<name>/**` | `~/.claude/skills/` | 由 `specrune skills install --adapter claude` 创建（链接优先，复制回退；Claude 只扫 `.claude/skills/`） |
+| `settings.json` | `~/.claude/settings.json` | 只合并事件 hook 与 env 键 |
+
+`hook` 命令写成 `"<宿主根>/specrune/bin/specrune" hook-claude`（路径带引号，
+宿主根含空格时也能执行）。找不到依赖里的二进制时不写该目录，命令保留裸
+`specrune hook-claude` 并回退 PATH。升级时旧裸命令与旧路径会原地替换，不会
+重复追加。
+
+`settings.json` 是混合所有权文件，安装器只增删本工具的条目：
+
+```json
+{
+  "env": {
+    "CLAUDE_BASH_MAINTAIN_PROJECT_WORKING_DIR": "1"
+  },
+  "hooks": {
+    "SessionStart": [
+      { "matcher": "startup", "hooks": [{ "type": "command", "command": "\"/home/you/.claude/specrune/bin/specrune\" hook-claude", "timeout": 30 }] },
+      { "matcher": "clear", "hooks": [{ "type": "command", "command": "\"/home/you/.claude/specrune/bin/specrune\" hook-claude", "timeout": 30 }] },
+      { "matcher": "compact", "hooks": [{ "type": "command", "command": "\"/home/you/.claude/specrune/bin/specrune\" hook-claude", "timeout": 30 }] }
+    ],
+    "UserPromptSubmit": [
+      { "hooks": [{ "type": "command", "command": "\"/home/you/.claude/specrune/bin/specrune\" hook-claude", "timeout": 15 }] }
+    ]
+  }
+}
+```
+
+用户的其它键、其它 hook 分组与 env 键原样保留；`env` 键只在用户未设时补，
+用户改过的值不会被覆盖。非法 JSON 不改并告警；卸载只擦本工具的 hook 条目与
+env 键、删除 `<宿主根>/specrune/` 二进制目录，擦完为空才删 settings 文件（与
+Go 的 `mergeClaudeSettings` / `ScrubClaudeSettings` 同语义）。
+
+状态写在 `<宿主根>/specrune-install.json`（项目级为
+`.specrune/.state/plugins/claude.json`），记录 `{ protocol, version, files }`。
+CLI 不读它；它只服务安装器的升级与卸载。`settings.json` 不进 `files`：它走
+键级擦除，不能按整文件哈希删除。
+
+## 命令
+
+```bash
+specrune-claude install   [--scope global|project] [--dir <路径>] [--dry-run] [--force]
+specrune-claude uninstall [--scope global|project] [--dir <路径>] [--dry-run] [--force]
+specrune-claude status    [--scope global|project] [--dir <路径>] [--json]
+```
+
+- `--dry-run` 只打印计划，不写盘。
+- `--force` 覆盖（install）或删除（uninstall）已被用户改过的文件。
+- 退出码：`0` 成功，`1` 运行失败，`2` 用法错误。
+
+## 从项目级旧装配迁移
+
+旧版 `specrune init --claude` 会写 `<项目>/.claude/`。Claude Code 同时加载
+全局与项目级配置，两处都在会重复挂 hook、每轮注入两次。
+
+CLI 已不再提供平台旧文件检测（`specrune doctor` 只校验研究与技能）。请在项目里
+手工删除旧版写入的 `.claude/agents/specrune-*.md`、`.claude/commands/specrune-*.md`
+与 `.claude/skills/specrune-*`；`.claude/settings.json` 只移除 `specrune hook-claude`
+条目与 `CLAUDE_BASH_MAINTAIN_PROJECT_WORKING_DIR`，其余用户配置保留。内容已改过的
+文件先备份再删。
+
+## 开发
+
+```bash
+npm test
+```
+
+包内 agents、commands、settings 是 Claude Code 适配的权威副本；`skills/` 是旧版
+安装器的兼容副本，新版技能正文由 CLI 的 `specrune skills install` 链接/复制。

package/agents/specrune-check.md

@@ -0,0 +1,37 @@
+---
+name: specrune-check
+description: |
+  Review agent for the SpecRune workflow. Compares the change against the task requirements and the project specs, fixes what it finds. Never commits.
+tools: Read, Write, Edit, Bash, Glob, Grep, Skill
+---
+# Check Agent
+
+You are the review agent inside a SpecRune workflow.
+
+## You are already the sub-agent
+
+The main session dispatched you; do the review and fixes yourself. Do not dispatch another review or implementation agent — that instruction in the breadcrumb or `workflow.md` is for the main session. Report work beyond a review's scope instead of spawning help.
+
+## Load your skill first
+
+Before touching anything, load the `specrune-review` skill, plus any skills named in your dispatch prompt, with the `Skill` tool. If that tool is unavailable, read `.agents/skills/<name>/SKILL.md` in the project, or `~/.agents/skills/<name>/SKILL.md` globally for each. If any is unavailable, report `<name> skill unavailable` and stop before reviewing.
+
+## Load your task context first
+
+On this platform your context is not preloaded at dispatch time. Fetch it before reviewing anything:
+
+    specrune context compile --role check
+
+Its JSON `context` field contains materialized copies of the task's `prd.md`, `design.md` / `implement.md` (when present), plus every spec and research file in `check.jsonl`. Review against that block.
+
+Fallback: retry with `--task <ref>` when your dispatch prompt names a task; if both attempts fail, report `could not load task context` and stop — an ungrounded review is worse than no review.
+
+Use the task path from the parent's prompt or curated context. Do not infer it from your child session, environment, or another session.
+
+## What to do
+
+Fix mechanical and local issues in scope; for design or judgment calls, report the evidence and stop. Re-run the focused lint, typecheck, and tests.
+
+## Report
+
+Report what you fixed, which files changed, and what you verified. If nothing is wrong, say so plainly; padding with speculation wastes time.

package/agents/specrune-implement.md

@@ -0,0 +1,42 @@
+---
+name: specrune-implement
+description: |
+  Implementation agent for the SpecRune workflow. Reads the task's requirements and curated specs, then writes the code. Never commits.
+tools: Read, Write, Edit, Bash, Glob, Grep, Skill
+---
+# Implement Agent
+
+You are the implementation agent inside a SpecRune workflow.
+
+## You are already the sub-agent
+
+The main session dispatched you; do the work yourself. Do not dispatch another implementation or review agent — that instruction in the breadcrumb or `workflow.md` is for the main session. Report work beyond one agent instead of spawning help.
+
+## Load your skill first
+
+Before touching anything, load the `specrune-before-dev` skill, plus any skills named in your dispatch prompt, with the `Skill` tool. If that tool is unavailable, read `.agents/skills/<name>/SKILL.md` in the project, or `~/.agents/skills/<name>/SKILL.md` globally for each. If any is unavailable, report `<name> skill unavailable` and stop before editing.
+
+## Load your task context first
+
+On this platform your context is not preloaded at dispatch time. Fetch it before touching anything:
+
+    specrune context compile --role implement
+
+Its JSON `context` field contains materialized copies of the task's `prd.md`, `design.md` / `implement.md` (when present), plus every spec and research file in `implement.jsonl`. Work from that block.
+
+Fallback: retry with `--task <ref>` when your dispatch prompt names a task; if both attempts fail, report `could not load task context` and stop — do not guess the requirements.
+
+## What to do
+
+Follow existing patterns; implement the change; run focused lint, typecheck, and tests; report what changed and what you verified.
+
+Before editing, state the change boundary: the behavior gap, where it lives, the files you expect to change, what you will not do, and how you will show behavior did not change. If the scope is larger than the dispatch, say so before continuing.
+
+## Never do
+
+`git commit`, `git push`, `git merge` — committing belongs to the session owner.
+
+## Working rules
+
+- Read adjacent code and tests first; stay inside this task's scope; do not revert work you did not write. Fix the cause, not the symptom; reuse existing helpers before inventing an abstraction.
+- Research files open with an evidence card (`status` / `sources` / `revision`). `INCONCLUSIVE` is not established and `NOT_FOUND` is a positive finding — neither licenses invention; re-verify cited lines when `revision` is stale.

package/agents/specrune-research.md

@@ -0,0 +1,45 @@
+---
+name: specrune-research
+description: |
+  Investigation agent for the SpecRune workflow. Finds the relevant code, patterns and docs, and writes each finding to the task's research/ directory.
+tools: Read, Write, Edit, Bash, Glob, Grep
+---
+# Research Agent
+
+You are the investigation agent inside a SpecRune workflow.
+
+## Progressive disclosure
+
+The research context is a navigation map, not preloaded bodies. Start from its paths and titles, read relevant contracts, then trace code and tests. Skip specs that are merely listed. `kind: navigation` entries record delivered pointers, not files read; a body intentionally not preloaded is not a dropped candidate. Search `.specrune/spec/` when incomplete. Record the sources the conclusions actually use in the evidence card; the ledger records delivery, not reading.
+
+If no navigation was delivered, run `specrune context compile --role research` and read the JSON `context` field. With a confirmed task path, pass `--task <ref>`; never infer the parent task from your child session or change its binding. Compilation failure is not an empty map: report missing context before task-dependent work. Without a task, a self-contained question may still be investigated.
+
+## Task and report
+
+Confirm the task from the parent's explicit path or the host-delivered task; `task current` may verify a delivered identity but never replaces the parent's. Report disagreement before task-dependent work.
+
+Write findings before reporting — an in-conversation-only finding disappears at the next compaction. For a confirmed task, create `<task-dir>/research/` if needed, one `<task-dir>/research/<slug>.md` per topic headed by its evidence card, then report paths and a summary, and report a failed write rather than claiming a file exists. With no task, return source-backed findings without a report; never guess a task directory or bind the parent session.
+
+## Evidence card
+
+Every report file opens with this YAML header:
+
+    ---
+    status: VERIFIED            # VERIFIED | INCONCLUSIVE | NOT_FOUND
+    sources:                    # files the conclusion actually rests on
+      - path: core/internal/specrune/context.go
+        lines: 654-682
+      - path: https://github.com/<org>/<repo>/blob/<rev>/<path>
+    revision: a1b2c3d           # git rev at investigation time
+    ---
+
+- `VERIFIED` — you read the evidence; `sources` is mandatory.
+- `INCONCLUSIVE` — the evidence does not settle the question.
+- `NOT_FOUND` — the thing genuinely is not there.
+- External repo? `sources[].path` may be an `http(s)://` permalink embedding the rev; `revision` then records that repo's rev (req:sessions-memory#session-record-authoritative; the doctor skips URL checks).
+
+Pick exactly one. No `sources` entry means it is not a fact: cite, downgrade, or drop it — never dress a guess up as a conclusion. Cite `file:line` so a stale reference can be re-located from `revision`.
+
+## Stay in your lane
+
+Write only a plain `<slug>.md` report under this task's `research/` — no subdirectories, and never copy source into the task directory; cite it by `file:line` plus the `revision` in the card. Do not edit code, specs, platform config, or task files; patching is no longer investigating.

package/bin/specrune-claude.mjs

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+// specrune-claude 的可执行入口。
+//
+// 包内只有这一个 bin：安装器负责把 agents / commands / skills 落到 Claude Code
+// 的配置目录，并对 settings.json 做键级合并——pnpm 10 默认拦截依赖的生命周期
+// 脚本，装包时偷偷写用户配置既不可见也不可控。
+// 共享核心缺失（旧版 specrune）等启动错误只打印可操作消息，不甩模块堆栈。
+try {
+  const { main } = await import("../src/install.mjs");
+  process.exitCode = await main(process.argv.slice(2));
+} catch (err) {
+  process.stderr.write(`specrune-claude: ${err?.message ?? err}\n`);
+  process.exitCode = 1;
+}

package/commands/specrune-finish-work.md

@@ -0,0 +1,70 @@
+---
+description: Wrap up: verify the tree, archive finished tasks, record the session
+---
+
+# Finish Work
+
+Wrap up the session: verify the tree, record the session, archive the finished
+task(s). Code commits are NOT done here — they belong to the workflow's commit
+step and must already be in history. That step is named, not numbered: numbers
+differ per workflow template and a stale one points at the wrong step with no
+error.
+
+## Step 1: Survey current state
+
+```bash
+specrune context --mode record
+git status --porcelain
+```
+
+Record mode lists active tasks, dirty paths, and recent commits (the hashes
+Step 3 needs). If it surfaces other completed tasks, ask once — "These N tasks
+look done — archive them too this round? [y/N]", default no. The bound task is
+archived regardless.
+
+## Step 2: Classify dirty paths
+
+Ignore `.specrune/workspace/`, `.specrune/tasks/` and `.specrune/sessions/`:
+this flow writes there. For the rest, decide whether each path is this task's
+work (cited in `prd.md` / the manifests, or in code areas of its scope) or
+another window's. Then:
+
+- **This task's work** — stop. Report the paths and send the user back to the
+  commit step. Do not `git commit` here and do not ask the user to.
+- **Unrelated** — report once and continue.
+- **Unsure** — ask once, then route by the answer.
+
+## Step 3: Record the session
+
+Verify every acceptance criterion in `prd.md` first — the summary claims what
+happened.
+
+```bash
+specrune session record --title "Session title" \
+  --commit "hash1,hash2" \
+  --summary "Brief summary of what happened" \
+  --next-step "What the next session should pick up first"
+```
+
+**Record before archiving.** The record's `task:` field resolves from the
+active-task pointer, and `task archive` clears session pointers aimed at the task
+it moves — archiving first leaves the field empty and still exits 0. Pass the
+work commits from Step 1, not the archive commits.
+
+`--next-step` is for a session with no memory of this one: name the concrete
+next action, not a topic. Repeat the flag for several items; the first is what
+gets surfaced. Older records without Next Steps are normal — do not backfill.
+
+## Step 4: Finish and archive
+
+```bash
+specrune task finish
+specrune task archive <task>
+```
+
+At minimum the bound task, plus any extras confirmed in Step 1. Archive moves
+the directory to `.specrune/tasks/archive/<YYYY-MM>/`, clears session pointers,
+and commits. It marks the task `completed` — except `canceled`, which keeps its
+status and empty completion date. Skip when there is no task.
+
+Final commit order: work commit → session record → `chore(task): archive ...`.

package/commands/specrune-next.md

@@ -0,0 +1,37 @@
+---
+description: Pick up the current task at the right step of the workflow
+---
+
+# Next Step
+
+Pick up the bound task at the right step of `.specrune/workflow.md` instead of
+re-deriving the flow.
+
+## Step 1: Load current context
+
+```bash
+specrune task current
+specrune context --mode phase
+```
+
+`task current` shows the binding, git state, and where the phase index says you
+are. One binding per session; switch with `specrune task start <task>`.
+
+## Step 2: Follow the project workflow
+
+`.specrune/workflow.md` is the only routing authority. Read its phase index,
+the current breadcrumb, and the relevant step; do not assume a particular
+status set, phase count, step number, or native/tdd route. The `specrune-next`
+skill only provides generic instructions for loading this project workflow.
+
+Step numbers are deliberately absent from these commands because they differ
+per workflow template. Route by role, then get the numbers from the per-turn
+breadcrumb or the step headings in `.specrune/workflow.md`.
+
+## Step 3: Load the specific step
+
+```bash
+specrune context --mode phase --step <X.X>
+```
+
+Follow the loaded instructions, then move to the next step.

package/commands/specrune-start.md

@@ -0,0 +1,56 @@
+---
+description: Start a SpecRune session: load context, pick or resume the active task
+---
+
+# Start Session
+
+Load the compact context by hand — at the start of a conversation, or when the
+host platform has no session-start hook.
+
+## Step 1: Current state and recent sessions
+
+```bash
+specrune context
+specrune session log
+```
+
+The log shows what happened recently, which task each session belonged to, and
+where it left off. Hook-driven platforms get the same three entries injected
+automatically; ask the user what they were working on only when both are empty.
+For the reasoning behind an old decision, `specrune mem` — the `specrune-update-spec`
+skill's step 3 holds the two-sources table for choosing between the two.
+
+## Step 2: Workflow and spec indexes
+
+```bash
+specrune context --mode phase
+specrune packages
+specrune specs
+cat .specrune/spec/<package>/<layer>/index.md   # each layer you expect to touch
+cat .specrune/spec/guides/index.md
+```
+
+Read indexes only for areas the work will touch; the index points at the
+guidelines, and `.specrune/workflow.md` holds the full flow (read on demand).
+
+## Step 3: Follow the project workflow
+
+`.specrune/workflow.md` is the only routing authority. Read its phase index,
+the current breadcrumb, and the relevant step before choosing an action. Do not
+assume a particular status set, phase count, step number, or native/tdd route.
+For a bound task, load `specrune-next`; it explains how to use the project's
+workflow rather than copying a route table into this command.
+
+## Skill routing
+
+| User intent | Skill |
+|---|---|
+| New feature / unclear requirements | `specrune-brainstorm` |
+| About to write code | `specrune-before-dev` |
+| Done coding / quality check | `specrune-review` |
+| Stuck / fixed the same bug multiple times | `specrune-break-loop` |
+| Learned something worth capturing | `specrune-update-spec` |
+
+Each step's full text lives in `.specrune/workflow.md`; load one with
+`specrune context --mode phase --step N.N`. The per-turn breadcrumb names the
+skill for the phase you are in.

package/package.json

@@ -1,6 +1,45 @@
 {
   "name": "specrune-claude",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.9.0",
+  "description": "SpecRune 的 Claude Code 宿主适配与安装器：全局装配 agents、commands、skills，并合并 settings.json 的事件 hook 与 env",
+  "type": "module",
+  "bin": {
+    "specrune-claude": "bin/specrune-claude.mjs"
+  },
+  "files": [
+    "bin",
+    "src",
+    "agents",
+    "commands",
+    "skills",
+    "settings.json",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "specrune": "^0.9.0"
+  },
+  "scripts": {
+    "test": "node --test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jsfaint/SpecRune.git",
+    "directory": "plugins/claude"
+  },
+  "homepage": "https://github.com/jsfaint/SpecRune#readme",
+  "bugs": {
+    "url": "https://github.com/jsfaint/SpecRune/issues"
+  },
+  "license": "MIT",
+  "keywords": [
+    "specrune",
+    "claude",
+    "claude-code",
+    "plugin",
+    "spec-driven",
+    "workflow"
+  ]
+}

package/settings.json

@@ -0,0 +1,50 @@
+{
+  "env": {
+    "CLAUDE_BASH_MAINTAIN_PROJECT_WORKING_DIR": "1"
+  },
+  "hooks": {
+    "SessionStart": [
+      {
+        "matcher": "startup",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "specrune hook-claude",
+            "timeout": 30
+          }
+        ]
+      },
+      {
+        "matcher": "clear",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "specrune hook-claude",
+            "timeout": 30
+          }
+        ]
+      },
+      {
+        "matcher": "compact",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "specrune hook-claude",
+            "timeout": 30
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "specrune hook-claude",
+            "timeout": 15
+          }
+        ]
+      }
+    ]
+  }
+}

package/skills/specrune-before-dev/SKILL.md

@@ -0,0 +1,69 @@
+---
+name: specrune-before-dev
+description: Load task requirements, specs and conventions before coding. Use in the main session before dispatch, or as the dispatched specrune-implement sub-agent.
+---
+
+# specrune-before-dev
+
+> **Project gate**: stop if the repository root lacks `.specrune/` or contains `.specrune-disabled`; do not run any step of this skill.
+
+Read the specs before coding so the implementation follows them, not the
+model's habits.
+
+## Who this skill is for
+
+- **Main session** — read the task and specs, state the boundary, then dispatch `specrune-implement`.
+- **Dispatched `specrune-implement` sub-agent** — run the steps below on the task path the parent supplied.
+
+## Sub-agent boundaries
+
+If you are the dispatched `specrune-implement` sub-agent:
+
+- Use the task path from the parent's prompt or curated context. Do not run `task current` to discover the parent task.
+- Do not create, start, finish, or archive tasks; do not commit.
+- Load any additional skills named in your dispatch prompt, not only this role skill.
+- If the curated context is missing or incomplete, report it before editing.
+
+## Dispatch note
+
+The main session may have loaded other skills. They are not inherited
+automatically: name the ones the sub-agent needs in the dispatch prompt (or
+pass `skills` to `specrune_subagent`). The sub-agent loads its role skill and
+those named skills.
+
+## Steps
+
+1. **Read the task's planning artifacts** (if a task is bound; a dispatched sub-agent uses the task path from its parent, never `task current`):
+
+   Main session:
+
+   ```bash
+   specrune task current
+   specrune task show <task>
+   ```
+
+   `prd.md` first; `design.md` / `implement.md` when present.
+
+2. **Find the specs that apply**:
+
+   ```bash
+   specrune packages
+   specrune specs            # path + title only; add --verbose for bytes/density/index refs
+   ```
+
+   Read `.specrune/spec/<package>/<layer>/index.md` for each package you touch
+   and follow it into the concrete guideline files. The index is a pointer, not
+   the goal. Include `spec/guides/index.md` for cross-cutting checklists.
+
+3. **State the change boundary** before writing code, for a non-trivial change
+   (more than one file, crosses a layer, changes a public interface, or edits
+   code you did not just write):
+
+   - the behavior gap between now and target
+   - where that behavior actually lives (not where it is easiest to intercept)
+   - files you expect to change, and why each is necessary
+   - what this task explicitly does not do
+   - how you will show a local refactor did not change behavior
+
+   If the real scope is clearly larger than that, say so before continuing.
+   Do not widen the change on your own.