jeopi-cli 16.2.14 → 16.2.15

package/dist/types/autolearn/managed-skills.d.ts

@@ -0,0 +1,45 @@
+/** Provider id stamped on discovered managed skills (distinguishes them from authored). */
+export declare const MANAGED_SKILLS_PROVIDER_ID = "jeopi-managed";
+/** Hard cap on a managed SKILL.md body to keep generated skills bounded. */
+export declare const MAX_MANAGED_SKILL_BYTES = 64000;
+/** Resolve the isolated managed-skills directory (`~/.jeopi/agent/managed-skills`). */
+export declare function getManagedSkillsDir(agentDir?: string): string;
+/**
+ * Validate + normalize a managed-skill name. Throws on anything outside the
+ * strict allowlist so a bad name can never escape `getManagedSkillsDir()`
+ * (blocks `..`, slashes, empty, and uppercase).
+ */
+export declare function sanitizeSkillName(raw: string): string;
+/**
+ * Whether `name` is a safe managed-skill name (the exact post-sanitize shape).
+ * Used to validate names read from disk at discovery time — a managed
+ * `SKILL.md` whose `frontmatter.name` was not produced by `sanitizeSkillName`
+ * (e.g. hand-placed) must not render unescaped into the system prompt.
+ */
+export declare function isValidManagedSkillName(name: string): boolean;
+/**
+ * Neutralize a machine-generated managed-skill description so it cannot break
+ * out of the system prompt's `<skills>` listing. Managed descriptions are
+ * generated from prior task content and persist across sessions, so this is a
+ * trust boundary: strip control/format chars, angle brackets (`<system-directive>`
+ * / `</skills>`), and Markdown fence delimiters (backticks, `~~~`), then collapse
+ * to a single line. Applied on BOTH write and read so existing files are safe too.
+ */
+export declare function sanitizeManagedDescription(raw: string): string;
+/**
+ * Serialize the minimal `name`/`description` frontmatter block via the repo's
+ * YAML helper (round-trips through `parseFrontmatter`).
+ */
+export declare function toSkillFrontmatter(name: string, description: string): string;
+export interface WriteManagedSkillInput {
+    action: "create" | "update";
+    name: string;
+    description: string;
+    body: string;
+}
+/** Create or update a managed `SKILL.md`. Returns the resolved file path. */
+export declare function writeManagedSkill(input: WriteManagedSkillInput): Promise<{
+    path: string;
+}>;
+/** Delete a managed skill directory. Throws when it does not exist. */
+export declare function deleteManagedSkill(name: string): Promise<void>;

package/dist/types/autoresearch/dashboard.d.ts

@@ -0,0 +1,4 @@
+import type { Theme } from "../modes/theme/theme";
+import type { AutoresearchRuntime, DashboardController } from "./types";
+export declare function createDashboardController(): DashboardController;
+export declare function renderDashboardLines(runtime: AutoresearchRuntime, width: number, theme: Theme, maxRows: number): string[];

package/dist/types/autoresearch/git.d.ts

@@ -0,0 +1,36 @@
+import type { ExtensionAPI } from "../extensibility/extensions";
+export interface EnsureAutoresearchBranchFailure {
+    error: string;
+    ok: false;
+}
+export interface EnsureAutoresearchBranchSuccess {
+    branchName: string | null;
+    created: boolean;
+    ok: true;
+    warning?: string;
+}
+export type EnsureAutoresearchBranchResult = EnsureAutoresearchBranchFailure | EnsureAutoresearchBranchSuccess;
+export declare function getCurrentAutoresearchBranch(_api: ExtensionAPI, workDir: string): Promise<string | null>;
+/**
+ * Ensure the working tree is on an `autoresearch/*` branch when possible.
+ *
+ * If the worktree is dirty and we're not already on an autoresearch branch, this returns
+ * `{ ok: true, branchName: null, warning }` rather than failing. The caller surfaces the
+ * warning and continues on the current branch — `keep` will skip auto-commits and `discard`
+ * will revert only run-modified paths instead of resetting to baseline.
+ */
+export declare function ensureAutoresearchBranch(api: ExtensionAPI, workDir: string, goal: string | null): Promise<EnsureAutoresearchBranchResult>;
+export declare function parseWorkDirDirtyPaths(statusOutput: string, workDirPrefix: string): string[];
+export declare function relativizeGitPathToWorkDir(repoRelativePath: string, workDirPrefix: string): string | null;
+export declare function parseDirtyPaths(statusOutput: string): string[];
+export declare function normalizeStatusPath(rawPath: string): string;
+export interface DirtyPathEntry {
+    path: string;
+    untracked: boolean;
+}
+export declare function parseDirtyPathsWithStatus(statusOutput: string): DirtyPathEntry[];
+export declare function parseWorkDirDirtyPathsWithStatus(statusOutput: string, workDirPrefix: string): DirtyPathEntry[];
+export declare function computeRunModifiedPaths(preRunDirtyPaths: string[], currentStatusOutput: string, workDirPrefix: string): {
+    tracked: string[];
+    untracked: string[];
+};

