@cline/core 0.0.38-nightly.1778113663

package/dist/types/config.d.ts

@@ -0,0 +1,167 @@
+import type { ModelInfo } from "@cline/llms";
+import type { AgentConfig, AgentHooks, AgentMode, AgentTool, BasicLogger, ConsecutiveMistakeLimitContext, ConsecutiveMistakeLimitDecision, ExtensionContext, HookErrorMode, ITelemetryService, MessageWithMetadata, SessionExecutionConfig, SessionPromptConfig, SessionWorkspaceConfig } from "@cline/shared";
+import type { ToolRoutingRule } from "../extensions/tools/model-tool-routing";
+import type { TeamEvent } from "../extensions/tools/team";
+import type { ProviderConfig } from "./provider-settings";
+export type CoreAgentMode = AgentMode;
+export interface CoreModelConfig {
+    providerId: string;
+    modelId: string;
+    apiKey?: string;
+    baseUrl?: string;
+    headers?: Record<string, string>;
+    providerConfig?: ProviderConfig;
+    knownModels?: Record<string, ModelInfo>;
+    /**
+     * Request model-side thinking/reasoning when supported.
+     */
+    thinking?: boolean;
+    /**
+     * Explicit reasoning effort override for capable models.
+     */
+    reasoningEffort?: ProviderConfig["reasoningEffort"];
+}
+export interface CoreRuntimeFeatures {
+    enableTools: boolean;
+    enableSpawnAgent: boolean;
+    enableAgentTeams: boolean;
+    disableMcpSettingsTools?: boolean;
+    yolo?: boolean;
+}
+export interface CoreCompactionContext {
+    agentId: string;
+    conversationId: string;
+    parentAgentId: string | null;
+    iteration: number;
+    messages: MessageWithMetadata[];
+    model: {
+        id: string;
+        provider: string;
+        info?: ModelInfo;
+    };
+    contextWindowTokens: number;
+    triggerTokens: number;
+    thresholdRatio: number;
+    utilizationRatio: number;
+}
+export interface CoreCompactionResult {
+    messages: MessageWithMetadata[];
+}
+export interface CoreCompactionSummarizerConfig {
+    providerId: string;
+    modelId: string;
+    apiKey?: string;
+    baseUrl?: string;
+    headers?: Record<string, string>;
+    knownModels?: Record<string, ModelInfo>;
+    providerConfig?: ProviderConfig;
+    maxOutputTokens?: number;
+}
+export type CoreCompactionStrategy = "basic" | "agentic";
+export interface CoreCompactionConfig {
+    enabled?: boolean;
+    strategy?: CoreCompactionStrategy;
+    thresholdRatio?: number;
+    reserveTokens?: number;
+    preserveRecentTokens?: number;
+    contextWindowTokens?: number;
+    summarizer?: CoreCompactionSummarizerConfig;
+    compact?: (context: CoreCompactionContext) => Promise<CoreCompactionResult | undefined> | CoreCompactionResult | undefined;
+}
+/**
+ * Context passed to a custom `createCheckpoint` implementation.
+ */
+export interface CoreCheckpointContext {
+    /** Absolute path to the working directory of the session. */
+    cwd: string;
+    /** The session identifier. */
+    sessionId: string;
+    /** Monotonically increasing run counter for this session (starts at 1). */
+    runCount: number;
+}
+/**
+ * Configuration for the built-in git-based checkpoint feature.
+ *
+ * Checkpoints capture a restorable snapshot of the workspace at the start of
+ * each root-agent run so that changes made during a session can be rolled back.
+ *
+ * @example Disable checkpoints entirely:
+ * ```ts
+ * checkpoint: { enabled: false }
+ * ```
+ *
+ * @example Bring your own checkpoint implementation:
+ * ```ts
+ * checkpoint: {
+ *   createCheckpoint: async ({ cwd, sessionId, runCount }) => {
+ *     const ref = await mySnapshotFn(cwd);
+ *     return { ref, createdAt: Date.now(), runCount };
+ *   },
+ * }
+ * ```
+ */
+export interface CoreCheckpointConfig {
+    /**
+     * Whether to create checkpoints on each root-agent run start.
+     * Defaults to `false` — checkpoints are **opt-in**. Set to `true` to
+     * enable the built-in git stash/ref checkpoint behaviour for this session.
+     */
+    enabled?: boolean;
+    /**
+     * Replace the built-in git stash/ref checkpoint logic with a custom
+     * implementation. Called once at the start of each root-agent run (before
+     * the first agent iteration).
+     *
+     * Return an object with at least `ref`, `createdAt`, and `runCount` to have
+     * the entry recorded in session metadata, or return `undefined` to skip
+     * writing a checkpoint for that run.
+     */
+    createCheckpoint?: (context: CoreCheckpointContext) => Promise<{
+        ref: string;
+        createdAt: number;
+        runCount: number;
+        kind?: "stash" | "commit";
+    } | undefined> | {
+        ref: string;
+        createdAt: number;
+        runCount: number;
+        kind?: "stash" | "commit";
+    } | undefined;
+}
+export interface CoreSessionConfig extends CoreModelConfig, CoreRuntimeFeatures, Omit<SessionWorkspaceConfig, "workspaceRoot">, Omit<SessionPromptConfig, "systemPrompt">, Omit<SessionExecutionConfig, "enableTools" | "teamName" | "missionLogIntervalSteps" | "missionLogIntervalMs" | "maxConsecutiveMistakes"> {
+    /**
+     * Core/hub runtime session identifier.
+     *
+     * When provided, this becomes the host-owned id for persistence, hub
+     * subscriptions, send/abort/stop commands, and approval routing. When
+     * omitted, the runtime host creates one. This is distinct from the agent
+     * conversation id, which is generated by the conversation store for
+     * transcript/tool/hook context.
+     */
+    sessionId?: string;
+    workspaceRoot?: string;
+    systemPrompt: string;
+    teamName?: string;
+    missionLogIntervalSteps?: number;
+    missionLogIntervalMs?: number;
+    hooks?: AgentHooks;
+    hookErrorMode?: HookErrorMode;
+    logger?: BasicLogger;
+    telemetry?: ITelemetryService;
+    extensionContext?: ExtensionContext;
+    extraTools?: AgentTool[];
+    pluginPaths?: string[];
+    extensions?: AgentConfig["extensions"];
+    execution?: AgentConfig["execution"];
+    compaction?: CoreCompactionConfig;
+    checkpoint?: CoreCheckpointConfig;
+    onTeamEvent?: (event: TeamEvent) => void;
+    onConsecutiveMistakeLimitReached?: (context: ConsecutiveMistakeLimitContext) => Promise<ConsecutiveMistakeLimitDecision> | ConsecutiveMistakeLimitDecision;
+    toolRoutingRules?: ToolRoutingRule[];
+    /**
+     * Optional skill allowlist for the `skills` tool. When provided, only these
+     * skills are surfaced in tool metadata and invocable by name.
+     */
+    skills?: string[];
+    workspaceMetadata?: string;
+}

