@cline/core 0.0.38-nightly.1778113663

package/dist/cron/runner/cron-runner.d.ts

@@ -0,0 +1,45 @@
+import type { BasicLogger } from "@cline/shared";
+import type { ResolveCronSpecsDirOptions } from "@cline/shared/storage";
+import type { HubScheduleRuntimeHandlers } from "../service/schedule-service";
+import type { CronRunRecord, SqliteCronStore } from "../store/sqlite-cron-store";
+import type { CronMaterializer } from "./cron-materializer";
+export interface CronRunnerOptions {
+    store: SqliteCronStore;
+    materializer: CronMaterializer;
+    runtimeHandlers: HubScheduleRuntimeHandlers;
+    /** Default runtime workspace for the hub/daemon process. */
+    workspaceRoot: string;
+    /** Cron spec source/report location. Defaults to global `~/.cline/cron`. */
+    specs?: ResolveCronSpecsDirOptions;
+    logger?: BasicLogger;
+    pollIntervalMs?: number;
+    claimLeaseSeconds?: number;
+    globalMaxConcurrency?: number;
+}
+export declare class CronRunner {
+    private readonly store;
+    private readonly materializer;
+    private readonly options;
+    private readonly limiter;
+    private readonly claimLeaseMs;
+    private timer;
+    private started;
+    private ticking;
+    private disposed;
+    private stopping;
+    private readonly activeRuns;
+    constructor(options: CronRunnerOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    dispose(): Promise<void>;
+    tick(): Promise<void>;
+    getActiveRuns(): Array<CronRunRecord & {
+        claimToken: string;
+        sessionId?: string;
+    }>;
+    private executeClaim;
+    private buildPrompt;
+    private startClaimLeaseHeartbeat;
+    private buildSystemPrompt;
+    private buildStartRequest;
+}

package/dist/cron/runner/resource-limiter.d.ts

@@ -0,0 +1,8 @@
+export declare class ResourceLimiter {
+    private readonly globalMaxConcurrency;
+    private readonly activeExecutions;
+    constructor(globalMaxConcurrency: number);
+    acquire(scheduleId: string, executionId: string, maxParallel: number): boolean;
+    release(scheduleId: string, executionId: string): void;
+    getGlobalActiveCount(): number;
+}

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/service/cron-service.d.ts

@@ -0,0 +1,56 @@
+import type { AutomationEventEnvelope, BasicLogger } from "@cline/shared";
+import type { ResolveCronSpecsDirOptions } from "@cline/shared/storage";
+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";
+/**
+ * Top-level orchestrator for file-based cron automation.
+ *
+ * Wires together:
+ *   - `SqliteCronStore` (cron.db)
+ *   - `CronReconciler` (disk -> DB)
+ *   - `CronWatcher` (cron specs directory filesystem events)
+ *   - `CronMaterializer` (queue materialization)
+ *   - `CronRunner` (claim + execute + report)
+ *
+ * This service is the forward path: the legacy `HubScheduleService`
+ * continues to serve programmatic schedules, while `CronService` handles
+ * everything sourced from the configured file-based cron directory.
+ */
+export interface CronServiceOptions {
+    /** Default runtime workspace for the hub/daemon process. */
+    workspaceRoot: string;
+    /** Cron spec source/report location. Defaults to global `~/.cline/cron`. */
+    specs?: ResolveCronSpecsDirOptions;
+    runtimeHandlers: HubScheduleRuntimeHandlers;
+    dbPath?: string;
+    logger?: BasicLogger;
+    pollIntervalMs?: number;
+    claimLeaseSeconds?: number;
+    globalMaxConcurrency?: number;
+    watcherDebounceMs?: number;
+}
+export declare class CronService {
+    private readonly store;
+    private readonly reconciler;
+    private readonly watcher;
+    private readonly eventIngress;
+    private readonly materializer;
+    private readonly runner;
+    private started;
+    private disposed;
+    constructor(options: CronServiceOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    dispose(): Promise<void>;
+    listSpecs(options?: ListSpecsOptions): CronSpecRecord[];
+    getSpec(specId: string): CronSpecRecord | undefined;
+    listRuns(options?: ListRunsOptions): CronRunRecord[];
+    getRun(runId: string): CronRunRecord | undefined;
+    listActiveRuns(): CronRunRecord[];
+    listUpcomingRuns(limit?: number): CronRunRecord[];
+    reconcileNow(): Promise<void>;
+    ingestEvent(event: AutomationEventEnvelope): CronEventIngressResult;
+    listEventLogs(options?: ListEventLogsOptions): import("../store/sqlite-cron-store").CronEventLogRecord[];
+    getEventLog(eventId: string): import("../store/sqlite-cron-store").CronEventLogRecord | undefined;
+}

package/dist/cron/service/schedule-command-service.d.ts

@@ -0,0 +1,9 @@
+import type { HubCommandEnvelope, HubReplyEnvelope } from "@cline/shared";
+import type { HubScheduleService } from "./schedule-service";
+export declare class HubScheduleCommandService {
+    private readonly schedules;
+    constructor(schedules: HubScheduleService);
+    handleCommand(envelope: HubCommandEnvelope): Promise<HubReplyEnvelope>;
+    private toCreateInput;
+    private toUpdateInput;
+}

package/dist/cron/service/schedule-service.d.ts

@@ -0,0 +1,98 @@
+import type { BasicLogger, ChatRunTurnRequest, ChatStartSessionArtifacts, ChatStartSessionRequest, HubScheduleCreateInput, HubScheduleUpdateInput, ScheduleExecutionRecord, ScheduleExecutionStatus, ScheduleRecord } from "@cline/shared";
+type HubScheduleTurnResult = {
+    text: string;
+    usage?: {
+        inputTokens?: number;
+        outputTokens?: number;
+        cacheReadTokens?: number;
+        cacheWriteTokens?: number;
+        totalCost?: number;
+    };
+    inputTokens?: number;
+    outputTokens?: number;
+    iterations?: number;
+    finishReason?: string;
+    messages?: unknown[];
+    toolCalls?: Array<{
+        name: string;
+        input?: unknown;
+        output?: unknown;
+        error?: string;
+        durationMs?: number;
+    }>;
+};
+export interface HubScheduleRuntimeHandlers {
+    startSession(request: ChatStartSessionRequest): Promise<{
+        sessionId: string;
+        startResult?: ChatStartSessionArtifacts;
+    }>;
+    sendSession(sessionId: string, request: ChatRunTurnRequest): Promise<{
+        result: HubScheduleTurnResult;
+    }>;
+    abortSession(sessionId: string): Promise<{
+        applied: boolean;
+    }>;
+    stopSession(sessionId: string): Promise<{
+        applied: boolean;
+    }>;
+}
+export interface ActiveScheduledExecution {
+    executionId: string;
+    scheduleId: string;
+    sessionId: string;
+    startedAt: string;
+    timeoutAt?: string;
+}
+export interface HubScheduleServiceOptions {
+    runtimeHandlers: HubScheduleRuntimeHandlers;
+    eventPublisher?: (eventType: string, payload: unknown) => void;
+    logger?: BasicLogger;
+    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 materializer;
+    private readonly runner;
+    private started;
+    private disposed;
+    constructor(options: HubScheduleServiceOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    dispose(): Promise<void>;
+    createSchedule(input: HubScheduleCreateInput): ScheduleRecord;
+    getSchedule(scheduleId: string): ScheduleRecord | undefined;
+    listSchedules(options?: ListSchedulesOptions): ScheduleRecord[];
+    updateSchedule(scheduleId: string, updates: HubScheduleUpdateInput): ScheduleRecord | undefined;
+    deleteSchedule(scheduleId: string): boolean;
+    pauseSchedule(scheduleId: string): ScheduleRecord | undefined;
+    resumeSchedule(scheduleId: string): ScheduleRecord | undefined;
+    triggerScheduleNow(scheduleId: string): Promise<ScheduleExecutionRecord | undefined>;
+    listScheduleExecutions(options: ListScheduleExecutionsOptions): ScheduleExecutionRecord[];
+    getScheduleStats(scheduleId: string): ScheduleExecutionStats;
+    getActiveExecutions(): ActiveScheduledExecution[];
+    getUpcomingRuns(limit?: number): Array<{
+        scheduleId: string;
+        name: string;
+        nextRunAt: string;
+    }>;
+}
+export {};

package/dist/cron/specs/cron-reconciler.d.ts

@@ -0,0 +1,61 @@
+import type { CronSpecParseResult } from "@cline/shared";
+import { type ResolveCronSpecsDirOptions } from "@cline/shared/storage";
+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:
+ * watcher events are triggers to re-run reconciliation for one file, not a
+ * replacement.
+ */
+export interface CronReconcilerOptions {
+    store: SqliteCronStore;
+    /**
+     * Cron spec source location. Defaults to global `~/.cline/cron`.
+     * Pass `{ scope: "workspace", workspaceRoot }` later to enable
+     * workspace-level cron sources without changing reconciler internals.
+     */
+    specs?: ResolveCronSpecsDirOptions;
+    /** @deprecated Use `specs: { scope: "workspace", workspaceRoot }`. */
+    workspaceRoot?: string;
+}
+export interface ReconcileChange {
+    relativePath: string;
+    result: UpsertSpecResult;
+    parse: CronSpecParseResult;
+}
+export interface ReconcileSummary {
+    scanned: number;
+    upserted: number;
+    invalidParses: number;
+    removed: number;
+    changes: ReconcileChange[];
+}
+export declare class CronReconciler {
+    private readonly store;
+    private readonly cronDir;
+    constructor(options: CronReconcilerOptions);
+    getCronDir(): string;
+    /**
+     * Reconcile every file under the cron specs directory into the DB and mark specs
+     * whose source files no longer exist as `removed=1`.
+     */
+    reconcileAll(): Promise<ReconcileSummary>;
+    /**
+     * Reconcile a single file (absolute path). `relativePath` is expected to
+     * be POSIX-relative to the cron specs directory. Returns the reconciliation change
+     * or undefined if the file could not be read.
+     */
+    reconcileFile(relativePath: string, absolutePath: string): Promise<ReconcileChange | undefined>;
+    /**
+     * Handle a file that disappeared from disk between reconciliations.
+     * Marks the spec as removed and cancels any queued runs for it.
+     */
+    handleFileDeleted(spec: CronSpecRecord): void;
+    /**
+     * Refresh next_run_at for every enabled schedule spec.
+     * Used at startup to handle the "one overdue catch-up on startup then
+     * advance to next slot" policy.
+     */
+    refreshScheduleNextRunAt(): void;
+    private applyScheduleNextRunAt;
+}

package/dist/cron/specs/cron-spec-parser.d.ts

@@ -0,0 +1,26 @@
+import type { CronSpecParseResult, CronTriggerKind } from "@cline/shared";
+/**
+ * Markdown frontmatter parser for `.cline/cron/*.md` automation specs.
+ *
+ * Lives in @cline/core because it depends on `yaml`. The spec types
+ * themselves live in @cline/shared so other packages can consume them
+ * without pulling in a YAML parser.
+ *
+ * The parser never throws for a single bad file — it produces a
+ * `CronSpecParseResult` with an `error` message so the reconciler can record
+ * `parse_status='invalid'` durably instead of dropping state.
+ */
+export declare function inferTriggerKindFromPath(relativePath: string): CronTriggerKind;
+export declare function splitFrontmatter(raw: string): {
+    frontmatter: string | undefined;
+    body: string;
+};
+export declare function computeContentHash(frontmatterJson: unknown, body: string): string;
+export interface ParseCronSpecInput {
+    relativePath: string;
+    raw: string;
+}
+/**
+ * Parse a single cron spec file. Never throws; always returns a result.
+ */
+export declare function parseCronSpecFile(input: ParseCronSpecInput): CronSpecParseResult;

package/dist/cron/specs/cron-watcher.d.ts

@@ -0,0 +1,22 @@
+import type { CronReconciler } from "./cron-reconciler";
+export interface CronWatcherOptions {
+    reconciler: CronReconciler;
+    debounceMs?: number;
+    onError?: (error: unknown) => void;
+    onReconciled?: () => void | Promise<void>;
+}
+export declare class CronWatcher {
+    private readonly reconciler;
+    private readonly debounceMs;
+    private readonly onError;
+    private readonly onReconciled;
+    private watcher?;
+    private readonly pending;
+    private disposed;
+    constructor(options: CronWatcherOptions);
+    start(): void;
+    stop(): void;
+    dispose(): void;
+    private scheduleReconcile;
+    private reconcileNow;
+}

package/dist/cron/store/cron-schema.d.ts

@@ -0,0 +1,2 @@
+import type { SqliteDb } from "@cline/shared/db";
+export declare function ensureCronSchema(db: SqliteDb): void;

package/dist/cron/store/sqlite-cron-store.d.ts

@@ -0,0 +1,240 @@
+import type { AutomationEventEnvelope, CronSpec, CronSpecExtensionKind, CronTriggerKind, HubScheduleCreateInput, HubScheduleUpdateInput } from "@cline/shared";
+/**
+ * Generalized cron/automation store backed by `cron.db`. Sessions stay in
+ * their own database (see @cline/shared `ensureSessionSchema`). cron_runs
+ * here absorb one-off, recurring, and event-driven work under one queue.
+ */
+export type CronRunStatus = "queued" | "running" | "done" | "failed" | "cancelled";
+export type CronRunTriggerKind = "one_off" | "schedule" | "event" | "manual" | "retry";
+export type CronParseStatus = "valid" | "invalid";
+export type CronEventProcessingStatus = "received" | "unmatched" | "queued" | "suppressed" | "failed";
+export interface CronSpecRecord {
+    specId: string;
+    externalId: string;
+    sourcePath: string;
+    triggerKind: CronTriggerKind;
+    sourceMtimeMs?: number;
+    sourceHash?: string;
+    parseStatus: CronParseStatus;
+    parseError?: string;
+    enabled: boolean;
+    removed: boolean;
+    title: string;
+    prompt?: string;
+    workspaceRoot?: string;
+    scheduleExpr?: string;
+    timezone?: string;
+    eventType?: string;
+    filters?: Record<string, unknown>;
+    debounceSeconds?: number;
+    dedupeWindowSeconds?: number;
+    cooldownSeconds?: number;
+    mode?: string;
+    systemPrompt?: string;
+    providerId?: string;
+    modelId?: string;
+    maxIterations?: number;
+    timeoutSeconds?: number;
+    maxParallel?: number;
+    tools?: string[];
+    notesDirectory?: string;
+    extensions?: CronSpecExtensionKind[];
+    source?: string;
+    tags?: string[];
+    metadata?: Record<string, unknown>;
+    revision: number;
+    lastMaterializedRunId?: string;
+    lastRunAt?: string;
+    nextRunAt?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface CronRunRecord {
+    runId: string;
+    specId: string;
+    specRevision: number;
+    triggerKind: CronRunTriggerKind;
+    status: CronRunStatus;
+    claimToken?: string;
+    claimStartedAt?: string;
+    claimUntilAt?: string;
+    scheduledFor?: string;
+    triggerEventId?: string;
+    startedAt?: string;
+    completedAt?: string;
+    sessionId?: string;
+    reportPath?: string;
+    error?: string;
+    attemptCount: number;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface CronEventLogRecord {
+    eventId: string;
+    eventType: string;
+    source: string;
+    subject?: string;
+    occurredAt: string;
+    receivedAt: string;
+    workspaceRoot?: string;
+    dedupeKey?: string;
+    payload?: Record<string, unknown>;
+    attributes?: Record<string, unknown>;
+    processingStatus: CronEventProcessingStatus;
+    matchedSpecCount: number;
+    queuedRunCount: number;
+    suppressedCount: number;
+    error?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface UpsertSpecInput {
+    externalId: string;
+    sourcePath: string;
+    triggerKind: CronTriggerKind;
+    sourceMtimeMs?: number;
+    sourceHash: string;
+    parseStatus: CronParseStatus;
+    parseError?: string;
+    spec?: CronSpec;
+}
+export interface UpsertSpecResult {
+    record: CronSpecRecord;
+    created: boolean;
+    revisionChanged: boolean;
+}
+export interface SqliteCronStoreOptions {
+    dbPath?: string;
+}
+export interface ListSpecsOptions {
+    triggerKind?: CronTriggerKind;
+    enabled?: boolean;
+    parseStatus?: CronParseStatus;
+    includeRemoved?: boolean;
+    limit?: number;
+}
+export interface ListRunsOptions {
+    specId?: string;
+    status?: CronRunStatus | CronRunStatus[];
+    limit?: number;
+}
+export interface ClaimRunOptions {
+    nowIso: string;
+    leaseMs: number;
+    limit?: number;
+}
+export interface ClaimedCronRun {
+    run: CronRunRecord;
+    claimToken: string;
+    claimUntilAt: string;
+}
+interface ClaimBoundUpdate {
+    runId: string;
+    claimToken: string;
+}
+export interface MaterializeScheduleRunResult {
+    queued: boolean;
+    run?: CronRunRecord;
+    nextRunAt?: string;
+}
+export interface EnqueueRunInput {
+    specId: string;
+    specRevision: number;
+    triggerKind: CronRunTriggerKind;
+    scheduledFor?: string;
+    triggerEventId?: string;
+}
+export interface InsertEventLogResult {
+    record: CronEventLogRecord;
+    created: boolean;
+}
+export interface ListEventLogsOptions {
+    eventType?: string;
+    source?: string;
+    processingStatus?: CronEventProcessingStatus;
+    limit?: number;
+}
+export declare class SqliteCronStore {
+    private readonly db;
+    constructor(options?: SqliteCronStoreOptions);
+    close(): void;
+    getSpecBySourcePath(sourcePath: string): CronSpecRecord | undefined;
+    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;
+    private updateSpecRow;
+    markSpecRemoved(specId: string): void;
+    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;
+    }): MaterializeScheduleRunResult;
+    getRun(runId: string): CronRunRecord | undefined;
+    insertEventLog(event: AutomationEventEnvelope, options?: {
+        receivedAtIso?: string;
+    }): InsertEventLogResult;
+    getEventLog(eventId: string): CronEventLogRecord | undefined;
+    listEventLogs(options?: ListEventLogsOptions): CronEventLogRecord[];
+    updateEventLogProcessing(eventId: string, update: {
+        status: CronEventProcessingStatus;
+        matchedSpecCount?: number;
+        queuedRunCount?: number;
+        suppressedCount?: number;
+        error?: string;
+    }): boolean;
+    listRuns(options?: ListRunsOptions): CronRunRecord[];
+    hasRecentEventRunForDedupe(options: {
+        specId: string;
+        dedupeKey: string;
+        sinceIso: string;
+    }): boolean;
+    hasRecentEventRunForSpec(options: {
+        specId: string;
+        sinceIso: string;
+    }): boolean;
+    findQueuedEventRunForDedupe(options: {
+        specId: string;
+        dedupeKey: string;
+    }): CronRunRecord | undefined;
+    updateQueuedEventRunForDebounce(options: {
+        runId: string;
+        triggerEventId: string;
+        scheduledFor: string;
+    }): CronRunRecord | undefined;
+    hasOneOffRunForRevision(specId: string, revision: number): boolean;
+    enqueueRun(input: EnqueueRunInput): CronRunRecord;
+    cancelQueuedRunsForSpec(specId: string): number;
+    claimDueRuns(options: ClaimRunOptions): ClaimedCronRun[];
+    renewClaim(runId: string, claimToken: string, leaseUntilAt: string): boolean;
+    completeRun(runId: string, update: {
+        status: "done" | "failed" | "cancelled";
+        sessionId?: string;
+        reportPath?: string;
+        error?: string;
+        completedAtIso?: string;
+        claimToken?: string;
+    }): boolean;
+    requeueRun(update: ClaimBoundUpdate & {
+        error?: string;
+        scheduledFor?: string;
+    }): boolean;
+    attachSessionIdToRun(runId: string, sessionId: string): void;
+    attachReportPathToRun(runId: string, reportPath: string): void;
+}
+export {};

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

@@ -0,0 +1,7 @@
+export type { AvailableRuntimeCommand, RuntimeCommandKind, } 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, 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

@@ -0,0 +1,11 @@
+import type { UserInstructionConfigWatcher } from "./user-instruction-config-loader";
+export type RuntimeCommandKind = "skill" | "workflow";
+export type AvailableRuntimeCommand = {
+    id: string;
+    name: string;
+    instructions: string;
+    description?: string;
+    kind: RuntimeCommandKind;
+};
+export declare function listAvailableRuntimeCommandsFromWatcher(watcher: UserInstructionConfigWatcher): AvailableRuntimeCommand[];
+export declare function resolveRuntimeSlashCommandFromWatcher(input: string, watcher: UserInstructionConfigWatcher): string;

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>;