package/dist/types/autoresearch/helpers.d.ts

@@ -0,0 +1,24 @@
+import type { ASIData, MetricDirection, NumericMetricMap } from "./types";
+export declare const METRIC_LINE_PREFIX = "METRIC";
+export declare const ASI_LINE_PREFIX = "ASI";
+export declare const EXPERIMENT_MAX_LINES = 10;
+export declare const EXPERIMENT_MAX_BYTES: number;
+export declare function parseMetricLines(output: string): Map<string, number>;
+export declare function parseAsiLines(output: string): ASIData | null;
+export declare function mergeAsi(base: ASIData | null, override: ASIData | undefined): ASIData | undefined;
+export declare function commas(value: number): string;
+export declare function fmtNum(value: number, decimals?: number): string;
+export declare function formatNum(value: number | null, unit: string): string;
+export declare function formatElapsed(milliseconds: number): string;
+export declare function killTree(pid: number, signal?: NodeJS.Signals | number): void;
+export declare function isBetter(current: number, best: number, direction: MetricDirection): boolean;
+export declare function inferMetricUnitFromName(name: string): string;
+export declare function normalizePathSpec(value: string): string;
+export declare function pathMatchesSpec(pathValue: string, specValue: string): boolean;
+export declare function dedupeStrings(values: readonly string[]): string[];
+export declare function ensureNumericMetricMap(value: NumericMetricMap | undefined): NumericMetricMap;
+export declare function sanitizeAsi(value: {
+    [key: string]: unknown;
+} | undefined): ASIData | undefined;
+export declare function tryGitStatus(cwd: string): Promise<string>;
+export declare function tryGitPrefix(cwd: string): Promise<string>;

package/dist/types/autoresearch/index.d.ts

@@ -0,0 +1,2 @@
+import type { ExtensionFactory } from "../extensibility/extensions";
+export declare const createAutoresearchExtension: ExtensionFactory;

package/dist/types/autoresearch/state.d.ts

@@ -0,0 +1,17 @@
+import type { SessionEntry } from "../session/session-entries";
+import type { RunRow, SessionRow } from "./storage";
+import type { AutoresearchRuntime, ExperimentResult, ExperimentState, MetricDef, MetricDirection, NumericMetricMap, ReconstructedControlState, RuntimeStore } from "./types";
+export declare function createExperimentState(): ExperimentState;
+export declare function createSessionRuntime(): AutoresearchRuntime;
+export declare function cloneExperimentState(state: ExperimentState): ExperimentState;
+export declare function currentResults(results: ExperimentResult[], segment: number): ExperimentResult[];
+export declare function findBaselineResult(results: ExperimentResult[], segment: number): ExperimentResult | null;
+export declare function findBaselineMetric(results: ExperimentResult[], segment: number): number | null;
+export declare function findBestKeptMetric(results: ExperimentResult[], segment: number, direction: MetricDirection): number | null;
+export declare function findBaselineRunNumber(results: ExperimentResult[], segment: number): number | null;
+export declare function findBaselineSecondary(results: ExperimentResult[], segment: number, knownMetrics: MetricDef[]): NumericMetricMap;
+export declare function sortedMedian(values: number[]): number;
+export declare function computeConfidence(results: ExperimentResult[], segment: number, direction: MetricDirection): number | null;
+export declare function buildExperimentState(session: SessionRow, loggedRuns: RunRow[]): ExperimentState;
+export declare function reconstructControlState(entries: SessionEntry[]): ReconstructedControlState;
+export declare function createRuntimeStore(): RuntimeStore;

package/dist/types/autoresearch/storage.d.ts

