@bbigbang/protocol 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,3685 @@
+import type { DatasetFieldSchema, DatasetMediaSlotSchema, PanelLevelNode, PanelSubmitKind, PanelTemplateNode } from './panel.js';
+import type { AgentSurfaceMode } from './agentSurface.js';
+export { validatePanelTemplateProps } from './panel.js';
+export { collectDatasetAggregateNodes, collectPanelLevelActionBars, collectPanelLevelParameterInputs, collectPanelLevelUnsupportedNodes, collectPanelTemplateUnsupportedNodes, isPanelLevelActionBarNode, isPanelLevelContainerNode, isPanelLevelDatasetAggregateNode, isPanelLevelNodeEffectivelyEmpty, isPanelLevelParameterInputNode, isPanelTemplateContainerNode, mapPanelLevelNodes, matchPanelApiJsonlAllowedUrlPrefix, normalizePanelApiJsonlAuthProfileName, normalizePanelApiJsonlAuthProfileNames, normalizePanelApiJsonlAllowedUrlPrefix, normalizePanelApiJsonlAllowedUrlPrefixes, panelLevelNodeContainsEmptyLayoutContainer, panelLevelNodeHasActionBar, panelLevelNodeUsesDatasetAggregate, validatePanelApiJsonlAuthProfile, validatePanelApiJsonlUrl, validatePanelApiJsonlUrlList, walkPanelTemplateNodes, walkPanelLevelNodes, } from './panel.js';
+export type { MapPanelLevelNodesOptions, PanelApiJsonlAuthProfile, PanelApiJsonlDatasetSource, PanelLevelActionBarNode, PanelLevelContainerNode, PanelLevelDatasetAggregateNode, PanelLevelNode, PanelLevelNodeMapper, PanelLevelNodeVisitor, PanelLevelNodeWalkContext, PanelLevelParameterInputNode, PanelTemplateContainerNode, PanelTemplateNode, PanelTemplateNodeVisitor, PanelTemplateNodeWalkContext, PanelTemplateUnsupportedNodePolicy, PanelLevelUnsupportedNodePolicy, PanelSemanticEvent, PanelSemanticEventRefs, PanelSemanticEventWakePolicy, RowTemplateGridProps, } from './panel.js';
+export type AgentType = 'claude_acp' | 'claude_sdk' | 'codex_acp' | 'codex_app_server';
+export { AGENT_SURFACE_MODE_ENV, AGENT_SURFACE_MODES, DEFAULT_AGENT_SURFACE_MODE, normalizeAgentSurfaceMode, } from './agentSurface.js';
+export type { AgentSurfaceMode } from './agentSurface.js';
+export declare const BUILTIN_UI_PANEL_SKILL_ROOT_SENTINEL = "bigbang:builtin/ui-panel";
+export declare const BUILTIN_LIBRARY_DOCUMENTS_SKILL_ROOT_SENTINEL = "bigbang:builtin/library-documents";
+export declare const BUILTIN_WORKSPACE_TOOL_SKILL_ROOT_SENTINEL = "bigbang:builtin/workspace-tool-builder";
+export type AgentRole = 'user' | 'platform_agent' | 'library_curator' | 'suggested_planner';
+export type ConversationStatus = 'idle' | 'queued' | 'active' | 'recovering' | 'awaiting_approval' | 'failed';
+export type ThreadKind = 'direct' | 'branch';
+export type ServerIdentityResult = {
+    serverId: string;
+    serverSlug: string;
+    serverName: string;
+    publicServerUrl: string | null;
+    publicBasePath: string | null;
+    version?: string;
+};
+export type CreateHubServerRegistrationTokenRequest = {
+    serverSlug: string;
+    serverName: string;
+    version?: string;
+    expiresInSeconds?: number;
+};
+export type HubServerRegistrationTokenResult = {
+    token: string;
+    expiresAt: number;
+    installCommand: string;
+    serverId: string;
+    serverSlug: string;
+    serverName: string;
+    version: string;
+};
+export type ClaimHubServerRegistrationRequest = {
+    token: string;
+    serverId: string;
+    serverSlug: string;
+    serverName: string;
+    upstream: string;
+    bridgeUrl: string;
+    version: string;
+};
+export type ClaimHubServerRegistrationResult = {
+    ok: true;
+    serverId: string;
+    serverSlug: string;
+    serverName: string;
+    upstream: string;
+    replaced: boolean;
+};
+export type AgentPermissionKind = 'read' | 'edit' | 'delete' | 'move' | 'search' | 'execute' | 'think' | 'fetch' | 'switch_mode' | 'other';
+export type AgentPermissionSupportLevel = 'enforced' | 'limited' | 'unsupported';
+export declare const AGENT_PERMISSION_KINDS: AgentPermissionKind[];
+export type AgentPermissionDefinition = {
+    kind: AgentPermissionKind;
+    label: string;
+    description: string;
+};
+export declare const AGENT_PERMISSION_DEFINITIONS: AgentPermissionDefinition[];
+export type AgentRuntimePermissionDefinition = AgentPermissionDefinition & {
+    support: AgentPermissionSupportLevel;
+};
+export declare const AGENT_RUNTIME_PERMISSION_SUPPORT: Record<AgentType, Partial<Record<AgentPermissionKind, AgentPermissionSupportLevel>>>;
+export declare function getAgentPermissionSupport(agentType: AgentType, kind: AgentPermissionKind): AgentPermissionSupportLevel;
+export declare function isAgentPermissionSupported(agentType: AgentType, kind: AgentPermissionKind): boolean;
+export declare function listAgentRuntimePermissions(agentType: AgentType): AgentRuntimePermissionDefinition[];
+export declare function parseAgentPermissionKind(value: unknown): AgentPermissionKind | null;
+export declare function normalizeAgentDisabledToolKinds(agentType: AgentType, values: unknown): AgentPermissionKind[] | undefined;
+export type RuntimeDispatchMode = 'cold_start' | 'resume' | 'dream';
+export type MissionRuntimeProvider = 'droid_cli' | 'bigbang_native';
+export type MissionState = 'draft' | 'queued' | 'running' | 'paused' | 'completed' | 'failed' | 'cancelled';
+export type MissionModelMode = 'platform_override' | 'droid_default';
+export type MissionAttemptType = 'run' | 'session_continuation' | 'active_interaction';
+export type MissionAttemptState = 'queued' | 'running' | 'completed' | 'failed';
+export type NativeMissionFeatureStatus = 'pending' | 'queued' | 'running' | 'completed' | 'failed' | 'skipped' | 'cancelled';
+export type NativeMissionAssertionStatus = 'pending' | 'passed' | 'failed' | 'blocked';
+export type MissionInteractionStatus = 'queued' | 'delivered' | 'observed' | 'applied' | 'completed' | 'failed';
+export type MissionInfo = {
+    missionId: string;
+    ownerUserId: string;
+    title: string;
+    description: string;
+    state: MissionState;
+    runtimeProvider: MissionRuntimeProvider;
+    nodeId: string | null;
+    workspacePath: string;
+    missionDir: string | null;
+    initiatorAgentId: string | null;
+    controlConversationId: string | null;
+    modelMode: MissionModelMode;
+    orchestratorModel: string | null;
+    workerModel: string | null;
+    validatorModel: string | null;
+    effectiveModelConfig: Record<string, unknown> | null;
+    createdAt: number;
+    updatedAt: number;
+    startedAt: number | null;
+    completedAt: number | null;
+    lastImportedAt: number | null;
+    latestFactorySessionId: string | null;
+    latestFactoryArtifactDir: string | null;
+    latestFactorySeenAt: number | null;
+};
+export type MissionSnapshotInfo = {
+    snapshotId: string;
+    missionId: string;
+    source: string;
+    snapshot: Record<string, unknown>;
+    createdAt: number;
+};
+export type MissionEventInfo = {
+    eventId: string;
+    missionId: string;
+    eventType: string;
+    source: string;
+    eventTime: number;
+    payload: Record<string, unknown>;
+    createdAt: number;
+};
+export type MissionAttemptInfo = {
+    attemptId: string;
+    missionId: string;
+    requestId: string | null;
+    attemptType: MissionAttemptType;
+    state: MissionAttemptState;
+    nodeId: string | null;
+    missionDir: string | null;
+    promptPreview: string | null;
+    pid: number | null;
+    exitCode: number | null;
+    signal: string | null;
+    error: string | null;
+    factorySessionId: string | null;
+    factoryArtifactDir: string | null;
+    stdoutEventCount: number;
+    stderrEventCount: number;
+    outputPreview: string | null;
+    lastOutputAt: number | null;
+    supersededBy: string | null;
+    supersessionReason: 'retry' | 'recovery' | 'orphan_cleanup' | null;
+    supersededAt: number | null;
+    createdAt: number;
+    acceptedAt: number | null;
+    completedAt: number | null;
+    updatedAt: number;
+};
+export type MissionFeatureInfo = {
+    featureId: string;
+    missionId: string;
+    milestone: string;
+    description: string;
+    skillName: string | null;
+    status: NativeMissionFeatureStatus;
+    ordering: number;
+    preconditions: string[];
+    expectedBehavior: string[];
+    retryCount: number;
+    isValidator?: boolean;
+    handoff?: Record<string, unknown> | null;
+    workerOutput?: Record<string, unknown> | null;
+    createdAt: number;
+    updatedAt: number;
+};
+export type DiscoveredIssue = {
+    id: string;
+    severity: 'blocking' | 'non-blocking';
+    description: string;
+    suggestion?: string;
+};
+export type MissionWorkerTranscriptEntry = {
+    workerSessionId: string;
+    featureId: string;
+    milestone: string;
+    role: 'assistant' | 'tool_result';
+    kind: 'tool_call' | 'tool_result' | 'content' | 'thinking';
+    toolName?: string;
+    toolCallId?: string;
+    content: string;
+    timestamp: number;
+};
+export type NativeMissionHandoff = {
+    schemaVersion: '2.0.0';
+    salientSummary: string;
+    whatWasImplemented: string[];
+    whatWasLeftUndone: string;
+    verification: {
+        commandsRun: Array<{
+            command: string;
+            exitCode: number;
+            observation: string;
+        }>;
+        interactiveChecks: Array<{
+            action: string;
+            observed: string;
+        }>;
+    };
+    tests: {
+        added: Array<{
+            file: string;
+            cases: Array<{
+                name: string;
+                description: string;
+            }>;
+        }>;
+    };
+    discoveredIssues: DiscoveredIssue[];
+    skillFeedback?: string;
+    commitId?: string;
+    repoPath?: string;
+    successState: 'success' | 'partial' | 'failure';
+    returnToOrchestrator: boolean;
+    workerSessionId: string;
+};
+export type MissionValidationAssertionInfo = {
+    assertionId: string;
+    missionId: string;
+    featureId: string | null;
+    assertionText: string;
+    status: NativeMissionAssertionStatus;
+    note: string | null;
+    evidence: string | null;
+    confidence: MissionTraceConfidence | null;
+    createdAt: number;
+    updatedAt: number;
+};
+export type MissionInteractionInfo = {
+    interactionId: string;
+    missionId: string;
+    prompt: string;
+    status: MissionInteractionStatus;
+    position: number;
+    createdAt: number;
+    updatedAt: number;
+};
+export type MissionEvidenceSourceType = 'mission_event' | 'mission_attempt' | 'mission_snapshot' | 'mission_feature' | 'mission_assertion' | 'mission_interaction';
+export type MissionEvidenceRoleHint = 'orchestrator' | 'worker' | 'validator' | 'system' | 'user' | 'unknown';
+export type MissionEvidenceInfo = {
+    evidenceId: string;
+    missionId: string;
+    runtimeProvider: MissionRuntimeProvider;
+    sourceType: MissionEvidenceSourceType;
+    sourceRef: string;
+    eventTime: number;
+    roleHint: MissionEvidenceRoleHint;
+    payloadPreview: string;
+    payloadJson: Record<string, unknown>;
+    featureId?: string | null;
+};
+export type MissionTraceRole = 'orchestrator' | 'worker' | 'validator' | 'system' | 'user' | 'unknown';
+export type MissionTraceOperation = 'mission_lifecycle' | 'mission_plan' | 'milestone_start' | 'feature_queued' | 'feature_started' | 'feature_lifecycle' | 'worker_dispatch' | 'worker_prompt_built' | 'worker_output_received' | 'worker_tool_call' | 'handoff_created' | 'validation_started' | 'validation_result' | 'validation_assertion' | 'report_generated' | 'artifact_written' | 'retry_scheduled' | 'pause_requested' | 'pause_effective' | 'resume_requested' | 'resume_effective' | 'cancellation_requested' | 'cancellation_effective' | 'interaction_queued' | 'interaction_observed' | 'interaction_applied' | 'handoff_items_dismissed' | 'mission_event';
+export type MissionTraceConfidence = 'observed' | 'derived' | 'inferred' | 'unknown';
+export type MissionTraceInfo = {
+    traceId: string;
+    missionId: string;
+    runtimeProvider: MissionRuntimeProvider;
+    time: number;
+    role: MissionTraceRole;
+    operation: MissionTraceOperation;
+    confidence: MissionTraceConfidence;
+    summary: string;
+    details: Record<string, unknown>;
+    evidenceIds: string[];
+};
+export type MissionValidationPolicy = 'failOnFirst' | 'continueOnWarning';
+export type MissionRetryBackoff = 'fixed' | 'exponential';
+export type MissionRetryPolicy = {
+    maxRetries: number;
+    backoff: MissionRetryBackoff;
+    baseDelayMs?: number;
+    maxDelayMs?: number;
+};
+export type CreateMissionRequest = {
+    title: string;
+    description?: string;
+    runtimeProvider?: MissionRuntimeProvider;
+    nodeId?: string | null;
+    workspacePath: string;
+    missionDir?: string | null;
+    initiatorAgentId?: string | null;
+    controlConversationId?: string | null;
+    modelMode?: MissionModelMode;
+    orchestratorModel?: string | null;
+    workerModel?: string | null;
+    validatorModel?: string | null;
+    validationPolicy?: MissionValidationPolicy;
+    validationTimeoutMs?: number;
+    retryPolicy?: MissionRetryPolicy | null;
+};
+export type UpdateMissionRequest = {
+    title?: string;
+    description?: string | null;
+    runtimeProvider?: MissionRuntimeProvider;
+    nodeId?: string | null;
+    workspacePath?: string;
+    missionDir?: string | null;
+    initiatorAgentId?: string | null;
+    controlConversationId?: string | null;
+    modelMode?: MissionModelMode;
+    orchestratorModel?: string | null;
+    workerModel?: string | null;
+    validatorModel?: string | null;
+    validationPolicy?: MissionValidationPolicy;
+    validationTimeoutMs?: number;
+    retryPolicy?: MissionRetryPolicy | null;
+};
+export type DroidModelOptionInfo = {
+    id: string;
+    label: string;
+    source: string;
+    provider: string | null;
+    model: string | null;
+    recommendedFor: Array<'orchestrator' | 'worker' | 'validator' | 'session_default'>;
+};
+export type DroidModelOptionsInfo = {
+    options: DroidModelOptionInfo[];
+    defaults: {
+        orchestratorModel: string | null;
+        workerModel: string | null;
+        validatorModel: string | null;
+        sessionModel: string | null;
+    };
+    settingsPath: string;
+    loadedFromSettings: boolean;
+    loadedFromCliHelp: boolean;
+    error: string | null;
+};
+export type ImportMissionSnapshotRequest = {
+    source?: string;
+    snapshot: Record<string, unknown>;
+};
+export type ImportDroidMissionArtifactsRequest = Record<string, never>;
+export type RunDroidMissionRequest = {
+    nodeId?: string | null;
+};
+export type ContinueDroidMissionRequest = {
+    prompt: string;
+    nodeId?: string | null;
+};
+export type RecordMissionPhase1ClosureDecisionRequest = {
+    decision: 'accepted_paused_partial_boundary';
+    note?: string | null;
+};
+export type MissionContinuationReadinessInfo = {
+    ready: boolean;
+    reason: string;
+    mode: 'active_mailbox' | 'session_continuation' | 'unavailable';
+    missionDir: string | null;
+    factorySessionId: string | null;
+    rootFactorySessionId: string | null;
+    factoryArtifactDir: string | null;
+};
+export type ClaudeSessionModeId = 'default' | 'acceptEdits' | 'plan' | 'bypassPermissions';
+export type ClaudePermissionMode = Exclude<ClaudeSessionModeId, 'plan'>;
+export type CodexAppServerMode = 'default' | 'plan';
+export type CodexServiceTier = 'fast' | 'flex';
+export type ClaudeSessionModeDefinition = {
+    id: ClaudeSessionModeId;
+    label: string;
+    description: string;
+};
+export type ClaudeSessionModelDefinition = {
+    id: string;
+    label: string;
+    description?: string;
+    isDefault?: boolean;
+};
+export declare const CLAUDE_SESSION_MODEL_OPTIONS: readonly [{
+    readonly id: "claude-opus-4-6[1m]";
+    readonly label: "Opus 4.6 1M";
+    readonly description: "Opus 4.6 with 1M context window";
+}, {
+    readonly id: "claude-opus-4-6";
+    readonly label: "Opus 4.6";
+    readonly description: "Opus 4.6 · Most capable for complex work";
+    readonly isDefault: true;
+}, {
+    readonly id: "claude-sonnet-4-6";
+    readonly label: "Sonnet 4.6";
+    readonly description: "Sonnet 4.6 · Best for everyday tasks";
+}, {
+    readonly id: "claude-haiku-4-5";
+    readonly label: "Haiku 4.5";
+    readonly description: "Haiku 4.5 · Fastest for quick answers";
+}];
+export type ClaudeSessionCommandName = 'rewind';
+export type ClaudeSessionCommandDefinition = {
+    name: ClaudeSessionCommandName;
+    description: string;
+    argumentHint?: string;
+};
+export type ClaudeSessionControlState = {
+    sessionId: string | null;
+    modeId: ClaudeSessionModeId;
+    modelId: string | null;
+    effectiveModelId: string | null;
+    checkpointingEnabled: boolean;
+    availableModes: ClaudeSessionModeDefinition[];
+    availableModels: ClaudeSessionModelDefinition[];
+    availableCommands: ClaudeSessionCommandDefinition[];
+};
+export type ClaudeCommandExecutionResult = {
+    commandName: ClaudeSessionCommandName;
+    ok: boolean;
+    summary: string;
+    targetUserMessageUuid?: string;
+    canRewind?: boolean;
+    filesChanged?: string[];
+    insertions?: number;
+    deletions?: number;
+};
+export type RuntimeDriverDefinition = {
+    agentType: AgentType;
+    command: string;
+    args: string[];
+    supportsResume: boolean;
+    supportsPushNotifications: boolean;
+    capabilities: AgentRuntimeCapability[];
+    nativeMemoryBackend: 'claude' | 'workspace';
+    defaultEnv?: Record<string, string>;
+};
+export type AgentRuntimeCapability = 'activeTurnSteer' | 'planApprovalLoop';
+export declare const AGENT_RUNTIME_CAPABILITIES: Record<AgentType, AgentRuntimeCapability[]>;
+export declare function listAgentRuntimeCapabilities(agentType: AgentType): AgentRuntimeCapability[];
+export declare function hasAgentRuntimeCapability(agentType: AgentType, capability: AgentRuntimeCapability): boolean;
+export declare const CODEX_ACP_DEFAULT_ARGS: readonly ["-c", "sandbox_mode=\"danger-full-access\"", "-c", "approval_policy=\"never\"", "-c", "features.memories=false", "-c", "memories.use_memories=false", "-c", "memories.generate_memories=false"];
+export declare const RUNTIME_DRIVERS: Record<AgentType, RuntimeDriverDefinition>;
+export declare function getRuntimeDriver(agentType: AgentType): RuntimeDriverDefinition;
+export declare function listRuntimeDrivers(): RuntimeDriverDefinition[];
+export declare const BEIJING_TIME_ZONE = "Asia/Shanghai";
+type TimeInput = number | string | Date;
+export declare function formatBeijingDateTime(input: TimeInput, options?: {
+    withSeconds?: boolean;
+}): string;
+export declare function formatBeijingPromptTimestamp(input: TimeInput): string;
+export declare function formatBeijingMonthDayTime(input: TimeInput, options?: {
+    withSeconds?: boolean;
+}): string;
+export declare function formatBeijingTime(input: TimeInput, options?: {
+    withSeconds?: boolean;
+}): string;
+export declare const THREAD_SHORT_ID_LENGTH = 16;
+export declare function stripIgnoredMentionContexts(content: string): string;
+export declare function extractMentionedNames(content: string): string[];
+export declare function normalizeThreadShortIdInput(threadRootId: string | null | undefined): string | null;
+export declare function normalizeMessageIdForThreadShortId(messageId: string): string;
+export declare function buildThreadShortId(messageId: string): string;
+export type RecentMessageSourceType = 'dm' | 'channel' | 'thread' | 'task';
+export type RecentMessageSourceItem = {
+    sourceKey: string;
+    sourceType: RecentMessageSourceType;
+    channelId: string;
+    channelName?: string | null;
+    agentId?: string | null;
+    agentName?: string | null;
+    threadRootId?: string | null;
+    taskRef?: string | null;
+    taskNumber?: number | null;
+    taskTitle?: string | null;
+    latestMessageId: string;
+    latestSeq: number;
+    latestCreatedAt: string;
+    latestSenderName: string;
+    latestSenderType: 'user' | 'agent' | 'system';
+    latestSnippet: string;
+    unreadCount: number;
+};
+export declare function buildRecentMessageSourceKey(params: {
+    sourceType: RecentMessageSourceType;
+    channelId?: string | null;
+    agentId?: string | null;
+    threadRootId?: string | null;
+}): string;
+export declare function parseRecentMessageSourceKey(sourceKey: string): ({
+    sourceType: 'dm';
+    agentId: string;
+} | {
+    sourceType: 'channel';
+    channelId: string;
+} | {
+    sourceType: 'thread' | 'task';
+    channelId: string;
+    threadRootId: string;
+}) | null;
+export type ConversationStatusEvent = {
+    type: 'conversation.status';
+    status: ConversationStatus;
+    conversationId: string;
+};
+export type TurnBeginEvent = {
+    type: 'turn.begin';
+    turnId: string;
+    startedAt?: number;
+    promptText?: string;
+};
+export type TurnEndEvent = {
+    type: 'turn.end';
+    turnId: string;
+    stopReason?: string;
+    endedAt?: number;
+    error?: string;
+};
+export type ContentDeltaEvent = {
+    type: 'content.delta';
+    text: string;
+};
+export type ActivityDeltaEvent = {
+    type: 'activity.delta';
+    text: string;
+};
+export type ThinkingDeltaEvent = {
+    type: 'thinking.delta';
+    text: string;
+};
+export type PlanUpdateEvent = {
+    type: 'plan.update';
+    title: string;
+    detail?: string;
+    createdAt?: number;
+};
+export type PlanPhaseEvent = {
+    type: 'plan.phase';
+    phase: 'planning' | 'implementation';
+    createdAt?: number;
+};
+export type TaskUpdateEvent = {
+    type: 'task.update';
+    title: string;
+    detail?: string;
+    createdAt?: number;
+};
+export type ToolCallEvent = {
+    type: 'tool.call';
+    toolCallId: string;
+    name: string;
+    input: unknown;
+    detail?: string;
+    status?: 'running' | 'completed' | 'failed' | 'cancelled';
+    metadata?: Record<string, unknown>;
+    startedAt?: number;
+};
+export type ToolResultEvent = {
+    type: 'tool.result';
+    toolCallId: string;
+    output: string;
+    detail?: string;
+    error?: boolean;
+    status?: 'completed' | 'failed' | 'cancelled';
+    metadata?: Record<string, unknown>;
+    endedAt?: number;
+};
+export type AgentFileAccessKind = 'file' | 'directory' | 'unknown';
+export type ChatFileReference = {
+    accessId: string;
+    token: string;
+    absolutePath: string;
+    kind: AgentFileAccessKind;
+};
+export type RunUsageEvent = {
+    type: 'run.usage';
+    inputTokens?: number;
+    cachedInputTokens?: number;
+    outputTokens?: number;
+    reasoningOutputTokens?: number;
+    totalTokens?: number;
+    currentInputTokens?: number;
+    currentCachedInputTokens?: number;
+    modelContextWindow?: number;
+    createdAt?: number;
+    metadata?: Record<string, unknown>;
+};
+export type RuntimeCompactEvent = {
+    type: 'runtime.compact';
+    threadId: string;
+    turnId: string;
+    itemId?: string;
+    source: 'thread_compacted' | 'raw_response_item' | 'thread_item';
+    eventKey: string;
+    createdAt?: number;
+};
+export type RunSteerResultEvent = {
+    type: 'run.steer.result';
+    requestId: string;
+    runId: string;
+    ok: boolean;
+    error?: string;
+    createdAt?: number;
+};
+export type ApprovalRequestEvent = {
+    type: 'approval.request';
+    requestId: string;
+    toolName: string;
+    toolArgs: unknown;
+    toolKind?: string | null;
+    approvalKind?: 'tool' | 'plan' | 'question';
+    title?: string;
+    description?: string;
+    input?: unknown;
+    actions?: ApprovalAction[];
+};
+export type ErrorEvent = {
+    type: 'error';
+    message: string;
+};
+export type HistoryCompleteEvent = {
+    type: 'history.complete';
+};
+export type HistoryResetEvent = {
+    type: 'history.reset';
+};
+export type PeerDeliveryIntent = 'silent' | 'batch' | 'immediate';
+export type HistoryUserMessageEvent = {
+    type: 'history.user_message';
+    text: string;
+};
+export type ChannelMessageEvent = {
+    type: 'channel.message';
+    message: {
+        id: string;
+        senderId?: string;
+        senderName: string;
+        senderDeleted?: boolean;
+        senderType: 'user' | 'agent' | 'system';
+        content: string;
+        createdAt: string;
+        deletedAt?: string | null;
+        deletedByName?: string | null;
+        seq?: number;
+        /** Thread short ID derived from the root message ID. Present only for thread replies. */
+        threadRootId?: string;
+        /** Present on root messages when the thread surface exists even if it has no visible replies yet. */
+        threadActive?: boolean;
+        /** Present only when the message was synthesized from raw deltas as a fallback. */
+        messageSource?: string;
+        /** DB message_kind for special chat projections such as plan or final. */
+        messageKind?: string;
+        /** Agent-declared peer notification delivery for shared channel/thread messages. */
+        peerDelivery?: PeerDeliveryIntent;
+        /** Present when this message IS a task thread root. */
+        taskNumber?: number;
+        taskRef?: string | null;
+        taskDescription?: string | null;
+        taskStatus?: string;
+        taskAssigneeName?: string | null;
+        taskAssigneeDeleted?: boolean;
+        taskThreadStatus?: ConversationStatus | null;
+        /** Attachment UUIDs uploaded with this message. */
+        attachmentIds?: string[];
+        /** Asset UUIDs uploaded with this message. Compatibility alias of attachmentIds. */
+        assetIds?: string[];
+        /** File references proven by same-run tool access records. */
+        fileRefs?: ChatFileReference[];
+        /** Persisted run that produced this message, when available. */
+        runId?: string | null;
+        /** Panel IDs attached to this message. */
+        panelIds?: string[];
+        /** Ephemeral Panel preview IDs attached to this message. */
+        panelPreviewIds?: string[];
+        /** Workspace Tool IDs attached to this message. */
+        toolIds?: string[];
+    };
+};
+export type ChannelMessageDeletedEvent = {
+    type: 'channel.message.deleted';
+    channelId: string;
+    messageId: string;
+    threadRootId?: string | null;
+    seq: number;
+    deletedAt: string;
+    deletedByName?: string | null;
+};
+export type ChannelNoticeEvent = {
+    type: 'channel.notice';
+    notice: {
+        message: string;
+        createdAt: string;
+    };
+};
+export type ChannelHistoryResetEvent = {
+    type: 'channel.history.reset';
+};
+export type ChannelTasksChangedEvent = {
+    type: 'channel.tasks.changed';
+    channelId: string;
+    changedAt: number;
+};
+export type ChannelConversationStatusEvent = {
+    type: 'channel.conversation.status';
+    channelId: string;
+    conversation: ConversationInfo;
+};
+export type SystemNoticeEvent = {
+    type: 'system.notice';
+    message: string;
+};
+export type PanelSharedStateUpdatedEvent = {
+    type: 'panel.shared_state_updated';
+    panelId: string;
+    shared: Record<string, unknown>;
+    version: number;
+    updatedByUserId?: string;
+    updatedAt?: number;
+    threadRootId?: string;
+};
+export type PanelActionTriggeredEvent = {
+    type: 'panel.action_triggered';
+    panelId: string;
+    submitKind?: PanelSubmitKind;
+    actionId?: string;
+    triggeredByUserId: string;
+    triggeredAt?: number;
+    threadRootId?: string;
+};
+export type PanelUpdatedEvent = {
+    type: 'panel.updated';
+    panelId: string;
+    version: number;
+    changed: Array<'props' | 'actions' | 'rows' | 'status' | 'progress' | 'result'>;
+    updatedAt?: number;
+    threadRootId?: string;
+};
+export type PanelDeletedEvent = {
+    type: 'panel.deleted';
+    panelId: string;
+    deletedAt: number;
+    threadRootId?: string;
+};
+export type WorkspaceToolStateUpdatedEvent = {
+    type: 'workspace_tool.state_updated';
+    toolId: string;
+    state: WorkspaceToolStateRow | null;
+    updatedAt: number;
+};
+export type MessageReactionSummary = {
+    emoji: string;
+    count: number;
+    reactors: Array<{
+        id: string;
+        name: string;
+        type: 'user' | 'agent';
+    }>;
+};
+export type ChannelMessageReactionEvent = {
+    type: 'channel.message.reaction';
+    channelId: string;
+    messageId: string;
+    reactions: MessageReactionSummary[];
+};
+export type ServerEvent = ConversationStatusEvent | TurnBeginEvent | TurnEndEvent | ContentDeltaEvent | ActivityDeltaEvent | ThinkingDeltaEvent | PlanUpdateEvent | PlanPhaseEvent | TaskUpdateEvent | ToolCallEvent | ToolResultEvent | RunUsageEvent | RuntimeCompactEvent | RunSteerResultEvent | ApprovalRequestEvent | ErrorEvent | HistoryCompleteEvent | HistoryResetEvent | HistoryUserMessageEvent | ChannelMessageEvent | ChannelMessageDeletedEvent | ChannelNoticeEvent | ChannelHistoryResetEvent | ChannelTasksChangedEvent | ChannelConversationStatusEvent | SystemNoticeEvent | PanelSharedStateUpdatedEvent | PanelActionTriggeredEvent | PanelUpdatedEvent | PanelDeletedEvent | WorkspaceToolStateUpdatedEvent | ChannelMessageReactionEvent;
+export type FileRef = {
+    uri: string;
+    mimeType?: string;
+    assetId?: string;
+    filename?: string;
+    sizeBytes?: number;
+    assetKind?: AssetKind;
+    scopeType?: AssetScopeType;
+    scopeId?: string;
+    canonicalUri?: string;
+    canonicalPath?: string;
+    preferredLocalPath?: string;
+};
+export type AssetKind = 'image' | 'text' | 'code' | 'json' | 'binary';
+export type AssetScopeType = 'direct_conversation' | 'channel' | 'thread' | 'agent_upload';
+export type PromptRuntimeOverrides = {
+    planMode?: boolean | null;
+    codexMode?: CodexAppServerMode | null;
+};
+export type ConversationPromptSlashCommand = {
+    name: string;
+    bodyText: string;
+};
+export type ApprovalAction = {
+    id: string;
+    label: string;
+    variant?: 'primary' | 'secondary' | 'danger';
+    requiresInput?: boolean;
+    inputPlaceholder?: string;
+};
+export type ApprovalQuestionOption = {
+    label: string;
+    description?: string;
+};
+export type ApprovalQuestion = {
+    id: string;
+    header: string;
+    question: string;
+    options: ApprovalQuestionOption[];
+    multiSelect?: boolean;
+    isOther?: boolean;
+    isSecret?: boolean;
+};
+export type PromptEvent = {
+    type: 'prompt';
+    text: string;
+    attachments?: FileRef[];
+    runtimeOverrides?: PromptRuntimeOverrides;
+};
+export type ApprovalResponseEvent = {
+    type: 'approval.response';
+    requestId: string;
+    decision: 'allow' | 'deny';
+    selectedActionId?: string;
+    responseText?: string;
+    answers?: Record<string, string[]>;
+};
+export type CancelEvent = {
+    type: 'cancel';
+};
+export type ClientEvent = PromptEvent | ApprovalResponseEvent | CancelEvent;
+export type NodeRegisterMsg = {
+    type: 'node.register';
+    nodeId: string;
+    processInstanceId?: string;
+    hostname: string;
+    agentTypes: string[];
+    version: string;
+    terminalBackendAvailable: boolean;
+};
+export type NodeHeartbeatMsg = {
+    type: 'node.heartbeat';
+    nodeId: string;
+};
+export type NodeHostState = 'idle' | 'active' | 'failed';
+export type NodeHostSnapshot = {
+    hostKey: string;
+    hostInstanceId?: string | null;
+    sessionKey: string;
+    workspaceRoot: string;
+    agentType: AgentType;
+    state: NodeHostState;
+    currentRunId: string | null;
+    hasPendingApproval: boolean;
+    inboxSize: number;
+    pendingDispatchCount: number;
+    lastWakeAt: number | null;
+    lastSleepAt: number | null;
+    lastError: string | null;
+    resumable: boolean;
+};
+export type NodeHostsSnapshotMsg = {
+    type: 'node.hosts.snapshot';
+    nodeId: string;
+    generatedAt: number;
+    hosts: NodeHostSnapshot[];
+};
+export type AssetMaterializedMsg = {
+    type: 'asset.materialized';
+    assetId: string;
+    agentId: string;
+    conversationId: string;
+    nodeProcessInstanceId: string;
+    hostKey: string;
+    hostInstanceId: string;
+    runId?: string | null;
+    localPath: string;
+    materializedAt: number;
+};
+export type AssetMaterializationClearedMsg = {
+    type: 'asset.materialization.cleared';
+    nodeProcessInstanceId: string;
+    hostKey: string;
+    hostInstanceId: string;
+    clearedAt: number;
+    reason?: 'host_closed' | 'cache_cleared' | 'node_shutdown';
+};
+export type NodeRuntimeDriverInventory = {
+    agentType: AgentType;
+    command: string;
+    args: string[];
+    supportsResume: boolean;
+    supportsPushNotifications: boolean;
+    capabilities: AgentRuntimeCapability[];
+    nativeMemoryBackend: 'claude' | 'workspace';
+    supportsClaudeSessionControls: boolean;
+};
+export type NodeRuntimeCapabilities = {
+    envProfile?: string | null;
+    agentSurfaceMode?: AgentSurfaceMode;
+    bigbangCliAvailable?: boolean;
+    builtinSkillRoots?: string[];
+    panelApiJsonlAllowedOrigins?: string[];
+    panelApiJsonlAllowedUrlPrefixes?: string[];
+    panelApiJsonlAuthProfiles?: string[];
+    workspaceRpc: boolean;
+    workspaceInspect: boolean;
+    workspaceGit: boolean;
+    terminals: boolean;
+    skills: boolean;
+    codexAppServerRpc: boolean;
+    codexTranscripts: boolean;
+    claudeTranscripts: boolean;
+    claudeControls: boolean;
+    nativeMissionWorker: boolean;
+};
+export type NodeRuntimeSnapshot = {
+    workspaceRoot: string;
+    terminalBackendAvailable: boolean;
+    runtimeDrivers: NodeRuntimeDriverInventory[];
+    capabilities: NodeRuntimeCapabilities;
+};
+export type NodeRuntimeSnapshotMsg = {
+    type: 'node.runtime.snapshot';
+    nodeId: string;
+    processInstanceId?: string | null;
+    generatedAt: number;
+    runtime: NodeRuntimeSnapshot;
+};
+export type MissionRunAcceptedMsg = {
+    type: 'mission.run.accepted';
+    requestId: string;
+    missionId: string;
+    runtimeProvider?: MissionRuntimeProvider;
+    missionDir: string;
+    pid?: number | null;
+    featureId?: string | null;
+};
+export type DroidMissionRunAcceptedMsg = MissionRunAcceptedMsg;
+export type NativeMissionRunAcceptedMsg = MissionRunAcceptedMsg & {
+    runtimeProvider: 'bigbang_native';
+    featureId?: string;
+};
+export type MissionRunEventMsg = {
+    type: 'mission.run.event';
+    requestId: string;
+    missionId: string;
+    runtimeProvider?: MissionRuntimeProvider;
+    eventType: string;
+    eventTime: number;
+    source: string;
+    payload: Record<string, unknown>;
+    featureId?: string | null;
+};
+export type DroidMissionRunEventMsg = MissionRunEventMsg;
+export type NativeMissionRunEventMsg = MissionRunEventMsg & {
+    runtimeProvider: 'bigbang_native';
+    featureId?: string;
+};
+export type MissionRunEndMsg = {
+    type: 'mission.run.end';
+    requestId: string;
+    missionId: string;
+    runtimeProvider?: MissionRuntimeProvider;
+    missionDir: string;
+    factorySessionId?: string | null;
+    factoryArtifactDir?: string | null;
+    exitCode?: number | null;
+    signal?: string | null;
+    error?: string;
+    reason?: string | null;
+    featureId?: string | null;
+    output?: Record<string, unknown> | null;
+    handoff?: Record<string, unknown> | null;
+};
+export type DroidMissionRunEndMsg = MissionRunEndMsg;
+export type NativeMissionRunEndMsg = MissionRunEndMsg & {
+    runtimeProvider: 'bigbang_native';
+    featureId?: string;
+};
+export type MissionRunCancelMsg = {
+    type: 'mission.run.cancel';
+    requestId: string;
+    missionId: string;
+    runtimeProvider?: MissionRuntimeProvider;
+    featureId?: string | null;
+};
+export type DroidMissionContinuationInspectRequestMsg = {
+    type: 'mission.continuation.inspect.request';
+    requestId: string;
+    missionId: string;
+    workspaceRoot: string;
+    missionDir: string;
+};
+export type DroidMissionContinuationInspectResponseMsg = {
+    type: 'mission.continuation.inspect.response';
+    requestId: string;
+    missionId: string;
+    missionDir: string | null;
+    rootFactorySessionId?: string | null;
+    factorySessionId?: string | null;
+    factoryArtifactDir?: string | null;
+    error?: string | null;
+};
+/** Agent subprocess event forwarded by node to core */
+export type RunEventMsg = {
+    type: 'run.event';
+    runId: string;
+    conversationId: string;
+    event: ServerEvent;
+};
+export type RunEndMsg = {
+    type: 'run.end';
+    runId: string;
+    conversationId: string;
+    stopReason?: string;
+    error?: string;
+};
+export type RunSteerResultMsg = {
+    type: 'run.steer.result';
+    requestId: string;
+    runId: string;
+    conversationId: string;
+    ok: boolean;
+    error?: string;
+};
+export type NotificationDeliveryMetadata = {
+    deliveryId: string;
+    roundId: string;
+    ackedThroughSeq: number;
+    surfaceKey: string;
+};
+export type RunDeliveryAckMsg = {
+    type: 'run.delivery.ack';
+    deliveryId: string;
+    roundId: string;
+    runId: string;
+    conversationId: string;
+    ackedThroughSeq: number;
+    mode: 'dispatch' | 'steer';
+};
+export type RunAcceptedMsg = {
+    type: 'run.accepted';
+    runId: string;
+    conversationId: string;
+};
+export type NodePermissionRequestMsg = {
+    type: 'permission.request';
+    runId: string;
+    conversationId: string;
+    requestId: string;
+    toolName: string;
+    toolArgs: unknown;
+    toolKind?: string | null;
+    approvalKind?: 'tool' | 'plan' | 'question';
+    title?: string;
+    description?: string;
+    input?: unknown;
+    actions?: ApprovalAction[];
+};
+export type WorkspaceErrorCode = 'invalid_request' | 'not_found' | 'not_directory' | 'not_file' | 'path_outside_workspace' | 'binary_file' | 'file_too_large' | 'io_error';
+export type WorkspaceWriteMode = 'overwrite' | 'append';
+export type WorkspaceWriteContentEncoding = 'utf8' | 'base64';
+export type AgentWorkspaceEntry = {
+    name: string;
+    path: string;
+    kind: 'directory' | 'file';
+    size: number | null;
+    modifiedAt: number | null;
+    isSymlink?: boolean;
+};
+export type AgentFileAccessDirectoryEntry = AgentWorkspaceEntry & {
+    canOpen?: boolean;
+    entryToken?: string;
+};
+export type DirectoryPageInfo = {
+    nextCursor: string | null;
+    hasMore: boolean;
+    limit: number;
+};
+export type AgentSkillEntry = {
+    name: string;
+    path: string;
+    kind: 'directory' | 'file';
+    size: number | null;
+    modifiedAt: number | null;
+};
+export type AgentSkillSummary = {
+    name: string;
+    path: string;
+    sourceRoot: string;
+    description?: string;
+};
+export type CodexReasoningEffort = 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
+export type CodexModelDefinition = {
+    id: string;
+    model: string;
+    displayName: string;
+    description?: string;
+    hidden: boolean;
+    supportedReasoningEfforts: CodexReasoningEffort[];
+    defaultReasoningEffort?: CodexReasoningEffort | null;
+    additionalSpeedTiers: string[];
+    isDefault: boolean;
+};
+export type CodexModelListResult = {
+    models: CodexModelDefinition[];
+    nextCursor: string | null;
+    defaultModel: string | null;
+};
+export type CodexNativeSkillMetadata = {
+    name: string;
+    description: string;
+    shortDescription?: string;
+    path: string;
+    scope?: string;
+    enabled: boolean;
+    interface?: unknown;
+    dependencies?: unknown;
+};
+export type CodexNativeSkillListEntry = {
+    cwd: string;
+    skills: CodexNativeSkillMetadata[];
+    errors: unknown[];
+};
+export type CodexNativeSkillListResult = {
+    data: CodexNativeSkillListEntry[];
+};
+export type CodexThreadSummary = {
+    id: string;
+    forkedFromId?: string | null;
+    preview: string;
+    createdAt: number;
+    updatedAt: number;
+    status: string;
+    path?: string | null;
+    cwd: string;
+    modelProvider?: string;
+    source?: unknown;
+    name?: string | null;
+    turns?: unknown[];
+};
+export type CodexThreadListResult = {
+    threads: CodexThreadSummary[];
+    nextCursor: string | null;
+    backwardsCursor: string | null;
+};
+export type CodexThreadReadResult = {
+    thread: CodexThreadSummary;
+};
+export type CodexConversationSummaryRequestMsg = {
+    type: 'codex.conversation.summary.request';
+    requestId: string;
+    prompt: string;
+    envVars?: Record<string, string>;
+};
+export type CodexConversationSummaryResponseMsg = {
+    type: 'codex.conversation.summary.response';
+    requestId: string;
+    content?: string;
+    error?: string;
+};
+export type WorkspaceListResponseMsg = {
+    type: 'workspace.list.response';
+    requestId: string;
+    relativePath: string;
+    entries?: AgentWorkspaceEntry[];
+    directoryPage?: DirectoryPageInfo;
+    error?: string;
+    errorCode?: WorkspaceErrorCode;
+};
+export type WorkspacePreviewMimeType = 'text/markdown' | 'text/plain' | 'image/png' | 'image/jpeg' | 'image/webp' | 'image/gif' | 'image/svg+xml' | 'image/avif' | 'image/bmp' | 'image/x-icon';
+export type WorkspaceReadResponseMsg = {
+    type: 'workspace.read.response';
+    requestId: string;
+    relativePath: string;
+    content?: string;
+    mimeType?: WorkspacePreviewMimeType;
+    size?: number;
+    modifiedAt?: number | null;
+    offset?: number;
+    limit?: number;
+    nextOffset?: number | null;
+    hasMore?: boolean;
+    error?: string;
+    errorCode?: WorkspaceErrorCode;
+};
+export type WorkspaceArchiveResponseMsg = {
+    type: 'workspace.archive.response';
+    requestId: string;
+    relativePath: string;
+    archiveBase64?: string;
+    byteSize?: number;
+    fileCount?: number;
+    error?: string;
+    errorCode?: WorkspaceErrorCode;
+};
+export type WorkspaceExtractResponseMsg = {
+    type: 'workspace.extract.response';
+    requestId: string;
+    relativePath: string;
+    ok?: boolean;
+    byteSize?: number;
+    fileCount?: number;
+    error?: string;
+    errorCode?: WorkspaceErrorCode;
+};
+export type FsReadPathResponseMsg = {
+    type: 'fs.read_path.response';
+    requestId: string;
+    absolutePath: string;
+    kind?: AgentFileAccessKind;
+    content?: string;
+    rawContentBase64?: boolean;
+    entries?: AgentWorkspaceEntry[];
+    directoryPage?: DirectoryPageInfo;
+    mimeType?: WorkspacePreviewMimeType;
+    size?: number;
+    modifiedAt?: number | null;
+    offset?: number;
+    limit?: number;
+    nextOffset?: number | null;
+    hasMore?: boolean;
+    error?: string;
+    errorCode?: WorkspaceErrorCode;
+};
+export type HttpFetchTextResponseMsg = {
+    type: 'http.fetch_text.response';
+    requestId: string;
+    url: string;
+    content?: string;
+    status?: number;
+    contentType?: string | null;
+    size?: number;
+    partialContent?: boolean;
+    rangeStart?: number;
+    rangeEnd?: number;
+    totalSize?: number | null;
+    hasMore?: boolean;
+    notModified?: boolean;
+    etag?: string | null;
+    lastModified?: string | null;
+    error?: string;
+    errorCode?: WorkspaceErrorCode;
+};
+export type WorkspaceServiceProxyMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+export type WorkspaceServiceProxyResponseMsg = {
+    type: 'workspace.service_proxy.response';
+    requestId: string;
+    url: string;
+    method: WorkspaceServiceProxyMethod;
+    status?: number;
+    body?: string;
+    contentType?: string | null;
+    size?: number;
+    error?: string;
+    errorCode?: WorkspaceErrorCode;
+};
+export type FsPathSuggestion = {
+    path: string;
+    name: string;
+    parentPath: string;
+    isGitRepo: boolean;
+};
+export type FsPathSuggestResponseMsg = {
+    type: 'fs.path_suggest.response';
+    requestId: string;
+    query: string;
+    suggestions?: FsPathSuggestion[];
+    error?: string;
+    errorCode?: WorkspaceErrorCode;
+};
+export type FsReadPathStreamStartMsg = {
+    type: 'fs.read_path.stream.start';
+    requestId: string;
+    absolutePath: string;
+    mimeType: WorkspacePreviewMimeType;
+    size: number;
+    modifiedAt?: number | null;
+};
+export type FsReadPathStreamChunkMsg = {
+    type: 'fs.read_path.stream.chunk';
+    requestId: string;
+    encoding: 'base64';
+    chunk: string;
+};
+export type FsReadPathStreamEndMsg = {
+    type: 'fs.read_path.stream.end';
+    requestId: string;
+    error?: string;
+    errorCode?: WorkspaceErrorCode;
+};
+export type WorkspaceWriteResponseMsg = {
+    type: 'workspace.write.response';
+    requestId: string;
+    relativePath: string;
+    ok?: boolean;
+    modifiedAt?: number | null;
+    error?: string;
+    errorCode?: WorkspaceErrorCode;
+};
+export type WorkspaceDeleteFileResponseMsg = {
+    type: 'workspace.delete_file.response';
+    requestId: string;
+    relativePath: string;
+    ok?: boolean;
+    error?: string;
+    errorCode?: WorkspaceErrorCode;
+};
+export type WorkspaceDeletePathResponseMsg = {
+    type: 'workspace.delete_path.response';
+    requestId: string;
+    relativePath: string;
+    ok?: boolean;
+    error?: string;
+    errorCode?: WorkspaceErrorCode;
+};
+export type LibraryMirrorFileEntry = {
+    path: string;
+    content: string;
+    sha256: string;
+};
+export type LibraryMirrorTree = {
+    files: LibraryMirrorFileEntry[];
+};
+export type LibraryMirrorApplyRequestMsg = {
+    type: 'library.mirror.apply.request';
+    requestId: string;
+    workspaceRoot: string;
+    shared: LibraryMirrorTree | null;
+    personal: LibraryMirrorTree | null;
+};
+export type LibraryMirrorApplyResponseMsg = {
+    type: 'library.mirror.apply.response';
+    requestId: string;
+    ok?: boolean;
+    error?: string;
+};
+export type LibraryMirrorSnapshotRequestMsg = {
+    type: 'library.mirror.snapshot.request';
+    requestId: string;
+    workspaceRoot: string;
+};
+export type LibraryMirrorSnapshotResponseMsg = {
+    type: 'library.mirror.snapshot.response';
+    requestId: string;
+    shared?: LibraryMirrorTree | null;
+    personal?: LibraryMirrorTree | null;
+    error?: string;
+};
+export type LibraryAuthorityDeleteRequestMsg = {
+    type: 'library.authority.delete.request';
+    requestId: string;
+    libraryRoot: string;
+    relativePath: string;
+    recursive?: boolean;
+    agentName?: string;
+};
+export type LibraryAuthorityDeleteResponseMsg = {
+    type: 'library.authority.delete.response';
+    requestId: string;
+    ok?: boolean;
+    error?: string;
+    errorCode?: WorkspaceErrorCode;
+};
+export type LibraryAuthorityRenameRequestMsg = {
+    type: 'library.authority.rename.request';
+    requestId: string;
+    libraryRoot: string;
+    relativePath: string;
+    nextRelativePath: string;
+    agentName?: string;
+};
+export type LibraryAuthorityRenameResponseMsg = {
+    type: 'library.authority.rename.response';
+    requestId: string;
+    ok?: boolean;
+    error?: string;
+    errorCode?: WorkspaceErrorCode;
+};
+export type WorkspaceResetRequestMsg = {
+    type: 'workspace.reset.request';
+    requestId: string;
+    workspaceRoot: string;
+    agentName?: string;
+};
+export type WorkspaceResetResponseMsg = {
+    type: 'workspace.reset.response';
+    requestId: string;
+    workspaceRoot: string;
+    ok?: boolean;
+    error?: string;
+    errorCode?: WorkspaceErrorCode;
+};
+export type WorkbenchWorkspaceKind = 'local_checkout' | 'worktree' | 'directory';
+export type WorkspaceInspectResult = {
+    workspaceRoot: string;
+    isGit: boolean;
+    repoRoot: string | null;
+    workspaceKind: WorkbenchWorkspaceKind;
+    branchName: string | null;
+    remoteUrl: string | null;
+};
+export type WorkspaceInspectRequestMsg = {
+    type: 'workspace.inspect.request';
+    requestId: string;
+    workspaceRoot: string;
+};
+export type WorkspaceInspectResponseMsg = {
+    type: 'workspace.inspect.response';
+    requestId: string;
+    inspect?: WorkspaceInspectResult;
+    error?: string;
+    errorCode?: WorkspaceErrorCode;
+};
+export type WorkbenchGitDiffMode = 'uncommitted' | 'base';
+export type WorkbenchGitAheadBehind = {
+    ahead: number;
+    behind: number;
+};
+export type WorkbenchGitStatusResult = {
+    workspaceRoot: string;
+    isGit: boolean;
+    repoRoot: string | null;
+    workspaceKind: WorkbenchWorkspaceKind;
+    branchName: string | null;
+    remoteUrl: string | null;
+    baseRef: string | null;
+    hasRemote: boolean;
+    isDirty: boolean;
+    changedFiles: number;
+    stagedFiles: number;
+    unstagedFiles: number;
+    untrackedFiles: number;
+    aheadOfOrigin: number;
+    behindOfOrigin: number;
+    aheadBehind: WorkbenchGitAheadBehind | null;
+};
+export type WorkbenchGitDiffLineType = 'context' | 'add' | 'remove' | 'header';
+export type WorkbenchGitDiffLine = {
+    type: WorkbenchGitDiffLineType;
+    content: string;
+    oldLineNumber: number | null;
+    newLineNumber: number | null;
+};
+export type WorkbenchGitDiffHunk = {
+    header: string;
+    lines: WorkbenchGitDiffLine[];
+};
+export type WorkbenchGitDiffFileStatus = 'modified' | 'added' | 'deleted' | 'renamed' | 'copied' | 'untracked' | 'type_changed' | 'conflicted' | 'unknown';
+export type WorkbenchGitDiffFile = {
+    path: string;
+    oldPath: string | null;
+    status: WorkbenchGitDiffFileStatus;
+    isNew: boolean;
+    isDeleted: boolean;
+    isUntracked: boolean;
+    hunks: WorkbenchGitDiffHunk[];
+};
+export type WorkbenchGitDiffResult = {
+    workspaceRoot: string;
+    isGit: boolean;
+    mode: WorkbenchGitDiffMode;
+    baseRef: string | null;
+    files: WorkbenchGitDiffFile[];
+};
+export type WorkbenchGitAction = 'fetch' | 'pull_ff_only' | 'commit_all' | 'push';
+export type WorkbenchGitActionResult = {
+    workspaceRoot: string;
+    action: WorkbenchGitAction;
+    stdout: string;
+    stderr: string;
+    branchName: string | null;
+};
+export type ClaudeControlConversationTarget = {
+    conversationId: string;
+    sessionKey: string;
+    hostKey: string;
+    workspaceRoot: string;
+    envVars?: Record<string, string>;
+    disabledToolKinds?: AgentPermissionKind[];
+};
+export type WorkspaceGitStatusRequestMsg = {
+    type: 'workspace.git_status.request';
+    requestId: string;
+    workspaceRoot: string;
+};
+export type WorkspaceGitStatusResponseMsg = {
+    type: 'workspace.git_status.response';
+    requestId: string;
+    status?: WorkbenchGitStatusResult;
+    error?: string;
+    errorCode?: WorkspaceErrorCode;
+};
+export type WorkspaceGitDiffRequestMsg = {
+    type: 'workspace.git_diff.request';
+    requestId: string;
+    workspaceRoot: string;
+    mode: WorkbenchGitDiffMode;
+};
+export type WorkspaceGitDiffResponseMsg = {
+    type: 'workspace.git_diff.response';
+    requestId: string;
+    diff?: WorkbenchGitDiffResult;
+    error?: string;
+    errorCode?: WorkspaceErrorCode;
+};
+export type WorkspaceGitActionRequestMsg = {
+    type: 'workspace.git_action.request';
+    requestId: string;
+    workspaceRoot: string;
+    action: WorkbenchGitAction;
+    commitMessage?: string;
+};
+export type WorkspaceGitActionResponseMsg = {
+    type: 'workspace.git_action.response';
+    requestId: string;
+    result?: WorkbenchGitActionResult;
+    error?: string;
+    errorCode?: WorkspaceErrorCode;
+};
+export type ClaudeControlsRequestMsg = {
+    type: 'claude.controls.request';
+    requestId: string;
+    target: ClaudeControlConversationTarget;
+};
+export type ClaudeControlsResponseMsg = {
+    type: 'claude.controls.response';
+    requestId: string;
+    controls?: ClaudeSessionControlState;
+    error?: string;
+};
+export type ClaudeSetModeRequestMsg = {
+    type: 'claude.set_mode.request';
+    requestId: string;
+    target: ClaudeControlConversationTarget;
+    modeId: ClaudeSessionModeId;
+};
+export type ClaudeSetModeResponseMsg = {
+    type: 'claude.set_mode.response';
+    requestId: string;
+    controls?: ClaudeSessionControlState;
+    error?: string;
+};
+export type ClaudeSetModelRequestMsg = {
+    type: 'claude.set_model.request';
+    requestId: string;
+    target: ClaudeControlConversationTarget;
+    modelId?: string | null;
+};
+export type ClaudeSetModelResponseMsg = {
+    type: 'claude.set_model.response';
+    requestId: string;
+    controls?: ClaudeSessionControlState;
+    error?: string;
+};
+export type CodexModelListRequestMsg = {
+    type: 'codex.model.list.request';
+    requestId: string;
+    workspaceRoot?: string | null;
+    cursor?: string | null;
+    limit?: number | null;
+    includeHidden?: boolean | null;
+};
+export type CodexModelListResponseMsg = {
+    type: 'codex.model.list.response';
+    requestId: string;
+    models?: CodexModelDefinition[];
+    nextCursor?: string | null;
+    defaultModel?: string | null;
+    error?: string;
+};
+export type CodexSkillsListRequestMsg = {
+    type: 'codex.skills.list.request';
+    requestId: string;
+    workspaceRoot: string;
+    skillRoots?: string[];
+    forceReload?: boolean;
+};
+export type CodexSkillsListResponseMsg = {
+    type: 'codex.skills.list.response';
+    requestId: string;
+    data?: CodexNativeSkillListEntry[];
+    error?: string;
+};
+export type CodexThreadListRequestMsg = {
+    type: 'codex.thread.list.request';
+    requestId: string;
+    workspaceRoot: string;
+    cursor?: string | null;
+    limit?: number | null;
+    archived?: boolean | null;
+    searchTerm?: string | null;
+    useStateDbOnly?: boolean;
+};
+export type CodexThreadListResponseMsg = {
+    type: 'codex.thread.list.response';
+    requestId: string;
+    threads?: CodexThreadSummary[];
+    nextCursor?: string | null;
+    backwardsCursor?: string | null;
+    error?: string;
+};
+export type CodexThreadReadRequestMsg = {
+    type: 'codex.thread.read.request';
+    requestId: string;
+    workspaceRoot: string;
+    threadId: string;
+    includeTurns?: boolean;
+};
+export type CodexThreadReadResponseMsg = {
+    type: 'codex.thread.read.response';
+    requestId: string;
+    thread?: CodexThreadSummary;
+    error?: string;
+};
+export type ClaudeCommandRequestMsg = {
+    type: 'claude.command.request';
+    requestId: string;
+    target: ClaudeControlConversationTarget;
+    commandName: ClaudeSessionCommandName;
+    args?: string | null;
+};
+export type ClaudeCommandResponseMsg = {
+    type: 'claude.command.response';
+    requestId: string;
+    result?: ClaudeCommandExecutionResult;
+    controls?: ClaudeSessionControlState;
+    error?: string;
+};
+export type WorkbenchTerminalInfo = {
+    terminalId: string;
+    workspaceRoot: string;
+    cwd: string;
+    name: string;
+    cols: number;
+    rows: number;
+    createdAt: number;
+    lastActivityAt: number;
+    exited: boolean;
+    exitCode?: number | null;
+    signal?: string | null;
+};
+export type TerminalListRequestMsg = {
+    type: 'terminal.list.request';
+    requestId: string;
+    workspaceRoot: string;
+};
+export type TerminalListResponseMsg = {
+    type: 'terminal.list.response';
+    requestId: string;
+    workspaceRoot: string;
+    terminals?: WorkbenchTerminalInfo[];
+    error?: string;
+    errorCode?: WorkspaceErrorCode;
+};
+export type TerminalCreateRequestMsg = {
+    type: 'terminal.create.request';
+    requestId: string;
+    workspaceRoot: string;
+    cwd?: string;
+    name?: string;
+    startupCommand?: string;
+    closeOnStartupCommand?: boolean;
+    cols?: number;
+    rows?: number;
+};
+export type TerminalCreateResponseMsg = {
+    type: 'terminal.create.response';
+    requestId: string;
+    terminal?: WorkbenchTerminalInfo;
+    error?: string;
+    errorCode?: WorkspaceErrorCode;
+};
+export type TerminalSnapshotRequestMsg = {
+    type: 'terminal.snapshot.request';
+    requestId: string;
+    terminalId: string;
+};
+export type TerminalSnapshotResponseMsg = {
+    type: 'terminal.snapshot.response';
+    requestId: string;
+    terminal?: WorkbenchTerminalInfo;
+    buffer?: string;
+    error?: string;
+    errorCode?: WorkspaceErrorCode;
+};
+export type TerminalInputRequestMsg = {
+    type: 'terminal.input.request';
+    requestId: string;
+    terminalId: string;
+    data: string;
+};
+export type TerminalInputResponseMsg = {
+    type: 'terminal.input.response';
+    requestId: string;
+    ok?: boolean;
+    error?: string;
+    errorCode?: WorkspaceErrorCode;
+};
+export type TerminalResizeRequestMsg = {
+    type: 'terminal.resize.request';
+    requestId: string;
+    terminalId: string;
+    cols: number;
+    rows: number;
+};
+export type TerminalResizeResponseMsg = {
+    type: 'terminal.resize.response';
+    requestId: string;
+    ok?: boolean;
+    error?: string;
+    errorCode?: WorkspaceErrorCode;
+};
+export type TerminalCloseRequestMsg = {
+    type: 'terminal.close.request';
+    requestId: string;
+    terminalId: string;
+};
+export type TerminalCloseResponseMsg = {
+    type: 'terminal.close.response';
+    requestId: string;
+    ok?: boolean;
+    error?: string;
+    errorCode?: WorkspaceErrorCode;
+};
+export type TerminalOutputEventMsg = {
+    type: 'terminal.output.event';
+    terminalId: string;
+    data: string;
+};
+export type TerminalExitEventMsg = {
+    type: 'terminal.exit.event';
+    terminalId: string;
+    exitCode?: number | null;
+    signal?: string | null;
+};
+export type SkillsListRequestMsg = {
+    type: 'skills.list.request';
+    requestId: string;
+    skillRoots: string[];
+    path?: string | null;
+    agentType?: AgentType;
+    workspaceRoot?: string | null;
+};
+export type SkillsListResponseMsg = {
+    type: 'skills.list.response';
+    requestId: string;
+    roots: string[];
+    path?: string | null;
+    skills?: AgentSkillSummary[];
+    entries?: AgentSkillEntry[];
+    error?: string;
+    errorCode?: WorkspaceErrorCode;
+};
+export type SkillsReadRequestMsg = {
+    type: 'skills.read.request';
+    requestId: string;
+    skillRoots: string[];
+    path: string;
+    agentType?: AgentType;
+    workspaceRoot?: string | null;
+};
+export type SkillsReadResponseMsg = {
+    type: 'skills.read.response';
+    requestId: string;
+    path: string;
+    content?: string;
+    mimeType?: 'text/markdown' | 'text/plain';
+    size?: number;
+    modifiedAt?: number | null;
+    error?: string;
+    errorCode?: WorkspaceErrorCode;
+};
+export type CodexTranscriptFileEntry = {
+    path: string;
+    size: number;
+    modifiedAt: number;
+    sessionId?: string;
+    cwd?: string;
+};
+export type CodexTranscriptListRequestMsg = {
+    type: 'codex.transcript.list.request';
+    requestId: string;
+    maxFiles?: number;
+};
+export type CodexTranscriptListResponseMsg = {
+    type: 'codex.transcript.list.response';
+    requestId: string;
+    rootPath?: string;
+    files?: CodexTranscriptFileEntry[];
+    truncated?: boolean;
+    error?: string;
+    errorCode?: WorkspaceErrorCode;
+};
+export type CodexTranscriptReadRequestMsg = {
+    type: 'codex.transcript.read.request';
+    requestId: string;
+    path: string;
+};
+export type CodexTranscriptReadResponseMsg = {
+    type: 'codex.transcript.read.response';
+    requestId: string;
+    path: string;
+    rootPath?: string;
+    content?: string;
+    size?: number;
+    modifiedAt?: number | null;
+    error?: string;
+    errorCode?: WorkspaceErrorCode;
+};
+export type ClaudeTranscriptListRequestMsg = {
+    type: 'claude.transcript.list.request';
+    requestId: string;
+    workspaceRoot: string;
+    maxFiles?: number;
+};
+export type ClaudeTranscriptListResponseMsg = {
+    type: 'claude.transcript.list.response';
+    requestId: string;
+    rootPath?: string;
+    files?: CodexTranscriptFileEntry[];
+    truncated?: boolean;
+    error?: string;
+    errorCode?: WorkspaceErrorCode;
+};
+export type ClaudeTranscriptReadRequestMsg = {
+    type: 'claude.transcript.read.request';
+    requestId: string;
+    workspaceRoot: string;
+    path: string;
+};
+export type ClaudeTranscriptReadResponseMsg = {
+    type: 'claude.transcript.read.response';
+    requestId: string;
+    path: string;
+    rootPath?: string;
+    content?: string;
+    size?: number;
+    modifiedAt?: number | null;
+    error?: string;
+    errorCode?: WorkspaceErrorCode;
+};
+export type RunDebugSnapshotMsg = {
+    type: 'run.debug.snapshot';
+    runId: string;
+    conversationId: string;
+    sessionKey: string;
+    acpSessionId: string;
+    isFreshSession: boolean;
+    isExact: boolean;
+    effectiveSystemPromptText?: string;
+    effectiveContextText?: string;
+};
+export type AgentCleanupResponseMsg = {
+    type: 'agent.cleanup.response';
+    requestId: string;
+    agentId: string;
+    ok?: boolean;
+    error?: string;
+};
+export type NodeToCore = NodeRegisterMsg | NodeHeartbeatMsg | NodeHostsSnapshotMsg | AssetMaterializedMsg | AssetMaterializationClearedMsg | NodeRuntimeSnapshotMsg | DroidMissionRunAcceptedMsg | DroidMissionRunEventMsg | DroidMissionRunEndMsg | DroidMissionContinuationInspectResponseMsg | RunAcceptedMsg | RunEventMsg | RunEndMsg | RunSteerResultMsg | RunDeliveryAckMsg | NodePermissionRequestMsg | ClaudeControlsResponseMsg | ClaudeSetModeResponseMsg | ClaudeSetModelResponseMsg | ClaudeCommandResponseMsg | CodexModelListResponseMsg | CodexSkillsListResponseMsg | CodexThreadListResponseMsg | CodexThreadReadResponseMsg | CodexConversationSummaryResponseMsg | WorkspaceInspectResponseMsg | WorkspaceGitStatusResponseMsg | WorkspaceGitDiffResponseMsg | WorkspaceGitActionResponseMsg | WorkspaceListResponseMsg | WorkspaceReadResponseMsg | WorkspaceArchiveResponseMsg | WorkspaceExtractResponseMsg | FsReadPathResponseMsg | HttpFetchTextResponseMsg | WorkspaceServiceProxyResponseMsg | FsPathSuggestResponseMsg | FsReadPathStreamStartMsg | FsReadPathStreamChunkMsg | FsReadPathStreamEndMsg | LibraryMirrorApplyResponseMsg | LibraryMirrorSnapshotResponseMsg | LibraryAuthorityDeleteResponseMsg | LibraryAuthorityRenameResponseMsg | WorkspaceWriteResponseMsg | WorkspaceDeleteFileResponseMsg | WorkspaceDeletePathResponseMsg | WorkspaceResetResponseMsg | TerminalListResponseMsg | TerminalCreateResponseMsg | TerminalSnapshotResponseMsg | TerminalInputResponseMsg | TerminalResizeResponseMsg | TerminalCloseResponseMsg | TerminalOutputEventMsg | TerminalExitEventMsg | SkillsListResponseMsg | SkillsReadResponseMsg | CodexTranscriptListResponseMsg | CodexTranscriptReadResponseMsg | ClaudeTranscriptListResponseMsg | ClaudeTranscriptReadResponseMsg | AgentCleanupResponseMsg | RunDebugSnapshotMsg | SoloRunEventMsg | SoloRunEndMsg | SoloPermissionRequestMsg;
+export type NodeAckMsg = {
+    type: 'node.ack';
+    nodeId: string;
+};
+export type RunDispatchMsg = {
+    type: 'run.dispatch';
+    runId: string;
+    conversationId: string;
+    agentType: AgentType;
+    agentSurfaceMode?: AgentSurfaceMode;
+    model?: string;
+    reasoningEffort?: string;
+    claudePermissionMode?: ClaudePermissionMode;
+    codexMode?: CodexAppServerMode;
+    codexServiceTier?: CodexServiceTier;
+    workspacePath: string | null;
+    agentName?: string;
+    skillRoots?: string[];
+    enabledSkillPaths?: string[];
+    envVars?: Record<string, string>;
+    disabledToolKinds?: AgentPermissionKind[];
+    prompt: string;
+    attachments?: FileRef[];
+    runtimeOverrides?: PromptRuntimeOverrides;
+    sessionKey: string;
+    hostKey: string;
+    dispatchMode: RuntimeDispatchMode;
+    systemPromptText?: string;
+    contextText?: string;
+    resumeContextText?: string;
+    delivery?: NotificationDeliveryMetadata;
+    channelBridgeConfig?: {
+        agentId: string;
+        conversationId: string;
+        serverUrl: string;
+        authToken?: string;
+    };
+};
+export type RunCancelMsg = {
+    type: 'run.cancel';
+    runId: string;
+};
+export type RunSteerMsg = {
+    type: 'run.steer';
+    requestId: string;
+    runId: string;
+    conversationId: string;
+    prompt: string;
+    attachments?: FileRef[];
+    delivery?: NotificationDeliveryMetadata;
+};
+export type NodePermissionResponseMsg = {
+    type: 'permission.response';
+    requestId: string;
+    decision: 'allow' | 'deny';
+    selectedActionId?: string;
+    responseText?: string;
+    answers?: Record<string, string[]>;
+};
+export type SoloRunDispatchMsg = {
+    type: 'solo.run.dispatch';
+    soloSessionId: string;
+    agentId: string;
+    agentType: AgentType;
+    workspacePath: string;
+    agentName?: string;
+    model?: string;
+    reasoningEffort?: string;
+    codexMode?: CodexAppServerMode;
+    codexServiceTier?: CodexServiceTier;
+    envVars?: Record<string, string>;
+    disabledToolKinds?: AgentPermissionKind[];
+    prompt: string;
+    systemPromptText?: string;
+};
+export type SoloCancelMsg = {
+    type: 'solo.cancel';
+    soloSessionId: string;
+};
+export type SoloCloseMsg = {
+    type: 'solo.close';
+    soloSessionId: string;
+};
+export type SoloSteerMsg = {
+    type: 'solo.steer';
+    soloSessionId: string;
+    prompt: string;
+};
+export type SoloPermissionResponseMsg = {
+    type: 'solo.permission.response';
+    soloSessionId: string;
+    requestId: string;
+    decision: 'allow' | 'deny';
+    selectedActionId?: string;
+    responseText?: string;
+    answers?: Record<string, string[]>;
+};
+export type SoloRunEventMsg = {
+    type: 'solo.run.event';
+    soloSessionId: string;
+    event: ServerEvent;
+};
+export type SoloRunEndMsg = {
+    type: 'solo.run.end';
+    soloSessionId: string;
+    stopReason?: string;
+    error?: string;
+};
+export type SoloPermissionRequestMsg = {
+    type: 'solo.permission.request';
+    soloSessionId: string;
+    requestId: string;
+    toolName: string;
+    toolArgs: unknown;
+    toolKind?: string | null;
+    approvalKind?: 'tool' | 'plan' | 'question';
+    title?: string;
+    description?: string;
+    input?: unknown;
+    actions?: Array<{
+        id: string;
+        label: string;
+    }>;
+};
+export type SoloClientPromptMsg = {
+    type: 'solo.prompt';
+    soloSessionId: string;
+    text: string;
+};
+export type SoloClientSteerMsg = {
+    type: 'solo.steer';
+    soloSessionId: string;
+    text: string;
+};
+export type SoloClientApprovalResponseMsg = {
+    type: 'solo.approval.response';
+    soloSessionId: string;
+    requestId: string;
+    decision: 'allow' | 'deny';
+    selectedActionId?: string;
+    responseText?: string;
+    answers?: Record<string, string[]>;
+};
+export type SoloClientMessage = SoloClientPromptMsg | SoloCancelMsg | SoloClientSteerMsg | SoloClientApprovalResponseMsg;
+export type SoloServerMessage = SoloRunEventMsg | SoloRunEndMsg | SoloPermissionRequestMsg | {
+    type: 'error';
+    message: string;
+};
+export type WorkspaceListRequestMsg = {
+    type: 'workspace.list.request';
+    requestId: string;
+    workspaceRoot: string;
+    relativePath: string;
+    runId?: string;
+    scaffold?: boolean;
+    agentName?: string;
+    cursor?: string | null;
+    limit?: number;
+};
+export type WorkspaceReadRequestMsg = {
+    type: 'workspace.read.request';
+    requestId: string;
+    workspaceRoot: string;
+    relativePath: string;
+    runId?: string;
+    scaffold?: boolean;
+    agentName?: string;
+    offset?: number;
+    limit?: number;
+};
+export type WorkspaceArchiveRequestMsg = {
+    type: 'workspace.archive.request';
+    requestId: string;
+    workspaceRoot: string;
+    relativePath: string;
+    maxBytes?: number;
+};
+export type WorkspaceExtractRequestMsg = {
+    type: 'workspace.extract.request';
+    requestId: string;
+    workspaceRoot: string;
+    relativePath: string;
+    archiveBase64: string;
+    overwrite?: boolean;
+    maxBytes?: number;
+};
+export type FsReadPathRequestMsg = {
+    type: 'fs.read_path.request';
+    requestId: string;
+    absolutePath: string;
+    allowedRoot?: string;
+    trustedRoot?: string;
+    cursor?: string | null;
+    offset?: number;
+    limit?: number;
+    maxPreviewBytes?: number;
+    rawContentBase64?: boolean;
+};
+export type FsPathSuggestRequestMsg = {
+    type: 'fs.path_suggest.request';
+    requestId: string;
+    query: string;
+    limit?: number;
+};
+export type FsReadPathStreamRequestMsg = {
+    type: 'fs.read_path.stream.request';
+    requestId: string;
+    absolutePath: string;
+    allowedRoot?: string;
+};
+export type HttpFetchTextRequestMsg = {
+    type: 'http.fetch_text.request';
+    requestId: string;
+    url: string;
+    maxBytes?: number;
+    authProfile?: string;
+    ifNoneMatch?: string;
+    ifModifiedSince?: string;
+    ifRange?: string;
+    rangeStart?: number;
+    rangeLength?: number;
+};
+export type WorkspaceServiceProxyRequestMsg = {
+    type: 'workspace.service_proxy.request';
+    requestId: string;
+    url: string;
+    method?: WorkspaceServiceProxyMethod;
+    headers?: Record<string, string>;
+    body?: string;
+    maxBytes?: number;
+};
+export type WorkspaceWriteRequestMsg = {
+    type: 'workspace.write.request';
+    requestId: string;
+    workspaceRoot: string;
+    relativePath: string;
+    content: string;
+    mode: WorkspaceWriteMode;
+    contentEncoding?: WorkspaceWriteContentEncoding;
+    scaffold?: boolean;
+    agentName?: string;
+};
+export type WorkspaceDeleteFileRequestMsg = {
+    type: 'workspace.delete_file.request';
+    requestId: string;
+    workspaceRoot: string;
+    relativePath: string;
+};
+export type WorkspaceDeletePathRequestMsg = {
+    type: 'workspace.delete_path.request';
+    requestId: string;
+    workspaceRoot: string;
+    relativePath: string;
+    recursive?: boolean;
+};
+export type LibraryMirrorApplyCoreRequestMsg = LibraryMirrorApplyRequestMsg;
+export type LibraryMirrorSnapshotCoreRequestMsg = LibraryMirrorSnapshotRequestMsg;
+export type LibraryAuthorityDeleteCoreRequestMsg = LibraryAuthorityDeleteRequestMsg;
+export type LibraryAuthorityRenameCoreRequestMsg = LibraryAuthorityRenameRequestMsg;
+export type WorkspaceInspectCoreRequestMsg = WorkspaceInspectRequestMsg;
+export type WorkspaceGitStatusCoreRequestMsg = WorkspaceGitStatusRequestMsg;
+export type WorkspaceGitDiffCoreRequestMsg = WorkspaceGitDiffRequestMsg;
+export type WorkspaceGitActionCoreRequestMsg = WorkspaceGitActionRequestMsg;
+export type TerminalListCoreRequestMsg = TerminalListRequestMsg;
+export type TerminalCreateCoreRequestMsg = TerminalCreateRequestMsg;
+export type TerminalSnapshotCoreRequestMsg = TerminalSnapshotRequestMsg;
+export type TerminalInputCoreRequestMsg = TerminalInputRequestMsg;
+export type TerminalResizeCoreRequestMsg = TerminalResizeRequestMsg;
+export type TerminalCloseCoreRequestMsg = TerminalCloseRequestMsg;
+export type SkillsListCoreRequestMsg = SkillsListRequestMsg;
+export type SkillsReadCoreRequestMsg = SkillsReadRequestMsg;
+export type HostCloseMsg = {
+    type: 'host.close';
+    hostKey: string;
+};
+export type AgentCleanupRequestMsg = {
+    type: 'agent.cleanup.request';
+    requestId: string;
+    agentId: string;
+    hostKeys: string[];
+    sessionKeys?: string[];
+};
+export type NativeMissionFeatureContext = {
+    featureId: string;
+    featureDescription: string;
+    milestone: string;
+    expectedBehavior?: string[];
+    preconditions?: string[];
+    priorHandoffs?: Array<{
+        featureId: string;
+        salientSummary: string;
+        whatWasImplemented?: string[];
+    }>;
+    validationContract?: string;
+    workspaceFiles?: string[];
+    useAgentDispatch?: boolean;
+    isValidator?: boolean;
+};
+export type MissionRunRequestMsg = {
+    type: 'mission.run.request';
+    requestId: string;
+    missionId: string;
+    runtimeProvider?: MissionRuntimeProvider;
+    title: string;
+    prompt: string;
+    continueSession?: boolean;
+    interaction?: boolean;
+    workspaceRoot: string;
+    missionDir: string;
+    modelMode: MissionModelMode;
+    orchestratorModel?: string | null;
+    workerModel?: string | null;
+    validatorModel?: string | null;
+} & Partial<NativeMissionFeatureContext>;
+export type DroidMissionRunRequestMsg = MissionRunRequestMsg;
+export type NativeMissionRunRequestMsg = MissionRunRequestMsg & {
+    runtimeProvider: 'bigbang_native';
+    featureId?: string;
+    featureDescription?: string;
+    milestone?: string;
+};
+export type CoreToNode = NodeAckMsg | RunDispatchMsg | RunCancelMsg | RunSteerMsg | NodePermissionResponseMsg | ClaudeControlsRequestMsg | ClaudeSetModeRequestMsg | ClaudeSetModelRequestMsg | ClaudeCommandRequestMsg | CodexModelListRequestMsg | CodexSkillsListRequestMsg | CodexThreadListRequestMsg | CodexThreadReadRequestMsg | CodexConversationSummaryRequestMsg | WorkspaceInspectCoreRequestMsg | WorkspaceGitStatusCoreRequestMsg | WorkspaceGitDiffCoreRequestMsg | WorkspaceGitActionCoreRequestMsg | WorkspaceListRequestMsg | WorkspaceReadRequestMsg | WorkspaceArchiveRequestMsg | WorkspaceExtractRequestMsg | FsReadPathRequestMsg | HttpFetchTextRequestMsg | WorkspaceServiceProxyRequestMsg | FsPathSuggestRequestMsg | FsReadPathStreamRequestMsg | LibraryMirrorApplyCoreRequestMsg | LibraryMirrorSnapshotCoreRequestMsg | LibraryAuthorityDeleteCoreRequestMsg | LibraryAuthorityRenameCoreRequestMsg | WorkspaceWriteRequestMsg | WorkspaceDeleteFileRequestMsg | WorkspaceDeletePathRequestMsg | WorkspaceResetRequestMsg | TerminalListCoreRequestMsg | TerminalCreateCoreRequestMsg | TerminalSnapshotCoreRequestMsg | TerminalInputCoreRequestMsg | TerminalResizeCoreRequestMsg | TerminalCloseCoreRequestMsg | SkillsListCoreRequestMsg | SkillsReadCoreRequestMsg | DroidMissionRunRequestMsg | MissionRunCancelMsg | DroidMissionContinuationInspectRequestMsg | CodexTranscriptListRequestMsg | CodexTranscriptReadRequestMsg | ClaudeTranscriptListRequestMsg | ClaudeTranscriptReadRequestMsg | HostCloseMsg | AgentCleanupRequestMsg | SoloRunDispatchMsg | SoloCancelMsg | SoloCloseMsg | SoloSteerMsg | SoloPermissionResponseMsg;
+export type AgentSurfaceKind = 'dm' | 'dm_thread' | 'channel' | 'channel_thread';
+export type SurfaceSummaryLastMessage = {
+    messageId: string;
+    target: string;
+    senderName: string;
+    senderType: string;
+    preview: string;
+    createdAt: string;
+};
+export type SurfaceSummaryTaskLink = {
+    taskId: string;
+    agentTaskRef: string | null;
+    taskNumber: number;
+    title: string;
+    status: 'todo' | 'in_progress' | 'in_review' | 'done';
+    threadTarget: string | null;
+};
+export type SurfaceSummaryBoundTask = SurfaceSummaryTaskLink & {
+    description: string | null;
+    claimedByName: string | null;
+};
+export type SurfaceSummaryActiveHandoff = {
+    handoffId: string;
+    mode: 'delegate_only' | 'continue_there' | 'collab';
+    status: 'started' | 'accepted' | 'completed' | 'cancelled' | 'failed';
+    sourceConversationId: string;
+    targetConversationId: string | null;
+    targetReplyTarget: string;
+    sourceTarget: string | null;
+    goal: string;
+    error: string | null;
+    updatedAt: string;
+};
+export type SurfaceSummaryPayload = {
+    goal: string | null;
+    recentState: string | null;
+    blockers: string[];
+    nextStep: string | null;
+    lastUserMessage: string | null;
+    lastAgentMessage: string | null;
+    linkedTaskRefs: string[];
+    linkedTaskTitles: string[];
+    unreadCount: number;
+    queuedPromptCount: number;
+    lastMessageAt: string | null;
+    lastMessage: SurfaceSummaryLastMessage | null;
+    linkedTasks: SurfaceSummaryTaskLink[];
+    boundTask: SurfaceSummaryBoundTask | null;
+    ownerAgentId: string | null;
+    ownerName: string | null;
+    participants: string[];
+    myRole: string | null;
+    activeHandoff: SurfaceSummaryActiveHandoff | null;
+};
+export type AgentRuntimePresenceHost = {
+    hostKey: string;
+    replyTarget: string | null;
+    surfaceKind: AgentSurfaceKind | null;
+    state: NodeHostState;
+    currentRunId: string | null;
+    hasPendingApproval: boolean;
+    inboxSize: number;
+    pendingDispatchCount: number;
+    resumable: boolean;
+    lastWakeAt: string | null;
+    lastSleepAt: string | null;
+    lastError: string | null;
+};
+export type AgentRuntimePresence = {
+    generatedAt: string;
+    node: {
+        nodeId: string | null;
+        machineName: string | null;
+        hostname: string | null;
+        status: 'unassigned' | 'pending' | 'online' | 'offline';
+        version: string | null;
+        lastSeen: string | null;
+    };
+    runtime: {
+        workspaceRoot: string | null;
+        terminalBackendAvailable: boolean | null;
+        runtimeDrivers: NodeRuntimeDriverInventory[];
+        capabilities: NodeRuntimeCapabilities | null;
+    };
+    summary: {
+        totalHosts: number;
+        activeHosts: number;
+        idleHosts: number;
+        failedHosts: number;
+        hostsWithPendingApproval: number;
+        resumableHosts: number;
+    };
+    currentHost: AgentRuntimePresenceHost | null;
+    otherHosts: AgentRuntimePresenceHost[];
+};
+export type RuntimePresenceResponse = AgentRuntimePresence & {
+    reportText?: string;
+};
+export type SurfaceConversationItem = {
+    conversationId: string;
+    replyTarget: string;
+    status: ConversationStatus;
+    surfaceKind: AgentSurfaceKind;
+    threadKind: ThreadKind;
+    threadRootId?: string | null;
+    unreadCount: number;
+    queuedPromptCount: number;
+    hasActiveRun?: boolean;
+    updatedAt: string;
+    summaryUpdatedAt?: string;
+    summary: SurfaceSummaryPayload;
+    summaryText: string;
+    reportText?: string;
+};
+export type SelfStateResponse = {
+    generatedAt?: string;
+    agent?: {
+        agentId?: string;
+        name?: string;
+        agentType?: string;
+        nodeId?: string | null;
+        joinedChannels?: Array<{
+            channelId: string;
+            name: string | null;
+            target: string;
+        }>;
+    };
+    summary?: {
+        totalConversations?: number;
+        activeConversations?: number;
+        queuedConversations?: number;
+        recoveringConversations?: number;
+        awaitingApprovalConversations?: number;
+        failedConversations?: number;
+        totalUnreadMessages?: number;
+        surfacesWithUnread?: number;
+        pendingPrompts?: number;
+        claimedTasks?: number;
+        involvedTasks?: number;
+        inReviewTasks?: number;
+    };
+    currentConversation?: {
+        conversationId?: string;
+        replyTarget: string;
+        status: ConversationStatus;
+        surfaceKind: AgentSurfaceKind;
+        unreadCount: number;
+        queuedPromptCount: number;
+    } | null;
+    reportText?: string;
+    recentTasks?: Array<{
+        taskId: string;
+        agentTaskRef?: string | null;
+        taskNumber: number;
+        title: string;
+        status: 'todo' | 'in_progress' | 'in_review' | 'done';
+        sourceTarget?: string | null;
+        threadTarget?: string | null;
+    }>;
+    recentHandoffs?: Array<{
+        handoffId: string;
+        mode: 'delegate_only' | 'continue_there' | 'collab';
+        status: 'started' | 'accepted' | 'completed' | 'cancelled' | 'failed';
+        sourceTarget?: string | null;
+        targetReplyTarget: string;
+        goal?: string | null;
+    }>;
+    currentContext?: SurfaceSummaryPayload | null;
+    conversations?: Array<SurfaceConversationItem & {
+        context?: SurfaceSummaryPayload;
+    }>;
+    runtimePresence?: AgentRuntimePresence | null;
+};
+export type RelevantContextBundleAction = 'inspect_surface' | 'read_history' | 'read_task_history' | 'check_handoff' | 'handoff_candidate' | 'stay_on_current_surface';
+export type RelevantContextBundleReasonCode = 'bound_task_match' | 'linked_task_match' | 'active_handoff' | 'recent_handoff' | 'same_thread_root' | 'same_target_family' | 'participant_overlap' | 'owner_match' | 'role_present' | 'unread_activity' | 'queued_activity' | 'recent_activity' | 'current_conversation_handoff' | 'task_status_active' | 'task_status_review';
+export type RelevantContextBundleReason = {
+    code: RelevantContextBundleReasonCode;
+    label: string;
+    weight: number;
+    detail?: string | null;
+};
+export type RelevantContextHistorySuggestion = {
+    target: string;
+    around?: string | null;
+    includeRoot?: boolean;
+    reason: string;
+};
+export type RelevantContextBundleSurfaceItem = {
+    kind: 'surface';
+    score: number;
+    reasons: RelevantContextBundleReason[];
+    updatedAt: string;
+    conversationId: string;
+    replyTarget: string;
+    status: ConversationStatus;
+    surfaceKind: AgentSurfaceKind;
+    threadKind: ThreadKind;
+    threadRootId?: string | null;
+    unreadCount: number;
+    queuedPromptCount: number;
+    goal?: string | null;
+    nextStep?: string | null;
+    myRole?: string | null;
+    ownerName?: string | null;
+    linkedTaskRefs: string[];
+    boundTask?: SurfaceSummaryBoundTask | null;
+    activeHandoff?: SurfaceSummaryActiveHandoff | null;
+    lastMessage?: SurfaceSummaryLastMessage | null;
+    summaryText: string;
+};
+export type RelevantContextBundleTaskItem = {
+    kind: 'task';
+    score: number;
+    reasons: RelevantContextBundleReason[];
+    updatedAt: string;
+    taskId: string;
+    agentTaskRef: string | null;
+    taskNumber: number;
+    title: string;
+    status: TaskInfo['status'];
+    sourceTarget?: string | null;
+    sourceLabel?: string | null;
+    threadTarget?: string | null;
+};
+export type RelevantContextBundleHandoffItem = {
+    kind: 'handoff';
+    score: number;
+    reasons: RelevantContextBundleReason[];
+    updatedAt: string;
+    handoffId: string;
+    mode: 'delegate_only' | 'continue_there' | 'collab';
+    status: 'started' | 'accepted' | 'completed' | 'cancelled' | 'failed';
+    workflowKind: 'generic' | 'dm_task_thread' | 'channel_task_thread';
+    sourceDisposition: 'keep_running' | 'cancel_current_run';
+    sourceConversationId: string;
+    sourceTarget?: string | null;
+    targetConversationId: string | null;
+    targetReplyTarget: string;
+    goal: string;
+    relatedTaskRef?: string | null;
+    taskId?: string | null;
+    taskNumber?: number | null;
+};
+export type RelevantContextBundleItem = RelevantContextBundleSurfaceItem | RelevantContextBundleTaskItem | RelevantContextBundleHandoffItem;
+export type RelevantContextBundle = {
+    generatedAt: string;
+    currentConversation: {
+        conversationId: string;
+        replyTarget: string;
+        status: ConversationStatus;
+        surfaceKind: AgentSurfaceKind;
+        boundTaskRef?: string | null;
+        linkedTaskRefs: string[];
+    };
+    recommendedNextAction: RelevantContextBundleAction;
+    recommendedNextActionReason: string;
+    suggestedHistoryReads: RelevantContextHistorySuggestion[];
+    items: RelevantContextBundleItem[];
+    totalCount: number;
+    truncated: boolean;
+    overflowByStatus: Record<string, number>;
+};
+export type ConversationInfo = {
+    id: string;
+    channelId: string;
+    replyTarget?: string | null;
+    title: string;
+    agentType: AgentType;
+    runtimeCapabilities?: AgentRuntimeCapability[];
+    threadKind: ThreadKind;
+    isPrimaryThread: boolean;
+    threadRootId?: string | null;
+    surfaceKind?: AgentSurfaceKind;
+    workspacePath: string | null;
+    status: ConversationStatus;
+    createdAt: number;
+    updatedAt: number;
+    historyResetAt?: number | null;
+    nodeId?: string | null;
+    agentId?: string | null;
+    userId?: string | null;
+    activeProjectId?: string | null;
+    uiPanelEnabled?: boolean;
+};
+export type WorkspaceSessionStatus = ConversationStatus;
+export type WorkspaceSessionRuntimeProfile = 'workspace_native';
+export type WorkspaceSessionInfo = {
+    workspaceSessionId: string;
+    agentId: string;
+    projectId: string | null;
+    workspaceRootId: string;
+    title: string;
+    status: WorkspaceSessionStatus;
+    runtimeProfile: WorkspaceSessionRuntimeProfile;
+    createdByUserId: string | null;
+    createdAt: number;
+    updatedAt: number;
+    lastActiveAt: number;
+    archivedAt: number | null;
+};
+export type EnsureWorkspaceSessionRequest = {
+    agentId: string;
+    workspaceRootId: string;
+    title?: string;
+};
+export type EnsureWorkspaceSessionResult = {
+    session: WorkspaceSessionInfo;
+    created: boolean;
+};
+export type WorkspaceSessionListResult = {
+    sessions: WorkspaceSessionInfo[];
+};
+export type WorkspaceSessionPromptRequest = {
+    text: string;
+    runtimeOverrides?: PromptRuntimeOverrides;
+};
+export type WorkspaceSessionPromptResult = {
+    queued: boolean;
+    runId: string;
+    dispatchMode: RuntimeDispatchMode;
+    session: WorkspaceSessionInfo;
+};
+export type WorkspaceSessionApprovalResponseRequest = {
+    requestId: string;
+    decision: 'allow' | 'deny';
+    selectedActionId?: string;
+    responseText?: string;
+};
+export type WorkspaceSessionApprovalResponseResult = {
+    ok: true;
+    session: WorkspaceSessionInfo;
+};
+export type WorkspaceSessionCancelResult = {
+    ok: true;
+    runId: string;
+    session: WorkspaceSessionInfo;
+};
+export type WorkspaceSessionEventEntry = {
+    runId: string;
+    seq: number;
+    createdAt: number;
+    event: ServerEvent;
+};
+export type WorkspaceSessionEventListResult = {
+    session: WorkspaceSessionInfo;
+    events: WorkspaceSessionEventEntry[];
+};
+export type CreateConversationRequest = {
+    agentType?: AgentType;
+    workspacePath?: string;
+    title?: string;
+    channelId?: string;
+    threadKind?: ThreadKind;
+    isPrimaryThread?: boolean;
+    threadRootId?: string | null;
+    envVars?: Record<string, string>;
+    nodeId?: string;
+    agentId?: string;
+    activeProjectId?: string | null;
+};
+export type SetConversationActiveProjectRequest = {
+    activeProjectId?: string | null;
+};
+export type SetClaudeSessionModeRequest = {
+    modeId: ClaudeSessionModeId;
+};
+export type SetClaudeSessionModelRequest = {
+    modelId?: string | null;
+};
+export type ExecuteClaudeSessionCommandRequest = {
+    commandName: ClaudeSessionCommandName;
+    args?: string | null;
+};
+export type AgentWorkspaceListResult = {
+    path: string;
+    entries: AgentWorkspaceEntry[];
+    directoryPage?: DirectoryPageInfo;
+};
+export type AgentFileAccessPreviewResult = {
+    accessId: string;
+    absolutePath: string;
+    kind: AgentFileAccessKind;
+    content?: string;
+    entries?: AgentFileAccessDirectoryEntry[];
+    directoryPage?: DirectoryPageInfo;
+    mimeType?: WorkspacePreviewMimeType;
+    size?: number;
+    modifiedAt?: number | null;
+};
+export type AssetMetadataResult = {
+    assetId: string;
+    attachmentId: string;
+    filename: string;
+    originalFilename?: string | null;
+    mimeType: string | null;
+    sizeBytes: number;
+    kind: AssetKind;
+    scopeType: AssetScopeType;
+    scopeId: string;
+    canonicalPath: string;
+    storagePath: string;
+    agentLocalPath?: string | null;
+    preferredLocalPath?: string | null;
+};
+export type AttachmentMetadataResult = AssetMetadataResult;
+export type AgentWorkspaceFileResult = {
+    path: string;
+    content: string;
+    mimeType: WorkspacePreviewMimeType;
+    size: number;
+    modifiedAt: number | null;
+    offset?: number;
+    limit?: number;
+    nextOffset?: number | null;
+    hasMore?: boolean;
+};
+export type AgentWorkspaceInspectResult = {
+    nodeId: string | null;
+    workspaceRoot: string | null;
+    inspect: WorkspaceInspectResult | null;
+};
+export type ResourceSpaceBackendType = 'node_path' | 'shared_mount';
+export type ResourceSpaceType = 'docs' | 'experiments' | 'mixed';
+export type ResourceTreeEntry = AgentWorkspaceEntry;
+export type ResourceTreeResult = {
+    path: string;
+    entries: ResourceTreeEntry[];
+};
+export type ResourceFileResult = {
+    path: string;
+    content: string;
+    mimeType: WorkspacePreviewMimeType;
+    size: number;
+    modifiedAt: number | null;
+};
+export type ResourceSpaceInfo = {
+    resourceSpaceId: string;
+    name: string;
+    resourceType: ResourceSpaceType;
+    backendType: ResourceSpaceBackendType;
+    nodeId?: string | null;
+    rootPath: string;
+    channelId?: string | null;
+    description?: string | null;
+    createdAt: number;
+    updatedAt: number;
+};
+export type ProjectBackendType = 'local_path' | 'shared_mount';
+export type AgentProjectBindingInfo = {
+    projectId: string;
+    name: string;
+    backendType: ProjectBackendType;
+    rootPath: string;
+    nodeId?: string | null;
+    description?: string | null;
+    isDefault: boolean;
+};
+export type ProjectBoundAgentInfo = {
+    agentId: string;
+    name: string;
+    nodeId?: string | null;
+    isDefault: boolean;
+};
+export type ProjectInfo = {
+    projectId: string;
+    name: string;
+    backendType: ProjectBackendType;
+    rootPath: string;
+    nodeId?: string | null;
+    description?: string | null;
+    boundAgents: ProjectBoundAgentInfo[];
+    createdAt: number;
+    updatedAt: number;
+};
+export type CreateProjectRequest = {
+    name: string;
+    backendType: ProjectBackendType;
+    rootPath: string;
+    nodeId?: string | null;
+    description?: string;
+};
+export type UpdateProjectRequest = {
+    name?: string;
+    backendType?: ProjectBackendType;
+    rootPath?: string;
+    nodeId?: string | null;
+    description?: string | null;
+};
+export type BindProjectAgentRequest = {
+    agentId: string;
+    isDefault?: boolean;
+};
+export type SetAgentDefaultProjectRequest = {
+    projectId?: string | null;
+};
+export type WorkbenchRootKind = 'agent_workspace' | 'project_space' | 'resource_space' | 'user_library';
+export type WorkbenchRootInfo = {
+    workbenchRootId: string;
+    kind: WorkbenchRootKind;
+    displayName: string;
+    rootPath: string;
+    nodeId: string | null;
+    projectId?: string;
+    projectBackendType?: ProjectBackendType;
+    agentId?: string;
+    agentIds?: string[];
+    resourceSpaceId?: string;
+    resourceType?: ResourceSpaceType;
+    backendType?: ResourceSpaceBackendType;
+    writable: boolean;
+    terminalSupported: boolean;
+    terminalDisabledReason?: string | null;
+    sourceLabel: string;
+};
+export type WorkbenchProjectKind = 'git' | 'directory';
+export type WorkbenchWorkspaceInfo = {
+    workspaceId: string;
+    workbenchRootId: string;
+    displayName: string;
+    rootPath: string;
+    workspaceKind: WorkbenchWorkspaceKind;
+    branchName: string | null;
+    remoteUrl: string | null;
+    nodeId: string | null;
+    projectId?: string;
+    projectBackendType?: ProjectBackendType;
+    agentId?: string;
+    agentIds?: string[];
+    writable: boolean;
+    terminalSupported: boolean;
+    terminalDisabledReason?: string | null;
+};
+export type WorkbenchProjectInfo = {
+    projectId: string;
+    displayName: string;
+    projectKind: WorkbenchProjectKind;
+    primaryRootPath: string | null;
+    remoteUrl: string | null;
+    workspaces: WorkbenchWorkspaceInfo[];
+};
+export type WorkbenchProjectsResult = {
+    projects: WorkbenchProjectInfo[];
+};
+export type NodePathSuggestionsResult = {
+    nodeId: string;
+    query: string;
+    suggestions: FsPathSuggestion[];
+};
+export type WorkbenchGitStatusApiResult = WorkbenchGitStatusResult;
+export type WorkbenchGitDiffApiResult = WorkbenchGitDiffResult;
+export type CreateWorkbenchGitActionRequest = {
+    action: WorkbenchGitAction;
+    commitMessage?: string;
+};
+export type WorkbenchGitActionApiResult = WorkbenchGitActionResult;
+export type WorkbenchTreeResult = AgentWorkspaceListResult;
+export type WorkbenchFileResult = AgentWorkspaceFileResult;
+export type CreateWorkbenchTerminalRequest = {
+    cwd?: string;
+    name?: string;
+    startupCommand?: string;
+    closeOnStartupCommand?: boolean;
+    cols?: number;
+    rows?: number;
+};
+export type WorkbenchTerminalListResult = {
+    workbenchRootId: string;
+    terminals: WorkbenchTerminalInfo[];
+};
+export type WorkbenchTerminalSnapshotResult = {
+    terminal: WorkbenchTerminalInfo;
+    buffer: string;
+};
+export type WorkbenchTerminalWsClientEvent = {
+    type: 'input';
+    data: string;
+} | {
+    type: 'resize';
+    cols: number;
+    rows: number;
+} | {
+    type: 'ping';
+};
+export type WorkbenchTerminalWsServerEvent = {
+    type: 'snapshot';
+    terminal: WorkbenchTerminalInfo;
+    buffer: string;
+} | {
+    type: 'output';
+    terminalId: string;
+    data: string;
+} | {
+    type: 'exit';
+    terminalId: string;
+    exitCode?: number | null;
+    signal?: string | null;
+} | {
+    type: 'pong';
+} | {
+    type: 'error';
+    message: string;
+};
+export type CreateResourceSpaceRequest = {
+    name: string;
+    resourceType: ResourceSpaceType;
+    backendType: ResourceSpaceBackendType;
+    nodeId?: string | null;
+    rootPath: string;
+    channelId?: string | null;
+    description?: string;
+};
+export type UpdateResourceSpaceRequest = {
+    name?: string;
+    resourceType?: ResourceSpaceType;
+    backendType?: ResourceSpaceBackendType;
+    nodeId?: string | null;
+    rootPath?: string;
+    channelId?: string | null;
+    description?: string | null;
+};
+export type AnalyzeResourceRequest = {
+    agentId: string;
+    question: string;
+    path: string;
+    selection?: string;
+};
+export type AnalyzeResourceResult = {
+    conversation: ConversationInfo;
+    queued: boolean;
+};
+export type AgentSkillListResult = {
+    path: string | null;
+    roots: string[];
+    skills: AgentSkillSummary[];
+    entries: AgentSkillEntry[];
+};
+export type AgentSkillFileResult = {
+    path: string;
+    content: string;
+    mimeType: 'text/markdown' | 'text/plain';
+    size: number;
+    modifiedAt: number | null;
+};
+export type MemoryCategory = 'project_knowledge' | 'person' | 'preference' | 'decision' | 'procedure';
+export type MemoryNodeStatus = 'draft' | 'confirmed' | 'retired';
+export type MemoryEdgeRelation = 'related_to' | 'depends_on' | 'contradicts' | 'evolved_from';
+export type MemorySourceRef = {
+    messageId: string;
+    snippet: string;
+};
+export type MemoryNodeInfo = {
+    nodeId: string;
+    agentId: string;
+    topic: string;
+    summary: string;
+    category: MemoryCategory;
+    importance: number;
+    sourceRefs?: MemorySourceRef[];
+    status: MemoryNodeStatus;
+    firstSeenAt: number;
+    lastReinforcedAt: number;
+    retiredAt?: number | null;
+    createdAt: number;
+    updatedAt: number;
+};
+export type MemoryEdgeInfo = {
+    edgeId: string;
+    agentId: string;
+    sourceNodeId: string;
+    targetNodeId: string;
+    relation: MemoryEdgeRelation;
+    strength: number;
+    createdAt: number;
+};
+export type MemoryGraphResponse = {
+    nodes: MemoryNodeInfo[];
+    edges: MemoryEdgeInfo[];
+};
+export type AgentInfo = {
+    agentId: string;
+    name: string;
+    agentRole?: AgentRole;
+    agentType: AgentType;
+    model?: string;
+    reasoningEffort?: string;
+    claudePermissionMode?: ClaudePermissionMode;
+    codexMode?: CodexAppServerMode;
+    codexServiceTier?: CodexServiceTier;
+    channelId: string;
+    channelIds: string[];
+    systemPrompt: string;
+    description?: string;
+    envVars?: Record<string, string>;
+    disabledToolKinds?: AgentPermissionKind[];
+    nodeId?: string | null;
+    workspacePath?: string | null;
+    projectPath?: string | null;
+    projects?: AgentProjectBindingInfo[];
+    skillRoots?: string[];
+    enabledSkillPaths?: string[];
+    skillSelectionMode?: 'legacy_all' | 'explicit';
+    memoryNetworkEnabled?: boolean;
+    dreamEnabled?: boolean;
+    dreamSchedule?: string;
+    dreamMinMessages?: number;
+    lastDreamAt?: number | null;
+    lastDreamSeq?: number | null;
+    deletedAt?: number | null;
+    createdAt: number;
+    updatedAt: number;
+};
+export type CreateAgentRequest = {
+    name: string;
+    agentType?: AgentType;
+    model?: string;
+    reasoningEffort?: string;
+    claudePermissionMode?: ClaudePermissionMode;
+    codexMode?: CodexAppServerMode;
+    codexServiceTier?: CodexServiceTier;
+    channelId?: string;
+    systemPrompt?: string;
+    description?: string;
+    envVars?: Record<string, string>;
+    disabledToolKinds?: AgentPermissionKind[];
+    nodeId?: string;
+    workspacePath?: string;
+    projectPath?: string;
+    skillRoots?: string[];
+};
+export type UpdateAgentRequest = {
+    name?: string;
+    agentType?: AgentType;
+    systemPrompt?: string;
+    description?: string;
+    model?: string | null;
+    reasoningEffort?: string | null;
+    claudePermissionMode?: ClaudePermissionMode | null;
+    codexMode?: CodexAppServerMode | null;
+    codexServiceTier?: CodexServiceTier | null;
+    envVars?: Record<string, string>;
+    disabledToolKinds?: AgentPermissionKind[];
+    channelId?: string;
+    projectPath?: string | null;
+    skillRoots?: string[];
+    enabledSkillPaths?: string[];
+    memoryNetworkEnabled?: boolean;
+    dreamEnabled?: boolean;
+    dreamSchedule?: string;
+    dreamMinMessages?: number;
+};
+export type ChannelInfo = {
+    channelId: string;
+    name: string;
+    workspacePath: string | null;
+    description?: string;
+    collaborationMode?: 'mention_only';
+    members?: Array<{
+        agentId: string;
+        name: string;
+    }>;
+    createdAt: number;
+    updatedAt: number;
+};
+export type ChannelMemberStatus = {
+    agentId: string;
+    isOwner: boolean;
+    isRecentParticipant: boolean;
+    lastActiveAt: number | null;
+};
+export type CreateChannelRequest = {
+    name: string;
+    workspacePath?: string;
+    description?: string;
+    agentIds?: string[];
+    collaborationMode?: 'mention_only';
+};
+export type UpdateChannelRequest = {
+    description?: string;
+    collaborationMode?: 'mention_only';
+};
+export type TaskInfo = {
+    taskId: string;
+    taskRef?: string | null;
+    channelId: string;
+    taskNumber: number;
+    title: string;
+    description?: string;
+    executionMode?: 'normal' | 'loop';
+    activeLoopId?: string | null;
+    activeLoopStatus?: 'pending' | 'running' | 'awaiting_approval' | 'paused' | 'succeeded' | 'failed' | 'stopped' | 'cancelled' | null;
+    status: 'todo' | 'in_progress' | 'in_review' | 'done';
+    assigneeId?: string | null;
+    assigneeName?: string | null;
+    assigneeDeleted?: boolean;
+    linkedThreadId?: string | null;
+    linkedThreadShortId?: string | null;
+    /** The channel_messages.message_id that IS this task's thread root */
+    messageId?: string | null;
+    participants?: GlobalTaskParticipantInfo[];
+    /** ARCH-2: Blocked task reason, set when task is blocked */
+    blockedReason?: string | null;
+    /** ARCH-2: Timestamp when task was blocked */
+    blockedAt?: string | null;
+    /** ARCH-2: Who (agent name or username) blocked the task */
+    blockedBy?: string | null;
+    createdAt: number;
+    updatedAt: number;
+};
+export type GlobalTaskParticipantInfo = {
+    agentId: string;
+    name: string;
+    role: 'owner' | 'collaborator';
+    isChannelMember?: boolean;
+};
+export type GlobalTaskInfo = TaskInfo & {
+    sourceType: 'channel' | 'dm';
+    channelName: string;
+    creatorName?: string | null;
+    participants: GlobalTaskParticipantInfo[];
+};
+export type ProactiveOpportunityKind = 'task_review_waiting' | 'task_blocked_waiting' | 'task_unassigned_todo' | 'task_stale_in_progress' | 'planner_task_candidate';
+export type ProactiveOpportunityStatus = 'open' | 'snoozed' | 'dismissed' | 'resolved';
+export type ProactiveOpportunityTaskSourceType = 'dm' | 'channel';
+export type ProactiveOpportunitySourceType = ProactiveOpportunityTaskSourceType | 'planner';
+export type ProactiveOpportunityAction = 'ask_update' | 'create_task';
+export type ProactiveOpportunityEvidenceLink = {
+    label: string;
+    url: string;
+    summary?: string;
+};
+export type ProactiveOpportunityTaskInfo = {
+    taskId: string;
+    taskRef?: string | null;
+    sourceType: ProactiveOpportunityTaskSourceType;
+    channelId: string;
+    channelName?: string | null;
+    agentId?: string | null;
+    agentName?: string | null;
+    taskNumber: number;
+    title: string;
+    description?: string | null;
+    status: TaskInfo['status'];
+    assigneeId?: string | null;
+    assigneeName?: string | null;
+    linkedThreadId?: string | null;
+    linkedThreadShortId?: string | null;
+    messageId?: string | null;
+    blockedReason?: string | null;
+    blockedAt?: string | null;
+    blockedBy?: string | null;
+    createdAt: number;
+    updatedAt: number;
+};
+export type ProactiveOpportunityInfo = {
+    opportunityId: string;
+    kind: ProactiveOpportunityKind;
+    status: ProactiveOpportunityStatus;
+    actions: ProactiveOpportunityAction[];
+    dedupeKey: string;
+    sourceType: ProactiveOpportunitySourceType;
+    title: string;
+    rationale: string;
+    evidence: Record<string, unknown>;
+    evidenceLinks?: ProactiveOpportunityEvidenceLink[];
+    task?: ProactiveOpportunityTaskInfo;
+    snoozedUntil?: number | null;
+    dismissedAt?: number | null;
+    resolvedAt?: number | null;
+    createdAt: number;
+    updatedAt: number;
+};
+export type ProactiveOpportunityAskUpdateResult = {
+    ok: true;
+    snoozedUntil: number;
+    sourceType: ProactiveOpportunityTaskSourceType;
+    taskId: string;
+    messageId?: string | null;
+    conversationId?: string | null;
+    threadRootId?: string | null;
+    queued?: boolean;
+    runId?: string;
+};
+export type ProactiveOpportunityCreateTaskResult = {
+    ok: true;
+    taskId: string;
+    taskNumber: number;
+    sourceType: ProactiveOpportunityTaskSourceType;
+    channelId: string;
+    agentId?: string | null;
+    messageId: string;
+    threadRootId: string;
+};
+export type AgentReminderScheduleKind = 'one_time' | 'recurring';
+export type AgentReminderIntervalUnit = 'hour' | 'day' | 'week';
+export type AgentReminderStatus = 'active' | 'paused' | 'in_progress' | 'awaiting_review' | 'needs_attention' | 'completed' | 'cancelled';
+export type AgentReminderOccurrenceStatus = 'pending' | 'dispatched' | 'awaiting_review' | 'snoozed' | 'completed' | 'skipped' | 'failed' | 'cancelled';
+export type AgentReminderEventType = 'created' | 'updated' | 'paused' | 'resumed' | 'cancelled' | 'scheduled' | 'dispatched' | 'snoozed' | 'completed' | 'failed' | 'skipped' | 'blocked_by_open_occurrence' | 'auto_completed_from_task_done' | 'completed_task_marked_done' | 'submitted_for_review' | 'submitted_task_marked_in_review' | 'reopened_for_rework' | 'abandoned';
+export type AgentReminderOccurrenceInfo = {
+    occurrenceId: string;
+    reminderId: string;
+    scheduledFor: number;
+    startedAt?: number | null;
+    completedAt?: number | null;
+    status: AgentReminderOccurrenceStatus;
+    taskId?: string | null;
+    conversationId?: string | null;
+    threadRootId?: string | null;
+    taskNumber?: number | null;
+    taskTitle?: string | null;
+    taskStatus?: TaskInfo['status'] | null;
+    error?: string | null;
+    createdAt: number;
+    updatedAt: number;
+};
+export type AgentReminderInfo = {
+    reminderId: string;
+    agentId: string;
+    title: string;
+    promptText: string;
+    scheduleKind: AgentReminderScheduleKind;
+    intervalUnit?: AgentReminderIntervalUnit | null;
+    intervalValue?: number | null;
+    startAt: number;
+    endAt?: number | null;
+    maxOccurrences?: number | null;
+    status: AgentReminderStatus;
+    timezone: string;
+    lastScheduledAt?: number | null;
+    nextRunAt?: number | null;
+    createdByUserId?: string | null;
+    createdByAgentId?: string | null;
+    targetUserId?: string | null;
+    createdAt: number;
+    updatedAt: number;
+    recentOccurrences?: AgentReminderOccurrenceInfo[];
+};
+export type AgentReminderEventInfo = {
+    eventId: string;
+    reminderId: string;
+    occurrenceId?: string | null;
+    eventType: AgentReminderEventType;
+    actorType: 'user' | 'agent' | 'system';
+    actorId?: string | null;
+    actorName?: string | null;
+    payload?: Record<string, unknown> | null;
+    createdAt: number;
+};
+export type CreateAgentReminderRequest = {
+    title: string;
+    promptText: string;
+    scheduleKind: AgentReminderScheduleKind;
+    startAt: number;
+    intervalUnit?: AgentReminderIntervalUnit | null;
+    intervalValue?: number | null;
+    endAt?: number | null;
+    maxOccurrences?: number | null;
+};
+export type UpdateAgentReminderRequest = {
+    title?: string;
+    promptText?: string;
+    scheduleKind?: AgentReminderScheduleKind;
+    startAt?: number;
+    intervalUnit?: AgentReminderIntervalUnit | null;
+    intervalValue?: number | null;
+    endAt?: number | null;
+    maxOccurrences?: number | null;
+};
+export type AgentReminderListResult = {
+    reminders: AgentReminderInfo[];
+};
+export type AgentReminderOccurrenceListResult = {
+    reminder: AgentReminderInfo;
+    occurrences: AgentReminderOccurrenceInfo[];
+};
+export type AgentReminderOccurrenceTaskResult = {
+    taskId: string;
+    status: TaskInfo['status'];
+    taskNumber: number;
+};
+export type AgentReminderCurrentOccurrenceResult = {
+    reminder: AgentReminderInfo;
+    currentOccurrence: AgentReminderOccurrenceInfo | null;
+    latestOccurrence: AgentReminderOccurrenceInfo | null;
+};
+export type AgentReminderOccurrenceActionResult = {
+    ok: true;
+    reminder: AgentReminderInfo;
+    occurrence: AgentReminderOccurrenceInfo;
+    task?: AgentReminderOccurrenceTaskResult | null;
+};
+export type CompleteAgentReminderOccurrenceResult = AgentReminderOccurrenceActionResult;
+export type SubmitReminderOccurrenceForReviewResult = AgentReminderOccurrenceActionResult;
+export type SnoozeAgentReminderOccurrenceRequest = {
+    until: number;
+};
+export type TaskUpdateDeliveryKind = 'task_status_changed' | 'task_created' | 'task_claimed' | 'task_unclaimed' | 'task_details_updated';
+export type TaskUpdateDelivery = {
+    kind: TaskUpdateDeliveryKind;
+    taskNumber: number;
+    status: TaskInfo['status'];
+    summaryText: string;
+    recommendedNoteTargets: string[];
+    noteGuidance: string;
+    memoryReminder: string;
+};
+export type NodeInfoRest = {
+    nodeId: string;
+    hostname: string;
+    agentTypes: string[];
+    version: string;
+    lastSeen: number;
+    terminalBackendAvailable: boolean;
+};
+export type NodeHostInventoryRest = NodeHostSnapshot & {
+    nodeId: string;
+    snapshotAt: number;
+    nodeOnline: boolean;
+};
+export type NodeRuntimeInventoryRest = NodeRuntimeSnapshot & {
+    nodeId: string;
+    snapshotAt: number;
+    nodeOnline: boolean;
+};
+export type MachineInfo = {
+    nodeId: string;
+    name: string;
+    hostname: string | null;
+    agentTypes: string[];
+    version: string | null;
+    status: 'pending' | 'online' | 'offline';
+    envVarKeys: string[];
+    lastSeen: number | null;
+    provisionedAt: number;
+    createdAt: number;
+};
+export type CreateMachineRequest = {
+    name: string;
+    envVarKeys?: string[];
+};
+export type SavedItemSourceKind = 'dm' | 'channel' | 'thread';
+export type SavedItemProcessStatus = 'inbox' | 'processed' | 'skipped';
+export type SavedItem = {
+    id: string;
+    userId: string;
+    messageId: string;
+    senderName: string;
+    content: string;
+    contextUrl: string;
+    sourceKind?: SavedItemSourceKind;
+    processStatus?: SavedItemProcessStatus;
+    processedAt?: number | null;
+    processedRunId?: string | null;
+    sourceDeletedAt?: number | null;
+    sourceDeletedByName?: string | null;
+    createdAt: number;
+};
+export type SaveMessageRequest = {
+    messageId: string;
+    senderName: string;
+    content: string;
+    contextUrl: string;
+    sourceKind?: SavedItemSourceKind;
+};
+export type LibraryCuratorConfig = {
+    userId: string;
+    curatorAgentId: string;
+    nodeId: string | null;
+    libraryRootPath: string;
+    scheduleIntervalMs: number;
+    categories: string[];
+    lastRunAt: number | null;
+    nextRunAt: number | null;
+    enabled: boolean;
+    createdAt: number;
+    updatedAt: number;
+};
+export type UpdateLibraryCuratorConfigRequest = {
+    scheduleIntervalMs?: number;
+    categories?: string[];
+    enabled?: boolean;
+};
+export type LibraryScope = 'personal' | 'shared' | 'all';
+export type WritableLibraryScope = Exclude<LibraryScope, 'all'>;
+export type SharedLibraryConfig = {
+    sharedKey: string;
+    libraryRootPath: string;
+    createdAt: number;
+    updatedAt: number;
+};
+export type PlatformAgentDefinitionId = string;
+export type PlatformAgentRole = PlatformAgentDefinitionId;
+export type PlatformWorkflowType = 'planner_suggestions' | 'library_curate';
+export type PlatformRunMode = 'workflow' | 'debug';
+export type PlatformResourceScope = 'saved_inbox' | 'open_tasks' | 'recent_messages' | 'conversation_summaries' | 'agent_memory' | 'agent_notes' | 'personal_library_inventory' | 'personal_library_documents';
+export type PlatformAgentToolPolicy = {
+    disabledToolKinds?: AgentPermissionKind[];
+};
+export type PlatformAgentDefinition = {
+    definitionId: PlatformAgentDefinitionId;
+    workflowType: PlatformWorkflowType;
+    label: string;
+    description: string;
+    resourceScopes: PlatformResourceScope[];
+    resourceConfig?: Record<string, unknown>;
+    promptTemplateOverride?: string | null;
+    toolPolicy?: PlatformAgentToolPolicy;
+    enabled: boolean;
+    createdAt: number;
+    updatedAt: number;
+};
+export type PlatformAgentRuntimeConfig = {
+    model?: string | null;
+    reasoningEffort?: string | null;
+    envVars?: Record<string, string>;
+};
+export type PlatformAgentInstanceConfig = {
+    userId: string;
+    definitionId: PlatformAgentDefinitionId;
+    agentId: string;
+    enabled: boolean;
+    scheduleIntervalMs: number;
+    workflowConfig: Record<string, unknown>;
+    runtimeConfig: PlatformAgentRuntimeConfig;
+    lastRunAt: number | null;
+    nextRunAt: number | null;
+    createdAt: number;
+    updatedAt: number;
+};
+export type PlatformAgentRunInfo = {
+    runId: string;
+    definitionId: PlatformAgentDefinitionId;
+    userId: string;
+    mode: PlatformRunMode;
+    status: string;
+    createdAt: number;
+    completedAt?: number | null;
+    error?: string | null;
+    generatedCount?: number | null;
+    resourcesAccessed?: {
+        savedItems: number;
+        tasks: number;
+        messages: number;
+    } | null;
+};
+export type PlatformWorkflowCatalogEntry = {
+    workflowType: PlatformWorkflowType;
+    label: string;
+    description: string;
+    defaultResourceScopes: PlatformResourceScope[];
+    defaultToolPolicy: PlatformAgentToolPolicy;
+    defaultPromptTemplate: string;
+};
+export type SuggestedPlannerConfig = {
+    userId: string;
+    plannerAgentId: string;
+    nodeId: string | null;
+    scheduleIntervalMs: number;
+    lookbackDays: number;
+    lastRunAt: number | null;
+    nextRunAt: number | null;
+    enabled: boolean;
+    createdAt: number;
+    updatedAt: number;
+};
+export type PlatformAgentRuntimeConfigPatch = {
+    model?: string | null;
+    reasoningEffort?: string | null;
+    envVars?: Record<string, string>;
+};
+export type UpdateSuggestedPlannerConfigRequest = PlatformAgentRuntimeConfigPatch & {
+    scheduleIntervalMs?: number;
+    lookbackDays?: number;
+    enabled?: boolean;
+};
+export type UpdatePlatformLibraryConfigRequest = UpdateLibraryCuratorConfigRequest & PlatformAgentRuntimeConfigPatch;
+export type UpdatePlatformAgentInstanceRequest = {
+    enabled?: boolean;
+    scheduleIntervalMs?: number;
+    workflowConfig?: Record<string, unknown>;
+    runtimeConfig?: PlatformAgentRuntimeConfig;
+};
+export type CreatePlatformAgentDefinitionRequest = {
+    definitionId: PlatformAgentDefinitionId;
+    workflowType: PlatformWorkflowType;
+    label: string;
+    description: string;
+    resourceScopes?: PlatformResourceScope[];
+    resourceConfig?: Record<string, unknown>;
+    promptTemplateOverride?: string | null;
+    toolPolicy?: PlatformAgentToolPolicy;
+    enabled?: boolean;
+};
+export type UpdatePlatformAgentDefinitionRequest = {
+    label?: string;
+    description?: string;
+    resourceScopes?: PlatformResourceScope[];
+    resourceConfig?: Record<string, unknown>;
+    promptTemplateOverride?: string | null;
+    toolPolicy?: PlatformAgentToolPolicy;
+    enabled?: boolean;
+};
+export type PlatformAgentInfo = {
+    definition: PlatformAgentDefinition;
+    instance: PlatformAgentInstanceConfig;
+    agent: AgentInfo | null;
+    lastRun?: PlatformAgentRunInfo | null;
+};
+export type PanelToolPromotionState = 'eligible_unlinked' | 'direct_promotable' | 'agent_assisted_pending' | 'linked_live_tool' | 'source_archived_linked_live_tool' | 'linked_tool_deleted_retryable' | 'ineligible';
+export type PanelToolPromotionInfo = {
+    panelId: string;
+    state?: PanelToolPromotionState;
+    stateReason?: string | null;
+    ctaLabel?: string | null;
+    disabledReason?: string | null;
+    promotionConversationId?: string | null;
+    toolId?: string | null;
+    toolName?: string | null;
+    toolRevision?: number | null;
+    maintenanceConversationId?: string | null;
+};
+export type WorkspaceToolActionKind = 'start' | 'stop' | 'status' | 'restart' | 'custom';
+export type WorkspaceToolActionMode = 'platform_exec' | 'notify_agent';
+export type WorkspaceToolScope = 'private' | 'channel' | 'public';
+export type WorkspaceToolPublicReviewStatus = 'not_requested' | 'pending_review' | 'approved' | 'rejected';
+export type WorkspaceToolParamInput = 'text' | 'textarea' | 'number' | 'checkbox' | 'select' | 'multiselect' | 'tags' | 'date' | 'file';
+export type WorkspaceToolParamField = {
+    name: string;
+    label?: string;
+    description?: string;
+    input?: WorkspaceToolParamInput;
+    required?: boolean;
+    placeholder?: string;
+    defaultValue?: unknown;
+    min?: number | string;
+    max?: number | string;
+    accept?: string;
+    multiple?: boolean;
+    maxBytes?: number;
+    options?: Array<{
+        label: string;
+        value: string;
+    }>;
+};
+export declare const WORKSPACE_TOOL_PANEL_ACTION_PARAM_NAMESPACE = "tool_action";
+export declare function buildWorkspaceToolPanelActionParamKey(actionId: string, paramName: string): string;
+export declare function parseWorkspaceToolPanelActionParamKey(key: string): {
+    actionId: string;
+    paramName: string;
+} | null;
+export declare function extractWorkspaceToolPanelActionParams(actionId: string, formValues: Record<string, unknown> | null | undefined): Record<string, unknown>;
+export type WorkspaceToolMediaSlotSchema = Omit<DatasetMediaSlotSchema, 'kind'> & {
+    kind: 'workspace_path';
+};
+export type WorkspaceToolStateRow = {
+    fields: Record<string, unknown>;
+    media?: Record<string, {
+        kind: 'workspace_path';
+        value: string;
+    }>;
+};
+export type WorkspaceToolActionManifest = {
+    actionId: string;
+    label: string;
+    description?: string;
+    kind: WorkspaceToolActionKind;
+    mode?: WorkspaceToolActionMode;
+    command?: string;
+    cwd?: string;
+    persistent?: boolean;
+    maxRunSeconds?: number;
+    idleTimeoutSeconds?: number;
+    paramsSchema?: WorkspaceToolParamField[];
+};
+export type WorkspaceToolViewManifest = {
+    title?: string;
+    fields: DatasetFieldSchema[];
+    mediaSlots?: WorkspaceToolMediaSlotSchema[];
+    summary?: PanelLevelNode;
+    parameterForm?: PanelLevelNode;
+    template: PanelTemplateNode;
+};
+export type WorkspaceToolExecutionEnv = {
+    condaEnv?: string;
+    vars?: Record<string, string>;
+    cwd?: string;
+};
+export type WorkspaceToolServiceManifest = {
+    port: number;
+    healthPath?: string;
+};
+export type WorkspaceToolCliManifest = {
+    entry: string;
+};
+export type WorkspaceToolRuntimeMode = 'per_action' | 'persistent_runtime';
+export type WorkspaceToolRuntimeManifest = {
+    mode?: WorkspaceToolRuntimeMode;
+    idleTtlSeconds?: number;
+    entry?: string;
+    logDir?: string;
+};
+export type WorkspaceToolManifest = {
+    slug: string;
+    name: string;
+    description: string;
+    icon?: string;
+    defaultCwd?: string;
+    env?: WorkspaceToolExecutionEnv;
+    cli?: WorkspaceToolCliManifest;
+    runtime?: WorkspaceToolRuntimeManifest;
+    scope?: WorkspaceToolScope;
+    scopeChannelId?: string | null;
+    allowSharedExec?: boolean;
+    service?: WorkspaceToolServiceManifest;
+    actions: WorkspaceToolActionManifest[];
+    view: WorkspaceToolViewManifest;
+};
+export type WorkspaceToolRunStatus = 'running' | 'completed' | 'failed' | 'cancelled' | 'timed_out';
+export type WorkspaceToolRuntimeState = 'idle' | 'running' | 'failed' | 'completed';
+export type WorkspaceToolVerificationStatus = 'needs_verification' | 'checking' | 'verified' | 'warning' | 'failed';
+export type WorkspaceToolPublishDiagnosticSeverity = 'error' | 'warning' | 'info';
+export type WorkspaceToolPublishDiagnostic = {
+    severity: WorkspaceToolPublishDiagnosticSeverity;
+    code: string;
+    message: string;
+    actionIds?: string[];
+};
+export type WorkspaceToolRunEventType = 'log' | 'progress' | 'result' | 'error' | 'artifact' | 'cleanup_started' | 'cleanup_completed' | 'cleanup_timed_out' | 'cleanup_failed' | 'runtime_action_timed_out';
+export type WorkspaceToolBackendRuntime = 'cli' | 'command' | 'none';
+export type WorkspaceToolRunArtifactRef = {
+    path: string;
+    label?: string;
+    mimeType?: string;
+    sizeBytes?: number;
+};
+export type WorkspaceToolRunEventInfo = {
+    eventId: string;
+    runId: string;
+    toolId: string;
+    sequence: number;
+    type: WorkspaceToolRunEventType;
+    level?: string | null;
+    summary?: string | null;
+    payload?: Record<string, unknown> | null;
+    artifacts?: WorkspaceToolRunArtifactRef[] | null;
+    createdAt: number;
+};
+export type WorkspaceToolRunEventsResult = {
+    events: WorkspaceToolRunEventInfo[];
+    nextBeforeSequence?: number | null;
+};
+export type WorkspaceToolRunArtifactListItem = {
+    eventId: string;
+    eventSequence: number;
+    eventCreatedAt: number;
+    eventType: WorkspaceToolRunEventType;
+    eventSummary?: string | null;
+    artifact: WorkspaceToolRunArtifactRef;
+};
+export type WorkspaceToolRunArtifactsResult = {
+    artifacts: WorkspaceToolRunArtifactListItem[];
+    nextBeforeSequence?: number | null;
+};
+export type WorkspaceToolRunInfo = {
+    runId: string;
+    toolId: string;
+    toolRevision?: number | null;
+    actionId: string;
+    actionKind?: WorkspaceToolActionKind;
+    terminalId?: string | null;
+    status: WorkspaceToolRunStatus;
+    params?: Record<string, unknown> | null;
+    exitCode?: number | null;
+    signal?: string | null;
+    startedAt: number;
+    endedAt?: number | null;
+    requestedByUserId?: string | null;
+    requestedByUsername?: string | null;
+    requestedByAgentId?: string | null;
+    requestedByAgentName?: string | null;
+    executionTargetKind?: 'owner_agent' | string | null;
+    executionAgentId?: string | null;
+    executionNodeId?: string | null;
+    executionHostname?: string | null;
+    executionWorkspacePath?: string | null;
+    events?: WorkspaceToolRunEventInfo[];
+};
+export type WorkspaceToolAgentHealth = {
+    isOnline: boolean;
+    isDeleted: boolean;
+    hasNode: boolean;
+    hasWorkspace: boolean;
+};
+export type WorkspaceToolInfo = {
+    toolId: string;
+    userId: string;
+    agentId: string;
+    agentName?: string | null;
+    agentNodeId?: string | null;
+    agentHealth?: WorkspaceToolAgentHealth | null;
+    sourcePanelId?: string | null;
+    panelId?: string | null;
+    slug: string;
+    name: string;
+    description: string;
+    icon?: string | null;
+    scope: WorkspaceToolScope;
+    scopeChannelId?: string | null;
+    allowSharedExec: boolean;
+    publicReviewStatus: WorkspaceToolPublicReviewStatus;
+    pendingPublicReview: boolean;
+    isOwner: boolean;
+    canManage: boolean;
+    manifestPath: string | null;
+    bundleRoot: string | null;
+    backendRuntime?: WorkspaceToolBackendRuntime;
+    actionBackendRuntimes?: Record<string, WorkspaceToolBackendRuntime>;
+    manifest: WorkspaceToolManifest;
+    latestState?: WorkspaceToolStateRow | null;
+    businessState?: string | null;
+    runtimeState?: WorkspaceToolRuntimeState;
+    isRunning: boolean;
+    activeTerminalId?: string | null;
+    maintenanceConversationId?: string | null;
+    sourceConversationId?: string | null;
+    sourceMessageId?: string | null;
+    clonedFromToolId?: string | null;
+    clonedFromRevision?: number | null;
+    verification?: WorkspaceToolVerificationInfo | null;
+    revision: number;
+    createdAt: number;
+    updatedAt: number;
+    deletedAt?: number | null;
+    lastRun?: WorkspaceToolRunInfo | null;
+};
+export type WorkspaceToolVerificationInfo = {
+    verificationId: string;
+    toolId: string;
+    toolRevision: number;
+    sourceToolId?: string | null;
+    sourceRevision?: number | null;
+    targetAgentId: string;
+    targetNodeId?: string | null;
+    targetWorkspacePath?: string | null;
+    conversationId?: string | null;
+    status: WorkspaceToolVerificationStatus;
+    summary?: string | null;
+    details?: Record<string, unknown> | null;
+    smokeRunId?: string | null;
+    startedAt: number;
+    endedAt?: number | null;
+    updatedAt: number;
+};
+export type UpdateWorkspaceToolSettingsRequest = {
+    scope: WorkspaceToolScope;
+    scopeChannelId?: string | null;
+    allowSharedExec?: boolean;
+    cancelPendingPublicReview?: boolean;
+};
+export type CloneWorkspaceToolRequest = {
+    targetAgentId: string;
+    slug?: string | null;
+    name?: string | null;
+    description?: string | null;
+};
+export type CloneWorkspaceToolResponse = {
+    tool: WorkspaceToolInfo;
+    toolUrl: string;
+    verification?: WorkspaceToolVerificationInfo | null;
+};
+export type WorkspaceToolPlatformExecActionResult = {
+    mode: 'platform_exec';
+    tool: WorkspaceToolInfo;
+    run: WorkspaceToolRunInfo;
+    latestState?: WorkspaceToolStateRow | null;
+    outputText?: string | null;
+};
+export type WorkspaceToolNotifyAgentActionResult = {
+    mode: 'notify_agent';
+    tool: WorkspaceToolInfo;
+    conversationId: string;
+    queued: boolean;
+    runId?: string;
+    latestState?: WorkspaceToolStateRow | null;
+    outputText?: null;
+};
+export type WorkspaceToolActionResult = WorkspaceToolPlatformExecActionResult | WorkspaceToolNotifyAgentActionResult;
+export type LibraryDocument = {
+    id: string;
+    scope?: WritableLibraryScope;
+    userId?: string | null;
+    title: string;
+    category: string;
+    topicPath: string;
+    relativePath: string;
+    summary: string;
+    sourceSavedItemIds: string[];
+    createdAt: number;
+    updatedAt: number;
+    lastRunId?: string | null;
+    notionPageId?: string | null;
+    notionPageUrl?: string | null;
+};
+export type LibraryDocumentTreeNode = {
+    scope?: WritableLibraryScope;
+    name: string;
+    path: string;
+    kind: 'directory' | 'file';
+    children?: LibraryDocumentTreeNode[];
+};
+export type LibraryOrganizeResult = {
+    ok: boolean;
+    runId?: string;
+    queued?: boolean;
+    skipped?: boolean;
+    reason?: string;
+    error?: string;
+};
+export * from './handoff.js';
+export * from './panel.js';