peaks-loop 3.0.0

package/dist/src/services/standards/ide-aware-standards-service.d.ts

@@ -0,0 +1,94 @@
+/**
+ * IDE-aware wrapper for `peaks standards init` / `peaks standards update`.
+ *
+ * Slice #011-2026-06-07-ide-adapter-resource-profile: the original
+ * `executeProjectStandardsInit` / `executeProjectStandardsUpdate` always
+ * wrote to `CLAUDE.md` + `.claude/rules/**` regardless of which IDE
+ * the user was running. This wrapper dispatches on the IDE detected
+ * (or explicitly requested via `--ide`) and falls back to the legacy
+ * Claude Code path with a stderr warning when the detected IDE has
+ * no `standardsProfile` declared (Trae in slice 1.3.2).
+ *
+ * Two entry points:
+ *
+ *   - `executeProjectStandardsInitIdeAware` — same signature as the
+ *     underlying `executeProjectStandardsInit`, plus an optional
+ *     `ideId` override that bypasses detection.
+ *   - `executeProjectStandardsUpdateIdeAware` — same shape, for the
+ *     `update` flow.
+ *
+ * Detection precedence:
+ *   1. Explicit `options.ideId` (CLI `--ide` flag)
+ *   2. `IdeRegistry.detect()` from cwd (or the `projectRoot` if given)
+ *   3. `null` (no IDE detected) → fall back to the legacy Claude Code path
+ *
+ * Fallback behavior: when the resolved IDE has no `standardsProfile`
+ * declared, the wrapper STILL calls the legacy Claude Code writer
+ * (so the user gets the files they would have gotten before slice #011)
+ * and emits a stderr warning with the IDE id and the fact that the
+ * adapter is UNVERIFIED for the standards profile. This keeps the
+ * "Trae is UNVERIFIED, ship a working file tree, surface the gap"
+ * contract intact.
+ */
+import type { IdeId } from '../ide/ide-types.js';
+import { detectAllResourceTargets, getStandardsProfile } from '../ide/resource-profile.js';
+import { type ProjectStandardsInitOptions, type ProjectStandardsInitResult, type ProjectStandardsUpdateResult } from './project-standards-service.js';
+export type { ProjectStandardsInitResult, ProjectStandardsUpdateResult };
+export type ProjectStandardsIdeAwareOptions = ProjectStandardsInitOptions & {
+    /**
+     * Explicit IDE override. When set, bypasses `IdeRegistry.detect()`
+     * (cwd + env heuristics) and uses the provided IDE id directly.
+     * Mirrors the `peaks hooks install --ide <id>` pattern.
+     */
+    readonly ideId?: IdeId;
+};
+export type ProjectStandardsUpdateIdeAwareOptions = ProjectStandardsInitOptions & {
+    /** Explicit IDE override. See {@link ProjectStandardsIdeAwareOptions}. */
+    readonly ideId?: IdeId;
+};
+/**
+ * Resolve the active IDE id for a standards call. Order of precedence:
+ *   1. explicit `options.ideId`
+ *   2. `IdeRegistry.detect()` from `options.projectRoot`
+ *   3. `null` (no detected IDE — caller falls back to legacy)
+ */
+export declare function resolveStandardsIdeId(options: {
+    readonly projectRoot: string;
+    readonly ideId?: IdeId;
+}): IdeId | null;
+/**
+ * Run `peaks standards init` with IDE-aware dispatch.
+ *
+ * When the resolved IDE has a `standardsProfile`, the call still
+ * delegates to the existing `executeProjectStandardsInit` (the
+ * profile maps to the Claude Code path; future per-IDE writers
+ * plug in here). When the IDE is unregistered for the standards
+ * profile, the call delegates to the legacy path + emits a stderr
+ * warning.
+ */
+export declare function executeProjectStandardsInitIdeAware(options: ProjectStandardsIdeAwareOptions): ProjectStandardsInitResult;
+/**
+ * Run `peaks standards update` with IDE-aware dispatch.
+ *
+ * Same dispatch rules as `executeProjectStandardsInitIdeAware`.
+ */
+export declare function executeProjectStandardsUpdateIdeAware(options: ProjectStandardsUpdateIdeAwareOptions): ProjectStandardsUpdateResult;
+/**
+ * Test seam + integration-test helper: returns the resolved IDE id
+ * for the call, plus the active standards profile. Exported for
+ * the integration test in `tests/unit/standards/ide-aware-standards-service.test.ts`
+ * to assert the dispatch decision without running the full write.
+ */
+export declare function inspectStandardsDispatch(options: {
+    readonly projectRoot: string;
+    readonly ideId?: IdeId;
+}): {
+    readonly ideId: IdeId | null;
+    readonly profile: ReturnType<typeof getStandardsProfile>;
+};
+/**
+ * Test seam: the resource-profile accessor exposes
+ * `detectAllResourceTargets` for callers that need to enumerate
+ * across all registered IDEs. Re-exported here for convenience.
+ */
+export { detectAllResourceTargets };

