peaks-loop 4.0.0-beta → 4.0.0-beta.11

package/dist/services/standards/loop-engineering-readiness-lint.js

@@ -0,0 +1,248 @@
+/**
+ * Loop Engineering Readiness linter (M6 — peak-spec §7.5 + §8.4).
+ *
+ * Pure function: takes the raw markdown text of a peaks-* SKILL.md
+ * file and returns either
+ *   { ok: true, findings: [] }
+ * or
+ *   { ok: false, findings: string[] }.
+ *
+ * The lint asserts three structural properties the spec binds every
+ * Loop-Engineering-participating peaks-* skill to:
+ *
+ *   1. The skill references the shared guideline file
+ *      `.peaks/standards/loop-engineering-guidelines.md` (or its
+ *      alias `.peaks/standards/loop-engineering-guidelines.md`).
+ *      Reference may appear anywhere in the body — code fence,
+ *      plain prose, or list item — as long as the literal token is
+ *      present.
+ *
+ *   2. The skill does NOT introduce a CLI verb that bypasses the
+ *      LLM-coordinated model. We flag lines that look like
+ *      "Run `peaks <verb>` to …" where `<verb>` is not in the
+ *      allowlist of LLM-owned sediment / asset / evolution verbs.
+ *      The user types NL; the LLM runs the CLI on the user's behalf
+ *      (RL-1 / Human-NL-Choice-Only).
+ *
+ *   3. The skill does NOT introduce a JSON / manifest
+ *      hand-authoring surface. We flag lines containing phrases
+ *      like "Edit the manifest", "write the JSON", "fill the JSON
+ *      file", etc., when they are not part of an explicit allowlist
+ *      (allowlist only references; never an instructional phrase).
+ *
+ * Each finding is a single line of the form:
+ *   "<rule>: <offending excerpt>"
+ * so a downstream CLI can render it directly without further
+ * parsing.
+ *
+ * The lint intentionally does NOT touch any application-level
+ * code; it only parses a SKILL.md text. The peaks CLI command
+ * `peaks skill lint --category loop-engineering-readiness
+ *   --path <skill-dir>`
+ * (registered in src/cli/commands/skill-loop-engineering-readiness.ts)
+ * reads the SKILL.md from disk and calls this function.
+ *
+ * Per RL-1 / Human-NL-Choice-Only and
+ * `.peaks/memory/two-forms-only-rule.md`, the user only ever picks
+ * via AskUserQuestion or describes in NL; the LLM runs the CLI.
+ * This lint is what stops a future peaks-* skill from regressing
+ * that rule at the textual layer.
+ */
+/**
+ * The shared guideline file that every Loop-Engineering-participating
+ * peaks-* skill must reference. Both the canonical path and the
+ * common alias are accepted.
+ *
+ * The alias is intentionally identical to the canonical path here:
+ * the spec sometimes renders it as
+ *   `.peaks/standards/loop-engineering-guidelines.md`
+ * with a slash prefix and sometimes without. We accept both.
+ */
+export const LOOP_ENGINEERING_GUIDELINE_PATHS = [
+    '.peaks/standards/loop-engineering-guidelines.md',
+];
+/**
+ * The allowlist of CLI verbs that a peaks-* SKILL.md may legitimately
+ * instruct an LLM to invoke on the user's behalf. These are the
+ * sediment / asset / evolution surface verbs introduced in
+ * 2026-07-07-loop-engineering-crystallization-design §7.4 plus the
+ * 18-verb sediment pool from 2026-07-04-peaks-maker-dynamic-skill-
+ * sediment-design §4.2.
+ *
+ * Any other `peaks <verb>` token that appears in the form
+ *   "Run `peaks <verb>` to …"
+ * is treated as a CLI-verb-bypass attempt and flagged.
+ */
+export const ALLOWED_CLI_VERBS = new Set([
+    // sediment pool verbs (M6 reference; peak-maker's owned surface)
+    'add-segment',
+    'add-bee',
+    'refine-bee',
+    'clone-bee',
+    'promote',
+    'retire',
+    'dispose',
+    'releases',
+    'release-show',
+    'release-diff',
+    'export',
+    'import',
+    'gc-blobs',
+    'list',
+    'show',
+    'search',
+    'recent',
+    'rebuild-index',
+    // loop crystallizer surface (§7.4)
+    'loop',
+    'crystallize',
+    // evolution ratchet surface (§7.4)
+    'evolution',
+    'propose',
+    'evaluate',
+    'revert',
+    'mark-keep',
+    // umbrella asset surface (§7.4)
+    'asset',
+    'status',
+    // adapter surface (peaks-maker's owned skill runtime)
+    'adapter',
+    // lint surface (this command's own kind)
+    'lint',
+    'standards',
+    'skill',
+    'ready',
+]);
+/**
+ * Phrases that constitute a JSON / manifest hand-authoring surface.
+ * If a SKILL.md instructs the user to perform one of these actions,
+ * it violates RL-1 / Human-NL-Choice-Only and is flagged.
+ *
+ * Each entry is a lowercase substring matched against each line of
+ * the SKILL.md. The match is case-insensitive; the surrounding
+ * `<verb>` placeholders in the original spec are matched literally.
+ */
+export const JSON_HAND_AUTHORING_PHRASES = [
+    'edit the manifest',
+    'edit your manifest',
+    'edit the json',
+    'edit the .json file',
+    'write the json',
+    'write the json manifest',
+    'write the manifest json',
+    'fill the json',
+    'fill in the json',
+    'fill in the manifest',
+    'fill in the manifest.json',
+    'hand-author the manifest',
+    'hand-author the json',
+    'open the manifest and',
+    'open the manifest.json and',
+    'manually edit the manifest',
+    'manually edit the json',
+];
+/**
+ * Phrases that explicitly reference a JSON / manifest surface but
+ * in an ALLOWED way — e.g. "the manifest is written by the CLI" or
+ * "see manifest schema for details". A line that contains one of
+ * these allowlisted phrases is NOT flagged even if it contains a
+ * JSON-hand-authoring phrase elsewhere on the same line.
+ *
+ * The allowlist is intentionally narrow; it must mention either
+ * the CLI as the writer OR a schema reference, NOT an instructional
+ * verb targeting the user.
+ */
+export const JSON_REFERENCE_ALLOWLIST = [
+    'the cli writes',
+    'written by the cli',
+    'written by peaks',
+    'manifest schema',
+    'see the manifest schema',
+    'see manifest schema',
+    'schema_version',
+    'peaks.bundle/1',
+    'peaks.loop/1',
+    'peaks.bee/1',
+];
+// ---------------------------------------------------------------------------
+// Pure function
+// ---------------------------------------------------------------------------
+/**
+ * Lint a SKILL.md text for Loop Engineering readiness.
+ *
+ * @param skillMdText raw markdown text of a peaks-* SKILL.md
+ * @returns a ReadinessLintResult
+ */
+export function lintSkillLoopEngineeringReadiness(skillMdText) {
+    const findings = [];
+    if (typeof skillMdText !== 'string' || skillMdText.trim().length === 0) {
+        return {
+            ok: false,
+            findings: ['skill-md-empty: SKILL.md text is empty or missing'],
+        };
+    }
+    checkGuidelineReference(skillMdText, findings);
+    checkCliVerbBypass(skillMdText, findings);
+    checkJsonHandAuthoring(skillMdText, findings);
+    if (findings.length > 0) {
+        return { ok: false, findings };
+    }
+    return { ok: true, findings: [] };
+}
+// ---------------------------------------------------------------------------
+// Individual checks
+// ---------------------------------------------------------------------------
+function checkGuidelineReference(text, findings) {
+    // Strip code fences before checking — references inside ``` blocks
+    // are still valid references (the lint accepts them), but we strip
+    // so the substring match is unambiguous.
+    const stripped = text;
+    for (const ref of LOOP_ENGINEERING_GUIDELINE_PATHS) {
+        if (stripped.includes(ref)) {
+            return;
+        }
+    }
+    findings.push(`missing-guideline-reference: SKILL.md must reference ${LOOP_ENGINEERING_GUIDELINE_PATHS[0]} (spec §7.5 / §8.4 / RL-8)`);
+}
+function checkCliVerbBypass(text, findings) {
+    // Match lines that contain `peaks <verb>` in a run-this-command
+    // pattern: "Run `peaks <verb>` to …" or "`peaks <verb>` to …" or
+    // "use `peaks <verb>` to …".
+    //
+    // The regex is intentionally narrow: it requires backticks around
+    // `peaks <verb>` so prose that mentions "peaks <verb>" as a noun
+    // (e.g. "peaks skill sediment list") is not flagged. The verb
+    // token is captured as the first `[a-z][a-z0-9-]*` chunk after
+    // "peaks "; everything between the verb and the closing backtick
+    // is allowed (e.g. `peaks custom-evolve my-bee` — verb is
+    // "custom-evolve", args are "my-bee").
+    const lineRegex = /^\s*[-*]?\s*(?:Run|Use|Type|Execute)\s+`peaks\s+([a-z][a-z0-9-]*)[^`]*`/gim;
+    const lines = text.split(/\r?\n/);
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        let m;
+        lineRegex.lastIndex = 0;
+        while ((m = lineRegex.exec(line)) !== null) {
+            const verb = m[1];
+            if (!ALLOWED_CLI_VERBS.has(verb)) {
+                const excerpt = line.trim().slice(0, 120);
+                findings.push(`cli-verb-bypass: line ${i + 1} introduces CLI verb \`peaks ${verb}\` to be typed by the user (${excerpt}) — only LLM-coordinated verbs from the sediment/asset/evolution surface are allowed (RL-1)`);
+            }
+        }
+    }
+}
+function checkJsonHandAuthoring(text, findings) {
+    const lines = text.split(/\r?\n/);
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const lowered = line.toLowerCase();
+        const matchedPhrase = JSON_HAND_AUTHORING_PHRASES.find((p) => lowered.includes(p));
+        if (!matchedPhrase)
+            continue;
+        const isAllowlisted = JSON_REFERENCE_ALLOWLIST.some((p) => lowered.includes(p));
+        if (isAllowlisted)
+            continue;
+        const excerpt = line.trim().slice(0, 120);
+        findings.push(`json-hand-authoring: line ${i + 1} introduces JSON / manifest hand-authoring surface ("${matchedPhrase}") — ${excerpt} (RL-1: user only picks or describes in NL)`);
+    }
+}

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

