@jmoyers/harness 0.1.10 → 0.1.20

package/src/control-plane/stream-server.ts

@@ -11,9 +11,10 @@ import { randomUUID } from 'node:crypto';
 import { tmpdir } from 'node:os';
 import { delimiter, isAbsolute, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { LinearClient } from '@linear/sdk';
 import { type CodexLiveEvent, type LiveSessionNotifyMode } from '../codex/live-session.ts';
 import type { PtyExit } from '../pty/pty_host.ts';
-import type { TerminalBufferTail, TerminalSnapshotFrame } from '../terminal/snapshot-oracle.ts';
+import type { TerminalSnapshotFrame } from '../terminal/snapshot-oracle.ts';
 import {
   encodeStreamEnvelope,
   type StreamObservedEvent,
@@ -85,6 +86,11 @@ import {
 import { closeOwnedStateStore as closeOwnedStreamServerStateStore } from './stream-server-state-store.ts';
 import { SessionStatusEngine } from './status/session-status-engine.ts';
 import { SessionPromptEngine } from './prompt/session-prompt-engine.ts';
+import {
+  StorageLifecycleCore,
+  type StorageLifecyclePolicy,
+  type StorageLifecycleTelemetryStore,
+} from '../storage/storage-lifecycle-core.ts';
 import {
   appendThreadTitlePromptHistory,
   createAnthropicThreadTitleNamer,
@@ -98,32 +104,14 @@ import {
   eventIncludesTaskId as filterEventIncludesTaskId,
   matchesObservedFilter as matchesStreamObservedFilter,
 } from './stream-server-observed-filter.ts';
-import type { HarnessLifecycleHooksConfig } from '../config/config-core.ts';
+import {
+  DEFAULT_HARNESS_CONFIG,
+  loadHarnessConfig,
+  type HarnessLifecycleHooksConfig,
+} from '../config/config-core.ts';
 import { LifecycleHooksRuntime } from './lifecycle-hooks.ts';
 import { readGitDirectorySnapshot } from '../mux/live-mux/git-snapshot.ts';
-
-interface SessionDataEvent {
-  cursor: number;
-  chunk: Buffer;
-}
-
-interface SessionAttachHandlers {
-  onData: (event: SessionDataEvent) => void;
-  onExit: (exit: PtyExit) => void;
-}
-
-interface LiveSessionLike {
-  attach(handlers: SessionAttachHandlers, sinceCursor?: number): string;
-  detach(attachmentId: string): void;
-  latestCursorValue(): number;
-  processId(): number | null;
-  write(data: string | Uint8Array): void;
-  resize(cols: number, rows: number): void;
-  snapshot(): TerminalSnapshotFrame;
-  bufferTail?(tailLines?: number): TerminalBufferTail;
-  close(): void;
-  onEvent(listener: (event: CodexLiveEvent) => void): () => void;
-}
+import type { LiveSessionLike, StartSessionRuntimeInput } from './stream-session-runtime-types.ts';
 
 export interface StartControlPlaneSessionInput {
   command?: string;
@@ -140,21 +128,6 @@ export interface StartControlPlaneSessionInput {
   terminalBackgroundHex?: string;
 }
 
-interface StartSessionRuntimeInput {
-  readonly sessionId: string;
-  readonly args: readonly string[];
-  readonly initialCols: number;
-  readonly initialRows: number;
-  readonly env?: Record<string, string>;
-  readonly cwd?: string;
-  readonly tenantId?: string;
-  readonly userId?: string;
-  readonly workspaceId?: string;
-  readonly worktreeId?: string;
-  readonly terminalForegroundHex?: string;
-  readonly terminalBackgroundHex?: string;
-}
-
 type StartControlPlaneSession = (input: StartControlPlaneSessionInput) => LiveSessionLike;
 
 interface CodexTelemetryServerConfig {
@@ -201,6 +174,11 @@ interface CritiqueConfig {
   readonly launch: CritiqueLaunchConfig;
 }
 
+interface ClaudeLaunchConfig {
+  readonly defaultMode: 'yolo' | 'standard';
+  readonly directoryModes: Readonly<Record<string, 'yolo' | 'standard'>>;
+}
+
 interface CursorLaunchConfig {
   readonly defaultMode: 'yolo' | 'standard';
   readonly directoryModes: Readonly<Record<string, 'yolo' | 'standard'>>;
@@ -230,6 +208,13 @@ interface GitHubIntegrationConfig {
   readonly viewerLogin: string | null;
 }
 
+interface LinearIntegrationConfig {
+  readonly enabled: boolean;
+  readonly apiBaseUrl: string;
+  readonly tokenEnvVar: string;
+  readonly token: string | null;
+}
+
 interface ThreadTitleConfig {
   readonly enabled: boolean;
   readonly apiKey: string | null;
@@ -248,6 +233,7 @@ interface GitHubRemotePullRequest {
   readonly baseBranch: string;
   readonly state: 'open' | 'closed';
   readonly isDraft: boolean;
+  readonly mergedAt: string | null;
   readonly updatedAt: string;
   readonly createdAt: string;
   readonly closedAt: string | null;
@@ -264,6 +250,48 @@ interface GitHubRemotePrJob {
   readonly completedAt: string | null;
 }
 
+interface GitHubRemotePrReviewComment {
+  readonly commentId: string;
+  readonly authorLogin: string | null;
+  readonly body: string;
+  readonly url: string | null;
+  readonly createdAt: string;
+  readonly updatedAt: string;
+}
+
+interface GitHubRemotePrReviewThread {
+  readonly threadId: string;
+  readonly isResolved: boolean;
+  readonly isOutdated: boolean;
+  readonly resolvedByLogin: string | null;
+  readonly comments: readonly GitHubRemotePrReviewComment[];
+}
+
+interface GitHubProjectReviewCachePullRequest {
+  readonly number: number;
+  readonly title: string;
+  readonly url: string;
+  readonly authorLogin: string | null;
+  readonly headBranch: string;
+  readonly headSha: string;
+  readonly baseBranch: string;
+  readonly state: 'draft' | 'open' | 'merged' | 'closed';
+  readonly isDraft: boolean;
+  readonly mergedAt: string | null;
+  readonly closedAt: string | null;
+  readonly updatedAt: string;
+  readonly createdAt: string;
+}
+
+interface GitHubProjectReviewCacheEntry {
+  readonly repositoryId: string;
+  readonly branchName: string;
+  readonly pr: GitHubProjectReviewCachePullRequest | null;
+  readonly openThreads: readonly GitHubRemotePrReviewThread[];
+  readonly resolvedThreads: readonly GitHubRemotePrReviewThread[];
+  readonly fetchedAtMs: number;
+}
+
 type GitDirectorySnapshot = Awaited<ReturnType<typeof readGitDirectorySnapshot>>;
 type GitDirectorySnapshotReader = (cwd: string) => Promise<GitDirectorySnapshot>;
 type GitHubTokenResolver = () => Promise<string | null>;
@@ -290,12 +318,14 @@ interface StartControlPlaneStreamServerOptions {
   codexTelemetry?: CodexTelemetryServerConfig;
   codexHistory?: CodexHistoryIngestConfig;
   codexLaunch?: CodexLaunchConfig;
+  claudeLaunch?: ClaudeLaunchConfig;
   critique?: CritiqueConfig;
   agentInstall?: Partial<Record<AgentToolType, AgentInstallCommandConfig>>;
   cursorLaunch?: CursorLaunchConfig;
   cursorHooks?: Partial<CursorHooksConfig>;
   gitStatus?: GitStatusMonitorConfig;
   github?: Partial<GitHubIntegrationConfig>;
+  linear?: Partial<LinearIntegrationConfig>;
   githubTokenResolver?: GitHubTokenResolver;
   githubExecFile?: GitHubExecFile;
   githubFetch?: typeof fetch;
@@ -303,6 +333,20 @@ interface StartControlPlaneStreamServerOptions {
   lifecycleHooks?: HarnessLifecycleHooksConfig;
   threadTitle?: Partial<ThreadTitleConfig>;
   threadTitleNamer?: ThreadTitleNamer;
+  storageLifecyclePolicy?: Partial<StorageLifecyclePolicy>;
+  storageLifecyclePolicyReload?: {
+    cwd: string;
+    filePath?: string;
+    env?: NodeJS.ProcessEnv;
+    pollMs?: number;
+  };
+}
+
+interface StorageLifecyclePolicyReloadConfig {
+  readonly cwd: string;
+  readonly filePath?: string;
+  readonly env?: NodeJS.ProcessEnv;
+  readonly pollMs: number;
 }
 
 interface ConnectionState {
@@ -427,6 +471,52 @@ interface OtlpEndpointTarget {
   readonly token: string;
 }
 
+function asTelemetryLifecycleStore(value: unknown): StorageLifecycleTelemetryStore | null {
+  if (typeof value !== 'object' || value === null) {
+    return null;
+  }
+  const candidate = value as Record<string, unknown>;
+  const prune = candidate['pruneTelemetryOlderThan'];
+  const checkpoint = candidate['checkpointWal'];
+  const compact = candidate['compactFreelistPages'];
+  const copyForward = candidate['runOnlineCopyForwardCompactionStep'];
+  if (
+    typeof prune !== 'function' ||
+    typeof checkpoint !== 'function' ||
+    typeof compact !== 'function'
+  ) {
+    return null;
+  }
+  return {
+    pruneTelemetryOlderThan: (cutoffIngestedAt, limit) =>
+      (prune as (cutoffIngestedAt: string, limit: number) => number).call(
+        value,
+        cutoffIngestedAt,
+        limit,
+      ),
+    checkpointWal: (mode) => {
+      (checkpoint as (mode?: 'PASSIVE' | 'TRUNCATE') => void).call(value, mode);
+    },
+    compactFreelistPages: (maxPages) => {
+      (compact as (maxPages: number) => void).call(value, maxPages);
+    },
+    ...(typeof copyForward !== 'function'
+      ? {}
+      : {
+          runOnlineCopyForwardCompactionStep: (batchSize: number, finalizeTailRows: number) =>
+            (
+              copyForward as (
+                batchSize: number,
+                finalizeTailRows: number,
+              ) => {
+                readonly state: 'idle' | 'copying' | 'finalized';
+                readonly copiedRows: number;
+              }
+            ).call(value, batchSize, finalizeTailRows),
+        }),
+  };
+}
+
 function isTelemetryRequestAbortError(error: unknown): boolean {
   const code = (error as NodeJS.ErrnoException).code;
   if (code === 'ECONNRESET' || code === 'ERR_STREAM_PREMATURE_CLOSE') {
@@ -441,6 +531,11 @@ const DEFAULT_SESSION_EXIT_TOMBSTONE_TTL_MS = 5 * 60 * 1000;
 const DEFAULT_MAX_STREAM_JOURNAL_ENTRIES = 10000;
 const DEFAULT_GIT_STATUS_POLL_MS = 1200;
 const DEFAULT_GITHUB_POLL_MS = 15_000;
+const DEFAULT_STORAGE_LIFECYCLE_POLICY_RELOAD_POLL_MS = 5000;
+const DEFAULT_GITHUB_PROJECT_REVIEW_PREWARM_INTERVAL_MS = 5 * 60 * 1000;
+const DEFAULT_LINEAR_API_BASE_URL = 'https://api.linear.app/graphql';
+const GITHUB_OAUTH_ACCESS_TOKEN_ENV_VAR = 'HARNESS_GITHUB_OAUTH_ACCESS_TOKEN';
+const LINEAR_OAUTH_ACCESS_TOKEN_ENV_VAR = 'HARNESS_LINEAR_OAUTH_ACCESS_TOKEN';
 const HISTORY_POLL_JITTER_RATIO = 0.35;
 const SESSION_DIAGNOSTICS_BUCKET_MS = 10_000;
 const SESSION_DIAGNOSTICS_BUCKET_COUNT = 6;
@@ -597,6 +692,23 @@ function normalizeCodexHistoryConfig(
   };
 }
 
+function normalizeStorageLifecyclePolicyReloadConfig(
+  input: StartControlPlaneStreamServerOptions['storageLifecyclePolicyReload'],
+): StorageLifecyclePolicyReloadConfig | null {
+  if (input === undefined) {
+    return null;
+  }
+  return {
+    cwd: input.cwd,
+    ...(input.filePath === undefined ? {} : { filePath: input.filePath }),
+    ...(input.env === undefined ? {} : { env: input.env }),
+    pollMs: Math.max(
+      250,
+      Math.floor(input.pollMs ?? DEFAULT_STORAGE_LIFECYCLE_POLICY_RELOAD_POLL_MS),
+    ),
+  };
+}
+
 function normalizeCodexLaunchConfig(input: CodexLaunchConfig | undefined): CodexLaunchConfig {
   return {
     defaultMode: input?.defaultMode ?? 'standard',
@@ -666,6 +778,13 @@ function normalizeAgentInstallConfig(
   };
 }
 
+function normalizeClaudeLaunchConfig(input: ClaudeLaunchConfig | undefined): ClaudeLaunchConfig {
+  return {
+    defaultMode: input?.defaultMode ?? 'standard',
+    directoryModes: input?.directoryModes ?? {},
+  };
+}
+
 function normalizeCursorLaunchConfig(input: CursorLaunchConfig | undefined): CursorLaunchConfig {
   return {
     defaultMode: input?.defaultMode ?? 'standard',
@@ -729,10 +848,15 @@ function normalizeGitHubIntegrationConfig(
     typeof tokenEnvVarRaw === 'string' && tokenEnvVarRaw.trim().length > 0
       ? tokenEnvVarRaw.trim()
       : 'GITHUB_TOKEN';
-  const envToken = process.env[tokenEnvVar];
+  const manualEnvToken = process.env[tokenEnvVar];
+  const oauthEnvToken = process.env[GITHUB_OAUTH_ACCESS_TOKEN_ENV_VAR];
+  const envTokenRaw =
+    typeof manualEnvToken === 'string' && manualEnvToken.trim().length > 0
+      ? manualEnvToken
+      : oauthEnvToken;
   const tokenRaw =
     input?.token ??
-    (typeof envToken === 'string' && envToken.trim().length > 0 ? envToken.trim() : null);
+    (typeof envTokenRaw === 'string' && envTokenRaw.trim().length > 0 ? envTokenRaw.trim() : null);
   const branchStrategyRaw = input?.branchStrategy;
   const branchStrategy =
     branchStrategyRaw === 'current-only' ||
@@ -772,6 +896,36 @@ function normalizeGitHubIntegrationConfig(
   };
 }
 
+function normalizeLinearIntegrationConfig(
+  input: Partial<LinearIntegrationConfig> | undefined,
+): LinearIntegrationConfig {
+  const tokenEnvVarRaw = input?.tokenEnvVar;
+  const tokenEnvVar =
+    typeof tokenEnvVarRaw === 'string' && tokenEnvVarRaw.trim().length > 0
+      ? tokenEnvVarRaw.trim()
+      : 'LINEAR_API_KEY';
+  const manualEnvToken = process.env[tokenEnvVar];
+  const oauthEnvToken = process.env[LINEAR_OAUTH_ACCESS_TOKEN_ENV_VAR];
+  const envTokenRaw =
+    typeof manualEnvToken === 'string' && manualEnvToken.trim().length > 0
+      ? manualEnvToken
+      : oauthEnvToken;
+  const tokenRaw =
+    input?.token ??
+    (typeof envTokenRaw === 'string' && envTokenRaw.trim().length > 0 ? envTokenRaw.trim() : null);
+  const apiBaseUrlRaw = input?.apiBaseUrl;
+  const apiBaseUrl =
+    typeof apiBaseUrlRaw === 'string' && apiBaseUrlRaw.trim().length > 0
+      ? apiBaseUrlRaw.trim().replace(/\/+$/u, '')
+      : DEFAULT_LINEAR_API_BASE_URL;
+  return {
+    enabled: input?.enabled ?? false,
+    apiBaseUrl,
+    tokenEnvVar,
+    token: tokenRaw,
+  };
+}
+
 function normalizeThreadTitleConfig(
   input: Partial<ThreadTitleConfig> | undefined,
 ): ThreadTitleConfig {
@@ -965,6 +1119,7 @@ const streamServerInternals = {
   gitRepositorySnapshotEqual,
   commandExists,
   normalizeGitHubIntegrationConfig,
+  normalizeLinearIntegrationConfig,
   parseGitHubOwnerRepoFromRemote,
   resolveTrackedBranchName,
   summarizeGitHubCiRollup,
@@ -1092,12 +1247,14 @@ export class ControlPlaneStreamServer {
   private readonly codexTelemetry: CodexTelemetryServerConfig;
   private readonly codexHistory: CodexHistoryIngestConfig;
   private readonly codexLaunch: CodexLaunchConfig;
+  private readonly claudeLaunch: ClaudeLaunchConfig;
   private readonly critique: CritiqueConfig;
   private readonly agentInstall: AgentInstallConfig;
   private readonly cursorLaunch: CursorLaunchConfig;
   private readonly cursorHooks: CursorHooksConfig;
   private readonly gitStatusMonitor: GitStatusMonitorConfig;
   private readonly github: GitHubIntegrationConfig;
+  private readonly linear: LinearIntegrationConfig;
   private readonly githubTokenResolver: GitHubTokenResolver;
   private readonly githubExecFile: GitHubExecFile;
   private readonly githubFetch: typeof fetch;
@@ -1107,6 +1264,16 @@ export class ControlPlaneStreamServer {
       repo: string;
       headBranch: string;
     }): Promise<GitHubRemotePullRequest | null>;
+    findPullRequestForBranch(input: {
+      owner: string;
+      repo: string;
+      headBranch: string;
+    }): Promise<GitHubRemotePullRequest | null>;
+    listPullRequestReviewThreads(input: {
+      owner: string;
+      repo: string;
+      pullNumber: number;
+    }): Promise<readonly GitHubRemotePrReviewThread[]>;
     createPullRequest(input: {
       owner: string;
       repo: string;
@@ -1117,6 +1284,16 @@ export class ControlPlaneStreamServer {
       draft: boolean;
     }): Promise<GitHubRemotePullRequest>;
   };
+  private readonly linearApi: {
+    issueByIdentifier(input: { identifier: string }): Promise<{
+      identifier: string;
+      title: string;
+      description: string | null;
+      url: string | null;
+      stateName: string | null;
+      teamKey: string | null;
+    } | null>;
+  };
   private readonly readGitDirectorySnapshot: GitDirectorySnapshotReader;
   private readonly statusEngine = new SessionStatusEngine();
   private readonly promptEngine = new SessionPromptEngine();
@@ -1129,6 +1306,8 @@ export class ControlPlaneStreamServer {
   private telemetryAddress: AddressInfo | null = null;
   private readonly telemetryTokenToSessionId = new Map<string, string>();
   private readonly lifecycleHooks: LifecycleHooksRuntime;
+  private readonly storageLifecycle: StorageLifecycleCore;
+  private readonly storageLifecyclePolicyReload: StorageLifecyclePolicyReloadConfig | null;
   private historyPollTimer: NodeJS.Timeout | null = null;
   private historyPollInFlight = false;
   private historyIdleStreak = 0;
@@ -1142,9 +1321,18 @@ export class ControlPlaneStreamServer {
   private gitStatusPollInFlight = false;
   private githubPollInFlight = false;
   private githubPollPromise: Promise<void> | null = null;
+  private storageLifecycleTimer: NodeJS.Timeout | null = null;
+  private storageLifecyclePolicyReloadTimer: NodeJS.Timeout | null = null;
+  private storageLifecyclePolicyLastKnownGood = DEFAULT_HARNESS_CONFIG;
+  private storageLifecyclePolicyLastError: string | null = null;
   private readonly gitStatusRefreshInFlightDirectoryIds = new Set<string>();
   private readonly gitStatusByDirectoryId = new Map<string, DirectoryGitStatusCacheEntry>();
   private readonly gitStatusDirectoriesById = new Map<string, ControlPlaneDirectoryRecord>();
+  private readonly githubProjectReviewCacheByKey = new Map<string, GitHubProjectReviewCacheEntry>();
+  private readonly githubProjectReviewRefreshInFlightByKey = new Map<
+    string,
+    Promise<GitHubProjectReviewCacheEntry>
+  >();
   private readonly connections = new Map<string, ConnectionState>();
   private readonly sessions = new Map<string, SessionState>();
   private readonly launchCommandBySessionId = new Map<string, string>();
@@ -1173,25 +1361,40 @@ export class ControlPlaneStreamServer {
       this.stateStore = options.stateStore;
       this.ownsStateStore = false;
     } else {
-      this.stateStore = new SqliteControlPlaneStore(options.stateStorePath ?? ':memory:');
+      const busyTimeoutMs = options.storageLifecyclePolicy?.busyTimeoutMs;
+      this.stateStore = new SqliteControlPlaneStore(
+        options.stateStorePath ?? ':memory:',
+        busyTimeoutMs === undefined
+          ? undefined
+          : {
+              busyTimeoutMs,
+            },
+      );
       this.ownsStateStore = true;
     }
     this.codexTelemetry = normalizeCodexTelemetryConfig(options.codexTelemetry);
     this.codexHistory = normalizeCodexHistoryConfig(options.codexHistory);
     this.codexLaunch = normalizeCodexLaunchConfig(options.codexLaunch);
+    this.claudeLaunch = normalizeClaudeLaunchConfig(options.claudeLaunch);
     this.critique = normalizeCritiqueConfig(options.critique);
     this.agentInstall = normalizeAgentInstallConfig(options.agentInstall);
     this.cursorLaunch = normalizeCursorLaunchConfig(options.cursorLaunch);
     this.cursorHooks = normalizeCursorHooksConfig(options.cursorHooks);
     this.gitStatusMonitor = normalizeGitStatusMonitorConfig(options.gitStatus);
     this.github = normalizeGitHubIntegrationConfig(options.github);
+    this.linear = normalizeLinearIntegrationConfig(options.linear);
     this.githubExecFile = options.githubExecFile ?? execFile;
     this.githubTokenResolver =
       options.githubTokenResolver ?? (async () => await this.readGhAuthToken());
     this.githubFetch = options.githubFetch ?? fetch;
     this.githubApi = {
-      openPullRequestForBranch: async (input) => await this.openGitHubPullRequestForBranch(input),
-      createPullRequest: async (input) => await this.createGitHubPullRequest(input),
+      openPullRequestForBranch: this.openGitHubPullRequestForBranch.bind(this),
+      findPullRequestForBranch: this.findGitHubPullRequestForBranch.bind(this),
+      listPullRequestReviewThreads: this.listGitHubPullRequestReviewThreads.bind(this),
+      createPullRequest: this.createGitHubPullRequest.bind(this),
+    };
+    this.linearApi = {
+      issueByIdentifier: this.fetchLinearIssueByIdentifier.bind(this),
     };
     this.readGitDirectorySnapshot =
       options.readGitDirectorySnapshot ??
@@ -1230,14 +1433,22 @@ export class ControlPlaneStreamServer {
         webhooks: [],
       },
     );
-    this.server = createServer((socket) => {
-      this.handleConnection(socket);
-    });
+    this.server = createServer(this.handleConnection.bind(this));
     this.telemetryServer = this.codexTelemetry.enabled
-      ? createHttpServer((request, response) => {
-          this.handleTelemetryHttpRequest(request, response);
-        })
+      ? createHttpServer(this.handleTelemetryHttpRequest.bind(this))
       : null;
+    this.storageLifecycle = new StorageLifecycleCore({
+      telemetryStore: asTelemetryLifecycleStore(this.stateStore),
+      ...(options.storageLifecyclePolicy === undefined
+        ? {}
+        : {
+            policy: options.storageLifecyclePolicy,
+          }),
+      writeStderr: (text) => process.stderr.write(text),
+    });
+    this.storageLifecyclePolicyReload = normalizeStorageLifecyclePolicyReloadConfig(
+      options.storageLifecyclePolicyReload,
+    );
   }
 
   async start(): Promise<void> {
@@ -1268,6 +1479,8 @@ export class ControlPlaneStreamServer {
     this.startHistoryPollingIfEnabled();
     this.startGitStatusPollingIfEnabled();
     this.startGitHubPollingIfEnabled();
+    this.startStorageLifecyclePolling();
+    this.startStorageLifecyclePolicyReloadPolling();
   }
 
   address(): AddressInfo {
@@ -1294,6 +1507,8 @@ export class ControlPlaneStreamServer {
     this.stopHistoryPolling();
     this.stopGitStatusPolling();
     this.stopGitHubPolling();
+    this.stopStorageLifecyclePolling();
+    this.stopStorageLifecyclePolicyReloadPolling();
     await this.waitForGitHubPollingToSettle();
 
     for (const sessionId of [...this.sessions.keys()]) {
@@ -1381,7 +1596,18 @@ export class ControlPlaneStreamServer {
   }
 
   private pollHistoryTimerTick(): void {
-    void this.pollHistoryFile();
+    void this.pollHistoryFile().catch((error: unknown) => {
+      if (this.markStateStoreClosedIfDetected(error)) {
+        return;
+      }
+      if (this.shouldSkipStateStoreWork()) {
+        return;
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      recordPerfEvent('control-plane.history.poll.failed', {
+        error: message,
+      });
+    });
   }
 
   private stopHistoryPolling(): void {
@@ -1394,14 +1620,78 @@ export class ControlPlaneStreamServer {
     this.historyNextAllowedPollAtMs = 0;
   }
 
+  updateStorageLifecyclePolicy(policy: Partial<StorageLifecyclePolicy>): void {
+    this.storageLifecycle.updatePolicy(policy);
+  }
+
+  private startStorageLifecyclePolling(): void {
+    // Temporarily disabled while maintenance is moved out of interactive/server hot paths.
+  }
+
+  private stopStorageLifecyclePolling(): void {
+    if (this.storageLifecycleTimer === null) {
+      return;
+    }
+    clearInterval(this.storageLifecycleTimer);
+    this.storageLifecycleTimer = null;
+  }
+
+  private startStorageLifecyclePolicyReloadPolling(): void {
+    if (
+      this.storageLifecyclePolicyReload === null ||
+      this.storageLifecyclePolicyReloadTimer !== null
+    ) {
+      return;
+    }
+    const intervalMs = this.storageLifecyclePolicyReload.pollMs;
+    this.storageLifecyclePolicyReloadTimer = setInterval(() => {
+      this.reloadStorageLifecyclePolicyFromConfig();
+    }, intervalMs);
+    this.storageLifecyclePolicyReloadTimer.unref();
+  }
+
+  private stopStorageLifecyclePolicyReloadPolling(): void {
+    if (this.storageLifecyclePolicyReloadTimer === null) {
+      return;
+    }
+    clearInterval(this.storageLifecyclePolicyReloadTimer);
+    this.storageLifecyclePolicyReloadTimer = null;
+  }
+
+  private reloadStorageLifecyclePolicyFromConfig(): void {
+    if (this.storageLifecyclePolicyReload === null) {
+      return;
+    }
+    const loaded = loadHarnessConfig({
+      cwd: this.storageLifecyclePolicyReload.cwd,
+      ...(this.storageLifecyclePolicyReload.filePath === undefined
+        ? {}
+        : { filePath: this.storageLifecyclePolicyReload.filePath }),
+      ...(this.storageLifecyclePolicyReload.env === undefined
+        ? {}
+        : { env: this.storageLifecyclePolicyReload.env }),
+      lastKnownGood: this.storageLifecyclePolicyLastKnownGood,
+    });
+    this.storageLifecyclePolicyLastKnownGood = loaded.config;
+    if (loaded.fromLastKnownGood && loaded.error !== null) {
+      if (loaded.error !== this.storageLifecyclePolicyLastError) {
+        process.stderr.write(`[config] storage lifecycle policy reload skipped: ${loaded.error}\n`);
+        this.storageLifecyclePolicyLastError = loaded.error;
+      }
+      return;
+    }
+    this.storageLifecyclePolicyLastError = null;
+    this.updateStorageLifecyclePolicy(loaded.config.storage.lifecycle);
+  }
+
   private startGitStatusPollingIfEnabled(): void {
     if (!this.gitStatusMonitor.enabled || this.gitStatusPollTimer !== null) {
       return;
     }
     this.reloadGitStatusDirectoriesFromStore();
-    void this.pollGitStatus();
+    this.triggerGitStatusPoll();
     this.gitStatusPollTimer = setInterval(() => {
-      void this.pollGitStatus();
+      this.triggerGitStatusPoll();
     }, this.gitStatusMonitor.pollMs);
     this.gitStatusPollTimer.unref();
   }
@@ -1494,6 +1784,9 @@ export class ControlPlaneStreamServer {
 
   private triggerGitHubPoll(): void {
     void this.pollGitHub().catch((error: unknown) => {
+      if (this.markStateStoreClosedIfDetected(error)) {
+        return;
+      }
       if (this.shouldIgnoreGitHubPollError(error)) {
         return;
       }
@@ -1504,10 +1797,41 @@ export class ControlPlaneStreamServer {
     });
   }
 
+  private triggerGitStatusPoll(): void {
+    void this.pollGitStatus().catch((error: unknown) => {
+      if (this.markStateStoreClosedIfDetected(error)) {
+        return;
+      }
+      if (this.shouldSkipStateStoreWork()) {
+        return;
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      recordPerfEvent('control-plane.git-status.poll.failed', {
+        error: message,
+      });
+    });
+  }
+
   private isStateStoreClosedError(error: unknown): boolean {
     const message = error instanceof Error ? error.message : String(error);
     const normalized = message.trim().toLowerCase();
-    return normalized.includes('database has closed') || normalized.includes('database is closed');
+    return (
+      normalized.includes('database has closed') ||
+      normalized.includes('database is closed') ||
+      normalized.includes('cannot use a closed database')
+    );
+  }
+
+  private markStateStoreClosedIfDetected(error: unknown): boolean {
+    if (!this.isStateStoreClosedError(error)) {
+      return false;
+    }
+    this.stateStoreClosed = true;
+    this.stopGitHubPolling();
+    this.stopGitStatusPolling();
+    this.stopHistoryPolling();
+    this.stopStorageLifecyclePolling();
+    return true;
   }
 
   private shouldSkipStateStoreWork(): boolean {
@@ -1526,6 +1850,9 @@ export class ControlPlaneStreamServer {
     try {
       await pollPromise;
     } catch (error: unknown) {
+      if (this.markStateStoreClosedIfDetected(error)) {
+        return;
+      }
       if (!this.shouldIgnoreGitHubPollError(error)) {
         const message = error instanceof Error ? error.message : String(error);
         recordPerfEvent('control-plane.github.poll.failed-on-close', {
@@ -1720,6 +2047,8 @@ export class ControlPlaneStreamServer {
         directoryPath: directory?.path ?? null,
         codexLaunchDefaultMode: this.codexLaunch.defaultMode,
         codexLaunchModeByDirectoryPath: this.codexLaunch.directoryModes,
+        claudeLaunchDefaultMode: this.claudeLaunch.defaultMode,
+        claudeLaunchModeByDirectoryPath: this.claudeLaunch.directoryModes,
         cursorLaunchDefaultMode: this.cursorLaunch.defaultMode,
         cursorLaunchModeByDirectoryPath: this.cursorLaunch.directoryModes,
       });
@@ -1912,6 +2241,39 @@ export class ControlPlaneStreamServer {
   }
 
   private handleTelemetryHttpRequest(request: IncomingMessage, response: ServerResponse): void {
+    const requestWithEvents = request as unknown as {
+      on?: (event: string, listener: (...args: unknown[]) => void) => void;
+      once?: (event: string, listener: (...args: unknown[]) => void) => void;
+      off?: (event: string, listener: (...args: unknown[]) => void) => void;
+    };
+    const responseWithEvents = response as unknown as {
+      on?: (event: string, listener: (...args: unknown[]) => void) => void;
+      once?: (event: string, listener: (...args: unknown[]) => void) => void;
+      off?: (event: string, listener: (...args: unknown[]) => void) => void;
+    };
+    const onStreamError = (error: unknown): void => {
+      if (isTelemetryRequestAbortError(error)) {
+        return;
+      }
+      if (response.writableEnded) {
+        return;
+      }
+      response.statusCode = 500;
+      response.end();
+    };
+    const cleanupStreamErrorListeners = (): void => {
+      requestWithEvents.off?.('error', onStreamError);
+      responseWithEvents.off?.('error', onStreamError);
+      requestWithEvents.off?.('close', cleanupStreamErrorListeners);
+      responseWithEvents.off?.('close', cleanupStreamErrorListeners);
+      responseWithEvents.off?.('finish', cleanupStreamErrorListeners);
+    };
+    requestWithEvents.on?.('error', onStreamError);
+    responseWithEvents.on?.('error', onStreamError);
+    requestWithEvents.once?.('close', cleanupStreamErrorListeners);
+    responseWithEvents.once?.('close', cleanupStreamErrorListeners);
+    responseWithEvents.once?.('finish', cleanupStreamErrorListeners);
+
     void this.handleTelemetryHttpRequestAsync(request, response).catch((error: unknown) => {
       if (isTelemetryRequestAbortError(error)) {
         return;
@@ -2054,6 +2416,7 @@ export class ControlPlaneStreamServer {
       observedAt: event.observedAt,
       payload: event.payload,
     });
+    const persistedPayload = this.storageLifecycle.prepareTelemetryPayload(event.payload);
 
     const inserted = this.stateStore.appendTelemetry({
       source: event.source,
@@ -2063,7 +2426,7 @@ export class ControlPlaneStreamServer {
       severity: event.severity,
       summary: event.summary,
       observedAt: event.observedAt,
-      payload: event.payload,
+      payload: persistedPayload,
       fingerprint,
     });
     if (resolvedSessionId !== null) {
@@ -2205,9 +2568,15 @@ export class ControlPlaneStreamServer {
   }
 
   private async pollHistoryFile(): Promise<void> {
-    await pollStreamServerHistoryFile(
-      this as unknown as Parameters<typeof pollStreamServerHistoryFile>[0],
-    );
+    try {
+      await pollStreamServerHistoryFile(
+        this as unknown as Parameters<typeof pollStreamServerHistoryFile>[0],
+      );
+    } catch (error: unknown) {
+      if (!this.markStateStoreClosedIfDetected(error)) {
+        throw error;
+      }
+    }
   }
 
   private async pollHistoryFileUnsafe(): Promise<boolean> {
@@ -2217,9 +2586,15 @@ export class ControlPlaneStreamServer {
   }
 
   private async pollGitStatus(): Promise<void> {
-    await pollStreamServerGitStatus(
-      this as unknown as Parameters<typeof pollStreamServerGitStatus>[0],
-    );
+    try {
+      await pollStreamServerGitStatus(
+        this as unknown as Parameters<typeof pollStreamServerGitStatus>[0],
+      );
+    } catch (error: unknown) {
+      if (!this.markStateStoreClosedIfDetected(error)) {
+        throw error;
+      }
+    }
   }
 
   private async refreshGitStatusForDirectory(
@@ -2314,6 +2689,10 @@ export class ControlPlaneStreamServer {
     this.githubPollPromise = pollPromise;
     try {
       await pollPromise;
+    } catch (error: unknown) {
+      if (!this.markStateStoreClosedIfDetected(error)) {
+        throw error;
+      }
     } finally {
       if (this.githubPollPromise === pollPromise) {
         this.githubPollPromise = null;
@@ -2322,6 +2701,200 @@ export class ControlPlaneStreamServer {
     }
   }
 
+  private githubProjectReviewCacheKey(input: { repositoryId: string; branchName: string }): string {
+    return `${input.repositoryId}:${input.branchName}`;
+  }
+
+  private getGitHubProjectReviewCache(input: { repositoryId: string; branchName: string }): {
+    repositoryId: string;
+    branchName: string;
+    pr: {
+      number: number;
+      title: string;
+      url: string;
+      authorLogin: string | null;
+      headBranch: string;
+      headSha: string;
+      baseBranch: string;
+      state: 'draft' | 'open' | 'merged' | 'closed';
+      isDraft: boolean;
+      mergedAt: string | null;
+      closedAt: string | null;
+      updatedAt: string;
+      createdAt: string;
+    } | null;
+    openThreads: readonly {
+      threadId: string;
+      isResolved: boolean;
+      isOutdated: boolean;
+      resolvedByLogin: string | null;
+      comments: readonly {
+        commentId: string;
+        authorLogin: string | null;
+        body: string;
+        url: string | null;
+        createdAt: string;
+        updatedAt: string;
+      }[];
+    }[];
+    resolvedThreads: readonly {
+      threadId: string;
+      isResolved: boolean;
+      isOutdated: boolean;
+      resolvedByLogin: string | null;
+      comments: readonly {
+        commentId: string;
+        authorLogin: string | null;
+        body: string;
+        url: string | null;
+        createdAt: string;
+        updatedAt: string;
+      }[];
+    }[];
+    fetchedAtMs: number;
+  } | null {
+    const key = this.githubProjectReviewCacheKey(input);
+    const cached = this.githubProjectReviewCacheByKey.get(key);
+    return cached ?? null;
+  }
+
+  private async refreshGitHubProjectReviewCache(input: {
+    repositoryId: string;
+    owner: string;
+    repo: string;
+    branchName: string;
+    forceRefresh?: boolean;
+    remotePr?: GitHubRemotePullRequest | null;
+  }): Promise<{
+    repositoryId: string;
+    branchName: string;
+    pr: {
+      number: number;
+      title: string;
+      url: string;
+      authorLogin: string | null;
+      headBranch: string;
+      headSha: string;
+      baseBranch: string;
+      state: 'draft' | 'open' | 'merged' | 'closed';
+      isDraft: boolean;
+      mergedAt: string | null;
+      closedAt: string | null;
+      updatedAt: string;
+      createdAt: string;
+    } | null;
+    openThreads: readonly {
+      threadId: string;
+      isResolved: boolean;
+      isOutdated: boolean;
+      resolvedByLogin: string | null;
+      comments: readonly {
+        commentId: string;
+        authorLogin: string | null;
+        body: string;
+        url: string | null;
+        createdAt: string;
+        updatedAt: string;
+      }[];
+    }[];
+    resolvedThreads: readonly {
+      threadId: string;
+      isResolved: boolean;
+      isOutdated: boolean;
+      resolvedByLogin: string | null;
+      comments: readonly {
+        commentId: string;
+        authorLogin: string | null;
+        body: string;
+        url: string | null;
+        createdAt: string;
+        updatedAt: string;
+      }[];
+    }[];
+    fetchedAtMs: number;
+  }> {
+    const key = this.githubProjectReviewCacheKey(input);
+    const forceRefresh = input.forceRefresh === true;
+    const cached = this.githubProjectReviewCacheByKey.get(key);
+    if (
+      !forceRefresh &&
+      cached !== undefined &&
+      Date.now() - cached.fetchedAtMs < DEFAULT_GITHUB_PROJECT_REVIEW_PREWARM_INTERVAL_MS
+    ) {
+      return cached;
+    }
+    const inFlight = this.githubProjectReviewRefreshInFlightByKey.get(key);
+    if (inFlight !== undefined) {
+      return await inFlight;
+    }
+    const refreshPromise: Promise<GitHubProjectReviewCacheEntry> = (async () => {
+      const remotePr =
+        input.remotePr !== undefined
+          ? input.remotePr
+          : await this.openGitHubPullRequestForBranch({
+              owner: input.owner,
+              repo: input.repo,
+              headBranch: input.branchName,
+            });
+      if (remotePr === null) {
+        const next: GitHubProjectReviewCacheEntry = {
+          repositoryId: input.repositoryId,
+          branchName: input.branchName,
+          pr: null,
+          openThreads: [],
+          resolvedThreads: [],
+          fetchedAtMs: Date.now(),
+        };
+        this.githubProjectReviewCacheByKey.set(key, next);
+        return next;
+      }
+      const reviewThreads = await this.listGitHubPullRequestReviewThreads({
+        owner: input.owner,
+        repo: input.repo,
+        pullNumber: remotePr.number,
+      });
+      const next: GitHubProjectReviewCacheEntry = {
+        repositoryId: input.repositoryId,
+        branchName: input.branchName,
+        pr: {
+          number: remotePr.number,
+          title: remotePr.title,
+          url: remotePr.url,
+          authorLogin: remotePr.authorLogin,
+          headBranch: remotePr.headBranch,
+          headSha: remotePr.headSha,
+          baseBranch: remotePr.baseBranch,
+          state:
+            remotePr.state === 'open' && remotePr.isDraft
+              ? 'draft'
+              : remotePr.state === 'open'
+                ? 'open'
+                : remotePr.mergedAt !== null
+                  ? 'merged'
+                  : 'closed',
+          isDraft: remotePr.isDraft,
+          mergedAt: remotePr.mergedAt,
+          closedAt: remotePr.closedAt,
+          updatedAt: remotePr.updatedAt,
+          createdAt: remotePr.createdAt,
+        },
+        openThreads: reviewThreads.filter((thread) => !thread.isResolved),
+        resolvedThreads: reviewThreads.filter((thread) => thread.isResolved),
+        fetchedAtMs: Date.now(),
+      };
+      this.githubProjectReviewCacheByKey.set(key, next);
+      return next;
+    })();
+    this.githubProjectReviewRefreshInFlightByKey.set(key, refreshPromise);
+    try {
+      return await refreshPromise;
+    } finally {
+      if (this.githubProjectReviewRefreshInFlightByKey.get(key) === refreshPromise) {
+        this.githubProjectReviewRefreshInFlightByKey.delete(key);
+      }
+    }
+  }
+
   private async syncGitHubBranch(input: {
     directory: ControlPlaneDirectoryRecord;
     repository: ControlPlaneRepositoryRecord;
@@ -2344,6 +2917,20 @@ export class ControlPlaneStreamServer {
         return;
       }
       if (remotePr === null) {
+        this.githubProjectReviewCacheByKey.set(
+          this.githubProjectReviewCacheKey({
+            repositoryId: input.repository.repositoryId,
+            branchName: input.branchName,
+          }),
+          {
+            repositoryId: input.repository.repositoryId,
+            branchName: input.branchName,
+            pr: null,
+            openThreads: [],
+            resolvedThreads: [],
+            fetchedAtMs: Date.now(),
+          },
+        );
         const staleOpen = this.stateStore.listGitHubPullRequests({
           repositoryId: input.repository.repositoryId,
           headBranch: input.branchName,
@@ -2424,6 +3011,13 @@ export class ControlPlaneStreamServer {
         isDraft: remotePr.isDraft,
         observedAt: remotePr.updatedAt || now,
       });
+      void this.refreshGitHubProjectReviewCache({
+        repositoryId: input.repository.repositoryId,
+        owner: input.owner,
+        repo: input.repo,
+        branchName: input.branchName,
+        remotePr,
+      }).catch(() => {});
       const jobs = await this.listGitHubPrJobsForCommit({
         owner: input.owner,
         repo: input.repo,
@@ -2491,6 +3085,9 @@ export class ControlPlaneStreamServer {
         lastErrorAt: null,
       });
     } catch (error: unknown) {
+      if (this.markStateStoreClosedIfDetected(error)) {
+        return;
+      }
       if (this.shouldIgnoreGitHubPollError(error)) {
         return;
       }
@@ -2510,6 +3107,9 @@ export class ControlPlaneStreamServer {
           lastErrorAt: now,
         });
       } catch (syncStateError: unknown) {
+        if (this.markStateStoreClosedIfDetected(syncStateError)) {
+          return;
+        }
         if (!this.shouldIgnoreGitHubPollError(syncStateError)) {
           throw syncStateError;
         }
@@ -2527,8 +3127,8 @@ export class ControlPlaneStreamServer {
     if (token === null) {
       const hint =
         this.githubTokenResolutionError === null
-          ? 'set GITHUB_TOKEN or run gh auth login'
-          : `${this.githubTokenResolutionError}; set GITHUB_TOKEN or run gh auth login`;
+          ? `set ${this.github.tokenEnvVar} or ${GITHUB_OAUTH_ACCESS_TOKEN_ENV_VAR} or run gh auth login`
+          : `${this.githubTokenResolutionError}; set ${this.github.tokenEnvVar} or ${GITHUB_OAUTH_ACCESS_TOKEN_ENV_VAR} or run gh auth login`;
       throw new Error(`github token not configured: ${hint}`);
     }
     const response = await this.githubFetch(`${this.github.apiBaseUrl}${path}`, {
@@ -2549,6 +3149,82 @@ export class ControlPlaneStreamServer {
     return await response.json();
   }
 
+  private async fetchLinearIssueByIdentifier(input: { identifier: string }): Promise<{
+    identifier: string;
+    title: string;
+    description: string | null;
+    url: string | null;
+    stateName: string | null;
+    teamKey: string | null;
+  } | null> {
+    const token = this.linear.token;
+    if (token === null || token.trim().length === 0) {
+      throw new Error(
+        `linear token not configured: set ${this.linear.tokenEnvVar} or ${LINEAR_OAUTH_ACCESS_TOKEN_ENV_VAR}`,
+      );
+    }
+    const client = new LinearClient({
+      apiKey: token,
+      apiUrl: this.linear.apiBaseUrl,
+    });
+    const response = await client.client.rawRequest<
+      {
+        issues?: {
+          nodes?: Array<{
+            identifier?: string;
+            title?: string;
+            description?: string | null;
+            url?: string | null;
+            state?: {
+              name?: string | null;
+            } | null;
+            team?: {
+              key?: string | null;
+            } | null;
+          }>;
+        };
+      },
+      { identifier: string }
+    >(
+      `
+        query HarnessLinearIssueImport($identifier: String!) {
+          issues(filter: { identifier: { eq: $identifier } }, first: 1) {
+            nodes {
+              identifier
+              title
+              description
+              url
+              state {
+                name
+              }
+              team {
+                key
+              }
+            }
+          }
+        }
+      `,
+      {
+        identifier: input.identifier,
+      },
+    );
+    const issue = response.data?.issues?.nodes?.[0];
+    if (issue === undefined) {
+      return null;
+    }
+    if (typeof issue.identifier !== 'string' || typeof issue.title !== 'string') {
+      throw new Error('linear issue response malformed');
+    }
+    return {
+      identifier: issue.identifier,
+      title: issue.title,
+      description: typeof issue.description === 'string' ? issue.description : null,
+      url: typeof issue.url === 'string' ? issue.url : null,
+      stateName: typeof issue.state?.name === 'string' ? issue.state.name : null,
+      teamKey: typeof issue.team?.key === 'string' ? issue.team.key : null,
+    };
+  }
+
   private parseGitHubPullRequest(value: unknown): GitHubRemotePullRequest | null {
     if (typeof value !== 'object' || value === null || Array.isArray(value)) {
       return null;
@@ -2565,6 +3241,8 @@ export class ControlPlaneStreamServer {
     const updatedAt = record['updated_at'];
     const createdAt = record['created_at'];
     const closedAt = record['closed_at'];
+    const mergedAtRaw = record['merged_at'];
+    const mergedAt = mergedAtRaw === undefined ? null : mergedAtRaw;
     if (
       typeof number !== 'number' ||
       typeof title !== 'string' ||
@@ -2574,6 +3252,7 @@ export class ControlPlaneStreamServer {
       typeof updatedAt !== 'string' ||
       typeof createdAt !== 'string' ||
       (closedAt !== null && typeof closedAt !== 'string') ||
+      (mergedAt !== null && typeof mergedAt !== 'string') ||
       typeof head !== 'object' ||
       head === null ||
       Array.isArray(head) ||
@@ -2608,6 +3287,7 @@ export class ControlPlaneStreamServer {
       baseBranch: baseRef,
       state,
       isDraft: draft,
+      mergedAt: mergedAt as string | null,
       updatedAt,
       createdAt,
       closedAt: closedAt as string | null,
@@ -2628,6 +3308,204 @@ export class ControlPlaneStreamServer {
     return this.parseGitHubPullRequest(payload[0]);
   }
 
+  private async findGitHubPullRequestForBranch(input: {
+    owner: string;
+    repo: string;
+    headBranch: string;
+  }): Promise<GitHubRemotePullRequest | null> {
+    const head = encodeURIComponent(`${input.owner}:${input.headBranch}`);
+    const path = `/repos/${encodeURIComponent(input.owner)}/${encodeURIComponent(input.repo)}/pulls?state=all&head=${head}&per_page=10&sort=updated&direction=desc`;
+    const payload = await this.githubJsonRequest(path);
+    if (!Array.isArray(payload) || payload.length === 0) {
+      return null;
+    }
+    for (const value of payload) {
+      const parsed = this.parseGitHubPullRequest(value);
+      if (parsed !== null) {
+        return parsed;
+      }
+    }
+    return null;
+  }
+
+  private async listGitHubPullRequestReviewThreads(input: {
+    owner: string;
+    repo: string;
+    pullNumber: number;
+  }): Promise<readonly GitHubRemotePrReviewThread[]> {
+    const payload = await this.githubJsonRequest('/graphql', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        query: `
+          query HarnessPullRequestReviewThreads($owner: String!, $repo: String!, $number: Int!) {
+            repository(owner: $owner, name: $repo) {
+              pullRequest(number: $number) {
+                reviewThreads(first: 100) {
+                  nodes {
+                    id
+                    isResolved
+                    isOutdated
+                    resolvedBy {
+                      login
+                    }
+                    comments(first: 100) {
+                      nodes {
+                        id
+                        body
+                        bodyText
+                        url
+                        createdAt
+                        updatedAt
+                        author {
+                          login
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        `,
+        variables: {
+          owner: input.owner,
+          repo: input.repo,
+          number: input.pullNumber,
+        },
+      }),
+    });
+    if (typeof payload !== 'object' || payload === null || Array.isArray(payload)) {
+      throw new Error('github graphql review threads response malformed');
+    }
+    const payloadRecord = payload as Record<string, unknown>;
+    const errors = payloadRecord['errors'];
+    if (Array.isArray(errors) && errors.length > 0) {
+      const firstError = errors[0];
+      if (typeof firstError === 'object' && firstError !== null && !Array.isArray(firstError)) {
+        const message = (firstError as Record<string, unknown>)['message'];
+        if (typeof message === 'string' && message.trim().length > 0) {
+          throw new Error(`github graphql review threads failed: ${message}`);
+        }
+      }
+      throw new Error('github graphql review threads failed');
+    }
+    const data =
+      typeof payloadRecord['data'] === 'object' &&
+      payloadRecord['data'] !== null &&
+      !Array.isArray(payloadRecord['data'])
+        ? (payloadRecord['data'] as Record<string, unknown>)
+        : null;
+    const repository =
+      data !== null &&
+      typeof data['repository'] === 'object' &&
+      data['repository'] !== null &&
+      !Array.isArray(data['repository'])
+        ? (data['repository'] as Record<string, unknown>)
+        : null;
+    const pullRequest =
+      repository !== null &&
+      typeof repository['pullRequest'] === 'object' &&
+      repository['pullRequest'] !== null &&
+      !Array.isArray(repository['pullRequest'])
+        ? (repository['pullRequest'] as Record<string, unknown>)
+        : null;
+    const reviewThreads =
+      pullRequest !== null &&
+      typeof pullRequest['reviewThreads'] === 'object' &&
+      pullRequest['reviewThreads'] !== null &&
+      !Array.isArray(pullRequest['reviewThreads'])
+        ? (pullRequest['reviewThreads'] as Record<string, unknown>)
+        : null;
+    const threadNodes = reviewThreads?.['nodes'];
+    if (!Array.isArray(threadNodes)) {
+      return [];
+    }
+    const threads: GitHubRemotePrReviewThread[] = [];
+    for (const threadRaw of threadNodes) {
+      if (typeof threadRaw !== 'object' || threadRaw === null || Array.isArray(threadRaw)) {
+        continue;
+      }
+      const thread = threadRaw as Record<string, unknown>;
+      const threadId = thread['id'];
+      const isResolved = thread['isResolved'];
+      const isOutdated = thread['isOutdated'];
+      const resolvedBy =
+        typeof thread['resolvedBy'] === 'object' &&
+        thread['resolvedBy'] !== null &&
+        !Array.isArray(thread['resolvedBy'])
+          ? (thread['resolvedBy'] as Record<string, unknown>)
+          : null;
+      const resolvedByLogin =
+        resolvedBy !== null && typeof resolvedBy['login'] === 'string' ? resolvedBy['login'] : null;
+      const commentsRecord =
+        typeof thread['comments'] === 'object' &&
+        thread['comments'] !== null &&
+        !Array.isArray(thread['comments'])
+          ? (thread['comments'] as Record<string, unknown>)
+          : null;
+      const commentsNodes = commentsRecord?.['nodes'];
+      if (
+        typeof threadId !== 'string' ||
+        typeof isResolved !== 'boolean' ||
+        typeof isOutdated !== 'boolean' ||
+        !Array.isArray(commentsNodes)
+      ) {
+        continue;
+      }
+      const comments: GitHubRemotePrReviewComment[] = [];
+      for (const commentRaw of commentsNodes) {
+        if (typeof commentRaw !== 'object' || commentRaw === null || Array.isArray(commentRaw)) {
+          continue;
+        }
+        const comment = commentRaw as Record<string, unknown>;
+        const commentId = comment['id'];
+        const bodyText = comment['bodyText'];
+        const body = comment['body'];
+        const url = comment['url'];
+        const createdAt = comment['createdAt'];
+        const updatedAt = comment['updatedAt'];
+        const author =
+          typeof comment['author'] === 'object' &&
+          comment['author'] !== null &&
+          !Array.isArray(comment['author'])
+            ? (comment['author'] as Record<string, unknown>)
+            : null;
+        const authorLogin =
+          author !== null && typeof author['login'] === 'string' ? author['login'] : null;
+        const normalizedBody =
+          typeof bodyText === 'string' ? bodyText : typeof body === 'string' ? body : null;
+        if (
+          typeof commentId !== 'string' ||
+          normalizedBody === null ||
+          (url !== null && url !== undefined && typeof url !== 'string') ||
+          typeof createdAt !== 'string' ||
+          typeof updatedAt !== 'string'
+        ) {
+          continue;
+        }
+        comments.push({
+          commentId,
+          authorLogin,
+          body: normalizedBody,
+          url: typeof url === 'string' ? url : null,
+          createdAt,
+          updatedAt,
+        });
+      }
+      threads.push({
+        threadId,
+        isResolved,
+        isOutdated,
+        resolvedByLogin,
+        comments,
+      });
+    }
+    return threads;
+  }
+
   private async createGitHubPullRequest(input: {
     owner: string;
     repo: string;
@@ -3318,7 +4196,7 @@ export class ControlPlaneStreamServer {
       scopeKind: task.scopeKind,
       projectId: task.projectId,
       title: task.title,
-      description: task.description,
+      body: task.body,
       status: task.status,
       orderIndex: task.orderIndex,
       claimedByControllerId: task.claimedByControllerId,
@@ -3327,21 +4205,6 @@ export class ControlPlaneStreamServer {
       baseBranch: task.baseBranch,
       claimedAt: task.claimedAt,
       completedAt: task.completedAt,
-      linear: {
-        issueId: task.linear.issueId,
-        identifier: task.linear.identifier,
-        url: task.linear.url,
-        teamId: task.linear.teamId,
-        projectId: task.linear.projectId,
-        projectMilestoneId: task.linear.projectMilestoneId,
-        cycleId: task.linear.cycleId,
-        stateId: task.linear.stateId,
-        assigneeId: task.linear.assigneeId,
-        priority: task.linear.priority,
-        estimate: task.linear.estimate,
-        dueDate: task.linear.dueDate,
-        labelIds: [...task.linear.labelIds],
-      },
       createdAt: task.createdAt,
       updatedAt: task.updatedAt,
     };