@clinebot/core 0.0.37 → 0.0.38

package/dist/session/{message-builder.d.ts → services/message-builder.d.ts}

@@ -4,9 +4,9 @@
  * @see PLAN.md §3.1 — moved from `packages/agents/src/context/message-builder.ts`.
  * @see PLAN.md §3.2.3 — public surface of `MessageBuilder`.
  *
- * Verbatim port: walks the conversation to produce provider-ready
- * messages, handles tool-result truncation and outdated-file-content
- * rewrite for compaction. Per-instance caches make this host state.
+ * Walks the conversation to produce provider-ready messages, handling
+ * tool-result truncation and outdated-file-content rewrite for compaction.
+ * Per-instance caches make this host state.
  */
 import type * as LlmsProviders from "@clinebot/llms";
 /**
@@ -25,11 +25,13 @@ export declare class MessageBuilder {
     private readResultLocatorCache;
     constructor(maxToolResultChars?: number, targetToolNames?: Set<string>, maxTotalTextBytes?: number);
     buildForApi(messages: LlmsProviders.Message[]): LlmsProviders.Message[];
+    private transformBlock;
     private reindex;
     private resetIndexes;
-    private getReadResultRecord;
+    private getReadLocators;
     private extractLocatorsFromReadToolInput;
     private extractReadLocatorsFromToolResultContent;
+    private tryParseReadLocators;
     private extractLocatorsFromParsedReadResult;
     private extractLocatorFromReadRequest;
     private extractLocatorFromResultEntry;
@@ -40,14 +42,9 @@ export declare class MessageBuilder {
     private toReadLocatorKey;
     private isFullFileRead;
     private isOutdatedReadLocator;
-    private toFileBlockOwnerKey;
     private replaceOutdatedReadContent;
     private countOutdatedImageEntries;
-    private countOutdatedImageEntriesInParsed;
-    private countOutdatedImageEntriesInEntry;
-    private isImageReadSummaryEntry;
-    private replaceOutdatedReadContentInString;
-    private replaceOutdatedReadContentInParsed;
+    private replaceOutdatedInString;
     private replaceOutdatedReadEntry;
     private isReadTool;
     private shouldTruncateTool;
@@ -55,11 +52,5 @@ export declare class MessageBuilder {
     private truncateMiddle;
     private truncateToTotalTextBudget;
     private countMessageTextBytes;
-    private countToolResultTextBytes;
     private collectTruncationCandidates;
-    private truncateMiddleToLength;
-    private truncateMiddleToBytes;
-    private utf8ByteLength;
-    private cloneContentBlockForMutation;
 }
-//# sourceMappingURL=message-builder.d.ts.map

package/dist/session/{persistence-service.d.ts → services/persistence-service.d.ts}

@@ -1,15 +1,15 @@
 import type * as LlmsProviders from "@clinebot/llms";
 import type { AgentResult } from "@clinebot/shared";
-import type { SubAgentEndContext, SubAgentStartContext } from "../extensions/tools/team";
-import type { HookEventPayload } from "../hooks";
-import type { SessionStatus } from "../types/common";
-import type { PersistedSessionUpdateInput, SessionMessagesArtifactUploader, SessionPersistenceAdapter } from "../types/session";
-import type { SessionRow } from "./session-row";
+import type { SubAgentEndContext, SubAgentStartContext } from "../../extensions/tools/team";
+import type { HookEventPayload } from "../../hooks";
+import type { SessionStatus } from "../../types/common";
+import type { PersistedSessionUpdateInput, SessionMessagesArtifactUploader, SessionPersistenceAdapter } from "../../types/session";
+import type { SessionRow } from "../models/session-row";
 export type { PersistedSessionUpdateInput, SessionPersistenceAdapter };
 export declare class UnifiedSessionPersistenceService {
     private readonly adapter;
     private readonly manifestStore;
-    private readonly subagents;
+    private readonly teamChildren;
     private static readonly STALE_REASON;
     private static readonly STALE_SOURCE;
     private static readonly TEAM_HEARTBEAT_LOG_INTERVAL_MS;
@@ -18,9 +18,9 @@ export declare class UnifiedSessionPersistenceService {
     });
     private toPersistedMessages;
     ensureSessionsDir(): string;
-    writeSessionManifest(manifestPath: string, manifest: import("./session-manifest").SessionManifest): void;
-    readSessionManifest(sessionId: string): import("./session-manifest").SessionManifest | undefined;
-    createRootSessionWithArtifacts(input: import("./session-row").CreateRootSessionWithArtifactsInput): Promise<import("./session-row").RootSessionArtifacts>;
+    writeSessionManifest(manifestPath: string, manifest: import("../models/session-manifest").SessionManifest): void;
+    readSessionManifest(sessionId: string): import("../models/session-manifest").SessionManifest | undefined;
+    createRootSessionWithArtifacts(input: import("../models/session-row").CreateRootSessionWithArtifactsInput): Promise<import("../models/session-row").RootSessionArtifacts>;
     updateSessionStatus(sessionId: string, status: SessionStatus, exitCode?: number | null): Promise<{
         updated: boolean;
         endedAt?: string;
@@ -34,7 +34,7 @@ export declare class UnifiedSessionPersistenceService {
         updated: boolean;
     }>;
     queueSpawnRequest(event: HookEventPayload): Promise<void>;
-    upsertSubagentSession(input: import("./session-row").UpsertSubagentInput): Promise<string | undefined>;
+    upsertSubagentSession(input: import("../models/session-row").UpsertSubagentInput): Promise<string | undefined>;
     upsertSubagentSessionFromHook(event: HookEventPayload): Promise<string | undefined>;
     appendSubagentHookAudit(_subSessionId: string, event: HookEventPayload): Promise<void>;
     persistSessionMessages(sessionId: string, messages: LlmsProviders.Message[], systemPrompt?: string): Promise<void>;
@@ -56,4 +56,3 @@ export declare class UnifiedSessionPersistenceService {
         deleted: boolean;
     }>;
 }
-//# sourceMappingURL=persistence-service.d.ts.map

package/dist/session/{session-service.d.ts → services/session-service.d.ts}

@@ -1,7 +1,7 @@
-import type { SqliteSessionStore } from "../services/storage/sqlite-session-store";
-import type { SessionMessagesArtifactUploader } from "../types/session";
+import type { SqliteSessionStore } from "../../services/storage/sqlite-session-store";
+import type { SessionMessagesArtifactUploader } from "../../types/session";
+import { type CreateRootSessionInput } from "../models/session-row";
 import { UnifiedSessionPersistenceService } from "./persistence-service";
-import { type CreateRootSessionInput } from "./session-row";
 export declare class CoreSessionService extends UnifiedSessionPersistenceService {
     private readonly store;
     constructor(store: SqliteSessionStore, options?: {
@@ -10,5 +10,4 @@ export declare class CoreSessionService extends UnifiedSessionPersistenceService
     });
     createRootSession(input: CreateRootSessionInput): void;
 }
-export type { CreateRootSessionInput, CreateRootSessionWithArtifactsInput, RootSessionArtifacts, SessionRow, UpsertSubagentInput, } from "./session-row";
-//# sourceMappingURL=session-service.d.ts.map
+export type { CreateRootSessionInput, CreateRootSessionWithArtifactsInput, RootSessionArtifacts, SessionRow, UpsertSubagentInput, } from "../models/session-row";

package/dist/session/session-snapshot.d.ts

@@ -0,0 +1,57 @@
+import type * as LlmsProviders from "@clinebot/llms";
+import type { CheckpointEntry } from "../hooks/checkpoint-hooks";
+import type { SessionAccumulatedUsage } from "../runtime/host/runtime-host";
+import type { SessionRecord } from "../types/sessions";
+export interface CoreSessionCheckpointSnapshot {
+    enabled?: boolean;
+    latest?: CheckpointEntry;
+    history: CheckpointEntry[];
+}
+export interface CoreSessionSnapshot {
+    version: 1;
+    sessionId: string;
+    source: SessionRecord["source"];
+    status: SessionRecord["status"];
+    createdAt: string;
+    updatedAt: string;
+    endedAt?: string | null;
+    exitCode?: number | null;
+    interactive: boolean;
+    workspace: {
+        cwd: string;
+        root: string;
+    };
+    model: {
+        providerId: string;
+        modelId: string;
+    };
+    capabilities: {
+        enableTools: boolean;
+        enableSpawn: boolean;
+        enableTeams: boolean;
+    };
+    lineage: {
+        parentSessionId?: string;
+        parentAgentId?: string;
+        agentId?: string;
+        conversationId?: string;
+        isSubagent: boolean;
+    };
+    team?: {
+        name: string;
+    };
+    prompt?: string;
+    metadata?: Record<string, unknown>;
+    artifacts?: {
+        messagesPath?: string;
+    };
+    messages?: LlmsProviders.Message[];
+    usage?: SessionAccumulatedUsage;
+    checkpoint?: CoreSessionCheckpointSnapshot;
+}
+export declare function createCoreSessionSnapshot(input: {
+    session: SessionRecord;
+    messages?: LlmsProviders.Message[];
+    usage?: SessionAccumulatedUsage;
+}): CoreSessionSnapshot;
+export declare function coreSessionSnapshotToRecord(snapshot: CoreSessionSnapshot): SessionRecord;

package/dist/session/session-versioning-service.d.ts

@@ -0,0 +1,48 @@
+import type * as LlmsProviders from "@clinebot/llms";
+import type { CheckpointEntry, CheckpointMetadata } from "../hooks/checkpoint-hooks";
+import type { RestoreSessionInput } from "../runtime/host/runtime-host";
+import type { SessionRecord } from "../types/sessions";
+import { type CheckpointRestorePlan } from "./checkpoint-restore";
+import { type CoreSessionSnapshot } from "./session-snapshot";
+export type SessionVersioningErrorCode = "invalid_restore" | "session_not_found" | "session_messages_not_found";
+export declare class SessionVersioningError extends Error {
+    readonly code: SessionVersioningErrorCode;
+    constructor(code: SessionVersioningErrorCode, message: string);
+}
+export interface SessionCheckpointRestoreContext {
+    sourceSession: SessionRecord;
+    sourceMessages?: LlmsProviders.Message[];
+    sourceSnapshot: CoreSessionSnapshot;
+    plan: CheckpointRestorePlan;
+    restoredCheckpointMetadata?: CheckpointMetadata;
+    initialMessages: LlmsProviders.Message[];
+    restoreMessages: boolean;
+    restoreWorkspace: boolean;
+    checkpointRunCount: number;
+}
+export interface SessionCheckpointRestoreResult<TStartResult = unknown> {
+    sessionId?: string;
+    startResult?: TStartResult;
+    messages?: LlmsProviders.Message[];
+    checkpoint: CheckpointEntry;
+    sourceSnapshot: CoreSessionSnapshot;
+    restoredSnapshot?: CoreSessionSnapshot;
+}
+export interface SessionCheckpointRestoreInput<TRestoreStartInput, TStartInput, TStartResult> {
+    sessionId: string;
+    checkpointRunCount: number;
+    cwd?: string;
+    restore?: RestoreSessionInput["restore"];
+    start?: TRestoreStartInput;
+    getSession(sessionId: string): Promise<SessionRecord | undefined>;
+    readMessages(sessionId: string): Promise<LlmsProviders.Message[]>;
+    buildStartInput?: (context: SessionCheckpointRestoreContext, start: TRestoreStartInput) => TStartInput | Promise<TStartInput>;
+    startSession?: (input: TStartInput) => Promise<TStartResult>;
+    getStartedSessionId?: (result: TStartResult) => string | undefined;
+    readRestoredSession?: (sessionId: string) => Promise<SessionRecord | undefined>;
+    applyWorkspaceCheckpoint?: (cwd: string, checkpoint: CheckpointEntry) => Promise<void>;
+    retainCheckpointRefs?: (cwd: string, sessionId: string, history: CheckpointEntry[]) => Promise<void>;
+}
+export declare class SessionVersioningService {
+    restoreCheckpoint<TRestoreStartInput, TStartInput, TStartResult>(input: SessionCheckpointRestoreInput<TRestoreStartInput, TStartInput, TStartResult>): Promise<SessionCheckpointRestoreResult<TStartResult>>;
+}

package/dist/session/{conversation-store.d.ts → stores/conversation-store.d.ts}

@@ -27,4 +27,3 @@ export declare class ConversationStore {
     isSessionStarted(): boolean;
     markSessionStarted(): void;
 }
-//# sourceMappingURL=conversation-store.d.ts.map

package/dist/session/{session-manifest-store.d.ts → stores/session-manifest-store.d.ts}

@@ -1,7 +1,7 @@
 import type * as LlmsProviders from "@clinebot/llms";
-import { SessionArtifacts } from "../services/session-artifacts";
-import type { SessionMessagesArtifactUploader, SessionPersistenceAdapter } from "../types/session";
-import { type SessionManifest } from "./session-manifest";
+import { SessionArtifacts } from "../../services/session-artifacts";
+import type { SessionMessagesArtifactUploader, SessionPersistenceAdapter } from "../../types/session";
+import { type SessionManifest } from "../models/session-manifest";
 export declare class SessionManifestStore {
     private readonly adapter;
     private readonly messagesArtifactUploader?;
@@ -19,4 +19,3 @@ export declare class SessionManifestStore {
     persistSessionMessages(sessionId: string, messages: LlmsProviders.Message[], systemPrompt?: string): Promise<void>;
     appendStaleSessionHookLog(detectedAt: string, sessionId: string, pid: number, reason: string, source: string): void;
 }
-//# sourceMappingURL=session-manifest-store.d.ts.map

package/dist/session/{team-persistence-store.d.ts → stores/team-persistence-store.d.ts}

@@ -1,6 +1,6 @@
 import type { TeamTeammateSpec } from "@clinebot/shared";
-import type { AgentTeamsRuntime, TeamEvent } from "../extensions/tools/team";
-import { type TeamRuntimeState } from "./session-row";
+import type { AgentTeamsRuntime, TeamEvent } from "../../extensions/tools/team";
+import { type TeamRuntimeState } from "../models/session-row";
 export interface FileTeamPersistenceStoreOptions {
     teamName: string;
     baseDir?: string;
@@ -21,4 +21,3 @@ export declare class FileTeamPersistenceStore {
     private hasPersistableState;
     private clearPersistedState;
 }
-//# sourceMappingURL=team-persistence-store.d.ts.map

package/dist/session/team/index.d.ts

@@ -0,0 +1,2 @@
+export { TeamChildSessionManager } from "./team-child-session-manager";
+export { buildTeamRunContinuationPrompt, dispatchTeamEventToBackend, emitTeamProgress, formatModePrompt, hasPendingTeamRunWork, notifyTeamRunWaiters, shouldAutoContinueTeamRuns, trackTeamRunState, waitForTeamRunUpdates, } from "./team-session-coordinator";

package/dist/session/{subagent-session-manager.d.ts → team/team-child-session-manager.d.ts}

@@ -1,12 +1,12 @@
 import type * as LlmsProviders from "@clinebot/llms";
 import type { AgentResult } from "@clinebot/shared";
-import type { SubAgentEndContext, SubAgentStartContext } from "../extensions/tools/team";
-import type { HookEventPayload } from "../hooks";
-import type { SessionStatus } from "../types/common";
-import type { SessionPersistenceAdapter, StoredMessageWithMetadata } from "../types/session";
-import type { SessionManifestStore } from "./session-manifest-store";
-import type { UpsertSubagentInput } from "./session-row";
-export declare class SubagentSessionManager {
+import type { SubAgentEndContext, SubAgentStartContext } from "../../extensions/tools/team";
+import type { HookEventPayload } from "../../hooks";
+import type { SessionStatus } from "../../types/common";
+import type { SessionPersistenceAdapter, StoredMessageWithMetadata } from "../../types/session";
+import type { UpsertSubagentInput } from "../models/session-row";
+import type { SessionManifestStore } from "../stores/session-manifest-store";
+export declare class TeamChildSessionManager {
     private readonly adapter;
     private readonly manifestStore;
     private readonly toPersistedMessages;
@@ -33,4 +33,3 @@ export declare class SubagentSessionManager {
     handleSubAgentEnd(rootSessionId: string, context: SubAgentEndContext): Promise<void>;
     appendSubagentHookAudit(event: HookEventPayload): void;
 }
-//# sourceMappingURL=subagent-session-manager.d.ts.map

package/dist/session/{session-team-coordination.d.ts → team/team-session-coordinator.d.ts}

@@ -1,7 +1,7 @@
 import { type AgentMode, type AgentResult } from "@clinebot/shared";
-import type { TeamEvent } from "../extensions/tools/team";
-import type { CoreSessionEvent } from "../types/events";
-import type { ActiveSession, TeamRunUpdate } from "../types/session";
+import type { TeamEvent } from "../../extensions/tools/team";
+import type { CoreSessionEvent } from "../../types/events";
+import type { ActiveSession, TeamRunUpdate } from "../../types/session";
 export declare function trackTeamRunState(session: ActiveSession, event: TeamEvent): void;
 export declare function dispatchTeamEventToBackend(rootSessionId: string, event: TeamEvent, invokeOptional: (method: string, ...args: unknown[]) => Promise<void>): Promise<void>;
 export declare function emitTeamProgress(session: ActiveSession, rootSessionId: string, event: TeamEvent, emit: (event: CoreSessionEvent) => void): void;
@@ -11,4 +11,3 @@ export declare function notifyTeamRunWaiters(session: ActiveSession): void;
 export declare function waitForTeamRunUpdates(session: ActiveSession): Promise<TeamRunUpdate[]>;
 export declare function buildTeamRunContinuationPrompt(session: ActiveSession, updates: TeamRunUpdate[]): string;
 export declare function formatModePrompt(prompt: string, mode: AgentMode | undefined): string;
-//# sourceMappingURL=session-team-coordination.d.ts.map

package/dist/settings/index.d.ts

@@ -0,0 +1,2 @@
+export { CoreSettingsService, createCoreSettingsService, } from "./settings-service";
+export type { ClineCoreSettingsApi, CoreSettingsItem, CoreSettingsItemKind, CoreSettingsItemSource, CoreSettingsListInput, CoreSettingsMutationResult, CoreSettingsSnapshot, CoreSettingsToggleInput, CoreSettingsType, } from "./types";

package/dist/settings/settings-service.d.ts

@@ -0,0 +1,6 @@
+import type { CoreSettingsListInput, CoreSettingsMutationResult, CoreSettingsSnapshot, CoreSettingsToggleInput } from "./types";
+export declare class CoreSettingsService {
+    list(input?: CoreSettingsListInput): Promise<CoreSettingsSnapshot>;
+    toggle(input: CoreSettingsToggleInput): Promise<CoreSettingsMutationResult>;
+}
+export declare function createCoreSettingsService(): CoreSettingsService;

package/dist/settings/types.d.ts

@@ -0,0 +1,42 @@
+import type { UserInstructionConfigService } from "../extensions/config";
+import type { BuiltinToolAvailabilityContext } from "../extensions/tools";
+export type CoreSettingsType = "skills" | "workflows" | "rules" | "tools";
+export type CoreSettingsItemKind = "skill" | "workflow" | "rule" | "tool";
+export type CoreSettingsItemSource = "global" | "workspace" | "builtin" | "global-plugin" | "workspace-plugin";
+export interface CoreSettingsItem {
+    id: string;
+    name: string;
+    path: string;
+    kind: CoreSettingsItemKind;
+    source: CoreSettingsItemSource;
+    enabled?: boolean;
+    description?: string;
+    toggleable?: boolean;
+}
+export interface CoreSettingsSnapshot {
+    workflows: CoreSettingsItem[];
+    rules: CoreSettingsItem[];
+    skills: CoreSettingsItem[];
+    tools: CoreSettingsItem[];
+}
+export interface CoreSettingsListInput {
+    cwd?: string;
+    workspaceRoot?: string;
+    userInstructionService?: UserInstructionConfigService;
+    availabilityContext?: BuiltinToolAvailabilityContext;
+}
+export interface CoreSettingsToggleInput extends CoreSettingsListInput {
+    type: CoreSettingsType;
+    id?: string;
+    path?: string;
+    name?: string;
+    enabled?: boolean;
+}
+export interface CoreSettingsMutationResult {
+    snapshot: CoreSettingsSnapshot;
+    changedTypes: CoreSettingsType[];
+}
+export interface ClineCoreSettingsApi {
+    list(input?: CoreSettingsListInput): Promise<CoreSettingsSnapshot>;
+    toggle(input: CoreSettingsToggleInput): Promise<CoreSettingsMutationResult>;
+}

package/dist/types/chat-schema.d.ts

@@ -30,23 +30,23 @@ export declare const ChatSessionStatusSchema: z.ZodEnum<{
     cancelled: "cancelled";
 }>;
 export declare const ChatMessageRoleSchema: z.ZodEnum<{
+    system: "system";
+    status: "status";
     error: "error";
     user: "user";
     assistant: "assistant";
     tool: "tool";
-    system: "system";
-    status: "status";
 }>;
 export declare const ChatMessageSchema: z.ZodObject<{
     id: z.ZodString;
     sessionId: z.ZodNullable<z.ZodString>;
     role: z.ZodEnum<{
+        system: "system";
+        status: "status";
         error: "error";
         user: "user";
         assistant: "assistant";
         tool: "tool";
-        system: "system";
-        status: "status";
     }>;
     content: z.ZodString;
     createdAt: z.ZodNumber;
@@ -62,6 +62,15 @@ export declare const ChatMessageSchema: z.ZodObject<{
         hookEventName: z.ZodOptional<z.ZodString>;
         inputTokens: z.ZodOptional<z.ZodNumber>;
         outputTokens: z.ZodOptional<z.ZodNumber>;
+        checkpoint: z.ZodOptional<z.ZodObject<{
+            ref: z.ZodString;
+            createdAt: z.ZodNumber;
+            runCount: z.ZodNumber;
+            kind: z.ZodOptional<z.ZodEnum<{
+                commit: "commit";
+                stash: "stash";
+            }>>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export declare const ChatSummarySchema: z.ZodObject<{
@@ -105,12 +114,12 @@ export declare const ChatViewStateSchema: z.ZodObject<{
         id: z.ZodString;
         sessionId: z.ZodNullable<z.ZodString>;
         role: z.ZodEnum<{
+            system: "system";
+            status: "status";
             error: "error";
             user: "user";
             assistant: "assistant";
             tool: "tool";
-            system: "system";
-            status: "status";
         }>;
         content: z.ZodString;
         createdAt: z.ZodNumber;
@@ -126,6 +135,15 @@ export declare const ChatViewStateSchema: z.ZodObject<{
             hookEventName: z.ZodOptional<z.ZodString>;
             inputTokens: z.ZodOptional<z.ZodNumber>;
             outputTokens: z.ZodOptional<z.ZodNumber>;
+            checkpoint: z.ZodOptional<z.ZodObject<{
+                ref: z.ZodString;
+                createdAt: z.ZodNumber;
+                runCount: z.ZodNumber;
+                kind: z.ZodOptional<z.ZodEnum<{
+                    commit: "commit";
+                    stash: "stash";
+                }>>;
+            }, z.core.$strip>>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
     rawTranscript: z.ZodString;
@@ -141,4 +159,3 @@ export type ChatSessionStatus = z.infer<typeof ChatSessionStatusSchema>;
 export type ChatMessage = z.infer<typeof ChatMessageSchema>;
 export type ChatSummary = z.infer<typeof ChatSummarySchema>;
 export type ChatViewState = z.infer<typeof ChatViewStateSchema>;
-//# sourceMappingURL=chat-schema.d.ts.map

package/dist/types/common.d.ts

@@ -17,4 +17,3 @@ export declare const SessionSource: {
 };
 export type BuiltinSessionSource = (typeof SessionSource)[keyof typeof SessionSource];
 export type SessionSource = BuiltinSessionSource | (string & {});
-//# sourceMappingURL=common.d.ts.map

package/dist/types/config.d.ts

@@ -1,5 +1,5 @@
 import type { ModelInfo } from "@clinebot/llms";
-import type { AgentConfig, AgentHooks, AgentMode, BasicLogger, ConsecutiveMistakeLimitContext, ConsecutiveMistakeLimitDecision, ExtensionContext, HookErrorMode, ITelemetryService, MessageWithMetadata, SessionExecutionConfig, SessionPromptConfig, SessionWorkspaceConfig, Tool } from "@clinebot/shared";
+import type { AgentConfig, AgentHooks, AgentMode, AgentTool, BasicLogger, ConsecutiveMistakeLimitContext, ConsecutiveMistakeLimitDecision, ExtensionContext, HookErrorMode, ITelemetryService, MessageWithMetadata, SessionExecutionConfig, SessionPromptConfig, SessionWorkspaceConfig } from "@clinebot/shared";
 import type { ToolRoutingRule } from "../extensions/tools/model-tool-routing";
 import type { TeamEvent } from "../extensions/tools/team";
 import type { ProviderConfig } from "./provider-settings";
@@ -149,7 +149,7 @@ export interface CoreSessionConfig extends CoreModelConfig, CoreRuntimeFeatures,
     logger?: BasicLogger;
     telemetry?: ITelemetryService;
     extensionContext?: ExtensionContext;
-    extraTools?: Tool[];
+    extraTools?: AgentTool[];
     pluginPaths?: string[];
     extensions?: AgentConfig["extensions"];
     execution?: AgentConfig["execution"];
@@ -165,4 +165,3 @@ export interface CoreSessionConfig extends CoreModelConfig, CoreRuntimeFeatures,
     skills?: string[];
     workspaceMetadata?: string;
 }
-//# sourceMappingURL=config.d.ts.map

package/dist/types/events.d.ts

@@ -1,3 +1,4 @@
+import type { CoreSessionSnapshot } from "../session/session-snapshot";
 export interface SessionChunkEvent {
     sessionId: string;
     stream: "stdout" | "stderr" | "agent";
@@ -44,6 +45,10 @@ export interface SessionPendingPromptSubmittedEvent {
     delivery: "queue" | "steer";
     attachmentCount: number;
 }
+export interface SessionSnapshotEvent {
+    sessionId: string;
+    snapshot: CoreSessionSnapshot;
+}
 export type CoreSessionEvent = {
     type: "chunk";
     payload: SessionChunkEvent;
@@ -66,6 +71,9 @@ export type CoreSessionEvent = {
 } | {
     type: "pending_prompt_submitted";
     payload: SessionPendingPromptSubmittedEvent;
+} | {
+    type: "session_snapshot";
+    payload: SessionSnapshotEvent;
 } | {
     type: "ended";
     payload: SessionEndedEvent;
@@ -79,4 +87,3 @@ export type CoreSessionEvent = {
         status: string;
     };
 };
-//# sourceMappingURL=events.d.ts.map

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

@@ -1,6 +1,6 @@
 import { z } from "zod";
-import { type ProviderClient, type ProviderConfig, type ProviderProtocol, type ProviderSettings, toProviderConfig } from "../llms/provider-settings";
-export type { ProviderClient, ProviderConfig, ProviderProtocol, ProviderSettings, };
+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";
@@ -17,4 +17,3 @@ export interface StoredProviderSettings {
 export declare const StoredProviderSettingsEntrySchema: z.ZodType<StoredProviderSettingsEntry>;
 export declare const StoredProviderSettingsSchema: z.ZodType<StoredProviderSettings>;
 export declare function emptyStoredProviderSettings(): StoredProviderSettings;
-//# sourceMappingURL=provider-settings.d.ts.map

package/dist/types/session.d.ts

@@ -1,9 +1,9 @@
 import type * as LlmsProviders from "@clinebot/llms";
-import type { SessionAccumulatedUsage } from "../runtime/runtime-host";
-import type { BuiltRuntime } from "../runtime/session-runtime";
-import type { SessionRuntime } from "../runtime/session-runtime-orchestrator";
-import type { SessionRow } from "../session/session-row";
-import type { RootSessionArtifacts } from "../session/session-service";
+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 = {
@@ -13,6 +13,7 @@ export type ActiveSession = {
     artifacts?: RootSessionArtifacts;
     source: SessionSource;
     startedAt: string;
+    updatedAt: string;
     status: SessionStatus;
     endedAt?: string | null;
     exitCode?: number | null;
@@ -30,6 +31,22 @@ export type ActiveSession = {
     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;
@@ -97,4 +114,3 @@ export interface SessionMessagesArtifactUploader {
         row?: SessionRow;
     }): Promise<void>;
 }
-//# sourceMappingURL=session.d.ts.map

package/dist/types/sessions.d.ts

@@ -26,4 +26,3 @@ export interface SessionHistoryMetadata extends Record<string, unknown> {
 export interface SessionHistoryRecord extends Omit<SessionRecord, "metadata"> {
     metadata?: SessionHistoryMetadata;
 }
-//# sourceMappingURL=sessions.d.ts.map

package/dist/types/storage.d.ts

@@ -34,4 +34,3 @@ export interface ArtifactStore {
     appendHook(sessionId: string, payload: unknown): Promise<void> | void;
     writeMessages(sessionId: string, messages: unknown[]): Promise<void> | void;
 }
-//# sourceMappingURL=storage.d.ts.map