@clinebot/core 0.0.0

package/dist/session/default-session-manager.d.ts

@@ -0,0 +1,77 @@
+import { Agent, type AgentConfig, type AgentResult, type ToolApprovalRequest, type ToolApprovalResult } from "@clinebot/agents";
+import type { providers as LlmsProviders } from "@clinebot/llms";
+import { type ToolExecutors } from "../default-tools";
+import type { RuntimeBuilder } from "../runtime/session-runtime";
+import { ProviderSettingsManager } from "../storage/provider-settings-manager";
+import type { CoreSessionEvent } from "../types/events";
+import type { SessionRecord } from "../types/sessions";
+import type { RpcCoreSessionService } from "./rpc-session-service";
+import { RuntimeOAuthTokenManager } from "./runtime-oauth-token-manager";
+import type { SendSessionInput, SessionManager, StartSessionInput, StartSessionResult } from "./session-manager";
+import type { CoreSessionService } from "./session-service";
+type SessionBackend = CoreSessionService | RpcCoreSessionService;
+export interface DefaultSessionManagerOptions {
+    distinctId: string;
+    sessionService: SessionBackend;
+    runtimeBuilder?: RuntimeBuilder;
+    createAgent?: (config: AgentConfig) => Agent;
+    defaultToolExecutors?: Partial<ToolExecutors>;
+    toolPolicies?: AgentConfig["toolPolicies"];
+    providerSettingsManager?: ProviderSettingsManager;
+    oauthTokenManager?: RuntimeOAuthTokenManager;
+    requestToolApproval?: (request: ToolApprovalRequest) => Promise<ToolApprovalResult>;
+}
+export declare class DefaultSessionManager implements SessionManager {
+    private readonly sessionService;
+    private readonly runtimeBuilder;
+    private readonly createAgentInstance;
+    private readonly defaultToolExecutors?;
+    private readonly defaultToolPolicies?;
+    private readonly providerSettingsManager;
+    private readonly oauthTokenManager;
+    private readonly defaultRequestToolApproval?;
+    private readonly listeners;
+    private readonly sessions;
+    constructor(options: DefaultSessionManagerOptions);
+    private resolveStoredProviderSettings;
+    private buildResolvedProviderConfig;
+    start(input: StartSessionInput): Promise<StartSessionResult>;
+    send(input: SendSessionInput): Promise<AgentResult | undefined>;
+    abort(sessionId: string): Promise<void>;
+    stop(sessionId: string): Promise<void>;
+    dispose(reason?: string): Promise<void>;
+    get(sessionId: string): Promise<SessionRecord | undefined>;
+    list(limit?: number): Promise<SessionRecord[]>;
+    delete(sessionId: string): Promise<boolean>;
+    readTranscript(sessionId: string, maxChars?: number): Promise<string>;
+    readMessages(sessionId: string): Promise<LlmsProviders.Message[]>;
+    readHooks(sessionId: string, limit?: number): Promise<unknown[]>;
+    subscribe(listener: (event: CoreSessionEvent) => void): () => void;
+    private runTurn;
+    private executeAgentTurn;
+    private prepareTurnInput;
+    private resolveAbsoluteFilePaths;
+    private ensureSessionPersisted;
+    private finalizeSingleRun;
+    private failSession;
+    private shutdownSession;
+    private updateStatus;
+    private emitStatus;
+    private listRows;
+    private getRow;
+    private createSpawnTool;
+    private handleTeamEvent;
+    private hasPendingTeamRunWork;
+    private shouldAutoContinueTeamRuns;
+    private notifyTeamRunWaiters;
+    private waitForTeamRunUpdates;
+    private buildTeamRunContinuationPrompt;
+    private emit;
+    private invoke;
+    private invokeOptional;
+    private invokeOptionalValue;
+    private runWithAuthRetry;
+    private isLikelyAuthError;
+    private syncOAuthCredentials;
+}
+export {};

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

@@ -0,0 +1,12 @@
+import { UnifiedSessionPersistenceService } from "./unified-session-persistence-service";
+export interface RpcCoreSessionServiceOptions {
+    address?: string;
+    sessionsDir: string;
+}
+export declare class RpcCoreSessionService extends UnifiedSessionPersistenceService {
+    private readonly sessionsDirPath;
+    private readonly client;
+    constructor(options: RpcCoreSessionServiceOptions);
+    ensureSessionsDir(): string;
+    close(): void;
+}

