@towles/tool 0.0.109 → 0.0.111

package/packages/agentboard/apps/tui/src/session-status.test.ts

@@ -0,0 +1,70 @@
+import { describe, it, expect } from "vitest";
+import type { SessionData, AgentEvent } from "@tt-agentboard/runtime";
+import { computeSessionStatusCounts } from "./session-status";
+
+function makeSession(agentStatus?: AgentEvent["status"]): SessionData {
+  return {
+    name: "test",
+    createdAt: Date.now(),
+    dir: "/tmp",
+    branch: "main",
+    dirty: false,
+    isWorktree: false,
+    filesChanged: 0,
+    linesAdded: 0,
+    linesRemoved: 0,
+    commitsDelta: 0,
+    unseen: false,
+    panes: 1,
+    ports: [],
+    windows: 1,
+    uptime: "0s",
+    agentState: agentStatus
+      ? { agent: "claude", session: "test", status: agentStatus, ts: Date.now() }
+      : null,
+    agents: [],
+    eventTimestamps: [],
+  };
+}
+
+describe("computeSessionStatusCounts", () => {
+  it("returns all zeros for empty sessions", () => {
+    expect(computeSessionStatusCounts([])).toEqual({ active: 0, error: 0, idle: 0 });
+  });
+
+  it("counts running sessions as active", () => {
+    const sessions = [makeSession("running"), makeSession("running")];
+    expect(computeSessionStatusCounts(sessions)).toEqual({ active: 2, error: 0, idle: 0 });
+  });
+
+  it("counts waiting sessions as active", () => {
+    const sessions = [makeSession("waiting")];
+    expect(computeSessionStatusCounts(sessions)).toEqual({ active: 1, error: 0, idle: 0 });
+  });
+
+  it("counts error sessions", () => {
+    const sessions = [makeSession("error")];
+    expect(computeSessionStatusCounts(sessions)).toEqual({ active: 0, error: 1, idle: 0 });
+  });
+
+  it("counts idle, done, interrupted, and null agentState as idle", () => {
+    const sessions = [
+      makeSession("idle"),
+      makeSession("done"),
+      makeSession("interrupted"),
+      makeSession(undefined),
+    ];
+    expect(computeSessionStatusCounts(sessions)).toEqual({ active: 0, error: 0, idle: 4 });
+  });
+
+  it("counts mixed statuses correctly", () => {
+    const sessions = [
+      makeSession("running"),
+      makeSession("error"),
+      makeSession("idle"),
+      makeSession("waiting"),
+      makeSession("done"),
+    ];
+    expect(computeSessionStatusCounts(sessions)).toEqual({ active: 2, error: 1, idle: 2 });
+  });
+});

package/packages/agentboard/apps/tui/src/session-status.ts

@@ -0,0 +1,19 @@
+import type { SessionData } from "@tt-agentboard/runtime";
+import type { SessionStatusCounts } from "./components/StatusBar";
+
+export function computeSessionStatusCounts(sessions: SessionData[]): SessionStatusCounts {
+  let active = 0;
+  let error = 0;
+  let idle = 0;
+  for (const s of sessions) {
+    const status = s.agentState?.status;
+    if (status === "running" || status === "waiting") {
+      active++;
+    } else if (status === "error") {
+      error++;
+    } else {
+      idle++;
+    }
+  }
+  return { active, error, idle };
+}

package/{plugins/tt-agentboard → packages/agentboard}/package.json

@@ -2,18 +2,14 @@
   "name": "@towles/tt-agentboard",
   "version": "0.0.1",
   "private": true,
