peaks-loop 4.1.3 → 4.1.4

package/dist/services/config/config-validation.d.ts

@@ -0,0 +1,19 @@
+import type { ModelProviderConfig, PeaksConfig } from './config-types.js';
+export declare function isSensitiveConfigPath(path: string): boolean;
+export declare function isLegacyConfigKey(path: string): boolean;
+export declare function isProviderConfigPath(path: string): boolean;
+export declare function isSecretKey(key: string): boolean;
+export declare function isProviderBaseUrlPath(path: string): boolean;
+export declare function validateProviderBaseUrl(value: unknown): void;
+export declare function getProxyUrlCandidate(key: string, value: unknown): unknown;
+export declare function isProxyConfigPath(path: string): boolean;
+export declare function validateModelProviderConfig(providers: ModelProviderConfig): void;
+export declare function validateProviderConfig(partial: Partial<PeaksConfig>): void;
+export declare function isValidProxyUrl(value: string): boolean;
+export declare function validateProxyUrl(value: unknown): void;
+export declare function validateProxyConfig(partial: Partial<PeaksConfig>): void;
+export declare function containsSensitiveConfigValue(value: unknown): boolean;
+export type RedactedConfigValue = string | number | boolean | null | RedactedConfigValue[] | {
+    [key: string]: RedactedConfigValue;
+};
+export declare function redactConfigSecrets(value: unknown, path?: string): RedactedConfigValue;

package/dist/services/config/config-validation.js

