@sctg/cline-shared 3.84.0-beta.20260524130712

package/dist/db/index.js

@@ -0,0 +1,80 @@
+var V=Object.defineProperty;var X=(x)=>x;function Z(x,f){this[x]=X.bind(null,f)}var S=(x,f)=>{for(var j in f)V(x,j,{get:f[j],enumerable:!0,configurable:!0,set:Z.bind(f,j)})};import{mkdirSync as $}from"node:fs";import{createRequire as H}from"node:module";import{dirname as W}from"node:path";function J(x){if(x instanceof Error)return x.message;return String(x)}function K(x){if(x&&typeof x==="object"&&"code"in x&&typeof x.code==="string")return x.code;return""}var G=3,U=50;function D(){return new Date().toISOString()}function Q(x){return x?1:0}function I(x){return typeof x==="string"?x:""}function N(x){if(typeof x!=="string")return;let f=x.trim();return f.length>0?f:void 0}function A(x){return x===1||x===!0}function L(x){if(x<=0)return;try{let f=new SharedArrayBuffer(4),j=new Int32Array(f);Atomics.wait(j,0,0,x)}catch{}}function M(x){if(!x||typeof x!=="object")return!1;let f=J(x),j=K(x);return j==="SQLITE_BUSY"||j==="SQLITE_LOCKED"||f.includes("SQLITE_BUSY")||f.includes("SQLITE_LOCKED")||f.includes("database is locked")}function z(x){let f=0;for(;;)try{return x()}catch(j){if(!M(j)||f>=G)throw j;f+=1,L(U*2**(f-1))}}function P(x){return{prepare:(f)=>{let j=x.query(f);return{run:(...k)=>z(()=>j.run(...k)),get:(...k)=>z(()=>j.get(...k)),all:(...k)=>z(()=>j.all(...k))}},exec:(f)=>z(()=>x.exec(f)),close:()=>x.close?.()}}function Y(x){return{prepare:(f)=>{let j=x.prepare(f);return{run:(...k)=>z(()=>j.run(...k)),get:(...k)=>z(()=>j.get(...k)??null),all:(...k)=>z(()=>j.all(...k))}},exec:(f)=>z(()=>x.exec(f)),close:()=>x.close?.()}}function C(x){$(W(x),{recursive:!0});let f=H(import.meta.url);if(typeof globalThis.Bun<"u"){let{Database:k}=f("bun:sqlite");return P(new k(x,{create:!0}))}let j=process.emitWarning;process.emitWarning=(k,...O)=>{if((typeof k==="string"?k:k?.message??"").includes("SQLite"))return;return j.call(process,k,...O)};try{let{DatabaseSync:k}=f(["node",":sqlite"].join(""));return Y(new k(x))}finally{process.emitWarning=j}}var c=[`CREATE TABLE IF NOT EXISTS sessions (
+		session_id TEXT PRIMARY KEY,
+		source TEXT NOT NULL,
+		pid INTEGER NOT NULL,
+		started_at TEXT NOT NULL,
+		ended_at TEXT,
+		exit_code INTEGER,
+		status TEXT NOT NULL,
+		status_lock INTEGER NOT NULL DEFAULT 0,
+		interactive INTEGER NOT NULL,
+		provider TEXT NOT NULL,
+		model TEXT NOT NULL,
+		cwd TEXT NOT NULL,
+		workspace_root TEXT NOT NULL,
+		team_name TEXT,
+		enable_tools INTEGER NOT NULL,
+		enable_spawn INTEGER NOT NULL,
+		enable_teams INTEGER NOT NULL,
+		parent_session_id TEXT,
+		parent_agent_id TEXT,
+		agent_id TEXT,
+		conversation_id TEXT,
+		is_subagent INTEGER NOT NULL DEFAULT 0,
+		prompt TEXT,
+		metadata_json TEXT,
+		transcript_path TEXT NOT NULL DEFAULT '',
+		hook_path TEXT NOT NULL,
+		messages_path TEXT,
+		updated_at TEXT NOT NULL
+	);`,`CREATE TABLE IF NOT EXISTS subagent_spawn_queue (
+		id INTEGER PRIMARY KEY AUTOINCREMENT,
+		root_session_id TEXT NOT NULL,
+		parent_agent_id TEXT NOT NULL,
+		task TEXT,
+		system_prompt TEXT,
+		created_at TEXT NOT NULL,
+		consumed_at TEXT
+	);`,`CREATE TABLE IF NOT EXISTS schedules (
+		schedule_id TEXT PRIMARY KEY,
+		name TEXT NOT NULL,
+		cron_pattern TEXT NOT NULL,
+		prompt TEXT NOT NULL,
+		provider TEXT NOT NULL,
+		model TEXT NOT NULL,
+		mode TEXT NOT NULL DEFAULT 'act',
+		workspace_root TEXT,
+		cwd TEXT,
+		system_prompt TEXT,
+		max_iterations INTEGER,
+		timeout_seconds INTEGER,
+		max_parallel INTEGER NOT NULL DEFAULT 1,
+		enabled INTEGER NOT NULL DEFAULT 1,
+		created_at TEXT NOT NULL,
+		updated_at TEXT NOT NULL,
+		last_run_at TEXT,
+		next_run_at TEXT,
+		claim_token TEXT,
+		claim_started_at TEXT,
+		claim_until_at TEXT,
+		created_by TEXT,
+		tags TEXT,
+		metadata_json TEXT
+	);`,`CREATE TABLE IF NOT EXISTS schedule_executions (
+		execution_id TEXT PRIMARY KEY,
+		schedule_id TEXT NOT NULL,
+		session_id TEXT,
+		triggered_at TEXT NOT NULL,
+		started_at TEXT,
+		ended_at TEXT,
+		status TEXT NOT NULL,
+		exit_code INTEGER,
+		error_message TEXT,
+		iterations INTEGER,
+		tokens_used INTEGER,
+		cost_usd REAL,
+		FOREIGN KEY (schedule_id) REFERENCES schedules(schedule_id) ON DELETE CASCADE,
+		FOREIGN KEY (session_id) REFERENCES sessions(session_id) ON DELETE SET NULL
+	);`,`CREATE INDEX IF NOT EXISTS idx_schedule_executions_schedule
+	ON schedule_executions(schedule_id, triggered_at DESC);`,`CREATE INDEX IF NOT EXISTS idx_schedules_next_run
+	ON schedules(enabled, next_run_at);`],T=[{table:"sessions",column:"workspace_root",sql:"ALTER TABLE sessions ADD COLUMN workspace_root TEXT;"},{table:"sessions",column:"parent_session_id",sql:"ALTER TABLE sessions ADD COLUMN parent_session_id TEXT;"},{table:"sessions",column:"parent_agent_id",sql:"ALTER TABLE sessions ADD COLUMN parent_agent_id TEXT;"},{table:"sessions",column:"agent_id",sql:"ALTER TABLE sessions ADD COLUMN agent_id TEXT;"},{table:"sessions",column:"conversation_id",sql:"ALTER TABLE sessions ADD COLUMN conversation_id TEXT;"},{table:"sessions",column:"is_subagent",sql:"ALTER TABLE sessions ADD COLUMN is_subagent INTEGER NOT NULL DEFAULT 0;"},{table:"sessions",column:"messages_path",sql:"ALTER TABLE sessions ADD COLUMN messages_path TEXT;"},{table:"sessions",column:"metadata_json",sql:"ALTER TABLE sessions ADD COLUMN metadata_json TEXT;"},{table:"sessions",column:"transcript_path",sql:"ALTER TABLE sessions ADD COLUMN transcript_path TEXT NOT NULL DEFAULT '';"},{table:"schedules",column:"claim_token",sql:"ALTER TABLE schedules ADD COLUMN claim_token TEXT;"},{table:"schedules",column:"claim_started_at",sql:"ALTER TABLE schedules ADD COLUMN claim_started_at TEXT;"},{table:"schedules",column:"claim_until_at",sql:"ALTER TABLE schedules ADD COLUMN claim_until_at TEXT;"}];function _(x,f){return new Set(x.prepare(`PRAGMA table_info(${f});`).all().map((j)=>j.name))}function B(x,f={}){x.exec("PRAGMA journal_mode = WAL;"),x.exec("PRAGMA busy_timeout = 5000;");for(let O of c)x.exec(O);if(!f.includeLegacyMigrations)return;let j=new Map,k=(O)=>{let F=j.get(O);if(!F)F=_(x,O),j.set(O,F);return F};for(let O of T)if(!k(O.table).has(O.column)){if(x.exec(O.sql),O.column==="workspace_root")x.exec("UPDATE sessions SET workspace_root = cwd WHERE workspace_root IS NULL OR workspace_root = '';");j.delete(O.table)}}export{Q as toBoolInt,D as nowIso,C as loadSqliteDb,B as ensureSessionSchema,I as asString,N as asOptionalString,A as asBool};

