peaks-loop 4.0.0-beta.8 → 4.0.0-beta.9

package/dist/services/sop/sop-registry-service.js

@@ -0,0 +1,89 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { lintSop } from './sop-service.js';
+import { scopedRegistryPath, scopedSopManifestPath } from './sop-paths.js';
+/** Manifest location relative to its Peaks home (`~/.peaks/` or `<project>/.peaks/`). Machine-independent. */
+function relativeManifestPath(id) {
+    return `sops/${id}/sop.json`;
+}
+function countGates(sops) {
+    // Tolerate a hand-edited / corrupted registry: a malformed entry counts as 0
+    // gates rather than crashing the read-only `sop registry` command.
+    return sops.reduce((total, sop) => total + (Array.isArray(sop?.gates) ? sop.gates.length : 0), 0);
+}
+/** Read a single registry layer; empty when absent. Throws on corrupt JSON. */
+async function readRegistryAt(scope, projectRoot) {
+    if (scope === 'project' && projectRoot === undefined) {
+        return [];
+    }
+    const path = scopedRegistryPath(scope, projectRoot);
+    if (!existsSync(path)) {
+        return [];
+    }
+    const parsed = JSON.parse(await readFile(path, 'utf8'));
+    return Array.isArray(parsed.sops) ? parsed.sops : [];
+}
+/**
+ * Read the registry that execution/enumeration should see: the MERGED view of
+ * the project layer (when projectRoot is given) over the global layer — a
+ * project entry wins over a global one with the same id. Without projectRoot,
+ * the global registry only.
+ */
+export async function readRegistry(projectRoot) {
+    const globalSops = await readRegistryAt('global', undefined);
+    const projectSops = projectRoot !== undefined ? await readRegistryAt('project', projectRoot) : [];
+    const byId = new Map();
+    for (const sop of globalSops)
+        byId.set(sop.id, sop);
+    for (const sop of projectSops)
+        byId.set(sop.id, sop); // project wins
+    const sops = [...byId.values()].sort((left, right) => left.id.localeCompare(right.id));
+    return { version: 1, sops, gateCount: countGates(sops) };
+}
+export class SopRegisterError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = 'SopRegisterError';
+        this.code = code;
+    }
+}
+export async function registerSop(options) {
+    const scope = options.projectRoot !== undefined ? 'project' : 'global';
+    // Register the EXACT layer the caller targets — not the precedence resolution.
+    const manifestPath = scopedSopManifestPath(scope, options.projectRoot, options.id);
+    if (!existsSync(manifestPath)) {
+        throw new SopRegisterError('SOP_NOT_FOUND', `No SOP found for id "${options.id}"`);
+    }
+    const manifest = JSON.parse(await readFile(manifestPath, 'utf8'));
+    const lintOptions = { id: options.id };
+    if (options.allowCommands === true)
+        lintOptions.allowCommands = true;
+    if (options.projectRoot !== undefined)
+        lintOptions.projectRoot = options.projectRoot;
+    const lint = await lintSop(lintOptions);
+    if (lint === null || !lint.ok) {
+        throw new SopRegisterError('SOP_INVALID', `SOP "${options.id}" must lint clean before it can be registered`);
+    }
+    const gates = manifest.gates.map((gate) => ({
+        ref: `${manifest.id}/${gate.id}`,
+        gateId: gate.id,
+        sopId: manifest.id,
+        phase: gate.phase,
+        transition: `${manifest.id}:${gate.phase}`
+    }));
+    const registered = { id: manifest.id, path: relativeManifestPath(manifest.id), gates };
+    // Upsert within the SAME layer's registry (not the merged view).
+    const current = await readRegistryAt(scope, options.projectRoot);
+    const others = current.filter((sop) => sop.id !== manifest.id);
+    const sops = [...others, registered].sort((left, right) => left.id.localeCompare(right.id));
+    const registry = { version: 1, sops, gateCount: countGates(sops) };
+    if (options.dryRun === true) {
+        return { id: manifest.id, registered, gateCount: registry.gateCount, scope, applied: false };
+    }
+    const path = scopedRegistryPath(scope, options.projectRoot);
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, `${JSON.stringify(registry, null, 2)}\n`, 'utf8');
+    return { id: manifest.id, registered, gateCount: registry.gateCount, scope, applied: true };
+}

package/dist/services/sop/sop-service.d.ts

