mstro-app 0.4.17 → 0.4.21

package/server/services/plan/issue-retry.ts

@@ -0,0 +1,294 @@
+// Copyright (c) 2025-present Mstro, Inc. All rights reserved.
+// Licensed under the MIT License. See LICENSE file for details.
+
+/**
+ * Issue Retry — Retry loop for PM issue execution.
+ *
+ * Brings the same resilience as Chat view (improvisation-retry.ts) to PM agents:
+ * - Tool timeout checkpoint recovery (preserves completed tools, skips hung tool)
+ * - Signal crash recovery (preserves accumulated results across retries)
+ * - Premature completion handling (max_tokens / end_turn → resume with "continue")
+ *
+ * Unlike Chat's retry system, PM agents don't maintain session continuity across
+ * prompts — each issue is independent — so we skip inter-movement recovery and
+ * simplify the resume strategy.
+ */
+
+import { hlog } from '../../cli/headless/headless-logger.js';
+import { HeadlessRunner } from '../../cli/headless/index.js';
+import { assessPrematureCompletion } from '../../cli/headless/stall-assessor.js';
+import type { ExecutionCheckpoint, SessionResult } from '../../cli/headless/types.js';
+import {
+  buildResumeRetryPrompt,
+  buildRetryPrompt,
+  buildSignalCrashRecoveryPrompt,
+} from '../../cli/prompt-builders.js';
+
+/** Max retries per issue execution (tool timeout, signal crash, premature completion combined) */
+const MAX_ISSUE_RETRIES = 3;
+
+/** Max accumulated tool results to carry across retries */
+const MAX_ACCUMULATED_RESULTS = 50;
+
+/** Lightweight tool record for accumulation across retries */
+interface ToolRecord {
+  toolName: string;
+  toolId: string;
+  toolInput: Record<string, unknown>;
+  result?: string;
+  isError?: boolean;
+  duration?: number;
+}
+
+interface IssueRetryState {
+  currentPrompt: string;
+  retryNumber: number;
+  checkpoint: ExecutionCheckpoint | null;
+  accumulatedToolResults: ToolRecord[];
+  timedOutTools: Array<{ toolName: string; input: Record<string, unknown>; timeoutMs: number }>;
+  /** Session ID from a prior run — enables --resume for premature completion */
+  lastSessionId: string | undefined;
+  bestResult: SessionResult | null;
+}
+
+export interface IssueRunnerConfig {
+  workingDir: string;
+  /** Original enriched prompt for this issue */
+  prompt: string;
+  /** Stall detection timeouts (ms) */
+  stallWarningMs: number;
+  stallKillMs: number;
+  stallHardCapMs: number;
+  stallMaxExtensions: number;
+  /** Callback for streaming output to executor event bus */
+  outputCallback?: (text: string) => void;
+}
+
+/**
+ * Execute a PM issue with retry logic.
+ *
+ * This wraps HeadlessRunner.run() with the same retry strategies as Chat view:
+ * 1. Tool timeout → checkpoint recovery with accumulated results
+ * 2. Signal crash → fresh start with preserved tool results
+ * 3. Premature completion → resume session with "continue"
+ */
+export async function runIssueWithRetry(config: IssueRunnerConfig): Promise<SessionResult> {
+  const state: IssueRetryState = {
+    currentPrompt: config.prompt,
+    retryNumber: 0,
+    checkpoint: null,
+    accumulatedToolResults: [],
+    timedOutTools: [],
+    lastSessionId: undefined,
+    bestResult: null,
+  };
+
+  let result: SessionResult | undefined;
+
+  while (state.retryNumber <= MAX_ISSUE_RETRIES) {
+    // Clear checkpoint from prior iteration
+    state.checkpoint = null;
+
+    // Determine resume strategy
+    const useResume = !!state.lastSessionId;
+    const resumeSessionId = state.lastSessionId;
+    state.lastSessionId = undefined;
+
+    const runner = new HeadlessRunner({
+      workingDir: config.workingDir,
+      directPrompt: state.currentPrompt,
+      stallWarningMs: config.stallWarningMs,
+      stallKillMs: config.stallKillMs,
+      stallHardCapMs: config.stallHardCapMs,
+      stallMaxExtensions: config.stallMaxExtensions,
+      verbose: true,
+      continueSession: useResume,
+      claudeSessionId: resumeSessionId,
+      outputCallback: config.outputCallback,
+      onToolTimeout: (cp: ExecutionCheckpoint) => {
+        state.checkpoint = cp;
+      },
+    });
+
+    result = await runner.run();
+
+    // Track best result for fallback selection
+    if (!state.bestResult || scoreResult(result) > scoreResult(state.bestResult)) {
+      state.bestResult = result;
+    }
+
+    // Evaluate retry strategies in priority order
+    if (tryToolTimeoutRetry(state, result, config)) continue;
+    if (trySignalCrashRetry(state, result, config)) continue;
+    if (await tryPrematureCompletionRetry(state, result, config)) continue;
+
+    // No retry needed — break out
+    break;
+  }
+
+  return result ?? state.bestResult ?? {
+    completed: false,
+    needsHandoff: false,
+    totalTokens: 0,
+    sessionId: '',
+    error: 'No result produced after retries',
+  };
+}
+
+// ========== Retry Strategies ==========
+
+/**
+ * Strategy 1: Tool timeout checkpoint recovery.
+ * When a tool times out, we have a checkpoint with all completed tools.
+ * Build a new prompt injecting those results and skip the hung resource.
+ */
+function tryToolTimeoutRetry(
+  state: IssueRetryState,
+  _result: SessionResult,
+  config: IssueRunnerConfig,
+): boolean {
+  if (!state.checkpoint || state.retryNumber >= MAX_ISSUE_RETRIES) return false;
+
+  const cp = state.checkpoint;
+  state.retryNumber++;
+
+  state.timedOutTools.push({
+    toolName: cp.hungTool.toolName,
+    input: cp.hungTool.input ?? {},
+    timeoutMs: cp.hungTool.timeoutMs,
+  });
+
+  const canResume = cp.inProgressTools.length === 0 && !!cp.claudeSessionId;
+
+  hlog(`[PM-RETRY] Tool timeout: ${cp.hungTool.toolName} after ${Math.round(cp.hungTool.timeoutMs / 1000)}s, ${cp.completedTools.length} tools completed, retry ${state.retryNumber}/${MAX_ISSUE_RETRIES} (${canResume ? 'resume' : 'fresh'})`);
+
+  if (canResume) {
+    state.lastSessionId = cp.claudeSessionId;
+    state.currentPrompt = buildResumeRetryPrompt(cp, state.timedOutTools);
+  } else {
+    state.currentPrompt = buildRetryPrompt(cp, config.prompt, state.timedOutTools);
+  }
+
+  config.outputCallback?.(`\n[PM-RETRY] Auto-retry ${state.retryNumber}/${MAX_ISSUE_RETRIES}: ${canResume ? 'Resuming session' : 'Continuing'} with ${cp.completedTools.length} results, skipping failed ${cp.hungTool.toolName}.\n`);
+
+  return true;
+}
+
+/**
+ * Strategy 2: Signal crash recovery.
+ * Process was killed by signal (SIGTERM/SIGKILL from stall watchdog or OS).
+ * Accumulate completed tools and retry with preserved context.
+ */
+function trySignalCrashRetry(
+  state: IssueRetryState,
+  result: SessionResult,
+  config: IssueRunnerConfig,
+): boolean {
+  const isSignalCrash = !!result.signalName;
+  const exitCodeSignal = !result.completed && !result.signalName && result.error?.match(/exited with code (1[2-9]\d|[2-9]\d{2})/);
+  if ((!isSignalCrash && !exitCodeSignal) || state.retryNumber >= MAX_ISSUE_RETRIES) return false;
+  // Don't double-handle if a checkpoint was already captured (tool timeout takes priority)
+  if (state.checkpoint) return false;
+
+  accumulateToolResults(result, state);
+  state.retryNumber++;
+
+  const signalInfo = result.signalName || 'unknown signal';
+  const useResume = !!result.claudeSessionId && state.retryNumber === 1;
+
+  hlog(`[PM-RETRY] Signal crash: ${signalInfo}, ${state.accumulatedToolResults.length} tools preserved, retry ${state.retryNumber}/${MAX_ISSUE_RETRIES} (${useResume ? 'resume' : 'fresh'})`);
+
+  if (useResume) {
+    state.lastSessionId = result.claudeSessionId;
+    state.currentPrompt = buildSignalCrashRecoveryPrompt(config.prompt, true);
+  } else {
+    state.currentPrompt = buildSignalCrashRecoveryPrompt(
+      config.prompt,
+      false,
+      state.accumulatedToolResults,
+    );
+  }
+
+  config.outputCallback?.(`\n[PM-RETRY] Signal recovery ${state.retryNumber}/${MAX_ISSUE_RETRIES}: ${useResume ? 'Resuming' : 'Restarting'} with ${state.accumulatedToolResults.length} preserved results.\n`);
+
+  return true;
+}
+
+/** Check if an end_turn result is actually incomplete using Haiku assessment. */
+async function isEndTurnIncomplete(result: SessionResult): Promise<boolean> {
+  if (!result.assistantResponse) return false;
+  const claudeCmd = process.env.CLAUDE_COMMAND || 'claude';
+  try {
+    const verdict = await assessPrematureCompletion({
+      responseTail: result.assistantResponse.slice(-800),
+      successfulToolCalls: result.toolUseHistory?.filter(t => t.result !== undefined && !t.isError).length ?? 0,
+      hasThinking: !!result.thinkingOutput,
+      responseLength: result.assistantResponse.length,
+    }, claudeCmd, true);
+
+    hlog(`[PM-RETRY] Premature completion check: ${verdict.isIncomplete ? 'INCOMPLETE' : 'COMPLETE'} — ${verdict.reason}`);
+    return verdict.isIncomplete;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Strategy 3: Premature completion.
+ * Claude hit max_tokens or ended early without finishing work.
+ * Resume the session with "continue".
+ */
+async function tryPrematureCompletionRetry(
+  state: IssueRetryState,
+  result: SessionResult,
+  config: IssueRunnerConfig,
+): Promise<boolean> {
+  if (!result.completed || result.signalName || state.retryNumber >= MAX_ISSUE_RETRIES) return false;
+  if (state.checkpoint) return false;
+  if (!result.claudeSessionId || !result.stopReason) return false;
+
+  const isMaxTokens = result.stopReason === 'max_tokens';
+  const isEndTurn = result.stopReason === 'end_turn';
+  if (!isMaxTokens && !isEndTurn) return false;
+
+  // max_tokens always continues; end_turn requires AI assessment
+  if (isEndTurn && !(await isEndTurnIncomplete(result))) return false;
+
+  state.retryNumber++;
+  state.lastSessionId = result.claudeSessionId;
+  state.currentPrompt = 'continue';
+
+  const reason = isMaxTokens ? 'Output limit reached' : 'Task appears unfinished';
+  hlog(`[PM-RETRY] Premature completion: ${reason}, resuming session, retry ${state.retryNumber}/${MAX_ISSUE_RETRIES}`);
+  config.outputCallback?.(`\n[PM-RETRY] ${reason} — resuming session (retry ${state.retryNumber}/${MAX_ISSUE_RETRIES}).\n`);
+
+  return true;
+}
+
+// ========== Helpers ==========
+
+function accumulateToolResults(result: SessionResult, state: IssueRetryState): void {
+  if (!result.toolUseHistory) return;
+  for (const t of result.toolUseHistory) {
+    if (t.result !== undefined) {
+      state.accumulatedToolResults.push({
+        toolName: t.toolName,
+        toolId: t.toolId,
+        toolInput: t.toolInput,
+        result: t.result,
+        isError: t.isError,
+        duration: t.duration,
+      });
+    }
+  }
+  if (state.accumulatedToolResults.length > MAX_ACCUMULATED_RESULTS) {
+    state.accumulatedToolResults = state.accumulatedToolResults.slice(-MAX_ACCUMULATED_RESULTS);
+  }
+}
+
+function scoreResult(r: SessionResult): number {
+  const toolCount = r.toolUseHistory?.filter(t => t.result !== undefined && !t.isError).length ?? 0;
+  const responseLen = Math.min((r.assistantResponse?.length ?? 0) / 50, 100);
+  const hasThinking = r.thinkingOutput ? 20 : 0;
+  return toolCount * 10 + responseLen + hasThinking;
+}

package/server/services/plan/review-gate.ts

@@ -53,7 +53,7 @@ export async function reviewIssue(options: ReviewIssueOptions): Promise<ReviewRe
       stallWarningMs: REVIEW_STALL_WARNING_MS,
       stallKillMs: REVIEW_STALL_KILL_MS,
       stallHardCapMs: REVIEW_STALL_HARD_CAP_MS,
-      verbose: false,
+      verbose: true,
       outputCallback: onOutput ? (text: string) => onOutput(`Review: ${text}`) : undefined,
     });
 
