peaks-loop 4.0.38 → 4.0.39

package/skills/peaks-doctor/SKILL.md

@@ -3,6 +3,30 @@ name: peaks-doctor
 description: Orchestrate peaks-loop's L3 doctor (peaks audit + peaks doctor + peaks openspec from-doctor) for project health. Use when the user asks for a project health check, doctor report, audit, or wants to convert doctor findings into OpenSpec change records. Coordinates the L2 audit framework + the L3.2 doctor + the L3.3 from-doctor proposal generator. Triggers on `/peaks-doctor`, "peaks doctor", "项目健康", "doctor report", "health check", "check the project", "audit my repo".
 visibility: internal
 ---
+
+<!-- peaks:loop-hygiene — generated block; keep byte-identical in every SKILL.md -->
+
+## Loop hygiene (every turn — MANDATORY)
+
+**Skill header.** While this skill is active, open every turn with
+`Peaks-Loop Skill: <skill> | Peaks-Loop Gate: <gate> | Next: <one short action>`.
+Every turn, not only the first — it is how the user knows which skill is driving.
+
+**Context is this skill's own business.** Run `peaks skill presence --json` every turn and
+read its `context` block. When `action` is `auto-fire`, `pre-compact`, or `red-line`,
+run `peaks code auto-compact --project .` **yourself**, then continue. Tell the user the
+ratio in one line if it helps, but never hand them the compaction step: asking the user to
+run `/compact` is the regression the zero-pause contract forbids. This holds in **every
+mode** — standard *and* 24h. The mode moves the threshold, never the obligation.
+
+**Read before you edit.** Read a file BEFORE your first `Edit` / `Write` / `MultiEdit` on
+it — for every path outside `.peaks/**` (source, tests, docs, config); `.peaks/**` writes
+are exempt. Skipping that read trips a `PreToolUse` gate (ECC's "Fact-Forcing Gate"),
+which denies the edit. **A denial is not a failure and the tool is not broken — your edit
+was not applied.** Read the file, state the facts the gate asks for (importers, affected
+API, data schemas if any, the user's verbatim instruction), then retry the same operation.
+Do not switch tools, do not give up, do not retry blindly.
+<!-- /peaks:loop-hygiene -->
 ---
 
 # Peaks-Loop Doctor

package/skills/peaks-final-review/SKILL.md

@@ -3,6 +3,30 @@ name: peaks-final-review
 description: Final-review skill for Peaks. Use when a workflow needs to assemble 4-dimension business-review evidence (functional-completeness, problem-resolution, no-new-bugs, existing-functionality-intact) for human acceptance at the end of an autonomous slice. Triggers on "/peaks-final-review", "prepare final review", "4-dim review", or peaks-code end-of-workflow handoff.
 ---
 
+<!-- peaks:loop-hygiene — generated block; keep byte-identical in every SKILL.md -->
+
+## Loop hygiene (every turn — MANDATORY)
+
+**Skill header.** While this skill is active, open every turn with
+`Peaks-Loop Skill: <skill> | Peaks-Loop Gate: <gate> | Next: <one short action>`.
+Every turn, not only the first — it is how the user knows which skill is driving.
+
+**Context is this skill's own business.** Run `peaks skill presence --json` every turn and
+read its `context` block. When `action` is `auto-fire`, `pre-compact`, or `red-line`,
+run `peaks code auto-compact --project .` **yourself**, then continue. Tell the user the
+ratio in one line if it helps, but never hand them the compaction step: asking the user to
+run `/compact` is the regression the zero-pause contract forbids. This holds in **every
+mode** — standard *and* 24h. The mode moves the threshold, never the obligation.
+
+**Read before you edit.** Read a file BEFORE your first `Edit` / `Write` / `MultiEdit` on
+it — for every path outside `.peaks/**` (source, tests, docs, config); `.peaks/**` writes
+are exempt. Skipping that read trips a `PreToolUse` gate (ECC's "Fact-Forcing Gate"),
+which denies the edit. **A denial is not a failure and the tool is not broken — your edit
+was not applied.** Read the file, state the facts the gate asks for (importers, affected
+API, data schemas if any, the user's verbatim instruction), then retry the same operation.
+Do not switch tools, do not give up, do not retry blindly.
+<!-- /peaks:loop-hygiene -->
+
 ## Single-scope-axis naming convention
 
 > **Read once at the top of this file; the rest of the skill is written against it.**

package/skills/peaks-ide/SKILL.md

@@ -3,6 +3,30 @@ name: peaks-ide
 description: Orchestrate peaks-loop's IDE-aware behavior (hooks + statusline + handle) for a user's specific IDE. Detects the current state (which IDE the user is on, what peaks has already installed), plans the install / switch / status / uninstall actions, and invokes the existing peaks CLI primitives. Triggers on `/peaks-ide`, "set up peaks for my IDE", "switch peaks to Trae", "what did peaks install", "uninstall peaks hooks". Sits between the user and `peaks hooks install` / `peaks statusline install` / `peaks hook handle` — those are the CLI primitives; this skill is the user-facing surface.
 visibility: internal
 ---
+
+<!-- peaks:loop-hygiene — generated block; keep byte-identical in every SKILL.md -->
+
+## Loop hygiene (every turn — MANDATORY)
+
+**Skill header.** While this skill is active, open every turn with
+`Peaks-Loop Skill: <skill> | Peaks-Loop Gate: <gate> | Next: <one short action>`.
+Every turn, not only the first — it is how the user knows which skill is driving.
+
+**Context is this skill's own business.** Run `peaks skill presence --json` every turn and
+read its `context` block. When `action` is `auto-fire`, `pre-compact`, or `red-line`,
+run `peaks code auto-compact --project .` **yourself**, then continue. Tell the user the
+ratio in one line if it helps, but never hand them the compaction step: asking the user to
+run `/compact` is the regression the zero-pause contract forbids. This holds in **every
+mode** — standard *and* 24h. The mode moves the threshold, never the obligation.
+
+**Read before you edit.** Read a file BEFORE your first `Edit` / `Write` / `MultiEdit` on
+it — for every path outside `.peaks/**` (source, tests, docs, config); `.peaks/**` writes
+are exempt. Skipping that read trips a `PreToolUse` gate (ECC's "Fact-Forcing Gate"),
+which denies the edit. **A denial is not a failure and the tool is not broken — your edit
+was not applied.** Read the file, state the facts the gate asks for (importers, affected
+API, data schemas if any, the user's verbatim instruction), then retry the same operation.
+Do not switch tools, do not give up, do not retry blindly.
+<!-- /peaks:loop-hygiene -->
 ---
 
 # Peaks-Loop IDE Setup (peaks-ide)

package/skills/peaks-issue-fix-orchestrator/SKILL.md

@@ -3,6 +3,30 @@ name: peaks-issue-fix-orchestrator
 description: End-to-end orchestrator that surveys open issues in a target repo, classifies them by difficulty, mines reference merged-PRs, fixes each issue with real commits (with Repository + AI-modified declaration), writes normalized PR description files, and emits a one-line submit script. Use when the user wants to drive a "fix N open issues and prepare PRs" run on an upstream repo (any language; primarily Python + TypeScript). Reuses Loop Engineering primitives: 4-layer asset model, Darwin ratchet, karpathy-engineered red lines, Human-NL-Choice-Only. Triggers on `/peaks-issue-fix-orchestrator`, "fix 30 issues", "dogfood on <repo>", "open-issue sweep on <repo>".
 ---
 
+<!-- peaks:loop-hygiene — generated block; keep byte-identical in every SKILL.md -->
+
+## Loop hygiene (every turn — MANDATORY)
+
+**Skill header.** While this skill is active, open every turn with
+`Peaks-Loop Skill: <skill> | Peaks-Loop Gate: <gate> | Next: <one short action>`.
+Every turn, not only the first — it is how the user knows which skill is driving.
+
+**Context is this skill's own business.** Run `peaks skill presence --json` every turn and
+read its `context` block. When `action` is `auto-fire`, `pre-compact`, or `red-line`,
+run `peaks code auto-compact --project .` **yourself**, then continue. Tell the user the
+ratio in one line if it helps, but never hand them the compaction step: asking the user to
+run `/compact` is the regression the zero-pause contract forbids. This holds in **every
+mode** — standard *and* 24h. The mode moves the threshold, never the obligation.
+
+**Read before you edit.** Read a file BEFORE your first `Edit` / `Write` / `MultiEdit` on
+it — for every path outside `.peaks/**` (source, tests, docs, config); `.peaks/**` writes
+are exempt. Skipping that read trips a `PreToolUse` gate (ECC's "Fact-Forcing Gate"),
+which denies the edit. **A denial is not a failure and the tool is not broken — your edit
+was not applied.** Read the file, state the facts the gate asks for (importers, affected
+API, data schemas if any, the user's verbatim instruction), then retry the same operation.
+Do not switch tools, do not give up, do not retry blindly.
+<!-- /peaks:loop-hygiene -->
+
 # peaks-issue-fix-orchestrator
 
 peaks-issue-fix-orchestrator is the **user-facing skill** that turns a natural-language "dogfood on this repo, fix 30 open issues" request into a reproducible batch fix run. The LLM orchestrates the survey, classification, reference-PR mining, per-batch fix+commit, per-branch relocation, normalized PR body authoring, and submit-script emission. The user only describes a target and picks among a few multi-choice options.

package/skills/peaks-resume/SKILL.md

@@ -3,6 +3,30 @@ name: peaks-resume
 description: Universal resume primitive for any in-flight Peaks-Loop workflow (orchestrator-agnostic). Detects the current session's deepest completed gate and surfaces a resume option via AskUserQuestion. Use when ANY bee (peaks-code, future peaks-research, future peaks-content, …) needs to recover from /compact or session interruption. Triggers on "/peaks-resume", "continue the unfinished work", "继续完成", "把刚才没做完的收尾". (Replaces peaks-resume as a top-level primitive.)
 ---
 
+<!-- peaks:loop-hygiene — generated block; keep byte-identical in every SKILL.md -->
+
+## Loop hygiene (every turn — MANDATORY)
+
+**Skill header.** While this skill is active, open every turn with
+`Peaks-Loop Skill: <skill> | Peaks-Loop Gate: <gate> | Next: <one short action>`.
+Every turn, not only the first — it is how the user knows which skill is driving.
+
+**Context is this skill's own business.** Run `peaks skill presence --json` every turn and
+read its `context` block. When `action` is `auto-fire`, `pre-compact`, or `red-line`,
+run `peaks code auto-compact --project .` **yourself**, then continue. Tell the user the
+ratio in one line if it helps, but never hand them the compaction step: asking the user to
+run `/compact` is the regression the zero-pause contract forbids. This holds in **every
+mode** — standard *and* 24h. The mode moves the threshold, never the obligation.
+
+**Read before you edit.** Read a file BEFORE your first `Edit` / `Write` / `MultiEdit` on
+it — for every path outside `.peaks/**` (source, tests, docs, config); `.peaks/**` writes
+are exempt. Skipping that read trips a `PreToolUse` gate (ECC's "Fact-Forcing Gate"),
+which denies the edit. **A denial is not a failure and the tool is not broken — your edit
+was not applied.** Read the file, state the facts the gate asks for (importers, affected
+API, data schemas if any, the user's verbatim instruction), then retry the same operation.
+Do not switch tools, do not give up, do not retry blindly.
+<!-- /peaks:loop-hygiene -->
+
 # Peaks-Loop Code Resume (wrapper)
 
 Peaks-Loop Code Resume is a thin wrapper that handles the **most common high-frequency request shape**: "I was in the middle of something, continue it." It detects the current session's deepest completed gate, surfaces a resume option, then yields to the main `peaks-code` skill (which runs the actual workflow from the matching gate onwards).

package/skills/peaks-slice-decompose/SKILL.md

@@ -3,6 +3,30 @@ name: peaks-slice-decompose
 description: Run multi-pass slice decomposition on a PRD-ready request and emit a v2 envelope with passes, cross-pass edges, and an LLM-arbitration trace. Use when a PRD is ready and the caller needs service-level and/or file-level cuts in one artifact.
 ---
 
+<!-- peaks:loop-hygiene — generated block; keep byte-identical in every SKILL.md -->
+
+## Loop hygiene (every turn — MANDATORY)
+
+**Skill header.** While this skill is active, open every turn with
+`Peaks-Loop Skill: <skill> | Peaks-Loop Gate: <gate> | Next: <one short action>`.
+Every turn, not only the first — it is how the user knows which skill is driving.
+
+**Context is this skill's own business.** Run `peaks skill presence --json` every turn and
+read its `context` block. When `action` is `auto-fire`, `pre-compact`, or `red-line`,
+run `peaks code auto-compact --project .` **yourself**, then continue. Tell the user the
+ratio in one line if it helps, but never hand them the compaction step: asking the user to
+run `/compact` is the regression the zero-pause contract forbids. This holds in **every
+mode** — standard *and* 24h. The mode moves the threshold, never the obligation.
+
+**Read before you edit.** Read a file BEFORE your first `Edit` / `Write` / `MultiEdit` on
+it — for every path outside `.peaks/**` (source, tests, docs, config); `.peaks/**` writes
+are exempt. Skipping that read trips a `PreToolUse` gate (ECC's "Fact-Forcing Gate"),
+which denies the edit. **A denial is not a failure and the tool is not broken — your edit
+was not applied.** Read the file, state the facts the gate asks for (importers, affected
+API, data schemas if any, the user's verbatim instruction), then retry the same operation.
+Do not switch tools, do not give up, do not retry blindly.
+<!-- /peaks:loop-hygiene -->
+
 ## Single-scope-axis naming convention
 
 > **Read once at the top of this file; the rest of the skill is written against it.**

package/skills/peaks-solo/SKILL.md

@@ -14,6 +14,30 @@ metadata:
   red_lines: [RL-1, RL-8, HC-7, HC-8, HC-9, HC-10, HC-11]
 ---
 
+<!-- peaks:loop-hygiene — generated block; keep byte-identical in every SKILL.md -->
+
+## Loop hygiene (every turn — MANDATORY)
+
+**Skill header.** While this skill is active, open every turn with
+`Peaks-Loop Skill: <skill> | Peaks-Loop Gate: <gate> | Next: <one short action>`.
+Every turn, not only the first — it is how the user knows which skill is driving.
+
+**Context is this skill's own business.** Run `peaks skill presence --json` every turn and
+read its `context` block. When `action` is `auto-fire`, `pre-compact`, or `red-line`,
+run `peaks code auto-compact --project .` **yourself**, then continue. Tell the user the
+ratio in one line if it helps, but never hand them the compaction step: asking the user to
+run `/compact` is the regression the zero-pause contract forbids. This holds in **every
+mode** — standard *and* 24h. The mode moves the threshold, never the obligation.
+
+**Read before you edit.** Read a file BEFORE your first `Edit` / `Write` / `MultiEdit` on
+it — for every path outside `.peaks/**` (source, tests, docs, config); `.peaks/**` writes
+are exempt. Skipping that read trips a `PreToolUse` gate (ECC's "Fact-Forcing Gate"),
+which denies the edit. **A denial is not a failure and the tool is not broken — your edit
+was not applied.** Read the file, state the facts the gate asks for (importers, affected
+API, data schemas if any, the user's verbatim instruction), then retry the same operation.
+Do not switch tools, do not give up, do not retry blindly.
+<!-- /peaks:loop-hygiene -->
+
 # peaks-solo — Dispatcher (分诊员)
 
 > peaks-solo 是 Peaks-Loop 的 dispatcher,不是 orchestrator。读取技能池 → 分诊 → 转交 leaf 或自规划 → 回头问沉淀。**不持有 implementation surface**。

package/skills/peaks-sop/SKILL.md

@@ -3,6 +3,30 @@ name: peaks-sop
 description: Authoring skill for user-defined SOPs (standard operating procedures) in Peaks. Use when a user wants to create, edit, debug, or register their own gated workflow — ordered phases plus gates that block advancement until conditions are met — by describing it in natural language instead of hand-writing JSON or memorizing CLI commands. DOMAIN-AGNOSTIC: not just software/release flows — equally for content publishing, compliance and approval checklists, data pipelines, onboarding, ops runbooks, or any personal repeatable procedure, wherever "don't enter the next stage until X is true" applies and X is checkable via a file, file content, or a command.
 ---
 
+<!-- peaks:loop-hygiene — generated block; keep byte-identical in every SKILL.md -->
+
+## Loop hygiene (every turn — MANDATORY)
+
+**Skill header.** While this skill is active, open every turn with
+`Peaks-Loop Skill: <skill> | Peaks-Loop Gate: <gate> | Next: <one short action>`.
+Every turn, not only the first — it is how the user knows which skill is driving.
+
+**Context is this skill's own business.** Run `peaks skill presence --json` every turn and
+read its `context` block. When `action` is `auto-fire`, `pre-compact`, or `red-line`,
+run `peaks code auto-compact --project .` **yourself**, then continue. Tell the user the
+ratio in one line if it helps, but never hand them the compaction step: asking the user to
+run `/compact` is the regression the zero-pause contract forbids. This holds in **every
+mode** — standard *and* 24h. The mode moves the threshold, never the obligation.
+
+**Read before you edit.** Read a file BEFORE your first `Edit` / `Write` / `MultiEdit` on
+it — for every path outside `.peaks/**` (source, tests, docs, config); `.peaks/**` writes
+are exempt. Skipping that read trips a `PreToolUse` gate (ECC's "Fact-Forcing Gate"),
+which denies the edit. **A denial is not a failure and the tool is not broken — your edit
+was not applied.** Read the file, state the facts the gate asks for (importers, affected
+API, data schemas if any, the user's verbatim instruction), then retry the same operation.
+Do not switch tools, do not give up, do not retry blindly.
+<!-- /peaks:loop-hygiene -->
+
 # Peaks-Loop SOP Authoring
 
 Peaks-Loop SOP turns a natural-language workflow description into a validated, registered custom SOP, then helps the user debug it until each gate behaves as intended. The user describes the process in plain language; this skill drives the `peaks sop` CLI on their behalf — they never have to hand-write `sop.json` or remember the command sequence.

package/skills/peaks-status/SKILL.md

@@ -3,6 +3,30 @@ name: peaks-status
 description: Universal status primitive for any in-flight Peaks-Loop workflow (orchestrator-agnostic). Reads the existing CLI primitives (peaks skill presence, peaks session list, peaks project dashboard, peaks request show) and renders a 1-screen status table. Use when the user asks "where are we", "现在到哪了", "what's the current state" for ANY bee (peaks-code, future peaks-research, …). Triggers on "/peaks-status", "现在到哪了", "what is the current state", "show me the dashboard". (Replaces peaks-status as a top-level primitive.)
 ---
 
+<!-- peaks:loop-hygiene — generated block; keep byte-identical in every SKILL.md -->
+
+## Loop hygiene (every turn — MANDATORY)
+
+**Skill header.** While this skill is active, open every turn with
+`Peaks-Loop Skill: <skill> | Peaks-Loop Gate: <gate> | Next: <one short action>`.
+Every turn, not only the first — it is how the user knows which skill is driving.
+
+**Context is this skill's own business.** Run `peaks skill presence --json` every turn and
+read its `context` block. When `action` is `auto-fire`, `pre-compact`, or `red-line`,
+run `peaks code auto-compact --project .` **yourself**, then continue. Tell the user the
+ratio in one line if it helps, but never hand them the compaction step: asking the user to
+run `/compact` is the regression the zero-pause contract forbids. This holds in **every
+mode** — standard *and* 24h. The mode moves the threshold, never the obligation.
+
+**Read before you edit.** Read a file BEFORE your first `Edit` / `Write` / `MultiEdit` on
+it — for every path outside `.peaks/**` (source, tests, docs, config); `.peaks/**` writes
+are exempt. Skipping that read trips a `PreToolUse` gate (ECC's "Fact-Forcing Gate"),
+which denies the edit. **A denial is not a failure and the tool is not broken — your edit
+was not applied.** Read the file, state the facts the gate asks for (importers, affected
+API, data schemas if any, the user's verbatim instruction), then retry the same operation.
+Do not switch tools, do not give up, do not retry blindly.
+<!-- /peaks:loop-hygiene -->
+
 # Peaks-Loop Code Status (wrapper)
 
 Peaks-Loop Code Status is a thin wrapper that renders a compact status table for the current peaks-code orchestrator state. It is the answer to "I just want to know where we are" — no PRD, no RD, no QA, no full peaks-code orchestration. Just read the existing CLI state and render a 1-screen summary.

package/skills/peaks-test/SKILL.md

@@ -3,6 +3,30 @@ name: peaks-test
 description: Universal test-runner primitive for any in-flight Peaks-Loop workflow (orchestrator-agnostic). Runs the project's test suite on the current repo and reports results. Use when the user asks "run the tests", "跑一下 test", "跑测试" for ANY bee (peaks-code, future peaks-research, …). Triggers on "/peaks-test", "跑一下 test", "跑测试", "run the tests", "test now". (Replaces peaks-test as a top-level primitive.)
 ---
 
+<!-- peaks:loop-hygiene — generated block; keep byte-identical in every SKILL.md -->
+
+## Loop hygiene (every turn — MANDATORY)
+
+**Skill header.** While this skill is active, open every turn with
+`Peaks-Loop Skill: <skill> | Peaks-Loop Gate: <gate> | Next: <one short action>`.
+Every turn, not only the first — it is how the user knows which skill is driving.
+
+**Context is this skill's own business.** Run `peaks skill presence --json` every turn and
+read its `context` block. When `action` is `auto-fire`, `pre-compact`, or `red-line`,
+run `peaks code auto-compact --project .` **yourself**, then continue. Tell the user the
+ratio in one line if it helps, but never hand them the compaction step: asking the user to
+run `/compact` is the regression the zero-pause contract forbids. This holds in **every
+mode** — standard *and* 24h. The mode moves the threshold, never the obligation.
+
+**Read before you edit.** Read a file BEFORE your first `Edit` / `Write` / `MultiEdit` on
+it — for every path outside `.peaks/**` (source, tests, docs, config); `.peaks/**` writes
+are exempt. Skipping that read trips a `PreToolUse` gate (ECC's "Fact-Forcing Gate"),
+which denies the edit. **A denial is not a failure and the tool is not broken — your edit
+was not applied.** Read the file, state the facts the gate asks for (importers, affected
+API, data schemas if any, the user's verbatim instruction), then retry the same operation.
+Do not switch tools, do not give up, do not retry blindly.
+<!-- /peaks:loop-hygiene -->
+
 # Peaks-Loop Code Test (wrapper)
 
 Peaks-Loop Code Test is a thin wrapper that runs the project's test suite on the current repo and reports results. It is the answer to "I just want to see if the tests pass" — no PRD, no RD, no QA, no full peaks-code orchestration. Just `pnpm vitest run` and a compact summary.