package/dist/src/services/standards/ide-aware-standards-service.js

@@ -0,0 +1,89 @@
+import { detectAllResourceTargets, getStandardsProfile, } from '../ide/resource-profile.js';
+import { executeProjectStandardsInit, executeProjectStandardsUpdate, } from './project-standards-service.js';
+import { detectInstalledIde } from '../ide/ide-detector.js';
+function warnUnregisteredIde(ideId, projectRoot) {
+    process.stderr.write(`peaks standards: IDE '${ideId}' has no standardsProfile declared; ` +
+        `falling back to the legacy Claude Code path (CLAUDE.md + .claude/rules/**) ` +
+        `for project '${projectRoot}'. This is a slice #011 follow-up gap; ` +
+        `see .peaks/memory/ide-adapter-resource-profile-framework.md.\n`);
+}
+function warnNoIdeDetected(projectRoot) {
+    process.stderr.write(`peaks standards: no IDE detected in '${projectRoot}'; ` +
+        `writing to the legacy Claude Code path (CLAUDE.md + .claude/rules/**). ` +
+        `Pass --ide <id> to bypass detection.\n`);
+}
+/**
+ * Resolve the active IDE id for a standards call. Order of precedence:
+ *   1. explicit `options.ideId`
+ *   2. `IdeRegistry.detect()` from `options.projectRoot`
+ *   3. `null` (no detected IDE — caller falls back to legacy)
+ */
+export function resolveStandardsIdeId(options) {
+    if (options.ideId !== undefined) {
+        return options.ideId;
+    }
+    return detectInstalledIde(options.projectRoot);
+}
+/**
+ * Run `peaks standards init` with IDE-aware dispatch.
+ *
+ * When the resolved IDE has a `standardsProfile`, the call still
+ * delegates to the existing `executeProjectStandardsInit` (the
+ * profile maps to the Claude Code path; future per-IDE writers
+ * plug in here). When the IDE is unregistered for the standards
+ * profile, the call delegates to the legacy path + emits a stderr
+ * warning.
+ */
+export function executeProjectStandardsInitIdeAware(options) {
+    const ideId = resolveStandardsIdeId(options);
+    if (ideId === null) {
+        warnNoIdeDetected(options.projectRoot);
+        return executeProjectStandardsInit(options);
+    }
+    const profile = getStandardsProfile(ideId);
+    if (profile === null) {
+        warnUnregisteredIde(ideId, options.projectRoot);
+        return executeProjectStandardsInit(options);
+    }
+    // Claude Code path: profile matches the legacy writer. Future per-IDE
+    // writers (markdown+frontmatter, multiple rule roots, etc.) plug in
+    // here by branching on `profile.format` / `profile.rulesDir`.
+    return executeProjectStandardsInit(options);
+}
+/**
+ * Run `peaks standards update` with IDE-aware dispatch.
+ *
+ * Same dispatch rules as `executeProjectStandardsInitIdeAware`.
+ */
+export function executeProjectStandardsUpdateIdeAware(options) {
+    const ideId = resolveStandardsIdeId(options);
+    if (ideId === null) {
+        warnNoIdeDetected(options.projectRoot);
+        return executeProjectStandardsUpdate(options);
+    }
+    const profile = getStandardsProfile(ideId);
+    if (profile === null) {
+        warnUnregisteredIde(ideId, options.projectRoot);
+        return executeProjectStandardsUpdate(options);
+    }
+    return executeProjectStandardsUpdate(options);
+}
+/**
+ * Test seam + integration-test helper: returns the resolved IDE id
+ * for the call, plus the active standards profile. Exported for
+ * the integration test in `tests/unit/standards/ide-aware-standards-service.test.ts`
+ * to assert the dispatch decision without running the full write.
+ */
+export function inspectStandardsDispatch(options) {
+    const ideId = resolveStandardsIdeId(options);
+    if (ideId === null) {
+        return { ideId: null, profile: null };
+    }
+    return { ideId, profile: getStandardsProfile(ideId) };
+}
+/**
+ * Test seam: the resource-profile accessor exposes
+ * `detectAllResourceTargets` for callers that need to enumerate
+ * across all registered IDEs. Re-exported here for convenience.
+ */
+export { detectAllResourceTargets };