package/dist/session/runtime-oauth-token-manager.d.ts

@@ -0,0 +1,28 @@
+import { ProviderSettingsManager } from "../storage/provider-settings-manager";
+declare const MANAGED_OAUTH_PROVIDERS: readonly ["cline", "oca", "openai-codex"];
+type ManagedOAuthProviderId = (typeof MANAGED_OAUTH_PROVIDERS)[number];
+export declare class OAuthReauthRequiredError extends Error {
+    readonly providerId: ManagedOAuthProviderId;
+    constructor(providerId: ManagedOAuthProviderId);
+}
+export type RuntimeOAuthResolution = {
+    providerId: ManagedOAuthProviderId;
+    apiKey: string;
+    accountId?: string;
+    refreshed: boolean;
+};
+export declare class RuntimeOAuthTokenManager {
+    private readonly providerSettingsManager;
+    private readonly refreshInFlight;
+    constructor(options?: {
+        providerSettingsManager?: ProviderSettingsManager;
+    });
+    resolveProviderApiKey(input: {
+        providerId: string;
+        forceRefresh?: boolean;
+    }): Promise<RuntimeOAuthResolution | null>;
+    private resolveWithSingleFlight;
+    private resolveProviderApiKeyInternal;
+    private resolveCredentials;
+}
+export {};

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

@@ -0,0 +1,19 @@
+export declare function nowIso(): string;
+export declare function unlinkIfExists(path: string | null | undefined): void;
+export interface SessionArtifactPaths {
+    transcriptPath: string;
+    hookPath: string;
+    messagesPath: string;
+}
+export declare class SessionArtifacts {
+    private readonly ensureSessionsDir;
+    constructor(ensureSessionsDir: () => string);
+    sessionArtifactsDir(sessionId: string): string;
+    ensureSessionArtifactsDir(sessionId: string): string;
+    sessionTranscriptPath(sessionId: string): string;
+    sessionHookPath(sessionId: string): string;
+    sessionMessagesPath(sessionId: string): string;
+    sessionManifestPath(sessionId: string, ensureDir?: boolean): string;
+    removeSessionDirIfEmpty(sessionId: string): void;
+    subagentArtifactPaths(sessionId: string, subAgentId: string, activeTeamTaskSessionId?: string): SessionArtifactPaths;
+}

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

@@ -0,0 +1,15 @@
+import type { HookEventPayload } from "@clinebot/agents";
+import type { SessionStatus } from "../types/common";
+export declare function sanitizeSessionToken(value: string): string;
+export declare function makeSubSessionId(rootSessionId: string, agentId: string): string;
+export declare function makeTeamTaskSubSessionId(rootSessionId: string, agentId: string): string;
+export declare function parseTeamTaskSubSessionId(sessionId: string): {
+    rootSessionId: string;
+    agentId: string;
+    teamTaskId: string;
+} | null;
+export declare function parseSubSessionId(sessionId: string): {
+    rootSessionId: string;
+    agentId: string;
+} | null;
+export declare function deriveSubsessionStatus(event: HookEventPayload): SessionStatus;

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

@@ -0,0 +1,21 @@
+import type { AgentConfig, ToolApprovalRequest, ToolApprovalResult } from "@clinebot/agents";
+import type { ToolExecutors } from "../default-tools";
+import { RpcCoreSessionService } from "./rpc-session-service";
+import type { SessionManager } from "./session-manager";
+import { CoreSessionService } from "./session-service";
+type SessionBackend = RpcCoreSessionService | CoreSessionService;
+export interface CreateSessionHostOptions {
+    distinctId?: string;
+    sessionService?: SessionBackend;
+    backendMode?: "auto" | "rpc" | "local";
+    rpcAddress?: string;
+    autoStartRpcServer?: boolean;
+    rpcConnectAttempts?: number;
+    rpcConnectDelayMs?: number;
+    defaultToolExecutors?: Partial<ToolExecutors>;
+    toolPolicies?: AgentConfig["toolPolicies"];
+    requestToolApproval?: (request: ToolApprovalRequest) => Promise<ToolApprovalResult>;
+}
+export type SessionHost = SessionManager;
+export declare function createSessionHost(options: CreateSessionHostOptions): Promise<SessionHost>;
+export {};

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