@@ -0,0 +1,142 @@
+import type { ASIData, ExperimentStatus, MetricDirection, NumericMetricMap } from "./types";
+export interface SessionRow {
+    id: number;
+    name: string;
+    goal: string | null;
+    primaryMetric: string;
+    metricUnit: string;
+    direction: MetricDirection;
+    preferredCommand: string | null;
+    branch: string | null;
+    baselineCommit: string | null;
+    currentSegment: number;
+    maxIterations: number | null;
+    scopePaths: string[];
+    offLimits: string[];
+    constraints: string[];
+    secondaryMetrics: string[];
+    notes: string;
+    createdAt: number;
+    closedAt: number | null;
+}
+export interface RunRow {
+    id: number;
+    sessionId: number;
+    segment: number;
+    command: string;
+    startedAt: number;
+    completedAt: number | null;
+    durationMs: number | null;
+    exitCode: number | null;
+    timedOut: boolean;
+    parsedPrimary: number | null;
+    parsedMetrics: NumericMetricMap | null;
+    parsedAsi: ASIData | null;
+    preRunDirtyPaths: string[];
+    logPath: string;
+    status: ExperimentStatus | null;
+    description: string | null;
+    metric: number | null;
+    metrics: NumericMetricMap | null;
+    asi: ASIData | null;
+    commitHash: string | null;
+    confidence: number | null;
+    modifiedPaths: string[] | null;
+    scopeDeviations: string[] | null;
+    justification: string | null;
+    flagged: boolean;
+    flaggedReason: string | null;
+    loggedAt: number | null;
+    abandonedAt: number | null;
+}
+export interface OpenSessionParams {
+    name: string;
+    goal: string | null;
+    primaryMetric: string;
+    metricUnit: string;
+    direction: MetricDirection;
+    preferredCommand: string | null;
+    branch: string | null;
+    baselineCommit: string | null;
+    maxIterations: number | null;
+    scopePaths: string[];
+    offLimits: string[];
+    constraints: string[];
+    secondaryMetrics: string[];
+}
+export interface UpdateSessionParams {
+    goal?: string | null;
+    preferredCommand?: string | null;
+    maxIterations?: number | null;
+    scopePaths?: string[];
+    offLimits?: string[];
+    constraints?: string[];
+    secondaryMetrics?: string[];
+    primaryMetric?: string;
+    metricUnit?: string;
+    direction?: MetricDirection;
+    branch?: string | null;
+    baselineCommit?: string | null;
+    notes?: string;
+}
+export interface InsertRunParams {
+    sessionId: number;
+    segment: number;
+    command: string;
+    logPath: string;
+    preRunDirtyPaths: string[];
+    startedAt: number;
+}
+export interface MarkRunCompletedParams {
+    runId: number;
+    completedAt: number;
+    durationMs: number;
+    exitCode: number | null;
+    timedOut: boolean;
+    parsedPrimary: number | null;
+    parsedMetrics: NumericMetricMap | null;
+    parsedAsi: ASIData | null;
+}
+export interface MarkRunLoggedParams {
+    runId: number;
+    status: ExperimentStatus;
+    description: string;
+    metric: number;
+    metrics: NumericMetricMap;
+    asi: ASIData | null;
+    commitHash: string | null;
+    confidence: number | null;
+    modifiedPaths: string[];
+    scopeDeviations: string[];
+    justification: string | null;
+    loggedAt: number;
+}
+export declare class AutoresearchStorage {
+    #private;
+    constructor(dbPath: string, projectDir: string);
+    get dbPath(): string;
+    get projectDir(): string;
+    close(): void;
+    getActiveSession(): SessionRow | null;
+    getActiveSessionForBranch(branch: string | null): SessionRow | null;
+    getSessionById(sessionId: number): SessionRow | null;
+    openSession(params: OpenSessionParams): SessionRow;
+    updateSession(sessionId: number, updates: UpdateSessionParams): SessionRow;
+    bumpSegment(sessionId: number): SessionRow;
+    closeSession(sessionId: number): void;
+    insertRun(params: InsertRunParams): RunRow;
+    updateRunLogPath(runId: number, logPath: string): RunRow;
+    updateRunConfidence(runId: number, confidence: number | null): RunRow;
+    markRunCompleted(params: MarkRunCompletedParams): RunRow;
+    markRunLogged(params: MarkRunLoggedParams): RunRow;
+    flagRun(runId: number, reason: string): RunRow;
+    abandonPendingRuns(sessionId: number): number;
+    getPendingRun(sessionId: number): RunRow | null;
+    getRunById(runId: number): RunRow | null;
+    getRunByIdRequired(runId: number): RunRow;
+    listRuns(sessionId: number): RunRow[];
+    listLoggedRuns(sessionId: number): RunRow[];
+}
+export declare function openAutoresearchStorage(cwd: string): Promise<AutoresearchStorage>;
+export declare function openAutoresearchStorageIfExists(cwd: string): Promise<AutoresearchStorage | null>;
+export declare function closeAllAutoresearchStorages(): void;

