peaks-cli 1.3.2 → 1.3.4

package/dist/src/services/skills/statusline-settings-service.js

@@ -1,11 +1,15 @@
-import { closeSync, constants, existsSync, lstatSync, mkdirSync, openSync, readFileSync, realpathSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
+import { closeSync, constants, existsSync, mkdirSync, openSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
 import { randomUUID } from 'node:crypto';
-import { dirname, isAbsolute, join, relative, resolve } from 'node:path';
+import { dirname, isAbsolute, join, resolve } from 'node:path';
 import { homedir } from 'node:os';
+import { assertSafeSettingsFile, isInsidePath } from '../ide/shared/safe-path.js';
+import { getAdapter } from '../ide/ide-registry.js';
 export const STATUSLINE_COMMAND = 'peaks statusline';
-function isInsidePath(childPath, parentPath) {
-    const rel = relative(parentPath, childPath);
-    return rel === '' || (!rel.startsWith('..') && !isAbsolute(rel));
+// Re-export the shared helper so existing consumers that imported
+// `isInsidePath` from this module keep compiling.
+export { isInsidePath };
+function resolveIde(options) {
+    return options?.ide ?? 'claude-code';
 }
 function resolveSettingsRoot(scope, projectRoot) {
     if (scope === 'global')
@@ -15,25 +19,17 @@ function resolveSettingsRoot(scope, projectRoot) {
     }
     return resolve(projectRoot);
 }
-function resolveSettingsPath(scope, projectRoot) {
+/**
+ * Resolve + safety-check the settings path for the given IDE and scope. The
+ * `dirName` and `settingsFileName` come from the registered adapter
+ * (`getAdapter(ide)`) so the hardcoded `.claude/settings.json` is gone —
+ * future adapters swap by changing the registry, not this file.
+ */
+function resolveAndAssertSettingsPath(scope, ide, projectRoot) {
     const root = resolveSettingsRoot(scope, projectRoot);
-    return join(root, '.claude', 'settings.json');
-}
-/** Reject symlinked .claude dir or settings file to prevent escape. */
-function assertSafeSettingsPath(scope, root, settingsPath) {
-    const claudeDir = join(root, '.claude');
-    if (existsSync(claudeDir) && lstatSync(claudeDir).isSymbolicLink()) {
-        throw new Error('.claude directory must not be a symlink');
-    }
-    if (existsSync(settingsPath)) {
-        if (lstatSync(settingsPath).isSymbolicLink()) {
-            throw new Error('settings.json must not be a symlink');
-        }
-        const realRoot = realpathSync(root);
-        if (!isInsidePath(realpathSync(settingsPath), realRoot)) {
-            throw new Error(`settings.json must stay inside the ${scope} root`);
-        }
-    }
+    const adapter = getAdapter(ide);
+    const { settingsPath } = assertSafeSettingsFile(scope, root, adapter.settings.dirName, adapter.settings.settingsFileName);
+    return { root, settingsPath };
 }
 function readSettings(settingsPath) {
     if (!existsSync(settingsPath))
@@ -76,10 +72,9 @@ function buildPlan(scope, settingsPath, settings, exists) {
         desiredCommand: STATUSLINE_COMMAND
     };
 }
-export function planStatusLineInstall(scope, projectRoot) {
-    const root = resolveSettingsRoot(scope, projectRoot);
-    const settingsPath = resolveSettingsPath(scope, projectRoot);
-    assertSafeSettingsPath(scope, root, settingsPath);
+export function planStatusLineInstall(scope, projectRoot, options) {
+    const ide = resolveIde(options);
+    const { settingsPath } = resolveAndAssertSettingsPath(scope, ide, projectRoot);
     const exists = existsSync(settingsPath);
     const settings = readSettings(settingsPath);
     return buildPlan(scope, settingsPath, settings, exists);
@@ -109,9 +104,8 @@ function atomicWriteJson(settingsPath, settings) {
     }
 }
 export function applyStatusLineInstall(scope, projectRoot, options = {}) {
-    const root = resolveSettingsRoot(scope, projectRoot);
-    const settingsPath = resolveSettingsPath(scope, projectRoot);
-    assertSafeSettingsPath(scope, root, settingsPath);
+    const ide = resolveIde(options);
+    const { settingsPath } = resolveAndAssertSettingsPath(scope, ide, projectRoot);
     const exists = existsSync(settingsPath);
     const settings = readSettings(settingsPath);
     const plan = buildPlan(scope, settingsPath, settings, exists);
@@ -126,10 +120,9 @@ export function applyStatusLineInstall(scope, projectRoot, options = {}) {
     atomicWriteJson(settingsPath, nextSettings);
     return { ...plan, applied: true };
 }
-export function removeStatusLineInstall(scope, projectRoot) {
-    const root = resolveSettingsRoot(scope, projectRoot);
-    const settingsPath = resolveSettingsPath(scope, projectRoot);
-    assertSafeSettingsPath(scope, root, settingsPath);
+export function removeStatusLineInstall(scope, projectRoot, options) {
+    const ide = resolveIde(options);
+    const { settingsPath } = resolveAndAssertSettingsPath(scope, ide, projectRoot);
     if (!existsSync(settingsPath)) {
         return { scope, settingsPath, removed: false };
     }
@@ -142,3 +135,7 @@ export function removeStatusLineInstall(scope, projectRoot) {
     atomicWriteJson(settingsPath, rest);
     return { scope, settingsPath, removed: true };
 }
+// Suppress unused-import warning for `isAbsolute` if it becomes unused in
+// future refactors. The pre-refactor file used it in the local isInsidePath;
+// the shared helper owns that logic now.
+void isAbsolute;

package/dist/src/services/slice/slice-archive-service.d.ts

@@ -0,0 +1,20 @@
+export declare const ARCHIVE_RETENTION_MS: number;
+export interface ArchiveResult {
+    readonly archivedCompleted: number;
+    readonly archivedInFlight: number;
+    readonly gcDeleted: number;
+}
+/** Build the canonical archive dir for a given session + slice id. */
+export declare function archiveDir(projectRoot: string, sessionId: string, sliceId: string): string;
+/** Build the in-flight subdir (records not yet disposed). */
+export declare function inFlightArchiveDir(projectRoot: string, sessionId: string, sliceId: string): string;
+/**
+ * Archive the current `.peaks/_sub_agents/<sid>/` tree under
+ * `<archiveDir>` (per the sliceId), separating completed vs in-flight.
+ * Then run the 30-day GC over the archive dir.
+ */
+export declare function archiveSubAgentRecords(projectRoot: string, options: {
+    sessionId: string;
+    sliceId: string;
+    now?: () => Date;
+}): ArchiveResult;

package/dist/src/services/slice/slice-archive-service.js

@@ -0,0 +1,111 @@
+/**
+ * Slice #009 / G5 RL-8 — sub-agent dispatch record archival + 30-day GC.
+ *
+ * Called by the `peaks session finish` / `peaks session abandon` /
+ * new-rid-startup hooks. Walks the per-session `.peaks/_sub_agents/<sid>/`
+ * tree and moves completed + disposed records to
+ * `.peaks/_runtime/<sid>/_archive/_sub_agents/<sliceId>/`.
+ *
+ * GC policy:
+ *   - Records with `disposed: true` AND `outcome ∈ {success, failed,
+ *     timeout, cancelled}` (not "no-execution") → archive + 30-day GC.
+ *   - Records with `disposed: false` (any outcome) → archive but NOT
+ *     GC'd. Next session will see them as still-pending in
+ *     `_archive/.../in-flight/` and can resume reducer work.
+ *
+ * Lazy GC: `archiveSubAgentRecords` also scans the archive dir and
+ * deletes entries older than 30 days. No cron, no background daemon.
+ */
+import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, statSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import { isDispatchStatus, isOutcome } from '../dispatch/dispatch-record-writer.js';
+export const ARCHIVE_RETENTION_MS = 30 * 24 * 60 * 60 * 1000; // 30 days
+/** Build the canonical archive dir for a given session + slice id. */
+export function archiveDir(projectRoot, sessionId, sliceId) {
+    return join(projectRoot, '.peaks', '_runtime', sessionId, '_archive', '_sub_agents', sliceId);
+}
+/** Build the in-flight subdir (records not yet disposed). */
+export function inFlightArchiveDir(projectRoot, sessionId, sliceId) {
+    return join(archiveDir(projectRoot, sessionId, sliceId), 'in-flight');
+}
+/**
+ * Archive the current `.peaks/_sub_agents/<sid>/` tree under
+ * `<archiveDir>` (per the sliceId), separating completed vs in-flight.
+ * Then run the 30-day GC over the archive dir.
+ */
+export function archiveSubAgentRecords(projectRoot, options) {
+    const now = options.now ?? (() => new Date());
+    const sourceDir = join(projectRoot, '.peaks', '_sub_agents', options.sessionId);
+    const completedDir = archiveDir(projectRoot, options.sessionId, options.sliceId);
+    const inFlightDir = inFlightArchiveDir(projectRoot, options.sessionId, options.sliceId);
+    mkdirSync(completedDir, { recursive: true });
+    mkdirSync(inFlightDir, { recursive: true });
+    let archivedCompleted = 0;
+    let archivedInFlight = 0;
+    if (existsSync(sourceDir)) {
+        for (const entry of readdirSync(sourceDir)) {
+            if (!entry.startsWith('dispatch-') || !entry.endsWith('.json'))
+                continue;
+            const src = join(sourceDir, entry);
+            const record = readRecordOrNull(src);
+            if (record === null)
+                continue;
+            if (record.disposed === true && isCompletedOutcome(record.outcome)) {
+                renameSync(src, join(completedDir, entry));
+                archivedCompleted += 1;
+            }
+            else {
+                renameSync(src, join(inFlightDir, entry));
+                archivedInFlight += 1;
+            }
+        }
+    }
+    // 30-day GC: walk the archive root (any sliceId), delete entries
+    // whose file mtime is older than the retention.
+    const gcDeleted = runGarbageCollection(completedDir, now().getTime());
+    return { archivedCompleted, archivedInFlight, gcDeleted };
+}
+function isCompletedOutcome(outcome) {
+    return outcome === 'success' || outcome === 'failed' || outcome === 'timeout' || outcome === 'cancelled';
+}
+function readRecordOrNull(path) {
+    try {
+        const raw = readFileSync(path, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (typeof parsed !== 'object' || parsed === null)
+            return null;
+        const obj = parsed;
+        if (!isOutcome(obj.outcome) || !isDispatchStatus(obj.status))
+            return null;
+        if (typeof obj.disposed !== 'boolean')
+            return null;
+        return obj;
+    }
+    catch {
+        return null;
+    }
+}
+function runGarbageCollection(dir, nowMs) {
+    if (!existsSync(dir))
+        return 0;
+    let deleted = 0;
+    for (const entry of readdirSync(dir)) {
+        const full = join(dir, entry);
+        try {
+            const stat = statSync(full);
+            if (stat.isDirectory()) {
+                deleted += runGarbageCollection(full, nowMs);
+                continue;
+            }
+            const ageMs = nowMs - stat.mtimeMs;
+            if (ageMs > ARCHIVE_RETENTION_MS) {
+                unlinkSync(full);
+                deleted += 1;
+            }
+        }
+        catch {
+            /* skip unreadable; do not crash the archive op */
+        }
+    }
+    return deleted;
+}

package/dist/src/services/solo/batch-heartbeat-poller.d.ts

@@ -0,0 +1,51 @@
+import { summarize, type SubAgentLiveView } from './status-line-renderer.js';
+export declare const DEFAULT_POLL_INTERVAL_MS = 10000;
+export declare const DEFAULT_STALE_THRESHOLD_MS: number;
+export type PollRecord = {
+    readonly path: string;
+    readonly role: string;
+};
+export type PollerStatusEvent = {
+    readonly kind: 'status';
+    readonly line: string;
+    readonly summary: ReturnType<typeof summarize>;
+    readonly views: readonly SubAgentLiveView[];
+};
+export type PollerStaleEvent = {
+    readonly kind: 'stale';
+    readonly path: string;
+    readonly role: string;
+    readonly lastBeatAgoSec: number;
+    readonly thresholdSec: number;
+};
+export type PollerDoneEvent = {
+    readonly kind: 'done';
+    readonly summary: ReturnType<typeof summarize>;
+};
+export type PollerEvent = PollerStatusEvent | PollerStaleEvent | PollerDoneEvent;
+export type PollerHandlers = {
+    onStatus?: (event: PollerStatusEvent) => void;
+    onStale?: (event: PollerStaleEvent) => void;
+    onDone?: (event: PollerDoneEvent) => void;
+    onError?: (error: unknown) => void;
+};
+export type PollerOptions = {
+    prefix: string;
+    intervalMs?: number;
+    staleThresholdMs?: number;
+    now?: () => Date;
+};
+export declare class BatchHeartbeatPoller {
+    private readonly records;
+    private readonly handlers;
+    private readonly options;
+    private timer;
+    private prevStale;
+    private prevSummaryDone;
+    private running;
+    constructor(records: readonly PollRecord[], handlers: PollerHandlers, options: PollerOptions);
+    start(): void;
+    stop(): void;
+    /** Force a tick (testing seam + low-level access for explicit invocation). */
+    tick(): void;
+}

package/dist/src/services/solo/batch-heartbeat-poller.js

@@ -0,0 +1,88 @@
+import { readRecords } from '../dispatch/dispatch-record-writer.js';
+import { renderStatusLine, summarize, viewSubAgent } from './status-line-renderer.js';
+export const DEFAULT_POLL_INTERVAL_MS = 10_000;
+export const DEFAULT_STALE_THRESHOLD_MS = 5 * 60 * 1000;
+const TERMINAL_STATUSES = ['done', 'failed'];
+const TERMINAL_RECORD_STATUSES = [
+    'done',
+    'failed',
+    'cancelled',
+    'no-execution'
+];
+export class BatchHeartbeatPoller {
+    records;
+    handlers;
+    options;
+    timer = null;
+    prevStale = new Set();
+    prevSummaryDone = 0;
+    running = false;
+    constructor(records, handlers, options) {
+        this.records = records;
+        this.handlers = handlers;
+        this.options = options;
+    }
+    start() {
+        if (this.running)
+            return;
+        this.running = true;
+        this.tick();
+        const interval = this.options.intervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+        this.timer = setInterval(() => this.tick(), interval);
+        // Don't keep the process alive just for the poller.
+        this.timer.unref?.();
+    }
+    stop() {
+        this.running = false;
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+    }
+    /** Force a tick (testing seam + low-level access for explicit invocation). */
+    tick() {
+        let recs;
+        try {
+            recs = readRecords(this.records.map((r) => r.path));
+        }
+        catch (error) {
+            this.handlers.onError?.(error);
+            return;
+        }
+        const now = this.options.now ?? (() => new Date());
+        const summary = summarize(recs);
+        const views = recs.map((r) => viewSubAgent(r, now));
+        const line = renderStatusLine(this.options.prefix, recs, now);
+        this.handlers.onStatus?.({ kind: 'status', line, summary, views });
+        const staleThresholdSec = Math.floor((this.options.staleThresholdMs ?? DEFAULT_STALE_THRESHOLD_MS) / 1000);
+        for (const rec of recs) {
+            const v = viewSubAgent(rec, now);
+            if (v.isStale) {
+                const key = `${rec.role}::${rec.requestId}`;
+                if (!this.prevStale.has(key)) {
+                    this.prevStale.add(key);
+                    this.handlers.onStale?.({
+                        kind: 'stale',
+                        path: this.records.find((p) => p.role === rec.role)?.path ?? '',
+                        role: rec.role,
+                        lastBeatAgoSec: v.lastBeatAgoSec ?? -1,
+                        thresholdSec: staleThresholdSec
+                    });
+                }
+            }
+        }
+        if (summary.total > 0 && summary.done === summary.total && this.prevSummaryDone !== summary.done) {
+            this.prevSummaryDone = summary.done;
+            this.handlers.onDone?.({ kind: 'done', summary });
+            this.stop();
+        }
+        else if (recs.length > 0 &&
+            recs.every((r) => TERMINAL_RECORD_STATUSES.includes(r.status) || TERMINAL_STATUSES.includes(r.status))) {
+            this.handlers.onDone?.({ kind: 'done', summary });
+            this.stop();
+        }
+        else {
+            this.prevSummaryDone = summary.done;
+        }
+    }
+}

package/dist/src/services/solo/status-line-renderer.d.ts

@@ -0,0 +1,34 @@
+/**
+ * G6.5 — status line renderer for the peaks-solo batch-sync wait period.
+ *
+ * Single line, 80-120 chars, status-line-friendly. The shape is
+ * documented in PRD §G6.5:
+ *
+ *   [peaks-solo] swarm 3/3 running | rd-planning 45% (12s ago) | qa-test-cases 30% (5s ago) | ui-design 20% (2s ago)
+ *   [peaks-solo] swarm 3/3 running | rd-planning 70% (8s ago) | qa-test-cases 50% (3s ago) | ui-design 30% (6s ago)
+ *   ...
+ *   [peaks-solo] swarm 3/3 done in 47.3s
+ *
+ * Pure helper; the poller calls it once per tick. No IO.
+ */
+import type { DispatchRecord } from '../dispatch/dispatch-record-writer.js';
+export type SubAgentLiveView = {
+    readonly role: string;
+    readonly status: string;
+    readonly progress: number | null;
+    readonly lastBeatAgoSec: number | null;
+    readonly isStale: boolean;
+};
+export type SwarmSummary = {
+    readonly total: number;
+    readonly running: number;
+    readonly done: number;
+    readonly failed: number;
+    readonly stale: number;
+};
+/** Build a per-sub-agent view of the current state of one record. */
+export declare function viewSubAgent(record: DispatchRecord, now?: () => Date): SubAgentLiveView;
+/** Aggregate swarm summary. */
+export declare function summarize(records: readonly DispatchRecord[]): SwarmSummary;
+/** Render a single status line. */
+export declare function renderStatusLine(prefix: string, records: readonly DispatchRecord[], now?: () => Date): string;

package/dist/src/services/solo/status-line-renderer.js

@@ -0,0 +1,55 @@
+const STALE_THRESHOLD_SEC = 5 * 60;
+/** Build a per-sub-agent view of the current state of one record. */
+export function viewSubAgent(record, now = () => new Date()) {
+    const latest = record.heartbeats[record.heartbeats.length - 1];
+    const lastBeatAgo = record.lastBeatAt
+        ? Math.max(0, Math.floor((now().getTime() - new Date(record.lastBeatAt).getTime()) / 1000))
+        : null;
+    const isStale = lastBeatAgo !== null && lastBeatAgo > STALE_THRESHOLD_SEC;
+    return {
+        role: record.role,
+        status: record.status,
+        progress: latest ? latest.progress : null,
+        lastBeatAgoSec: lastBeatAgo,
+        isStale
+    };
+}
+/** Aggregate swarm summary. */
+export function summarize(records) {
+    let running = 0;
+    let done = 0;
+    let failed = 0;
+    let stale = 0;
+    for (const r of records) {
+        const v = viewSubAgent(r);
+        if (v.isStale)
+            stale += 1;
+        if (r.status === 'done')
+            done += 1;
+        else if (r.status === 'failed' || r.status === 'cancelled')
+            failed += 1;
+        else
+            running += 1;
+    }
+    return { total: records.length, running, done, failed, stale };
+}
+/** Render a single status line. */
+export function renderStatusLine(prefix, records, now = () => new Date()) {
+    if (records.length === 0) {
+        return `${prefix} swarm 0/0 idle`;
+    }
+    const summary = summarize(records);
+    const allDone = summary.done === summary.total;
+    if (allDone) {
+        return `${prefix} swarm ${summary.done}/${summary.total} done`;
+    }
+    const parts = records.map((r) => renderOne(r, now));
+    return `${prefix} swarm ${summary.running}/${summary.total} running | ${parts.join(' | ')}`;
+}
+function renderOne(record, now) {
+    const view = viewSubAgent(record, now);
+    const pct = view.progress !== null ? `${view.progress}%` : '?%';
+    const ago = view.lastBeatAgoSec !== null ? `${view.lastBeatAgoSec}s ago` : 'no beat';
+    const stale = view.isStale ? ' ⚠ stale' : '';
+    return `${view.role} ${pct} (${ago})${stale}`;
+}

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/project-standards-service.d.ts

@@ -68,7 +68,7 @@ export type ProjectStandardsUpdateSummary = {
         readonly reviewSuggestions: string[];
     };
 };
-type ProjectStandardsInitOptions = {
+export type ProjectStandardsInitOptions = {
     readonly projectRoot: string;
     readonly language?: string;
     readonly apply?: boolean;
@@ -79,4 +79,3 @@ export declare function executeProjectStandardsInit(options: ProjectStandardsIni
 export declare function executeProjectStandardsUpdate(options: ProjectStandardsInitOptions): ProjectStandardsUpdateResult;
 export declare function summarizeProjectStandardsInitResult(result: ProjectStandardsInitResult): ProjectStandardsInitSummary;
 export declare function summarizeProjectStandardsUpdateResult(result: ProjectStandardsUpdateResult): ProjectStandardsUpdateSummary;
-export {};