bosun 0.29.2 → 0.29.3

package/.env.example

@@ -482,7 +482,7 @@ TELEGRAM_MINIAPP_ENABLED=false
 # CODEX_FEATURES_CHILD_AGENTS_MD=true     # Sub-agent discovery via CODEX.md (KEY for sub-agents)
 # CODEX_FEATURES_MEMORY_TOOL=true         # Persistent memory across sessions
 # CODEX_FEATURES_UNDO=true                # Undo/rollback support
-# CODEX_FEATURES_COLLAB=true              # Collaboration mode
+# CODEX_FEATURES_MULTI_AGENT=true         # Multi Agent mode
 # CODEX_FEATURES_COLLABORATION_MODES=true # Mode selection for collaboration
 # CODEX_FEATURES_STEER=true               # Steering/guidance
 # CODEX_FEATURES_APPS=true                # ChatGPT Apps integration

package/agent-pool.mjs

@@ -570,7 +570,7 @@ async function launchCodexThread(prompt, cwd, timeoutMs, extra = {}) {
     ...(codexOpts.config || {}),
     features: {
       child_agents_md: true,
-      collab: true,
+      multi_agent: true,
       memory_tool: true,
       undo: true,
       steer: true,

package/cli.mjs

@@ -118,6 +118,7 @@ function showHelp() {
     --workspace-add <name>      Create a new workspace
     --workspace-switch <id>     Switch active workspace
     --workspace-add-repo        Add repo to workspace (interactive)
+    --workspace-health          Run workspace health diagnostics
 
   TASK MANAGEMENT
     task list [--status s] [--json]  List tasks with optional filters
@@ -914,6 +915,17 @@ async function main() {
     process.exit(0);
   }
 
+  // Handle --workspace-health / --verify-workspace
+  if (args.includes("--workspace-health") || args.includes("--verify-workspace") || args.includes("workspace-health")) {
+    const { runWorkspaceHealthCheck, formatWorkspaceHealthReport } =
+      await import("./config-doctor.mjs");
+    const configDirArg = getArgValue("--config-dir");
+    const configDir = configDirArg || process.env.BOSUN_DIR || resolve(os.homedir(), "bosun");
+    const result = runWorkspaceHealthCheck({ configDir });
+    console.log(formatWorkspaceHealthReport(result));
+    process.exit(result.ok ? 0 : 1);
+  }
+
   // Handle --setup
   if (args.includes("--setup") || args.includes("setup")) {
     const configDirArg = getArgValue("--config-dir");

package/codex-config.mjs

@@ -13,8 +13,8 @@
  * append or patch well-known sections rather than rewriting the whole file.
  */
 
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
-import { resolve, dirname } from "node:path";
+import { existsSync, readFileSync, writeFileSync, mkdirSync, statSync } from "node:fs";
+import { resolve, dirname, parse } from "node:path";
 import { homedir } from "node:os";
 import { fileURLToPath } from "node:url";
 import { resolveCodexProfileRuntime } from "./codex-model-profiles.mjs";
@@ -100,7 +100,7 @@ const buildAgentsBlock = (_maxThreads) =>
 const RECOMMENDED_FEATURES = {
   // Sub-agents & collaboration
   child_agents_md:        { default: true, envVar: "CODEX_FEATURES_CHILD_AGENTS_MD",   comment: "Enable sub-agent discovery via CODEX.md" },
-  collab:                 { default: true, envVar: "CODEX_FEATURES_COLLAB",             comment: "Enable collaboration mode" },
+  multi_agent:                 { default: true, envVar: "CODEX_FEATURES_MULTI_AGENT",             comment: "Enable collaboration mode" },
   collaboration_modes:    { default: true, envVar: "CODEX_FEATURES_COLLABORATION_MODES", comment: "Enable collaboration mode selection" },
 
   // Continuity & recovery
@@ -128,7 +128,7 @@ const RECOMMENDED_FEATURES = {
 const CRITICAL_ALWAYS_ON_FEATURES = new Set([
   "child_agents_md",
   "memory_tool",
-  "collab",
+  "multi_agent",
   "collaboration_modes",
   "shell_tool",
   "unified_exec",
@@ -416,6 +416,10 @@ function normalizeWritableRoots(input, { repoRoot, additionalRoots } = {}) {
   const addRoot = (value) => {
     const trimmed = String(value || "").trim();
     if (!trimmed) return;
+    // Reject bare relative paths like ".git" — they resolve relative to CWD
+    // at Codex launch time and cause "writable root does not exist" errors
+    // (e.g. /home/user/.codex/.git). Only accept absolute paths.
+    if (!trimmed.startsWith("/")) return;
     roots.add(trimmed);
   };
   if (Array.isArray(input)) {
@@ -428,14 +432,17 @@ function normalizeWritableRoots(input, { repoRoot, additionalRoots } = {}) {
       .forEach(addRoot);
   }
 
-  // Add paths for primary repo root
+  // Add paths for a repo root — only if it's a non-empty absolute path
   const addRepoRootPaths = (repo) => {
     if (!repo) return;
-    const r = String(repo);
-    if (!r) return;
+    const r = String(repo).trim();
+    if (!r || !r.startsWith("/")) return;
     addRoot(r);
-    addRoot(resolve(r, ".git"));
-    addRoot(resolve(r, ".cache", "worktrees"));
+    const gitDir = resolve(r, ".git");
+    // Only add .git if it actually exists (prevents phantom writable roots)
+    if (existsSync(gitDir)) addRoot(gitDir);
+    const cacheWorktrees = resolve(r, ".cache", "worktrees");
+    addRoot(cacheWorktrees);
     addRoot(resolve(r, ".cache"));
     const parent = dirname(r);
     if (parent && parent !== r) addRoot(parent);
@@ -451,11 +458,91 @@ function normalizeWritableRoots(input, { repoRoot, additionalRoots } = {}) {
   }
 
   // /tmp is needed for sandbox temp files, pip installs, etc.
-  addRoot("/tmp");
+  roots.add("/tmp");
 
   return Array.from(roots);
 }
 
+/**
+ * Validate that a directory has a valid .git ancestor (regular repo or worktree).
+ * In worktrees, .git is a file containing "gitdir: <path>" — follow the reference
+ * to find the actual git object store. Returns the resolved .git directory path
+ * or null if not found.
+ * @param {string} dir - Directory to check
+ * @returns {{ gitDir: string|null, mainWorktreeRoot: string|null, isWorktree: boolean }}
+ */
+export function ensureGitAncestor(dir) {
+  if (!dir) return { gitDir: null, mainWorktreeRoot: null, isWorktree: false };
+  let current = resolve(dir);
+  const { root } = parse(current);
+  while (current !== root) {
+    const gitPath = resolve(current, ".git");
+    if (existsSync(gitPath)) {
+      try {
+        const stat = statSync(gitPath);
+        if (stat.isDirectory()) {
+          // Regular git repo
+          return { gitDir: gitPath, mainWorktreeRoot: current, isWorktree: false };
+        }
+        if (stat.isFile()) {
+          // Worktree: .git is a file with "gitdir: <relative-or-absolute-path>"
+          const content = readFileSync(gitPath, "utf8").trim();
+          const match = content.match(/^gitdir:\s*(.+)$/);
+          if (match) {
+            const gitdirRef = resolve(current, match[1].trim());
+            // Worktree gitdir points to <main-repo>/.git/worktrees/<name>
+            // Walk up 2 levels to get the main .git directory
+            const mainGitDir = resolve(gitdirRef, "..", "..");
+            const mainRepoRoot = dirname(mainGitDir);
+            return {
+              gitDir: mainGitDir,
+              mainWorktreeRoot: mainRepoRoot,
+              isWorktree: true,
+            };
+          }
+        }
+      } catch { /* permission error, race, etc. */ }
+    }
+    current = dirname(current);
+  }
+  return { gitDir: null, mainWorktreeRoot: null, isWorktree: false };
+}
+
+/**
+ * Build writable roots for a specific task's execution context.
+ * Combines the global config roots with task-specific paths (worktree, repo root).
+ * @param {{ worktreePath?: string, repoRoot?: string, existingRoots?: string[] }} opts
+ * @returns {string[]} Merged writable roots
+ */
+export function buildTaskWritableRoots({ worktreePath, repoRoot, existingRoots = [] } = {}) {
+  const roots = new Set(existingRoots.filter(r => r && r.startsWith("/")));
+  const addIfExists = (p) => {
+    if (p && p.startsWith("/")) roots.add(p);
+  };
+
+  if (worktreePath) {
+    addIfExists(worktreePath);
+    // Worktrees have a .git file pointing to main repo — resolve the actual git dir
+    const ancestor = ensureGitAncestor(worktreePath);
+    if (ancestor.gitDir) addIfExists(ancestor.gitDir);
+    if (ancestor.mainWorktreeRoot) {
+      addIfExists(resolve(ancestor.mainWorktreeRoot, ".git"));
+      addIfExists(resolve(ancestor.mainWorktreeRoot, ".cache", "worktrees"));
+    }
+  }
+  if (repoRoot) {
+    addIfExists(repoRoot);
+    const gitDir = resolve(repoRoot, ".git");
+    if (existsSync(gitDir)) addIfExists(gitDir);
+    addIfExists(resolve(repoRoot, ".cache", "worktrees"));
+    addIfExists(resolve(repoRoot, ".cache"));
+    const parent = dirname(repoRoot);
+    if (parent && parent !== repoRoot) addIfExists(parent);
+  }
+  roots.add("/tmp");
+  return Array.from(roots);
+}
+
 export function hasSandboxWorkspaceWrite(toml) {
   return /^\[sandbox_workspace_write\]/m.test(toml);
 }
@@ -1114,7 +1201,7 @@ export function ensureCodexConfig({
   // ── 1f. Ensure sandbox workspace-write defaults ───────────
 
   {
-    // Determine primary repo root and any workspace roots
+    // Determine primary repo root — prefer workspace agent root
     const primaryRepoRoot = env.BOSUN_AGENT_REPO_ROOT || env.REPO_ROOT || "";
     const additionalRoots = [];
     // If agent repo root differs from REPO_ROOT, include both
@@ -1122,6 +1209,27 @@ export function ensureCodexConfig({
         env.BOSUN_AGENT_REPO_ROOT !== env.REPO_ROOT) {
       additionalRoots.push(env.REPO_ROOT);
     }
+    // Enumerate ALL workspace repo paths so every repo's .git/.cache is writable
+    try {
+      // Inline workspace config read (sync) — avoids async import in sync function
+      const configDirGuess = env.BOSUN_DIR || resolve(homedir(), "bosun");
+      const bosunConfigPath = resolve(configDirGuess, "bosun.config.json");
+      if (existsSync(bosunConfigPath)) {
+        const bosunCfg = JSON.parse(readFileSync(bosunConfigPath, "utf8"));
+        const wsDir = resolve(configDirGuess, "workspaces");
+        const allWs = Array.isArray(bosunCfg.workspaces) ? bosunCfg.workspaces : [];
+        for (const ws of allWs) {
+          const wsPath = resolve(wsDir, ws.id || ws.name || "");
+          for (const repo of ws.repos || []) {
+            const repoPath = resolve(wsPath, repo.name);
+            if (repoPath && !additionalRoots.includes(repoPath) &&
+                repoPath !== primaryRepoRoot) {
+              additionalRoots.push(repoPath);
+            }
+          }
+        }
+      }
+    } catch { /* workspace config read failed — skip */ }
     const ensured = ensureSandboxWorkspaceWrite(toml, {
       writableRoots: env.CODEX_SANDBOX_WRITABLE_ROOTS || "",
       repoRoot: primaryRepoRoot,

package/codex-shell.mjs

@@ -222,7 +222,7 @@ const THREAD_OPTIONS = {
   skipGitRepoCheck: true,
   webSearchMode: "live",
   approvalPolicy: "never",
-  // Note: sub-agent features (child_agents_md, collab, memory_tool, etc.)
+  // Note: sub-agent features (child_agents_md, multi_agent, memory_tool, etc.)
   // are configured via ~/.codex/config.toml [features] section, not SDK ThreadOptions.
   // codex-config.mjs ensureFeatureFlags() handles this during setup.
 };
@@ -247,7 +247,7 @@ async function getThread() {
       config: {
         features: {
           child_agents_md: true,
-          collab: true,
+          multi_agent: true,
           memory_tool: true,
           undo: true,
           steer: true,
@@ -746,7 +746,7 @@ export async function initCodexShell() {
       config: {
         features: {
           child_agents_md: true,
-          collab: true,
+          multi_agent: true,
           memory_tool: true,
           undo: true,
           steer: true,

package/config-doctor.mjs

@@ -699,3 +699,247 @@ export function formatConfigDoctorReport(result) {
 
   return lines.join("\n");
 }
+
+/**
+ * Run workspace-specific health checks.
+ * Validates workspace repos, git status, writable roots, worktree health.
+ * @param {{ configDir?: string, repoRoot?: string }} options
+ * @returns {{ ok: boolean, workspaces: Array, issues: { errors: Array, warnings: Array, infos: Array } }}
+ */
+export function runWorkspaceHealthCheck(options = {}) {
+  const configDir = options.configDir || process.env.BOSUN_DIR || join(homedir(), "bosun");
+  const repoRoot = options.repoRoot || process.cwd();
+  const issues = { errors: [], warnings: [], infos: [] };
+  const workspaceResults = [];
+
+  // 1. Check if workspaces are configured
+  let workspaces = [];
+  try {
+    const configPath = join(configDir, "bosun.config.json");
+    if (existsSync(configPath)) {
+      const config = JSON.parse(readFileSync(configPath, "utf8"));
+      workspaces = config.workspaces || [];
+    }
+  } catch (err) {
+    issues.errors.push({
+      code: "WS_CONFIG_READ_FAILED",
+      message: `Failed to read workspace config: ${err.message}`,
+      fix: "Check bosun.config.json is valid JSON",
+    });
+  }
+
+  if (workspaces.length === 0) {
+    issues.infos.push({
+      code: "WS_NONE_CONFIGURED",
+      message: "No workspaces configured — agents use developer repo directly.",
+      fix: "Run 'bosun --workspace-add <name>' to create a workspace for isolated agent execution.",
+    });
+    return { ok: true, workspaces: workspaceResults, issues };
+  }
+
+  // 2. Check each workspace
+  for (const ws of workspaces) {
+    const wsResult = {
+      id: ws.id || "unknown",
+      name: ws.name || ws.id || "unnamed",
+      path: ws.path || "",
+      repos: [],
+      ok: true,
+    };
+
+    // 2a. Workspace directory exists
+    const wsPath = ws.path || join(configDir, "workspaces", ws.id || ws.name);
+    if (!existsSync(wsPath)) {
+      issues.warnings.push({
+        code: "WS_DIR_MISSING",
+        message: `Workspace "${wsResult.name}" directory missing: ${wsPath}`,
+        fix: `Run 'bosun --setup' or mkdir -p "${wsPath}"`,
+      });
+      wsResult.ok = false;
+    }
+
+    // 2b. Check repos in workspace
+    for (const repo of ws.repos || []) {
+      const repoName = repo.name || repo.slug || "unknown";
+      const repoPath = join(wsPath, repoName);
+      const repoStatus = { name: repoName, path: repoPath, ok: true, issues: [] };
+
+      if (!existsSync(repoPath)) {
+        repoStatus.ok = false;
+        repoStatus.issues.push("directory missing");
+        issues.errors.push({
+          code: "WS_REPO_MISSING",
+          message: `Workspace repo "${repoName}" not found at ${repoPath}`,
+          fix: `Run 'bosun --workspace-add-repo <url>' or 'bosun --setup' to clone it`,
+        });
+      } else {
+        const gitPath = join(repoPath, ".git");
+        if (!existsSync(gitPath)) {
+          repoStatus.ok = false;
+          repoStatus.issues.push(".git missing");
+          issues.errors.push({
+            code: "WS_REPO_NO_GIT",
+            message: `Workspace repo "${repoName}" has no .git at ${repoPath}`,
+            fix: `Clone the repo: git clone <url> "${repoPath}"`,
+          });
+        } else {
+          // Check remote connectivity (quick)
+          try {
+            const branch = execSync("git rev-parse --abbrev-ref HEAD", {
+              cwd: repoPath, encoding: "utf8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"],
+            }).trim();
+            repoStatus.branch = branch;
+            repoStatus.issues.push(`on branch: ${branch}`);
+          } catch {
+            repoStatus.issues.push("git status check failed");
+          }
+
+          // Check for uncommitted changes
+          try {
+            const status = execSync("git status --porcelain", {
+              cwd: repoPath, encoding: "utf8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"],
+            }).trim();
+            if (status) {
+              const lines = status.split("\n").length;
+              repoStatus.issues.push(`${lines} uncommitted change(s)`);
+              issues.infos.push({
+                code: "WS_REPO_DIRTY",
+                message: `Workspace repo "${repoName}" has ${lines} uncommitted change(s)`,
+                fix: null,
+              });
+            }
+          } catch { /* ignore */ }
+        }
+      }
+
+      wsResult.repos.push(repoStatus);
+      if (!repoStatus.ok) wsResult.ok = false;
+    }
+
+    workspaceResults.push(wsResult);
+  }
+
+  // 3. Check Codex sandbox writable_roots coverage
+  const codexConfigPath = join(homedir(), ".codex", "config.toml");
+  if (existsSync(codexConfigPath)) {
+    try {
+      const toml = readFileSync(codexConfigPath, "utf8");
+      const rootsMatch = toml.match(/writable_roots\s*=\s*\[([^\]]*)\]/);
+      if (rootsMatch) {
+        const roots = rootsMatch[1].split(",").map(r => r.trim().replace(/^"|"$/g, "")).filter(Boolean);
+        for (const ws of workspaces) {
+          const wsPath = ws.path || join(configDir, "workspaces", ws.id || ws.name);
+          for (const repo of ws.repos || []) {
+            const repoPath = join(wsPath, repo.name || repo.slug || "");
+            const gitPath = join(repoPath, ".git");
+            if (existsSync(gitPath) && !roots.some(r => gitPath.startsWith(r) || r === gitPath)) {
+              issues.warnings.push({
+                code: "WS_SANDBOX_MISSING_ROOT",
+                message: `Workspace repo .git not in Codex writable_roots: ${gitPath}`,
+                fix: `Run 'bosun --setup' to update Codex sandbox config, or add "${gitPath}" to writable_roots in ~/.codex/config.toml`,
+              });
+            }
+          }
+        }
+
+        // Check for phantom/relative writable roots
+        for (const root of roots) {
+          if (!root.startsWith("/")) {
+            issues.warnings.push({
+              code: "WS_SANDBOX_RELATIVE_ROOT",
+              message: `Relative path in Codex writable_roots: "${root}" — may resolve incorrectly`,
+              fix: `Remove "${root}" from writable_roots in ~/.codex/config.toml and run 'bosun --setup'`,
+            });
+          } else if (!existsSync(root) && root !== "/tmp") {
+            issues.infos.push({
+              code: "WS_SANDBOX_PHANTOM_ROOT",
+              message: `Codex writable_root path does not exist: ${root}`,
+              fix: null,
+            });
+          }
+        }
+      }
+    } catch { /* ignore parse errors */ }
+  }
+
+  // 4. Check BOSUN_AGENT_REPO_ROOT
+  const agentRoot = process.env.BOSUN_AGENT_REPO_ROOT || "";
+  if (agentRoot) {
+    if (!existsSync(agentRoot)) {
+      issues.warnings.push({
+        code: "WS_AGENT_ROOT_MISSING",
+        message: `BOSUN_AGENT_REPO_ROOT points to non-existent path: ${agentRoot}`,
+        fix: "Run 'bosun --setup' to bootstrap workspace repos",
+      });
+    } else if (!existsSync(join(agentRoot, ".git"))) {
+      issues.warnings.push({
+        code: "WS_AGENT_ROOT_NO_GIT",
+        message: `BOSUN_AGENT_REPO_ROOT has no .git: ${agentRoot}`,
+        fix: "Clone the repo at the workspace path or update BOSUN_AGENT_REPO_ROOT",
+      });
+    } else {
+      issues.infos.push({
+        code: "WS_AGENT_ROOT_OK",
+        message: `Agent repo root: ${agentRoot}`,
+        fix: null,
+      });
+    }
+  }
+
+  const hasErrors = issues.errors.length > 0;
+  return { ok: !hasErrors, workspaces: workspaceResults, issues };
+}
+
+/**
+ * Format workspace health report for CLI output.
+ * @param {{ ok: boolean, workspaces: Array, issues: object }} result
+ * @returns {string}
+ */
+export function formatWorkspaceHealthReport(result) {
+  const lines = [];
+  lines.push("=== bosun workspace health ===");
+  lines.push(`Status: ${result.ok ? "HEALTHY" : "ISSUES FOUND"}`);
+  lines.push("");
+
+  if (result.workspaces.length === 0) {
+    lines.push("  No workspaces configured.");
+    lines.push("");
+  }
+
+  for (const ws of result.workspaces) {
+    const icon = ws.ok ? "✓" : "✗";
+    lines.push(`  ${icon} ${ws.name} (${ws.id})`);
+    for (const repo of ws.repos) {
+      const rIcon = repo.ok ? "✓" : "✗";
+      const details = repo.issues.length > 0 ? ` — ${repo.issues.join(", ")}` : "";
+      lines.push(`    ${rIcon} ${repo.name}${details}`);
+    }
+  }
+  lines.push("");
+
+  if (result.issues.errors.length > 0) {
+    lines.push("Errors:");
+    for (const e of result.issues.errors) {
+      lines.push(`  ✗ ${e.message}`);
+      if (e.fix) lines.push(`    fix: ${e.fix}`);
+    }
+    lines.push("");
+  }
+  if (result.issues.warnings.length > 0) {
+    lines.push("Warnings:");
+    for (const w of result.issues.warnings) {
+      lines.push(`  ⚠ ${w.message}`);
+      if (w.fix) lines.push(`    fix: ${w.fix}`);
+    }
+    lines.push("");
+  }
+  if (result.issues.infos.length > 0) {
+    lines.push("Info:");
+    for (const i of result.issues.infos) {
+      lines.push(`  ℹ ${i.message}`);
+    }
+    lines.push("");
+  }
+
+  return lines.join("\n");
+}

package/monitor.mjs

@@ -593,6 +593,37 @@ if (effectiveRepoRoot && process.cwd() !== effectiveRepoRoot) {
   }
 }
 
+// ── Periodic Workspace Sync ─────────────────────────────────────────────────
+// Every 30 minutes, fetch latest changes for all workspace repos so agents
+// always work against recent upstream. Only runs if workspaces are configured.
+const WORKSPACE_SYNC_INTERVAL_MS = 30 * 60 * 1000; // 30 minutes
+let workspaceSyncTimer = null;
+{
+  const wsArray = config.repositories?.filter((r) => r.workspace) || [];
+  if (wsArray.length > 0) {
+    const workspaceIds = [...new Set(wsArray.map((r) => r.workspace).filter(Boolean))];
+    const doWorkspaceSync = () => {
+      for (const wsId of workspaceIds) {
+        try {
+          const results = pullWorkspaceRepos(config.configDir, wsId);
+          const failed = results.filter((r) => !r.success);
+          if (failed.length > 0) {
+            console.warn(`[monitor] workspace sync: ${failed.length} repo(s) failed in ${wsId}`);
+          } else {
+            console.log(`[monitor] workspace sync: ${wsId} up to date (${results.length} repos)`);
+          }
+        } catch (err) {
+          console.warn(`[monitor] workspace sync failed for ${wsId}: ${err.message}`);
+        }
+      }
+    };
+    workspaceSyncTimer = setInterval(doWorkspaceSync, WORKSPACE_SYNC_INTERVAL_MS);
+    // Unref so the timer doesn't keep the process alive during shutdown
+    if (workspaceSyncTimer?.unref) workspaceSyncTimer.unref();
+    console.log(`[monitor] workspace sync: scheduled every ${WORKSPACE_SYNC_INTERVAL_MS / 60000} min for ${workspaceIds.length} workspace(s)`);
+  }
+}
+
 console.log(`[monitor] task planner mode: ${plannerMode}`);
 console.log(`[monitor] kanban backend: ${kanbanBackend}`);
 console.log(`[monitor] executor mode: ${executorMode}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bosun",
-  "version": "0.29.2",
+  "version": "0.29.3",
   "description": "AI-powered orchestrator supervisor — manages AI agent executors with failover, auto-restarts on failure, analyzes crashes with Codex SDK, creates PRs via Vibe-Kanban API, and sends Telegram notifications. Supports N executors with weighted distribution, multi-repo projects, and auto-setup.",
   "type": "module",
   "license": "Apache 2.0",

package/task-executor.mjs

@@ -3717,6 +3717,7 @@ class TaskExecutor {
         "BOSUN_TASK_ID", "BOSUN_TASK_TITLE", "BOSUN_TASK_DESCRIPTION",
         "BOSUN_BRANCH_NAME", "BOSUN_WORKTREE_PATH", "BOSUN_SDK", "BOSUN_MANAGED",
         "BOSUN_REPO_ROOT", "BOSUN_REPO_SLUG", "BOSUN_WORKSPACE", "BOSUN_REPOSITORY",
+        "BOSUN_AGENT_REPO_ROOT",
       ];
       const _savedEnv = {};
       for (const k of _savedEnvKeys) _savedEnv[k] = process.env[k];
@@ -3746,6 +3747,9 @@ class TaskExecutor {
       process.env.BOSUN_REPO_SLUG       = executionRepoSlug;
       process.env.BOSUN_WORKSPACE       = taskRepoContext.workspace || "";
       process.env.BOSUN_REPOSITORY      = taskRepoContext.repository || "";
+      // Enforce workspace isolation: agents must resolve repo root from the
+      // workspace-scoped executionRepoRoot, NOT the developer's personal repo.
+      process.env.BOSUN_AGENT_REPO_ROOT = executionRepoRoot;
 
       const attemptId = `${taskId}-${randomUUID()}`;
       const taskMeta = {

package/ui/components/chat-view.js

@@ -4,6 +4,7 @@
  *  tracking, and pending/retry message support.
  * ────────────────────────────────────────────────────────────── */
 import { h } from "preact";
+import { memo } from "preact/compat";
 import { useState, useEffect, useRef, useCallback, useMemo } from "preact/hooks";
 import htm from "htm";
 import { apiFetch } from "../modules/api.js";
@@ -151,8 +152,23 @@ function renderMarkdown(text) {
   return result;
 }
 
+/* ─── Markdown render cache — avoids re-parsing identical content ─── */
+const _mdCache = new Map();
+const MD_CACHE_MAX = 500;
+function cachedRenderMarkdown(text) {
+  if (_mdCache.has(text)) return _mdCache.get(text);
+  const html = renderMarkdown(text);
+  if (_mdCache.size >= MD_CACHE_MAX) {
+    // Evict oldest quarter when full
+    const keys = Array.from(_mdCache.keys()).slice(0, MD_CACHE_MAX >> 2);
+    for (const k of keys) _mdCache.delete(k);
+  }
+  _mdCache.set(text, html);
+  return html;
+}
+
 /* ─── Code block copy button ─── */
-function CodeBlock({ code }) {
+const CodeBlock = memo(function CodeBlock({ code }) {
   const [copied, setCopied] = useState(false);
   const handleCopy = useCallback(() => {
     try {
@@ -170,10 +186,10 @@ function CodeBlock({ code }) {
       <pre><code>${code}</code></pre>
     </div>
   `;
-}
+});
 
 /* ─── Render message content with code block + markdown support ─── */
-function MessageContent({ text }) {
+const MessageContent = memo(function MessageContent({ text }) {
   if (!text) return null;
   const parts = text.split(/(```[\s\S]*?```)/g);
   return html`${parts.map((part, i) => {
@@ -181,9 +197,9 @@ function MessageContent({ text }) {
       const code = part.slice(3, -3).replace(/^\w+\n/, "");
       return html`<${CodeBlock} key=${i} code=${code} />`;
     }
-    return html`<div key=${i} class="md-rendered" dangerouslySetInnerHTML=${{ __html: renderMarkdown(part) }} />`;
+    return html`<div key=${i} class="md-rendered" dangerouslySetInnerHTML=${{ __html: cachedRenderMarkdown(part) }} />`;
   })}`;
-}
+});
 
 /* ─── Stream helpers ─── */
 function categorizeMessage(msg) {
@@ -206,6 +222,42 @@ function formatMessageLine(msg) {
   return `[${timestamp}] ${String(kind).toUpperCase()}: ${content}`;
 }
 
+/* ─── Memoized ChatBubble — only re-renders if msg identity changes ─── */
+const ChatBubble = memo(function ChatBubble({ msg }) {
+  const isTool = msg.type === "tool_call" || msg.type === "tool_result";
+  const isError = msg.type === "error" || msg.type === "stream_error";
+  const role = msg.role ||
+    (isTool || isError ? "system" : msg.type === "system" ? "system" : "assistant");
+  const bubbleClass = isError
+    ? "error"
+    : isTool
+      ? "tool"
+      : role === "user"
+        ? "user"
+        : role === "system"
+          ? "system"
+          : "assistant";
+  const label =
+    isTool
+      ? msg.type === "tool_call" ? "TOOL CALL" : "TOOL RESULT"
+      : isError ? "ERROR" : null;
+  return html`
+    <div class="chat-bubble ${bubbleClass}">
+      ${role === "system" && !isTool
+        ? html`<div class="chat-system-text">${msg.content}</div>`
+        : html`
+            ${label ? html`<div class="chat-bubble-label">${label}</div>` : null}
+            <div class="chat-bubble-content">
+              <${MessageContent} text=${msg.content} />
+            </div>
+            <div class="chat-bubble-time">
+              ${msg.timestamp ? formatRelative(msg.timestamp) : ""}
+            </div>
+          `}
+    </div>
+  `;
+}, (prev, next) => prev.msg === next.msg);
+
 /* ─── Chat View component ─── */
 export function ChatView({ sessionId, readOnly = false, embedded = false }) {
   const [input, setInput] = useState("");
@@ -406,7 +458,9 @@ export function ChatView({ sessionId, readOnly = false, embedded = false }) {
     const newMessages = nextCount > prevCount;
     lastMessageCount.current = nextCount;
     if (!paused && autoScroll) {
-      el.scrollTop = el.scrollHeight;
+      // Use smooth scroll for small increments, instant for large jumps
+      const gap = el.scrollHeight - el.scrollTop - el.clientHeight;
+      el.scrollTo({ top: el.scrollHeight, behavior: gap < 800 ? "smooth" : "instant" });
       return;
     }
     if (newMessages && !autoScroll) {
@@ -484,7 +538,7 @@ export function ChatView({ sessionId, readOnly = false, embedded = false }) {
     setInput(e.target.value);
     const el = e.target;
     el.style.height = 'auto';
-    el.style.height = Math.min(el.scrollHeight, 100) + 'px';
+    el.style.height = Math.min(el.scrollHeight, 120) + 'px';
   }, []);
 
   const toggleFilter = useCallback((key) => {
@@ -754,50 +808,12 @@ export function ChatView({ sessionId, readOnly = false, embedded = false }) {
             </button>
           </div>
         `}
-        ${visibleMessages.map((msg) => {
-          const isTool =
-            msg.type === "tool_call" || msg.type === "tool_result";
-          const isError = msg.type === "error" || msg.type === "stream_error";
-          const role = msg.role ||
-            (isTool || isError ? "system" : msg.type === "system" ? "system" : "assistant");
-          const bubbleClass = isError
-            ? "error"
-            : isTool
-              ? "tool"
-              : role === "user"
-                ? "user"
-                : role === "system"
-                  ? "system"
-                  : "assistant";
-          const label =
-            isTool
-              ? msg.type === "tool_call"
-                ? "TOOL CALL"
-                : "TOOL RESULT"
-              : isError
-                ? "ERROR"
-                : null;
-          return html`
-            <div
-              key=${msg.id || msg.timestamp}
-              class="chat-bubble ${bubbleClass}"
-            >
-              ${role === "system" && !isTool
-                ? html`<div class="chat-system-text">${msg.content}</div>`
-                : html`
-                    ${label
-                      ? html`<div class="chat-bubble-label">${label}</div>`
-                      : null}
-                    <div class="chat-bubble-content">
-                      <${MessageContent} text=${msg.content} />
-                    </div>
-                    <div class="chat-bubble-time">
-                      ${msg.timestamp ? formatRelative(msg.timestamp) : ""}
-                    </div>
-                  `}
-            </div>
-          `;
-        })} 
+        ${visibleMessages.map((msg) => html`
+          <${ChatBubble}
+            key=${msg.id || msg.timestamp}
+            msg=${msg}
+          />`
+        )} 
 
         ${/* Pending messages (optimistic rendering) — use .peek() to avoid
               subscribing ChatView to pendingMessages signal. Pending messages
@@ -844,12 +860,12 @@ export function ChatView({ sessionId, readOnly = false, embedded = false }) {
             class="btn btn-primary btn-sm"
             onClick=${() => {
               const el = messagesRef.current;
-              if (el) el.scrollTop = el.scrollHeight;
+              if (el) el.scrollTo({ top: el.scrollHeight, behavior: "smooth" });
               setAutoScroll(true);
               setUnreadCount(0);
             }}
           >
-            Jump to latest${unreadCount ? ` (${unreadCount})` : ""}
+            ↓ Jump to latest${unreadCount ? ` (${unreadCount})` : ""}
           </button>
         </div>
       `}

package/ui/styles/sessions.css

@@ -35,8 +35,9 @@
   background: rgba(5, 6, 8, 0.5);
   opacity: 0;
   pointer-events: none;
-  transition: opacity 0.2s ease;
+  transition: opacity 0.28s cubic-bezier(0.32, 0.72, 0, 1);
   z-index: 140;
+  -webkit-tap-highlight-color: transparent;
 }
 
 .session-drawer-backdrop.open {
@@ -93,9 +94,11 @@
     bottom: calc(var(--nav-height) + var(--safe-bottom));
     width: min(88vw, 360px);
     transform: translateX(-100%);
-    transition: transform 0.24s ease;
+    transition: transform 0.28s cubic-bezier(0.32, 0.72, 0, 1);
+    will-change: transform;
     z-index: 160;
     box-shadow: 12px 0 40px rgba(0, 0, 0, 0.35);
+    background: var(--bg-secondary);
   }
   .session-split.drawer-open .session-pane {
     transform: translateX(0);
@@ -150,7 +153,7 @@
   display: flex;
   align-items: center;
   padding: 0;
-  border-bottom: 1px solid var(--border, var(--border));
+  border-bottom: 1px solid var(--border);
   background: var(--bg-primary);
   flex-shrink: 0;
 }
@@ -177,6 +180,7 @@
   font-size: 12px;
   font-weight: 600;
   cursor: pointer;
+  transition: color var(--transition-fast), border-color var(--transition-fast);
 }
 
 .session-drawer-btn:hover {
@@ -184,6 +188,17 @@
   border-color: var(--border-strong);
 }
 
+.session-drawer-btn:active {
+  transform: scale(0.96);
+}
+
+/* On tablet+, the session pane is inline — hide the hamburger drawer toggle */
+@media (min-width: 769px) {
+  .session-drawer-btn {
+    display: none;
+  }
+}
+
 .chat-shell-title {
   display: flex;
   flex-direction: column;
@@ -569,6 +584,12 @@
 .chat-stream-dot.executing,
 .chat-stream-dot.streaming {
   background: var(--accent);
+  animation: streamDotPulse 1.8s ease-in-out infinite;
+}
+
+@keyframes streamDotPulse {
+  0%, 100% { box-shadow: 0 0 0 4px rgba(218, 119, 86, 0.1); }
+  50% { box-shadow: 0 0 0 6px rgba(218, 119, 86, 0.25); }
 }
 
 .chat-stream-dot.paused {
@@ -749,7 +770,12 @@
   flex: 1;
   min-height: 0;
   overflow-y: auto;
+  overflow-x: hidden;
   -webkit-overflow-scrolling: touch;
+  overscroll-behavior-y: contain;
+  scroll-padding-bottom: 80px;
+  scrollbar-width: thin;
+  scrollbar-color: rgba(255, 255, 255, 0.08) transparent;
   padding: 20px 16px 48px;
   display: flex;
   flex-direction: column;
@@ -757,6 +783,23 @@
   align-items: stretch;
 }
 
+.chat-messages::-webkit-scrollbar {
+  width: 6px;
+}
+
+.chat-messages::-webkit-scrollbar-track {
+  background: transparent;
+}
+
+.chat-messages::-webkit-scrollbar-thumb {
+  background: rgba(255, 255, 255, 0.1);
+  border-radius: 3px;
+}
+
+.chat-messages::-webkit-scrollbar-thumb:hover {
+  background: rgba(255, 255, 255, 0.18);
+}
+
 .chat-load-earlier {
   display: flex;
   align-items: center;
@@ -821,6 +864,11 @@
   background: var(--bg-card);
   align-self: flex-start;
   box-shadow: var(--shadow-sm);
+  /* CSS containment — tells the browser each bubble is layout-independent,
+     reducing style recalc and layout thrashing on long message lists */
+  content-visibility: auto;
+  contain-intrinsic-size: auto 80px;
+  contain: layout style;
 }
 
 .chat-bubble.user {
@@ -888,6 +936,19 @@
   margin-top: 4px;
 }
 
+/* Subtle entrance for bubbles — only the last few get the animation
+   (content-visibility: auto on older bubbles skips them for free) */
+.chat-bubble:last-child,
+.chat-bubble:nth-last-child(2),
+.chat-bubble:nth-last-child(3) {
+  animation: chatBubbleIn 0.18s ease-out;
+}
+
+@keyframes chatBubbleIn {
+  from { opacity: 0; transform: translateY(6px); }
+  to { opacity: 1; transform: translateY(0); }
+}
+
 .chat-jump-latest {
   position: absolute;
   left: 0;
@@ -897,10 +958,27 @@
   justify-content: center;
   pointer-events: none;
   z-index: 6;
+  animation: fadeSlideUp 0.2s ease;
 }
 
 .chat-jump-latest .btn {
   pointer-events: auto;
+  border-radius: var(--radius-full);
+  padding: 6px 16px;
+  font-size: 12px;
+  font-weight: 600;
+  box-shadow: var(--shadow-md);
+  backdrop-filter: blur(8px);
+  transition: transform var(--transition-fast), box-shadow var(--transition-fast);
+}
+
+.chat-jump-latest .btn:hover {
+  transform: translateY(-1px);
+  box-shadow: var(--shadow-lg);
+}
+
+.chat-jump-latest .btn:active {
+  transform: scale(0.96);
 }
 
 /* ─── Code blocks ─── */
@@ -1253,8 +1331,8 @@ ul.md-list li::before {
   right: 0;
   max-height: 240px;
   overflow-y: auto;
-  background: var(--bg-card, var(--bg-card));
-  border: 1px solid var(--border, var(--border));
+  background: var(--bg-card);
+  border: 1px solid var(--border);
   border-radius: var(--radius-lg) var(--radius-lg) 0 0;
   box-shadow: var(--shadow-lg, 0 4px 24px rgba(0,0,0,.35));
   z-index: 9999;
@@ -1345,7 +1423,7 @@ ul.md-list li::before {
 .chat-input-area {
   position: relative;
   padding: 16px 16px;
-  border-top: 1px solid var(--border, var(--border));
+  border-top: 1px solid var(--border);
   background: var(--bg-surface, var(--bg-card));
   flex-shrink: 0;
 }
@@ -1391,20 +1469,12 @@ ul.md-list li::before {
   padding: 0 0 calc(12px + var(--safe-bottom, 0px));
 }
 
-.app-shell[data-tab="chat"] .chat-view-embedded .chat-messages {
-  padding: 0 0 16px;
-}
-
-.app-shell[data-tab="chat"] .chat-input-area {
-  padding: 0 0 calc(12px + var(--safe-bottom, 0px));
-}
-
 .chat-input-wrapper {
   display: flex;
   align-items: flex-end;
   gap: 8px;
-  background: var(--bg-card, var(--bg-card));
-  border: 1px solid var(--border, var(--border));
+  background: var(--bg-card);
+  border: 1px solid var(--border);
   border-radius: 24px;
   padding: 8px 8px 8px 16px;
   transition: border-color 0.15s, box-shadow 0.15s;
@@ -1413,8 +1483,8 @@ ul.md-list li::before {
 }
 
 .chat-input-wrapper:focus-within {
-  border-color: var(--accent, var(--color-primary, #3b82f6));
-  box-shadow: 0 0 0 2px rgba(59, 130, 246, 0.1);
+  border-color: var(--accent);
+  box-shadow: 0 0 0 2px var(--accent-soft, rgba(218, 119, 86, 0.12));
 }
 
 .chat-textarea {
@@ -1430,6 +1500,7 @@ ul.md-list li::before {
   min-height: 24px;
   max-height: 120px;
   padding: 4px 0;
+  scrollbar-width: thin;
 }
 
 .chat-textarea::placeholder {
@@ -1752,3 +1823,76 @@ ul.md-list li::before {
   background: rgba(245, 158, 11, 0.1);
   border-radius: 4px;
 }
+
+/* ═══ Mobile Chat Refinements ═══ */
+@media (max-width: 768px) {
+  .chat-shell-inner {
+    padding: 8px 10px;
+    gap: 8px;
+  }
+
+  .chat-shell-name {
+    font-size: 13px;
+  }
+
+  .chat-shell-meta {
+    font-size: 10px;
+  }
+
+  .chat-input-wrapper {
+    padding: 6px 6px 6px 12px;
+    border-radius: 20px;
+  }
+
+  .chat-textarea {
+    font-size: 16px; /* prevent iOS zoom on focus */
+    max-height: 100px;
+  }
+
+  .chat-input-area .chat-send-btn {
+    width: 34px;
+    height: 34px;
+    font-size: 15px;
+  }
+
+  .chat-input-hint {
+    font-size: 10px;
+    padding: 3px 2px 0;
+  }
+
+  .chat-bubble {
+    padding: 8px 12px;
+    font-size: 14px;
+  }
+
+  .chat-bubble.user {
+    max-width: min(85%, 480px);
+  }
+
+  .chat-messages {
+    padding: 12px 10px 40px;
+    gap: 8px;
+  }
+}
+
+/* ═══ Desktop Chat Refinements ═══ */
+@media (min-width: 1200px) {
+  .chat-messages {
+    padding: 24px 20px 48px;
+    gap: 10px;
+  }
+
+  .chat-shell-inner {
+    max-width: 1080px;
+    padding: 12px 16px;
+  }
+
+  /* Wider input area on large screens */
+  .chat-input-wrapper {
+    max-width: min(840px, 100%);
+  }
+
+  .chat-input-hint {
+    max-width: min(840px, 100%);
+  }
+}

package/ui/tabs/chat.js

@@ -386,6 +386,16 @@ export function ChatTab() {
     } catch { /* signal read error - ignore */ }
   }, [isMobile]);
 
+  /* ── Auto-focus textarea when switching sessions (desktop only) ── */
+  useEffect(() => {
+    if (!sessionId || isMobile) return;
+    // Delay focus to let the ChatView mount first
+    const timer = setTimeout(() => {
+      if (textareaRef.current) textareaRef.current.focus();
+    }, 150);
+    return () => clearTimeout(timer);
+  }, [sessionId, isMobile]);
+
   /* ── Slash command filtering ──
      Use useMemo with no signal deps to avoid subscribing ChatTab to
      activeAgentInfo. The commands list only matters when the user is

package/ui-server.mjs

@@ -3435,6 +3435,18 @@ async function handleApi(req, res, url) {
     return;
   }
 
+  if (path === "/api/workspace-health") {
+    try {
+      const { runWorkspaceHealthCheck } = await import("./config-doctor.mjs");
+      const configDir = resolveUiConfigDir();
+      const result = runWorkspaceHealthCheck({ configDir });
+      jsonResponse(res, 200, { ok: result.ok, data: result });
+    } catch (err) {
+      jsonResponse(res, 500, { ok: false, error: err.message });
+    }
+    return;
+  }
+
   if (path === "/api/worktrees") {
     try {
       const worktrees = listActiveWorktrees(repoRoot);