-  "workspaces": [
-    "apps/*",
-    "packages/*"
-  ],
   "type": "module",
   "scripts": {
     "server": "bun run apps/server/src/main.ts",
     "tui": "bun run apps/tui/src/index.tsx",
     "dev:server": "bun --watch run apps/server/src/main.ts",
     "dev:tui": "bun --watch run apps/tui/src/index.tsx",
-    "test": "bun test packages/runtime/test",
-    "typecheck": "tsc --noEmit"
+    "test": "bun test packages/runtime/src",
+    "typecheck:runtime": "tsc --noEmit -p packages/runtime/tsconfig.json"
   },
   "dependencies": {
     "@tt-agentboard/mux-tmux": "workspace:*",

package/{plugins/tt-agentboard → packages/agentboard}/packages/runtime/package.json

@@ -7,6 +7,9 @@
   "scripts": {
     "test": "bun test"
   },
+  "dependencies": {
+    "consola": "^3.4.2"
+  },
   "devDependencies": {
     "@types/bun": "latest",
     "typescript": "^5"

package/{plugins/tt-agentboard/packages/runtime/test → packages/agentboard/packages/runtime/src/agents}/tracker.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect, beforeEach } from "bun:test";
-import { AgentTracker, instanceKey } from "../src/agents/tracker";
-import type { AgentEvent } from "../src/contracts/agent";
+import { AgentTracker, instanceKey } from "./tracker";
+import type { AgentEvent } from "../contracts/agent";
 
 function makeEvent(overrides: Partial<AgentEvent> = {}): AgentEvent {
   return {

package/packages/agentboard/packages/runtime/src/agents/watchers/claude-code.test.ts

@@ -0,0 +1,63 @@
+import { describe, it, expect } from "bun:test";
+import { determineStatus } from "./claude-code";
+
+describe("determineStatus", () => {
+  it('returns "idle" when no message', () => {
+    expect(determineStatus({})).toBe("idle");
+    expect(determineStatus({ message: undefined })).toBe("idle");
+  });
+
+  it('returns "idle" when message has no role', () => {
+    expect(determineStatus({ message: { content: "hi" } })).toBe("idle");
+  });
+
+  it('returns "running" for user messages', () => {
+    expect(determineStatus({ message: { role: "user", content: "hello" } })).toBe("running");
+  });
+
+  it('returns "running" for assistant messages with tool_use', () => {
+    expect(
+      determineStatus({
+        message: {
+          role: "assistant",
+          content: [{ type: "text", text: "Let me check that." }, { type: "tool_use" }],
+        },
+      }),
+    ).toBe("running");
+  });
+
+  it('returns "done" for assistant messages without tool_use', () => {
+    expect(
+      determineStatus({
+        message: {
+          role: "assistant",
+          content: [{ type: "text", text: "Here is the answer." }],
+        },
+      }),
+    ).toBe("done");
+  });
+
+  it('returns "done" for assistant messages with string content', () => {
+    expect(
+      determineStatus({
+        message: { role: "assistant", content: "plain text response" },
+      }),
+    ).toBe("done");
+  });
+
+  it('returns "done" for assistant messages with empty content', () => {
+    expect(
+      determineStatus({
+        message: { role: "assistant", content: [] },
+      }),
+    ).toBe("done");
+  });
+
+  it('returns "idle" for unknown roles', () => {
+    expect(
+      determineStatus({
+        message: { role: "system", content: "system message" },
+      }),
+    ).toBe("idle");
+  });
+});

package/{plugins/tt-agentboard → packages/agentboard}/packages/runtime/src/agents/watchers/claude-code.ts

@@ -18,6 +18,7 @@ import { join, basename } from "node:path";
 import { homedir } from "node:os";
 import type { AgentStatus } from "../../contracts/agent";
 import type { AgentWatcher, AgentWatcherContext } from "../../contracts/agent-watcher";
+import { JOURNAL_IDLE_TIMEOUT_MS } from "../../shared";
 
 // --- Types ---
 
@@ -145,7 +146,30 @@ export class ClaudeCodeAgentWatcher implements AgentWatcher {
     const threadId = basename(filePath, ".jsonl");
     const prev = this.sessions.get(threadId);
 
-    if (prev && size === prev.fileSize) return;
+    if (prev && size === prev.fileSize) {
+      // Post-seed: if status is "running" but journal hasn't been written to
+      // in >2min, the process likely exited — downgrade to "idle".
+      if (this.seeded && prev.status === "running") {
+        try {
+          const mtime = (await stat(filePath)).mtimeMs;
+          if (Date.now() - mtime > JOURNAL_IDLE_TIMEOUT_MS) {
+            prev.status = "idle";
+            const session = prev.projectDir ? this.ctx?.resolveSession(prev.projectDir) : undefined;
+            if (session) {
+              this.ctx?.emit({
+                agent: "claude-code",
+                session,
+                status: "idle",
+                ts: Date.now(),
+                threadId,
+                threadName: prev.threadName,
+              });
+            }
+          }
+        } catch {}
+      }
+      return;
+    }
 
     // Seed mode: read last entry to capture real status for post-seed emit
     if (!this.seeded) {
@@ -178,7 +202,7 @@ export class ClaudeCodeAgentWatcher implements AgentWatcher {
       if (latestStatus === "running") {
         try {
           const mtime = (await stat(filePath)).mtimeMs;
-          if (Date.now() - mtime > 10_000) latestStatus = "idle";
+          if (Date.now() - mtime > JOURNAL_IDLE_TIMEOUT_MS) latestStatus = "idle";
         } catch {}
       }
 

package/packages/agentboard/packages/runtime/src/config.test.ts

@@ -0,0 +1,107 @@
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import { mkdirSync, rmSync, existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { loadConfig, saveConfig, loadPreferredEditor } from "./config";
+
+const TEST_HOME = join(import.meta.dir, ".test-home");
+const CONFIG_DIR = join(TEST_HOME, ".config", "towles-tool");
+const SETTINGS_FILE = join(CONFIG_DIR, "towles-tool.settings.json");
+
+describe("config", () => {
+  beforeEach(() => {
+    rmSync(TEST_HOME, { recursive: true, force: true });
+  });
+
+  afterEach(() => {
+    rmSync(TEST_HOME, { recursive: true, force: true });
+  });
+
+  describe("loadConfig", () => {
+    it("returns defaults when no settings file exists", () => {
+      const config = loadConfig(TEST_HOME);
+      expect(config.port).toBeUndefined();
+      expect(config.theme).toBeUndefined();
+      expect(config.sidebarWidth).toBeUndefined();
+    });
+
+    it("reads agentboard config from settings file", () => {
+      mkdirSync(CONFIG_DIR, { recursive: true });
+      writeFileSync(
+        SETTINGS_FILE,
+        JSON.stringify({
+          preferredEditor: "cursor",
+          agentboard: {
+            port: 4201,
+            theme: "tokyo-night",
+            sidebarWidth: 30,
+          },
+        }),
+      );
+
+      const config = loadConfig(TEST_HOME);
+      expect(config.port).toBe(4201);
+      expect(config.theme).toBe("tokyo-night");
+      expect(config.sidebarWidth).toBe(30);
+    });
+
+    it("handles malformed JSON gracefully", () => {
+      mkdirSync(CONFIG_DIR, { recursive: true });
+      writeFileSync(SETTINGS_FILE, "not json {{{");
+
+      const config = loadConfig(TEST_HOME);
+      expect(config.port).toBeUndefined();
+    });
+
+    it("handles missing agentboard key", () => {
+      mkdirSync(CONFIG_DIR, { recursive: true });
+      writeFileSync(SETTINGS_FILE, JSON.stringify({ preferredEditor: "code" }));
+
+      const config = loadConfig(TEST_HOME);
+      expect(config.port).toBeUndefined();
+    });
+  });
+
+  describe("saveConfig", () => {
+    it("creates settings file with agentboard key", () => {
+      saveConfig({ theme: "gruvbox-dark" }, TEST_HOME);
+
+      expect(existsSync(SETTINGS_FILE)).toBe(true);
+      const saved = JSON.parse(readFileSync(SETTINGS_FILE, "utf-8"));
+      expect(saved.agentboard.theme).toBe("gruvbox-dark");
+    });
+
+    it("merges with existing agentboard config", () => {
+      mkdirSync(CONFIG_DIR, { recursive: true });
+      writeFileSync(
+        SETTINGS_FILE,
+        JSON.stringify({
+          preferredEditor: "cursor",
+          agentboard: {
+            theme: "nord",
+            sidebarWidth: 28,
+          },
+        }),
+      );
+
+      saveConfig({ sidebarWidth: 32 }, TEST_HOME);
+
+      const saved = JSON.parse(readFileSync(SETTINGS_FILE, "utf-8"));
+      expect(saved.agentboard.theme).toBe("nord");
+      expect(saved.agentboard.sidebarWidth).toBe(32);
+      expect(saved.preferredEditor).toBe("cursor");
+    });
+  });
+
+  describe("loadPreferredEditor", () => {
+    it("returns 'code' when no settings file exists", () => {
+      expect(loadPreferredEditor(TEST_HOME)).toBe("code");
+    });
+
+    it("reads preferredEditor from settings file", () => {
+      mkdirSync(CONFIG_DIR, { recursive: true });
+      writeFileSync(SETTINGS_FILE, JSON.stringify({ preferredEditor: "cursor" }));
+
+      expect(loadPreferredEditor(TEST_HOME)).toBe("cursor");
+    });
+  });
+});

package/packages/agentboard/packages/runtime/src/config.ts

@@ -0,0 +1,80 @@
+import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+import type { PartialTheme } from "./themes";
+
+export interface AgentboardConfig {
+  /** Explicit mux provider name (overrides auto-detect) */
+  mux?: string;
+  /** Custom server port */
+  port?: number;
+  /** Theme: builtin name (e.g. "catppuccin-latte") or partial inline theme object */
+  theme?: string | PartialTheme;
+  /** Sidebar column width (default 26) */
+  sidebarWidth?: number;
+  /** Sidebar position relative to the terminal window (default "left") */
+  sidebarPosition?: "left" | "right";
+  /** Tmux prefix key for sidebar toggle (default "s") */
+  keybinding?: string;
+  /** Persisted detail panel heights keyed by mux session name */
+  detailPanelHeights?: Record<string, number>;
+}
+
+const DEFAULTS: AgentboardConfig = {};
+
+function settingsPath(homeDir?: string): string {
+  const home = homeDir ?? process.env.HOME ?? process.env.USERPROFILE ?? "";
+  return join(home, ".config", "towles-tool", "towles-tool.settings.json");
+}
+
+function readSettingsFile(homeDir?: string): Record<string, unknown> {
+  try {
+    return JSON.parse(readFileSync(settingsPath(homeDir), "utf-8")) as Record<string, unknown>;
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Load agentboard config from ~/.config/towles-tool/towles-tool.settings.json
+ * under the "agentboard" key.
+ * @param homeDir — override home directory (for testing)
+ */
+export function loadConfig(homeDir?: string): AgentboardConfig {
+  const settings = readSettingsFile(homeDir);
+  const agentboard = settings.agentboard;
+
+  if (!agentboard || typeof agentboard !== "object") {
+    return { ...DEFAULTS };
+  }
+
+  return { ...DEFAULTS, ...(agentboard as Partial<AgentboardConfig>) };
+}
+
+/**
+ * Save partial agentboard config updates to the main settings file.
+ * Merges with existing agentboard config to preserve fields.
+ * @param updates — partial config fields to write
+ * @param homeDir — override home directory (for testing)
+ */
+export function saveConfig(updates: Partial<AgentboardConfig>, homeDir?: string): void {
+  const filePath = settingsPath(homeDir);
+  const settings = readSettingsFile(homeDir);
+  const existing = (settings.agentboard ?? {}) as Partial<AgentboardConfig>;
+  const merged = { ...existing, ...updates };
+
+  settings.agentboard = merged;
+
+  mkdirSync(dirname(filePath), { recursive: true });
+  writeFileSync(filePath, JSON.stringify(settings, null, 2) + "\n");
+}
+
+/**
+ * Load preferredEditor from the main settings file.
+ * @param homeDir — override home directory (for testing)
+ */
+export function loadPreferredEditor(homeDir?: string): string {
+  const settings = readSettingsFile(homeDir);
+  const editor = settings.preferredEditor;
+  return typeof editor === "string" && editor.length > 0 ? editor : "code";
+}

package/{plugins/tt-agentboard → packages/agentboard}/packages/runtime/src/index.ts

@@ -37,7 +37,7 @@ export {
   SERVER_ERR_LOG,
   INSTALL_LOG,
 } from "./debug";
-export { loadConfig, saveConfig } from "./config";
+export { loadConfig, saveConfig, loadPreferredEditor } from "./config";
 export type { AgentboardConfig } from "./config";
 export { resolveTheme, BUILTIN_THEMES, DEFAULT_THEME } from "./themes";
 export type { Theme, ThemePalette, PartialTheme } from "./themes";

package/{plugins/tt-agentboard → packages/agentboard}/packages/runtime/src/plugins/loader.ts

@@ -89,38 +89,6 @@ export class PluginLoader {
     return loaded;
   }
 
-  /**
-   * Load community plugins from npm package names.
-   * Each package should `export default function(api: PluginAPI) { ... }`
-   * or have a package.json "agentboard" field pointing to the entry file.
-   *
-   * Returns names of successfully loaded packages.
-   */
-  loadPackages(packageNames: string[]): string[] {
-    const loaded: string[] = [];
-    const api = this.createAPI();
-
-    for (const pkg of packageNames) {
-      try {
-        const mod = require(pkg);
-        const factory: PluginFactory | undefined =
-          typeof mod.default === "function"
-            ? mod.default
-            : typeof mod === "function"
-              ? mod
-              : undefined;
-        if (factory) {
-          factory(api);
-          loaded.push(pkg);
-        }
-      } catch {
-        // Package not installed or broken — skip
-      }
-    }
-
-    return loaded;
-  }
-
   /**
    * Load a single factory from a file path.
    */
@@ -145,7 +113,7 @@ export class PluginLoader {
     const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
     return {
       registeredMuxProviders: this.registry.list(),
-      configPath: join(home, ".config", "towles-tool", "agentboard", "config.json"),
+      configPath: join(home, ".config", "towles-tool", "towles-tool.settings.json"),
       serverPort: SERVER_PORT,
     };
   }

package/{plugins/tt-agentboard → packages/agentboard}/packages/runtime/src/server/git-info.ts

@@ -1,6 +1,7 @@
 import { existsSync, watch } from "node:fs";
 import type { FSWatcher } from "node:fs";
 import { join } from "node:path";
+import consola from "consola";
 import type { SessionData } from "../shared";
 
 // --- Shell helper (for git commands only) ---
@@ -151,8 +152,8 @@ export function syncGitWatchers(sessions: SessionData[], broadcastFn: () => void
     try {
       const watcher = watch(headPath, () => onGitHeadChange(broadcastFn));
       gitHeadWatchers.set(dir, watcher);
-    } catch {
-      /* ignore */
+    } catch (err) {
+      consola.debug(`Failed to watch git HEAD at ${headPath}:`, err);
     }
   }
 }

package/{plugins/tt-agentboard → packages/agentboard}/packages/runtime/src/server/index.ts

@@ -1,18 +1,19 @@
-import { readFileSync, statSync, unlinkSync, writeFileSync, appendFileSync } from "node:fs";
+import { readFileSync, unlinkSync, writeFileSync, appendFileSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
 import type { MuxProvider } from "../contracts/mux";
 import { isFullSidebarCapable, isBatchCapable } from "../contracts/mux";
 import type { AgentEvent } from "../contracts/agent";
+import { TERMINAL_STATUSES } from "../contracts/agent";
 import type { AgentWatcher, AgentWatcherContext } from "../contracts/agent-watcher";
 import { AgentTracker, instanceKey } from "../agents/tracker";
 import { SessionOrder } from "./session-order";
 import { SessionMetadataStore } from "./metadata-store";
-import { loadConfig, saveConfig } from "../config";
+import { loadConfig, saveConfig, loadPreferredEditor } from "../config";
 import { resolveSidebarWidthFromResizeContext, snapshotSidebarWindows } from "./sidebar-width-sync";
 import type { SidebarResizeContext, SidebarResizeSuppression } from "./sidebar-width-sync";
 import { shell, getGitInfo, syncGitWatchers, teardownGitWatchers } from "./git-info";
-import { refreshPortSnapshot, getSessionPorts } from "./port-scanner";
+import { refreshPortSnapshot, getSessionPorts, startPortPoll } from "./port-scanner";
 import {
   SERVER_PORT,
   SERVER_HOST,
@@ -73,8 +74,9 @@ export function startServer(
   const config = loadConfig();
   let currentTheme: string | undefined =
     typeof config.theme === "string" ? config.theme : undefined;
-  let sidebarWidth = config.sidebarWidth ?? 26;
+  let sidebarWidth = config.sidebarWidth ?? 35;
   let sidebarPosition: "left" | "right" = config.sidebarPosition ?? "left";
+  let preferredEditor = loadPreferredEditor();
   let sidebarVisible = false;
 
   log("server", "config loaded", {
@@ -196,19 +198,24 @@ export function startServer(
     if (!paneAgents || paneAgents.size === 0) return watcherAgents;
 
     const result = [...watcherAgents];
-    // Build a set of tracked agent:threadId keys for matching
-    const trackedByKey = new Set(watcherAgents.map((a) => instanceKey(a.agent, a.threadId)));
-    // Also track which agent names + threadIds are covered by watchers
-    const trackedThreadIds = new Set(
-      watcherAgents.filter((a) => a.threadId).map((a) => `${a.agent}:${a.threadId}`),
-    );
+    const trackedByKey = new Map(result.map((a, i) => [instanceKey(a.agent, a.threadId), i]));
 
     for (const [, presence] of paneAgents) {
-      // If the pane scanner resolved a threadId, check if watcher already tracks it
-      if (presence.threadId && trackedThreadIds.has(`${presence.agent}:${presence.threadId}`))
+      const key = instanceKey(presence.agent, presence.threadId);
+      const trackedIdx = trackedByKey.get(key);
+
+      if (trackedIdx != null) {
+        // Watcher already tracks this agent — correct terminal statuses
+        // using pane liveness (process is confirmed alive, so terminal
+        // journal status is a between-turn artifact).
+        const tracked = result[trackedIdx]!;
+        if (TERMINAL_STATUSES.has(tracked.status)) {
+          tracked.status = "running";
+          tracked.paneId = presence.paneId;
+        }
         continue;
-      // Check by instanceKey as well
-      if (trackedByKey.has(instanceKey(presence.agent, presence.threadId))) continue;
+      }
+
       // If we have no threadId from pane scan and watcher tracks any instance of this agent, skip
       if (!presence.threadId && watcherAgents.some((a) => a.agent === presence.agent)) continue;
 
@@ -319,6 +326,7 @@ export function startServer(
       currentSession,
       theme: currentTheme,
       sidebarWidth,
+      preferredEditor,
       ts: Date.now(),
     };
   }
@@ -1128,15 +1136,6 @@ export function startServer(
             }
           }
 
-          // If status is "running" but journal hasn't been written to recently,
-          // the Claude process likely exited — downgrade to "idle".
-          if (lastStatus === "running") {
-            try {
-              const mtime = statSync(filePath).mtimeMs;
-              if (Date.now() - mtime > 10_000) lastStatus = "idle";
-            } catch {}
-          }
-
           return { threadName, status: lastStatus };
         } catch {
           continue;
@@ -1445,21 +1444,8 @@ export function startServer(
 
   // --- Port polling (detect new/stopped listeners every 10s) ---
 
-  const PORT_POLL_INTERVAL_MS = 10_000;
   let portPollTimer: ReturnType<typeof setInterval> | null = null;
 
-  function startPortPoll() {
-    // Run initial snapshot immediately so first broadcast has ports
-    if (lastState) {
-      refreshPortSnapshot(lastState.sessions.map((s) => s.name));
-    }
-    portPollTimer = setInterval(() => {
-      if (!lastState || clientCount === 0) return;
-      const changed = refreshPortSnapshot(lastState.sessions.map((s) => s.name));
-      if (changed) broadcastState();
-    }, PORT_POLL_INTERVAL_MS);
-  }
-
   function cleanup() {
     for (const w of allWatchers) w.stop();
     if (watcherBroadcastTimer) clearTimeout(watcherBroadcastTimer);
@@ -1728,7 +1714,7 @@ export function startServer(
     refreshPortSnapshot(allMuxSessions);
   }
   broadcastState();
-  startPortPoll();
+  portPollTimer = startPortPoll({ lastState, clientCount, broadcastState });
   startPaneScan();
   // Run initial pane scan
   refreshPaneAgents();

package/{plugins/tt-agentboard → packages/agentboard}/packages/runtime/src/server/launcher.ts

@@ -1,5 +1,4 @@
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
+import { existsSync, readFileSync, unlinkSync } from "node:fs";
 import { connect } from "node:net";
 import { SERVER_PORT, SERVER_HOST, PID_FILE } from "../shared";
 import { SERVER_ERR_LOG } from "../debug";
@@ -32,31 +31,20 @@ async function isPortOpen(host: string, port: number, timeoutMs = 200): Promise<
   });
 }
 
-function resolveAgentboardDir(): string {
-  if (process.env.TT_AGENTBOARD_DIR) return process.env.TT_AGENTBOARD_DIR;
-  // Walk up from packages/runtime/src/server/ to the plugin root
-  return new URL("../../../..", import.meta.url).pathname;
-}
-
-function resolveServerEntryPath(pluginDir: string): string {
-  return join(pluginDir, "apps", "server", "src", "main.ts");
-}
-
 export async function ensureServer(): Promise<void> {
   if (existsSync(PID_FILE)) {
     const pid = Number.parseInt(readFileSync(PID_FILE, "utf-8").trim(), 10);
     if (!Number.isNaN(pid) && isProcessAlive(pid) && (await isPortOpen(SERVER_HOST, SERVER_PORT))) {
       return;
     }
+    // Stale PID file — remove before spawning a new server
+    try {
+      unlinkSync(PID_FILE);
+    } catch {}
   }
 
-  const pluginDir = resolveAgentboardDir();
-  const serverPath = resolveServerEntryPath(pluginDir);
-
-  const proc = Bun.spawn([process.execPath, "run", serverPath], {
+  const proc = Bun.spawn(["tt", "agentboard", "server"], {
     stdio: ["ignore", "ignore", Bun.file(SERVER_ERR_LOG)],
-    cwd: pluginDir,
-    env: { ...process.env, TT_AGENTBOARD_DIR: pluginDir },
   });
   proc.unref();