@hunsu/bridge 0.1.1

package/dist/index.d.ts

@@ -0,0 +1,1001 @@
+import { type IncomingMessage, type ServerResponse } from "node:http";
+import { type TeamRunEvent, type JsonRpcMessage, type Runner, type RunnerAppServerCommandAction, type RunnerAppServerItem } from "@hunsu/codex-runner";
+import { type BridgeRuntimeConfig } from "@hunsu/config";
+import { type CommitSha, type ArtifactActionCommandRunner, type ArtifactActionRunPlan, type ArtifactActionRunRecord } from "@hunsu/core";
+import type { HunsuPortApplyResult, HunsuPortInspection, HunsuPortPlan } from "@hunsu/core";
+import type { ManagerConfig } from "@hunsu/protocol";
+import { type Result } from "@hunsu/protocol";
+import { type ExecuteRunStatus } from "./execute/execute-model.ts";
+import type { AgentConversationRef, ArtifactRecord, BoardProjection, Command, DomainEvent, HarnessSnapshot, HubPackageLock, HunsuRecord, ReadyHunsuDraft, LineRecord, LocalSnapshotSkillMetadata, MoveId, MoveOutcome, NodeId, PathId, ExecutionPlan, MemberPath, PositiveInteger, RegistryPackageSkillMetadata, SkillMetaSkillMetadata, SkillSnapshotFile, Destination, DestinationSeed, WorktreeRef } from "@hunsu/protocol";
+export type StudioRunStatus = ExecuteRunStatus;
+export type StudioSkillFile = {
+    path: string;
+    size: number;
+    text?: string;
+};
+export type StudioSkillSummary = LocalSnapshotSkillMetadata & {
+    files: StudioSkillFile[];
+};
+export type ApmSkillReference = {
+    kind: "registry-package";
+    registryKind: "apm";
+    name: string;
+    registry: string;
+    package: string;
+    version: string;
+};
+export type ApmSkillRegistryClient = {
+    resolveSkill(ref: ApmSkillReference): Promise<RegistryPackageSkillMetadata>;
+    fetchSkillFiles(lock: RegistryPackageSkillMetadata): Promise<SkillSnapshotFile[]>;
+};
+export type SkillMetaInstallOptions = {
+    env?: Record<string, string | undefined>;
+    home?: string;
+};
+export type SkillMetaInstaller = {
+    install(skill: SkillMetaSkillMetadata, cwd: string, options: SkillMetaInstallOptions): Promise<void>;
+};
+export type StudioRunState = {
+    runId: string;
+    roadmapId?: string;
+    executeId: string;
+    requestId: string;
+    lineId: string;
+    repositoryPath?: string;
+    provider: "codex";
+    source?: "live" | "rehydrated";
+    status: StudioRunStatus;
+    selectedDestinationIds: string[];
+    harnessLock?: HubPackageLock;
+    sourceNodeId?: NodeId;
+    sourceMoveId?: MoveId;
+    targetMoveOrdinal?: PositiveInteger;
+    worktree?: WorktreeRef;
+    conversationRef?: AgentConversationRef;
+    outcome?: MoveOutcome;
+    providerThreadId?: string;
+    providerTeamThreadId?: string;
+    providerTeamPlanningTurnId?: string;
+    providerMemberThreadId?: string;
+    providerFinalizerThreadId?: string;
+    providerTurnIds?: string[];
+    finalResponse?: string;
+    attemptCount?: 0 | PositiveInteger;
+    maxAttemptCount?: PositiveInteger;
+    currentExecution?: ExecutionPlan;
+    memberEvaluations?: StudioMemberPathEvaluation[];
+    executionPlanPlan?: MemberPath[];
+    pathCommits?: Record<string, CommitSha>;
+    planExecutionTransition?: StudioExecutionTransition;
+    memberPathRuns?: StudioMemberPathRun[];
+    terminalMemberPathId?: PathId;
+    terminalPathCommit?: CommitSha;
+    moveFinalizerMessage?: string;
+    moveFinalizerCommit?: CommitSha;
+    error?: string;
+    debugEvents: TeamRunEvent[];
+    rawAppServerMessages: StudioRawAppServerMessage[];
+    codexTurns: StudioCodexTurn[];
+    codexItems: StudioCodexItem[];
+    agentSessionIds?: string[];
+    agentSessions: AgentSession[];
+    activeItemIds: string[];
+    activeAgentSessionId?: string;
+    liveStatus?: StudioLiveStatus;
+    assistantTranscript: StudioAssistantTranscript[];
+    startedAt: string;
+    updatedAt: string;
+};
+export type StudioRunSummary = Omit<StudioRunState, "currentExecution" | "debugEvents" | "rawAppServerMessages" | "codexItems" | "assistantTranscript" | "finalResponse" | "moveFinalizerMessage"> & {
+    finalResponse?: string;
+    moveFinalizerMessage?: string;
+    debugEventCount: number;
+    rawAppServerMessageCount: number;
+    codexItemCount: number;
+    assistantTranscriptCount: number;
+};
+export type StudioRawAppServerMessage = {
+    direction: "server-notification" | "server-request";
+    method?: string;
+    providerThreadId?: string;
+    providerTurnId?: string;
+    message: JsonRpcMessage;
+    at: string;
+};
+export type StudioCodexTurn = {
+    providerThreadId: string;
+    providerTurnId: string;
+    status: "started" | "completed";
+    startedAt?: string;
+    completedAt?: string;
+};
+export type StudioCodexItem = {
+    itemId: string;
+    providerThreadId?: string;
+    providerTurnId?: string;
+    type: string;
+    status: "started" | "streaming" | "completed";
+    title: string;
+    detail?: string;
+    text?: string;
+    summary?: string[];
+    content?: string[];
+    command?: string;
+    cwd?: string;
+    commandActions?: RunnerAppServerCommandAction[];
+    output?: string;
+    changes?: unknown;
+    rawItem?: RunnerAppServerItem;
+    durationMs?: number;
+    startedAt?: string;
+    completedAt?: string;
+    updatedAt: string;
+};
+export type StudioLiveStatus = {
+    phase: "working" | "thinking" | "exploring" | "running" | "waiting" | "idle";
+    headline: string;
+    detail?: string;
+    itemId?: string;
+    providerTurnId?: string;
+    updatedAt: string;
+};
+export type StudioAssistantTranscript = {
+    itemId: string;
+    providerThreadId?: string;
+    providerTurnId?: string;
+    text: string;
+    status: "streaming" | "completed";
+    updatedAt: string;
+};
+export type AgentSessionOwner = {
+    kind: "TeamPlan";
+    runId: string;
+    executeId: string;
+    attempt: PositiveInteger;
+} | {
+    kind: "ExecutionPlan";
+    runId: string;
+    executeId: string;
+    attempt: PositiveInteger;
+    pathId: PathId;
+    executorId: string;
+} | {
+    kind: "MoveFinalizer";
+    runId: string;
+    executeId: string;
+    moveId?: MoveId;
+} | {
+    kind: "HunsuDraft";
+    draftSessionId: string;
+};
+export type AgentSessionRouteKind = "Plan" | "Path" | "HunsuDraft";
+export type AgentSessionRouteRef = {
+    kind: "Route";
+    routeKind: AgentSessionRouteKind;
+    routeId: string;
+    sourceLineId: string;
+    sourceNodeId: string;
+    targetNodeId?: string;
+    worktree?: WorktreeRef;
+    runId?: string;
+    executeId?: string;
+    draftSessionId?: string;
+};
+export type AgentInteractionRequest = {
+    interactionId: string;
+    prompt: string;
+    createdAt: string;
+};
+export type AgentSessionState = {
+    type: "waiting";
+    reason?: string;
+} | {
+    type: "starting";
+    startedAt: string;
+} | {
+    type: "executing";
+    provider: StudioAgentSessionRef;
+    activeItemIds: string[];
+} | {
+    type: "interactWait";
+    provider: StudioAgentSessionRef;
+    interaction: AgentInteractionRequest;
+    activeItemIds: string[];
+} | {
+    type: "completed";
+    provider?: StudioAgentSessionRef;
+    finalResponse?: string;
+    completedAt: string;
+} | {
+    type: "failed";
+    provider?: StudioAgentSessionRef;
+    error: string;
+    completedAt: string;
+};
+export type AgentMessageRole = "user" | "assistant" | "tool" | "reasoning" | "system";
+export type AgentMessage = {
+    sessionId: string;
+    messageId: string;
+    itemId: string;
+    role: AgentMessageRole;
+    type: string;
+    status: "started" | "streaming" | "completed";
+    title: string;
+    text?: string;
+    summary?: string[];
+    content?: string[];
+    command?: string;
+    cwd?: string;
+    commandActions?: RunnerAppServerCommandAction[];
+    output?: string;
+    changes?: unknown;
+    durationMs?: number;
+    revision: number;
+    createdAt: string;
+    updatedAt: string;
+    completedAt?: string;
+};
+export type AgentSession = {
+    sessionId: string;
+    roadmapId?: string;
+    routeRef: AgentSessionRouteRef;
+    runId?: string;
+    executeId?: string;
+    owner: AgentSessionOwner;
+    state: AgentSessionState;
+    provider?: StudioAgentSessionRef;
+    messages: AgentMessage[];
+    activeItemIds: string[];
+    finalResponse?: string;
+    error?: string;
+    revision: number;
+    createdAt: string;
+    updatedAt: string;
+};
+export type StudioExecuteView = StudioRunSummary & {
+    executeId: string;
+    teamRouteId: string;
+    selectedDestinationIds: string[];
+    sourceMoveId?: MoveId;
+    targetMoveOrdinal?: PositiveInteger;
+    statusLabel: string;
+    outcomeLabel?: "Arrived" | "Accident";
+    memberEvaluations: StudioMemberPathEvaluation[];
+};
+export type StudioRoadmapView = BoardProjection & {
+    roadmap: BoardProjection;
+    destinations: Destination[];
+    teams: LineRecord[];
+    moves: BoardProjection["moves"];
+    hunsus: BoardProjection["hunsus"];
+};
+export type StudioExecuteCompletionFacts = {
+    summary: string;
+    evidence: string[];
+    risks: string[];
+};
+export type StudioMemberPathEvaluation = StudioExecuteCompletionFacts & {
+    terminalPathId?: PathId;
+    terminalPathCommit?: CommitSha;
+    attempt: PositiveInteger;
+    at: string;
+};
+export type StudioAgentSessionRef = {
+    providerThreadId: string;
+    providerTurnId: string;
+};
+export type StudioEncodedRuntimeFile = {
+    path: string;
+    commit: CommitSha;
+    text: string;
+};
+export type StudioExecutionFileState = "present" | "none";
+export type StudioExecutionNextState = StudioExecutionFileState | "pending";
+export type StudioExecutionTransition = {
+    path: string;
+    previousCommit?: CommitSha;
+    previous?: StudioEncodedRuntimeFile;
+    previousState: StudioExecutionFileState;
+    nextCommit?: CommitSha;
+    next?: StudioEncodedRuntimeFile;
+    nextState: StudioExecutionNextState;
+};
+type StudioMemberPathRunBase = {
+    pathId: PathId;
+    executorId: string;
+    goal: string;
+    requires: MemberPath["requires"];
+    attempt: PositiveInteger;
+    agentSessionId?: string;
+    dependencyPathIds: PathId[];
+    dependencyOutputs: string[];
+    currentExecutionFile?: StudioEncodedRuntimeFile;
+    currentExecutionTransition?: StudioExecutionTransition;
+    startedAt: string;
+};
+export type StudioMemberPathRun = (StudioMemberPathRunBase & {
+    status: "planned" | "starting";
+}) | (StudioMemberPathRunBase & {
+    status: "executing";
+    session: StudioAgentSessionRef;
+}) | (StudioMemberPathRunBase & {
+    status: "completed";
+    session: StudioAgentSessionRef;
+    finalResponse: string;
+    commit?: CommitSha;
+    parentCommit?: CommitSha;
+    treeChanged?: boolean;
+    completedAt: string;
+}) | (StudioMemberPathRunBase & {
+    status: "failed";
+    session?: StudioAgentSessionRef;
+    error: string;
+    finalResponse?: string;
+    commit?: CommitSha;
+    parentCommit?: CommitSha;
+    treeChanged?: boolean;
+    completedAt: string;
+});
+export type StudioServerState = {
+    events: DomainEvent[];
+    runs: Record<string, StudioRunState>;
+    agentSessions: Record<string, AgentSession>;
+    hunsuDrafts: Record<string, StudioHunsuDraftSession>;
+    hunsuDraftArtifacts: Record<string, StudioHunsuDraftArtifact>;
+    filesystemCapabilities: Record<string, FilesystemBrowseCapability>;
+    liveSubscribers: Set<StudioLiveSubscriber>;
+    agentSessionSubscribers: Set<AgentSessionSubscriber>;
+};
+export type StudioServerSecurityOptions = {
+    authToken?: string;
+    allowedOrigins?: string[];
+    allowNoOrigin?: boolean;
+};
+export type StudioServerOptions = {
+    state?: StudioServerState;
+    cwd?: string;
+    persist?: boolean;
+    runner?: Runner;
+    actionRunner?: ArtifactActionCommandRunner;
+    apmSkillRegistryClient?: ApmSkillRegistryClient;
+    roadmapRegistryPath?: string;
+    runtimeConfig?: BridgeRuntimeConfig;
+    security?: StudioServerSecurityOptions;
+};
+export type StudioCommandResult = {
+    acceptedEvents: DomainEvent[];
+    board: BoardProjection;
+};
+export type StudioCommandRequest = Command | {
+    commands: Command[];
+};
+export type RepositorySelectionRequest = {
+    cwd: string;
+};
+export type RepositorySelectionResult = {
+    repository: WorktreeStatus;
+    board: BoardProjection;
+};
+export type RoadmapRegistryEntry = {
+    roadmapId: string;
+    displayName: string;
+    repositoryPath: string;
+    lastOpenedAt: string;
+    lastKnownBranch?: string;
+    health: "ok" | "missing";
+};
+export type RoadmapOpenRequest = {
+    path?: string;
+    cwd?: string;
+    browseToken?: string;
+    title?: string;
+};
+export type RoadmapPortRequest = RoadmapOpenRequest & {
+    goal?: string;
+    destinations?: DestinationSeed[];
+};
+export type RoadmapOpenResult = {
+    roadmap: RoadmapRegistryEntry;
+    repository: WorktreeStatus;
+    board: BoardProjection;
+};
+export type RoadmapPortInspectResult = {
+    port: HunsuPortInspection;
+    plan?: HunsuPortPlan;
+};
+export type RoadmapPortApplyResult = RoadmapOpenResult & {
+    port: HunsuPortApplyResult;
+};
+export type BrowseRootId = string & {
+    readonly __brand: "BrowseRootId";
+};
+export type BrowseToken = string & {
+    readonly __brand: "BrowseToken";
+};
+export type CanonicalLocalPath = string & {
+    readonly __brand: "CanonicalLocalPath";
+};
+export type FilesystemBrowseRoot = {
+    rootId: BrowseRootId;
+    path: CanonicalLocalPath;
+    label: string;
+};
+export type FilesystemBrowseCapability = {
+    browseToken: BrowseToken;
+    rootId: BrowseRootId;
+    path: CanonicalLocalPath;
+    displayPath: string;
+    issuedAt: string;
+    expiresAt: string;
+};
+export type FilesystemBrowseError = {
+    code: "no_roots" | "invalid_root" | "outside_root" | "not_directory" | "protected_path" | "invalid_grant" | "expired_grant";
+    message: string;
+};
+export type FilesystemBrowseEntry = {
+    kind: "directory";
+    name: string;
+    path: string;
+    rootId: BrowseRootId;
+    type: "directory";
+    isGitRepository: boolean;
+    isRoadmap: boolean;
+};
+export type FilesystemBrowseResult = {
+    path: string;
+    parent?: string;
+    rootId: BrowseRootId;
+    roots: FilesystemBrowseRoot[];
+    entries: FilesystemBrowseEntry[];
+};
+export type FilesystemGrantRequest = {
+    rootId?: string;
+    path?: string;
+};
+export type FilesystemGrantResult = {
+    capability: FilesystemBrowseCapability;
+};
+export type MoveFileNode = {
+    kind: "directory";
+    name: string;
+    path: string;
+} | {
+    kind: "textFile";
+    name: string;
+    path: string;
+    size: number;
+} | {
+    kind: "binaryFile";
+    name: string;
+    path: string;
+    size: number;
+} | {
+    kind: "tooLarge";
+    name: string;
+    path: string;
+    size: number;
+} | {
+    kind: "hiddenRuntime";
+    name: string;
+    path: string;
+};
+export type MoveFileTree = {
+    moveId: string;
+    commit: string;
+    path: string;
+    parent?: string;
+    nodes: MoveFileNode[];
+    changedPaths: string[];
+    runtimeCapsule: MoveRuntimeCapsule;
+};
+export type MoveFileBlob = {
+    kind: "text";
+    moveId: string;
+    commit: string;
+    path: string;
+    text: string;
+    language?: string;
+    size: number;
+} | {
+    kind: "binary";
+    moveId: string;
+    commit: string;
+    path: string;
+    size: number;
+} | {
+    kind: "tooLarge";
+    moveId: string;
+    commit: string;
+    path: string;
+    size: number;
+    maxBytes: number;
+} | {
+    kind: "hiddenRuntime";
+    moveId: string;
+    commit: string;
+    path: string;
+};
+export type MoveFileReadError = {
+    code: "unknown_move" | "invalid_path" | "not_found" | "not_file" | "git_error";
+    message: string;
+};
+export type MoveRuntimeCapsule = {
+    hiddenRuntimeFileCount: number;
+    runtimePaths: string[];
+    summary: string;
+};
+export type StudioRunStartRequest = {
+    requestId?: string;
+    lineId?: string;
+    selectedDestinationIds?: string[];
+};
+export type StudioRunActionRequest = {
+    runId: string;
+};
+export type StudioActionRunStartRequest = {
+    actionId?: string;
+    moveId?: string;
+    commit?: string;
+    env?: Record<string, string>;
+    dryRun?: boolean;
+};
+export type StudioLineDecisionRequest = {
+    lineId: string;
+    reason?: string;
+};
+export type StudioMoveCompletionRequest = {
+    runId: string;
+    fromRef: string;
+    summary: string;
+    destinationIds?: string[];
+    evidence: string[];
+    risks?: string[];
+    approvedRisks?: boolean;
+};
+export type StudioRunResult = {
+    run: StudioRunSummary;
+    execute: StudioExecuteView;
+    board: BoardProjection;
+};
+export type StudioMoveCompletionResult = StudioRunResult & {
+    moveId: string;
+    commit: string;
+    acceptedEvents: DomainEvent[];
+};
+export type StudioHunsuDraftStatus = "draft" | "ready" | "confirmed" | "discarded" | "failed";
+export type StudioHunsuDraftChatRole = "user" | "draft-agent" | "system";
+export type StudioHunsuDraftMessage = {
+    messageId: string;
+    role: StudioHunsuDraftChatRole;
+    text: string;
+    createdAt: string;
+};
+export type StudioHunsuDraftRuntimeFileChange = {
+    path: string;
+    kind: "added" | "updated" | "removed";
+    summary: string;
+    diff: string;
+};
+export type StudioHunsuDraftRuntimeFileDiff = {
+    path: string;
+    kind: "added" | "updated" | "removed";
+    diff: string;
+};
+export type StudioHunsuDraftChanges = {
+    draftSessionId: string;
+    sourceNodeId: string;
+    requestDir: string;
+    previousDir: string;
+    ok: boolean;
+    summary: string;
+    errors: string[];
+    files: StudioHunsuDraftRuntimeFileChange[];
+    checkedAt?: string;
+};
+export type StudioHunsuDraftDiffArtifact = {
+    diffArtifactId: string;
+    draftSessionId: string;
+    status: "pass" | "failed";
+    newTeamName?: string;
+    files: StudioHunsuDraftRuntimeFileDiff[];
+    errors: string[];
+    failedReason?: string;
+    checkedAt: string;
+    draftSurfaceHash: string;
+};
+type StudioHunsuDraftDiffArtifactRecord = Omit<StudioHunsuDraftDiffArtifact, "files"> & {
+    summary: string;
+    files: StudioHunsuDraftRuntimeFileChange[];
+    readyDraft?: ReadyHunsuDraft;
+};
+export type StudioHunsuDraftArtifact = {
+    artifactId: string;
+    kind: "source-protocol";
+    repositoryPath: string;
+    roadmapId?: string;
+    draftSessionId: string;
+    baseArtifactId?: string;
+    value: unknown;
+    createdAt: string;
+};
+export type StudioHunsuDraftSession = {
+    draftSessionId: string;
+    roadmapId?: string;
+    repositoryPath: string;
+    sourceLineId: string;
+    sourceNodeId: string;
+    sourceMoveId?: string;
+    routeId: string;
+    worktree?: WorktreeRef;
+    agentSessionIds: string[];
+    activeAgentSessionId?: string;
+    draftAgentSessionId?: string;
+    sourceArtifactId: string;
+    currentArtifactId: string;
+    managerLock?: HubPackageLock;
+    manager: ManagerConfig;
+    confirmedHunsuId?: string;
+    confirmedNodeId?: string;
+    providerThreadId?: string;
+    messages: StudioHunsuDraftMessage[];
+    readyDraft?: ReadyHunsuDraft;
+    latestDiffArtifactId?: string;
+    diffArtifacts: Record<string, StudioHunsuDraftDiffArtifactRecord>;
+    status: StudioHunsuDraftStatus;
+    error?: string;
+    createdAt: string;
+    updatedAt: string;
+};
+export type StudioHunsuDraftStartRequest = {
+    sourceNodeId?: string;
+    sourceMoveId?: string;
+    sourceLineId?: string;
+    managerLock?: HubPackageLock;
+    message?: string;
+};
+export type StudioHunsuDraftMessageRequest = {
+    message: string;
+};
+export type StudioHunsuDraftResult = {
+    draft: StudioHunsuDraftSession;
+    board: BoardProjection;
+    diffArtifact?: StudioHunsuDraftDiffArtifact;
+    acceptedEvents?: DomainEvent[];
+    hunsu?: HunsuRecord;
+};
+export type StudioHunsuDraftDiffArtifactResult = {
+    diffArtifact: StudioHunsuDraftDiffArtifact;
+};
+export type StudioHunsuDraftCheckCommandChangedFile = {
+    path: string;
+    kind: "added" | "updated" | "removed";
+};
+export type StudioHunsuDraftCheckCommandPassResult = {
+    status: "pass";
+    draftSessionId: string;
+    diffArtifactId: string;
+    marker: string;
+    checkedAt: string;
+    changedFiles: StudioHunsuDraftCheckCommandChangedFile[];
+};
+export type StudioHunsuDraftCheckCommandFailedResult = {
+    status: "failed";
+    draftSessionId: string;
+    diffArtifactId: string;
+    marker: string;
+    checkedAt: string;
+    failedReason: string;
+    errors: string[];
+};
+export type StudioHunsuDraftCheckCommandResult = StudioHunsuDraftCheckCommandPassResult | StudioHunsuDraftCheckCommandFailedResult;
+export type HunsuDraftRouteRuntimeFile = {
+    schema: "hunsu.hunsu-draft-route.v1";
+    draftSessionId: string;
+    roadmapId?: string;
+    repositoryPath: string;
+    routeId: string;
+    sourceLineId: string;
+    sourceNodeId: string;
+    sourceMoveId?: string;
+    sourceArtifactId: string;
+    currentArtifactId: string;
+    managerLock?: HubPackageLock;
+    manager: ManagerConfig;
+    confirmedHunsuId?: string;
+    confirmedNodeId?: string;
+    status: StudioHunsuDraftStatus;
+    readyDraft?: ReadyHunsuDraft;
+    latestDiffArtifactId?: string;
+    diffArtifacts?: Record<string, StudioHunsuDraftDiffArtifactRecord>;
+    worktree?: WorktreeRef;
+    updatedAt: string;
+};
+export type StudioLiveEvent = {
+    type: "runs.snapshot";
+    runs: StudioRunSummary[];
+    executes: StudioExecuteView[];
+} | {
+    type: "run.updated";
+    run: StudioRunSummary;
+    execute: StudioExecuteView;
+    board?: BoardProjection;
+};
+export type StudioLiveSubscriber = (event: StudioLiveEvent) => void;
+export type AgentSessionListResult = {
+    sessions: AgentSession[];
+};
+export type AgentSessionResult = {
+    session: AgentSession;
+};
+export type AgentSessionLifecyclePatch = {
+    type: "agentSession.lifecycle";
+    sessionId: string;
+    roadmapId?: string;
+    routeRef: AgentSessionRouteRef;
+    runId?: string;
+    executeId?: string;
+    owner: AgentSessionOwner;
+    state: AgentSessionState;
+    provider?: StudioAgentSessionRef;
+    activeItemIds: string[];
+    finalResponse?: string;
+    error?: string;
+    sessionRevision: number;
+    updatedAt: string;
+};
+export type AgentSessionEvent = {
+    type: "agentSession.snapshot";
+    sessions: AgentSession[];
+} | AgentSessionLifecyclePatch | {
+    type: "agentMessage.delta";
+    sessionId: string;
+    roadmapId?: string;
+    routeRef: AgentSessionRouteRef;
+    runId?: string;
+    executeId?: string;
+    messageId: string;
+    itemId: string;
+    role: AgentMessageRole;
+    messageType: string;
+    title: string;
+    field: "text" | "output" | "summary" | "content";
+    delta: string;
+    contentIndex?: number;
+    messageRevision: number;
+    sessionRevision: number;
+    createdAt: string;
+    updatedAt: string;
+} | {
+    type: "agentMessage.completed";
+    sessionId: string;
+    roadmapId?: string;
+    routeRef: AgentSessionRouteRef;
+    runId?: string;
+    executeId?: string;
+    messageId: string;
+    itemId: string;
+    role: AgentMessageRole;
+    messageType: string;
+    title: string;
+    status: "completed";
+    text?: string;
+    summary?: string[];
+    content?: string[];
+    command?: string;
+    cwd?: string;
+    commandActions?: RunnerAppServerCommandAction[];
+    output?: string;
+    changes?: unknown;
+    messageRevision: number;
+    sessionRevision: number;
+    createdAt: string;
+    completedAt: string;
+    durationMs?: number;
+    updatedAt: string;
+};
+export type AgentSessionSubscriber = (event: AgentSessionEvent) => void;
+export type WorktreeChange = {
+    status: string;
+    path: string;
+};
+export type WorktreeStatus = {
+    root: string;
+    branch: string;
+    clean: boolean;
+    changes: WorktreeChange[];
+};
+export type MoveDiff = {
+    moveId: string;
+    commit: string;
+    headCommit: string;
+    baseCommit?: string;
+    baseMoveId?: string;
+    files: MoveDiffFile[];
+    tree: MoveDiffTreeNode[];
+    text: string;
+};
+export type MoveDiffFileKind = "added" | "modified" | "removed" | "renamed" | "copied" | "typeChanged";
+export type MoveDiffFile = {
+    path: string;
+    oldPath?: string;
+    kind: MoveDiffFileKind;
+    patch: string;
+};
+export type MoveDiffTreeNode = {
+    kind: "directory";
+    name: string;
+    path: string;
+    changedFileCount: number;
+    children: MoveDiffTreeNode[];
+} | {
+    kind: "file";
+    name: string;
+    path: string;
+    oldPath?: string;
+    changeKind: MoveDiffFileKind;
+};
+export declare function createStudioState(events?: DomainEvent[]): StudioServerState;
+export declare function createBridgeApiAuthToken(): string;
+export type StudioBridgeStartOptions = {
+    cwd?: string;
+    webUrl?: string;
+    noOpen?: boolean;
+    dryRun?: boolean;
+    json?: boolean;
+    env?: Record<string, string | undefined>;
+};
+export type StudioBridgeStartInfo = {
+    bridgeApiUrl: string;
+    studioUrl: string;
+    allowedOrigin: string;
+};
+export declare function startStudioBridge(options?: StudioBridgeStartOptions): Promise<StudioBridgeStartInfo>;
+export declare function createStudioServer(options?: StudioServerOptions): import("http").Server<typeof IncomingMessage, typeof ServerResponse>;
+type ArtifactActionApiOptions = {
+    cwd: string;
+    roadmapId?: string;
+    actionRunner?: ArtifactActionCommandRunner;
+    ambientEnv?: Record<string, string | undefined>;
+    processEnv?: Record<string, string | undefined>;
+    worktreeRoot?: string;
+};
+export declare function createHttpApmSkillRegistryClient(fetchImpl?: typeof fetch): ApmSkillRegistryClient;
+export declare function planStudioArtifactActionRun(request: StudioActionRunStartRequest, options: ArtifactActionApiOptions): ArtifactActionRunPlan;
+export declare function startStudioArtifactActionRun(request: StudioActionRunStartRequest, options: ArtifactActionApiOptions): ArtifactActionRunRecord;
+export declare function boardFromEvents(events: DomainEvent[]): BoardProjection;
+export declare function subscribeStudioLiveEvents(state: StudioServerState, subscriber: StudioLiveSubscriber, options?: {
+    cwd?: string;
+}): () => void;
+type AgentSessionSubscriptionScope = {
+    cwd?: string;
+    roadmapId?: string;
+    sessionId?: string;
+};
+export declare function subscribeAgentSessionEvents(state: StudioServerState, subscriber: AgentSessionSubscriber, options?: AgentSessionSubscriptionScope): () => void;
+export declare function toStudioRoadmapView(board: BoardProjection): StudioRoadmapView;
+export declare function toStudioExecuteView(run: StudioRunState | StudioRunSummary): StudioExecuteView;
+export declare function findArtifact(board: BoardProjection, artifactId: string): ArtifactRecord | undefined;
+export declare function readWorktreeStatus(cwd?: string): WorktreeStatus;
+export declare function listRoadmapRegistry(options?: {
+    roadmapRegistryPath?: string;
+}): RoadmapRegistryEntry[];
+export declare function openStudioRoadmap(request: RoadmapOpenRequest, state: StudioServerState, options?: {
+    persist?: boolean;
+    roadmapRegistryPath?: string;
+}): RoadmapOpenResult;
+export declare function createStudioRoadmap(request: RoadmapOpenRequest, state: StudioServerState, options?: {
+    persist?: boolean;
+    roadmapRegistryPath?: string;
+}): RoadmapOpenResult;
+export declare function inspectStudioPort(request: RoadmapPortRequest): RoadmapPortInspectResult;
+export declare function applyStudioPort(request: RoadmapPortRequest, state: StudioServerState, options?: {
+    roadmapRegistryPath?: string;
+}): RoadmapPortApplyResult;
+export declare function loadStudioRoadmap(roadmapId: string, state: StudioServerState, options?: {
+    persist?: boolean;
+    roadmapRegistryPath?: string;
+}): RoadmapOpenResult;
+export declare function resolveRoadmapRepositoryPath(roadmapId: string, options?: {
+    roadmapRegistryPath?: string;
+}): string;
+export declare function filesystemBrowseRoots(cwd?: string): string[];
+export declare function filesystemBrowseRootEntries(cwd?: string): FilesystemBrowseRoot[];
+export declare function browseFilesystem(path: string | undefined, options?: {
+    cwd?: string;
+    rootId?: string;
+}): FilesystemBrowseResult;
+export declare function tryBrowseFilesystem(path: string | undefined, options?: {
+    cwd?: string;
+    rootId?: string;
+}): Result<FilesystemBrowseResult, FilesystemBrowseError>;
+export declare function createFilesystemBrowseGrant(request: FilesystemGrantRequest, state: StudioServerState, options?: {
+    cwd?: string;
+}): FilesystemGrantResult;
+export declare function tryCreateFilesystemBrowseGrant(request: FilesystemGrantRequest, state: StudioServerState, options?: {
+    cwd?: string;
+}): Result<FilesystemGrantResult, FilesystemBrowseError>;
+export declare function createRouteWorktree(cwd: string, routeId: string, createdAt?: string, requestedBaseRef?: string, requestedWorktreeRoot?: string): WorktreeRef;
+export declare function createExecuteWorktree(cwd: string, executeId: string, createdAt?: string, requestedBaseRef?: string, requestedWorktreeRoot?: string): WorktreeRef;
+export declare function readMoveDiff(board: BoardProjection, moveId: string, cwd?: string): MoveDiff;
+export declare function readMoveFileTree(board: BoardProjection, moveId: string, cwd?: string, path?: string): MoveFileTree;
+export declare function tryReadMoveFileTree(board: BoardProjection, moveId: string, cwd?: string, path?: string): Result<MoveFileTree, MoveFileReadError>;
+export declare function readMoveFileBlob(board: BoardProjection, moveId: string, cwd?: string, path?: string): MoveFileBlob;
+export declare function tryReadMoveFileBlob(board: BoardProjection, moveId: string, cwd?: string, path?: string): Result<MoveFileBlob, MoveFileReadError>;
+export declare function selectStudioRepository(cwd: string, state: StudioServerState, options?: {
+    persist?: boolean;
+    forceRoot?: boolean;
+}): RepositorySelectionResult;
+export declare function ensureStudioRepository(cwd: string, options?: {
+    forceRoot?: boolean;
+}): string;
+export declare function executeStudioCommand(command: Command, state: StudioServerState, options?: {
+    cwd?: string;
+    persist?: boolean;
+}): Promise<StudioCommandResult>;
+export declare function executeStudioCommands(commands: Command[], state: StudioServerState, options?: {
+    cwd?: string;
+    persist?: boolean;
+}): Promise<StudioCommandResult>;
+export declare function startStudioRun(request: StudioRunStartRequest, state: StudioServerState, options?: {
+    cwd?: string;
+    persist?: boolean;
+    runner?: Runner;
+    apmSkillRegistryClient?: ApmSkillRegistryClient;
+    routeWorktreeRoot?: string;
+    roadmapId?: string;
+}): Promise<StudioRunResult>;
+export declare function pauseStudioRun(request: StudioRunActionRequest, state: StudioServerState, options?: {
+    cwd?: string;
+    persist?: boolean;
+    runner?: Runner;
+}): Promise<StudioRunResult>;
+export declare function resumeStudioRun(request: StudioRunActionRequest, state: StudioServerState, options?: {
+    cwd?: string;
+    persist?: boolean;
+    runner?: Runner;
+    apmSkillRegistryClient?: ApmSkillRegistryClient;
+}): Promise<StudioRunResult>;
+export declare function stopStudioRun(request: StudioRunActionRequest, state: StudioServerState, options?: {
+    cwd?: string;
+    persist?: boolean;
+    runner?: Runner;
+}): Promise<StudioRunResult>;
+export declare function completeStudioMove(request: StudioMoveCompletionRequest, state: StudioServerState, options?: {
+    cwd?: string;
+    persist?: boolean;
+}): Promise<StudioMoveCompletionResult>;
+export declare function completeStudioMoveFromExecuteCompletion(completion: StudioExecuteCompletionFacts, state: StudioServerState, options: {
+    cwd?: string;
+    persist?: boolean;
+    runId: string;
+    runner?: Runner;
+}): Promise<StudioMoveCompletionResult | undefined>;
+export declare function recordStudioAccidentFromExecute(reason: string, evidence: string[], state: StudioServerState, options: {
+    cwd?: string;
+    persist?: boolean;
+    runId: string;
+    summary?: string;
+    risks?: string[];
+}): Promise<StudioMoveCompletionResult>;
+export declare function decideStudioLine(decision: "accept" | "reject", request: StudioLineDecisionRequest, state: StudioServerState, options?: {
+    cwd?: string;
+    persist?: boolean;
+}): Promise<StudioCommandResult>;
+export type MemberCodexEnvironmentPhase = "team" | "member" | "move-finalizer";
+export type MemberCodexEnvironmentPreparationOptions = {
+    phase?: MemberCodexEnvironmentPhase;
+    executorId?: string;
+    apmSkillRegistryClient?: ApmSkillRegistryClient;
+    skillMetaInstaller?: SkillMetaInstaller;
+    env?: Record<string, string | undefined>;
+    home?: string;
+};
+export declare function prepareMemberCodexEnvironmentForExecute(cwd: string, harness?: HarnessSnapshot, options?: MemberCodexEnvironmentPreparationOptions): Promise<void>;
+export declare function materializeCodexSkillsForExecute(cwd: string, harness?: HarnessSnapshot, options?: {
+    apmSkillRegistryClient?: ApmSkillRegistryClient;
+    skillMetaInstaller?: SkillMetaInstaller;
+}): Promise<void>;
+export declare function createNpxSkillsAddInstaller(command?: string): SkillMetaInstaller;
+export declare function listCodexSkills(env?: Record<string, string | undefined>, home?: string): StudioSkillSummary[];
+export declare function listCodexPlugins(env?: Record<string, string | undefined>, home?: string): string[];
+export {};