peaks-cli 1.3.9 → 1.4.0

package/dist/src/services/doctor/doctor-service.d.ts

@@ -44,6 +44,43 @@ export type WorkspaceLayoutInspection = {
     perChangeIdDirs?: string[];
 };
 export type WorkspaceLayoutProbe = () => WorkspaceLayoutInspection;
+/**
+ * 2026-06-10 — `gateguard-fact-force` (a third-party PreToolUse hook,
+ * NOT peaks-cli) fires on Edit / Write and demands a 4-fact questionnaire
+ * before allowing the edit. When the LLM is in a peaks-qa flow and tries
+ * to update `.peaks/_runtime/<sid>/qa/requests/*.md` via the Edit/Write
+ * tool, the hook demands facts that are inapplicable to QA envelope
+ * templates (no importers, no public API, no data files, user
+ * instruction already in the conversation context). The check detects
+ * this hook in the user's global and project `.claude/settings.json` and
+ * warns when no `.peaks/**` skip is configured. The probe is injected so
+ * tests do not depend on the real `~/.claude/settings.json` state.
+ */
+export type GateguardHookLocation = {
+    /** Source file the hook was discovered in (`global` or `project .claude/settings.json`). */
+    source: 'global' | 'project';
+    /** Resolved absolute path to the source file (for the message). */
+    sourcePath: string;
+    /** The PreToolUse entry that contains a gateguard hook command. */
+    entry: {
+        matcher?: string;
+        hooks: ReadonlyArray<{
+            type?: string;
+            command?: string;
+        }>;
+    };
+};
+export type GateguardProbeResult = {
+    /** Absolute path to `~/.claude/settings.json` (or null when the probe could not resolve it). */
+    globalSettingsPath: string | null;
+    /** Parsed global settings payload (or null when missing / unreadable / malformed). */
+    globalSettings: unknown;
+    /** Absolute path to the project `.claude/settings.json` (or null when the project root is not in a peaks project). */
+    projectSettingsPath: string | null;
+    /** Parsed project settings payload (or null when missing / unreadable / malformed). */
+    projectSettings: unknown;
+};
+export type GateguardProbe = () => GateguardProbeResult;
 export type DoctorOptions = {
     schemasBaseDir?: string;
     skillsBaseDir?: string;
@@ -59,6 +96,8 @@ export type DoctorOptions = {
     distVersionProbe?: DistVersionProbe;
     /** Injected for the build:workspace-layout-canonical check (defaults to inspectWorkspaceLayout on disk). */
     workspaceLayoutProbe?: WorkspaceLayoutProbe;
+    /** Injected for the integration:gateguard-peaks-conflict check (defaults to defaultGateguardProbe on disk). */
+    gateguardProbe?: GateguardProbe;
 };
 /**
  * Pure helper extracted from `defaultWorkspaceInitializedProbe` so tests can
@@ -99,4 +138,5 @@ export declare function inspectWorkspaceLayout(opts: {
     dotfileScanner?: (root: string) => string[];
     perChangeIdScanner?: (root: string) => string[];
 }): WorkspaceLayoutInspection;
+export declare function collectGateguardEntries(probe: GateguardProbeResult): GateguardHookLocation[];
 export declare function runDoctor(options?: DoctorOptions): Promise<DoctorReport>;

package/dist/src/services/doctor/doctor-service.js

@@ -270,6 +270,121 @@ function findDestructiveApplyLines(section) {
     const lines = section.split(/\r?\n/);
     return lines.filter((line) => DESTRUCTIVE_APPLY_PATTERNS.some((pattern) => pattern.test(line)));
 }
+// ---------------------------------------------------------------------------
+// 2026-06-10 — gateguard-fact-force integration check (NOT a peaks-cli hook).
+//
+// The `gateguard-fact-force` hook is a third-party PreToolUse hook that
+// fires on Edit / Write / MultiEdit and demands a 4-fact questionnaire
+// before allowing the edit. It is unrelated to peaks-cli, but when the
+// LLM is in a peaks-qa flow and edits `.peaks/_runtime/<sid>/qa/requests/
+// *.md`, the questionnaire demands facts that do not apply (no
+// importers, no public API, no data files, user instruction already
+// in the conversation context). The check below detects the hook in
+// `~/.claude/settings.json` and the project `.claude/settings.json`,
+// and warns when no `.peaks/**` skip is configured.
+//
+// Probing is split out of the check so the check itself stays a pure
+// mapping over `GateguardProbeResult`. Tests inject the probe to keep
+// `~/.claude/settings.json` from leaking into test fixtures.
+// ---------------------------------------------------------------------------
+/** Hook command fragments that identify the gateguard-fact-force hook. */
+const GATEGUARD_HOOK_NEEDLES = ['gateguard', 'fact-force', 'fact_force'];
+/** Token the gateguard hook exposes for "skip these paths" — the check
+ *  treats any match against `.peaks` (path or globs) as a routed
+ *  configuration. We accept a few common spellings because the third-
+ *  party hook's CLI surface is not part of peaks-cli's contract. */
+const GATEGUARD_PEAKS_SKIP_NEEDLES = [
+    '.peaks',
+    'peaks-skip',
+    'skip-glob',
+    '--skip',
+    'skip_paths'
+];
+function commandMentionsGateguard(command) {
+    if (typeof command !== 'string' || command.length === 0)
+        return false;
+    const lower = command.toLowerCase();
+    return GATEGUARD_HOOK_NEEDLES.some((needle) => lower.includes(needle));
+}
+function entrySkipsPeaks(entry) {
+    const matcher = typeof entry.matcher === 'string' ? entry.matcher : '';
+    const matcherMentionsPeaks = matcher.toLowerCase().includes('.peaks');
+    if (matcherMentionsPeaks)
+        return true;
+    for (const hook of entry.hooks) {
+        const command = typeof hook.command === 'string' ? hook.command : '';
+        const lower = command.toLowerCase();
+        if (GATEGUARD_PEAKS_SKIP_NEEDLES.some((needle) => lower.includes(needle))) {
+            return true;
+        }
+    }
+    return false;
+}
+function extractGateguardEntries(source, sourcePath, settings) {
+    if (settings === null || typeof settings !== 'object')
+        return [];
+    const hooks = settings.hooks;
+    if (hooks === null || typeof hooks !== 'object')
+        return [];
+    const preToolUse = hooks.PreToolUse;
+    if (!Array.isArray(preToolUse))
+        return [];
+    const out = [];
+    for (const rawEntry of preToolUse) {
+        if (rawEntry === null || typeof rawEntry !== 'object')
+            continue;
+        const entry = rawEntry;
+        if (!Array.isArray(entry.hooks))
+            continue;
+        const hooks = [];
+        for (const rawHook of entry.hooks) {
+            if (rawHook === null || typeof rawHook !== 'object')
+                continue;
+            const h = rawHook;
+            const hookEntry = {};
+            if (typeof h.type === 'string')
+                hookEntry.type = h.type;
+            if (typeof h.command === 'string')
+                hookEntry.command = h.command;
+            hooks.push(hookEntry);
+        }
+        if (!hooks.some((h) => commandMentionsGateguard(h.command)))
+            continue;
+        const outEntry = { hooks };
+        if (typeof entry.matcher === 'string')
+            outEntry.matcher = entry.matcher;
+        out.push({ source, sourcePath, entry: outEntry });
+    }
+    return out;
+}
+function readSettingsJson(path) {
+    if (!existsSync(path))
+        return null;
+    try {
+        return JSON.parse(readFileSync(path, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function defaultGateguardProbe() {
+    const projectRoot = findProjectRoot(process.cwd());
+    const globalPath = join(homedir(), '.claude', 'settings.json');
+    const projectPath = projectRoot === null ? null : join(projectRoot, '.claude', 'settings.json');
+    return {
+        globalSettingsPath: globalPath,
+        globalSettings: readSettingsJson(globalPath),
+        projectSettingsPath: projectPath,
+        projectSettings: projectPath === null ? null : readSettingsJson(projectPath)
+    };
+}
+export function collectGateguardEntries(probe) {
+    const fromGlobal = extractGateguardEntries('global', probe.globalSettingsPath ?? '~/.claude/settings.json', probe.globalSettings);
+    const fromProject = probe.projectSettingsPath === null
+        ? []
+        : extractGateguardEntries('project', probe.projectSettingsPath, probe.projectSettings);
+    return [...fromGlobal, ...fromProject];
+}
 export async function runDoctor(options = {}) {
     const checks = [];
     const registry = await loadSkillRegistry(options.skillsBaseDir);
@@ -619,6 +734,51 @@ export async function runDoctor(options = {}) {
             message: `Workspace layout check failed: ${getErrorMessage(error)}`
         });
     }
+    // 2026-06-10 — gateguard-fact-force integration check. The hook is a
+    // third-party PreToolUse that fires on Edit / Write and demands a
+    // 4-fact questionnaire; when the LLM is in a peaks-qa flow updating
+    // `.peaks/_runtime/<sid>/qa/requests/*.md` the facts do not apply.
+    // We warn when the hook is installed and no `.peaks/**` skip is
+    // configured. The check stays a pure mapping over the probe result
+    // so tests can drive it without touching the real `~/.claude/`.
+    const gateguardProbe = options.gateguardProbe ?? defaultGateguardProbe;
+    try {
+        const probe = gateguardProbe();
+        const offending = collectGateguardEntries(probe);
+        if (offending.length === 0) {
+            checks.push({
+                id: 'integration:gateguard-peaks-conflict',
+                ok: true,
+                message: 'No gateguard-fact-force PreToolUse hook detected in ~/.claude/settings.json or project .claude/settings.json; the Edit/Write fact-forcing flow will not interfere with peaks-qa .peaks/ artifact writes'
+            });
+        }
+        else {
+            const unrouted = offending.filter((location) => !entrySkipsPeaks(location.entry));
+            if (unrouted.length === 0) {
+                checks.push({
+                    id: 'integration:gateguard-peaks-conflict',
+                    ok: true,
+                    message: `gateguard-fact-force hook is installed in ${offending.map((l) => l.source).join(' + ')} but a .peaks/** skip pattern is configured; peaks-qa .peaks/ artifact writes are not blocked`
+                });
+            }
+            else {
+                const sources = Array.from(new Set(unrouted.map((u) => u.sourcePath))).join(' + ');
+                const matchers = unrouted.map((u) => u.entry.matcher ?? '*').join(', ');
+                checks.push({
+                    id: 'integration:gateguard-peaks-conflict',
+                    ok: false,
+                    message: `gateguard-fact-force PreToolUse hook is installed (${sources}, matcher: ${matchers}) with no .peaks/** skip pattern; every Edit/Write of a peaks-qa envelope (.peaks/_runtime/<sid>/qa/requests/*.md) will be intercepted and demand a 4-fact questionnaire that does not apply to QA templates. Workaround: set \`ECC_DISABLED_HOOKS=pre:edit-write:gateguard-fact-force\` for the session, OR add a paired PreToolUse entry whose matcher restricts the hook to non-.peaks paths. peaks-cli is NOT the source of this hook.`
+                });
+            }
+        }
+    }
+    catch (error) {
+        checks.push({
+            id: 'integration:gateguard-peaks-conflict',
+            ok: true,
+            message: `gateguard probe failed (${getErrorMessage(error)}); skipping check`
+        });
+    }
     try {
         const schemaText = await readText(join(schemaRoot, 'doctor-report.schema.json'));
         const schema = JSON.parse(schemaText);

package/dist/src/services/hooks/presence-marker-detector.d.ts

@@ -0,0 +1,16 @@
+export type DetectPresenceMarkerInput = {
+    project: string;
+    latestAssistantMessage: string;
+};
+export type DetectPresenceMarkerResult = {
+    active: boolean;
+    skill?: string;
+    markerFound: boolean;
+    warning?: string;
+};
+export type PresenceMarkerWarning = (typeof PRESENCE_MARKER_WARNING)[number];
+export declare const PRESENCE_MARKER_WARNING: readonly ["Peaks skill context may have been lost from this conversation; please re-invoke /peaks-<skill>."];
+/**
+ * Pure read-only presence-marker detection. No I/O side effects.
+ */
+export declare function detectPresenceMarker(input: DetectPresenceMarkerInput): DetectPresenceMarkerResult;

package/dist/src/services/hooks/presence-marker-detector.js

@@ -0,0 +1,105 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+/**
+ * Slice 028 (Q1=A): hook-based skill-presence marker detection.
+ *
+ * Background: the consumer-facing CLAUDE.md template (rendered by
+ * `peaks standards init` / `peaks standards update`) instructs the LLM
+ * to display a compact status header
+ *   `Peaks-Cli Skill: <skill> | Peaks-Cli Gate: <gate> | Next: <one short action>`
+ * on every turn while a peaks skill is active. If the LLM forgets (e.g.
+ * because of context compaction or a fresh session), the user is left
+ * without an at-a-glance signal that peaks is orchestrating the work.
+ *
+ * This service is the read-only side of the slice-028 detection
+ * mechanism. The PostToolUse hook (or any other consumer, e.g.
+ * `peaks skill detect-marker-loss`) calls
+ * `detectPresenceMarker({ project, latestAssistantMessage })`
+ * and gets back:
+ *
+ *   - `active`:      whether an active-skill marker was found on disk.
+ *   - `skill?`:      the active skill name, if any.
+ *   - `markerFound`: whether the latest assistant message carries the
+ *                    expected `Peaks-Cli Skill:` / `Peaks-Cli Gate:`
+ *                    marker. Always `false` when `active` is `false`.
+ *   - `warning?`:    a human-readable warning emitted when the marker
+ *                    is missing while the presence is active.
+ *
+ * The function is pure: it does not write to disk, does not clear the
+ * presence file, and does not depend on `process.cwd()`. The caller is
+ * expected to provide the absolute project root (peaks-cli convention
+ * from the standards-commands family — see dev-preference rule
+ * `project-option-is-canonical-project-root-source`).
+ */
+const PRESENCE_CANONICAL_PATH = '.peaks/_runtime/active-skill.json';
+const PRESENCE_LEGACY_PATH = '.peaks/.active-skill.json';
+const MARKER_PRIMARY = 'Peaks-Cli Skill:';
+const MARKER_SECONDARY = 'Peaks-Cli Gate:';
+const SKILL_NAME_RE = /"skill"\s*:\s*"([^"\\]*(?:\\.[^"\\]*)*)"/;
+export const PRESENCE_MARKER_WARNING = [
+    'Peaks skill context may have been lost from this conversation; please re-invoke /peaks-<skill>.'
+];
+function readPresenceFile(absolutePath) {
+    if (!existsSync(absolutePath))
+        return null;
+    let raw;
+    try {
+        raw = readFileSync(absolutePath, 'utf8');
+    }
+    catch {
+        return null;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    if (parsed === null || typeof parsed !== 'object')
+        return null;
+    const skillMatch = SKILL_NAME_RE.exec(JSON.stringify(parsed));
+    if (skillMatch === null)
+        return null;
+    if (typeof skillMatch[1] !== 'string' || skillMatch[1].length === 0)
+        return null;
+    return { skill: skillMatch[1] };
+}
+function readPresenceBackCompat(project) {
+    const projectRoot = resolve(project);
+    const canonicalPath = resolve(projectRoot, PRESENCE_CANONICAL_PATH);
+    const legacyPath = resolve(projectRoot, PRESENCE_LEGACY_PATH);
+    for (const candidate of [canonicalPath, legacyPath]) {
+        const parsed = readPresenceFile(candidate);
+        if (parsed === null)
+            continue;
+        return { skill: parsed.skill, path: candidate };
+    }
+    return null;
+}
+function messageHasMarker(message) {
+    if (message.length === 0)
+        return false;
+    return message.includes(MARKER_PRIMARY) || message.includes(MARKER_SECONDARY);
+}
+/**
+ * Pure read-only presence-marker detection. No I/O side effects.
+ */
+export function detectPresenceMarker(input) {
+    const project = input.project;
+    const message = input.latestAssistantMessage ?? '';
+    const presence = readPresenceBackCompat(project);
+    if (presence === null) {
+        return { active: false, markerFound: false };
+    }
+    const markerFound = messageHasMarker(message);
+    if (markerFound) {
+        return { active: true, skill: presence.skill, markerFound: true };
+    }
+    return {
+        active: true,
+        skill: presence.skill,
+        markerFound: false,
+        warning: PRESENCE_MARKER_WARNING[0]
+    };
+}

package/dist/src/services/skill-scope/adapters/_stub-helper.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Shared `makeStubAdapter` helper for the 5 non-shipped IDEs (Trae, Cursor,
+ * Codex, Qoder, Tongyi Lingma).
+ *
+ * Each stub adapter:
+ * 1. Implements `SkillScopeAdapter` with `supported: false`.
+ * 2. In `applyScope`, ALWAYS writes the companion source-of-truth
+ *    `.peaks/scope/<ide>-skills.json` first, then returns a NOT_SUPPORTED
+ *    ApplyResult (the test contract asserts the source-of-truth is on disk
+ *    even when the adapter can't apply it natively).
+ * 3. In `showScope`, reads from the companion source-of-truth file.
+ * 4. In `resetScope`, removes the companion source-of-truth file.
+ * 5. In `detect`, returns 0.0 (the stub does not actually probe).
+ *
+ * The TODO comment in each stub file points at the follow-up slice (025.2+).
+ */
+import type { SkillScopeAdapter } from '../types.js';
+/**
+ * IDE-id -> companion source-of-truth shape. The companion file is a
+ * parallel record so the user can see "this is what would have applied"
+ * even when the IDE doesn't support a real implementation.
+ */
+export interface StubSourceOfTruth {
+    readonly ide: string;
+    readonly generatedAt: string;
+    readonly strict: boolean;
+    readonly allowlist: readonly string[];
+    readonly denylist: readonly string[];
+    readonly todoRef: string;
+    readonly notes: string;
+}
+/**
+ * The factory: every stub is a thin wrapper around this function. The
+ * `applyScope` implementation ALWAYS writes the source-of-truth, then
+ * returns a NOT_SUPPORTED ApplyResult (NOT a thrown error — the contract
+ * for stub adapters is "return ok:false, notSupported:true" so the CLI
+ * can keep going and surface the error to the user).
+ */
+export declare function makeStubAdapter(ide: SkillScopeAdapter['ide'], todoRef: string, displayName: string): SkillScopeAdapter;

package/dist/src/services/skill-scope/adapters/_stub-helper.js

@@ -0,0 +1,98 @@
+/**
+ * Shared `makeStubAdapter` helper for the 5 non-shipped IDEs (Trae, Cursor,
+ * Codex, Qoder, Tongyi Lingma).
+ *
+ * Each stub adapter:
+ * 1. Implements `SkillScopeAdapter` with `supported: false`.
+ * 2. In `applyScope`, ALWAYS writes the companion source-of-truth
+ *    `.peaks/scope/<ide>-skills.json` first, then returns a NOT_SUPPORTED
+ *    ApplyResult (the test contract asserts the source-of-truth is on disk
+ *    even when the adapter can't apply it natively).
+ * 3. In `showScope`, reads from the companion source-of-truth file.
+ * 4. In `resetScope`, removes the companion source-of-truth file.
+ * 5. In `detect`, returns 0.0 (the stub does not actually probe).
+ *
+ * The TODO comment in each stub file points at the follow-up slice (025.2+).
+ */
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { ideCompanionFilePath, removeIfExists, scopeFilePath, writeJsonAtomic } from '../source-of-truth.js';
+async function writeStubCompanion(ide, input, todoRef) {
+    const file = ideCompanionFilePath(input.projectRoot, ide);
+    const data = {
+        ide,
+        generatedAt: input.sourceConfig.generatedAt,
+        strict: input.strict,
+        allowlist: input.allowlist,
+        denylist: input.denylist,
+        todoRef,
+        notes: `Stub source-of-truth for ${ide}. The real config format has not yet been researched. ` +
+            `This file is written so the user's intent is captured and can be ported when ` +
+            `the follow-up slice (${todoRef}) lands.`,
+    };
+    await writeJsonAtomic(file, data);
+    return file;
+}
+async function readStubCompanion(ide, projectRoot) {
+    const file = ideCompanionFilePath(projectRoot, ide);
+    if (!existsSync(file))
+        return null;
+    try {
+        return JSON.parse(await readFile(file, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The factory: every stub is a thin wrapper around this function. The
+ * `applyScope` implementation ALWAYS writes the source-of-truth, then
+ * returns a NOT_SUPPORTED ApplyResult (NOT a thrown error — the contract
+ * for stub adapters is "return ok:false, notSupported:true" so the CLI
+ * can keep going and surface the error to the user).
+ */
+export function makeStubAdapter(ide, todoRef, displayName) {
+    const ideStr = String(ide);
+    return {
+        ide,
+        supported: false,
+        async detect() {
+            // Stubs never "win" detection; they return 0.0 so the registry falls
+            // back to the shipped adapter (Claude Code).
+            return 0.0;
+        },
+        async applyScope(input) {
+            // 1. Always write the source-of-truth first.
+            const companion = await writeStubCompanion(ideStr, input, todoRef);
+            // 2. Always write the canonical .peaks/scope/skills.json too.
+            const canonical = scopeFilePath(input.projectRoot);
+            await writeJsonAtomic(canonical, input.sourceConfig);
+            // 3. Surface NOT_SUPPORTED with a clear, IDE-named message.
+            const message = `${displayName} (${ideStr}) config format not yet researched — ${todoRef} follow-up. ` +
+                `Source-of-truth written to ${companion}.`;
+            return {
+                ide,
+                ok: false,
+                writtenFiles: [companion, canonical],
+                usedShadowStub: false,
+                notSupported: true,
+                error: { code: 'NOT_SUPPORTED', message },
+            };
+        },
+        async showScope(projectRoot) {
+            const native = await readStubCompanion(ideStr, projectRoot);
+            return { source: null, native, ide };
+        },
+        async resetScope(input) {
+            const removed = [];
+            const companion = ideCompanionFilePath(input.projectRoot, ideStr);
+            if (await removeIfExists(companion))
+                removed.push(companion);
+            // Also remove the canonical source-of-truth on reset.
+            const canonical = scopeFilePath(input.projectRoot);
+            if (await removeIfExists(canonical))
+                removed.push(canonical);
+            return { ide, removedFiles: removed };
+        },
+    };
+}

package/dist/src/services/skill-scope/adapters/claude-code.d.ts

@@ -0,0 +1,59 @@
+/**
+ * `peaks skill scope` — Claude Code adapter (full impl, slice 025.1).
+ *
+ * Strategy (tech-doc-025 §3):
+ * 1. PRIMARY: write `.claude/settings.local.json` with
+ *    `permissions.allow: ["Skill(name)", ...]` + `permissions.deny: [...]`.
+ * 2. FALLBACK (R1, `--shadow-fallback`): when the runtime probe determines
+ *    Claude Code rejects `Skill(name)` in `permissions.deny`, write a
+ *    shadow stub at `.claude/skills/<name>/SKILL.md` for each denylisted
+ *    skill. Tagged with `_peaks_scope_disabled: true` (R6).
+ *
+ * Idempotency: dedupe the allow/deny arrays; shadow-stub writes skip
+ * when the marker is already present. AC11.
+ */
+import type { ApplyResult, ApplyScopeInput, ResetScopeInput, ResetScopeResult, ShowScopeResult, SkillScopeAdapter } from '../types.js';
+/** Format the `Skill(name)` string Claude Code's permission system uses. */
+export declare function skillRef(name: string): string;
+interface ClaudePermissions {
+    readonly allow: string[];
+    readonly deny: string[];
+}
+interface ClaudeSettings {
+    readonly permissions: ClaudePermissions;
+    readonly [key: string]: unknown;
+}
+/**
+ * Map allowlist/denylist → permissions.allow/permissions.deny. Never sorts;
+ * preserves input order. Always dedupes.
+ */
+export declare function toPermissions(allowlist: readonly string[], denylist: readonly string[]): ClaudeSettings;
+/**
+ * Strip any peaks-* name from the denylist (G6 hard constraint). Returns
+ * the cleaned denylist + the list of stripped names for the audit log.
+ */
+export declare function stripPeaksFromDenylist(denylist: readonly string[]): {
+    readonly cleaned: readonly string[];
+    readonly stripped: readonly string[];
+};
+/**
+ * Runtime probe for whether Claude Code supports `Skill(name)` syntax in
+ * `permissions.deny` (R1). For slice 025.1 we return `unknown` and let
+ * the caller decide. Replace this with a real check when Claude Code's
+ * `permissions.deny` schema is documented.
+ */
+export declare function probeSkillDenySupport(): Promise<'support-allow-and-deny' | 'support-allow-only' | 'unknown'>;
+export declare class ClaudeCodeSkillScope implements SkillScopeAdapter {
+    readonly ide: "claude-code";
+    readonly supported = true;
+    constructor(_opts?: {
+        readonly projectRoot?: string;
+    });
+    /** detect(): returns 1.0 when the project root has a .claude/ dir. */
+    detect(projectRoot: string): Promise<number>;
+    applyScope(input: ApplyScopeInput): Promise<ApplyResult>;
+    showScope(projectRoot: string): Promise<ShowScopeResult>;
+    resetScope(input: ResetScopeInput): Promise<ResetScopeResult>;
+}
+export declare const CLAUDE_CODE_SKILL_SCOPE: SkillScopeAdapter;
+export {};