package/dist/types/events.d.ts

@@ -0,0 +1,89 @@
+import type { CoreSessionSnapshot } from "../session/session-snapshot";
+export interface SessionChunkEvent {
+    sessionId: string;
+    stream: "stdout" | "stderr" | "agent";
+    chunk: string;
+    ts: number;
+}
+export interface SessionEndedEvent {
+    sessionId: string;
+    reason: string;
+    ts: number;
+}
+export interface SessionToolEvent {
+    sessionId: string;
+    hookEventName: "tool_call" | "tool_result" | "agent_end" | "agent_error" | "session_shutdown";
+    agentId?: string;
+    conversationId?: string;
+    parentAgentId?: string;
+    iteration?: number;
+    toolName?: string;
+    inputTokens?: number;
+    outputTokens?: number;
+    ts?: string;
+}
+export interface SessionTeamProgressEvent {
+    sessionId: string;
+    teamName: string;
+    lifecycle: import("@cline/shared").TeamProgressLifecycleEvent;
+    summary: import("@cline/shared").TeamProgressSummary;
+}
+export interface SessionPendingPrompt {
+    id: string;
+    prompt: string;
+    delivery: "queue" | "steer";
+    attachmentCount: number;
+}
+export interface SessionPendingPromptsEvent {
+    sessionId: string;
+    prompts: SessionPendingPrompt[];
+}
+export interface SessionPendingPromptSubmittedEvent {
+    sessionId: string;
+    id: string;
+    prompt: string;
+    delivery: "queue" | "steer";
+    attachmentCount: number;
+}
+export interface SessionSnapshotEvent {
+    sessionId: string;
+    snapshot: CoreSessionSnapshot;
+}
+export type CoreSessionEvent = {
+    type: "chunk";
+    payload: SessionChunkEvent;
+} | {
+    type: "agent_event";
+    payload: {
+        sessionId: string;
+        event: import("@cline/shared").AgentEvent;
+        /** Identifies the named agent within the team (e.g. "educator", "assessor", "coordinator") for both lead and teammate agents */
+        teamAgentId?: string;
+        /** Whether this is the lead agent or a teammate */
+        teamRole?: "lead" | "teammate";
+    };
+} | {
+    type: "team_progress";
+    payload: SessionTeamProgressEvent;
+} | {
+    type: "pending_prompts";
+    payload: SessionPendingPromptsEvent;
+} | {
+    type: "pending_prompt_submitted";
+    payload: SessionPendingPromptSubmittedEvent;
+} | {
+    type: "session_snapshot";
+    payload: SessionSnapshotEvent;
+} | {
+    type: "ended";
+    payload: SessionEndedEvent;
+} | {
+    type: "hook";
+    payload: SessionToolEvent;
+} | {
+    type: "status";
+    payload: {
+        sessionId: string;
+        status: string;
+    };
+};