@@ -0,0 +1,50 @@
+import type { AgentResult } from "@clinebot/agents";
+import type { providers as LlmsProviders } from "@clinebot/llms";
+import type { SessionSource } from "../types/common";
+import type { CoreSessionConfig } from "../types/config";
+import type { CoreSessionEvent } from "../types/events";
+import type { SessionRecord } from "../types/sessions";
+import type { SessionManifest } from "./session-manifest";
+export interface StartSessionInput {
+    config: CoreSessionConfig;
+    source?: SessionSource;
+    prompt?: string;
+    interactive?: boolean;
+    initialMessages?: LlmsProviders.Message[];
+    userImages?: string[];
+    userFiles?: string[];
+    userInstructionWatcher?: import("../agents").UserInstructionConfigWatcher;
+    onTeamRestored?: () => void;
+    defaultToolExecutors?: Partial<import("../default-tools").ToolExecutors>;
+    toolPolicies?: import("@clinebot/agents").AgentConfig["toolPolicies"];
+    requestToolApproval?: (request: import("@clinebot/agents").ToolApprovalRequest) => Promise<import("@clinebot/agents").ToolApprovalResult>;
+}
+export interface StartSessionResult {
+    sessionId: string;
+    manifest: SessionManifest;
+    manifestPath: string;
+    transcriptPath: string;
+    hookPath: string;
+    messagesPath: string;
+    result?: AgentResult;
+}
+export interface SendSessionInput {
+    sessionId: string;
+    prompt: string;
+    userImages?: string[];
+    userFiles?: string[];
+}
+export interface SessionManager {
+    start(input: StartSessionInput): Promise<StartSessionResult>;
+    send(input: SendSessionInput): Promise<AgentResult | undefined>;
+    abort(sessionId: string): Promise<void>;
+    stop(sessionId: string): Promise<void>;
+    dispose(reason?: string): Promise<void>;
+    get(sessionId: string): Promise<SessionRecord | undefined>;
+    list(limit?: number): Promise<SessionRecord[]>;
+    delete(sessionId: string): Promise<boolean>;
+    readMessages(sessionId: string): Promise<LlmsProviders.Message[]>;
+    readTranscript(sessionId: string, maxChars?: number): Promise<string>;
+    readHooks(sessionId: string, limit?: number): Promise<unknown[]>;
+    subscribe(listener: (event: CoreSessionEvent) => void): () => void;
+}

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

@@ -0,0 +1,30 @@
+import { z } from "zod";
+import { SessionSource } from "../types/common";
+export declare const SessionManifestSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    session_id: z.ZodString;
+    source: z.ZodEnum<typeof SessionSource>;
+    pid: z.ZodNumber;
+    started_at: z.ZodString;
+    ended_at: z.ZodOptional<z.ZodString>;
+    exit_code: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    status: z.ZodEnum<{
+        running: "running";
+        completed: "completed";
+        cancelled: "cancelled";
+        failed: "failed";
+    }>;
+    interactive: z.ZodBoolean;
+    provider: z.ZodString;
+    model: z.ZodString;
+    cwd: z.ZodString;
+    workspace_root: z.ZodString;
+    team_name: z.ZodOptional<z.ZodString>;
+    enable_tools: z.ZodBoolean;
+    enable_spawn: z.ZodBoolean;
+    enable_teams: z.ZodBoolean;
+    prompt: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    messages_path: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type SessionManifest = z.infer<typeof SessionManifestSchema>;

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