package/dist/types/autoresearch/tools/init-experiment.d.ts

@@ -0,0 +1,27 @@
+import type { ToolDefinition } from "../../extensibility/extensions";
+import type { AutoresearchToolFactoryOptions, ExperimentState } from "../types";
+export declare const HARNESS_FILENAME = "autoresearch.sh";
+export declare const DEFAULT_HARNESS_COMMAND = "bash autoresearch.sh";
+declare const initExperimentSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    name: string;
+    goal?: string | undefined;
+    primary_metric: string;
+    metric_unit?: string | undefined;
+    direction?: "higher" | "lower" | undefined;
+    secondary_metrics?: string[] | undefined;
+    scope_paths?: string[] | undefined;
+    off_limits?: string[] | undefined;
+    constraints?: string[] | undefined;
+    max_iterations?: number | undefined;
+    new_segment?: boolean | undefined;
+}, {}>;
+interface InitExperimentDetails {
+    state: ExperimentState;
+    createdSession: boolean;
+    bumpedSegment: boolean;
+    abandonedRuns: number;
+    harnessCommitted: boolean;
+    baselineCommit: string | null;
+}
+export declare function createInitExperimentTool(options: AutoresearchToolFactoryOptions): ToolDefinition<typeof initExperimentSchema, InitExperimentDetails>;
+export {};

package/dist/types/autoresearch/tools/log-experiment.d.ts

@@ -0,0 +1,21 @@
+import type { ToolDefinition } from "../../extensibility/extensions";
+import type { AutoresearchToolFactoryOptions, LogDetails } from "../types";
+declare const logExperimentSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    metric: number;
+    status: "checks_failed" | "crash" | "discard" | "keep";
+    description: string;
+    metrics?: {
+        [x: string]: number;
+    } | undefined;
+    asi?: {
+        [x: string]: unknown;
+    } | undefined;
+    commit?: string | undefined;
+    justification?: string | undefined;
+    flag_runs?: {
+        run_id: number;
+        reason: string;
+    }[] | undefined;
+}, {}>;
+export declare function createLogExperimentTool(options: AutoresearchToolFactoryOptions): ToolDefinition<typeof logExperimentSchema, LogDetails>;
+export {};

package/dist/types/autoresearch/tools/run-experiment.d.ts

@@ -0,0 +1,7 @@
+import type { ToolDefinition } from "../../extensibility/extensions";
+import type { AutoresearchToolFactoryOptions, RunDetails, RunExperimentProgressDetails } from "../types";
+declare const runExperimentSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    timeout_seconds?: number | undefined;
+}, {}>;
+export declare function createRunExperimentTool(options: AutoresearchToolFactoryOptions): ToolDefinition<typeof runExperimentSchema, RunDetails | RunExperimentProgressDetails>;
+export {};

package/dist/types/autoresearch/tools/update-notes.d.ts

@@ -0,0 +1,11 @@
+import type { ToolDefinition } from "../../extensibility/extensions";
+import type { AutoresearchToolFactoryOptions } from "../types";
+declare const updateNotesSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    body: string;
+    append_idea?: string | undefined;
+}, {}>;
+interface UpdateNotesDetails {
+    notes: string;
+}
+export declare function createUpdateNotesTool(options: AutoresearchToolFactoryOptions): ToolDefinition<typeof updateNotesSchema, UpdateNotesDetails>;
+export {};

package/dist/types/autoresearch/types.d.ts

