@phenx-inc/ctlsurf 0.10.0 → 0.12.0

package/out/renderer/assets/{javascript-Cy7ROXJl.js → javascript-C8T_SdLC.js}

@@ -1,5 +1,5 @@
-import { conf as conf$1, language as language$1 } from "./typescript-Dysz1PTX.js";
-import "./index-Dg1vMspf.js";
+import { conf as conf$1, language as language$1 } from "./typescript-HhQUr1Rb.js";
+import "./index-kkG56aKv.js";
 const conf = conf$1;
 const language = {
   // Set defaultToken to invalid to see what you do not tokenize yet

package/out/renderer/assets/{jsonMode-BtZtt3QW.js → jsonMode-D1zR4VVU.js}

@@ -1,6 +1,6 @@
-import { c as createWebWorker, l as languages, e as editor } from "./index-Dg1vMspf.js";
-import { f as DocumentFormattingEditProvider, g as DocumentRangeFormattingEditProvider, C as CompletionAdapter, H as HoverAdapter, b as DocumentSymbolAdapter, d as DocumentColorAdapter, F as FoldingRangeAdapter, S as SelectionRangeAdapter, e as DiagnosticsAdapter } from "./lspLanguageFeatures-Dmx0L0Bw.js";
-import { a, D, h, R, c, i, j, t, k } from "./lspLanguageFeatures-Dmx0L0Bw.js";
+import { c as createWebWorker, l as languages, e as editor } from "./index-kkG56aKv.js";
+import { f as DocumentFormattingEditProvider, g as DocumentRangeFormattingEditProvider, C as CompletionAdapter, H as HoverAdapter, b as DocumentSymbolAdapter, d as DocumentColorAdapter, F as FoldingRangeAdapter, S as SelectionRangeAdapter, e as DiagnosticsAdapter } from "./lspLanguageFeatures-CXGfrtzl.js";
+import { a, D, h, R, c, i, j, t, k } from "./lspLanguageFeatures-CXGfrtzl.js";
 const STOP_WHEN_IDLE_FOR = 2 * 60 * 1e3;
 class WorkerManager {
   constructor(defaults) {

package/out/renderer/assets/{liquid-xReAQeYs.js → liquid-COSMe9Uf.js}

@@ -1,4 +1,4 @@
-import { l as languages } from "./index-Dg1vMspf.js";
+import { l as languages } from "./index-kkG56aKv.js";
 const EMPTY_ELEMENTS = [
   "area",
   "base",

package/out/renderer/assets/{lspLanguageFeatures-Dmx0L0Bw.js → lspLanguageFeatures-CXGfrtzl.js}

@@ -1,4 +1,4 @@
-import { R as Range$1, l as languages, e as editor, U as Uri, M as MarkerSeverity } from "./index-Dg1vMspf.js";
+import { R as Range$1, l as languages, e as editor, U as Uri, M as MarkerSeverity } from "./index-kkG56aKv.js";
 var DocumentUri;
 (function(DocumentUri2) {
   function is(value) {

package/out/renderer/assets/{mdx-YMNFO1Zz.js → mdx-RfS44T-L.js}

@@ -1,4 +1,4 @@
-import { l as languages } from "./index-Dg1vMspf.js";
+import { l as languages } from "./index-kkG56aKv.js";
 const conf = {
   comments: {
     blockComment: ["{/*", "*/}"]

package/out/renderer/assets/{python-BExaDVxv.js → python-DFSWKHUu.js}

@@ -1,4 +1,4 @@
-import { l as languages } from "./index-Dg1vMspf.js";
+import { l as languages } from "./index-kkG56aKv.js";
 const conf = {
   comments: {
     lineComment: "#",

package/out/renderer/assets/{razor-HL8ANmQ4.js → razor-DtH2_uvo.js}

@@ -1,4 +1,4 @@
-import { l as languages } from "./index-Dg1vMspf.js";
+import { l as languages } from "./index-kkG56aKv.js";
 const EMPTY_ELEMENTS = [
   "area",
   "base",

package/out/renderer/assets/{tsMode-Dqd8vdLE.js → tsMode-BYIQ-S9Z.js}

@@ -1,4 +1,4 @@
-import { c as createWebWorker, e as editor, U as Uri, a as MarkerTag, M as MarkerSeverity, l as languages, t as typescriptDefaults, R as Range } from "./index-Dg1vMspf.js";
+import { c as createWebWorker, e as editor, U as Uri, a as MarkerTag, M as MarkerSeverity, l as languages, t as typescriptDefaults, R as Range } from "./index-kkG56aKv.js";
 class WorkerManager {
   constructor(_modeId, _defaults) {
     this._modeId = _modeId;

package/out/renderer/assets/{typescript-Dysz1PTX.js → typescript-HhQUr1Rb.js}

@@ -1,4 +1,4 @@
-import { l as languages } from "./index-Dg1vMspf.js";
+import { l as languages } from "./index-kkG56aKv.js";
 const conf = {
   wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
   comments: {

package/out/renderer/assets/{xml-BHp5Z9nc.js → xml-KuhgdKfD.js}

@@ -1,4 +1,4 @@
-import { l as languages } from "./index-Dg1vMspf.js";
+import { l as languages } from "./index-kkG56aKv.js";
 const conf = {
   comments: {
     blockComment: ["<!--", "-->"]

package/out/renderer/assets/{yaml-CPDHxVup.js → yaml-W_kzCFH7.js}

@@ -1,4 +1,4 @@
-import { l as languages } from "./index-Dg1vMspf.js";
+import { l as languages } from "./index-kkG56aKv.js";
 const conf = {
   comments: {
     lineComment: "#"

package/out/renderer/index.html

@@ -49,8 +49,8 @@
       color: #565f89;
     }
   </style>
-  <script type="module" crossorigin src="./assets/index-Dg1vMspf.js"></script>
-  <link rel="stylesheet" crossorigin href="./assets/index-BIceGcz3.css">
+  <script type="module" crossorigin src="./assets/index-kkG56aKv.js"></script>
+  <link rel="stylesheet" crossorigin href="./assets/index-BL9njXIL.css">
 </head>
 <body>
   <div id="boot-splash">

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phenx-inc/ctlsurf",
-  "version": "0.10.0",
+  "version": "0.12.0",
   "description": "Agent-agnostic terminal and desktop app for ctlsurf — run Claude Code, Codex, or any coding agent with live session logging and remote control",
   "main": "out/main/index.js",
   "bin": {

package/src/main/agents.ts

@@ -76,6 +76,14 @@ export function getDefaultAgent(): AgentConfig {
   return getAvailableAgents()[0]
 }
 
+// A remote agent runs over SSH (see ssh.ts). Its byte stream still flows
+// through the PTY — so the always-on agent-state monitor drives the dock
+// indicator — but its session files live on the remote box, so it must stay out
+// of local-only plumbing (transcript tailing, the ctlsurf worker socket).
+export function isRemoteAgent(agent: AgentConfig): boolean {
+  return agent.id.startsWith('remote-')
+}
+
 export function isCodingAgent(agent: AgentConfig): boolean {
-  return agent.id !== 'shell'
+  return agent.id !== 'shell' && !isRemoteAgent(agent)
 }

package/src/main/ctlsurfApi.ts

@@ -90,6 +90,13 @@ export class CtlsurfApi {
     return this.request('POST', '/folders', params)
   }
 
+  // All folders (projects) the API key can see. Used to let a remote session
+  // pick which ctlsurf project to bind to.
+  async listFolders(): Promise<Array<{ id: string; name: string; root_path?: string; git_remote?: string }>> {
+    const folders = await this.request('GET', '/folders')
+    return Array.isArray(folders) ? folders : []
+  }
+
   // ─── Workers ────────────────────────────────────────
 
   async getAuthCode(): Promise<{ code: string }> {

package/src/main/index.ts

@@ -25,6 +25,9 @@ import { AgentConfig, getDefaultAgent, getAvailableAgents } from './agents'
 import { getSettingsDir } from './settingsDir'
 import { Orchestrator } from './orchestrator'
 import { AttentionController } from './agentState'
+import { listSshHosts, getRecentHosts, addRecentHost, probeRemote, buildRemoteAgent, type RemoteAction } from './ssh'
+
+const SETTINGS_DIR = getSettingsDir(true)
 
 let mainWindow: BrowserWindow | null = null
 
@@ -51,12 +54,12 @@ function getProjectAbbrev(cwdPath: string): string {
   return word.slice(0, 2).toUpperCase()
 }
 
-// Draw a 32x32 filled circle overlay. `red` switches between the project-badge
-// blue and the "awaiting input" red dot.
-function createDotOverlay(red: boolean): Electron.NativeImage {
+// Draw a 32x32 filled circle overlay (Windows taskbar). `ready` switches between
+// the project-badge blue and the green "ready for you" dot.
+function createDotOverlay(ready: boolean): Electron.NativeImage {
   const size = 32
   const canvas = Buffer.alloc(size * size * 4, 0) // RGBA
-  const [r, g, b] = red ? [235, 64, 52] : [122, 162, 247]
+  const [r, g, b] = ready ? [52, 199, 89] : [122, 162, 247]
   for (let y = 0; y < size; y++) {
     for (let x = 0; x < size; x++) {
       const cx = x - size / 2
@@ -73,6 +76,43 @@ function createDotOverlay(red: boolean): Electron.NativeImage {
   return nativeImage.createFromBuffer(canvas, { width: size, height: size })
 }
 
+// The plain dock icon (macOS), loaded once at startup. Reused to composite the
+// green "ready" dot on top, and to restore the clean icon when it clears.
+let baseDockIcon: Electron.NativeImage | null = null
+
+// Composite a green "ready for you" dot (with a soft dark ring for contrast) into
+// the lower-right of the dock icon. Reads/writes the bitmap as a matched
+// toBitmap()/createFromBitmap() pair, which share the same (BGRA) byte order.
+function dockIconWithReadyDot(base: Electron.NativeImage): Electron.NativeImage {
+  const { width, height } = base.getSize()
+  if (!width || !height) return base
+  const bmp = base.toBitmap()
+  const r = Math.round(Math.min(width, height) * 0.17)   // dot radius
+  const ring = Math.max(2, Math.round(r * 0.22))         // ring thickness
+  const cx = width - r - Math.round(width * 0.05)
+  const cy = height - r - Math.round(height * 0.05)
+  const put = (x: number, y: number, b: number, g: number, rr: number) => {
+    const idx = (y * width + x) * 4
+    bmp[idx] = b; bmp[idx + 1] = g; bmp[idx + 2] = rr; bmp[idx + 3] = 255
+  }
+  for (let y = cy - r - ring; y <= cy + r + ring; y++) {
+    if (y < 0 || y >= height) continue
+    for (let x = cx - r - ring; x <= cx + r + ring; x++) {
+      if (x < 0 || x >= width) continue
+      const d = Math.sqrt((x - cx) ** 2 + (y - cy) ** 2)
+      if (d <= r) put(x, y, 89, 199, 52)        // green #34c759 (BGRA)
+      else if (d <= r + ring) put(x, y, 24, 26, 31) // dark ring #1f1a18
+    }
+  }
+  return nativeImage.createFromBitmap(bmp, { width, height })
+}
+
+// Show/clear the green "ready" dot on the macOS dock icon.
+function setDockReadyDot(on: boolean): void {
+  if (process.platform !== 'darwin' || !app.dock || !baseDockIcon) return
+  app.dock.setIcon(on ? dockIconWithReadyDot(baseDockIcon) : baseDockIcon)
+}
+
 // Last project abbreviation, so the steady badge can be restored after the
 // "awaiting input" indicator clears.
 let projectAbbrev = ''
@@ -90,8 +130,9 @@ function updateProjectBadge(cwdPath: string | null): void {
   if (!cwdPath) return
   projectAbbrev = getProjectAbbrev(cwdPath)
 
-  // Don't stomp the awaiting-input blink; it restores the steady badge itself.
-  if (!blinkTimer) applySteadyBadge()
+  // The project badge and the "ready" dot are now independent surfaces (badge
+  // vs dock icon), so the badge can always update.
+  applySteadyBadge()
 
   // All platforms: update window title
   if (mainWindow) {
@@ -100,18 +141,17 @@ function updateProjectBadge(cwdPath: string | null): void {
   }
 }
 
-// ─── "Awaiting input" attention indicator (cross-platform) ──────────
+// ─── "Ready for you" attention indicator (cross-platform) ──────────
 //
 // The detection is OS-independent; only the visual differs:
-//   macOS   — blink a red dot in the dock badge + one bounce
-//   Windows — red overlay icon on the taskbar button + flash the button
+//   macOS   — steady green dot composited on the dock icon + one bounce
+//   Windows — green overlay icon on the taskbar button + flash the button
 //   Linux   — badge count where supported + flash (window urgency hint)
 // While the window is focused the dock/taskbar nag is suppressed (the in-app
 // dot is enough); the renderer always gets `agent:state` regardless of OS.
 
 const attention = new AttentionController()
-let blinkTimer: ReturnType<typeof setInterval> | null = null
-let blinkOn = false
+let attentionActive = false
 let bounceId = -1
 
 function setAwaitingIndicator(on: boolean): void {
@@ -124,40 +164,31 @@ function applyAttention(active: boolean): void {
 }
 
 function startAttention(): void {
-  if (blinkTimer) return
-  log('[agent-state] attention START (blink + bounce)')
+  if (attentionActive) return
+  attentionActive = true
+  log('[agent-state] attention START (green ready dot + bounce)')
 
   if (process.platform === 'darwin' && app.dock) {
+    setDockReadyDot(true)
     bounceId = app.dock.bounce('informational')
   }
   if (process.platform === 'win32' && mainWindow) {
-    mainWindow.setOverlayIcon(createDotOverlay(true), 'Awaiting input')
+    mainWindow.setOverlayIcon(createDotOverlay(true), 'Ready for you')
     mainWindow.flashFrame(true)
   }
   if (process.platform === 'linux') {
     if (typeof app.badgeCount === 'number') app.badgeCount = 1
     mainWindow?.flashFrame(true)
   }
-
-  // Blink the macOS dock badge — the whole red pill (project initials and all)
-  // toggles on/off, so the project letters are preserved on the "on" frames
-  // rather than being replaced by a dot.
-  blinkOn = true
-  blinkTimer = setInterval(() => {
-    blinkOn = !blinkOn
-    if (process.platform === 'darwin' && app.dock) {
-      app.dock.setBadge(blinkOn ? (projectAbbrev || '●') : '')
-    }
-  }, 600)
 }
 
 function stopAttention(): void {
-  if (blinkTimer) {
-    clearInterval(blinkTimer)
-    blinkTimer = null
-    log('[agent-state] attention STOP')
-  }
+  if (!attentionActive) return
+  attentionActive = false
+  log('[agent-state] attention STOP')
+
   if (process.platform === 'darwin' && app.dock) {
+    setDockReadyDot(false)
     if (bounceId >= 0) { app.dock.cancelBounce(bounceId); bounceId = -1 }
   }
   if (process.platform === 'win32' && mainWindow) {
@@ -173,7 +204,7 @@ function stopAttention(): void {
 // ─── Orchestrator (shared logic) ──────────────────
 
 const orchestrator = new Orchestrator(
-  getSettingsDir(true),
+  SETTINGS_DIR,
   {
     onPtyData: (tabId, data) => mainWindow?.webContents.send('pty:data', tabId, data),
     onPtyExit: (tabId, code) => mainWindow?.webContents.send('pty:exit', tabId, code),
@@ -270,6 +301,56 @@ ipcMain.handle('pty:setActiveTab', (_event, tabId: string) => {
 ipcMain.handle('agents:list', () => getAvailableAgents())
 ipcMain.handle('agents:default', () => getDefaultAgent())
 
+// ─── Remote (SSH) ─────────────────────────────────
+
+// Hosts to offer: recently-used targets first, then ~/.ssh/config aliases.
+ipcMain.handle('ssh:listHosts', () => ({
+  configHosts: listSshHosts(),
+  recents: getRecentHosts(SETTINGS_DIR),
+}))
+
+// Non-interactive reachability + tmux probe (key-auth hosts only).
+ipcMain.handle('ssh:probe', (_event, target: string) => probeRemote(target))
+
+// Build the ssh-backed AgentConfig for a chosen connect action.
+ipcMain.handle('ssh:buildAgent', (_event, target: string, action: RemoteAction, agentCmd?: string) =>
+  buildRemoteAgent({ target, action, agentCmd }),
+)
+
+// Remember a target as most-recently-used (no secrets stored — just the host).
+ipcMain.handle('ssh:addRecent', (_event, target: string) => {
+  addRecentHost(SETTINGS_DIR, target)
+  return { ok: true }
+})
+
+// Stash an in-app password for the next remote spawn to `target`. Held only in
+// memory (auto-expires), injected once into ssh's prompt, then dropped.
+ipcMain.handle('ssh:setPassword', (_event, target: string, password: string) => {
+  orchestrator.setPendingSshPassword(target, password)
+  return { ok: true }
+})
+
+// ─── ctlsurf project selection (for remote sessions) ──
+
+// List existing ctlsurf projects (folders) to pick from.
+ipcMain.handle('ctlsurf:listProjects', async () => {
+  if (!orchestrator.ctlsurfApi.getApiKey()) return { ok: false, projects: [], error: 'No ctlsurf API key configured' }
+  try {
+    const folders = await orchestrator.ctlsurfApi.listFolders()
+    const projects = folders
+      .filter((f) => f && f.id && f.root_path)
+      .map((f) => ({ id: f.id, name: f.name || '(unnamed)', root_path: f.root_path as string }))
+    return { ok: true, projects }
+  } catch (err: any) {
+    return { ok: false, projects: [], error: err?.message || 'Failed to list projects' }
+  }
+})
+
+// Bind the active (remote) tab to a chosen project by its root_path.
+ipcMain.handle('ctlsurf:bindProject', (_event, rootPath: string) =>
+  orchestrator.bindActiveTabToProject(rootPath),
+)
+
 ipcMain.handle('app:homePath', () => app.getPath('home'))
 ipcMain.handle('app:cwd', () => process.env.CTLSURF_WORKER_CWD || process.cwd())
 ipcMain.handle('app:projectName', () => orchestrator.projectName)
@@ -414,7 +495,8 @@ ipcMain.handle('worker:getWebviewInfo', async () => {
   try {
     const { code } = await orchestrator.ctlsurfApi.getAuthCode()
     let pageUrl = `${frontendUrl}?embed=1&_code=${encodeURIComponent(code)}`
-    const currentCwd = orchestrator.cwd
+    // Prefer the active tab's bound project (remote sessions), else the local cwd.
+    const currentCwd = orchestrator.getActiveTabProjectPath() || orchestrator.cwd
 
     if (currentCwd) {
       try {
@@ -520,7 +602,8 @@ ipcMain.handle('tracking:set', async (_event, enabled: boolean) => {
 // ─── Tickets IPC ──────────────────────────────────
 
 ipcMain.handle('tickets:project', () => {
-  const cwd = orchestrator.getActiveTabCwd()
+  // Use the bound project path for remote sessions, else the local cwd.
+  const cwd = orchestrator.getActiveTabProjectPath()
   return { cwd, name: cwd ? cwd.split('/').filter(Boolean).pop() || cwd : null }
 })
 ipcMain.handle('tickets:add', async (_event, input: {
@@ -582,7 +665,8 @@ app.whenReady().then(() => {
   if (process.platform === 'darwin' && app.dock) {
     const iconPath = path.join(__dirname, '../../resources/icon.png')
     try {
-      app.dock.setIcon(nativeImage.createFromPath(iconPath))
+      baseDockIcon = nativeImage.createFromPath(iconPath)
+      app.dock.setIcon(baseDockIcon)
     } catch { /* ignore */ }
   }
 

package/src/main/orchestrator.ts

@@ -3,7 +3,8 @@ import fs from 'fs'
 import os from 'os'
 
 import { PtyManager } from './pty'
-import { AgentConfig, isCodingAgent } from './agents'
+import { AgentConfig, isCodingAgent, isRemoteAgent } from './agents'
+import { stripAnsiSeq, isPasswordPrompt } from './ssh'
 import { CtlsurfApi } from './ctlsurfApi'
 import { ConversationBridge } from './bridge'
 import { TranscriptTailer, supportsTranscriptLogging, readLatestAssistantReply } from './transcripts'
@@ -62,6 +63,10 @@ interface TabState {
   ptyManager: PtyManager
   agent: AgentConfig
   cwd: string
+  // For remote sessions bound to a ctlsurf project: the project's root_path,
+  // used in place of the (meaningless) local cwd for project-scoped work like
+  // tickets. Set by bindActiveTabToProject.
+  projectRootPath?: string
   termStreamBuffer: string
   termStreamTimer: ReturnType<typeof setTimeout> | null
 }
@@ -108,6 +113,10 @@ export class Orchestrator {
   private currentProjectName: string | null = null
   private transcriptTailer: TranscriptTailer | null = null
   private readonly stateMonitor: AgentStateMonitor
+  // One-shot SSH passwords entered in-app, keyed by target. Held only in memory
+  // until the next remote spawn for that target consumes them — never persisted.
+  private readonly pendingSshPasswords = new Map<string, string>()
+  private readonly pendingSshPasswordTimers = new Map<string, ReturnType<typeof setTimeout>>()
 
   constructor(settingsDir: string, events: OrchestratorEvents) {
     this.settingsDir = settingsDir
@@ -455,6 +464,50 @@ export class Orchestrator {
 
   // ─── PTY & Agent (multi-tab) ─────────────────────
 
+  // Stash an in-app SSH password for the next remote spawn to `target`. Kept
+  // only in memory and auto-expired so a typed-but-unused password doesn't
+  // linger. Never written to disk or logged.
+  setPendingSshPassword(target: string, password: string): void {
+    if (!target || !password) return
+    const prev = this.pendingSshPasswordTimers.get(target)
+    if (prev) clearTimeout(prev)
+    this.pendingSshPasswords.set(target, password)
+    this.pendingSshPasswordTimers.set(target, setTimeout(() => {
+      this.pendingSshPasswords.delete(target)
+      this.pendingSshPasswordTimers.delete(target)
+    }, 120_000))
+  }
+
+  private consumePendingSshPassword(target: string): string | undefined {
+    const pw = this.pendingSshPasswords.get(target)
+    if (pw === undefined) return undefined
+    this.pendingSshPasswords.delete(target)
+    const timer = this.pendingSshPasswordTimers.get(target)
+    if (timer) { clearTimeout(timer); this.pendingSshPasswordTimers.delete(target) }
+    return pw
+  }
+
+  // Watch a freshly-spawned ssh PTY for its password/passphrase prompt and write
+  // the password once. We write straight to the PTY (not through writePty) so it
+  // never reaches the bridge/chat-logging path; ssh keeps echo off, so it never
+  // renders to the terminal or scrollback either.
+  private armPasswordInjector(ptyManager: PtyManager, password: string): void {
+    let pw: string | null = password
+    let tail = ''
+    const giveUp = setTimeout(() => { pw = null; tail = '' }, 30_000)
+    ptyManager.onData((data: string) => {
+      if (pw === null) return
+      tail = (tail + stripAnsiSeq(data)).slice(-200)
+      if (isPasswordPrompt(tail)) {
+        log('[ssh] password prompt detected — injecting in-app password (one-shot)')
+        ptyManager.write(pw + '\r')
+        pw = null
+        tail = ''
+        clearTimeout(giveUp)
+      }
+    })
+  }
+
   async spawnAgent(tabId: string, agent: AgentConfig, cwd: string, opts?: { trackTime?: boolean }): Promise<void> {
     // Kill existing PTY on this tab if any
     const existing = this.tabs.get(tabId)
@@ -479,6 +532,18 @@ export class Orchestrator {
     // exactly when the dock indicator is most useful.
     this.stateMonitor.trackTab(tabId, agent.id, cwd)
 
+    // Remote (SSH) tab with an in-app password waiting: feed it to ssh's prompt
+    // once, directly over the PTY. The password is consumed here (removed from
+    // the pending map) and dropped after injection — never logged or persisted.
+    if (isRemoteAgent(agent)) {
+      const target = agent.args[1] // args are ['-t', target, ...]
+      const pw = target ? this.consumePendingSshPassword(target) : undefined
+      if (pw) {
+        log(`[ssh] remote spawn for ${target}: in-app password armed (will inject at prompt)`)
+        this.armPasswordInjector(ptyManager, pw)
+      }
+    }
+
     ptyManager.onData((data: string) => {
       this.events.onPtyData(tabId, data)
       this.timeTracker.recordActivity(tabId)
@@ -607,8 +672,19 @@ export class Orchestrator {
     return this.tabs.get(this.activeTabId)?.cwd ?? null
   }
 
+  /**
+   * Path used to resolve the active tab's ctlsurf project. For a remote session
+   * bound to a project this is the project's root_path; otherwise the local cwd.
+   */
+  getActiveTabProjectPath(): string | null {
+    if (!this.activeTabId) return null
+    const tab = this.tabs.get(this.activeTabId)
+    if (!tab) return null
+    return tab.projectRootPath ?? tab.cwd
+  }
+
   async addTicketForActiveTab(input: TicketInput): Promise<{ ok: boolean; error?: string }> {
-    const cwd = this.getActiveTabCwd()
+    const cwd = this.getActiveTabProjectPath()
     if (!cwd) return { ok: false, error: 'No active terminal tab' }
     if (!this.ctlsurfApi.getApiKey()) {
       return { ok: false, error: 'ctlsurf API key not configured' }
@@ -617,7 +693,7 @@ export class Orchestrator {
   }
 
   async updateTicketForActiveTab(rowId: string, input: TicketInput): Promise<{ ok: boolean; error?: string }> {
-    const cwd = this.getActiveTabCwd()
+    const cwd = this.getActiveTabProjectPath()
     if (!cwd) return { ok: false, error: 'No active terminal tab' }
     if (!this.ctlsurfApi.getApiKey()) {
       return { ok: false, error: 'ctlsurf API key not configured' }
@@ -626,7 +702,7 @@ export class Orchestrator {
   }
 
   async listTicketsForActiveTab(): Promise<{ ok: boolean; tickets: import('./ticketStore').Ticket[]; error?: string }> {
-    const cwd = this.getActiveTabCwd()
+    const cwd = this.getActiveTabProjectPath()
     if (!cwd) return { ok: false, tickets: [], error: 'No active terminal tab' }
     if (!this.ctlsurfApi.getApiKey()) {
       return { ok: false, tickets: [], error: 'ctlsurf API key not configured' }
@@ -636,6 +712,31 @@ export class Orchestrator {
 
   // ─── Worker WebSocket ───────────────────────────
 
+  // Bind the active tab (typically a remote SSH session, whose local cwd is
+  // meaningless) to a chosen ctlsurf project. We register the worker WS using
+  // the project's root_path so the backend resolves that folder — the same
+  // mechanism create-project relies on. This lights up chat logging, tickets,
+  // remote-control, and the project header/panel for the remote session.
+  bindActiveTabToProject(rootPath: string): { ok: boolean; error?: string } {
+    if (!rootPath) return { ok: false, error: 'No project path' }
+    if (!this.activeTabId) return { ok: false, error: 'No active tab' }
+    const tab = this.tabs.get(this.activeTabId)
+    if (!tab) return { ok: false, error: 'No active tab' }
+    if (!this.ctlsurfApi.getApiKey()) return { ok: false, error: 'No ctlsurf API key configured' }
+
+    log(`[ctlsurf] Binding tab agent="${tab.agent.name}" to project root_path=${rootPath}`)
+    // Remember the binding so project-scoped work (tickets) targets the chosen
+    // project instead of the remote tab's local cwd.
+    tab.projectRootPath = rootPath
+    this.stopNoProjectPolling()
+    this.workerWs.disconnect()
+    this.connectWorkerWs(tab.agent, rootPath)
+    // Tell the renderer the active project changed so the tickets + ctlsurf
+    // panels re-query against the bound project (they refresh on this event).
+    this.events.onCwdChanged()
+    return { ok: true }
+  }
+
   connectWorkerWs(agent: AgentConfig, cwd: string): void {
     const profile = this.getActiveProfile()
     const apiKey = profile.apiKey || process.env.CTLSURF_API_KEY