@@ -0,0 +1,55 @@
+import { type SopManifest } from './sop-types.js';
+export type SopInitOptions = {
+    id: string;
+    name?: string;
+    apply?: boolean;
+    /** When set, scaffold into the project layer (`<projectRoot>/.peaks/sops`) instead of global. */
+    projectRoot?: string;
+};
+export type SopInitResult = {
+    id: string;
+    dir: string;
+    manifestPath: string;
+    skillPath: string;
+    manifest: SopManifest;
+    skillContent: string;
+    applied: boolean;
+};
+export type SopLintSeverity = 'error' | 'warning';
+export type SopLintFinding = {
+    code: string;
+    message: string;
+    gateId?: string;
+    severity: SopLintSeverity;
+};
+export type SopLintResult = {
+    ok: boolean;
+    id: string;
+    manifestPath: string;
+    gateCount: number;
+    gateIds: string[];
+    findings: SopLintFinding[];
+    /**
+     * Non-blocking hints surfaced alongside the lint verdict. Currently used to
+     * flag gates that declared `stripMeta: true` so authors can confirm the
+     * opt-in. Empty array for manifests that do not opt in to any new behavior;
+     * this is a stable, machine-readable field distinct from `findings` (which
+     * are errors that block lint).
+     */
+    warnings: string[];
+};
+export type SopLintOptions = {
+    id: string;
+    /** `command`-type gates run shell-less processes; require explicit opt-in (OQ3 security). */
+    allowCommands?: boolean;
+    /** When set, lint the project-layer manifest (`<projectRoot>/.peaks/sops`) instead of global. */
+    projectRoot?: string;
+};
+/**
+ * Read and JSON-parse a SOP manifest for EXECUTION, resolving project-first then
+ * global (the project layer wins). Returns null when neither layer has it;
+ * throws on malformed JSON. Callers that need validation should run lintSop.
+ */
+export declare function readSopManifest(id: string, projectRoot?: string): Promise<SopManifest | null>;
+export declare function initSop(options: SopInitOptions): Promise<SopInitResult>;
+export declare function lintSop(options: SopLintOptions): Promise<SopLintResult | null>;

package/dist/services/sop/sop-service.js

