@clinebot/core 0.0.37 → 0.0.38

package/dist/cline-core/types.d.ts

@@ -0,0 +1,221 @@
+import type { Message } from "@clinebot/llms";
+import type { AgentConfig, AutomationEventEnvelope, BasicLogger, ITelemetryService } from "@clinebot/shared";
+import type { CronEventSuppression } from "../cron/events/cron-event-ingress";
+import type { CronEventLogRecord, CronRunRecord, CronSpecRecord } from "../cron/store/sqlite-cron-store";
+import type { CheckpointEntry } from "../hooks/checkpoint-hooks";
+import type { RuntimeCapabilities } from "../runtime/capabilities";
+import type { SessionHistoryListOptions } from "../runtime/host/history";
+import type { SessionBackend } from "../runtime/host/host";
+import type { LocalRuntimeStartOptions, RuntimeHostMode, StartSessionInput, StartSessionResult } from "../runtime/host/runtime-host";
+import type { CoreSessionConfig } from "../types/config";
+import type { SessionMessagesArtifactUploader } from "../types/session";
+export type { RuntimeHostMode } from "../runtime/host/runtime-host";
+export type { ClineCoreSettingsApi } from "../settings";
+export interface HubOptions {
+    endpoint?: string;
+    authToken?: string;
+    strategy?: "prefer-hub" | "require-hub";
+    clientType?: string;
+    displayName?: string;
+    workspaceRoot?: string;
+    cwd?: string;
+}
+export interface RemoteOptions {
+    endpoint: string;
+    authToken?: string;
+    clientType?: string;
+    displayName?: string;
+    workspaceRoot?: string;
+    cwd?: string;
+}
+export interface ClineCoreAutomationOptions {
+    /** @deprecated Use `cronSpecsDir`. */
+    cronDir?: string;
+    cronSpecsDir?: string;
+    /** @deprecated Reports are written under the resolved cron specs directory. */
+    reportsDir?: string;
+    cronScope?: "global" | "user" | "workspace";
+    workspaceRoot?: string;
+    dbPath?: string;
+    pollIntervalMs?: number;
+    claimLeaseSeconds?: number;
+    globalMaxConcurrency?: number;
+    watcherDebounceMs?: number;
+    autoStart?: boolean;
+}
+export type ClineAutomationSpec = CronSpecRecord;
+export type ClineAutomationRun = CronRunRecord;
+export type ClineAutomationEventLog = CronEventLogRecord;
+export type ClineAutomationEventSuppression = CronEventSuppression;
+export type ClineAutomationRunStatus = "queued" | "running" | "done" | "failed" | "cancelled";
+export interface ClineAutomationListSpecsOptions {
+    triggerKind?: "one_off" | "schedule" | "event";
+    enabled?: boolean;
+    parseStatus?: "valid" | "invalid";
+    includeRemoved?: boolean;
+    limit?: number;
+}
+export interface ClineAutomationListRunsOptions {
+    specId?: string;
+    status?: ClineAutomationRunStatus | ClineAutomationRunStatus[];
+    limit?: number;
+}
+export interface ClineAutomationListEventsOptions {
+    eventType?: string;
+    source?: string;
+    processingStatus?: "received" | "unmatched" | "queued" | "suppressed" | "failed";
+    limit?: number;
+}
+export interface ClineAutomationEventIngressResult {
+    event: ClineAutomationEventLog;
+    duplicate: boolean;
+    matchedSpecIds: string[];
+    queuedRuns: ClineAutomationRun[];
+    suppressions: ClineAutomationEventSuppression[];
+}
+export interface ClineCoreAutomationApi {
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    reconcileNow(): Promise<void>;
+    ingestEvent(event: AutomationEventEnvelope): ClineAutomationEventIngressResult;
+    listEvents(options?: ClineAutomationListEventsOptions): ClineAutomationEventLog[];
+    getEvent(eventId: string): ClineAutomationEventLog | undefined;
+    listSpecs(options?: ClineAutomationListSpecsOptions): ClineAutomationSpec[];
+    listRuns(options?: ClineAutomationListRunsOptions): ClineAutomationRun[];
+}
+export type ClineCoreListHistoryOptions = SessionHistoryListOptions;
+export interface ClineCoreStartInput extends Omit<StartSessionInput, "config" | "localRuntime"> {
+    config: CoreSessionConfig;
+    localRuntime?: LocalRuntimeStartOptions;
+}
+export interface RestoreOptions {
+    /**
+     * Restore the message history by starting a new session fork trimmed to
+     * `checkpointRunCount`. Defaults to true.
+     */
+    messages?: boolean;
+    /**
+     * Restore the workspace files from the checkpoint's git snapshot.
+     * Defaults to true.
+     */
+    workspace?: boolean;
+    /**
+     * Start the forked session with messages before the checkpoint user message
+     * while still returning messages through that user message. This is for
+     * clients that put the checkpoint message back into a compose box so it can
+     * be edited and submitted again without duplicating it in session history.
+     */
+    omitCheckpointMessageFromSession?: boolean;
+}
+export interface RestoreInput {
+    sessionId: string;
+    checkpointRunCount: number;
+    start?: ClineCoreStartInput;
+    cwd?: string;
+    restore?: RestoreOptions;
+}
+export interface RestoreResult {
+    sessionId?: string;
+    startResult?: StartSessionResult;
+    messages?: Message[];
+    checkpoint: CheckpointEntry;
+}
+export interface ClineCoreOptions {
+    /**
+     * A human-readable name for this SDK client (e.g. `"my-app"`, `"acme-bot"`).
+     * Used to identify the consumer in telemetry and logs.
+     */
+    clientName?: string;
+    /**
+     * A stable identifier for this machine or user, used for telemetry attribution.
+     * Defaults to the system machine ID, falling back to a generated `cl-<nanoid>` persisted
+     * at `~/.cline/data/machine-id`.
+     */
+    distinctId?: string;
+    /**
+     * Controls how the runtime host is selected:
+     * - `"auto"` (default) — prefers a compatible local hub when one is available and falls
+     *   back to local in-process execution when not.
+     * - `"hub"` — requires a compatible websocket hub runtime; throws if one is not reachable.
+     * - `"remote"` — requires an explicit remote websocket hub endpoint.
+     * - `"local"` — always uses local in-process execution and local SQLite/file storage.
+     */
+    backendMode?: RuntimeHostMode;
+    /**
+     * Hub runtime connection options. Used when `backendMode` is `"hub"` or when `"auto"`
+     * should prefer a shared local hub if available.
+     */
+    hub?: HubOptions;
+    /**
+     * Remote hub connection options. Only relevant when `backendMode` is `"remote"`.
+     */
+    remote?: RemoteOptions;
+    /**
+     * Client-owned runtime capabilities. Core adapts these handlers to the
+     * selected runtime backend so apps implement interactive behavior once.
+     */
+    capabilities?: RuntimeCapabilities;
+    /**
+     * Telemetry service instance to use for capturing events and usage.
+     * If omitted, telemetry is a no-op.
+     */
+    telemetry?: ITelemetryService;
+    /**
+     * Optional structured logger for core-side operational diagnostics such as
+     * runtime-host selection and fallback decisions.
+     */
+    logger?: BasicLogger;
+    /**
+     * Per-tool approval policies that control whether a tool runs automatically,
+     * requires user confirmation, or is blocked entirely.
+     */
+    toolPolicies?: AgentConfig["toolPolicies"];
+    /**
+     * Optional hook invoked after `messages.json` is persisted to disk.
+     * Consumers can use this to mirror session transcripts into remote storage.
+     */
+    messagesArtifactUploader?: SessionMessagesArtifactUploader;
+    /**
+     * Enables file-based and event-driven automation through this ClineCore
+     * instance. When configured, callers use `cline.automation.*` instead of
+     * constructing cron services directly.
+     */
+    automation?: boolean | ClineCoreAutomationOptions;
+    /**
+     * Custom `fetch` implementation forwarded to the AI gateway providers used
+     * by local sessions. When supplied, it is threaded into each
+     * `ProviderConfig.fetch` built during session bootstrap, which in turn
+     * populates `GatewayProviderSettings.fetch` (and the top-level
+     * `GatewayConfig.fetch` fallback) so hosts can inject custom HTTP behavior
+     * such as proxies, retries, tracing, or test doubles.
+     *
+     * Per-session or per-provider overrides still win: an explicit
+     * `config.fetch` on `CoreSessionConfig` or a stored provider-level `fetch`
+     * takes precedence over this default.
+     *
+     * Applies only to sessions executed in this process (local and fallback-
+     * to-local auto mode). For hub and remote runtimes the HTTP call happens
+     * inside the process that owns the gateway, so configure `fetch` there:
+     *   - `startHubServer({ fetch })` / `ensureHubServer({ fetch })` from
+     *     `@clinebot/hub`
+     *   - `createLocalHubScheduleRuntimeHandlers({ fetch })` from
+     *     `@clinebot/core/hub` for the scheduler
+     */
+    fetch?: typeof fetch;
+    /**
+     * An already-constructed session backend to use instead of resolving one automatically.
+     * Intended for testing or embedding a custom persistence layer.
+     * @internal
+     */
+    sessionService?: SessionBackend;
+    /**
+     * Optional hook invoked before each session starts.
+     * Use this to prepare workspace-scoped runtime state and then return an
+     * adapter that mutates the shared session input before core starts the run.
+     */
+    prepare?: (input: ClineCoreStartInput) => Promise<StartSessionBootstrap | undefined> | StartSessionBootstrap | undefined;
+}
+export interface StartSessionBootstrap {
+    applyToStartSessionInput(input: ClineCoreStartInput): Promise<ClineCoreStartInput> | ClineCoreStartInput;
+    dispose?(): Promise<void> | void;
+}