package/dist/types/provider-settings.d.ts

@@ -0,0 +1,19 @@
+import { z } from "zod";
+import { type ProviderClient, type ProviderConfig, type ProviderProtocol, type ProviderSettings, type ToProviderConfigOptions, toProviderConfig } from "../services/llms/provider-settings";
+export type { ProviderClient, ProviderConfig, ProviderProtocol, ProviderSettings, ToProviderConfigOptions, };
+export declare const ProviderSettingsSchemaTyped: z.ZodType<ProviderSettings>;
+export { toProviderConfig };
+export type ProviderTokenSource = "manual" | "oauth" | "migration";
+export interface StoredProviderSettingsEntry {
+    settings: ProviderSettings;
+    updatedAt: string;
+    tokenSource: ProviderTokenSource;
+}
+export interface StoredProviderSettings {
+    version: 1;
+    lastUsedProvider?: string;
+    providers: Record<string, StoredProviderSettingsEntry>;
+}
+export declare const StoredProviderSettingsEntrySchema: z.ZodType<StoredProviderSettingsEntry>;
+export declare const StoredProviderSettingsSchema: z.ZodType<StoredProviderSettings>;
+export declare function emptyStoredProviderSettings(): StoredProviderSettings;

package/dist/types/session.d.ts

@@ -0,0 +1,116 @@
+import type * as LlmsProviders from "@cline/llms";
+import type { SessionAccumulatedUsage } from "../runtime/host/runtime-host";
+import type { BuiltRuntime } from "../runtime/orchestration/session-runtime";
+import type { SessionRuntime } from "../runtime/orchestration/session-runtime-orchestrator";
+import type { SessionRow } from "../session/models/session-row";
+import type { RootSessionArtifacts } from "../session/services/session-service";
+import type { SessionSource, SessionStatus } from "./common";
+import type { CoreSessionConfig } from "./config";
+export type ActiveSession = {
+    sessionId: string;
+    config: CoreSessionConfig;
+    sessionMetadata?: Record<string, unknown>;
+    artifacts?: RootSessionArtifacts;
+    source: SessionSource;
+    startedAt: string;
+    updatedAt: string;
+    status: SessionStatus;
+    endedAt?: string | null;
+    exitCode?: number | null;
+    pendingPrompt?: string;
+    runtime: BuiltRuntime;
+    agent: SessionRuntime;
+    started: boolean;
+    aborting: boolean;
+    interactive: boolean;
+    persistedMessages?: LlmsProviders.MessageWithMetadata[];
+    activeTeamRunIds: Set<string>;
+    pendingTeamRunUpdates: TeamRunUpdate[];
+    teamRunWaiters: Array<() => void>;
+    pendingPrompts: PendingPrompt[];
+    drainingPendingPrompts: boolean;
+    pluginSandboxShutdown?: () => Promise<void>;
+    turnUsageBaseline?: SessionAccumulatedUsage;
+    /**
+     * Set to `true` once the assistant successfully invoked the canonical
+     * completion tool (`submit_and_exit`) for this session. Used to:
+     *
+     * 1. Emit `task.completed` exactly once at the moment the assistant
+     *    declares completion (parity with original Cline's
+     *    `attempt_completion`).
+     * 2. Suppress the fallback `task.completed` emission from
+     *    `shutdownSession(...)` so the same logical completion is not
+     *    reported twice.
+     *
+     * Non-interactive sessions that finish without ever calling the
+     * completion tool still receive a `task.completed` from the shutdown
+     * fallback.
+     */
+    submitAndExitObserved: boolean;
+};
+export type PendingPrompt = {
+    id: string;
+    prompt: string;
+    delivery: "queue" | "steer";
+    userImages?: string[];
+    userFiles?: string[];
+};
+export type TeamRunUpdate = {
+    runId: string;
+    agentId: string;
+    taskId?: string;
+    status: "completed" | "failed" | "cancelled" | "interrupted";
+    error?: string;
+    iterations?: number;
+};
+export type StoredMessageWithMetadata = LlmsProviders.MessageWithMetadata;
+export type PreparedTurnInput = {
+    prompt: string;
+    userImages?: string[];
+    userFiles?: string[];
+};
+export interface PersistedSessionUpdateInput {
+    sessionId: string;
+    expectedStatusLock?: number;
+    status?: SessionStatus;
+    endedAt?: string | null;
+    exitCode?: number | null;
+    prompt?: string | null;
+    metadata?: Record<string, unknown> | null;
+    title?: string | null;
+    parentSessionId?: string | null;
+    parentAgentId?: string | null;
+    agentId?: string | null;
+    conversationId?: string | null;
+    setRunning?: boolean;
+}
+export interface SessionPersistenceAdapter {
+    ensureSessionsDir(): string;
+    upsertSession(row: SessionRow): Promise<void>;
+    getSession(sessionId: string): Promise<SessionRow | undefined>;
+    listSessions(options: {
+        limit: number;
+        parentSessionId?: string;
+        status?: string;
+    }): Promise<SessionRow[]>;
+    updateSession(input: PersistedSessionUpdateInput): Promise<{
+        updated: boolean;
+        statusLock: number;
+    }>;
+    deleteSession(sessionId: string, cascade: boolean): Promise<boolean>;
+    enqueueSpawnRequest(input: {
+        rootSessionId: string;
+        parentAgentId: string;
+        task?: string;
+        systemPrompt?: string;
+    }): Promise<void>;
+    claimSpawnRequest(rootSessionId: string, parentAgentId: string): Promise<string | undefined>;
+}
+export interface SessionMessagesArtifactUploader {
+    uploadMessagesFile(input: {
+        sessionId: string;
+        path: string;
+        contents: string;
+        row?: SessionRow;
+    }): Promise<void>;
+}

