peaks-cli 1.3.1 → 1.3.3

package/dist/src/services/skill/resume-detector.js

@@ -0,0 +1,334 @@
+/**
+ * Peaks-Cli Solo Step 0.7 — Resume-mode detector.
+ *
+ * Mirrors the classification table in
+ * `skills/peaks-solo/SKILL.md` "Peaks-Cli Step 0.7: Detect unfinished work
+ * and offer resume". The function is a pure read of session artifacts;
+ * it performs no side effects and is safe to call from hooks, scripts,
+ * and skills.
+ *
+ * Two classification sources are merged:
+ *   1. State-based (PRD / RD / QA request artifact `state:` field) →
+ *      determines the *deepest completed gate*.
+ *   2. File-presence ("Other resume triggers" table) → if a required
+ *      artifact is missing for a gate that state says is complete, the
+ *      classifier emits a `resume:<earlier-point>` verdict AND a
+ *      `warnings[]` entry flagging the inconsistency.
+ *
+ * Primary vs. abandoned filter: when multiple RD/QA request artifacts
+ * exist for the same session (the 8-slice governance pass leaves
+ * `deferred`/`abandoned` artifacts alongside the active one), the
+ * classifier filters out files whose `state: blocked` field is paired
+ * with a `user-requested-abandon` transition note. The remaining
+ * artifacts are sorted by filename (alphabetical) and the first is the
+ * primary.
+ *
+ * Legacy path fallback: prefers the canonical
+ * `.peaks/_runtime/<sid>/` layout introduced in slice
+ * `2026-06-05-peaks-runtime-layer`; falls back to the pre-migration
+ * `.peaks/<sid>/` for one minor release so older trees do not show as
+ * false "fresh". The `usedLegacyPath` field reports which path was
+ * read.
+ */
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+const MID_IMPL_RD_STATES = new Set([
+    'spec-locked',
+    'implemented',
+    'running',
+    'blocked'
+]);
+/**
+ * Classify a session's resume state. Pure function — does not write
+ * files, does not call any peaks CLI.
+ *
+ * @param sid        The session id (e.g. `2026-06-06-session-22f08c`).
+ * @param peaksRoot  The canonical peaks runtime root, i.e. the
+ *                   directory containing `<sid>/` subdirs. For the
+ *                   v1.3.2 layout this is `<repo>/.peaks/_runtime`.
+ *                   The legacy `<repo>/.peaks` layout is also accepted
+ *                   for one minor release (see `usedLegacyPath`).
+ */
+export function classifyResume(sid, peaksRoot) {
+    const resolved = resolveSessionDir(sid, peaksRoot);
+    if (resolved === null) {
+        return {
+            kind: 'fresh',
+            point: null,
+            state: null,
+            missingArtifacts: [],
+            warnings: [],
+            abandonedRequestCount: 0,
+            usedLegacyPath: false
+        };
+    }
+    const { sessionDir, usedLegacyPath } = resolved;
+    const prdStates = readRequestStates(sessionDir, 'prd');
+    const rdStatesRaw = readRequestStates(sessionDir, 'rd');
+    const qaStatesRaw = readRequestStates(sessionDir, 'qa');
+    // Filter abandoned (state=blocked + user-requested-abandon note).
+    const abandonedRd = rdStatesRaw.filter((s) => s.abandoned);
+    const abandonedQa = qaStatesRaw.filter((s) => s.abandoned);
+    const abandonedCount = abandonedRd.length + abandonedQa.length;
+    // Primary selection filter: when there are MULTIPLE RD/QA requests,
+    // the abandoned ones are excluded from the candidate set so the
+    // classifier surfaces the active slice, not the audit-only trail.
+    // When there is only ONE request, the abandoned flag is informational
+    // only — a single blocked RD with an abandoned note is still the
+    // primary, because the user might want to unblock and continue.
+    const rdStates = rdStatesRaw.length > 1 ? rdStatesRaw.filter((s) => !s.abandoned) : rdStatesRaw;
+    const qaStates = qaStatesRaw.length > 1 ? qaStatesRaw.filter((s) => !s.abandoned) : qaStatesRaw;
+    const primaryPrd = pickPrimary(prdStates);
+    const primaryRd = pickPrimary(rdStates);
+    const primaryQa = pickPrimary(qaStates);
+    // Phase 1: TXT handoff present → workflow complete. Always wins.
+    if (existsSync(join(sessionDir, 'txt', 'handoff.md'))) {
+        return {
+            kind: 'complete',
+            point: null,
+            state: null,
+            missingArtifacts: [],
+            warnings: [],
+            abandonedRequestCount: abandonedCount,
+            usedLegacyPath
+        };
+    }
+    // Phase 2: every RD/QA request is abandoned (filtered out) AND
+    // there were multiple to begin with. The slice is effectively
+    // dead — return fresh so the user can start over without
+    // re-attaching to the abandoned work.
+    if (primaryRd === null &&
+        primaryQa === null &&
+        abandonedCount > 0 &&
+        (rdStatesRaw.length > 1 || qaStatesRaw.length > 1)) {
+        return {
+            kind: 'fresh',
+            point: null,
+            state: null,
+            missingArtifacts: [],
+            warnings: [],
+            abandonedRequestCount: abandonedCount,
+            usedLegacyPath
+        };
+    }
+    // Phase 3: mid-implementation RD states (spec-locked / implemented /
+    // running / blocked). Wins over the PRD-handed-off branch because
+    // the slice IS in flight — the LLM should not be told to "re-run
+    // the swarm" when an RD artifact is already mid-edit.
+    if (primaryRd !== null && MID_IMPL_RD_STATES.has(primaryRd.state)) {
+        return {
+            kind: 'in-flight',
+            point: null,
+            state: primaryRd.state,
+            missingArtifacts: [],
+            warnings: [],
+            abandonedRequestCount: abandonedCount,
+            usedLegacyPath
+        };
+    }
+    // Phase 4: terminal gates (QA verdict-issued / RD qa-handoff / PRD
+    // handed-off, with file-presence overrides).
+    const terminal = classifyTerminalGates(sessionDir, {
+        primaryPrd,
+        primaryRd,
+        primaryQa,
+        usedLegacyPath,
+        abandonedCount
+    });
+    if (terminal !== null)
+        return terminal;
+    // Phase 5: PRD exists with a non-handed-off state — treat as
+    // in-flight:spec-locked placeholder. The user can confirm whether
+    // they want to advance the PRD or start fresh.
+    if (primaryPrd !== null && primaryPrd.state.length > 0) {
+        return {
+            kind: 'in-flight',
+            point: null,
+            state: 'spec-locked',
+            missingArtifacts: [],
+            warnings: [],
+            abandonedRequestCount: abandonedCount,
+            usedLegacyPath
+        };
+    }
+    return {
+        kind: 'fresh',
+        point: null,
+        state: null,
+        missingArtifacts: [],
+        warnings: [],
+        abandonedRequestCount: abandonedCount,
+        usedLegacyPath
+    };
+}
+function classifyTerminalGates(sessionDir, ctx) {
+    // QA verdict-issued → deepest gate is D. If the test-report is
+    // missing the state is inconsistent; fall back to qa-execution.
+    if (ctx.primaryQa !== null && ctx.primaryQa.state === 'verdict-issued') {
+        const reportPath = join(sessionDir, 'qa', 'test-reports', ctx.primaryQa.filename);
+        if (!existsSync(reportPath)) {
+            return {
+                kind: 'resume',
+                point: 'qa-execution',
+                state: null,
+                missingArtifacts: [`qa/test-reports/${ctx.primaryQa.filename}`],
+                warnings: [
+                    'inconsistent: qa verdict-issued but no qa/test-reports/<rid>.md; CLI gate should have blocked the transition'
+                ],
+                abandonedRequestCount: ctx.abandonedCount,
+                usedLegacyPath: ctx.usedLegacyPath
+            };
+        }
+        return {
+            kind: 'resume',
+            point: 'txt-handoff',
+            state: null,
+            missingArtifacts: ['txt/handoff.md'],
+            warnings: [],
+            abandonedRequestCount: ctx.abandonedCount,
+            usedLegacyPath: ctx.usedLegacyPath
+        };
+    }
+    // RD qa-handoff → deepest gate is C. If the review artifacts are
+    // missing the state is inconsistent; fall back to rd-review-fanout.
+    if (ctx.primaryRd !== null && ctx.primaryRd.state === 'qa-handoff') {
+        const codeReviewPath = join(sessionDir, 'rd', 'code-review.md');
+        const securityReviewPath = join(sessionDir, 'rd', 'security-review.md');
+        const missing = [];
+        if (!existsSync(codeReviewPath))
+            missing.push('rd/code-review.md');
+        if (!existsSync(securityReviewPath))
+            missing.push('rd/security-review.md');
+        if (missing.length > 0) {
+            return {
+                kind: 'resume',
+                point: 'rd-review-fanout',
+                state: null,
+                missingArtifacts: missing,
+                warnings: [
+                    'inconsistent: rd qa-handoff but review artifacts missing; CLI gate should have blocked the transition'
+                ],
+                abandonedRequestCount: ctx.abandonedCount,
+                usedLegacyPath: ctx.usedLegacyPath
+            };
+        }
+        return {
+            kind: 'resume',
+            point: 'qa-validation',
+            state: null,
+            missingArtifacts: ctx.primaryQa === null
+                ? [`qa/test-cases/${ctx.primaryRd.filename}`]
+                : [],
+            warnings: [],
+            abandonedRequestCount: ctx.abandonedCount,
+            usedLegacyPath: ctx.usedLegacyPath
+        };
+    }
+    // PRD handed-off → deepest gate is B. Walk "Other resume triggers"
+    // in priority order: tech-doc > qa/test-cases > in-flight (swarm
+    // converged, RD impl not yet started).
+    if (ctx.primaryPrd !== null && ctx.primaryPrd.state === 'handed-off') {
+        const missing = [];
+        if (!existsSync(join(sessionDir, 'rd', 'tech-doc.md'))) {
+            missing.push('rd/tech-doc.md');
+        }
+        // QA test-cases path: use the RD rid if present, else fall back
+        // to the PRD rid. The rid is shared across roles.
+        const qaCasesRid = ctx.primaryRd !== null
+            ? ctx.primaryRd.filename
+            : ctx.primaryPrd !== null
+                ? ctx.primaryPrd.filename
+                : null;
+        if (qaCasesRid !== null) {
+            const qaCasesPath = join(sessionDir, 'qa', 'test-cases', qaCasesRid);
+            if (!existsSync(qaCasesPath)) {
+                missing.push(`qa/test-cases/${qaCasesRid}`);
+            }
+        }
+        if (missing.includes('rd/tech-doc.md')) {
+            return {
+                kind: 'resume',
+                point: 'rd-planning',
+                state: null,
+                missingArtifacts: missing,
+                warnings: [],
+                abandonedRequestCount: ctx.abandonedCount,
+                usedLegacyPath: ctx.usedLegacyPath
+            };
+        }
+        if (missing.some((m) => m.startsWith('qa/test-cases/'))) {
+            return {
+                kind: 'resume',
+                point: 'qa-test-cases',
+                state: null,
+                missingArtifacts: missing,
+                warnings: [],
+                abandonedRequestCount: ctx.abandonedCount,
+                usedLegacyPath: ctx.usedLegacyPath
+            };
+        }
+        // All post-PRD artifacts present. Either the RD is mid-impl
+        // (handled upstream in Phase 3) or the swarm converged but the
+        // implementation has not yet started. Report the latter as
+        // in-flight:spec-locked so the user can confirm.
+        return {
+            kind: 'in-flight',
+            point: null,
+            state: 'spec-locked',
+            missingArtifacts: [],
+            warnings: [],
+            abandonedRequestCount: ctx.abandonedCount,
+            usedLegacyPath: ctx.usedLegacyPath
+        };
+    }
+    return null;
+}
+/**
+ * Resolve the session directory. Prefers the canonical
+ * `.peaks/_runtime/<sid>/`; falls back to the legacy
+ * `.peaks/<sid>/` (one level up from the runtime root) for one
+ * minor release. Returns `null` when neither path exists.
+ */
+function resolveSessionDir(sid, peaksRoot) {
+    const canonical = join(peaksRoot, sid);
+    if (existsSync(canonical)) {
+        return { sessionDir: canonical, usedLegacyPath: false };
+    }
+    const legacy = join(peaksRoot, '..', sid);
+    if (existsSync(legacy)) {
+        return { sessionDir: legacy, usedLegacyPath: true };
+    }
+    return null;
+}
+function readRequestStates(sessionDir, role) {
+    const dir = join(sessionDir, role, 'requests');
+    if (!existsSync(dir))
+        return [];
+    return readdirSync(dir)
+        .filter((f) => typeof f === 'string' && f.endsWith('.md'))
+        .sort()
+        .map((filename) => {
+        const full = join(dir, filename);
+        const content = readFileSync(full, 'utf8');
+        return {
+            filename,
+            state: extractState(content),
+            abandoned: hasAbandonedTransitionNote(content)
+        };
+    });
+}
+function extractState(content) {
+    const match = /^-\s*state:\s*(\S+)|^state:\s*(\S+)/m.exec(content);
+    if (match === null)
+        return '';
+    const captured = match[1] ?? match[2] ?? '';
+    return captured.trim();
+}
+function hasAbandonedTransitionNote(content) {
+    return /user-requested-abandon/.test(content);
+}
+function pickPrimary(states) {
+    if (states.length === 0)
+        return null;
+    return states[0] ?? null;
+}