package/dist/cron/{cron-event-ingress.d.ts → events/cron-event-ingress.d.ts}

@@ -1,5 +1,5 @@
 import type { AutomationEventEnvelope, BasicLogger } from "@clinebot/shared";
-import type { CronEventLogRecord, CronRunRecord, CronSpecRecord, SqliteCronStore } from "./sqlite-cron-store";
+import type { CronEventLogRecord, CronRunRecord, CronSpecRecord, SqliteCronStore } from "../store/sqlite-cron-store";
 /**
  * Durable ingress for normalized automation events.
  *
@@ -35,4 +35,3 @@ export declare class CronEventIngress {
     ingestEvent(event: AutomationEventEnvelope): CronEventIngressResult;
     private materializeForSpec;
 }
-//# sourceMappingURL=cron-event-ingress.d.ts.map

package/dist/cron/{cron-report-writer.d.ts → reports/cron-report-writer.d.ts}

@@ -1,5 +1,5 @@
 import { type ResolveCronSpecsDirOptions } from "@clinebot/shared/storage";
-import type { CronEventLogRecord, CronRunRecord, CronSpecRecord } from "./sqlite-cron-store";
+import type { CronEventLogRecord, CronRunRecord, CronSpecRecord } from "../store/sqlite-cron-store";
 /**
  * Writes a markdown report for a completed or failed cron run.
  * Reports live under `<cron-specs-dir>/reports/<run-id>.md`.
@@ -38,4 +38,3 @@ export interface WriteReportOptions {
     data: CronRunReportData;
 }
 export declare function writeCronRunReport(options: WriteReportOptions): string;
-//# sourceMappingURL=cron-report-writer.d.ts.map

package/dist/cron/{cron-materializer.d.ts → runner/cron-materializer.d.ts}

@@ -1,4 +1,4 @@
-import type { CronSpecRecord, SqliteCronStore } from "./sqlite-cron-store";
+import type { CronSpecRecord, SqliteCronStore } from "../store/sqlite-cron-store";
 /**
  * Queue materialization rules shared between the reconciler, watcher, and
  * periodic runner tick. Execution stays trigger-agnostic once a row is
@@ -33,4 +33,3 @@ export declare class CronMaterializer {
      */
     materializeSchedule(spec: CronSpecRecord): boolean;
 }