@@ -0,0 +1,113 @@
+import type { AgentTeamsRuntime, TeamEvent, TeamTeammateSpec } from "@clinebot/agents";
+import type { SqliteSessionStore } from "../storage/sqlite-session-store";
+import type { SessionSource, SessionStatus } from "../types/common";
+import type { SessionManifest } from "./session-manifest";
+import { UnifiedSessionPersistenceService } from "./unified-session-persistence-service";
+export interface SessionRowShape {
+    session_id: string;
+    source: string;
+    pid: number;
+    started_at: string;
+    ended_at?: string | null;
+    exit_code?: number | null;
+    status: SessionStatus;
+    status_lock?: number;
+    interactive: number;
+    provider: string;
+    model: string;
+    cwd: string;
+    workspace_root: string;
+    team_name?: string | null;
+    enable_tools: number;
+    enable_spawn: number;
+    enable_teams: number;
+    parent_session_id?: string | null;
+    parent_agent_id?: string | null;
+    agent_id?: string | null;
+    conversation_id?: string | null;
+    is_subagent: number;
+    prompt?: string | null;
+    metadata_json?: string | null;
+    transcript_path: string;
+    hook_path: string;
+    messages_path?: string | null;
+    updated_at?: string;
+}
+export interface CreateRootSessionInput {
+    sessionId: string;
+    source: SessionSource;
+    pid: number;
+    startedAt: string;
+    interactive: boolean;
+    provider: string;
+    model: string;
+    cwd: string;
+    workspaceRoot: string;
+    teamName?: string;
+    enableTools: boolean;
+    enableSpawn: boolean;
+    enableTeams: boolean;
+    prompt?: string;
+    metadata?: Record<string, unknown>;
+    transcriptPath: string;
+    hookPath: string;
+    messagesPath: string;
+}
+export interface CreateRootSessionWithArtifactsInput {
+    sessionId: string;
+    source: SessionSource;
+    pid: number;
+    interactive: boolean;
+    provider: string;
+    model: string;
+    cwd: string;
+    workspaceRoot: string;
+    teamName?: string;
+    enableTools: boolean;
+    enableSpawn: boolean;
+    enableTeams: boolean;
+    prompt?: string;
+    metadata?: Record<string, unknown>;
+    startedAt?: string;
+}
+export interface RootSessionArtifacts {
+    manifestPath: string;
+    transcriptPath: string;
+    hookPath: string;
+    messagesPath: string;
+    manifest: SessionManifest;
+}
+export interface UpsertSubagentInput {
+    agentId: string;
+    parentAgentId: string;
+    conversationId: string;
+    prompt?: string;
+    rootSessionId?: string;
+}
+type TeamRuntimeState = ReturnType<AgentTeamsRuntime["exportState"]>;
+export interface FileTeamPersistenceStoreOptions {
+    teamName: string;
+    baseDir?: string;
+}
+export declare class FileTeamPersistenceStore {
+    private readonly dirPath;
+    private readonly statePath;
+    private readonly taskHistoryPath;
+    private readonly teammateSpecs;
+    constructor(options: FileTeamPersistenceStoreOptions);
+    loadState(): TeamRuntimeState | undefined;
+    getTeammateSpecs(): TeamTeammateSpec[];
+    upsertTeammateSpec(spec: TeamTeammateSpec): void;
+    removeTeammateSpec(agentId: string): void;
+    persist(runtime: AgentTeamsRuntime): void;
+    appendTaskHistory(event: TeamEvent): void;
+    private ensureDir;
+    private hasPersistableState;
+    private clearPersistedState;
+}
+export declare class CoreSessionService extends UnifiedSessionPersistenceService {
+    private readonly store;
+    constructor(store: SqliteSessionStore);
+    createRootSession(input: CreateRootSessionInput): void;
+}
+export {};

package/dist/session/sqlite-rpc-session-backend.d.ts

@@ -0,0 +1,30 @@
+import type { RpcSessionBackend, RpcSessionRow, RpcSessionUpdateInput, RpcSpawnQueueItem } from "@clinebot/rpc";
+export interface SqliteRpcSessionBackendOptions {
+    sessionsDir?: string;
+}
+export declare class SqliteRpcSessionBackend implements RpcSessionBackend {
+    private readonly store;
+    constructor(options?: SqliteRpcSessionBackendOptions);
+    init(): void;
+    upsertSession(row: RpcSessionRow): void;
+    getSession(sessionId: string): RpcSessionRow | undefined;
+    listSessions(options: {
+        limit: number;
+        parentSessionId?: string;
+        status?: string;
+    }): RpcSessionRow[];
+    updateSession(input: RpcSessionUpdateInput): {
+        updated: boolean;
+        statusLock: number;
+    };
+    deleteSession(sessionId: string): boolean;
+    deleteSessionsByParent(parentSessionId: string): void;
+    enqueueSpawnRequest(input: {
+        rootSessionId: string;
+        parentAgentId: string;
+        task?: string;
+        systemPrompt?: string;
+    }): void;
+    claimSpawnRequest(rootSessionId: string, parentAgentId: string): RpcSpawnQueueItem | undefined;
+}
+export declare function createSqliteRpcSessionBackend(options?: SqliteRpcSessionBackendOptions): RpcSessionBackend;