package/dist/src/services/skill/skill-scheduler.d.ts

@@ -0,0 +1,40 @@
+/**
+ * G6 — skill-level heartbeat scheduler config.
+ *
+ * Slice 2026-06-07-sub-agent-dispatch-decouple (G6): the SKILL.md front
+ * matter for a Dispatcher (peaks-solo / peaks-rd / peaks-qa) can opt
+ * into a non-default heartbeat interval by including a line like:
+ *
+ *   heartbeatIntervalSec: 15
+ *
+ * The default is 30 s (RL-13 empirical sweet spot). The poller
+ * cadence is fixed at 10 s (sub-agent 30 s / poller 10 s is the
+ * jitter-resistant offset).
+ *
+ * This module is a pure-key parser — it takes a SKILL.md body and
+ * returns the effective config. The Dispatcher's prompt template
+ * for sub-agents is then responsible for inlining the chosen value
+ * into the sub-agent prompt so that the LLM knows how often to
+ * call `peaks sub-agent heartbeat`.
+ *
+ * Note: the heartbeat *cadence* the LLM uses is enforced socially
+ * (via the prompt), not via any hook. R-1 / R-8 boundary — LLM
+ * behaviour is not observable. The user has been explicit about
+ * this: "心跳是 sub-agent 主动写, peaks CLI 不观测 LLM 行为".
+ */
+export declare const DEFAULT_HEARTBEAT_INTERVAL_SEC = 30;
+export declare const MIN_HEARTBEAT_INTERVAL_SEC = 5;
+export declare const MAX_HEARTBEAT_INTERVAL_SEC = 600;
+export type SkillHeartbeatConfig = {
+    readonly intervalSec: number;
+    /** Source of the chosen value (useful for debugging). */
+    readonly source: 'default' | 'skill-frontmatter';
+};
+/** Parse a SKILL.md body for a `heartbeatIntervalSec: <N>` line. */
+export declare function parseHeartbeatConfig(skillBody: string): SkillHeartbeatConfig;
+/**
+ * Build the heartbeat-instruction paragraph to inline in a sub-agent
+ * prompt. The LLM reads this and adjusts its `peaks sub-agent
+ * heartbeat` cadence accordingly.
+ */
+export declare function heartbeatInstructionParagraph(config: SkillHeartbeatConfig): string;