@@ -0,0 +1,154 @@
+import type { AgentToolResult } from "jeopi-agent-core";
+import type { ExtensionAPI, ExtensionContext } from "../extensibility/extensions";
+import type { SessionEntry } from "../session/session-entries";
+import type { TruncationResult } from "../session/streaming-output";
+export type MetricDirection = "lower" | "higher";
+export type ExperimentStatus = "keep" | "discard" | "crash" | "checks_failed";
+export type ASIValue = string | number | boolean | null | ASIValue[] | {
+    [key: string]: ASIValue;
+};
+export interface ASIData {
+    [key: string]: ASIValue;
+}
+export interface NumericMetricMap {
+    [key: string]: number;
+}
+export interface MetricDef {
+    name: string;
+    unit: string;
+}
+export interface ExperimentResult {
+    runNumber: number | null;
+    commit: string;
+    metric: number;
+    metrics: NumericMetricMap;
+    status: ExperimentStatus;
+    description: string;
+    timestamp: number;
+    segment: number;
+    confidence: number | null;
+    asi?: ASIData;
+    modifiedPaths: string[];
+    scopeDeviations: string[];
+    justification: string | null;
+    flagged: boolean;
+    flaggedReason: string | null;
+}
+export interface ExperimentState {
+    results: ExperimentResult[];
+    bestMetric: number | null;
+    bestDirection: MetricDirection;
+    metricName: string;
+    metricUnit: string;
+    secondaryMetrics: MetricDef[];
+    name: string | null;
+    goal: string | null;
+    currentSegment: number;
+    maxExperiments: number | null;
+    confidence: number | null;
+    scopePaths: string[];
+    offLimits: string[];
+    constraints: string[];
+    notes: string;
+    branch: string | null;
+    baselineCommit: string | null;
+    sessionId: number | null;
+}
+export interface RunExperimentProgressDetails {
+    phase: "running";
+    elapsed: string;
+    truncation?: TruncationResult;
+    fullOutputPath?: string;
+    runDirectory?: string;
+}
+export interface RunDetails {
+    runNumber: number;
+    runDirectory: string;
+    benchmarkLogPath: string;
+    command: string;
+    exitCode: number | null;
+    durationSeconds: number;
+    passed: boolean;
+    crashed: boolean;
+    timedOut: boolean;
+    tailOutput: string;
+    parsedMetrics: NumericMetricMap | null;
+    parsedPrimary: number | null;
+    parsedAsi: ASIData | null;
+    metricName: string;
+    metricUnit: string;
+    preRunDirtyPaths: string[];
+    abandonedPriorRun: number | null;
+    truncation?: TruncationResult;
+    fullOutputPath?: string;
+}
+export interface LogDetails {
+    experiment: ExperimentResult;
+    state: ExperimentState;
+    wallClockSeconds: number | null;
+    scopeDeviations: string[];
+    justification: string | null;
+    flaggedRuns: Array<{
+        runId: number;
+        reason: string;
+    }>;
+}
+export interface PendingRunSummary {
+    command: string;
+    durationSeconds: number | null;
+    parsedAsi: ASIData | null;
+    parsedMetrics: NumericMetricMap | null;
+    parsedPrimary: number | null;
+    passed: boolean;
+    preRunDirtyPaths: string[];
+    runDirectory: string;
+    runNumber: number;
+    exitCode: number | null;
+    timedOut: boolean;
+}
+export interface RunningExperiment {
+    startedAt: number;
+    command: string;
+    runDirectory: string;
+    runNumber: number;
+}
+export interface AutoresearchRuntime {
+    autoresearchMode: boolean;
+    autoResumeArmed: boolean;
+    dashboardExpanded: boolean;
+    lastAutoResumePendingRunNumber: number | null;
+    lastRunDuration: number | null;
+    lastRunAsi: ASIData | null;
+    lastRunArtifactDir: string | null;
+    lastRunNumber: number | null;
+    lastRunSummary: PendingRunSummary | null;
+    runningExperiment: RunningExperiment | null;
+    state: ExperimentState;
+    goal: string | null;
+}
+export interface AutoresearchControlEntryData {
+    mode: "on" | "off" | "clear";
+    goal?: string;
+}
+export interface ReconstructedControlState {
+    autoresearchMode: boolean;
+    goal: string | null;
+    lastMode: AutoresearchControlEntryData["mode"] | null;
+}
+export interface RuntimeStore {
+    clear(sessionKey: string): void;
+    ensure(sessionKey: string): AutoresearchRuntime;
+}
+export interface DashboardController {
+    clear(ctx: ExtensionContext): void;
+    requestRender(): void;
+    showOverlay(ctx: ExtensionContext, runtime: AutoresearchRuntime): Promise<void>;
+    updateWidget(ctx: ExtensionContext, runtime: AutoresearchRuntime): void;
+}
+export interface AutoresearchToolFactoryOptions {
+    dashboard: DashboardController;
+    getRuntime(ctx: ExtensionContext): AutoresearchRuntime;
+    pi: ExtensionAPI;
+}
+export type AutoresearchToolResult<TDetails> = AgentToolResult<TDetails>;
+export type SessionEntries = SessionEntry[];