package/dist/db/sqlite-db.d.ts

@@ -0,0 +1,24 @@
+export type SqliteStatement = {
+    run: (...params: unknown[]) => {
+        changes?: number;
+    };
+    get: (...params: unknown[]) => Record<string, unknown> | null;
+    all: (...params: unknown[]) => Record<string, unknown>[];
+};
+export type SqliteDb = {
+    prepare: (sql: string) => SqliteStatement;
+    exec: (sql: string) => void;
+    close?: () => void;
+};
+export declare function nowIso(): string;
+export declare function toBoolInt(value: boolean): number;
+export declare function asString(value: unknown): string;
+export declare function asOptionalString(value: unknown): string | undefined;
+export declare function asBool(value: unknown): boolean;
+export declare function isSqliteBusyError(error: unknown): boolean;
+export declare function withSqliteBusyRetry<T>(operation: () => T): T;
+export declare function loadSqliteDb(filePath: string): SqliteDb;
+export interface SessionSchemaOptions {
+    includeLegacyMigrations?: boolean;
+}
+export declare function ensureSessionSchema(db: SqliteDb, options?: SessionSchemaOptions): void;

package/dist/dispose.d.ts

@@ -0,0 +1,13 @@
+export type Disposable = (() => void | Promise<void>) | {
+    dispose: () => void | Promise<void>;
+};
+/**
+ * Register a disposable to be cleaned up when `disposeAll()` is called.
+ * Accepts either a function or an object with a `dispose` method.
+ */
+export declare function registerDisposable(disposable: Disposable): void;
+/**
+ * Dispose all registered disposables in registration order.
+ * Errors from individual disposables are suppressed so all run.
+ */
+export declare function disposeAll(): Promise<void>;