@@ -113,14 +113,25 @@ export function appendReviewFeedback(pmDir: string, issue: Issue, result: Review
   } catch { /* non-fatal */ }
 }
 
+/** Advance past a JSON string body (opening `"` already consumed). Returns index of closing `"`. */
+function skipJsonString(text: string, from: number): number {
+  for (let i = from; i < text.length; i++) {
+    if (text[i] === '\\') { i++; continue; }
+    if (text[i] === '"') return i;
+  }
+  return text.length;
+}
+
 /** Extract the outermost JSON object from AI output using brace balancing. */
 function extractJsonObject(text: string): string | null {
   const start = text.indexOf('{');
   if (start === -1) return null;
   let depth = 0;
   for (let i = start; i < text.length; i++) {
-    if (text[i] === '{') depth++;
-    else if (text[i] === '}') depth--;
+    const ch = text[i];
+    if (ch === '"') { i = skipJsonString(text, i + 1); continue; }
+    if (ch === '{') depth++;
+    else if (ch === '}') depth--;
     if (depth === 0) return text.slice(start, i + 1);
   }
   return null;

package/server/services/plan/state-reconciler.ts

@@ -109,6 +109,36 @@ function buildStateMarkdown(
   return `---\n${frontMatter}\n---\n\n${sections.join('\n')}`;
 }
 
+/**
+ * Derive epic status from its children's actual statuses.
+ * All children done/cancelled → done (auto-complete the epic).
+ */
+function deriveEpicDone(epic: Issue, issueByPath: Map<string, Issue>): boolean {
+  if (epic.children.length === 0) return false;
+  if (epic.status === 'done' || epic.status === 'cancelled') return false;
+
+  return epic.children.every(childPath => {
+    const child = issueByPath.get(childPath);
+    return child && (child.status === 'done' || child.status === 'cancelled');
+  });
+}
+
+function reconcileEpicStatuses(pmDir: string, issues: Issue[], issueByPath: Map<string, Issue>): void {
+  const epics = issues.filter(i => i.type === 'epic');
+  for (const epic of epics) {
+    if (!deriveEpicDone(epic, issueByPath)) continue;
+
+    const epicPath = join(pmDir, epic.path);
+    try {
+      let content = readFileSync(epicPath, 'utf-8');
+      content = replaceFrontMatterField(content, 'status', 'done');
+      writeFileSync(epicPath, content, 'utf-8');
+    } catch {
+      // Epic file may be missing or unwritable
+    }
+  }
+}
+
 /**
  * Derive sprint status from its issues' actual statuses.
  * - All issues done/cancelled → completed
@@ -155,6 +185,40 @@ function reconcileSprintStatuses(pmDir: string, sprints: Sprint[], issueByPath:
   }
 }
 
+/**
+ * After an issue is updated, check if its parent epic should be auto-completed.
+ * Returns the epic's relative path if it was marked done, null otherwise.
+ */
+export function tryCompleteParentEpic(workingDir: string, updatedIssue: Issue): string | null {
+  if (!updatedIssue.epic) return null;
+
+  const pmDir = resolvePmDir(workingDir);
+  if (!pmDir) return null;
+
+  // Determine which board the issue belongs to from its path
+  const boardMatch = updatedIssue.path.match(/^boards\/([^/]+)\//);
+  const issues = boardMatch
+    ? parseBoardDirectory(pmDir, boardMatch[1])?.issues
+    : parsePlanDirectory(workingDir)?.issues;
+  if (!issues) return null;
+
+  const epic = issues.find(i => i.path === updatedIssue.epic);
+  if (!epic) return null;
+
+  const issueByPath = new Map(issues.map(i => [i.path, i]));
+  if (!deriveEpicDone(epic, issueByPath)) return null;
+
+  const epicFullPath = join(pmDir, epic.path);
+  try {
+    let content = readFileSync(epicFullPath, 'utf-8');
+    content = replaceFrontMatterField(content, 'status', 'done');
+    writeFileSync(epicFullPath, content, 'utf-8');
+    return epic.path;
+  } catch {
+    return null;
+  }
+}
+
 export function reconcileState(workingDir: string, boardId?: string): void {
   const pmDir = resolvePmDir(workingDir);
   if (!pmDir) return;
@@ -183,7 +247,8 @@ export function reconcileState(workingDir: string, boardId?: string): void {
   const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
   const frontMatter = fmMatch ? fmMatch[1] : `project: "${project.name}"\ncurrent_sprint: null\nactive_milestone: null\npaused: false\nlast_session: null`;
 
-  // Reconcile sprint statuses from actual issue statuses
+  // Reconcile epic and sprint statuses from actual issue statuses
+  reconcileEpicStatuses(pmDir, issues, issueByPath);
   reconcileSprintStatuses(pmDir, sprints, issueByPath);
 
   // Update current_sprint in front matter based on actual sprint statuses
@@ -211,6 +276,10 @@ function reconcileBoardState(pmDir: string, _workingDir: string, boardId?: strin
   const { board, issues } = boardState;
 
   const issueByPath = new Map(issues.map(i => [i.path, i]));
+
+  // Reconcile epic statuses before categorizing
+  reconcileEpicStatuses(pmDir, issues, issueByPath);
+
   const categories = categorizeIssues(issues, issueByPath);
   const warnings = computeWarnings(issues);
 

package/server/services/platform.ts

@@ -21,7 +21,6 @@ import {
   updateCredentials,
 } from './platform-credentials.js'
 import { captureException } from './sentry.js'
-import { isBwrapAvailable } from './terminal/pty-utils.js'
 
 /**
  * Get machine identification string
@@ -40,8 +39,12 @@ let WebSocketImpl: typeof WebSocket
 if (typeof WebSocket !== 'undefined') {
   WebSocketImpl = WebSocket
 } else {
-  const { default: WS } = await import('ws')
-  WebSocketImpl = WS as unknown as typeof WebSocket
+  try {
+    const { default: WS } = await import('ws')
+    WebSocketImpl = WS as unknown as typeof WebSocket
+  } catch {
+    throw new Error('WebSocket not available: install the "ws" package or use Node.js 21+')
+  }
 }
 
 // PLATFORM_URL is set via --server / --dev flag in mstro.js
@@ -122,7 +125,7 @@ export class PlatformConnection {
 
   private startHeartbeat(): void {
     this.missedPongs = 0
-    this.heartbeatInterval = setInterval(() => this.heartbeatTick(), 2 * 60 * 1000)
+    this.heartbeatInterval = setInterval(() => this.heartbeatTick(), 25_000)
   }
 
   private heartbeatTick(): void {
@@ -186,7 +189,7 @@ export class PlatformConnection {
       osType,
       cpuArch,
       cliVersion: CLI_VERSION,
-      capabilities: JSON.stringify({ terminalSandbox: isBwrapAvailable() }),
+      capabilities: JSON.stringify({}),
       startedAt: this.startedAt,
     })
 
@@ -231,6 +234,7 @@ export class PlatformConnection {
     }
 
     this.ws.onclose = (event) => {
+      clearTimeout(connectionTimeout)
       this.stopHeartbeat()
       this.isConnected = false
 
@@ -254,6 +258,7 @@ export class PlatformConnection {
     }
 
     this.ws.onerror = () => {
+      clearTimeout(connectionTimeout)
       // onclose will be called after this
     }
   }
@@ -275,6 +280,10 @@ export class PlatformConnection {
         this.callbacks.onWebDisconnected?.()
         trackEvent(AnalyticsEvents.WEB_CLIENT_DISCONNECTED)
         break
+      case 'ping':
+        // Server-initiated ping — respond with pong to reset stale detection
+        this.send({ type: 'pong' })
+        break
       case 'pong':
         this.missedPongs = 0
         break
@@ -293,7 +302,9 @@ export class PlatformConnection {
     }
 
     this.reconnectAttempts++
-    const delay = Math.min(1000 * 2 ** (this.reconnectAttempts - 1), 30000)
+    const base = Math.min(1000 * 2 ** (this.reconnectAttempts - 1), 30000)
+    const jitter = base * 0.25 * (2 * Math.random() - 1)
+    const delay = Math.max(0, Math.round(base + jitter))
 
     this.reconnectTimeout = setTimeout(() => {
       this.reconnectTimeout = null

package/server/services/terminal/pty-manager.ts

@@ -10,17 +10,14 @@
 
 import { EventEmitter } from 'node:events';
 import { homedir, platform } from 'node:os';
-import { sanitizeEnvForSandbox } from '../sandbox-utils.js';
 import type { PTYSession } from './pty-utils.js';
 import {
-  buildBwrapArgs,
   detectShell,
   getPty,
   getPtyInstallInstructions,
   getShellName,
-  isBwrapAvailable,
   isPtyAvailable,
-  SCROLLBACK_MAX_BYTES,
+  SCROLLBACK_MAX_LENGTH,
   ScrollbackBuffer,
 } from './pty-utils.js';
 
@@ -54,14 +51,13 @@ export class PTYManager extends EventEmitter {
     return getPtyInstallInstructions();
   }
 
-  create(
+  async create(
     terminalId: string,
     workingDir: string,
     cols: number = 80,
     rows: number = 24,
     requestedShell?: string,
-    options?: { sandboxed?: boolean }
-  ): { shell: string; cwd: string; isReconnect: boolean; platform: string } {
+  ): Promise<{ shell: string; cwd: string; isReconnect: boolean; platform: string }> {
     const pty = getPty();
     if (!pty) {
       throw new Error(`PTY_NOT_AVAILABLE:${getPtyInstallInstructions()}`);
@@ -80,32 +76,9 @@ export class PTYManager extends EventEmitter {
     const cwd = workingDir || homedir();
 
     try {
-      const baseEnv = options?.sandboxed
-        ? sanitizeEnvForSandbox(process.env, cwd)
-        : { ...process.env, HOME: homedir() };
-      const env = { ...baseEnv, TERM: 'xterm-256color', COLORTERM: 'truecolor' };
+      const env = { ...process.env, HOME: homedir(), TERM: 'xterm-256color', COLORTERM: 'truecolor' };
 
-      // Sandboxed terminals use bubblewrap (bwrap) for filesystem isolation.
-      // The shell is spawned inside a namespace that only sees the project directory (rw)
-      // and system directories (ro). Without bwrap, sandboxed terminals are not available.
-      let spawnCommand: string;
-      let spawnArgs: string[];
-      let spawnCwd: string;
-
-      if (options?.sandboxed) {
-        if (!isBwrapAvailable()) {
-          throw new Error('SANDBOX_UNAVAILABLE:Terminal sandbox (bubblewrap) is not installed on this machine. Shared terminal sessions require bubblewrap for filesystem isolation.');
-        }
-        spawnCommand = '/usr/bin/bwrap';
-        spawnArgs = buildBwrapArgs(cwd, shell);
-        spawnCwd = '/'; // bwrap manages cwd internally via --chdir
-      } else {
-        spawnCommand = shell;
-        spawnArgs = [];
-        spawnCwd = cwd;
-      }
-
-      const ptyProcess = pty.spawn(spawnCommand, spawnArgs, { name: 'xterm-256color', cols, rows, cwd: spawnCwd, env });
+      const ptyProcess = pty.spawn(shell, [], { name: 'xterm-256color', cols, rows, cwd, env });
 
       const session: PTYSession = {
         id: terminalId,
@@ -118,7 +91,7 @@ export class PTYManager extends EventEmitter {
         rows,
         _outputBuffer: '',
         _outputTimer: null,
-        scrollback: new ScrollbackBuffer(SCROLLBACK_MAX_BYTES),
+        scrollback: new ScrollbackBuffer(SCROLLBACK_MAX_LENGTH),
       };
       this.terminals.set(terminalId, session);
 

package/server/services/terminal/pty-utils.ts

@@ -8,8 +8,6 @@
  * on session lifecycle orchestration.
  */
 
-import { execSync } from 'node:child_process';
-import { accessSync, constants as fsConstants, lstatSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import { platform } from 'node:os';
 
@@ -117,89 +115,13 @@ export function getShellName(shellPath: string): string {
   return parts[parts.length - 1] || 'shell';
 }
 
-// ── Bubblewrap (bwrap) sandbox detection ─────────────────────
-
-let _bwrapAvailable: boolean | null = null;
-
-/**
- * Check if bubblewrap (bwrap) is available for filesystem sandboxing.
- * Required for sandboxed terminal sessions (shared "can control" users).
- * Caches the result after first check.
- */
-export function isBwrapAvailable(): boolean {
-  if (_bwrapAvailable !== null) return _bwrapAvailable;
-
-  if (platform() !== 'linux') {
-    _bwrapAvailable = false;
-    return false;
-  }
-
-  try {
-    accessSync('/usr/bin/bwrap', fsConstants.X_OK);
-    execSync('bwrap --ro-bind / / -- /bin/true', { timeout: 5000, stdio: 'ignore' });
-    _bwrapAvailable = true;
-  } catch {
-    _bwrapAvailable = false;
-  }
-  return _bwrapAvailable;
-}
-
-/**
- * Build bwrap arguments to sandbox a shell to a specific directory.
- * Provides read-only access to system directories, read-write to the project dir only.
- */
-export function buildBwrapArgs(cwd: string, shell: string): string[] {
-  const mergedUsr = (() => {
-    try { return lstatSync('/bin').isSymbolicLink(); }
-    catch { return false; }
-  })();
-
-  const args: string[] = [
-    '--ro-bind', '/usr', '/usr',
-    '--ro-bind', '/etc', '/etc',
-    // Hide sensitive /etc files by binding /dev/null over them
-    '--ro-bind', '/dev/null', '/etc/shadow',
-    '--ro-bind', '/dev/null', '/etc/gshadow',
-  ];
-
-  if (mergedUsr) {
-    // Merged-usr distros (Fedora, Ubuntu 20.04+, Arch, Debian 12+)
-    args.push('--symlink', 'usr/bin', '/bin');
-    args.push('--symlink', 'usr/sbin', '/sbin');
-    args.push('--symlink', 'usr/lib', '/lib');
-    try { lstatSync('/lib64'); args.push('--symlink', 'usr/lib64', '/lib64'); } catch { /* skip */ }
-  } else {
-    args.push('--ro-bind', '/bin', '/bin');
-    args.push('--ro-bind', '/sbin', '/sbin');
-    args.push('--ro-bind', '/lib', '/lib');
-    try { lstatSync('/lib64'); args.push('--ro-bind', '/lib64', '/lib64'); } catch { /* skip */ }
-  }
-
-  args.push(
-    '--proc', '/proc',
-    '--dev', '/dev',
-    '--tmpfs', '/tmp',
-    '--tmpfs', '/run',
-    // Read-write access to the project directory only
-    '--bind', cwd, cwd,
-    '--unshare-pid',
-    '--unshare-ipc',
-    '--die-with-parent',
-    '--chdir', cwd,
-    '--',
-    shell,
-  );
-
-  return args;
-}
-
 // ── Scrollback buffer ─────────────────────────────────────────
 
-export const SCROLLBACK_MAX_BYTES = 256 * 1024; // 256KB
+export const SCROLLBACK_MAX_LENGTH = 256 * 1024; // ~256K characters
 
 /**
  * Fixed-size buffer that retains the most recent PTY output for replay on reconnect.
- * Stores raw string chunks and evicts oldest data when the total exceeds maxBytes.
+ * Stores raw string chunks and evicts oldest data when the total exceeds maxLength.
  */
 export class ScrollbackBuffer {
   private chunks: string[] = [];