@@ -0,0 +1,222 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { SOP_GATE_CHECK_TYPES, SOP_ID_PATTERN } from './sop-types.js';
+import { sopDir, sopManifestPath, sopSkillPath, projectSopDir, projectSopManifestPath, projectSopSkillPath, resolveSopManifestPath } from './sop-paths.js';
+/**
+ * SOP authoring substrate — Feature A, Slice 1.
+ *
+ * `initSop` scaffolds a user-authored SOP (manifest + registrable SKILL.md);
+ * `lintSop` validates the manifest. No registry, no enforcement here — Slice 1
+ * only lets users create and validate a SOP. The SOP id grammar
+ * (SOP_ID_PATTERN: lowercase kebab, no dots/slashes) doubles as the path
+ * traversal guard, matching how request artifacts guard their ids.
+ *
+ * SOP definitions are GLOBAL (`~/.peaks/sops/<id>/`, see ./sop-paths) so one
+ * authored SOP is reusable across projects; only run-state is per-project. The
+ * authoring ops here therefore take no projectRoot.
+ */
+const RESERVED_ID_PREFIX = 'peaks-';
+const RESERVED_IDS = new Set(['peaks']);
+/**
+ * Read and JSON-parse a SOP manifest for EXECUTION, resolving project-first then
+ * global (the project layer wins). Returns null when neither layer has it;
+ * throws on malformed JSON. Callers that need validation should run lintSop.
+ */
+export async function readSopManifest(id, projectRoot) {
+    const resolved = resolveSopManifestPath(id, projectRoot);
+    if (resolved === null) {
+        return null;
+    }
+    return JSON.parse(await readFile(resolved.path, 'utf8'));
+}
+/** Why an id cannot be used; null when the id is acceptable. */
+function reservedIdReason(id) {
+    if (id.startsWith(RESERVED_ID_PREFIX) || RESERVED_IDS.has(id)) {
+        return `SOP id "${id}" collides with the reserved built-in peaks-* namespace`;
+    }
+    return null;
+}
+function scaffoldManifest(id, name) {
+    return {
+        id,
+        name,
+        description: '',
+        phases: ['draft', 'review', 'done'],
+        gates: [
+            { id: 'example-gate', phase: 'review', check: { type: 'file-exists', path: 'README.md' } }
+        ]
+    };
+}
+function scaffoldSkill(manifest) {
+    const phaseList = manifest.phases.join(' → ');
+    return [
+        '---',
+        `name: ${manifest.id}`,
+        `description: User-authored Peaks SOP "${manifest.name}". Phases: ${phaseList}.`,
+        '---',
+        '',
+        `# ${manifest.name}`,
+        '',
+        'A user-authored SOP. Edit `sop.json` to define phases and gates, then run',
+        '`peaks sop lint` to validate it.',
+        '',
+        '## Phases',
+        '',
+        ...manifest.phases.map((phase) => `- ${phase}`),
+        ''
+    ].join('\n');
+}
+export async function initSop(options) {
+    if (!SOP_ID_PATTERN.test(options.id)) {
+        throw new Error(`Invalid SOP id: ${options.id} (expected lowercase letters, digits, and dashes, starting alphanumeric)`);
+    }
+    const reserved = reservedIdReason(options.id);
+    if (reserved !== null) {
+        throw new Error(reserved);
+    }
+    const inProject = options.projectRoot !== undefined;
+    const dir = inProject ? projectSopDir(options.projectRoot, options.id) : sopDir(options.id);
+    const manifestPath = inProject ? projectSopManifestPath(options.projectRoot, options.id) : sopManifestPath(options.id);
+    const skillPath = inProject ? projectSopSkillPath(options.projectRoot, options.id) : sopSkillPath(options.id);
+    if (existsSync(manifestPath)) {
+        throw new Error(`A SOP with id "${options.id}" already exists at ${manifestPath}. Remove it before re-running peaks sop init.`);
+    }
+    const manifest = scaffoldManifest(options.id, options.name ?? options.id);
+    const skillContent = scaffoldSkill(manifest);
+    const result = {
+        id: options.id,
+        dir,
+        manifestPath,
+        skillPath,
+        manifest,
+        skillContent,
+        applied: false
+    };
+    if (options.apply !== true) {
+        return result;
+    }
+    await mkdir(dir, { recursive: true });
+    await writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
+    await writeFile(skillPath, skillContent, 'utf8');
+    return { ...result, applied: true };
+}
+function pushError(findings, code, message, gateId) {
+    findings.push(gateId === undefined ? { code, message, severity: 'error' } : { code, message, gateId, severity: 'error' });
+}
+function lintGate(gate, index, phases, seenGateIds, allowCommands, findings) {
+    const label = typeof gate?.id === 'string' && gate.id.length > 0 ? gate.id : `#${index}`;
+    if (typeof gate?.id !== 'string' || !SOP_ID_PATTERN.test(gate.id)) {
+        pushError(findings, 'INVALID_GATE_ID', `Gate ${label} has an invalid id (expected lowercase kebab)`, label);
+        return;
+    }
+    if (seenGateIds.has(gate.id)) {
+        pushError(findings, 'DUPLICATE_GATE_ID', `Duplicate gate id "${gate.id}"`, gate.id);
+        return;
+    }
+    seenGateIds.add(gate.id);
+    if (typeof gate.phase !== 'string' || !phases.has(gate.phase)) {
+        pushError(findings, 'GATE_PHASE_UNKNOWN', `Gate "${gate.id}" binds to unknown phase "${String(gate.phase)}"`, gate.id);
+    }
+    const check = gate.check;
+    if (check === null || typeof check !== 'object' || !SOP_GATE_CHECK_TYPES.includes(check.type ?? '')) {
+        pushError(findings, 'INVALID_CHECK_TYPE', `Gate "${gate.id}" has an invalid or missing check type (expected ${SOP_GATE_CHECK_TYPES.join(' | ')})`, gate.id);
+        return;
+    }
+    if (check.type === 'file-exists' && (typeof check.path !== 'string' || check.path.length === 0)) {
+        pushError(findings, 'CHECK_MISSING_FIELD', `Gate "${gate.id}" file-exists check requires a non-empty "path"`, gate.id);
+    }
+    if (check.type === 'grep' && (typeof check.file !== 'string' || check.file.length === 0 || typeof check.pattern !== 'string' || check.pattern.length === 0)) {
+        pushError(findings, 'CHECK_MISSING_FIELD', `Gate "${gate.id}" grep check requires non-empty "file" and "pattern"`, gate.id);
+    }
+    if (check.type === 'command') {
+        if (!Array.isArray(check.run) || check.run.length === 0 || !check.run.every((part) => typeof part === 'string')) {
+            pushError(findings, 'CHECK_MISSING_FIELD', `Gate "${gate.id}" command check requires a non-empty string array "run"`, gate.id);
+        }
+        if (!allowCommands) {
+            pushError(findings, 'COMMAND_NOT_ALLOWED', `Gate "${gate.id}" uses a command check; re-run with --allow-commands to permit command-type gates`, gate.id);
+        }
+    }
+}
+function lintGuard(guard, index, phases, findings) {
+    const label = `#${index}`;
+    if (typeof guard?.phase !== 'string' || !phases.has(guard.phase)) {
+        pushError(findings, 'GUARD_PHASE_UNKNOWN', `Guard ${label} binds to unknown phase "${String(guard?.phase)}"`);
+    }
+    if (typeof guard?.bash !== 'string' || guard.bash.length === 0) {
+        pushError(findings, 'GUARD_MISSING_PATTERN', `Guard ${label} requires a non-empty "bash" pattern`);
+        return;
+    }
+    try {
+        // eslint-disable-next-line no-new
+        new RegExp(guard.bash);
+    }
+    catch {
+        pushError(findings, 'GUARD_INVALID_PATTERN', `Guard ${label} has an invalid bash regex "${guard.bash}"`);
+    }
+}
+export async function lintSop(options) {
+    // lint validates the EXACT layer the caller targets (project when projectRoot
+    // is set, else global) — not the precedence resolution used for execution.
+    const manifestPath = options.projectRoot !== undefined
+        ? projectSopManifestPath(options.projectRoot, options.id)
+        : sopManifestPath(options.id);
+    if (!existsSync(manifestPath)) {
+        return null;
+    }
+    const findings = [];
+    const warnings = [];
+    let manifest = null;
+    try {
+        manifest = JSON.parse(await readFile(manifestPath, 'utf8'));
+    }
+    catch (error) {
+        pushError(findings, 'INVALID_JSON', `Manifest is not valid JSON: ${error instanceof Error ? error.message : 'parse error'}`);
+        return { ok: false, id: options.id, manifestPath, gateCount: 0, gateIds: [], findings, warnings };
+    }
+    if (typeof manifest.id !== 'string' || !SOP_ID_PATTERN.test(manifest.id)) {
+        pushError(findings, 'INVALID_ID', `Manifest id "${String(manifest.id)}" is invalid (expected lowercase kebab)`);
+    }
+    else {
+        const reserved = reservedIdReason(manifest.id);
+        if (reserved !== null) {
+            pushError(findings, 'RESERVED_ID', reserved);
+        }
+        if (manifest.id !== options.id) {
+            pushError(findings, 'ID_MISMATCH', `Manifest id "${manifest.id}" does not match its directory "${options.id}"`);
+        }
+    }
+    const phases = Array.isArray(manifest.phases) ? manifest.phases : [];
+    if (phases.length === 0) {
+        pushError(findings, 'EMPTY_PHASES', 'Manifest must declare at least one phase');
+    }
+    const phaseSet = new Set();
+    for (const phase of phases) {
+        if (phaseSet.has(phase)) {
+            pushError(findings, 'DUPLICATE_PHASE', `Duplicate phase "${phase}"`);
+        }
+        phaseSet.add(phase);
+    }
+    const gates = Array.isArray(manifest.gates) ? manifest.gates : [];
+    const seenGateIds = new Set();
+    gates.forEach((gate, index) => lintGate(gate, index, phaseSet, seenGateIds, options.allowCommands === true, findings));
+    const guards = Array.isArray(manifest.guards) ? manifest.guards : [];
+    guards.forEach((guard, index) => lintGuard(guard, index, phaseSet, findings));
+    // Non-blocking hints: surface `stripMeta: true` opt-ins so the author can
+    // confirm the meta-strip behavior. Distinct from `findings` (which block
+    // lint). Per PRD 006 AC6, only gates that declared `stripMeta` warn.
+    for (const gate of gates) {
+        if (gate?.check?.type === 'grep' && gate.check.stripMeta === true) {
+            const label = typeof gate.id === 'string' && gate.id.length > 0 ? gate.id : '?';
+            warnings.push(`Gate "${label}" declares stripMeta: true — meta content (HTML comments / fenced code / block comments) is excluded from grep evaluation`);
+        }
+    }
+    return {
+        ok: findings.every((finding) => finding.severity !== 'error'),
+        id: options.id,
+        manifestPath,
+        gateCount: gates.length,
+        gateIds: [...seenGateIds],
+        findings,
+        warnings
+    };
+}

