feat(docker-git): persist terminals and expose container tasks

- add API, CLI, and web task views for SSH/agent/container processes

- persist browser terminal tabs and replay terminal output after reconnect

- align project search and launch-time ordering across CLI and web

Author: skulidropek

packages/api/src/api/contracts.ts

@@ -10,6 +10,7 @@ export type ProjectSummary = {
   readonly displayName: string
   readonly repoUrl: string
   readonly repoRef: string
+  readonly containerName?: string | undefined
   readonly status: ProjectStatus
   readonly statusLabel: string
   readonly sshSessions: number
@@ -367,6 +368,31 @@ export type TerminalSession = {
   readonly signal?: number | undefined
 }
 
+export type ContainerTaskKind = "ssh" | "web-terminal" | "agent" | "background" | "system"
+
+export type ContainerTask = {
+  readonly pid: number
+  readonly ppid: number
+  readonly user: string
+  readonly tty: string
+  readonly etime: string
+  readonly etimes: number
+  readonly command: string
+  readonly kind: ContainerTaskKind
+  readonly managedId?: string | undefined
+  readonly logAvailable: boolean
+}
+
+export type ContainerTaskSnapshot = {
+  readonly projectId: string
+  readonly containerName: string
+  readonly generatedAt: string
+  readonly sshConnections: number
+  readonly tasks: ReadonlyArray<ContainerTask>
+  readonly terminalSessions: ReadonlyArray<TerminalSession>
+  readonly agents: ReadonlyArray<AgentSession>
+}
+
 export type ForgeFedTicket = {
   readonly id: string
   readonly attributedTo: string

packages/api/src/http.ts

@@ -48,6 +48,7 @@ import { streamGithubAuthLogin } from "./services/auth-github-login-stream.js"
 import { createAuthTerminalSession, deleteAuthTerminalSession } from "./services/auth-terminal-sessions.js"
 import { streamCodexAuthLogin } from "./services/auth-codex-login-stream.js"
 import { getAgent, getAgentAttachInfo, listAgents, readAgentLogs, startAgent, stopAgent } from "./services/agents.js"
+import { readContainerTaskLogs, readContainerTaskSnapshot, stopContainerTask } from "./services/container-tasks.js"
 import { latestProjectCursor, listProjectEventsSince } from "./services/events.js"
 import {
   createFollowSubscription,
@@ -135,6 +136,11 @@ const TerminalSessionParamsSchema = Schema.Struct({
   sessionId: Schema.String
 })
 
+const ContainerTaskParamsSchema = Schema.Struct({
+  projectId: Schema.String,
+  pid: Schema.String
+})
+
 const AuthTerminalSessionParamsSchema = Schema.Struct({
   sessionId: Schema.String
 })
@@ -213,6 +219,18 @@ const parsePortParam = (value: string): Effect.Effect<number, ApiBadRequestError
     : Effect.fail(new ApiBadRequestError({ message: `Invalid port: ${value}` }))
 }
 
+const parsePidParam = (value: string): Effect.Effect<number, ApiBadRequestError> => {
+  const parsed = Number.parseInt(value, 10)
+  return String(parsed) === value && parsed > 0
+    ? Effect.succeed(parsed)
+    : Effect.fail(new ApiBadRequestError({ message: `Invalid pid: ${value}` }))
+}
+
+const parseQueryBoolean = (url: string, key: string): boolean => {
+  const value = new URL(url, "http://localhost").searchParams.get(key)
+  return value === "1" || value === "true" || value === "yes"
+}
+
 const hostWithoutPort = (host: string): string => {
   if (host.startsWith("[")) {
     const end = host.indexOf("]")
@@ -289,6 +307,7 @@ const projectPortForwardParams = HttpRouter.schemaParams(ProjectPortForwardParam
 const projectDatabaseProfileParams = HttpRouter.schemaParams(ProjectDatabaseProfileParamsSchema)
 const agentParams = HttpRouter.schemaParams(AgentParamsSchema)
 const terminalSessionParams = HttpRouter.schemaParams(TerminalSessionParamsSchema)
+const containerTaskParams = HttpRouter.schemaParams(ContainerTaskParamsSchema)
 const authTerminalSessionParams = HttpRouter.schemaParams(AuthTerminalSessionParamsSchema)
 
 const readCreateProjectRequest = () => HttpServerRequest.schemaBodyJson(CreateProjectRequestSchema)
@@ -914,6 +933,37 @@ export const makeRouter = () => {
         Effect.catchAll(errorResponse)
       )
     ),
+    HttpRouter.get(
+      "/projects/:projectId/tasks",
+      Effect.gen(function*(_) {
+        const { projectId } = yield* _(projectParams)
+        const request = yield* _(HttpServerRequest.HttpServerRequest)
+        const snapshot = yield* _(readContainerTaskSnapshot(projectId, parseQueryBoolean(request.url, "includeDefault")))
+        return yield* _(jsonResponse({ snapshot }, 200))
+      }).pipe(Effect.catchAll(errorResponse))
+    ),
+    HttpRouter.post(
+      "/projects/:projectId/tasks/:pid/stop",
+      containerTaskParams.pipe(
+        Effect.flatMap(({ projectId, pid }) =>
+          parsePidParam(pid).pipe(
+            Effect.flatMap((taskPid) => stopContainerTask(projectId, taskPid))
+          )
+        ),
+        Effect.flatMap(() => jsonResponse({ ok: true }, 200)),
+        Effect.catchAll(errorResponse)
+      )
+    ),
+    HttpRouter.get(
+      "/projects/:projectId/tasks/:pid/logs",
+      Effect.gen(function*(_) {
+        const { projectId, pid } = yield* _(containerTaskParams)
+        const taskPid = yield* _(parsePidParam(pid))
+        const request = yield* _(HttpServerRequest.HttpServerRequest)
+        const output = yield* _(readContainerTaskLogs(projectId, taskPid, parseQueryInt(request.url, "lines", 200)))
+        return yield* _(jsonResponse({ output }, 200))
+      }).pipe(Effect.catchAll(errorResponse))
+    ),
     HttpRouter.post(
       "/projects/:projectId/recreate",
       projectParams.pipe(

packages/api/src/services/auth-terminal-sessions.ts

@@ -10,6 +10,12 @@ import { WebSocket, WebSocketServer, type RawData } from "ws"
 import type { AuthTerminalFlow, AuthTerminalSessionRequest, TerminalSession, TerminalSessionStatus } from "../api/contracts.js"
 import { ApiConflictError, ApiNotFoundError, describeUnknown } from "../api/errors.js"
 import { spawnPtyBridge, type PtyBridge } from "./pty-bridge.js"
+import {
+  appendTerminalOutput,
+  emptyTerminalOutputBuffer,
+  renderTerminalOutputBuffer,
+  type TerminalOutputBuffer
+} from "./terminal-output-buffer.js"
 import { attachWebSocketHeartbeat } from "./websocket-heartbeat.js"
 
 type TerminalClientMessage =
@@ -28,13 +34,13 @@ type AuthTerminalRecord = {
   args: ReadonlyArray<string>
   cwd: string
   detachTimeout: ReturnType<typeof setTimeout> | null
+  outputBuffer: TerminalOutputBuffer
   pty: PtyBridge | null
   session: TerminalSession
   socket: WebSocket | null
 }
 
 const attachTimeoutMs = 30_000
-const reconnectGraceMs = 60_000
 const authTerminalProjectId = "__controller__"
 const authTerminalWsPathPattern = /^(?:\/api)?\/auth\/terminal-sessions\/([^/]+)\/ws$/u
 const authRunnerPath = fileURLToPath(new URL("../auth-terminal-runner.js", import.meta.url))
@@ -91,6 +97,18 @@ const sendServerMessage = (socket: WebSocket | null, message: TerminalServerMess
   socket.send(encodeServerMessage(message))
 }
 
+const sendTerminalOutput = (record: AuthTerminalRecord, data: string): void => {
+  record.outputBuffer = appendTerminalOutput(record.outputBuffer, data)
+  sendServerMessage(record.socket, { type: "output", data })
+}
+
+const replayTerminalOutput = (record: AuthTerminalRecord, socket: WebSocket): void => {
+  const data = renderTerminalOutputBuffer(record.outputBuffer)
+  if (data.length > 0) {
+    sendServerMessage(socket, { type: "output", data })
+  }
+}
+
 const clearAttachTimeout = (record: AuthTerminalRecord): void => {
   if (record.attachTimeout !== null) {
     clearTimeout(record.attachTimeout)
@@ -201,7 +219,7 @@ const startTerminalPty = (record: AuthTerminalRecord, cols: number, rows: number
     status: "attached"
   })
   pty.onData((data) => {
-    sendServerMessage(record.socket, { type: "output", data })
+    sendTerminalOutput(record, data)
   })
   pty.onExit(({ exitCode, signal }) => {
     finalizeRecord(
@@ -234,6 +252,7 @@ const registerRecord = (request: AuthTerminalSessionRequest): TerminalSession =>
     attachTimeout: null,
     cwd: process.cwd(),
     detachTimeout: null,
+    outputBuffer: emptyTerminalOutputBuffer,
     pty: null,
     session,
     socket: null
@@ -243,14 +262,6 @@ const registerRecord = (request: AuthTerminalSessionRequest): TerminalSession =>
   return session
 }
 
-const createDetachTimeout = (sessionId: string): ReturnType<typeof setTimeout> =>
-  setTimeout(() => {
-    const record = records.get(sessionId)
-    if (record !== undefined && record.socket === null) {
-      cleanupRecord(record)
-    }
-  }, reconnectGraceMs)
-
 const detachSocketFromRecord = (
   record: AuthTerminalRecord,
   socket: WebSocket
@@ -261,7 +272,6 @@ const detachSocketFromRecord = (
   }
   current.socket = null
   clearDetachTimeout(current)
-  current.detachTimeout = createDetachTimeout(current.session.id)
 }
 
 const handleSocketMessage = (record: AuthTerminalRecord, raw: RawData): void => {
@@ -296,6 +306,7 @@ const attachSocketToRecord = (
   attachWebSocketHeartbeat(socket)
   startTerminalPty(record, cols, rows)
   sendServerMessage(socket, { type: "ready", session: record.session })
+  replayTerminalOutput(record, socket)
   socket.on("message", (raw: RawData) => {
     handleSocketMessage(record, raw)
   })

packages/api/src/services/container-tasks-core.ts

@@ -0,0 +1,113 @@
+import type { AgentSession, ContainerTask, ContainerTaskKind } from "../api/contracts.js"
+
+export type RawContainerProcess = {
+  readonly pid: number
+  readonly ppid: number
+  readonly user: string
+  readonly tty: string
+  readonly etime: string
+  readonly etimes: number
+  readonly command: string
+  readonly baseline: boolean
+  readonly logAvailable: boolean
+}
+
+export type ManagedAgentPid = {
+  readonly agentId: string
+  readonly pid: number
+}
+
+const interactiveAgentPattern = /\b(codex|claude|opencode|gemini)\b/u
+
+const hasInteractiveTty = (process: RawContainerProcess): boolean =>
+  process.tty !== "?" && process.tty.trim().length > 0
+
+const commandSuggestsSsh = (command: string): boolean => command.startsWith("sshd:") || command.includes(" sshd:")
+
+const commandSuggestsAgent = (command: string): boolean =>
+  interactiveAgentPattern.test(command) || command.includes("docker-git-agent-")
+
+const resolveAncestorManagedId = (
+  process: RawContainerProcess,
+  pidToProcess: ReadonlyMap<number, RawContainerProcess>,
+  managedPidToAgentId: ReadonlyMap<number, string>
+): string | undefined => {
+  let cursor: RawContainerProcess | undefined = process
+  const seen = new Set<number>()
+  while (cursor !== undefined && !seen.has(cursor.pid)) {
+    seen.add(cursor.pid)
+    const managedId = managedPidToAgentId.get(cursor.pid)
+    if (managedId !== undefined) {
+      return managedId
+    }
+    cursor = pidToProcess.get(cursor.ppid)
+  }
+  return undefined
+}
+
+const classifyProcess = (
+  process: RawContainerProcess,
+  managedId: string | undefined
+): ContainerTaskKind => {
+  if (managedId !== undefined || commandSuggestsAgent(process.command)) {
+    return "agent"
+  }
+  if (process.baseline) {
+    return "system"
+  }
+  if (commandSuggestsSsh(process.command) || hasInteractiveTty(process)) {
+    return "ssh"
+  }
+  return "background"
+}
+
+const compareTasks = (left: ContainerTask, right: ContainerTask): number => {
+  const byKind = left.kind.localeCompare(right.kind)
+  if (byKind !== 0) {
+    return byKind
+  }
+  const byRuntime = right.etimes - left.etimes
+  return byRuntime !== 0 ? byRuntime : left.pid - right.pid
+}
+
+// CHANGE: classify raw container processes into stable task-manager rows.
+// WHY: API, CLI and WEB must share one total model for terminal/task visibility.
+// QUOTE(ТЗ): "можем мы сделать возможность видеть все запщуенные терминалы в контейнере?"
+// REF: user-message-2026-04-22-container-task-manager
+// SOURCE: n/a
+// FORMAT THEOREM: forall p in Processes: classify(p) in ContainerTaskKind
+// PURITY: CORE
+// EFFECT: none
+// INVARIANT: includeDefault=false excludes only baseline system processes
+// COMPLEXITY: O(n * h) where h is maximum process ancestry depth
+export const buildContainerTasks = (
+  processes: ReadonlyArray<RawContainerProcess>,
+  managedAgentPids: ReadonlyArray<ManagedAgentPid>,
+  includeDefault: boolean
+): ReadonlyArray<ContainerTask> => {
+  const pidToProcess = new Map(processes.map((process) => [process.pid, process]))
+  const managedPidToAgentId = new Map(managedAgentPids.map((entry) => [entry.pid, entry.agentId]))
+
+  return processes
+    .map((process) => {
+      const managedId = resolveAncestorManagedId(process, pidToProcess, managedPidToAgentId)
+      const kind = classifyProcess(process, managedId)
+      return {
+        pid: process.pid,
+        ppid: process.ppid,
+        user: process.user,
+        tty: process.tty,
+        etime: process.etime,
+        etimes: process.etimes,
+        command: process.command,
+        kind,
+        ...(managedId === undefined ? {} : { managedId }),
+        logAvailable: process.logAvailable
+      } satisfies ContainerTask
+    })
+    .filter((task) => includeDefault || task.kind !== "system")
+    .sort(compareTasks)
+}
+
+export const activeAgents = (agents: ReadonlyArray<AgentSession>): ReadonlyArray<AgentSession> =>
+  agents.filter((agent) => !["stopped", "exited", "failed"].includes(agent.status))