peaks-loop 4.0.37 → 4.0.39

package/skills/bee/peaks-prd/SKILL.md

@@ -7,6 +7,30 @@ description: |
   acceptance criteria, product change proposals, or user-confirmable product artifacts.
 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 PRD

package/skills/bee/peaks-qa/SKILL.md

@@ -7,6 +7,30 @@ description: |
   baseline reports, validation reports, acceptance checks, or refactor verification gates.
 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 -->
 ---
 
 ## Single-scope-axis naming convention

package/skills/bee/peaks-rd/SKILL.md

@@ -8,6 +8,30 @@ description: |
   Always use this for Peaks-Loop refactor workflows.
 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 -->
 ---
 
 ## Single-scope-axis naming convention

package/skills/bee/peaks-reviewer/SKILL.md

@@ -4,6 +4,30 @@ visibility: internal
 description: Third-party independent code-review skill for Peaks. Use as a parallel reviewer to karpathy-reviewer when a workflow needs an out-of-band (non-RD-model) review pass to mitigate single-LLM self-dogfood blind spots. Emits a schema-validated ReviewerEnvelope (no free-form LLM JSON). v2.14.0 G4.
 ---
 
+<!-- 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/bee/peaks-sc/SKILL.md

@@ -7,6 +7,30 @@ description: |
   GitHub artifact repository pointers, sync state, or rollback evidence.
 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 SC

package/skills/bee/peaks-security-audit/SKILL.md

@@ -12,6 +12,30 @@ metadata:
     - schema: .peaks/project-scan/audit-output-schema.md
 ---
 
+<!-- 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-security-audit
 
 > **Independent security audit skill** — separate from `peaks-rd`'s

package/skills/bee/peaks-txt/SKILL.md

@@ -7,6 +7,30 @@ description: |
   assumptions, discarded options, staleness checks, lessons, or reusable project memory.
 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 TXT

package/skills/bee/peaks-ui/SKILL.md

@@ -7,6 +7,30 @@ description: |
   frontend page behavior, high-fidelity HTML prototypes, or UI regression seeds.
 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 UI

package/skills/peaks-audit/SKILL.md

@@ -3,6 +3,30 @@ name: peaks-audit
 description: Gate autonomous LLM work on a 6-dimension audit + user-accepted goal. Use IMMEDIATELY after a need is expressed, BEFORE any PRD/RD/QA work starts.
 ---
 
+<!-- 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-code/SKILL.md

@@ -3,6 +3,30 @@ name: peaks-code
 description: Code-domain loop engineering orchestrator for the Peaks-Loop skill family. Use when the user asks Peaks-Loop to handle a code-repo workflow end-to-end (端到端/全流程/需求开发), especially from a product document (PRD/飞书文档/Feishu doc) through implementation and validation. Coordinates peaks-prd, peaks-rd, peaks-qa, peaks-ui, peaks-sc, and peaks-txt while preserving user confirmation gates. Triggers on `/peaks-code`, "peaks code", "全流程开发", "端到端迭代". General primitives (peaks-resume / peaks-status / peaks-test) are sibling skills, not children.
 ---
 
+<!-- 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 -->
+
 > **Detached sub-agent mode (Phase A, slice 2026-08-10).** When the orchestrator requires true parallelism with isolated context windows and survives orchestrator session exit, dispatch sub-agents with `--mode detached --vendor <claude|codex|copilot>`. The CLI spawns a real OS process via `ProcessSupervisor` (Windows `DETACHED_PROCESS` + `CREATE_NEW_PROCESS_GROUP`, POSIX `setsid` + `nohup`); the child vendor LLM receives a 5–8KB minimum prompt slice (no orchestrator session history) and self-compacts at 0.85 / 0.95 against the vendor window via the `<peaks-auto-compact>` marker (G8 — unlimited spend authorized). Orchestrator MUST emit one line of prose before every detached dispatch: `⏳ Spawning detached sub-agent via <vendor>: rid=<rid> (ETA ~60s)`. Status is read from `.peaks/_runtime/<sid>/detached/<rid>/status.json`; `LifecycleOwner` enforces 100% cleanup of `pid` / `log.txt` / `status.json` / `owner-session` on every exit path. `--no-throttle --max-concurrent <N>` bypasses `ResourceBudgetGuard` (user accepts risk; default max=8). See `references/sub-agent-dispatch.md` §"Detached Mode" for the full contract. Default mode remains `in-process` for backward compat (existing 106+ dispatch tests untouched).
 ---
 

package/skills/peaks-content/SKILL.md

@@ -3,6 +3,30 @@ name: peaks-content
 description: Non-code orchestrator for content workflows (draft / edit / publish / archive). Use when a user wants to drive an end-to-end content-production loop (blog post, newsletter, marketing copy, social thread, doc page) where the LLM must coordinate draft / edit / tone / publish / archive stages with explicit gates between them, and where the user only wants to speak natural language and pick options. NOT for free-form chatting; NOT for code review. Reuses the peaks-loop Loop Engineering primitives (Loop Engineering Asset, Bee Asset, Workflow Trace, Evolution Evaluation) but does NOT import peaks-code internals. Triggers on `/peaks-content`, "peaks content", "content workflow", "publish this to <channel>", "edit the draft", "archive the previous version".
 ---
 
+<!-- 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-content
 
 `peaks-content` is the **content-domain** orchestrator for peaks-loop. It drives an end-to-end content-production loop — draft, edit, publish, archive — through LLM-mediated sub-agents (the "bees") so a non-technical user can produce a polished, channel-ready piece of writing by speaking natural language and picking from multi-choice options. The user never types a CLI verb; the user never hand-authors markdown or JSON; the LLM runs every structured operation on the user's behalf.

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.