-//# sourceMappingURL=cron-materializer.d.ts.map

package/dist/cron/{cron-runner.d.ts → runner/cron-runner.d.ts}

@@ -1,8 +1,8 @@
 import type { BasicLogger } from "@clinebot/shared";
 import type { ResolveCronSpecsDirOptions } from "@clinebot/shared/storage";
+import type { HubScheduleRuntimeHandlers } from "../service/schedule-service";
+import type { CronRunRecord, SqliteCronStore } from "../store/sqlite-cron-store";
 import type { CronMaterializer } from "./cron-materializer";
-import type { HubScheduleRuntimeHandlers } from "./schedule-service";
-import type { SqliteCronStore } from "./sqlite-cron-store";
 export interface CronRunnerOptions {
     store: SqliteCronStore;
     materializer: CronMaterializer;
@@ -33,11 +33,13 @@ export declare class CronRunner {
     stop(): Promise<void>;
     dispose(): Promise<void>;
     tick(): Promise<void>;
+    getActiveRuns(): Array<CronRunRecord & {
+        claimToken: string;
+        sessionId?: string;
+    }>;
     private executeClaim;
     private buildPrompt;
     private startClaimLeaseHeartbeat;
-    private loadRulesForSpec;
     private buildSystemPrompt;
     private buildStartRequest;
 }
-//# sourceMappingURL=cron-runner.d.ts.map

package/dist/cron/{resource-limiter.d.ts → runner/resource-limiter.d.ts}

@@ -6,4 +6,3 @@ export declare class ResourceLimiter {
     release(scheduleId: string, executionId: string): void;
     getGlobalActiveCount(): number;
 }
-//# sourceMappingURL=resource-limiter.d.ts.map

package/dist/cron/schedule/scheduler.d.ts

@@ -0,0 +1,12 @@
+export interface ParsedCron {
+    minutes: number[];
+    hours: number[];
+    daysOfMonth: number[];
+    months: number[];
+    daysOfWeek: number[];
+}
+export declare function parseCron(pattern: string): ParsedCron;
+export declare function validateCronPattern(pattern: string): void;
+export declare function validateCronSchedule(pattern: string, timezone?: string, after?: number): void;
+export declare function validateTimezone(timezone: string | undefined): void;
+export declare function getNextCronTime(pattern: string, after: number, timezone?: string): number;

package/dist/cron/{cron-service.d.ts → service/cron-service.d.ts}

@@ -1,8 +1,8 @@
 import type { AutomationEventEnvelope, BasicLogger } from "@clinebot/shared";
 import type { ResolveCronSpecsDirOptions } from "@clinebot/shared/storage";
-import { type CronEventIngressResult } from "./cron-event-ingress";
+import { type CronEventIngressResult } from "../events/cron-event-ingress";
+import type { CronRunRecord, CronSpecRecord, ListEventLogsOptions, ListRunsOptions, ListSpecsOptions } from "../store/sqlite-cron-store";
 import type { HubScheduleRuntimeHandlers } from "./schedule-service";
-import type { CronRunRecord, CronSpecRecord, ListEventLogsOptions, ListRunsOptions, ListSpecsOptions } from "./sqlite-cron-store";
 /**
  * Top-level orchestrator for file-based cron automation.
  *
@@ -51,7 +51,6 @@ export declare class CronService {
     listUpcomingRuns(limit?: number): CronRunRecord[];
     reconcileNow(): Promise<void>;
     ingestEvent(event: AutomationEventEnvelope): CronEventIngressResult;
-    listEventLogs(options?: ListEventLogsOptions): import("./sqlite-cron-store").CronEventLogRecord[];
-    getEventLog(eventId: string): import("./sqlite-cron-store").CronEventLogRecord | undefined;
+    listEventLogs(options?: ListEventLogsOptions): import("../store/sqlite-cron-store").CronEventLogRecord[];
+    getEventLog(eventId: string): import("../store/sqlite-cron-store").CronEventLogRecord | undefined;
 }
-//# sourceMappingURL=cron-service.d.ts.map

package/dist/cron/{schedule-command-service.d.ts → service/schedule-command-service.d.ts}

@@ -7,4 +7,3 @@ export declare class HubScheduleCommandService {
     private toCreateInput;
     private toUpdateInput;
 }
-//# sourceMappingURL=schedule-command-service.d.ts.map

package/dist/cron/{schedule-service.d.ts → service/schedule-service.d.ts}

@@ -1,5 +1,4 @@
-import type { BasicLogger, ChatRunTurnRequest, ChatStartSessionArtifacts, ChatStartSessionRequest, HubScheduleCreateInput, HubScheduleUpdateInput, ScheduleExecutionRecord, ScheduleRecord } from "@clinebot/shared";
-import { type ListScheduleExecutionsOptions, type ListSchedulesOptions, type ScheduleExecutionStats } from "./sqlite-schedule-store";
+import type { BasicLogger, ChatRunTurnRequest, ChatStartSessionArtifacts, ChatStartSessionRequest, HubScheduleCreateInput, HubScheduleUpdateInput, ScheduleExecutionRecord, ScheduleExecutionStatus, ScheduleRecord } from "@clinebot/shared";
 type HubScheduleTurnResult = {
     text: string;
     usage?: {
@@ -22,11 +21,6 @@ type HubScheduleTurnResult = {
         durationMs?: number;
     }>;
 };
-export interface ScheduleAutonomousOptions {
-    enabled?: boolean;
-    idleTimeoutSeconds?: number;
-    pollIntervalSeconds?: number;
-}
 export interface HubScheduleRuntimeHandlers {
     startSession(request: ChatStartSessionRequest): Promise<{
         sessionId: string;
@@ -53,20 +47,32 @@ export interface HubScheduleServiceOptions {
     runtimeHandlers: HubScheduleRuntimeHandlers;
     eventPublisher?: (eventType: string, payload: unknown) => void;
     logger?: BasicLogger;
-    sessionsDbPath?: string;
+    dbPath?: string;
     pollIntervalMs?: number;
     globalMaxConcurrency?: number;
     claimLeaseSeconds?: number;
 }
+export interface ListSchedulesOptions {
+    enabled?: boolean;
+    limit?: number;
+    tags?: string[];
+}
+export interface ListScheduleExecutionsOptions {
+    scheduleId?: string;
+    status?: ScheduleExecutionStatus;
+    limit?: number;
+}
+export interface ScheduleExecutionStats {
+    totalRuns: number;
+    successRate: number;
+    avgDurationSeconds: number;
+    lastFailure?: ScheduleExecutionRecord;
+}
 export declare class HubScheduleService {
     private readonly store;
-    private readonly resourceLimiter;
-    private readonly options;
-    private readonly claimLeaseMs;
-    private readonly activeExecutions;
-    private timer;
+    private readonly materializer;
+    private readonly runner;
     private started;
-    private ticking;
     private disposed;
     constructor(options: HubScheduleServiceOptions);
     start(): Promise<void>;
@@ -88,13 +94,5 @@ export declare class HubScheduleService {
         name: string;
         nextRunAt: string;
     }>;
-    private tick;
-    private executeClaimedSchedule;
-    private startClaimLeaseHeartbeat;
-    private buildStartRequest;
-    private executeSchedule;
-    private publishEvent;
-    private runAutonomousIdleLoop;
 }
 export {};
-//# sourceMappingURL=schedule-service.d.ts.map

package/dist/cron/{cron-reconciler.d.ts → specs/cron-reconciler.d.ts}

@@ -1,6 +1,6 @@
 import type { CronSpecParseResult } from "@clinebot/shared";
 import { type ResolveCronSpecsDirOptions } from "@clinebot/shared/storage";
-import type { CronSpecRecord, SqliteCronStore, UpsertSpecResult } from "./sqlite-cron-store";
+import type { CronSpecRecord, SqliteCronStore, UpsertSpecResult } from "../store/sqlite-cron-store";
 /**
  * Scan the configured cron specs directory on disk, parse every file, and
  * upsert spec state into the cron DB. This is the startup source of truth:
@@ -59,4 +59,3 @@ export declare class CronReconciler {
     refreshScheduleNextRunAt(): void;
     private applyScheduleNextRunAt;
 }
-//# sourceMappingURL=cron-reconciler.d.ts.map

package/dist/cron/{cron-spec-parser.d.ts → specs/cron-spec-parser.d.ts}

@@ -24,4 +24,3 @@ export interface ParseCronSpecInput {
  * Parse a single cron spec file. Never throws; always returns a result.
  */
 export declare function parseCronSpecFile(input: ParseCronSpecInput): CronSpecParseResult;
-//# sourceMappingURL=cron-spec-parser.d.ts.map

package/dist/cron/{cron-watcher.d.ts → specs/cron-watcher.d.ts}

@@ -20,4 +20,3 @@ export declare class CronWatcher {
     private scheduleReconcile;
     private reconcileNow;
 }
-//# sourceMappingURL=cron-watcher.d.ts.map

package/dist/cron/{cron-schema.d.ts → store/cron-schema.d.ts}

@@ -1,3 +1,2 @@
 import type { SqliteDb } from "@clinebot/shared/db";
 export declare function ensureCronSchema(db: SqliteDb): void;
-//# sourceMappingURL=cron-schema.d.ts.map

package/dist/cron/{sqlite-cron-store.d.ts → store/sqlite-cron-store.d.ts}

@@ -1,4 +1,4 @@
-import type { AutomationEventEnvelope, CronSpec, CronSpecExtensionKind, CronTriggerKind } from "@clinebot/shared";
+import type { AutomationEventEnvelope, CronSpec, CronSpecExtensionKind, CronTriggerKind, HubScheduleCreateInput, HubScheduleUpdateInput } from "@clinebot/shared";
 /**
  * Generalized cron/automation store backed by `cron.db`. Sessions stay in
  * their own database (see @clinebot/shared `ensureSessionSchema`). cron_runs
@@ -162,6 +162,16 @@ export declare class SqliteCronStore {
     getSpec(specId: string): CronSpecRecord | undefined;
     getSpecByExternalId(externalId: string): CronSpecRecord | undefined;
     listSpecs(options?: ListSpecsOptions): CronSpecRecord[];
+    createHubSchedule(input: HubScheduleCreateInput): CronSpecRecord;
+    getHubSchedule(scheduleId: string): CronSpecRecord | undefined;
+    listHubSchedules(options?: {
+        enabled?: boolean;
+        limit?: number;
+        tags?: string[];
+    }): CronSpecRecord[];
+    updateHubSchedule(scheduleId: string, updates: HubScheduleUpdateInput): CronSpecRecord | undefined;
+    deleteHubSchedule(scheduleId: string): boolean;
+    enqueueHubScheduleRun(scheduleId: string, triggerKind?: "manual" | "retry"): CronRunRecord | undefined;
     listEventSpecsForType(eventType: string): CronSpecRecord[];
     upsertSpec(input: UpsertSpecInput): UpsertSpecResult;
     private insertSpecRow;
@@ -170,6 +180,7 @@ export declare class SqliteCronStore {
     updateSpecNextRunAt(specId: string, nextRunAt: string | undefined): void;
     updateSpecLastRunAt(specId: string, lastRunAt: string): void;
     updateLastMaterializedRunId(specId: string, runId: string): void;
+    private initializeScheduleNextRun;
     materializeDueScheduleRun(options: {
         specId: string;
         nowMs: number;
@@ -227,4 +238,3 @@ export declare class SqliteCronStore {
     attachReportPathToRun(runId: string, reportPath: string): void;
 }
 export {};
-//# sourceMappingURL=sqlite-cron-store.d.ts.map

package/dist/extensions/config/index.d.ts

@@ -1,10 +1,7 @@
-export type { AgentConfigWatcher, AgentConfigWatcherEvent, AgentYamlConfig, BuildAgentConfigOverridesOptions, CreateAgentConfigWatcherOptions, ParseYamlFrontmatterResult, PartialAgentConfigOverrides, } from "./agent-config-loader";
-export { AGENT_CONFIG_DIRECTORY_NAME, createAgentConfigDefinition, createAgentConfigWatcher, parseAgentConfigFromYaml, parsePartialAgentConfigFromYaml, readAgentConfigsFromDisk, resolveAgentConfigSearchPaths, resolveAgentsConfigDirPath, resolveAgentTools, toPartialAgentConfig, } from "./agent-config-loader";
-export { HOOK_CONFIG_FILE_EVENT_MAP, HOOKS_CONFIG_DIRECTORY_NAME, type HookConfigFileEntry, HookConfigFileName, listHookConfigFiles, resolveHooksConfigSearchPaths, toHookConfigFileName, } from "./hooks-config-loader";
 export type { AvailableRuntimeCommand, RuntimeCommandKind, } from "./runtime-commands";
-export { listAvailableRuntimeCommandsFromWatcher, resolveRuntimeSlashCommandFromWatcher, } from "./runtime-commands";
 export type { UnifiedConfigDefinition, UnifiedConfigFileCandidate, UnifiedConfigFileContext, UnifiedConfigRecord, UnifiedConfigWatcherEvent, UnifiedConfigWatcherOptions, } from "./unified-config-file-watcher";
 export { UnifiedConfigFileWatcher } from "./unified-config-file-watcher";
-export type { CreateInstructionWatcherOptions, CreateRulesConfigDefinitionOptions, CreateSkillsConfigDefinitionOptions, CreateUserInstructionConfigWatcherOptions, CreateWorkflowsConfigDefinitionOptions, ParseMarkdownFrontmatterResult, RuleConfig, SkillConfig, UserInstructionConfig, UserInstructionConfigType, UserInstructionConfigWatcher, UserInstructionConfigWatcherEvent, WorkflowConfig, } from "./user-instruction-config-loader";
-export { createRulesConfigDefinition, createSkillsConfigDefinition, createUserInstructionConfigWatcher, createWorkflowsConfigDefinition, parseRuleConfigFromMarkdown, parseSkillConfigFromMarkdown, parseWorkflowConfigFromMarkdown, RULES_CONFIG_DIRECTORY_NAME, resolveRulesConfigSearchPaths, resolveSkillsConfigSearchPaths, resolveWorkflowsConfigSearchPaths, SKILLS_CONFIG_DIRECTORY_NAME, WORKFLOWS_CONFIG_DIRECTORY_NAME, } from "./user-instruction-config-loader";
-//# sourceMappingURL=index.d.ts.map
+export type { CreateInstructionWatcherOptions, CreateRulesConfigDefinitionOptions, CreateSkillsConfigDefinitionOptions, CreateWorkflowsConfigDefinitionOptions, ParseMarkdownFrontmatterResult, RuleConfig, SkillConfig, UserInstructionConfig, UserInstructionConfigType, WorkflowConfig, } from "./user-instruction-config-loader";
+export { createRulesConfigDefinition, createSkillsConfigDefinition, createWorkflowsConfigDefinition, parseRuleConfigFromMarkdown, parseSkillConfigFromMarkdown, parseWorkflowConfigFromMarkdown, RULES_CONFIG_DIRECTORY_NAME, resolveRulesConfigSearchPaths, resolveSkillsConfigSearchPaths, resolveWorkflowsConfigSearchPaths, SKILLS_CONFIG_DIRECTORY_NAME, WORKFLOWS_CONFIG_DIRECTORY_NAME, } from "./user-instruction-config-loader";
+export type { CreateUserInstructionConfigServiceOptions, UserInstructionConfigRecord, UserInstructionConfigService, } from "./user-instruction-service";
+export { createUserInstructionConfigService } from "./user-instruction-service";

package/dist/extensions/config/runtime-commands.d.ts

@@ -9,4 +9,3 @@ export type AvailableRuntimeCommand = {
 };
 export declare function listAvailableRuntimeCommandsFromWatcher(watcher: UserInstructionConfigWatcher): AvailableRuntimeCommand[];
 export declare function resolveRuntimeSlashCommandFromWatcher(input: string, watcher: UserInstructionConfigWatcher): string;
-//# sourceMappingURL=runtime-commands.d.ts.map

package/dist/extensions/config/skill-frontmatter-toggle.d.ts

@@ -0,0 +1,11 @@
+export interface ToggleSkillFrontmatterOptions {
+    filePath: string;
+    enabled: boolean;
+}
+export interface ToggleSkillFrontmatterResult {
+    filePath: string;
+    enabled: boolean;
+    disabled: boolean;
+}
+export declare function updateSkillMarkdownEnabledState(content: string, enabled: boolean): string;
+export declare function toggleSkillFrontmatter({ filePath, enabled, }: ToggleSkillFrontmatterOptions): Promise<ToggleSkillFrontmatterResult>;

package/dist/extensions/config/unified-config-file-watcher.d.ts

@@ -75,4 +75,3 @@ export declare class UnifiedConfigFileWatcher<TType extends string = string, TIt
     private buildDesiredTypesByDirectory;
     private readDirectoryFileCandidates;
 }
-//# sourceMappingURL=unified-config-file-watcher.d.ts.map

package/dist/extensions/config/user-instruction-config-loader.d.ts

@@ -62,4 +62,3 @@ export interface CreateUserInstructionConfigWatcherOptions extends CreateInstruc
     workflows?: CreateWorkflowsConfigDefinitionOptions;
 }
 export declare function createUserInstructionConfigWatcher(options?: CreateUserInstructionConfigWatcherOptions): UserInstructionConfigWatcher;
-//# sourceMappingURL=user-instruction-config-loader.d.ts.map

package/dist/extensions/config/user-instruction-plugin.d.ts

@@ -0,0 +1,25 @@
+import type { AgentExtension } from "@clinebot/shared";
+import { type SkillsExecutorWithMetadata } from "../tools";
+import type { SkillConfig, UserInstructionConfigWatcher } from "./user-instruction-config-loader";
+type SkillsExecutorMetadataItem = {
+    id: string;
+    name: string;
+    description?: string;
+    disabled: boolean;
+};
+type ConfiguredSkill = SkillsExecutorMetadataItem & {
+    skill: SkillConfig;
+};
+export interface CreateUserInstructionPluginOptions {
+    watcher: UserInstructionConfigWatcher;
+    watcherReady?: Promise<void>;
+    includeRules?: boolean;
+    includeSkills?: boolean;
+    includeWorkflows?: boolean;
+    registerSkillsTool?: boolean;
+    allowedSkillNames?: ReadonlyArray<string>;
+}
+export declare function getConfiguredSkillsFromWatcher(watcher: UserInstructionConfigWatcher, allowedSkillNames?: ReadonlyArray<string>): ConfiguredSkill[];
+export declare function createUserInstructionSkillsExecutor(watcher: UserInstructionConfigWatcher, watcherReady?: Promise<void>, allowedSkillNames?: ReadonlyArray<string>): SkillsExecutorWithMetadata;
+export declare function createUserInstructionPlugin(options: CreateUserInstructionPluginOptions): AgentExtension;
+export {};

package/dist/extensions/config/user-instruction-service.d.ts

@@ -0,0 +1,23 @@
+import type { AgentExtension } from "@clinebot/shared";
+import { type AvailableRuntimeCommand } from "./runtime-commands";
+import { type CreateUserInstructionConfigWatcherOptions, type UserInstructionConfig, type UserInstructionConfigType } from "./user-instruction-config-loader";
+import { type CreateUserInstructionPluginOptions } from "./user-instruction-plugin";
+export interface UserInstructionConfigRecord<TConfig extends UserInstructionConfig = UserInstructionConfig> {
+    type: UserInstructionConfigType;
+    id: string;
+    filePath: string;
+    item: TConfig;
+}
+export interface CreateUserInstructionConfigServiceOptions extends CreateUserInstructionConfigWatcherOptions {
+}
+export interface UserInstructionConfigService {
+    start(): Promise<void>;
+    stop(): void;
+    refreshType(type: UserInstructionConfigType): Promise<void>;
+    listRecords<TConfig extends UserInstructionConfig = UserInstructionConfig>(type: UserInstructionConfigType): UserInstructionConfigRecord<TConfig>[];
+    listRuntimeCommands(): AvailableRuntimeCommand[];
+    resolveRuntimeSlashCommand(input: string): string;
+    hasConfiguredSkills(allowedSkillNames?: ReadonlyArray<string>): boolean;
+    createExtension(options: Omit<CreateUserInstructionPluginOptions, "watcher" | "watcherReady">): AgentExtension;
+}
+export declare function createUserInstructionConfigService(options?: CreateUserInstructionConfigServiceOptions): UserInstructionConfigService;

package/dist/extensions/context/agentic-compaction.d.ts

@@ -10,4 +10,3 @@ export declare function runAgenticCompaction(options: {
     estimateMessageTokens: EstimateMessageTokens;
     logger?: BasicLogger;
 }): Promise<CoreCompactionResult | undefined>;
-//# sourceMappingURL=agentic-compaction.d.ts.map

package/dist/extensions/context/basic-compaction.d.ts

@@ -6,4 +6,3 @@ export declare function runBasicCompaction(options: {
     estimateMessageTokens: EstimateMessageTokens;
     logger?: BasicLogger;
 }): CoreCompactionResult | undefined;
-//# sourceMappingURL=basic-compaction.d.ts.map

package/dist/extensions/context/compaction-shared.d.ts

@@ -58,4 +58,3 @@ export declare function buildSummaryMessage(options: {
     tokensBefore: number;
 }): MessageWithMetadata;
 export declare function getContextWindowTokens(context: Pick<CoreCompactionContext, "contextWindowTokens">): number;
-//# sourceMappingURL=compaction-shared.d.ts.map

package/dist/extensions/context/compaction.d.ts

@@ -17,4 +17,3 @@ export interface ContextPipelinePrepareTurnResult {
     systemPrompt?: string;
 }
 export declare function createContextCompactionPrepareTurn(config: Pick<CoreSessionConfig, "providerConfig" | "providerId" | "modelId" | "compaction" | "logger">): ((context: ContextPipelinePrepareTurnInput) => Promise<ContextPipelinePrepareTurnResult | undefined>) | undefined;
-//# sourceMappingURL=compaction.d.ts.map

package/dist/extensions/index.d.ts

@@ -3,4 +3,3 @@ export { discoverPluginModulePaths, resolveAgentPluginPaths, resolveAndLoadAgent
 export type { PluginInitializationFailure, PluginInitializationWarning, PluginLoadDiagnostics, } from "./plugin/plugin-load-report";
 export type { LoadAgentPluginFromPathOptions } from "./plugin/plugin-loader";
 export { loadAgentPluginFromPath, loadAgentPluginsFromPaths, loadAgentPluginsFromPathsWithDiagnostics, } from "./plugin/plugin-loader";
-//# sourceMappingURL=index.d.ts.map

package/dist/extensions/mcp/client.d.ts

@@ -1,3 +1,2 @@
 import type { McpServerClientFactory } from "./types";
 export declare function createDefaultMcpServerClientFactory(): McpServerClientFactory;
-//# sourceMappingURL=client.d.ts.map

package/dist/extensions/mcp/config-loader.d.ts

@@ -13,4 +13,3 @@ export declare function loadMcpSettingsFile(options?: LoadMcpSettingsOptions): M
 export declare function hasMcpSettingsFile(options?: LoadMcpSettingsOptions): boolean;
 export declare function resolveMcpServerRegistrations(options?: LoadMcpSettingsOptions): McpServerRegistration[];
 export declare function registerMcpServersFromSettingsFile(manager: Pick<McpManager, "registerServer">, options?: RegisterMcpServersFromSettingsOptions): Promise<McpServerRegistration[]>;
-//# sourceMappingURL=config-loader.d.ts.map

package/dist/extensions/mcp/index.d.ts

@@ -6,4 +6,3 @@ export type { CreateDisabledMcpToolPoliciesOptions, CreateDisabledMcpToolPolicyO
 export { createDisabledMcpToolPolicies, createDisabledMcpToolPolicy, } from "./policies";
 export { createMcpTools } from "./tools";
 export type { CreateMcpToolsOptions, McpConnectionStatus, McpManager, McpManagerOptions, McpServerClient, McpServerClientFactory, McpServerRegistration, McpServerSnapshot, McpServerTransportConfig, McpSseTransportConfig, McpStdioTransportConfig, McpStreamableHttpTransportConfig, McpToolCallRequest, McpToolCallResult, McpToolDescriptor, McpToolNameTransform, McpToolProvider, } from "./types";
-//# sourceMappingURL=index.d.ts.map

package/dist/extensions/mcp/manager.d.ts

@@ -21,4 +21,3 @@ export declare class InMemoryMcpManager implements McpManager {
     private requireServer;
     private runExclusive;
 }
-//# sourceMappingURL=manager.d.ts.map

package/dist/extensions/mcp/name-transform.d.ts

@@ -1,3 +1,2 @@
 import type { McpToolNameTransform } from "./types";
 export declare const defaultMcpToolNameTransform: McpToolNameTransform;
-//# sourceMappingURL=name-transform.d.ts.map

package/dist/extensions/mcp/policies.d.ts

@@ -12,4 +12,3 @@ export interface CreateDisabledMcpToolPoliciesOptions {
 }
 export declare function createDisabledMcpToolPolicy(options: CreateDisabledMcpToolPolicyOptions): Record<string, ToolPolicy>;
 export declare function createDisabledMcpToolPolicies(options: CreateDisabledMcpToolPoliciesOptions): Record<string, ToolPolicy>;
-//# sourceMappingURL=policies.d.ts.map