package/dist/session/unified-session-persistence-service.d.ts

@@ -0,0 +1,93 @@
+import type { HookEventPayload, SubAgentEndContext, SubAgentStartContext } from "@clinebot/agents";
+import type { providers as LlmsProviders } from "@clinebot/llms";
+import type { SessionStatus } from "../types/common";
+import { SessionArtifacts } from "./session-artifacts";
+import { type SessionManifest } from "./session-manifest";
+import type { CreateRootSessionWithArtifactsInput, RootSessionArtifacts, SessionRowShape, UpsertSubagentInput } from "./session-service";
+export interface PersistedSessionUpdateInput {
+    sessionId: string;
+    expectedStatusLock?: number;
+    status?: SessionStatus;
+    endedAt?: string | null;
+    exitCode?: number | null;
+    prompt?: string | null;
+    metadataJson?: string | null;
+    parentSessionId?: string | null;
+    parentAgentId?: string | null;
+    agentId?: string | null;
+    conversationId?: string | null;
+    setRunning?: boolean;
+}
+export interface SessionPersistenceAdapter {
+    ensureSessionsDir(): string;
+    upsertSession(row: SessionRowShape): Promise<void>;
+    getSession(sessionId: string): Promise<SessionRowShape | undefined>;
+    listSessions(options: {
+        limit: number;
+        parentSessionId?: string;
+        status?: string;
+    }): Promise<SessionRowShape[]>;
+    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 declare class UnifiedSessionPersistenceService {
+    private readonly adapter;
+    private readonly teamTaskSessionsByAgent;
+    protected readonly artifacts: SessionArtifacts;
+    constructor(adapter: SessionPersistenceAdapter);
+    private teamTaskQueueKey;
+    ensureSessionsDir(): string;
+    private sessionTranscriptPath;
+    private sessionHookPath;
+    private sessionMessagesPath;
+    private sessionManifestPath;
+    private sessionPathFromStore;
+    private activeTeamTaskSessionId;
+    private subagentArtifactPaths;
+    private writeSessionManifestFile;
+    private createRootSessionId;
+    createRootSessionWithArtifacts(input: CreateRootSessionWithArtifactsInput): Promise<RootSessionArtifacts>;
+    writeSessionManifest(manifestPath: string, manifest: SessionManifest): void;
+    updateSessionStatus(sessionId: string, status: SessionStatus, exitCode?: number | null): Promise<{
+        updated: boolean;
+        endedAt?: string;
+    }>;
+    updateSession(input: {
+        sessionId: string;
+        prompt?: string | null;
+        metadata?: Record<string, unknown> | null;
+    }): Promise<{
+        updated: boolean;
+    }>;
+    queueSpawnRequest(event: HookEventPayload): Promise<void>;
+    private readRootSession;
+    private claimQueuedSpawnTask;
+    upsertSubagentSession(input: UpsertSubagentInput): Promise<string | undefined>;
+    upsertSubagentSessionFromHook(event: HookEventPayload): Promise<string | undefined>;
+    appendSubagentHookAudit(subSessionId: string, event: HookEventPayload): Promise<void>;
+    appendSubagentTranscriptLine(subSessionId: string, line: string): Promise<void>;
+    persistSessionMessages(sessionId: string, messages: LlmsProviders.Message[]): Promise<void>;
+    applySubagentStatus(subSessionId: string, event: HookEventPayload): Promise<void>;
+    applySubagentStatusBySessionId(subSessionId: string, status: SessionStatus): Promise<void>;
+    applyStatusToRunningChildSessions(parentSessionId: string, status: Exclude<SessionStatus, "running">): Promise<void>;
+    private createTeamTaskSubSession;
+    onTeamTaskStart(rootSessionId: string, agentId: string, message: string): Promise<void>;
+    onTeamTaskEnd(rootSessionId: string, agentId: string, status: SessionStatus, summary?: string, messages?: LlmsProviders.Message[]): Promise<void>;
+    handleSubAgentStart(rootSessionId: string, context: SubAgentStartContext): Promise<void>;
+    handleSubAgentEnd(rootSessionId: string, context: SubAgentEndContext): Promise<void>;
+    private isPidAlive;
+    listSessions(limit?: number): Promise<SessionRowShape[]>;
+    deleteSession(sessionId: string): Promise<{
+        deleted: boolean;
+    }>;
+}

package/dist/session/workspace-manager.d.ts

@@ -0,0 +1,28 @@
+import type { WorkspaceInfo } from "../types/workspace";
+import { type WorkspaceManifest } from "./workspace-manifest";
+export interface WorkspaceManagerEvent {
+    type: "workspace_added" | "workspace_switched";
+    workspace: WorkspaceInfo;
+}
+export interface WorkspaceManager {
+    addWorkspacePath(workspacePath: string): Promise<WorkspaceInfo>;
+    switchWorkspace(workspacePath: string): Promise<WorkspaceInfo>;
+    subscribe(listener: (event: WorkspaceManagerEvent) => void): () => void;
+    getCurrentWorkspace(): WorkspaceInfo | undefined;
+    getWorkspace(workspacePath: string): WorkspaceInfo | undefined;
+    listWorkspaces(): WorkspaceInfo[];
+    getManifest(): WorkspaceManifest;
+}
+export declare class InMemoryWorkspaceManager implements WorkspaceManager {
+    private manifest;
+    private readonly listeners;
+    constructor(manifest?: WorkspaceManifest);
+    addWorkspacePath(workspacePath: string): Promise<WorkspaceInfo>;
+    switchWorkspace(workspacePath: string): Promise<WorkspaceInfo>;
+    subscribe(listener: (event: WorkspaceManagerEvent) => void): () => void;
+    getCurrentWorkspace(): WorkspaceInfo | undefined;
+    getWorkspace(workspacePath: string): WorkspaceInfo | undefined;
+    listWorkspaces(): WorkspaceInfo[];
+    getManifest(): WorkspaceManifest;
+    private emit;
+}

package/dist/session/workspace-manifest.d.ts

@@ -0,0 +1,25 @@
+import { z } from "zod";
+import type { WorkspaceInfo } from "../types/workspace";
+export declare const WorkspaceInfoSchema: z.ZodObject<{
+    rootPath: z.ZodString;
+    hint: z.ZodOptional<z.ZodString>;
+    associatedRemoteUrls: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    latestGitCommitHash: z.ZodOptional<z.ZodString>;
+    latestGitBranchName: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const WorkspaceManifestSchema: z.ZodObject<{
+    currentWorkspacePath: z.ZodOptional<z.ZodString>;
+    workspaces: z.ZodRecord<z.ZodString, z.ZodObject<{
+        rootPath: z.ZodString;
+        hint: z.ZodOptional<z.ZodString>;
+        associatedRemoteUrls: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        latestGitCommitHash: z.ZodOptional<z.ZodString>;
+        latestGitBranchName: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type WorkspaceManifest = z.infer<typeof WorkspaceManifestSchema>;
+export declare function emptyWorkspaceManifest(): WorkspaceManifest;
+export declare function normalizeWorkspacePath(workspacePath: string): string;
+export declare function generateWorkspaceInfo(workspacePath: string): Promise<WorkspaceInfo>;
+export declare function upsertWorkspaceInfo(manifest: WorkspaceManifest, info: WorkspaceInfo): WorkspaceManifest;
+export declare function buildWorkspaceMetadata(cwd: string): Promise<string>;

package/dist/storage/provider-settings-legacy-migration.d.ts

@@ -0,0 +1,13 @@
+import type { ProviderSettingsManager } from "./provider-settings-manager";
+export interface MigrateLegacyProviderSettingsOptions {
+    providerSettingsManager: ProviderSettingsManager;
+    dataDir?: string;
+    globalStatePath?: string;
+    secretsPath?: string;
+}
+export interface MigrateLegacyProviderSettingsResult {
+    migrated: boolean;
+    providerCount: number;
+    lastUsedProvider?: string;
+}
+export declare function migrateLegacyProviderSettings(options: MigrateLegacyProviderSettingsOptions): MigrateLegacyProviderSettingsResult;

package/dist/storage/provider-settings-manager.d.ts

@@ -0,0 +1,20 @@
+import { type ProviderConfig, type ProviderSettings, type ProviderTokenSource, type StoredProviderSettings } from "../types/provider-settings";
+export interface ProviderSettingsManagerOptions {
+    filePath?: string;
+}
+export interface SaveProviderSettingsOptions {
+    setLastUsed?: boolean;
+    tokenSource?: ProviderTokenSource;
+}
+export declare class ProviderSettingsManager {
+    private readonly filePath;
+    constructor(options?: ProviderSettingsManagerOptions);
+    getFilePath(): string;
+    read(): StoredProviderSettings;
+    write(state: StoredProviderSettings): void;
+    saveProviderSettings(settings: unknown, options?: SaveProviderSettingsOptions): StoredProviderSettings;
+    getProviderSettings(providerId: string): ProviderSettings | undefined;
+    getLastUsedProviderSettings(): ProviderSettings | undefined;
+    getProviderConfig(providerId: string): ProviderConfig | undefined;
+    getLastUsedProviderConfig(): ProviderConfig | undefined;
+}

package/dist/storage/sqlite-session-store.d.ts

@@ -0,0 +1,29 @@
+import { type SqliteDb } from "@clinebot/shared/db";
+import type { SessionStatus } from "../types/common";
+import type { SessionRecord } from "../types/sessions";
+import type { SessionStore } from "../types/storage";
+export interface SqliteSessionStoreOptions {
+    sessionsDir?: string;
+}
+export declare class SqliteSessionStore implements SessionStore {
+    private readonly sessionsDirPath;
+    private db;
+    constructor(options?: SqliteSessionStoreOptions);
+    init(): void;
+    ensureSessionsDir(): string;
+    sessionDbPath(): string;
+    getRawDb(): SqliteDb;
+    run(sql: string, params?: unknown[]): {
+        changes?: number;
+    };
+    queryOne<T>(sql: string, params?: unknown[]): T | undefined;
+    queryAll<T>(sql: string, params?: unknown[]): T[];
+    create(record: SessionRecord): void;
+    update(record: Partial<SessionRecord> & {
+        sessionId: string;
+    }): void;
+    updateStatus(sessionId: string, status: SessionStatus, exitCode?: number | null): void;
+    get(sessionId: string): SessionRecord | undefined;
+    list(limit?: number): SessionRecord[];
+    delete(sessionId: string, cascade?: boolean): boolean;
+}

package/dist/storage/sqlite-team-store.d.ts

@@ -0,0 +1,31 @@
+import type { TeamEvent, TeamRuntimeState, TeamTeammateSpec } from "@clinebot/agents";
+import type { TeamStore } from "../types/storage";
+export interface SqliteTeamStoreOptions {
+    teamDir?: string;
+}
+export interface TeamRuntimeLoadResult {
+    state?: TeamRuntimeState;
+    teammates: TeamTeammateSpec[];
+    interruptedRunIds: string[];
+}
+export declare class SqliteTeamStore implements TeamStore {
+    private readonly teamDirPath;
+    private db;
+    constructor(options?: SqliteTeamStoreOptions);
+    init(): void;
+    private ensureTeamDir;
+    private dbPath;
+    private getRawDb;
+    private ensureSchema;
+    private run;
+    private queryOne;
+    private queryAll;
+    listTeamNames(): string[];
+    readState(teamName: string): TeamRuntimeState | undefined;
+    readHistory(teamName: string, limit?: number): unknown[];
+    loadRuntime(teamName: string): TeamRuntimeLoadResult;
+    appendTeamEvent(teamName: string, eventType: string, payload: unknown, correlationId?: string): void;
+    persistRuntime(teamName: string, state: TeamRuntimeState, teammates: TeamTeammateSpec[]): void;
+    markInProgressRunsInterrupted(teamName: string, reason: string): string[];
+    handleTeamEvent(teamName: string, event: TeamEvent): void;
+}

package/dist/storage/team-store.d.ts

@@ -0,0 +1,2 @@
+export type { TeamStore } from "../types/storage";
+export { SqliteTeamStore, type SqliteTeamStoreOptions, } from "./sqlite-team-store";

package/dist/team/index.d.ts

@@ -0,0 +1 @@
+export { buildTeamProgressSummary, toTeamProgressLifecycleEvent, } from "./projections";