peaks-cli 1.3.3 → 1.3.5

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

@@ -10,36 +10,24 @@ import { getAdapter } from '../ide/ide-registry.js';
 // values are computed lazily inside each public function call.
 /** Sentinel substring identifying a Claude-Code gate-enforce hook entry. */
 export const HOOK_ENFORCE_SENTINEL = 'peaks gate enforce';
-/** Sentinel substring identifying a peaks-managed sub-agent-progress hook entry. */
-export const HOOK_PROGRESS_SENTINEL = 'peaks progress start';
 /** Default (claude-code) hook command — kept as a stable export for tests. */
 export const HOOK_ENFORCE_COMMAND = `peaks gate enforce --project "\${CLAUDE_PROJECT_DIR}"`;
-/** Default (claude-code) progress command — kept as a stable export for tests. */
-export const HOOK_PROGRESS_COMMAND = `peaks progress start --project "\${CLAUDE_PROJECT_DIR}" --reason "auto-spawn for sub-agent Task" --quiet`;
 function resolveHookSpec(ide) {
     const adapter = getAdapter(ide);
     if (ide === 'claude-code') {
         return {
             hookEnforceCommand: `peaks gate enforce --project "\${${adapter.envVar}}"`,
-            hookProgressCommand: `peaks progress start --project "\${${adapter.envVar}}" --reason "auto-spawn for sub-agent ${adapter.subAgentToolMatcher}" --quiet`,
             hookEnforceSentinel: HOOK_ENFORCE_SENTINEL,
-            hookProgressSentinel: HOOK_PROGRESS_SENTINEL,
             hookEnforceMatcher: adapter.toolMatcher, // 'Bash'
-            hookProgressMatcher: adapter.subAgentToolMatcher, // 'Task' (slice 2026-06-06-sub-agent-spawn-bug-and-decouple — adapter now self-reports sub-agent tool name)
-            hookEnforceEvent: adapter.hookEvent, // 'PreToolUse'
-            hookProgressEvent: adapter.hookEvent // 'PreToolUse' for Claude
+            hookEnforceEvent: adapter.hookEvent // 'PreToolUse'
         };
     }
     if (ide === 'trae') {
         return {
             hookEnforceCommand: `peaks hook handle --project "\${${adapter.envVar}}"`,
-            hookProgressCommand: `peaks progress start --project "\${${adapter.envVar}}" --reason "auto-spawn for sub-agent ${adapter.subAgentToolMatcher}" --quiet`,
             hookEnforceSentinel: 'peaks hook handle',
-            hookProgressSentinel: HOOK_PROGRESS_SENTINEL,
             hookEnforceMatcher: adapter.toolMatcher, // 'terminal'
-            hookProgressMatcher: adapter.subAgentToolMatcher, // 'Task' (UNVERIFIED for Trae; matches prior hardcoded literal so byte-level install output is unchanged)
-            hookEnforceEvent: adapter.hookEvent, // 'beforeToolCall'
-            hookProgressEvent: adapter.hookEvent // 'beforeToolCall' (no separate progress event yet for Trae)
+            hookEnforceEvent: adapter.hookEvent // 'beforeToolCall'
         };
     }
     // Future adapters (codex, cursor, qoder, tongyi-lingma) — not yet registered.
@@ -51,6 +39,10 @@ function resolveHookSpec(ide) {
 function resolveIde(options) {
     return options?.ide ?? 'claude-code';
 }
+/** Slice #013: read the skipProgress opt-in flag. Slice #014: the underlying install no longer emits the progress-start entry, so the flag is effectively a no-op (kept for API stability). */
+function resolveSkipProgress(options) {
+    return options?.skipProgress === true;
+}
 /** Resolve settings root dir for a scope. */
 function resolveSettingsRoot(scope, projectRoot) {
     if (scope === 'global')
@@ -101,24 +93,104 @@ function entryIsPeaksManaged(entry, sentinels) {
         return sentinels.some((sentinel) => cmd.includes(sentinel));
     });
 }
+/**
+ * Slice #014: read the *actually-installed* peaks-managed hook entries
+ * from a settings object. Replaces the pre-#014 `listInstalledEntriesForIde`
+ * helper in `hooks-commands.ts`, which returned the IDE-EXPECTED list
+ * (a hardcoded 2-entry array per adapter) rather than what was on disk.
+ * That bug surfaced when slice #013's local cleanup installed
+ * `peaks hooks install --no-progress` (gate-enforce only), but the
+ * status command still reported `entries: [Bash, Task]` because the
+ * helper didn't read the file.
+ *
+ * The new helper:
+ *   1. reads each `hooks.<event>` array,
+ *   2. filters to entries that are peaks-managed for the given IDE
+ *      (matches the legacy sentinel set: gate-enforce + the no-longer-
+ *      installed progress-start),
+ *   3. returns one `{ matcher, sentinel }` row per entry, taking the
+ *      FIRST matching sentinel per entry (entries have a single command
+ *      handler in practice, but the loop tolerates multi-handler
+ *      entries by taking the first match).
+ *
+ * Pre-#014 settings.json files that have a stale progress-start entry
+ * will see it surface in the result. This is intentional: the status
+ * command is the user's tool for "what is on disk right now", and
+ * surfacing a stale entry is the only way the user can know to run
+ * `peaks hooks install` (which now strips it) or `peaks hooks
+ * uninstall` (which removes it).
+ */
+export function readInstalledEntriesFromSettings(settings, ide) {
+    const sentinels = resolveLegacySentinels(ide);
+    // Walk every event key the settings file has, not just the
+    // adapter-declared one. A pre-#014 install could have left a
+    // progress-start entry on a different event than the gate-enforce
+    // entry (Trae: both on beforeToolCall, but a stale install on a
+    // future IDE could split them).
+    const hooksRoot = settings.hooks;
+    if (!hooksRoot || typeof hooksRoot !== 'object' || Array.isArray(hooksRoot))
+        return [];
+    const result = [];
+    for (const eventKey of Object.keys(hooksRoot)) {
+        const entries = readHookEntriesFromHooks(hooksRoot, eventKey);
+        for (const entry of entries) {
+            if (!entryIsPeaksManaged(entry, sentinels))
+                continue;
+            const matcher = typeof entry.matcher === 'string' ? entry.matcher : '';
+            // Find the first matching sentinel inside the entry's command
+            // handlers. For each handler, find the first sentinel substring
+            // it contains. We pick the first handler's first matching
+            // sentinel (entries have a single command in practice).
+            const firstHandler = Array.isArray(entry.hooks) ? entry.hooks[0] : undefined;
+            const cmd = typeof firstHandler?.command === 'string' ? firstHandler.command : '';
+            const sentinel = sentinels.find((s) => cmd.includes(s));
+            if (matcher === '' || sentinel === undefined)
+                continue;
+            result.push({ matcher, sentinel });
+        }
+    }
+    return result;
+}
 /**
  * Compute the per-IDE peaks hook entries to merge into the settings file.
  * Replaces the slice #1 hardcoded `PEAKS_HOOK_ENTRIES` constant; the constant
  * remains exported (computed for claude-code) for backward compat.
+ *
+ * Slice #013 (`--no-progress` flag): when `skipProgress` is true, the
+ * progress-start entry is omitted from the returned list. Install with this
+ * flag will (a) NOT emit the progress hook entry, and (b) will idempotently
+ * remove any previously-installed progress entry (sentinel-based merge).
+ *
+ * Slice #014 (refactor — full removal): only the gate-enforce entry is
+ * ever emitted. The `skipProgress` parameter is kept for API stability
+ * but is a no-op — the returned list is always single-entry. The progress
+ * entry's sentinel is included in the legacy sentinel set so uninstall
+ * can find + remove any stale progress-start entry that an older
+ * `peaks hooks install` may have written before this slice.
  */
-function resolveHookEntries(ide) {
+function resolveHookEntries(ide, _skipProgress = false) {
     const spec = resolveHookSpec(ide);
     return [
-        { sentinel: spec.hookEnforceSentinel, matcher: spec.hookEnforceMatcher, command: spec.hookEnforceCommand, event: spec.hookEnforceEvent },
-        { sentinel: spec.hookProgressSentinel, matcher: spec.hookProgressMatcher, command: spec.hookProgressCommand, event: spec.hookProgressEvent }
+        { sentinel: spec.hookEnforceSentinel, matcher: spec.hookEnforceMatcher, command: spec.hookEnforceCommand, event: spec.hookEnforceEvent }
     ];
 }
-/** Default (claude-code) peaks-managed hook entries — kept as a stable export for tests. */
+/**
+ * Legacy sentinel set used by uninstall + status to find and remove stale
+ * progress-start entries written by pre-#014 installs. The progress-start
+ * sentinel is the literal substring that older installs emitted.
+ */
+const LEGACY_PROGRESS_START_SENTINEL = 'peaks progress start';
+function resolveLegacySentinels(ide) {
+    if (ide === 'trae') {
+        return ['peaks hook handle', LEGACY_PROGRESS_START_SENTINEL];
+    }
+    return [HOOK_ENFORCE_SENTINEL, LEGACY_PROGRESS_START_SENTINEL];
+}
+/** Default (claude-code) peaks-managed hook entries — kept as a stable export for tests. Slice #014: only the gate-enforce entry. */
 export const PEAKS_HOOK_ENTRIES = (() => {
     const spec = resolveHookSpec('claude-code');
     return [
-        { sentinel: spec.hookEnforceSentinel, matcher: spec.hookEnforceMatcher, command: spec.hookEnforceCommand, event: spec.hookEnforceEvent },
-        { sentinel: spec.hookProgressSentinel, matcher: spec.hookProgressMatcher, command: spec.hookProgressCommand, event: spec.hookProgressEvent }
+        { sentinel: spec.hookEnforceSentinel, matcher: spec.hookEnforceMatcher, command: spec.hookEnforceCommand, event: spec.hookEnforceEvent }
     ];
 })();
 function isInstalledForIde(settings, ide) {
@@ -133,8 +205,43 @@ function isInstalledForIde(settings, ide) {
     }
     return false;
 }
+/**
+ * Slice #014: detect the "stale progress entry after pre-#014 install"
+ * case. The desired shape is gate-enforce-only. If the file currently
+ * has a peaks-managed progress-start entry (left behind by a pre-#014
+ * install), the install is NOT a no-op — it must strip the stale
+ * entry. This helper returns true exactly when the desired shape is
+ * fully reflected on disk: gate-enforce present AND no legacy
+ * progress-start present.
+ */
+function shapeMatchesDesired(settings, ide) {
+    const desiredEntries = resolveHookEntries(ide);
+    const desiredSentinels = new Set(desiredEntries.map((e) => e.sentinel));
+    const allPeaksSentinels = resolveLegacySentinels(ide);
+    const eventKeys = new Set(resolveHookEntries(ide).map((e) => e.event));
+    for (const eventKey of eventKeys) {
+        const present = readHookEventEntries(settings, eventKey);
+        const peaksPresent = present.filter((e) => entryIsPeaksManaged(e, allPeaksSentinels));
+        // (a) every peaks-managed entry currently on disk must match the
+        //     desired sentinel set (no stale entries the caller wants removed).
+        for (const entry of peaksPresent) {
+            const entrySentinels = (entry.hooks ?? []).map((h) => allPeaksSentinels.find((s) => String(h.command ?? '').includes(s))).filter((s) => Boolean(s));
+            if (entrySentinels.some((s) => !desiredSentinels.has(s))) {
+                return false;
+            }
+        }
+        // (b) every desired entry must be on disk.
+        for (const sentinel of desiredSentinels) {
+            const has = peaksPresent.some((entry) => (entry.hooks ?? []).some((h) => String(h.command ?? '').includes(sentinel)));
+            if (!has)
+                return false;
+        }
+    }
+    return true;
+}
 export function planHookInstall(scope, projectRoot, options) {
     const ide = resolveIde(options);
+    const _skipProgress = resolveSkipProgress(options);
     const root = resolveSettingsRoot(scope, projectRoot);
     const settingsPath = resolveSettingsPath(scope, ide, projectRoot);
     assertSafeSettingsPathCompat(scope, ide, root, settingsPath);
@@ -152,24 +259,29 @@ export function planHookInstall(scope, projectRoot, options) {
     };
 }
 /** Merge all peaks-managed hook entries into settings, preserving all other keys and hooks. */
-function withHooksInstalledForIde(settings, ide) {
+function withHooksInstalledForIde(settings, ide, _skipProgress = false) {
     const existingHooks = (settings.hooks && typeof settings.hooks === 'object' && !Array.isArray(settings.hooks))
         ? settings.hooks
         : {};
-    // Per-IDE entries may map to different events (Trae: both on beforeToolCall;
-    // Claude: both on PreToolUse). Group by event so each event array is
-    // independently merged.
+    // Per-IDE entries may map to different events (Trae: gate-enforce on
+    // beforeToolCall; Claude: gate-enforce on PreToolUse). Group by event
+    // so each event array is independently merged.
     const ourByEvent = new Map();
     for (const spec of resolveHookEntries(ide)) {
         const list = ourByEvent.get(spec.event) ?? [];
         list.push(spec);
         ourByEvent.set(spec.event, list);
     }
-    const sentinels = resolveHookEntries(ide).map((e) => e.sentinel);
+    // Slice #014: the legacy sentinel set includes the progress-start
+    // sentinel so a pre-#014 install's stale progress-start entry is
+    // stripped by the filter (the file converges on the new
+    // gate-enforce-only shape, idempotently). The desired set (passed
+    // in below) only contains the gate-enforce sentinel.
+    const allSentinels = resolveLegacySentinels(ide);
     const nextHooks = { ...existingHooks };
     for (const [eventKey, ourEntries] of ourByEvent) {
         const existing = readHookEntriesFromHooks(nextHooks, eventKey);
-        const nonPeaks = existing.filter((entry) => !entryIsPeaksManaged(entry, sentinels));
+        const nonPeaks = existing.filter((entry) => !entryIsPeaksManaged(entry, allSentinels));
         const ourFormatted = ourEntries.map((spec) => ({
             matcher: spec.matcher,
             hooks: [{ type: 'command', command: spec.command }]
@@ -189,17 +301,25 @@ function withHooksInstalledForIde(settings, ide) {
 }
 export function applyHookInstall(scope, projectRoot, options) {
     const ide = resolveIde(options);
+    const _skipProgress = resolveSkipProgress(options);
     const root = resolveSettingsRoot(scope, projectRoot);
     const settingsPath = resolveSettingsPath(scope, ide, projectRoot);
     assertSafeSettingsPathCompat(scope, ide, root, settingsPath);
     const exists = existsSync(settingsPath);
     const settings = exists ? readJsonObjectFile(settingsPath) : {};
     const spec = resolveHookSpec(ide);
+    // Slice #014: `alreadyInstalled` reflects the FULL desired shape
+    // (gate-enforce-only + no stale progress-start entry). Pre-#014
+    // installs that left a progress-start entry behind will be treated
+    // as not-yet-installed, so the merge strips the stale entry on the
+    // next install call. This is the only path that converges the file
+    // on the new shape; pure presence-checks are insufficient.
+    const alreadyInstalled = shapeMatchesDesired(settings, ide);
     const baseResult = {
         scope,
         settingsPath,
         exists,
-        alreadyInstalled: isInstalledForIde(settings, ide),
+        alreadyInstalled,
         desiredCommand: spec.hookEnforceCommand,
         sentinel: spec.hookEnforceSentinel,
         matcher: spec.hookEnforceMatcher
@@ -220,7 +340,12 @@ export function removeHookInstall(scope, projectRoot, options) {
     }
     const settings = readJsonObjectFile(settingsPath);
     const existingHooks = settings.hooks ?? {};
-    const sentinels = resolveHookEntries(ide).map((e) => e.sentinel);
+    // Slice #014: uninstall must remove the gate-enforce entry AND any
+    // legacy progress-start entry that a pre-#014 install left behind.
+    // The legacy sentinel set covers both shapes so the uninstall
+    // converges the file on "no peaks-managed entries", regardless of
+    // what shape the file was in when the user ran uninstall.
+    const sentinels = resolveLegacySentinels(ide);
     const eventKeys = new Set(resolveHookEntries(ide).map((e) => e.event));
     let removedAny = false;
     const nextHooks = { ...existingHooks };

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 {};

package/dist/src/shared/incrementing-number.d.ts

@@ -11,14 +11,6 @@
  * @returns Next available number (1, 2, 3, ...)
  */
 export declare function getNextNumber(dirPath: string): number;
-/**
- * Build a numbered filename from a number and description.
- * Format: 001-description-slug.md
- *
- * @param number - The file number (will be zero-padded to 3 digits)
- * @param description - Human-readable description (converted to kebab-case slug)
- * @returns Formatted filename like "001-feature-name.md"
- */
 export declare function buildNumberedFilename(number: number, description: string): string;
 /**
  * Get the next numbered file path in a directory.

package/dist/src/shared/incrementing-number.js

@@ -34,13 +34,23 @@ export function getNextNumber(dirPath) {
  * @param description - Human-readable description (converted to kebab-case slug)
  * @returns Formatted filename like "001-feature-name.md"
  */
+// Windows supports up to 255 chars per filename component (and 260 for the
+// full path). Pre-#015 the slug was silently truncated to 50 chars, which
+// produced orphaned artefacts (the on-disk file no longer matched the
+// request-id and the state machine could not find it). 255 is the OS-level
+// ceiling; if a requestId exceeds that, `mkdir` / `writeFile` will surface a
+// real ENAMETOOLONG error instead of a silent mismatch. We reserve 4 chars
+// for the `<NNN>-` numeric prefix and 3 chars for the `.md` suffix, so
+// the slug may be at most 248 chars (giving 4 + 248 + 3 = 255 total).
+const MAX_FILENAME_LENGTH = 255;
+const MAX_FILENAME_SLUG_LENGTH = MAX_FILENAME_LENGTH - 7;
 export function buildNumberedFilename(number, description) {
     const padded = String(number).padStart(3, '0');
     const slug = description
         .toLowerCase()
         .replace(/[^a-z0-9]+/g, '-')
         .replace(/^-|-$/g, '')
-        .slice(0, 50); // Limit slug length
+        .slice(0, MAX_FILENAME_SLUG_LENGTH);
     return `${padded}-${slug}.md`;
 }
 /**

package/dist/src/shared/version.d.ts

@@ -1 +1 @@
-export declare const CLI_VERSION = "1.3.3";
+export declare const CLI_VERSION = "1.3.5";

package/dist/src/shared/version.js

@@ -1 +1 @@
-export const CLI_VERSION = "1.3.3";
+export const CLI_VERSION = "1.3.5";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "peaks-cli",
-  "version": "1.3.3",
+  "version": "1.3.5",
   "description": "Cross-AI-IDE workflow-gating CLI + skill family (Claude Code shipped, Trae in progress; Codex / Cursor / Qoder / Tongyi Lingma on the roadmap).",
   "author": "SquabbyZ",
   "license": "MIT",