package/dist/src/services/skill/skill-scheduler.js

@@ -0,0 +1,53 @@
+/**
+ * G6 — skill-level heartbeat scheduler config.
+ *
+ * Slice 2026-06-07-sub-agent-dispatch-decouple (G6): the SKILL.md front
+ * matter for a Dispatcher (peaks-solo / peaks-rd / peaks-qa) can opt
+ * into a non-default heartbeat interval by including a line like:
+ *
+ *   heartbeatIntervalSec: 15
+ *
+ * The default is 30 s (RL-13 empirical sweet spot). The poller
+ * cadence is fixed at 10 s (sub-agent 30 s / poller 10 s is the
+ * jitter-resistant offset).
+ *
+ * This module is a pure-key parser — it takes a SKILL.md body and
+ * returns the effective config. The Dispatcher's prompt template
+ * for sub-agents is then responsible for inlining the chosen value
+ * into the sub-agent prompt so that the LLM knows how often to
+ * call `peaks sub-agent heartbeat`.
+ *
+ * Note: the heartbeat *cadence* the LLM uses is enforced socially
+ * (via the prompt), not via any hook. R-1 / R-8 boundary — LLM
+ * behaviour is not observable. The user has been explicit about
+ * this: "心跳是 sub-agent 主动写, peaks CLI 不观测 LLM 行为".
+ */
+export const DEFAULT_HEARTBEAT_INTERVAL_SEC = 30;
+export const MIN_HEARTBEAT_INTERVAL_SEC = 5;
+export const MAX_HEARTBEAT_INTERVAL_SEC = 600;
+/** Parse a SKILL.md body for a `heartbeatIntervalSec: <N>` line. */
+export function parseHeartbeatConfig(skillBody) {
+    const match = skillBody.match(/^\s*heartbeatIntervalSec\s*:\s*(\d+)\s*$/m);
+    if (!match) {
+        return { intervalSec: DEFAULT_HEARTBEAT_INTERVAL_SEC, source: 'default' };
+    }
+    const value = Number.parseInt(match[1], 10);
+    if (!Number.isInteger(value) || value < MIN_HEARTBEAT_INTERVAL_SEC || value > MAX_HEARTBEAT_INTERVAL_SEC) {
+        return { intervalSec: DEFAULT_HEARTBEAT_INTERVAL_SEC, source: 'default' };
+    }
+    return { intervalSec: value, source: 'skill-frontmatter' };
+}
+/**
+ * Build the heartbeat-instruction paragraph to inline in a sub-agent
+ * prompt. The LLM reads this and adjusts its `peaks sub-agent
+ * heartbeat` cadence accordingly.
+ */
+export function heartbeatInstructionParagraph(config) {
+    return (`While running, call ` +
+        `\`peaks sub-agent heartbeat --record <dispatchRecordPath> --status <state> --progress <pct> --note "<text>"\` ` +
+        `at least every ${config.intervalSec} seconds (the Dispatcher expects ` +
+        `${config.intervalSec}s cadence; default 30s, your SKILL.md overrides to ${config.intervalSec}s). ` +
+        `On completion, call \`--status done --progress 100 --note "completed"\`. ` +
+        `On failure, \`--status failed\`. Do not skip heartbeats; the parent ` +
+        `Dispatcher uses them to keep the user informed during the wait.`);
+}