package/dist/extensions/context.d.ts

@@ -0,0 +1,76 @@
+import type { BasicLogger } from "../logging/logger";
+import type { ITelemetryService } from "../services/telemetry";
+import type { WorkspaceInfo } from "../session/workspace";
+import type { AgentExtensionAutomationContext, AgentExtensionSessionContext } from "./contribution-registry";
+/**
+ * The IDE or client surface the user is running Cline from.
+ */
+export type ClientName = "cline-vscode" | "cline-jetbrains" | "cline-cli" | "cline-sdk" | "cline-kanban" | "cline-acp" | "cline-platform" | (string & {});
+/**
+ * Identity of the calling client (surface + version).
+ */
+export interface ClientContext {
+    /** e.g. "cline-vscode", "cline-cli", "cline-sdk" */
+    name: ClientName;
+    /** Semver string, e.g. "3.12.0" */
+    version?: string;
+}
+/**
+ * Identity of the authenticated user.
+ */
+export interface UserContext {
+    /** PostHog / analytics distinct ID */
+    distinctId?: string;
+    email?: string;
+    organizationId?: string;
+}
+/**
+ * Everything needed to describe the workspace and build the system prompt.
+ *
+ * Extends WorkspaceInfo (rootPath + git fields) with the additional fields
+ * required by buildClineSystemPrompt, so callers can spread a WorkspaceInfo
+ * and add only what they know.
+ */
+export interface WorkspaceContext extends WorkspaceInfo {
+    /**
+     * Current working directory. May differ from rootPath in multi-root
+     * workspaces or when the user cd'd inside the workspace.
+     */
+    cwd?: string;
+    /** Human-readable workspace name shown in the system prompt */
+    workspaceName?: string;
+    /**
+     * Pre-serialized workspace metadata block that replaces {{CLINE_METADATA}}
+     * in the system prompt template.
+     */
+    metadata?: string;
+    /** Agent mode: "act" | "plan" | "yolo" */
+    mode?: string;
+    /** Additional rules/instructions injected into the system prompt */
+    rules?: string;
+    /** IDE display name, e.g. "VS Code", "JetBrains", "Terminal Shell" */
+    ide?: string;
+    /** Node process.platform string, e.g. "darwin", "win32", "linux" */
+    platform?: string;
+}
+/**
+ * Ambient runtime context carried alongside ProviderConfig.
+ *
+ * Captures who is calling (user + client), where they are (workspace),
+ * and which services to use for logging and telemetry. None of these
+ * belong in the LLM provider credential config.
+ */
+export interface ExtensionContext {
+    user?: UserContext;
+    client?: ClientContext;
+    workspace?: WorkspaceContext;
+    /** Core session metadata forwarded into plugin setup context. */
+    session?: AgentExtensionSessionContext;
+    /**
+     * Host-provided automation ingress for plugins. Present when the session is
+     * started through a ClineCore instance with automation enabled.
+     */
+    automation?: AgentExtensionAutomationContext;
+    logger?: BasicLogger;
+    telemetry?: ITelemetryService;
+}