@@ -0,0 +1,214 @@
+/**
+ * peaks standards migrate — .claude/rules/ tree thinning.
+ * Slice: 2026-06-12-standards-migrate-claude-rules.
+ *
+ * The 1.x peaks-loop 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 { dirname, join } from 'node:path';
+const POINTER_TEXT = (canonicalPath) => `# Canonical peaks-loop 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-loop 2.0 rules live at:');
+    }
+    catch {
+        return false;
+    }
+}
+const CANONICAL_2_0_DEV_PREFERENCE = `# Peaks-Loop 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-loop 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);
+    // Exclude any prior `.peaks-2.0-backup-*` directory created by an
+    // earlier migration run. The backup is real content (not a pointer),
+    // so without this filter a second run would treat the backup dir as
+    // a fresh thick tree and re-thin / re-scaffold over it
+    // (slice 2026-07-15-ice-cola-dogfood).
+    const BACKUP_DIR_PREFIX = '.peaks-2.0-backup-';
+    const thickFiles = existingRulesFiles.filter((f) => {
+        if (isAlreadyPointer(f))
+            return false;
+        const relFromRules = f.slice(claudeRulesDir.length + 1);
+        const topSegment = relFromRules.split(/[\\/]/, 1)[0] ?? '';
+        return !topSegment.startsWith(BACKUP_DIR_PREFIX);
+    });
+    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);
+                    const destPath = join(backupPath, rel);
+                    // Each subdirectory under .claude/rules/ (e.g. common/,
+                    // typescript/) needs to be materialised before writing —
+                    // `mkdirSync(backupPath, { recursive: true })` only creates
+                    // the top-level backup dir, not the nested language pack
+                    // dirs. Without this mkdirSync, the first file written to
+                    // a nested subdir ENOENTs and the whole backup silently
+                    // becomes empty (slice 2026-07-15-ice-cola-dogfood).
+                    mkdirSync(dirname(destPath), { recursive: true });
+                    writeFileSync(destPath, 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/services/standards/missing-standards-detector.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Slice 2026-06-16-peaks-code-auto-scaffold (RD#7) — missing-standards-detector.
+ *
+ * Read-side companion to the `peaks standards init` / `peaks standards update`
+ * writers in `./project-standards-service.ts`. The writer KNOWS how to scaffold
+ * `.peaks/standards/{common,<language>}/` (2.0 canonical) from the curated
+ * baseline; this module detects when the consumer project's rules tree is
+ * missing or empty and emits a copy-pasteable diagnostic for the operator.
+ *
+ * Why a separate read module: the writer is `apply`-gated and write-bounded
+ * (it touches the filesystem via `prevalidateWrites`/`assertNotHomedirBaseline`).
+ * The detector is read-only and platform-aware (win32 path separators for
+ * Windows consumers) — coupling the two would force the writer to grow a
+ * read-only flag and a platform-switching argument.
+ *
+ * Cross-platform path rendering (AC6): the detector switches on
+ * `process.platform` and renders the project path with `path.sep` so Windows
+ * consumers see `C:\Users\<u>\project\.claude\rules\` verbatim rather than the
+ * POSIX form. The detection logic itself (readdirSync on `node:fs`) is
+ * platform-neutral.
+ *
+ * Once-per-session dedup (AC7): `peaks workspace init` writes a marker at
+ * `.peaks/_runtime/<sessionId>/.standards-checked` after the first detection
+ * pass. `detectMissingProjectStandards` does NOT consult the marker — that's
+ * the caller's responsibility (the CLI command decides whether to skip per
+ * AC7's "once per session" contract).
+ */
+import type { StandardsLanguage } from './project-standards-service.js';
+export type MissingProjectStandardsDiagnostic = {
+    readonly missing: boolean;
+    /**
+     * Absolute path to the rules root (`<projectRoot>/.claude/rules`). Rendered
+     * with the platform-native separator so Windows consumers see
+     * `C:\...\.claude\rules` verbatim.
+     */
+    readonly path: string;
+    /**
+     * Copy-pasteable remediation hint for the operator. Always present, even
+     * when `missing: false`, so downstream callers can show "if you ever need
+     * to re-scaffold: ..." as a nextAction without re-running the detector.
+     */
+    readonly remediation: string;
+    readonly language: StandardsLanguage;
+};
+/**
+ * Detect whether a consumer project's `.peaks/standards/` tree (2.0
+ * canonical) is missing or empty.
+ *
+ * Rules (per PRD R2, slice 2026-07-15):
+ *   - `.peaks/standards/common/` MUST exist AND contain at least one
+ *     `.md` file.
+ *   - `.peaks/standards/<language>/` MUST exist AND contain at least one
+ *     `.md` file — except for `generic`, where the language dir is
+ *     OPTIONAL.
+ *
+ * Returns `{ missing: true, ... }` when either required dir is absent or
+ * empty. The diagnostic is always populated so the caller can surface the
+ * remediation hint unconditionally (the CLI uses the same string for both
+ * the stderr banner and the JSON envelope warning).
+ */
+export declare function detectMissingProjectStandards(projectRoot: string, language: StandardsLanguage): MissingProjectStandardsDiagnostic;
+/**
+ * Once-per-session marker file path. The CLI writes this file under
+ * `.peaks/_runtime/<sessionId>/` after the first diagnostic pass so that
+ * subsequent `peaks workspace init` invocations within the same session
+ * skip the stderr banner (the diagnostic is still computable for
+ * programmatic consumers via `detectMissingProjectStandards`).
+ */
+export declare function getStandardsCheckedMarkerPath(projectRoot: string, sessionId: string): string;
+/**
+ * Mark this session as "standards checked" so subsequent invocations can
+ * skip the stderr diagnostic. Idempotent: existing marker is left as-is.
+ * Returns true if the marker was newly created, false if it already existed.
+ */
+export declare function markStandardsChecked(projectRoot: string, sessionId: string): boolean;
+/**
+ * Test seam: check whether the once-per-session marker exists. Caller is
+ * responsible for routing the result into the AC7 dedup logic.
+ */
+export declare function hasStandardsCheckedMarker(projectRoot: string, sessionId: string): boolean;
+export declare const platformPathSeparator: "\\" | "/";