package/dist/src/services/skills/hooks-settings-service.d.ts

@@ -1,43 +1,59 @@
+import type { IdeId } from '../ide/ide-types.js';
+import type { HookScope } from '../ide/shared/safe-path.js';
 /**
- * Installs (and removes) the Peaks gate-enforcement PreToolUse hook in a Claude
- * Code settings.json. The hook runs `peaks gate enforce` before every Bash call;
- * when a SOP guard's gates fail it returns `permissionDecision: "deny"`, which
- * blocks the tool call BEFORE Claude Code's permission checks — making the gate
- * un-bypassable by the agent (it holds even under --dangerously-skip-permissions).
+ * Install (and remove) the Peaks-managed hooks in an IDE's settings.json.
+ *
+ * The hook runs `peaks gate enforce` (Claude) or `peaks hook handle` (Trae /
+ * other future adapters) before every relevant tool call; when a SOP guard's
+ * gates fail it returns the adapter-specific deny shape, which blocks the
+ * tool call BEFORE the IDE's permission checks — making the gate
+ * un-bypassable by the agent.
+ *
+ * Slice #1 refactor: this service delegates to the `IdeAdapter` for
+ * `claude-code`. Slice #2 added Trae. Adapter provides `dirName` /
+ * `settingsFileName` / `envVar` / `hookEvent` / `toolMatcher`. The Claude
+ * install path is byte-level-compat with slice #0 (AC-1).
+ *
+ * Slice #3 refactor (this commit): the service is now per-IDE aware via an
+ * optional `options.ide` parameter. The CLI command is responsible for
+ * resolving the IDE (env → stdin shape → cwd → fallback to 'claude-code')
+ * via `detectIdeFromContext` and passing the result here. When `ide` is
+ * omitted, the service defaults to `'claude-code'` so existing tests and
+ * downstream callers continue to work without modification.
  *
  * Installation is an EXPLICIT user command (never postinstall): skills describe,
- * the CLI performs side effects. Writes preserve all other settings keys and any
- * other hooks, reject symlinked targets, and use an atomic rename so a partial
- * write can never corrupt the settings file. Our entry is merged into (not
- * replacing) the existing `hooks.PreToolUse` array and is identified by a
+ * the CLI performs side effects. Writes preserve all other settings keys and
+ * any other hooks, reject symlinked targets, and use an atomic rename so a
+ * partial write can never corrupt the settings file. Our entry is merged into
+ * (not replacing) the existing `hooks.<event>` array and is identified by a
  * sentinel substring in its command, so install is idempotent and uninstall
  * removes only our own entry.
  */