package/dist/extensions/contribution-registry.d.ts

@@ -0,0 +1,195 @@
+import type { AgentRuntimeHooks, AgentTool } from "../agent";
+import type { AutomationEventEnvelope } from "../cron";
+import type { BasicLogger } from "../logging/logger";
+import type { ITelemetryService } from "../services/telemetry";
+import type { WorkspaceInfo } from "../session/workspace";
+import type { ClientContext, UserContext } from "./context";
+export interface AgentExtensionCommand {
+    name: string;
+    description?: string;
+    handler?: (input: string) => Promise<string> | string;
+}
+export interface AgentExtensionRule {
+    id: string;
+    content: string | (() => string | Promise<string>);
+    source?: string;
+}
+export interface AgentExtensionMessageBuilder<TMessage = unknown> {
+    name: string;
+    build: (message: TMessage) => TMessage | Promise<TMessage>;
+}
+export interface AgentExtensionProvider {
+    name: string;
+    description?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface AgentExtensionAutomationEventType {
+    /** Normalized event type a plugin can emit, e.g. `github.pull_request.opened`. */
+    eventType: string;
+    /** Normalized source identifier, e.g. `github`, `linear`, or `local`. */
+    source: string;
+    description?: string;
+    attributesSchema?: Record<string, unknown>;
+    payloadSchema?: Record<string, unknown>;
+    examples?: AutomationEventEnvelope[];
+    metadata?: Record<string, unknown>;
+}
+export interface AgentExtensionAutomationContext {
+    /**
+     * Submit a normalized automation event to the host. Raw webhook or connector
+     * payloads should be translated into an `AutomationEventEnvelope` first.
+     */
+    ingestEvent: (event: AutomationEventEnvelope) => void | Promise<void>;
+}
+export interface AgentExtensionSessionContext {
+    /** Stable core session id for the root session that loaded the plugin. */
+    sessionId?: string;
+}
+/**
+ * API surface passed to an extension's `setup()` method.
+ *
+ * Use it to register the contributions the extension wants to make — tools,
+ * commands, message builders, providers, and automation event types. All
+ * registrations accumulate into the `ContributionRegistry` and are available to
+ * the host after `setup()` completes.
+ */
+export interface AgentExtensionApi<TTool = AgentTool, TMessage = unknown> {
+    /** Register a tool the agent can invoke during its run. Requires the `tools` capability. */
+    registerTool: (tool: TTool) => void;
+    /** Register a slash command available in connected chat surfaces. Requires the `commands` capability. */
+    registerCommand: (command: AgentExtensionCommand) => void;
+    /** Register prompt rules included in the runtime system prompt. Requires the `rules` capability. */
+    registerRule: (rule: AgentExtensionRule) => void;
+    /** Register a named message builder for transforming messages before they are sent. Requires the `messageBuilders` capability. */
+    registerMessageBuilder: (builder: AgentExtensionMessageBuilder<TMessage>) => void;
+    /** Register a provider contribution (e.g. a custom model provider). Requires the `providers` capability. */
+    registerProvider: (provider: AgentExtensionProvider) => void;
+    /** Register a normalized automation event type the plugin can emit. Requires the `automationEvents` capability. */
+    registerAutomationEventType: (eventType: AgentExtensionAutomationEventType) => void;
+}
+export type AgentExtensionHooks = Partial<AgentRuntimeHooks>;
+/**
+ * Session-scoped workspace context passed as the second argument to an
+ * extension's `setup(api, ctx)` method.
+ *
+ * These values are always sourced from the host session config — never from
+ * `process.cwd()`. Use them to resolve paths or build workspace-aware tool
+ * schemas at registration time.
+ *
+ * All fields are optional so `setup()` callers that do not have host context
+ * (e.g. unit tests) can omit them without breaking plugins.
+ */
+export interface PluginSetupContext {
+    /**
+     * Core session metadata known before the first agent run starts.
+     * Agent-level ids such as `agentId` and `conversationId` are available on
+     * lifecycle hook contexts once SessionRuntime creates them.
+     */
+    session?: AgentExtensionSessionContext;
+    /** Host/client identity such as `cline-cli`, `cline-vscode`, or an SDK app. */
+    client?: ClientContext;
+    /** Authenticated user or organization identity when the host provides it. */
+    user?: UserContext;
+    /**
+     * Structured workspace and git metadata for the session. Contains
+     * `rootPath`, `hint`, `associatedRemoteUrls`, `latestGitCommitHash`, and
+     * `latestGitBranchName`. Use `rootPath` for workspace-relative paths and
+     * the git fields for branch-aware registration or commit attribution at
+     * setup time.
+     */
+    workspaceInfo?: WorkspaceInfo;
+    /**
+     * Automation ingress made available by hosts that enable ClineCore
+     * automation. Plugins should feature-detect this property so the same plugin
+     * can run in hosts that do not enable automation.
+     */
+    automation?: AgentExtensionAutomationContext;
+    /** Host-provided logger scoped to this session/plugin setup. */
+    logger?: BasicLogger;
+    /**
+     * Host-provided telemetry service when available in the current process.
+     *
+     * This service is intentionally not serialized across plugin sandbox process
+     * boundaries; sandboxed plugins should feature-detect this property and expect
+     * it to be undefined unless a future host adds an explicit telemetry bridge.
+     */
+    telemetry?: ITelemetryService;
+}
+declare const ExtensionCapabilityOptions: readonly ["hooks", "tools", "commands", "rules", "messageBuilders", "providers", "automationEvents"];
+export type AgentExtensionCapability = (typeof ExtensionCapabilityOptions)[number];
+export interface PluginManifest {
+    paths?: string[];
+    capabilities: AgentExtensionCapability[];
+    providerIds?: string[];
+    modelIds?: string[];
+}
+export interface AgentExtensionRegistry<TTool = AgentTool, TMessage = unknown> {
+    tools: TTool[];
+    commands: AgentExtensionCommand[];
+    rules: AgentExtensionRule[];
+    messageBuilder: AgentExtensionMessageBuilder<TMessage>[];
+    providers: AgentExtensionProvider[];
+    automationEventTypes: AgentExtensionAutomationEventType[];
+}
+/**
+ * Base shape for a plugin or extension that can be loaded into a
+ * `ContributionRegistry`.
+ *
+ * An extension declares what it does through its `manifest` (capabilities and
+ * hook stages) and implements the corresponding handler methods. The registry
+ * validates at setup time that every declared stage has a matching handler and
+ * that no undeclared handlers are present.
+ *
+ * Hook handler properties are typed `unknown` here so that the generic base
+ * interface stays free of agent-specific imports. Concrete extension types
+ * (e.g. `AgentExtension` in `@cline/agents`) narrow them to the correct
+ * context and return types.
+ */
+export interface ContributionRegistryExtension<TTool = AgentTool, TMessage = unknown> {
+    type?: string;
+    /** Unique identifier for this extension, used in error messages and hook handler names. */
+    name: string;
+    /** Declares what capabilities and hook stages this extension uses. Validated before `setup()` runs. */
+    manifest: PluginManifest;
+    /** Indicates whether this extension is disabled. Disabled extensions are ignored during setup. */
+    disabled?: boolean;
+    /** Runtime-native hooks consumed directly by `@cline/agents`. */
+    hooks?: AgentExtensionHooks;
+    /**
+     * Called once during registry setup to register tools, commands, and other
+     * contributions.
+     *
+     * The optional second argument provides workspace context that is always
+     * sourced from the host session config — never from `process.cwd()`. Use
+     * `ctx.workspaceInfo?.rootPath` instead of `process.cwd()` or
+     * `import.meta.url` tricks when you need workspace-relative paths.
+     */
+    setup?: (api: AgentExtensionApi<TTool, TMessage>, ctx: PluginSetupContext) => void | Promise<void>;
+}
+export interface ContributionRegistryOptions<TExtension extends ContributionRegistryExtension<TTool, TMessage>, TTool = AgentTool, TMessage = unknown> {
+    extensions?: TExtension[];
+    /** Workspace context forwarded to each extension's `setup(api, ctx)` call. */
+    setupContext?: PluginSetupContext;
+}
+export declare function normalizePluginManifest(manifest: PluginManifest): PluginManifest;
+export declare class ContributionRegistry<TExtension extends ContributionRegistryExtension<TTool, TMessage>, TTool = AgentTool, TMessage = unknown> {
+    private readonly extensions;
+    private readonly registry;
+    private normalized;
+    private phase;
+    private readonly setupContext;
+    constructor(options?: ContributionRegistryOptions<TExtension, TTool, TMessage>);
+    resolve(): void;
+    validate(): void;
+    setup(): Promise<void>;
+    activate(): void;
+    initialize(): Promise<void>;
+    isActivated(): boolean;
+    getRegistrySnapshot(): AgentExtensionRegistry<TTool, TMessage>;
+    getRegisteredTools(): TTool[];
+    getRegisteredRules(): AgentExtensionRule[];
+    getRegisteredAutomationEventTypes(): AgentExtensionAutomationEventType[];
+    getValidatedExtensions(): TExtension[];
+}
+export declare function createContributionRegistry<TExtension extends ContributionRegistryExtension<TTool, TMessage>, TTool = AgentTool, TMessage = unknown>(options?: ContributionRegistryOptions<TExtension, TTool, TMessage>): ContributionRegistry<TExtension, TTool, TMessage>;
+export {};

package/dist/extensions/plugin.d.ts

@@ -0,0 +1 @@
+export declare const PLUGIN_FILE_EXTENSIONS: string[];

package/dist/hooks/contracts.d.ts

@@ -0,0 +1,9 @@
+export interface HookControl {
+    cancel?: boolean;
+    review?: boolean;
+    context?: string;
+    overrideInput?: unknown;
+    systemPrompt?: string;
+    appendMessages?: unknown[];
+    replaceMessages?: unknown[];
+}

package/dist/hooks/events.d.ts

@@ -0,0 +1,194 @@
+import { z } from "zod";
+import type { ToolCallRecord } from "../llms/tools";
+import type { HookSessionContext } from "../session/hook-context";
+import type { WorkspaceInfo } from "../session/workspace";
+import type { HookControl } from "./contracts";
+type AgentHookControl = Omit<HookControl, "appendMessages"> & {
+    systemPrompt?: string;
+    appendMessages?: unknown[];
+};
+export interface AgentHookRunStartPayload {
+    agentId: string;
+    conversationId: string;
+    parentAgentId: string | null;
+    userMessage: string;
+}
+export interface AgentHookToolCallStartPayload {
+    agentId: string;
+    conversationId: string;
+    parentAgentId: string | null;
+    iteration: number;
+    call: {
+        id: string;
+        name: string;
+        input: unknown;
+    };
+}
+export interface AgentHookToolCallEndPayload {
+    agentId: string;
+    conversationId: string;
+    parentAgentId: string | null;
+    iteration: number;
+    record: ToolCallRecord;
+}
+export interface AgentHookTurnEndPayload {
+    agentId: string;
+    conversationId: string;
+    parentAgentId: string | null;
+    iteration: number;
+    turn: unknown;
+}
+export interface AgentHookStopErrorPayload {
+    agentId: string;
+    conversationId: string;
+    parentAgentId: string | null;
+    iteration: number;
+    error: Error;
+}
+export interface AgentHookSessionShutdownPayload {
+    agentId: string;
+    conversationId: string;
+    parentAgentId: string | null;
+    reason?: string;
+}
+export declare const HookEventNameSchema: z.ZodEnum<{
+    tool_result: "tool_result";
+    agent_start: "agent_start";
+    agent_resume: "agent_resume";
+    agent_abort: "agent_abort";
+    agent_end: "agent_end";
+    agent_error: "agent_error";
+    tool_call: "tool_call";
+    prompt_submit: "prompt_submit";
+    pre_compact: "pre_compact";
+    session_shutdown: "session_shutdown";
+}>;
+export type HookEventName = z.infer<typeof HookEventNameSchema>;
+export interface PreToolUseData {
+    toolName: string;
+    parameters: Record<string, string>;
+}
+export interface PostToolUseData {
+    toolName: string;
+    parameters: Record<string, string>;
+    result: string;
+    success: boolean;
+    executionTimeMs: number;
+}
+export interface UserPromptSubmitData {
+    prompt: string;
+    attachments: string[];
+}
+export interface TaskStartData {
+    taskMetadata: Record<string, string>;
+}
+export interface TaskResumeData {
+    taskMetadata: Record<string, string>;
+    previousState: Record<string, string>;
+}
+export interface TaskCancelData {
+    taskMetadata: Record<string, string>;
+}
+export interface TaskCompleteData {
+    taskMetadata: Record<string, string>;
+}
+export interface PreCompactData {
+    taskId: string;
+    ulid: string;
+    contextSize: number;
+    compactionStrategy: string;
+    previousApiReqIndex: number;
+    tokensIn: number;
+    tokensOut: number;
+    tokensInCache: number;
+    tokensOutCache: number;
+    deletedRangeStart: number;
+    deletedRangeEnd: number;
+    contextJsonPath: string;
+    contextRawPath: string;
+}
+export interface HookEventPayloadBase {
+    clineVersion: string;
+    hookName: HookEventName;
+    timestamp: string;
+    taskId: string;
+    sessionContext?: HookSessionContext;
+    workspaceRoots: string[];
+    /**
+     * Structured workspace and git metadata for the session.
+     *
+     * Contains `rootPath`, `hint`, `associatedRemoteUrls`,
+     * `latestGitCommitHash`, and `latestGitBranchName` — the same data as
+     * `workspaceRoots[0]` plus the git fields. Hook scripts can use this for
+     * branch-aware logic or commit attribution without running `git` themselves.
+     *
+     * `undefined` when the session has no workspace metadata (e.g. unit tests
+     * or sessions started without a `cwd`).
+     */
+    workspaceInfo?: WorkspaceInfo;
+    userId: string;
+    agent_id: string;
+    parent_agent_id: string | null;
+    preToolUse?: PreToolUseData | undefined;
+    postToolUse?: PostToolUseData | undefined;
+    userPromptSubmit?: UserPromptSubmitData | undefined;
+    taskStart?: TaskStartData | undefined;
+    taskResume?: TaskResumeData | undefined;
+    taskCancel?: TaskCancelData | undefined;
+    taskComplete?: TaskCompleteData | undefined;
+    preCompact?: PreCompactData | undefined;
+}
+export interface ToolCallHookPayload extends HookEventPayloadBase {
+    hookName: "tool_call";
+    iteration: number;
+    tool_call: {
+        id: string;
+        name: string;
+        input: unknown;
+    };
+}
+export interface ToolResultHookPayload extends HookEventPayloadBase {
+    hookName: "tool_result";
+    iteration: number;
+    tool_result: ToolCallRecord;
+}
+export interface AgentEndHookPayload extends HookEventPayloadBase {
+    hookName: "agent_end";
+    iteration: number;
+    turn?: unknown;
+}
+export interface AgentErrorHookPayload extends HookEventPayloadBase {
+    hookName: "agent_error";
+    iteration: number;
+    error: {
+        name: string;
+        message: string;
+        stack?: string;
+    };
+}
+export interface AgentStartHookPayload extends HookEventPayloadBase {
+    hookName: "agent_start";
+}
+export interface AgentResumeHookPayload extends HookEventPayloadBase {
+    hookName: "agent_resume";
+}
+export interface AgentAbortHookPayload extends HookEventPayloadBase {
+    hookName: "agent_abort";
+    reason?: string;
+}
+export interface PromptSubmitHookPayload extends HookEventPayloadBase {
+    hookName: "prompt_submit";
+}
+export interface PreCompactHookPayload extends HookEventPayloadBase {
+    hookName: "pre_compact";
+    preCompact: PreCompactData;
+}
+export interface SessionShutdownHookPayload extends HookEventPayloadBase {
+    hookName: "session_shutdown";
+    reason?: string;
+}
+export type HookEventPayload = ToolCallHookPayload | ToolResultHookPayload | AgentStartHookPayload | AgentResumeHookPayload | AgentAbortHookPayload | PromptSubmitHookPayload | PreCompactHookPayload | AgentEndHookPayload | AgentErrorHookPayload | SessionShutdownHookPayload;
+export declare const HookEventPayloadSchema: z.ZodType<unknown>;
+export declare function parseHookEventPayload(value: unknown): HookEventPayload | undefined;
+export type SubprocessHookControl = AgentHookControl;
+export {};