thinkpool-pair 0.7.94 → 0.7.95

package/account.mjs

@@ -13,9 +13,10 @@ import path from 'node:path'
 import fs from 'node:fs'
 import { createClient } from '@supabase/supabase-js'
 import os from 'node:os'
-import { saveAuth, loadAuth, loadDirs, bindDir } from './auth-store.mjs'
+import { saveAuth, loadAuth, loadDirs, bindDir, loadServed, rememberServed } from './auth-store.mjs'
 import { isSafeToRestart } from './update-gate.mjs'
 import { makeThrottledTrack } from './presence.mjs'
+import { resolveServeDir } from './serve-dir.mjs'
 
 const VERSION = (() => { try { return JSON.parse(fs.readFileSync(new URL('./package.json', import.meta.url), 'utf8')).version } catch { return null } })()
 
@@ -380,16 +381,35 @@ export async function runAccount(SUPABASE_URL, SUPABASE_ANON) {
       rooms = data || []
     } catch { /* transient — keep existing children, retry next tick */ }
     const dirs = loadDirs()
+    const served = loadServed()
     for (const r of rooms) {
       const room = r.code
       if (!room || children.has(room)) continue
       if (r.owner_id && r.owner_id !== session.user.id) continue   // never serve a room we don't own (defense-in-depth behind the .eq above)
-      const dir = dirs[room] || DEFAULT_DIR   // auto-serve unbound sessions in the launch dir
+      // Resolve the serve dir: explicit bind > last-served memory > launch dir. REFUSE
+      // to auto-serve an unbound room from $HOME — that strips the agent's resume context
+      // (cwd-keyed SDK sessions) and shows your home folder as the repo (FVIHV1DE).
+      const choice = resolveServeDir({ bound: dirs[room], remembered: served[room], defaultDir: DEFAULT_DIR, home: os.homedir() })
+      if (choice.refuse) {
+        if (!warned.has(room)) {
+          warned.add(room)
+          const why = choice.reason === 'home'
+            ? `no project directory set — refusing to serve it from your home folder (${choice.dir}); the agent would lose its session context and the room would show "${path.basename(choice.dir)}" as the repo.`
+            : 'no directory to serve it from.'
+          process.stderr.write(`\n  ◇ ${room}: ${why}\n    Bind it to its repo:  npx thinkpool-pair bind ${room} <repo-dir>\n`)
+        }
+        continue
+      }
+      const dir = choice.dir
       if (!fs.existsSync(dir)) {
         if (!warned.has(room)) { warned.add(room); process.stderr.write(`\n  ◇ ${room}: bound directory is gone (${dir}) — re-bind it.\n`) }
         continue
       }
       warned.delete(room)
+      // Learn this room → dir so a later relaunch from $HOME resumes it HERE (the real
+      // repo) instead of the home-dir fallback. Only the auto path is remembered; an
+      // explicit bind already persists in dirs.json.
+      if (choice.fromDefault) rememberServed(room, dir)
       roomNames.set(room, r.name || null)   // feed list_sessions (cross-room roster)
       process.stderr.write(`\n  ◆ serving ${room}${r.name ? ` "${r.name}"` : ''}  →  ${dir}${dirs[room] ? '' : ' (default)'}\n`)
       // Children NEVER self-update (only the supervisor restart re-resolves

package/auth-store.mjs

@@ -11,6 +11,11 @@ import path from 'node:path'
 const DIR  = path.join(os.homedir(), '.thinkpool-pair')
 const AUTH = path.join(DIR, 'auth.json')
 const DIRS = path.join(DIR, 'dirs.json')
+// served.json: per-room memory of the last real (non-home) directory a room was
+// auto-served from. Distinct from dirs.json (explicit binds): this is learned, so a
+// supervisor relaunched from $HOME still resumes each room in the repo it last ran in
+// instead of falling back to the home folder (FVIHV1DE, 2026-06-30).
+const SERVED = path.join(DIR, 'served.json')
 
 function ensureDir() { try { fs.mkdirSync(DIR, { recursive: true }) } catch { /* noop */ } }
 
@@ -41,3 +46,15 @@ export function unbindDir(room) {
   try { fs.writeFileSync(DIRS, JSON.stringify(d, null, 2)) } catch { /* noop */ }
   return d
 }
+
+// Learned per-room serve directory (see SERVED note above). loadServed feeds the
+// dir-resolution precedence; rememberServed records the dir a room was just served
+// from so a later relaunch-from-home resumes it there rather than in $HOME.
+export function loadServed() { try { return JSON.parse(fs.readFileSync(SERVED, 'utf8')) } catch { return {} } }
+export function rememberServed(room, dir) {
+  const d = loadServed(); if (!room || !dir || d[room] === dir) return d
+  d[room] = dir
+  ensureDir()
+  try { fs.writeFileSync(SERVED, JSON.stringify(d, null, 2)) } catch { /* noop */ }
+  return d
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thinkpool-pair",
-  "version": "0.7.94",
+  "version": "0.7.95",
   "description": "Share a local coding-agent CLI (Claude Code, Codex, Gemini, Aider, …) into a ThinkPool Code room, live.",
   "type": "module",
   "bin": {
@@ -16,6 +16,7 @@
     "transcript-sanitize.mjs",
     "session-store.mjs",
     "cross-terminal.mjs",
+    "serve-dir.mjs",
     "service.mjs",
     "presence.mjs",
     "account.mjs",

package/serve-dir.mjs

@@ -0,0 +1,40 @@
+/* serve-dir.mjs — decide which working directory the account supervisor serves a
+   room from, and REFUSE the home-directory trap.
+
+   Why this exists (FVIHV1DE, 2026-06-30): the supervisor auto-serves an unbound room
+   from its own launch dir (DEFAULT_DIR = process.cwd()). When the supervisor is
+   relaunched from $HOME instead of the repo, every unbound room is served from $HOME.
+   That silently breaks two things:
+     1. The agent's cwd becomes ~, so the Claude SDK (which keys a session's transcript
+        by project directory) can't find the session that was created under the real
+        repo → resume fails → the agent is BLIND to its own history (the UI still replays
+        the persisted ThinkPool log, so "I see the chat but the agent can't").
+     2. The room's repo label is basename(cwd) = your home folder name ("max"/"conrad")
+        instead of "thinkpool" / a branch.
+   Loud refusal beats silent context corruption. Precedence:
+     explicit bind  >  last-served memory  >  the supervisor's launch dir
+   and an UNBOUND, never-served room is refused when the launch dir IS $HOME.
+   Pure (no fs/process) so it unit-tests without spawning bridges. */
+import path from 'node:path'
+
+const samePath = (a, b) => {
+  try { return !!a && !!b && path.resolve(a) === path.resolve(b) } catch { return false }
+}
+
+// Returns { dir, refuse, reason, fromDefault }.
+//  - dir:        the directory to serve from (even when refusing, for the message)
+//  - refuse:     true → do NOT serve; warn the user to bind instead
+//  - reason:     'home' | 'none' when refusing
+//  - fromDefault:true → resolved to the supervisor's launch dir with no bind/memory
+//                (the caller should remember it after a successful serve, so a later
+//                 relaunch-from-home resumes the room from this same repo)
+export function resolveServeDir({ bound, remembered, defaultDir, home } = {}) {
+  const pick = bound || remembered || defaultDir || null
+  if (!pick) return { dir: null, refuse: true, reason: 'none' }
+  // Only the AUTO path (no explicit bind, no remembered dir) is guarded — if a person
+  // deliberately bound a room to their home dir, that's their call, honour it.
+  if (!bound && !remembered && samePath(pick, home)) {
+    return { dir: pick, refuse: true, reason: 'home' }
+  }
+  return { dir: pick, refuse: false, fromDefault: !bound && !remembered }
+}