package/dist/types/sessions.d.ts

@@ -0,0 +1,28 @@
+import type { SessionLineage, SessionRuntimeRecordShape } from "@cline/shared";
+import type { SessionSource, SessionStatus } from "./common";
+export interface SessionRef extends SessionLineage {
+    sessionId: string;
+}
+export interface SessionRecord extends SessionRef, Omit<SessionRuntimeRecordShape, "source" | "status"> {
+    source: SessionSource;
+    status: SessionStatus;
+}
+export interface SessionHistoryMetadata extends Record<string, unknown> {
+    title?: string;
+    totalCost?: number;
+    checkpoint?: {
+        latest?: {
+            ref?: string;
+            createdAt?: number;
+            runCount?: number;
+        };
+        history?: Array<{
+            ref?: string;
+            createdAt?: number;
+            runCount?: number;
+        }>;
+    };
+}
+export interface SessionHistoryRecord extends Omit<SessionRecord, "metadata"> {
+    metadata?: SessionHistoryMetadata;
+}

package/dist/types/storage.d.ts

@@ -0,0 +1,36 @@
+import type { TeamRuntimeState, TeamTeammateSpec } from "@cline/shared";
+import type { TeamEvent } from "../extensions/tools/team";
+import type { SessionStatus } from "./common";
+import type { SessionRecord } from "./sessions";
+export interface SessionStore {
+    init(): Promise<void> | void;
+    create(record: SessionRecord): Promise<void> | void;
+    updateStatus(sessionId: string, status: SessionStatus, exitCode?: number | null): Promise<void> | void;
+    update(record: Partial<SessionRecord> & {
+        sessionId: string;
+    }): Promise<void> | void;
+    get(sessionId: string): Promise<SessionRecord | undefined> | SessionRecord | undefined;
+    list(limit?: number): Promise<SessionRecord[]> | SessionRecord[];
+    delete(sessionId: string, cascade?: boolean): Promise<boolean> | boolean;
+}
+export interface TeamStore {
+    listTeamNames(): Promise<string[]> | string[];
+    readState(teamName: string): Promise<TeamRuntimeState | undefined> | TeamRuntimeState | undefined;
+    readHistory(teamName: string, limit?: number): Promise<unknown[]> | unknown[];
+    loadRuntime(teamName: string): Promise<{
+        state?: TeamRuntimeState;
+        teammates: TeamTeammateSpec[];
+        interruptedRunIds: string[];
+    }> | {
+        state?: TeamRuntimeState;
+        teammates: TeamTeammateSpec[];
+        interruptedRunIds: string[];
+    };
+    handleTeamEvent(teamName: string, event: TeamEvent): Promise<void> | void;
+    persistRuntime(teamName: string, state: TeamRuntimeState, teammates: TeamTeammateSpec[]): Promise<void> | void;
+    markInProgressRunsInterrupted(teamName: string, reason: string): Promise<string[]> | string[];
+}
+export interface ArtifactStore {
+    appendHook(sessionId: string, payload: unknown): Promise<void> | void;
+    writeMessages(sessionId: string, messages: unknown[]): Promise<void> | void;
+}