package/dist/src/services/standards/migrate-claude-rules-service.d.ts

@@ -0,0 +1,19 @@
+export interface MigrateClaudeRulesInput {
+    readonly projectRoot: string;
+    readonly apply?: boolean;
+}
+export interface MigrateClaudeRulesData {
+    readonly backupPath: string | null;
+    readonly thinnedFiles: readonly string[];
+    readonly scaffoldedFiles: readonly string[];
+    readonly preservedFiles: readonly string[];
+    readonly wouldChange: boolean;
+    readonly applied: boolean;
+    readonly nextActions: readonly string[];
+}
+export interface MigrateClaudeRulesResult {
+    readonly ok: true;
+    readonly data: MigrateClaudeRulesData;
+    readonly warnings: readonly string[];
+}
+export declare function migrateClaudeRules(input: MigrateClaudeRulesInput): MigrateClaudeRulesResult;

package/dist/src/services/standards/migrate-claude-rules-service.js

@@ -0,0 +1,193 @@
+/**
+ * peaks standards migrate — .claude/rules/ tree thinning.
+ * Slice: 2026-06-12-standards-migrate-claude-rules.
+ *
+ * The 1.x peaks-cli install copied a thick .claude/rules
+ * tree (skill-first / CLI-auxiliary / dogfood / commit-trailer
+ * rules) into consumer projects. In 2.0, the canonical rules
+ * live at .peaks/standards/ and every markdown file under
+ * .claude/rules becomes a 2-line pointer to the canonical path.
+ *
+ * The service:
+ *   1. Backs up the existing `.claude/rules/` tree to
+ *      `.claude/rules/.peaks-2.0-backup-<ts>/` (timestamped;
+ *      safe to run multiple times).
+ *   2. Replaces each .md file under .claude/rules (recursive)
+ *      with a 2-line pointer.
+ *   3. Scaffolds the 2.0 canonical rules at
+ *      `.peaks/standards/{common,typescript}/`, but
+ *      never overwrites existing files in `.peaks/standards/`.
+ *
+ * All operations are gated by `apply: true`. Dry-run mode
+ * returns the would-change diff without writing.
+ */
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+const POINTER_TEXT = (canonicalPath) => `# Canonical peaks-cli 2.0 rules live at: ${canonicalPath}\n# This file is a 2-line pointer. Edit the canonical file instead.\n`;
+function timestampSlug() {
+    return new Date().toISOString().replace(/[:.]/g, '-');
+}
+function readMarkdownFilesRecursive(root) {
+    if (!existsSync(root))
+        return [];
+    const out = [];
+    const stat = statSync(root);
+    if (stat.isFile()) {
+        return root.endsWith('.md') ? [root] : [];
+    }
+    if (!stat.isDirectory())
+        return [];
+    for (const entry of readdirSync(root)) {
+        out.push(...readMarkdownFilesRecursive(join(root, entry)));
+    }
+    return out;
+}
+function isAlreadyPointer(filePath) {
+    if (!existsSync(filePath))
+        return false;
+    try {
+        const body = readFileSync(filePath, 'utf8');
+        return body.includes('Canonical peaks-cli 2.0 rules live at:');
+    }
+    catch {
+        return false;
+    }
+}
+const CANONICAL_2_0_DEV_PREFERENCE = `# Peaks-Cli dev preference (2.0 canonical)
+
+> Project-local preference, captured from the 1.x install + re-rendered with the 2.0 vocabulary.
+> Scope: applies to every iteration, adjustment, fix, or tweak on this project.
+> Reading: read this **before** opening a new CLI command or routing a new feature through a CLI surface.
+
+## Rule 1 — Skill-first, CLI-auxiliary
+
+When designing or modifying a peaks-cli feature, default to the **skill-first** design. CLI commands are **invoked by the skill prompt** when they are the right primitive: a side effect that must be atomic, a gate that must be machine-enforced, a probe that needs structured JSON, or a backstop that prevents the LLM from skipping a step. Behaviour only an LLM in a skill prompt would use lives **in the relevant skill's SKILL.md**, not as a new CLI command. See \`.claude/rules/common/dev-preference.md\` for the decision template.
+
+## Rule 2 — Dogfood on every adjustment
+
+**Every adjustment, iteration, or fix-problem operation must be dogfood-tested in the current project before the work is declared complete.** No exceptions for "it's a small change", "just a comment update", or "just a SKILL.md line". The unit test suite is a subset of "current effect"; the dogfood is the full set. If a change passes unit tests but breaks a CLI command, the change is a regression.
+
+## Rule 3 — Commits belong to the human
+
+**No AI co-author trailer.** The commit is the human's. **Identity is global gitconfig only** (\`~/.gitconfig\`). Do not set, override, or shadow \`user.name\` / \`user.email\` at the repo level, via env vars, or via \`git -c user.*=...\`. The commit's recorded author and committer must both equal the global identity.
+`;
+const CANONICAL_2_0_CODING_STYLE_TS = `# TypeScript Coding Standards (2.0 canonical)
+
+> Project-local standards, derived from the 1.x install + re-rendered with the 2.0 vocabulary.
+
+- Apply project-local conventions before generic typescript guidance.
+- Keep public APIs typed or documented according to typescript ecosystem norms.
+- Do not add new \`any\` types; use explicit domain types, generics, or \`unknown\` with narrowing.
+- Prefer standard tooling and existing project scripts for formatting, linting, tests, and coverage.
+- peaks-rd must check this file before planning code changes in typescript projects.
+`;
+const CANONICAL_2_0_COMMON_FILES = [
+    { relPath: 'common/dev-preference.md', content: CANONICAL_2_0_DEV_PREFERENCE },
+    {
+        relPath: 'common/coding-style.md',
+        content: '# Coding Standards (2.0 canonical)\n\n- Prefer simple, readable code over clever abstractions.\n- Keep functions focused and files cohesive.\n- Use immutable updates unless a language-specific convention explicitly favors mutation.\n- Validate user input, external data, file paths, and configuration at system boundaries.\n- Preserve existing project conventions when they are stricter than this baseline.\n',
+    },
+    {
+        relPath: 'common/code-review.md',
+        content: '# Code Review Standards (2.0 canonical)\n\n- Review diffs for correctness, maintainability, test coverage, and regression risk.\n- Treat missing tests for changed behavior as a blocker unless the change is documentation-only.\n- Verify code paths that handle filesystem, external APIs, credentials, user input, or generated artifacts.\n',
+    },
+    {
+        relPath: 'common/security.md',
+        content: '# Security Review Standards (2.0 canonical)\n\n- Never hardcode secrets, API keys, passwords, tokens, or credentials.\n- Do not send private code or secrets to external services without explicit user authorization.\n- Guard filesystem writes against path traversal, symlink, and junction escapes.\n- Require explicit confirmation for destructive actions, external state changes, and credential use.\n',
+    },
+    { relPath: 'typescript/coding-style.md', content: CANONICAL_2_0_CODING_STYLE_TS },
+];
+export function migrateClaudeRules(input) {
+    const projectRoot = input.projectRoot;
+    const apply = input.apply === true;
+    const warnings = [];
+    const nextActions = [];
+    const claudeRulesDir = join(projectRoot, '.claude', 'rules');
+    const peaksStandardsDir = join(projectRoot, '.peaks', 'standards');
+    const canonicalRelPath = '.peaks/standards/';
+    const existingRulesFiles = readMarkdownFilesRecursive(claudeRulesDir);
+    const thickFiles = existingRulesFiles.filter((f) => !isAlreadyPointer(f));
+    const hasThickFiles = thickFiles.length > 0;
+    // The backup path is computed eagerly (so dry-run can preview
+    // the would-create location) but only created on disk in
+    // apply mode. In dry-run mode we still return the path so
+    // the user can see where the backup will land.
+    const computedBackupPath = hasThickFiles ? join(claudeRulesDir, `.peaks-2.0-backup-${timestampSlug()}`) : null;
+    const backupPath = apply ? computedBackupPath : null;
+    const thinnedFiles = [];
+    const scaffoldedFiles = [];
+    const preservedFiles = [];
+    // wouldChange is true iff there is at least one thick file to
+    // thin. An empty .claude/rules/ is NOT a wouldChange (no-op).
+    const wouldChange = hasThickFiles;
+    if (apply && hasThickFiles) {
+        // Step 1: backup
+        if (backupPath !== null) {
+            try {
+                mkdirSync(backupPath, { recursive: true });
+                for (const file of thickFiles) {
+                    const body = readFileSync(file, 'utf8');
+                    const rel = file.slice(claudeRulesDir.length + 1);
+                    writeFileSync(join(backupPath, rel), body, 'utf8');
+                }
+            }
+            catch (err) {
+                warnings.push(`Backup step failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        // Step 2: replace each .md with a 2-line pointer
+        for (const file of thickFiles) {
+            try {
+                writeFileSync(file, POINTER_TEXT(canonicalRelPath), 'utf8');
+                thinnedFiles.push(file);
+            }
+            catch (err) {
+                warnings.push(`Thin step failed for ${file}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        // Step 3: scaffold .peaks/standards/ — never overwrite existing
+        for (const file of CANONICAL_2_0_COMMON_FILES) {
+            const dest = join(peaksStandardsDir, file.relPath);
+            if (existsSync(dest)) {
+                preservedFiles.push(dest);
+                continue;
+            }
+            try {
+                mkdirSync(join(dest, '..'), { recursive: true });
+                writeFileSync(dest, file.content, 'utf8');
+                scaffoldedFiles.push(dest);
+            }
+            catch (err) {
+                warnings.push(`Scaffold step failed for ${file.relPath}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+    }
+    if (thinnedFiles.length > 0) {
+        nextActions.push(`Thinned ${thinnedFiles.length} .md file(s) under .claude/rules (recursive) → 2-line pointer.`);
+    }
+    if (scaffoldedFiles.length > 0) {
+        nextActions.push(`Scaffolded ${scaffoldedFiles.length} 2.0 canonical rule(s) at .peaks/standards/.`);
+    }
+    if (preservedFiles.length > 0) {
+        nextActions.push(`Preserved ${preservedFiles.length} existing .peaks/standards/ file(s) (no overwrite).`);
+    }
+    if (backupPath !== null) {
+        nextActions.push(`Backup at ${backupPath} (git-ignored).`);
+    }
+    if (!apply && wouldChange) {
+        nextActions.push('Re-run with --apply to perform the migration.');
+    }
+    return {
+        ok: true,
+        data: {
+            backupPath,
+            thinnedFiles,
+            scaffoldedFiles,
+            preservedFiles,
+            wouldChange,
+            applied: apply && hasThickFiles,
+            nextActions,
+        },
+        warnings,
+    };
+}

package/dist/src/services/standards/migrate-service.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Slice 028 (Q2=A): `peaks standards migrate` rewrites a consumer
+ * project's `CLAUDE.md` to drop the legacy heartbeat block.
+ *
+ * The legacy block (rendered by `peaks standards init` / `peaks
+ * standards update` before slice 028) contained instructions that:
+ *   1. pointed the LLM at the legacy `.peaks/.active-skill.json` path;
+ *   2. required the LLM to invoke `peaks skill heartbeat:touch` and
+ *      `peaks skill presence:clear` on every turn;
+ *   3. ended with an `External reference: https://github.com/affaan-m/...`
+ *      line that was peaks-cli-internal, not consumer-facing.
+ *
+ * The replacement text matches the post-slice-025 peaks-cli repo's own
+ * `CLAUDE.md`: route the LLM through `peaks skill presence --json` and
+ * render a compact status header when a valid skill is active. This
+ * service is the deterministic in-place rewriter that brings existing
+ * consumer trees in line with the new template.
+ *
+ * Behavior:
+ *   - `migrateStandards({ project, apply: true })`     — rewrites the
+ *     file when the legacy block is present, returns
+ *     `applied: true`.
+ *   - `migrateStandards({ project, dryRun: true })`    — returns the
+ *     would-change preview, no write.
+ *   - `migrateStandards({ project })`                  — defaults to a
+ *     dry-run. `--apply` is the only opt-in for a destructive write.
+ *   - File missing → `file: null`, no throw.
+ *   - Legacy block not present → `foundOldBlock: false`, no write.
+ */
+export declare const NEW_TEMPLATE_TEXT = "Active Peaks-Cli skill presence: at the start of every response, run `peaks skill presence --json` to read the active skill marker. The CLI handles canonical-path resolution (`.peaks/_runtime/active-skill.json` with back-compat fallback to `.peaks/.active-skill.json`); do not read those files directly. When the response includes a valid skill name, display the compact status header: `Peaks-Cli Skill: <skill> | Peaks-Cli Gate: <gate> | Next: <one short action>`. Display the header on every turn while the CLI returns an active skill; omit when the CLI returns no active skill.";
+export type MigrateStandardsInput = {
+    project: string;
+    apply?: boolean;
+    dryRun?: boolean;
+};
+export type MigrateStandardsData = {
+    file: string | null;
+    foundOldBlock: boolean;
+    wouldChange: boolean;
+    applied: boolean;
+    before: {
+        lines: number;
+    } | null;
+    after: {
+        lines: number;
+    } | null;
+    nextActions: string[];
+};
+export type MigrateStandardsResult = {
+    ok: true;
+    data: MigrateStandardsData;
+    warnings: string[];
+};
+export declare function detectLegacyBlock(content: string): {
+    found: boolean;
+    start: number;
+    end: number;
+};
+export declare function rewriteLegacyBlock(content: string, newText?: string): {
+    rewritten: string;
+    replaced: boolean;
+};
+export declare function migrateStandards(input: MigrateStandardsInput): MigrateStandardsResult;

package/dist/src/services/standards/migrate-service.js

@@ -0,0 +1,193 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { isAbsolute, resolve } from 'node:path';
+/**
+ * Slice 028 (Q2=A): `peaks standards migrate` rewrites a consumer
+ * project's `CLAUDE.md` to drop the legacy heartbeat block.
+ *
+ * The legacy block (rendered by `peaks standards init` / `peaks
+ * standards update` before slice 028) contained instructions that:
+ *   1. pointed the LLM at the legacy `.peaks/.active-skill.json` path;
+ *   2. required the LLM to invoke `peaks skill heartbeat:touch` and
+ *      `peaks skill presence:clear` on every turn;
+ *   3. ended with an `External reference: https://github.com/affaan-m/...`
+ *      line that was peaks-cli-internal, not consumer-facing.
+ *
+ * The replacement text matches the post-slice-025 peaks-cli repo's own
+ * `CLAUDE.md`: route the LLM through `peaks skill presence --json` and
+ * render a compact status header when a valid skill is active. This
+ * service is the deterministic in-place rewriter that brings existing
+ * consumer trees in line with the new template.
+ *
+ * Behavior:
+ *   - `migrateStandards({ project, apply: true })`     — rewrites the
+ *     file when the legacy block is present, returns
+ *     `applied: true`.
+ *   - `migrateStandards({ project, dryRun: true })`    — returns the
+ *     would-change preview, no write.
+ *   - `migrateStandards({ project })`                  — defaults to a
+ *     dry-run. `--apply` is the only opt-in for a destructive write.
+ *   - File missing → `file: null`, no throw.
+ *   - Legacy block not present → `foundOldBlock: false`, no write.
+ */
+export const NEW_TEMPLATE_TEXT = 'Active Peaks-Cli skill presence: at the start of every response, run `peaks skill presence --json` to read the active skill marker. The CLI handles canonical-path resolution (`.peaks/_runtime/active-skill.json` with back-compat fallback to `.peaks/.active-skill.json`); do not read those files directly. When the response includes a valid skill name, display the compact status header: `Peaks-Cli Skill: <skill> | Peaks-Cli Gate: <gate> | Next: <one short action>`. Display the header on every turn while the CLI returns an active skill; omit when the CLI returns no active skill.';
+const LEGACY_BLOCK_OPENER_LINE = 'Peaks-Cli 心跳检测 (heartbeat check)';
+const LEGACY_BLOCK_CLOSER = 'External reference: https://github.com/affaan-m/everything-claude-code';
+const LEGACY_MARKER_FALLBACK = 'Do NOT skip step 3-5. The CLI heartbeat:touch command';
+const FORBIDDEN_LEGACY_STRINGS = [
+    'heartbeat:touch',
+    'presence:clear',
+    'Default runbook',
+    'Startup sequence',
+    'Swarm parallel phase'
+];
+const NEW_TEMPLATE_FINGERPRINT = 'peaks skill presence --json';
+export function detectLegacyBlock(content) {
+    const openerIndex = content.indexOf(LEGACY_BLOCK_OPENER_LINE);
+    if (openerIndex >= 0) {
+        // Walk back to the start of the `<!--` line. The opener text is
+        // typically indented on the line after `<!--` (the legacy block
+        // is a multi-line HTML comment), so we cut from the most recent
+        // `<!--` line above. If no `<!--` is found in the surrounding
+        // 4 lines, fall back to the start of the opener's own line.
+        const htmlCommentIndex = content.lastIndexOf('<!--', openerIndex);
+        const previousNewlineBeforeOpener = content.lastIndexOf('\n', openerIndex);
+        let start;
+        if (htmlCommentIndex < 0 || htmlCommentIndex < previousNewlineBeforeOpener - 200) {
+            // No `<!--` line within a reasonable distance — start of the
+            // opener's own line.
+            start = previousNewlineBeforeOpener + 1;
+        }
+        else {
+            start = content.lastIndexOf('\n', htmlCommentIndex) + 1;
+        }
+        const closerIndex = content.indexOf(LEGACY_BLOCK_CLOSER, openerIndex);
+        let endIndex;
+        if (closerIndex < 0) {
+            const tailIndex = content.indexOf(LEGACY_MARKER_FALLBACK, openerIndex);
+            if (tailIndex < 0) {
+                endIndex = content.length;
+            }
+            else {
+                endIndex = content.indexOf('\n', tailIndex);
+                if (endIndex < 0)
+                    endIndex = content.length;
+            }
+        }
+        else {
+            endIndex = content.indexOf('\n', closerIndex);
+            if (endIndex < 0)
+                endIndex = content.length;
+        }
+        return { found: true, start, end: endIndex };
+    }
+    // Fallback: opener stripped by editor / re-format. Detect by the
+    // first forbidden string that survives the rewrite, then walk back
+    // to the start of the line.
+    for (const marker of FORBIDDEN_LEGACY_STRINGS) {
+        const idx = content.indexOf(marker);
+        if (idx >= 0) {
+            const start = content.lastIndexOf('\n', idx) + 1;
+            return { found: true, start, end: content.length };
+        }
+    }
+    return { found: false, start: -1, end: -1 };
+}
+export function rewriteLegacyBlock(content, newText = NEW_TEMPLATE_TEXT) {
+    const detection = detectLegacyBlock(content);
+    if (!detection.found) {
+        return { rewritten: content, replaced: false };
+    }
+    const before = content.slice(0, detection.start);
+    const after = content.slice(detection.end);
+    const trimmedBefore = before.replace(/\s+$/u, '\n');
+    const cleanedAfter = after.replace(/^\n+/u, '\n');
+    const rewritten = `${trimmedBefore}${newText}${cleanedAfter}`;
+    return { rewritten, replaced: true };
+}
+export function migrateStandards(input) {
+    const project = input.project;
+    const projectRoot = isAbsolute(project) ? project : resolve(project);
+    const filePath = resolve(projectRoot, 'CLAUDE.md');
+    const apply = input.apply === true;
+    const dryRun = input.dryRun === true || apply === false;
+    if (!existsSync(filePath)) {
+        return {
+            ok: true,
+            data: {
+                file: null,
+                foundOldBlock: false,
+                wouldChange: false,
+                applied: false,
+                before: null,
+                after: null,
+                nextActions: ['CLAUDE.md does not exist; nothing to migrate']
+            },
+            warnings: []
+        };
+    }
+    const original = readFileSync(filePath, 'utf8');
+    const detection = detectLegacyBlock(original);
+    if (!detection.found) {
+        if (original.includes(NEW_TEMPLATE_FINGERPRINT)) {
+            return {
+                ok: true,
+                data: {
+                    file: filePath,
+                    foundOldBlock: false,
+                    wouldChange: false,
+                    applied: false,
+                    before: { lines: original.split('\n').length },
+                    after: null,
+                    nextActions: ['CLAUDE.md is already up to date']
+                },
+                warnings: []
+            };
+        }
+        return {
+            ok: true,
+            data: {
+                file: filePath,
+                foundOldBlock: false,
+                wouldChange: false,
+                applied: false,
+                before: { lines: original.split('\n').length },
+                after: null,
+                nextActions: ['CLAUDE.md has no peaks-cli block; nothing to migrate']
+            },
+            warnings: []
+        };
+    }
+    const { rewritten } = rewriteLegacyBlock(original);
+    const nextActions = [];
+    if (dryRun) {
+        nextActions.push('Re-run with --apply to perform the rewrite');
+        return {
+            ok: true,
+            data: {
+                file: filePath,
+                foundOldBlock: true,
+                wouldChange: true,
+                applied: false,
+                before: { lines: original.split('\n').length },
+                after: { lines: rewritten.split('\n').length },
+                nextActions
+            },
+            warnings: []
+        };
+    }
+    writeFileSync(filePath, rewritten, 'utf8');
+    nextActions.push('CLAUDE.md rewritten; no further action required');
+    return {
+        ok: true,
+        data: {
+            file: filePath,
+            foundOldBlock: true,
+            wouldChange: true,
+            applied: true,
+            before: { lines: original.split('\n').length },
+            after: { lines: rewritten.split('\n').length },
+            nextActions
+        },
+        warnings: []
+    };
+}