package/dist/services/sop/sop-types.d.ts

@@ -0,0 +1,95 @@
+/**
+ * User-authored SOP (standard operating procedure) skill types — Feature A.
+ *
+ * A SOP is a user-defined workflow: ordered phases plus gates that guard entry
+ * into a phase. Gates are first-class, addressable objects (stable id) so a
+ * later metering layer (Feature B) can count them; Slice 1 only models and
+ * validates them — no registry, no enforcement.
+ */
+export type SopGateCheckType = 'file-exists' | 'grep' | 'command';
+export type SopGateCheck = {
+    type: 'file-exists';
+    path: string;
+}
+/**
+ * grep: by default passes when `pattern` is FOUND in `file`. Set `absent: true`
+ * to invert — pass when the pattern is NOT found. `absent` expresses "must not
+ * contain X" (e.g. no leftover TODO) as a pure-text check, with no command gate
+ * and no `--allow-commands` escalation.
+ *
+ * Set `stripMeta: true` to evaluate the regex on a meta-stripped copy of the
+ * file (HTML comments + fenced code blocks + `/* … *​/` block comments
+ * removed). This lets content-publishing SOPs avoid the "literal-word trap"
+ * where the author discussing the gate's behavior in the post would itself
+ * trigger the gate. Default `false` preserves byte-identical behavior.
+ */
+ | {
+    type: 'grep';
+    file: string;
+    pattern: string;
+    absent?: boolean;
+    stripMeta?: boolean;
+} | {
+    type: 'command';
+    run: string[];
+    expectExitZero?: boolean;
+};
+export type SopGate = {
+    /** Stable id, unique within the SOP. Addressed by `peaks sop check --gate <id>`. */
+    id: string;
+    /** The phase whose entry this gate guards; must be one of the SOP's phases. */
+    phase: string;
+    check: SopGateCheck;
+};
+/**
+ * Binds a concrete irreversible Bash action to a phase: running a command that
+ * matches `bash` (a JS regex) counts as performing that phase's action, so the
+ * phase's gates must pass first. Enforced un-bypassably by the PreToolUse hook
+ * (`peaks gate enforce`). Optional — a SOP without guards still works exactly as
+ * before; enforcement is an opt-in overlay.
+ */
+export type SopPhaseGuard = {
+    /** The phase whose gates must pass before the matching command may run. Must be a declared phase. */
+    phase: string;
+    /** JS regular expression tested against the Bash `tool_input.command`. */
+    bash: string;
+};
+export type SopManifest = {
+    /** SOP id; namespaced separately from built-in peaks-* skills. */
+    id: string;
+    name: string;
+    description?: string;
+    /** Ordered, unique phase names. */
+    phases: string[];
+    gates: SopGate[];
+    /** Optional Bash-action guards enforced by the PreToolUse hook (opt-in). */
+    guards?: SopPhaseGuard[];
+};
+/**
+ * A registered gate's workspace-level identity. `ref` (`<sopId>/<gateId>`) is
+ * unique across the workspace; `transition` (`<sopId>:<phase>`) is the binding
+ * a future enforcement layer (Slice 3) consults. Built-in peaks-* gates are
+ * never recorded here.
+ */
+export type RegisteredGate = {
+    ref: string;
+    gateId: string;
+    sopId: string;
+    phase: string;
+    transition: string;
+};
+export type RegisteredSop = {
+    id: string;
+    path: string;
+    gates: RegisteredGate[];
+};
+export type SopRegistry = {
+    version: 1;
+    sops: RegisteredSop[];
+    /** Total gate count across all registered SOPs — the workspace pool a metering layer would read. */
+    gateCount: number;
+};
+export type SopCheckResult = 'pass' | 'fail' | 'blocked';
+export declare const SOP_GATE_CHECK_TYPES: ReadonlyArray<SopGateCheckType>;
+/** SOP id grammar: lowercase kebab, must start alphanumeric. */
+export declare const SOP_ID_PATTERN: RegExp;

package/dist/services/sop/sop-types.js

@@ -0,0 +1,11 @@
+/**
+ * User-authored SOP (standard operating procedure) skill types — Feature A.
+ *
+ * A SOP is a user-defined workflow: ordered phases plus gates that guard entry
+ * into a phase. Gates are first-class, addressable objects (stable id) so a
+ * later metering layer (Feature B) can count them; Slice 1 only models and
+ * validates them — no registry, no enforcement.
+ */
+export const SOP_GATE_CHECK_TYPES = ['file-exists', 'grep', 'command'];
+/** SOP id grammar: lowercase kebab, must start alphanumeric. */
+export const SOP_ID_PATTERN = /^[a-z0-9][a-z0-9-]*$/;

package/dist/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/services/standards/ide-aware-standards-service.js

@@ -0,0 +1,91 @@
+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 2.0 canonical path (CLAUDE.md + .peaks/standards/**). ` +
+        `Projects with a legacy 1.x thick .claude/rules/ tree keep that layout ` +
+        `(use \`peaks standards migrate --from-claude-rules\` to converge to 2.0). ` +
+        `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 };