-export type HookScope = 'project' | 'global';
-/** The hook command written into settings for the gate-enforce PreToolUse hook. `${CLAUDE_PROJECT_DIR}` is injected by Claude Code. */
-export declare const HOOK_ENFORCE_COMMAND = "peaks gate enforce --project \"${CLAUDE_PROJECT_DIR}\"";
-/**
- * Hook command for the sub-agent progress auto-spawn. Fires on every Task
- * tool call (the harness-enforced mechanism for "sub-agent dispatch"). The
- * command itself is non-blocking: `peaks progress start` is idempotent
- * (5-minute TTL on the spawn record) so the LLM does not see a fresh
- * terminal per Task. The `--quiet` flag keeps the LLM context clean — the
- * hook output otherwise adds ~500 tokens per Task call.
- */
-export declare const HOOK_PROGRESS_COMMAND = "peaks progress start --project \"${CLAUDE_PROJECT_DIR}\" --reason \"auto-spawn for sub-agent Task\" --quiet";
-/** Substring that identifies a Peaks-managed PreToolUse gate-enforce hook entry. */
+export type { HookScope } from '../ide/shared/safe-path.js';
+export type HookInstallOptions = {
+    /**
+     * Which IDE's adapter to install for. Defaults to `'claude-code'` for
+     * backward compatibility. The CLI command should resolve this from
+     * `detectIdeFromContext({ env, cwd, parsedStdin })` and pass the result.
+     * Throws if the IDE is not registered in the adapter registry.
+     */
+    readonly ide?: IdeId;
+};
+/** Sentinel substring identifying a Claude-Code gate-enforce hook entry. */
 export declare const HOOK_ENFORCE_SENTINEL = "peaks gate enforce";
