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

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

@@ -1,89 +0,0 @@
-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/src/services/sop/sop-service.d.ts

@@ -1,55 +0,0 @@
-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/src/services/sop/sop-service.js

@@ -1,222 +0,0 @@
-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/src/services/sop/sop-types.d.ts

@@ -1,95 +0,0 @@
-/**
- * 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/src/services/sop/sop-types.js

@@ -1,11 +0,0 @@
-/**
- * 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/src/services/standards/ide-aware-standards-service.d.ts

@@ -1,94 +0,0 @@
-/**
- * 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

@@ -1,89 +0,0 @@
-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 };