package/dist/types/capability/context-file.d.ts

@@ -0,0 +1,17 @@
+import type { SourceMeta } from "./types";
+/**
+ * A context file that provides persistent instructions to the agent.
+ */
+export interface ContextFile {
+    /** Absolute path to the file */
+    path: string;
+    /** File content */
+    content: string;
+    /** Which level this came from */
+    level: "user" | "project";
+    /** Distance from cwd (0 = in cwd, 1 = parent, etc.) for project files */
+    depth?: number;
+    /** Source metadata */
+    _source: SourceMeta;
+}
+export declare const contextFileCapability: import("./types").Capability<ContextFile>;

package/dist/types/capability/extension-module.d.ts

@@ -0,0 +1,15 @@
+import type { SourceMeta } from "./types";
+/**
+ * A loaded extension module.
+ */
+export interface ExtensionModule {
+    /** Extension module name (derived from path) */
+    name: string;
+    /** Absolute path to extension entrypoint */
+    path: string;
+    /** Source level */
+    level: "user" | "project";
+    /** Source metadata */
+    _source: SourceMeta;
+}
+export declare const extensionModuleCapability: import("./types").Capability<ExtensionModule>;

package/dist/types/capability/extension.d.ts

@@ -0,0 +1,28 @@
+import type { MCPServer } from "./mcp";
+import type { SourceMeta } from "./types";
+/**
+ * Extension manifest structure.
+ */
+export interface ExtensionManifest {
+    name?: string;
+    description?: string;
+    mcpServers?: Record<string, Omit<MCPServer, "name" | "_source">>;
+    tools?: unknown[];
+    context?: unknown;
+}
+/**
+ * A loaded extension.
+ */
+export interface Extension {
+    /** Extension name (from manifest.name or directory name) */
+    name: string;
+    /** Absolute path to extension directory */
+    path: string;
+    /** Parsed manifest data */
+    manifest: ExtensionManifest;
+    /** Source level */
+    level: "user" | "project";
+    /** Source metadata */
+    _source: SourceMeta;
+}
+export declare const extensionCapability: import("./types").Capability<Extension>;

package/dist/types/capability/fs.d.ts

@@ -0,0 +1,20 @@
+import * as fs from "node:fs";
+export declare function readFile(filePath: string): Promise<string | null>;
+export declare function readDirEntries(dirPath: string): Promise<fs.Dirent[]>;
+export declare function readDir(dirPath: string): Promise<string[]>;
+export declare function walkUp(startDir: string, name: string, opts?: {
+    file?: boolean;
+    dir?: boolean;
+}): Promise<string | null>;
+/**
+ * Walk up from startDir looking for a `.git` entry (file or directory).
+ * Returns the directory containing `.git` (the repo root), or null if not in a git repo.
+ * Results are based on the cached readDirEntries, so repeated calls are cheap.
+ */
+export declare function findRepoRoot(startDir: string): Promise<string | null>;
+export declare function cacheStats(): {
+    content: number;
+    dir: number;
+};
+export declare function clearCache(): void;
+export declare function invalidate(filePath: string): void;

package/dist/types/capability/hook.d.ts

@@ -0,0 +1,19 @@
+import type { SourceMeta } from "./types";
+/**
+ * A hook script.
+ */
+export interface Hook {
+    /** Hook name (filename without extension) */
+    name: string;
+    /** Absolute path to hook file */
+    path: string;
+    /** Hook type (pre/post) and associated tool */
+    type: "pre" | "post";
+    /** Tool this hook applies to, or "*" for all */
+    tool: string;
+    /** Source level */
+    level: "user" | "project";
+    /** Source metadata */
+    _source: SourceMeta;
+}
+export declare const hookCapability: import("./types").Capability<Hook>;