-/** Substring that identifies a Peaks-managed PreToolUse sub-agent-progress hook entry. */
+/** Sentinel substring identifying a peaks-managed sub-agent-progress hook entry. */
 export declare const HOOK_PROGRESS_SENTINEL = "peaks progress start";
+/** Default (claude-code) hook command — kept as a stable export for tests. */
+export declare const HOOK_ENFORCE_COMMAND = "peaks gate enforce --project \"${CLAUDE_PROJECT_DIR}\"";
+/** Default (claude-code) progress command — kept as a stable export for tests. */
+export declare const HOOK_PROGRESS_COMMAND = "peaks progress start --project \"${CLAUDE_PROJECT_DIR}\" --reason \"auto-spawn for sub-agent Task\" --quiet";
 export type HookInstallPlan = {
     scope: HookScope;
     settingsPath: string;
     exists: boolean;
     alreadyInstalled: boolean;
     desiredCommand: string;
-    /** Substring sentinel used to detect the entry. */
     sentinel: string;
-    /** Tool name (Bash | Task) the PreToolUse hook is keyed on. */
     matcher: string;
 };
 export type HookInstallResult = HookInstallPlan & {
@@ -59,9 +75,11 @@ export type PeaksHookEntry = {
     sentinel: string;
     matcher: string;
     command: string;
+    event: string;
 };
+/** Default (claude-code) peaks-managed hook entries — kept as a stable export for tests. */
 export declare const PEAKS_HOOK_ENTRIES: ReadonlyArray<PeaksHookEntry>;
-export declare function planHookInstall(scope: HookScope, projectRoot?: string): HookInstallPlan;
-export declare function applyHookInstall(scope: HookScope, projectRoot?: string): HookInstallResult;
-export declare function removeHookInstall(scope: HookScope, projectRoot?: string): HookRemoveResult;
-export declare function readHookStatus(scope: HookScope, projectRoot?: string): HookStatus;
+export declare function planHookInstall(scope: HookScope, projectRoot?: string, options?: HookInstallOptions): HookInstallPlan;
+export declare function applyHookInstall(scope: HookScope, projectRoot?: string, options?: HookInstallOptions): HookInstallResult;
+export declare function removeHookInstall(scope: HookScope, projectRoot?: string, options?: HookInstallOptions): HookRemoveResult;
+export declare function readHookStatus(scope: HookScope, projectRoot?: string, options?: HookInstallOptions): HookStatus;