package/dist/types.d.ts

@@ -0,0 +1,32 @@
+export type { AgentRunResult, AgentRunStatus, WorkspaceInfo, WorkspaceManifest, } from "@cline/shared";
+export { ClineCore } from "./ClineCore";
+export type { ClineCoreListHistoryOptions, ClineCoreOptions, ClineCoreStartInput, HubOptions, RemoteOptions, } from "./cline-core/types";
+export type { LoadAgentPluginFromPathOptions, ResolveAgentPluginPathsOptions, } from "./extensions";
+export { discoverPluginModulePaths, loadAgentPluginFromPath, loadAgentPluginsFromPaths, resolveAgentPluginPaths, resolveAndLoadAgentPlugins, resolvePluginConfigSearchPaths, } from "./extensions";
+export type { CreateInstructionWatcherOptions, CreateRulesConfigDefinitionOptions, CreateSkillsConfigDefinitionOptions, CreateUserInstructionConfigServiceOptions, CreateWorkflowsConfigDefinitionOptions, ParseMarkdownFrontmatterResult, RuleConfig, SkillConfig, UnifiedConfigDefinition, UnifiedConfigFileCandidate, UnifiedConfigFileContext, UnifiedConfigRecord, UnifiedConfigWatcherEvent, UnifiedConfigWatcherOptions, UserInstructionConfig, UserInstructionConfigRecord, UserInstructionConfigService, UserInstructionConfigType, WorkflowConfig, } from "./extensions/config";
+export { createRulesConfigDefinition, createSkillsConfigDefinition, createUserInstructionConfigService, createWorkflowsConfigDefinition, parseRuleConfigFromMarkdown, parseSkillConfigFromMarkdown, parseWorkflowConfigFromMarkdown, RULES_CONFIG_DIRECTORY_NAME, resolveRulesConfigSearchPaths, resolveSkillsConfigSearchPaths, resolveWorkflowsConfigSearchPaths, SKILLS_CONFIG_DIRECTORY_NAME, UnifiedConfigFileWatcher, WORKFLOWS_CONFIG_DIRECTORY_NAME, } from "./extensions/config";
+export type { BuiltinToolAvailabilityContext, ToolCatalogEntry, } from "./extensions/tools";
+export { getCoreAcpToolNames, getCoreBuiltinToolCatalog, getCoreDefaultEnabledToolIds, getCoreHeadlessToolNames, resolveCoreSelectedToolIds, TEAM_TOOL_NAMES, } from "./extensions/tools";
+export type { RuntimeCapabilities } from "./runtime/capabilities";
+export type { SessionBackend } from "./runtime/host/host";
+export type { PendingPromptMutationResult, PendingPromptsDeleteInput, PendingPromptsListInput, PendingPromptsRuntimeService, PendingPromptsServiceApi, PendingPromptsUpdateInput, RuntimeHost, RuntimeHost as SessionHost, RuntimeHostMode, SendSessionInput, SessionAccumulatedUsage, StartSessionInput, StartSessionResult, } from "./runtime/host/runtime-host";
+export type { BuiltRuntime as RuntimeEnvironment, RuntimeBuilder, RuntimeBuilderInput, SessionRuntime, } from "./runtime/orchestration/session-runtime";
+export type { SandboxCallOptions, SubprocessSandboxOptions, } from "./runtime/tools/subprocess-sandbox";
+export { SubprocessSandbox } from "./runtime/tools/subprocess-sandbox";
+export type { GlobalSettings } from "./services/global-settings";
+export { filterDisabledPluginPaths, filterDisabledTools, filterExtensionToolRegistrations, GlobalSettingsSchema, isPluginDisabledGlobally, isTelemetryOptedOutGlobally, isToolDisabledGlobally, readGlobalSettings, resolveDisabledPluginPaths, resolveDisabledToolNames, setDisabledPlugin, setDisabledTools, setTelemetryOptOutGlobally, toggleDisabledTool, writeGlobalSettings, } from "./services/global-settings";
+export type { PluginToolSummary } from "./services/plugin-tools";
+export { listPluginTools } from "./services/plugin-tools";
+export type { WorkspaceManager, WorkspaceManagerEvent, } from "./services/workspace/workspace-manager";
+export type { SessionManifest } from "./session/models/session-manifest";
+export type { SessionRow } from "./session/models/session-row";
+export type { CreateRootSessionWithArtifactsInput, RootSessionArtifacts, } from "./session/services/session-service";
+export type { CoreSessionCheckpointSnapshot, CoreSessionSnapshot, } from "./session/session-snapshot";
+export type { SessionCheckpointRestoreContext, SessionCheckpointRestoreResult, SessionVersioningErrorCode, } from "./session/session-versioning-service";
+export type { ChatMessage, ChatSessionConfig, ChatSessionStatus, ChatSummary, ChatViewState, } from "./types/chat-schema";
+export type { SessionSource, SessionStatus } from "./types/common";
+export type { CoreAgentMode, CoreModelConfig, CoreRuntimeFeatures, CoreSessionConfig, } from "./types/config";
+export type { CoreSessionEvent, SessionChunkEvent, SessionEndedEvent, SessionPendingPrompt, SessionPendingPromptSubmittedEvent, SessionPendingPromptsEvent, SessionTeamProgressEvent, SessionToolEvent, } from "./types/events";
+export type { SessionMessagesArtifactUploader } from "./types/session";
+export type { SessionHistoryMetadata, SessionHistoryRecord, SessionRecord, SessionRef, } from "./types/sessions";
+export type { ArtifactStore, SessionStore, TeamStore } from "./types/storage";

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare const CORE_BUILD_VERSION: string;