@@ -0,0 +1,152 @@
+/**
+ * Config key/URL validators and the secret-redaction surface.
+ *
+ * Split out of `config-service.ts` (file-size cap campaign). The service
+ * re-exports every name declared here, so existing importers keep using
+ * `./config-service.js` unchanged.
+ */
+import { isRecord } from './config-primitives.js';
+export function isSensitiveConfigPath(path) {
+    const normalized = path.toLowerCase().replace(/[^a-z0-9]/g, '');
+    return (normalized.includes('apikey') ||
+        normalized.includes('accesskey') ||
+        normalized.includes('privatekey') ||
+        normalized.includes('token') ||
+        normalized.includes('secret') ||
+        normalized.includes('password') ||
+        normalized.includes('bearer') ||
+        normalized.includes('credential') ||
+        normalized.includes('auth'));
+}
+/**
+ * 2.0.1 slim-config contract: `~/.peaks/config.json` only stores
+ * `version` + `ocr.llm.*` placeholders. The 1.x → 2.0 migration
+ * moved per-project fields (`language`, `model`, `economyMode`,
+ * `swarmMode`) to `<project>/.peaks/preferences.json` (per spec
+ * §10.4). `setConfig` rejects writes to those keys and points the
+ * user to the preferences path; tokens / providers / proxy still
+ * live in `~/.peaks/config.json` (the loader is tolerant of them
+ * but does not synthesise defaults for them anymore).
+ */
+const LEGACY_CONFIG_KEYS = new Set([
+    'language',
+    'model',
+    'economyMode',
+    'swarmMode'
+]);
+export function isLegacyConfigKey(path) {
+    const topLevel = path.split(/[.[].*/, 1)[0] ?? '';
+    return LEGACY_CONFIG_KEYS.has(topLevel);
+}
+export function isProviderConfigPath(path) {
+    return path === 'providers' || path.startsWith('providers.');
+}
+export function isSecretKey(key) {
+    return isSensitiveConfigPath(key);
+}
+function sanitizeBaseUrlForDisplay(value) {
+    try {
+        const url = new URL(value);
+        url.username = '';
+        url.password = '';
+        url.search = '';
+        url.hash = '';
+        return url.toString();
+    }
+    catch {
+        return '[invalid-url-redacted]';
+    }
+}
+export function isProviderBaseUrlPath(path) {
+    return /^providers\.[^.]+\.baseUrl$/.test(path);
+}
+function isValidProviderBaseUrl(value) {
+    try {
+        const url = new URL(value);
+        return (url.protocol === 'https:' &&
+            url.username.length === 0 &&
+            url.password.length === 0 &&
+            url.search.length === 0 &&
+            url.hash.length === 0);
+    }
+    catch {
+        return false;
+    }
+}
+export function validateProviderBaseUrl(value) {
+    if (value !== undefined && (typeof value !== 'string' || !isValidProviderBaseUrl(value))) {
+        throw new Error('Provider base URL must be HTTPS without embedded credentials, query, or fragment');
+    }
+}
+export function getProxyUrlCandidate(key, value) {
+    if (key === 'proxy.httpProxy') {
+        return value;
+    }
+    if (key === 'proxy' && isRecord(value)) {
+        return value.httpProxy;
+    }
+    return undefined;
+}
+export function isProxyConfigPath(path) {
+    return path === 'proxy' || path.startsWith('proxy.');
+}
+export function validateModelProviderConfig(providers) {
+    for (const provider of Object.values(providers)) {
+        validateProviderBaseUrl(provider?.baseUrl);
+    }
+}
+export function validateProviderConfig(partial) {
+    validateModelProviderConfig(partial.providers ?? {});
+}
+export function isValidProxyUrl(value) {
+    try {
+        const url = new URL(value);
+        return ((url.protocol === 'http:' || url.protocol === 'https:') &&
+            url.username.length === 0 &&
+            url.password.length === 0 &&
+            url.pathname === '/' &&
+            url.search.length === 0 &&
+            url.hash.length === 0);
+    }
+    catch {
+        return false;
+    }
+}
+export function validateProxyUrl(value) {
+    if (value !== undefined && (typeof value !== 'string' || !isValidProxyUrl(value))) {
+        throw new Error('Proxy URL must be an HTTP or HTTPS URL without embedded credentials');
+    }
+}
+export function validateProxyConfig(partial) {
+    validateProxyUrl(partial.proxy?.httpProxy);
+}
+export function containsSensitiveConfigValue(value) {
+    if (Array.isArray(value)) {
+        return value.some(containsSensitiveConfigValue);
+    }
+    if (value === null || typeof value !== 'object') {
+        return false;
+    }
+    return Object.entries(value).some(([key, entry]) => isSecretKey(key) || containsSensitiveConfigValue(entry));
+}
+export function redactConfigSecrets(value, path = '') {
+    if (Array.isArray(value)) {
+        return value.map((item, index) => redactConfigSecrets(item, `${path}[${index}]`));
+    }
+    if (value === null || typeof value !== 'object') {
+        if (isProviderBaseUrlPath(path) && typeof value === 'string') {
+            return sanitizeBaseUrlForDisplay(value);
+        }
+        return value;
+    }
+    return Object.fromEntries(Object.entries(value).map(([key, entry]) => {
+        const nextPath = path ? `${path}.${key}` : key;
+        if (isSecretKey(key)) {
+            return [key, '***'];
+        }
+        if (isProviderBaseUrlPath(nextPath) && typeof entry === 'string') {
+            return [key, sanitizeBaseUrlForDisplay(entry)];
+        }
+        return [key, redactConfigSecrets(entry, nextPath)];
+    }));
+}

package/dist/services/config/config-workspace.d.ts

@@ -0,0 +1,10 @@
+import type { ConfigLayer, WorkspaceConfig } from './config-types.js';
+export declare function getWorkspaceConfig(workspaceId: string, _projectRoot?: string | null): WorkspaceConfig | null;
+export declare function addWorkspace(workspace: WorkspaceConfig, layer?: ConfigLayer): void;
+export declare function removeWorkspace(workspaceId: string, layer?: ConfigLayer): boolean;
+export declare function setCurrentWorkspace(workspaceId: string, layer?: ConfigLayer): boolean;
+export declare function getCurrentWorkspaceConfig(): WorkspaceConfig | null;
+export declare function getWorkspaceConfigForPath(path?: string): WorkspaceConfig | null;
+export declare function ensureWorkspaceConfigForPath(path?: string): WorkspaceConfig | null;
+export declare function getWorkspaceConfigForCurrentPath(): WorkspaceConfig | null;
+export declare function ensureWorkspaceConfigForCurrentPath(): WorkspaceConfig | null;

package/dist/services/config/config-workspace.js

@@ -0,0 +1,158 @@
+/**
+ * Workspace registry: the raw `workspaces` / `currentWorkspace` fields and the artifact marker.
+ *
+ * Split out of `config-service.ts` (file-size cap campaign). The service
+ * re-exports every name declared here, so existing importers keep using
+ * `./config-service.js` unchanged.
+ */
+import { existsSync } from 'node:fs';
+import { dirname, isAbsolute, resolve } from 'node:path';
+import { stablePath } from '../../shared/path-utils.js';
+import { getUserConfigPath, isInsidePath, resolveProjectRootForConfig, validateArtifactWorkspaceMarkerPath, validateArtifactWorkspaceRoot, validateProjectBootstrapConfigPathForWrite, validateUserConfigPathForWrite, writeConfigFileSafely, writeProjectConfigFile, writeUserConfigFile } from './config-safety.js';
+import { toWorkspaceConfigs } from './config-coercion.js';
+import { ensureDir, getProjectWriteTarget, readJsonFile } from './config-file-io.js';
+import { getConfig } from './config-get.js';
+import { isRecord, isSafeConfigSegment } from './config-primitives.js';
+function readRawWorkspaceData(layer) {
+    const config = getConfig({ layer });
+    return isRecord(config)
+        ? {
+            currentWorkspace: typeof config.currentWorkspace === 'string' ? config.currentWorkspace : null,
+            workspaces: toWorkspaceConfigs(config.workspaces)
+        }
+        : { currentWorkspace: null, workspaces: [] };
+}
+function writeRawWorkspaceData(data, layer) {
+    const projectTarget = layer === 'project' ? getProjectWriteTarget() : null;
+    const targetPath = projectTarget?.configPath ?? getUserConfigPath();
+    ensureDir(dirname(targetPath));
+    const existing = projectTarget
+        ? (readJsonFile(targetPath, () => validateProjectBootstrapConfigPathForWrite(projectTarget.projectRoot, targetPath)) ?? {})
+        : (readJsonFile(targetPath, () => validateUserConfigPathForWrite(targetPath)) ?? {});
+    const merged = { ...existing, ...data };
+    const content = JSON.stringify(merged, null, 2);
+    if (projectTarget) {
+        writeProjectConfigFile(projectTarget.projectRoot, targetPath, content);
+    }
+    else {
+        writeUserConfigFile(targetPath, content);
+    }
+}
+function readAllWorkspaces() {
+    const userData = readRawWorkspaceData('user');
+    const projectData = readRawWorkspaceData('project');
+    const mergedWorkspaces = new Map();
+    for (const w of userData.workspaces)
+        mergedWorkspaces.set(w.workspaceId, w);
+    for (const w of projectData.workspaces)
+        mergedWorkspaces.set(w.workspaceId, w);
+    return {
+        currentWorkspace: projectData.currentWorkspace ?? userData.currentWorkspace,
+        workspaces: [...mergedWorkspaces.values()]
+    };
+}
+export function getWorkspaceConfig(workspaceId, _projectRoot) {
+    // Accepted for signature stability: the registry spans the user and project
+    // layers, so the id alone identifies the workspace.
+    void _projectRoot;
+    const { workspaces } = readAllWorkspaces();
+    return workspaces.find((w) => w.workspaceId === workspaceId) ?? null;
+}
+function readLayerConfig(layer) {
+    return readRawWorkspaceData(layer);
+}
+export function addWorkspace(workspace, layer = 'user') {
+    if (!isSafeConfigSegment(workspace.workspaceId)) {
+        throw new Error('Workspace id must only contain letters, numbers, dots, underscores, or hyphens and must not contain path traversal');
+    }
+    const config = readRawWorkspaceData(layer);
+    const workspaces = config.workspaces;
+    const existing = workspaces.findIndex((w) => w.workspaceId === workspace.workspaceId);
+    const updatedWorkspaces = existing >= 0
+        ? workspaces.map((existingWorkspace) => existingWorkspace.workspaceId === workspace.workspaceId ? workspace : existingWorkspace)
+        : [...workspaces, workspace];
+    writeRawWorkspaceData({ workspaces: updatedWorkspaces }, layer);
+}
+export function removeWorkspace(workspaceId, layer = 'user') {
+    if (!isSafeConfigSegment(workspaceId))
+        return false;
+    const config = readRawWorkspaceData(layer);
+    const workspaces = config.workspaces;
+    const idx = workspaces.findIndex((w) => w.workspaceId === workspaceId);
+    if (idx < 0)
+        return false;
+    const updatedWorkspaces = workspaces.filter((w) => w.workspaceId !== workspaceId);
+    const currentWorkspace = config.currentWorkspace === workspaceId
+        ? (updatedWorkspaces[0]?.workspaceId ?? null)
+        : (config.currentWorkspace ?? null);
+    writeRawWorkspaceData({ workspaces: updatedWorkspaces, currentWorkspace }, layer);
+    return true;
+}
+export function setCurrentWorkspace(workspaceId, layer = 'user') {
+    if (!isSafeConfigSegment(workspaceId))
+        return false;
+    const config = readRawWorkspaceData(layer);
+    const workspaces = config.workspaces;
+    const exists = workspaces.some((w) => w.workspaceId === workspaceId);
+    if (!exists)
+        return false;
+    writeRawWorkspaceData({ currentWorkspace: workspaceId }, layer);
+    return true;
+}
+export function getCurrentWorkspaceConfig() {
+    const { currentWorkspace, workspaces } = readAllWorkspaces();
+    if (!currentWorkspace)
+        return null;
+    return workspaces.find((w) => w.workspaceId === currentWorkspace) ?? null;
+}
+export function getWorkspaceConfigForPath(path = process.cwd()) {
+    const { workspaces } = readAllWorkspaces();
+    return findWorkspaceForPath(workspaces, path);
+}
+function findWorkspaceForPath(workspaces, path) {
+    const targetPath = stablePath(path);
+    const matches = workspaces.flatMap((workspace) => {
+        if (!isAbsolute(workspace.rootPath) || !existsSync(workspace.rootPath))
+            return [];
+        const rootPath = stablePath(workspace.rootPath);
+        return isInsidePath(targetPath, rootPath) ? [{ workspace, rootPath }] : [];
+    });
+    if (matches.length === 0)
+        return null;
+    return matches.reduce((best, match) => match.rootPath.length > best.rootPath.length ? match : best).workspace;
+}
+function getWorkspaceArtifactRoot(workspace) {
+    return workspace.artifactStorage?.localPath
+        ? resolve(workspace.artifactStorage.localPath)
+        : resolve(workspace.rootPath, '.peaks', 'artifacts');
+}
+function ensureArtifactWorkspaceMarker(workspace) {
+    const artifactRoot = getWorkspaceArtifactRoot(workspace);
+    const peaksPath = resolve(artifactRoot, '.peaks');
+    const markerPath = resolve(peaksPath, 'config.json');
+    ensureDir(artifactRoot);
+    validateArtifactWorkspaceRoot(artifactRoot, workspace.rootPath);
+    ensureDir(peaksPath);
+    validateArtifactWorkspaceMarkerPath(artifactRoot, peaksPath, markerPath);
+    if (!existsSync(markerPath)) {
+        writeConfigFileSafely(markerPath, '{}\n', () => validateArtifactWorkspaceMarkerPath(artifactRoot, peaksPath, markerPath), 'Artifact workspace marker must stay inside the artifact workspace');
+    }
+}
+export function ensureWorkspaceConfigForPath(path = process.cwd()) {
+    const projectRoot = resolveProjectRootForConfig(path);
+    if (!isAbsolute(projectRoot) || !existsSync(projectRoot))
+        return null;
+    const config = readLayerConfig('user');
+    const existingWorkspace = findWorkspaceForPath(config.workspaces, path);
+    if (existingWorkspace) {
+        ensureArtifactWorkspaceMarker(existingWorkspace);
+        return existingWorkspace;
+    }
+    return null;
+}
+export function getWorkspaceConfigForCurrentPath() {
+    return getWorkspaceConfigForPath(process.cwd());
+}
+export function ensureWorkspaceConfigForCurrentPath() {
+    return ensureWorkspaceConfigForPath(process.cwd());
+}

package/dist/services/skills/hooks-settings-deny-list.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Merge the peaks-managed Skill denylist into the existing settings object.
+ * Preserves every other `permissions.deny` entry the user (or another tool)
+ * has written so the install is additive, not destructive. The output is
+ * always deterministic: the same input always yields the same output,
+ * regardless of insertion order in the source array.
+ *
+ * Defensive behavior:
+ * - `settings.permissions` is missing or non-object → install creates a
+ *   fresh `permissions: { deny: [...our entries] }` object.
+ * - `settings.permissions.deny` is missing or non-array → install replaces
+ *   the field with a fresh array containing only our entries.
+ * - Duplicate entries (any source) are collapsed to one via `new Set`.
+ *
+ * The function is pure: it does not mutate the input. Atomic write happens
+ * at the call site (`applyHookInstall`).
+ */
+export declare function withSuperpowersSkillDenylist(settings: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Inverse of `withSuperpowersSkillDenylist`. Removes every peaks-managed
+ * `UseSkill(...)` entry from the deny list. If the resulting deny list is
+ * empty, the `deny` field itself is deleted; if the `permissions` object
+ * becomes empty, the `permissions` field itself is deleted. This is the
+ * uninstall path: every field we wrote must be removed exactly, and no
+ * other field may be touched.
+ *
+ * Pure (no mutation).
+ */
+export declare function withoutSuperpowersSkillDenylist(settings: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Read-only introspection. Returns the deny entries that `peaks hooks
+ * install` would write today. Useful for `peaks hooks status` and the
+ * dry-run envelope.
+ */
+export declare function listSuperpowersDenyEntries(): ReadonlyArray<string>;
+/**
+ *
+ * In addition to the static SUPERPOWERS_DENIED_SKILLS list, peaks
+ * scans the existing settings file for "trigger phrases" that
+ * indicate the user has configured the superpowers chain (or
+ * any other auto-run worktree-creating tool) and appends a
+ * defensive deny to prevent the chain from running raw
+ * `git worktree add` (or `podman run`) directly.
+ *
+ * Triggers detected (substring match on the existing
+ * permissions.deny / permissions.allow list):
+ *
+ *  - `superpowers:using-git-worktrees` — the chain's ground zero
+ *  - `superpowers:brainstorming` etc. — the upstream skill
+ *  - `Bash(git worktree add` — the user has explicitly
+ *    allowed raw git worktree, which our L2 lease-aware gate
+ *    would also intercept (defense in depth)
+ *
+ * Append-only — never replaces, never re-orders, never removes
+ * existing entries. Idempotent: re-running the install with
+ * the same input yields the same output.
+ */
+export declare const TRIGGER_PHRASES: ReadonlyArray<string>;
+export declare function withTriggeredDenyList(settings: Record<string, unknown>): Record<string, unknown>;
+/** Inverse of withTriggeredDenyList: strip every deny-trigger entry. */
+export declare function withoutTriggeredDenyList(settings: Record<string, unknown>): Record<string, unknown>;

package/dist/services/skills/hooks-settings-deny-list.js

@@ -0,0 +1,173 @@
+/**
+ * The peaks-managed `permissions.deny` entries, and their inverses.
+ *
+ * Split out of `hooks-settings-service.ts` (file-size cap campaign). The
+ * service re-exports every name declared here, so existing importers keep
+ * using `./hooks-settings-service.js` unchanged.
+ */
+import { SUPERPOWERS_DENIED_SKILLS, SUPERPOWERS_DENY_SENTINELS, formatSuperpowersDenyEntry } from './hooks-codegate-superpowers.js';
+/**
+ * Merge the peaks-managed Skill denylist into the existing settings object.
+ * Preserves every other `permissions.deny` entry the user (or another tool)
+ * has written so the install is additive, not destructive. The output is
+ * always deterministic: the same input always yields the same output,
+ * regardless of insertion order in the source array.
+ *
+ * Defensive behavior:
+ * - `settings.permissions` is missing or non-object → install creates a
+ *   fresh `permissions: { deny: [...our entries] }` object.
+ * - `settings.permissions.deny` is missing or non-array → install replaces
+ *   the field with a fresh array containing only our entries.
+ * - Duplicate entries (any source) are collapsed to one via `new Set`.
+ *
+ * The function is pure: it does not mutate the input. Atomic write happens
+ * at the call site (`applyHookInstall`).
+ */
+export function withSuperpowersSkillDenylist(settings) {
+    const ourEntries = SUPERPOWERS_DENIED_SKILLS.map(formatSuperpowersDenyEntry);
+    const permissions = settings.permissions &&
+        typeof settings.permissions === 'object' &&
+        !Array.isArray(settings.permissions)
+        ? settings.permissions
+        : {};
+    const existingDeny = Array.isArray(permissions.deny)
+        ? permissions.deny.filter((d) => typeof d === 'string')
+        : [];
+    const otherDeny = existingDeny.filter((d) => !SUPERPOWERS_DENY_SENTINELS.has(d));
+    const finalDeny = [...new Set([...otherDeny, ...ourEntries])];
+    return {
+        ...settings,
+        permissions: { ...permissions, deny: finalDeny }
+    };
+}
+/**
+ * Inverse of `withSuperpowersSkillDenylist`. Removes every peaks-managed
+ * `UseSkill(...)` entry from the deny list. If the resulting deny list is
+ * empty, the `deny` field itself is deleted; if the `permissions` object
+ * becomes empty, the `permissions` field itself is deleted. This is the
+ * uninstall path: every field we wrote must be removed exactly, and no
+ * other field may be touched.
+ *
+ * Pure (no mutation).
+ */
+export function withoutSuperpowersSkillDenylist(settings) {
+    const permissions = settings.permissions &&
+        typeof settings.permissions === 'object' &&
+        !Array.isArray(settings.permissions)
+        ? settings.permissions
+        : {};
+    if (!Array.isArray(permissions.deny)) {
+        return settings;
+    }
+    const remainingDeny = permissions.deny
+        .filter((d) => typeof d === 'string')
+        .filter((d) => !SUPERPOWERS_DENY_SENTINELS.has(d));
+    const nextPermissions = { ...permissions };
+    if (remainingDeny.length > 0) {
+        nextPermissions.deny = remainingDeny;
+    }
+    else {
+        delete nextPermissions.deny;
+    }
+    if (Object.keys(nextPermissions).length === 0) {
+        // The whole `permissions` object is empty (no deny, no allow, no other
+        // sub-fields). Drop it to avoid leaving an empty object on disk.
+        const rest = { ...settings };
+        delete rest['permissions'];
+        return rest;
+    }
+    return { ...settings, permissions: nextPermissions };
+}
+/**
+ * Read-only introspection. Returns the deny entries that `peaks hooks
+ * install` would write today. Useful for `peaks hooks status` and the
+ * dry-run envelope.
+ */
+export function listSuperpowersDenyEntries() {
+    return SUPERPOWERS_DENIED_SKILLS.map(formatSuperpowersDenyEntry);
+}
+/**
+ *
+ * In addition to the static SUPERPOWERS_DENIED_SKILLS list, peaks
+ * scans the existing settings file for "trigger phrases" that
+ * indicate the user has configured the superpowers chain (or
+ * any other auto-run worktree-creating tool) and appends a
+ * defensive deny to prevent the chain from running raw
+ * `git worktree add` (or `podman run`) directly.
+ *
+ * Triggers detected (substring match on the existing
+ * permissions.deny / permissions.allow list):
+ *
+ *  - `superpowers:using-git-worktrees` — the chain's ground zero
+ *  - `superpowers:brainstorming` etc. — the upstream skill
+ *  - `Bash(git worktree add` — the user has explicitly
+ *    allowed raw git worktree, which our L2 lease-aware gate
+ *    would also intercept (defense in depth)
+ *
+ * Append-only — never replaces, never re-orders, never removes
+ * existing entries. Idempotent: re-running the install with
+ * the same input yields the same output.
+ */
+export const TRIGGER_PHRASES = Object.freeze([
+    'superpowers:using-git-worktrees',
+    'superpowers:brainstorming',
+    'superpowers:writing-plans',
+    'superpowers:subagent-driven-development',
+    'Bash(git worktree add',
+    'Bash(podman run'
+]);
+/**
+ * Format a trigger-phrase into a stable `Edit` deny entry. We deny
+ * `Edit` (not `Bash`) on the *settings file* itself, so the
+ * user cannot edit the trigger away without an explicit
+ * `peaks hooks uninstall` first. The skill name (when
+ * applicable) is the value after the colon.
+ */
+function formatTriggerDenyEntry(phrase) {
+    return `Edit(deny-trigger:${phrase})`;
+}
+export function withTriggeredDenyList(settings) {
+    const existingDeny = Array.isArray(settings.permissions?.deny)
+        ? settings.permissions.deny.filter((d) => typeof d === 'string')
+        : [];
+    // Detect triggers in the existing allow + deny lists.
+    const existingAllow = Array.isArray(settings.permissions?.allow)
+        ? settings.permissions.allow.filter((d) => typeof d === 'string')
+        : [];
+    const haystack = [...existingDeny, ...existingAllow].join('|');
+    const triggered = TRIGGER_PHRASES.filter((p) => haystack.includes(p));
+    if (triggered.length === 0)
+        return settings;
+    const triggeredEntries = triggered.map(formatTriggerDenyEntry);
+    const permissions = settings.permissions &&
+        typeof settings.permissions === 'object' &&
+        !Array.isArray(settings.permissions)
+        ? settings.permissions
+        : {};
+    const otherDeny = existingDeny.filter((d) => !triggeredEntries.includes(d));
+    return {
+        ...settings,
+        permissions: { ...permissions, deny: [...new Set([...otherDeny, ...triggeredEntries])] }
+    };
+}
+/** Inverse of withTriggeredDenyList: strip every deny-trigger entry. */
+export function withoutTriggeredDenyList(settings) {
+    const permissions = settings.permissions &&
+        typeof settings.permissions === 'object' &&
+        !Array.isArray(settings.permissions)
+        ? settings.permissions
+        : {};
+    const existingDeny = Array.isArray(permissions.deny)
+        ? permissions.deny.filter((d) => typeof d === 'string')
+        : [];
+    const kept = existingDeny.filter((d) => !d.startsWith('Edit(deny-trigger:'));
+    const next = { ...permissions, deny: kept };
+    if (kept.length === 0)
+        delete next.deny;
+    if (Object.keys(next).length === 0) {
+        const out = { ...settings };
+        delete out.permissions;
+        return out;
+    }
+    return { ...settings, permissions: next };
+}

package/dist/services/skills/hooks-settings-envelopes.d.ts

@@ -0,0 +1,20 @@
+import type { HookScope } from '../ide/shared/safe-path.js';
+import type { HookRemoveResult, HookStatus, HookTarget } from './hooks-settings-types.js';
+/** The uninstall envelope; a `localPath` is reported only when it is a distinct file. */
+export declare function removedResult(scope: HookScope, settingsPath: string, localPath: string | undefined, removed: boolean): HookRemoveResult;
+/**
+ * Strip every peaks-managed row from one target's file and write it back.
+ *
+ * The deny-list helpers run only on the SHARED settings file (the one that
+ * carries the committed `permissions.deny` block); the machine-local file
+ * carries hook entries plus, for Claude Code, the gate exemptions.
+ */
+export declare function applyRemovalToTarget(target: HookTarget, sentinels: ReadonlyArray<string>, isSharedFile: boolean): boolean;
+/**
+ * The status envelope for an IDE that can never carry a peaks hook: the query
+ * ran, the disk was read, and the honest reply is "nothing, and nothing ever
+ * will be".
+ */
+export declare function unsupportedHookStatus(scope: HookScope, settingsPath: string, localPath: string | undefined): HookStatus;
+/** The status envelope for a set of resolved targets. */
+export declare function hookStatusFromTargets(scope: HookScope, settingsPath: string, targets: ReadonlyArray<HookTarget>): HookStatus;

package/dist/services/skills/hooks-settings-envelopes.js

@@ -0,0 +1,79 @@
+/**
+ * The result envelopes the uninstall and status verbs return.
+ *
+ * Split out of `hooks-settings-service.ts` (file-size cap campaign). The
+ * service re-exports every name declared here, so existing importers keep
+ * using `./hooks-settings-service.js` unchanged.
+ */
+import { existsSync } from 'node:fs';
+import { atomicWriteJson } from '../ide/shared/atomic-json.js';
+import { withoutExternalGateExemptions } from './hooks-codegate-superpowers.js';
+import { withoutSuperpowersSkillDenylist, withoutTriggeredDenyList } from './hooks-settings-deny-list.js';
+import { isInstalledForEntries, readSettingsFile, stripPeaksEntries } from './hooks-settings-file-shape.js';
+/** The uninstall envelope; a `localPath` is reported only when it is a distinct file. */
+export function removedResult(scope, settingsPath, localPath, removed) {
+    return {
+        scope,
+        settingsPath,
+        removed,
+        ...(localPath !== undefined && localPath !== settingsPath
+            ? { localSettingsPath: localPath }
+            : {})
+    };
+}
+/**
+ * Strip every peaks-managed row from one target's file and write it back.
+ *
+ * The deny-list helpers run only on the SHARED settings file (the one that
+ * carries the committed `permissions.deny` block); the machine-local file
+ * carries hook entries plus, for Claude Code, the gate exemptions.
+ */
+export function applyRemovalToTarget(target, sentinels, isSharedFile) {
+    const { settings, removed } = stripPeaksEntries(target, sentinels);
+    let finalSettings = settings;
+    if (target.envExemptions === true) {
+        finalSettings = withoutExternalGateExemptions(finalSettings);
+    }
+    if (isSharedFile) {
+        finalSettings = withoutTriggeredDenyList(withoutSuperpowersSkillDenylist(finalSettings));
+    }
+    atomicWriteJson(target.settingsPath, finalSettings);
+    return removed;
+}
+/**
+ * The status envelope for an IDE that can never carry a peaks hook: the query
+ * ran, the disk was read, and the honest reply is "nothing, and nothing ever
+ * will be".
+ */
+export function unsupportedHookStatus(scope, settingsPath, localPath) {
+    return {
+        scope,
+        settingsPath,
+        exists: existsSync(settingsPath),
+        ...(localPath !== undefined && localPath !== settingsPath
+            ? { localSettingsPath: localPath, localExists: existsSync(localPath) }
+            : {}),
+        installed: false,
+        supportsHooks: false
+    };
+}
+/** The status envelope for a set of resolved targets. */
+export function hookStatusFromTargets(scope, settingsPath, targets) {
+    const localTarget = targets.find((t) => t.settingsPath !== settingsPath);
+    return {
+        scope,
+        settingsPath,
+        exists: existsSync(settingsPath),
+        ...(localTarget !== undefined
+            ? {
+                localSettingsPath: localTarget.settingsPath,
+                localExists: existsSync(localTarget.settingsPath)
+            }
+            : {}),
+        installed: targets.some((t) => {
+            const settings = readSettingsFile(t.settingsPath);
+            return Object.keys(settings).length > 0 && isInstalledForEntries(settings, t.entries);
+        }),
+        supportsHooks: true
+    };
+}