┌───────────────────────┐
   Browser  ───▶ │                       │ ───▶  HttpTransport ───▶ Express (HTTP + SSE)
                 │   Transport interface │
   Obsidian ───▶ │                       │ ───▶  DirectTransport ─▶ in-process services
                 └───────────────────────┘

interface Transport {
  // Sessions
  listSessions(cwd?: string): Promise<SessionListResponse>;
  getSession(id: string, cwd?: string): Promise<Session>;
  updateSession(
    id: string,
    opts: UpdateSessionRequest,
    cwd?: string
  ): Promise<SessionUpdateResponse>;
  // SessionUpdateResponse is the session, plus `permissionModePendingUntilNextTurn`
  // when a STRICTER permission mode was saved but could not reach the reply that
  // is already running — that reply keeps the mode it started under. It also
  // carries `runtimeUnbound` while no runtime is recorded for the session: the
  // `runtime` it reports is a guess then, not an owner. Only an interactive
  // session's first turn records one, so this is not just a brand-new session.
  getMessages(sessionId: string, cwd?: string): Promise<{ messages: HistoryMessage[] }>;
  getSessionSnapshot(sessionId: string, cwd?: string): Promise<SessionSnapshot>;
  subscribeSession(sessionId, sinceCursor?, cwd?, signal?): AsyncIterable<SessionEvent>;
  subscribeSessionList(): AsyncIterable<SessionListEvent>;
  postMessage(sessionId, content, cwd?, options?): Promise<{ sessionId: string }>;
  // options: { clientMessageId?: string; context?: ClientContext; runtime?: string }
  // A brand-new session is created implicitly on its first postMessage() call
  // (pass a client-generated UUID as sessionId): there is no separate createSession.

  // Tool interaction
  approveTool(
    sessionId: string,
    toolCallId: string,
    alwaysAllow?: boolean
  ): Promise<{ ok: boolean }>;
  denyTool(sessionId: string, toolCallId: string, reason?: string): Promise<{ ok: boolean }>;
  // `reason` is optional free text (max 1000 chars) handed to the agent with the
  // refusal, so it can adjust instead of retrying the same call.
  submitAnswers(sessionId, toolCallId, answers): Promise<{ ok: boolean }>;
  // Both stop verbs answer an InterruptReceipt: `{ outcome, reason?, runtime }`,
  // where `outcome` is one of `acked` (the agent confirmed the stop), `closed`
  // (DorkOS ended it after the agent didn't answer), `not-running` (there was
  // nothing to stop), `unconfirmed` (the request went out and the runtime cannot
  // say whether it landed) or `failed` (the stop could not be delivered).
  // Say "stopped" only about `acked` and `closed`.
  stopTask(
    sessionId: string,
    taskId: string
  ): Promise<{ receipt: InterruptReceipt; taskId: string }>;
  interruptSession(
    sessionId: string
  ): Promise<{ receipt: InterruptReceipt; cancelledQueued: QueuedMessage[] }>;
  getTasks(sessionId: string, cwd?: string): Promise<{ tasks: TaskItem[] }>;

  // Filesystem & git
  browseDirectory(dirPath?, showHidden?): Promise<BrowseDirectoryResponse>;
  getDefaultCwd(): Promise<{ path: string }>;
  listFiles(cwd: string): Promise<FileListResponse>;
  getGitStatus(cwd?: string): Promise<GitStatusResponse | GitStatusError>;

  // Commands & config
  getCommands(refresh?: boolean, cwd?: string, opts?): Promise<CommandRegistry>;
  health(): Promise<HealthResponse>;
  getConfig(): Promise<ServerConfig>;
  updateConfig(patch: Record<string, unknown>): Promise<void>;

  // Runtime
  getModels(opts?): Promise<ModelOption[]>;
  getCapabilities(): Promise<{
    capabilities: Record<string, RuntimeCapabilities>;
    defaultRuntime: string;
  }>;

  // File uploads
  uploadFiles(files: UploadFile[], cwd: string, onProgress?): Promise<UploadResult[]>;

  // Tunnel
  startTunnel(): Promise<{ url: string }>;
  stopTunnel(): Promise<void>;

  // Directory operations
  createDirectory(parentPath: string, folderName: string): Promise<{ path: string }>;

  // Templates
  getTemplates(): Promise<TemplateEntry[]>;

  // Default agent
  setDefaultAgent(agentName: string): Promise<void>;

  // Admin
  resetAllData(confirm: string): Promise<{ message: string }>;
  restartServer(): Promise<{ message: string }>;
}