package/package.json

@@ -0,0 +1,83 @@
+{
+	"name": "@cline/core",
+	"description": "Cline Core SDK for Node Runtime",
+	"version": "0.0.38-nightly.1778113663",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/cline/sdk",
+		"directory": "packages/core"
+	},
+	"type": "module",
+	"types": "./dist/index.d.ts",
+	"main": "./dist/index.js",
+	"private": false,
+	"publishConfig": {
+		"access": "public"
+	},
+	"exports": {
+		".": {
+			"development": "./src/index.ts",
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js"
+		},
+		"./hub": {
+			"development": "./src/hub/index.ts",
+			"types": "./dist/hub/index.d.ts",
+			"import": "./dist/hub/index.js"
+		},
+		"./hub/daemon-entry": {
+			"development": "./src/hub/daemon/entry.ts",
+			"types": "./dist/hub/daemon/entry.d.ts",
+			"import": "./dist/hub/daemon/entry.js"
+		},
+		"./telemetry": {
+			"development": "./src/services/telemetry/index.ts",
+			"types": "./dist/services/telemetry/index.d.ts",
+			"import": "./dist/services/telemetry/index.js"
+		}
+	},
+	"scripts": {
+		"build": "rm -rf dist && bun run ./bun.mts && bun tsc -p tsconfig.build.json",
+		"clean": "rm -rf dist node_modules",
+		"typecheck": "bun tsc -p tsconfig.dev.json --noEmit && bun run typecheck:smoke",
+		"typecheck:smoke": "bun tsc -p tsconfig.smoke.json --noEmit",
+		"test": "bun run test:unit && bun run test:e2e",
+		"test:unit": "vitest run --config vitest.config.ts",
+		"test:e2e": "vitest run --config vitest.e2e.config.ts",
+		"verify:routines": "zsh -lc 'bunx vitest run src/cron/schedule-service.test.ts --config vitest.config.ts'",
+		"test:watch": "vitest --config vitest.config.ts"
+	},
+	"dependencies": {
+		"@cline/agents": "0.0.38-nightly.1778113663",
+		"@cline/shared": "0.0.38-nightly.1778113663",
+		"@cline/llms": "0.0.38-nightly.1778113663",
+		"@opentelemetry/api": "^1.9.0",
+		"@opentelemetry/api-logs": "^0.214.0",
+		"@opentelemetry/exporter-logs-otlp-http": "^0.214.0",
+		"@opentelemetry/exporter-metrics-otlp-http": "^0.214.0",
+		"@opentelemetry/exporter-trace-otlp-http": "^0.214.0",
+		"@opentelemetry/resources": "^2.6.1",
+		"@opentelemetry/sdk-logs": "^0.214.0",
+		"@opentelemetry/sdk-metrics": "^2.6.1",
+		"@opentelemetry/sdk-trace-base": "^2.6.1",
+		"@opentelemetry/sdk-trace-node": "^2.6.1",
+		"@opentelemetry/semantic-conventions": "^1.40.0",
+		"jiti": "^1.21.7",
+		"node-machine-id": "^1.1.12",
+		"nanoid": "^5.1.7",
+		"simple-git": "^3.32.3",
+		"ws": "^8.20.0",
+		"yaml": "^2.8.2",
+		"zod": "^4.3.6"
+	},
+	"devDependencies": {
+		"@types/ws": "^8.18.1"
+	},
+	"engines": {
+		"node": ">=22"
+	},
+	"files": [
+		"dist",
+		"!dist/**/*.d.ts.map"
+	]
+}