Add repo picker to spawn dialog and auto-worktree on project collision (#119)

* Add repo picker to spawn dialog and auto-worktree on project collision

- SpawnAgentDialog: show root selector dropdown when project has multiple roots,
  passing the chosen root as cwd to spawnProjectAgent/spawnProjectPersona
- spawn-agent: accept rootOverride parameter to spawn into any root, not just
  the active one
- project:add-root IPC: detect when selected path already belongs to another
  project and return a conflict descriptor instead of silently reusing it
- project:create-worktree-root IPC: given a repo path, discovers the git root,
  creates a new worktree at ~/.pear/worktrees/{projectId}/{repo} on a fresh
  pear/{project-slug} branch, and registers it as a root
- ProjectSettings: render an inline conflict banner with "Create worktree" and
  "Go to existing project" buttons when a collision is detected
- project-store: expose pendingRootConflict state, clearRootConflict, and
  createWorktreeRoot actions
- git: add getGitRoot and createWorktree helpers

https://claude.ai/code/session_01MhKe5JsErX12X8Wbjv9aU2

* Auto-HOLD terminal when typing with multiple agents active

When a user starts typing in any terminal and more than one agent is running
in the project, the terminal automatically switches to drive (hold) mode so
keystrokes are queued rather than immediately injected into the agent. This
prevents accidental input interference across agents.

- useTerminal: accept autoHold flag plus onAutoHoldStart/onAutoHoldRelease
  callbacks; on first keypress in passthrough mode fires onAutoHoldStart; on
  Enter fires onAutoHoldRelease(flush:true); on container blur fires
  onAutoHoldRelease(flush:false) to release hold without flushing
- TerminalInstance: threads autoHold + callback props through to useTerminal
- TerminalProject + SplitTerminalTile: thread autoHold props
- SplitTerminalPage: passes makeAutoHoldHandlers factory through to tiles
- TerminalPane: computes autoHold = runningAgents > 1; makeAutoHoldHandlers
  creates per-agent callbacks that call handleDeliveryModeChange and
  flushPending on Enter release

https://claude.ai/code/session_01MhKe5JsErX12X8Wbjv9aU2

* chore: apply pr-reviewer fixes for #119

* chore: apply pr-reviewer fixes for #119

* chore: apply pr-reviewer fixes for #119

* chore: apply pr-reviewer fixes for #119

* Fix spawn dialog cloud detach and auto-hold release

---------

Co-authored-by: Claude <noreply@anthropic.com>
Co-authored-by: agent-relay-code[bot] <agent-relay-code[bot]@users.noreply.github.com>
Co-authored-by: kjgbot <kjgbot@agentrelay.dev>

Author: 4 people

src/main/git.ts

@@ -1,8 +1,8 @@
 import { spawn } from 'child_process'
 import { createHash } from 'crypto'
-import { existsSync } from 'fs'
+import { existsSync, mkdirSync } from 'fs'
 import { appendFile, mkdtemp, readFile, rm, stat } from 'fs/promises'
-import { join } from 'path'
+import { dirname, join } from 'path'
 import { tmpdir } from 'os'
 import { assertDirectory } from './path-utils'
 import { cacheAvatarFromUrl, cachedAvatarUrl } from './avatar-cache'
@@ -1584,3 +1584,21 @@ export async function getSelectedDiff(path: string, input: { wholeFiles: string[
   const patch = input.patch?.trim() ? input.patch.trim() : ''
   return [...diffs, patch].filter(Boolean).join('\n')
 }
+
+export async function getGitRoot(path: string): Promise<string | null> {
+  try {
+    const result = await runGit(['rev-parse', '--show-toplevel'], path)
+    return result.trim()
+  } catch {
+    return null
+  }
+}
+
+export async function createWorktree(repoPath: string, worktreePath: string, branchName: string): Promise<void> {
+  mkdirSync(dirname(worktreePath), { recursive: true })
+  await runGit(['worktree', 'add', '-b', branchName, worktreePath], repoPath)
+}
+
+export function worktreeExists(worktreePath: string): boolean {
+  return existsSync(join(worktreePath, '.git'))
+}

src/main/ipc-handlers.ts

@@ -1,5 +1,6 @@
 import { app, ipcMain, dialog, BrowserWindow, shell } from 'electron'
-import { resolve } from 'path'
+import { createHash } from 'crypto'
+import { basename, join, resolve } from 'path'
 import type { SpawnPtyInput, SendMessageInput } from '@agent-relay/harness-driver'
 import {
   loadStore,
@@ -12,6 +13,7 @@ import {
   setProjectChannelPeople,
   addProjectRoot,
   removeProjectRoot,
+  findProjectsWithPath,
   addProjectIntegration,
   removeProjectIntegration
 } from './store'
@@ -158,7 +160,38 @@ export function registerIpcHandlers(): void {
       if (result.canceled || !result.filePaths[0]) return null
       path = result.filePaths[0]
     }
-    return addProjectRoot(projectId, path, name)
+
+    const conflict = findProjectsWithPath(path).find((p) => p.id !== projectId)
+    if (conflict) {
+      return { kind: 'conflict', projectId, existingProjectId: conflict.id, existingProjectName: conflict.name, path }
+    }
+
+    return { kind: 'added', root: addProjectRoot(projectId, path, name) }
+  })
+
+  ipcMain.handle('project:create-worktree-root', async (_, projectId: string, repoPath: string, projectName: string, name?: string) => {
+    const gitRoot = await git.getGitRoot(repoPath)
+    if (!gitRoot) throw new Error(`Not a git repository: ${repoPath}`)
+
+    const repoBasename = basename(gitRoot)
+    const repoHash = createHash('sha1').update(gitRoot).digest('hex').slice(0, 8)
+    const worktreePath = join(app.getPath('userData'), 'worktrees', projectId, `${repoBasename}-${repoHash}`)
+
+    const branchSlug = projectName
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, '-')
+      .replace(/^-+|-+$/g, '')
+      .slice(0, 40) || 'pear'
+    const projectSlug = projectId
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, '')
+      .slice(0, 8)
+    const branchName = `pear/${branchSlug}${projectSlug ? `-${projectSlug}` : ''}`
+
+    if (!git.worktreeExists(worktreePath)) {
+      await git.createWorktree(gitRoot, worktreePath, branchName)
+    }
+    return addProjectRoot(projectId, worktreePath, name || repoBasename)
   })
 
   ipcMain.handle('project:remove-root', (_, projectId: string, rootId: string) => {
@@ -250,6 +283,10 @@ export function registerIpcHandlers(): void {
     return brokerManager.connectCloud('cloud', win)
   })
 
+  ipcMain.handle('broker:send-input', async (_, projectId: string | undefined, name: string, data: string) => {
+    return brokerManager.sendInput(projectId, name, data)
+  })
+
   ipcMain.on('broker:send-input-fast', (_, projectId: string | undefined, name: string, data: string) => {
     brokerManager.sendInputFireAndForget(projectId, name, data)
   })

src/main/store.ts

@@ -1,6 +1,6 @@
 import { app } from 'electron'
 import { readFileSync, writeFileSync, renameSync, mkdirSync, existsSync } from 'fs'
-import { basename, join } from 'path'
+import { basename, join, resolve } from 'path'
 import { z } from 'zod'
 import type { ProactiveAgentBinding, ProactiveAgentDraft } from './proactive-agent.types'
 import {
@@ -193,6 +193,14 @@ export function setProjectChannelPeople(projectId: string, channelName: string,
   return normalizedPeople
 }
 
+export function findProjectsWithPath(rootPath: string): Array<{ id: string; name: string }> {
+  const data = loadStore()
+  const normalizedRootPath = resolve(rootPath)
+  return data.projects
+    .filter((p) => p.roots.some((r) => resolve(r.path) === normalizedRootPath))
+    .map((p) => ({ id: p.id, name: p.name }))
+}
+
 export function addProjectRoot(projectId: string, rootPath: string, name?: string): ProjectRoot {
   const data = loadStore()
   const project = withProject(data, projectId)

src/preload/index.ts

@@ -6,6 +6,7 @@ import type {
   AiHistSession,
   AiHistStats,
   AiHistStatusResponse,
+  AddRootResult,
   AuthLoginInput,
   AuthStatus,
   BrokerAttachTerminalInput,
@@ -66,6 +67,8 @@ import type {
   ProactiveAgentRunsPage,
   ProactiveAgentTranscript,
   ProjectListResult,
+  ProjectIntegrationResult,
+  ProjectRootRecord,
   TerminalAttachMode,
   UpdaterState,
   WorkforcePersona
@@ -77,6 +80,7 @@ export type {
   AiHistResumeEntry,
   AiHistSession,
   AiHistSource,
+  AddRootResult,
   AiHistStats,
   AiHistStatusResponse,
   AgentCurrentState,
@@ -160,6 +164,9 @@ export type {
   ProactiveAgentTranscript,
   ProactiveAgentWatchEventKind,
   ProjectListResult,
+  ProjectIntegrationResult,
+  ProjectRootConflict,
+  ProjectRootRecord,
   TerminalAttachMode,
   ViewMode,
   WorkforcePersona
@@ -198,11 +205,13 @@ const api = {
     setChannelPeople: (projectId: string, channelName: string, people: string[]) =>
       invoke<string[]>('project:set-channel-people', projectId, channelName, people),
     addRoot: (projectId: string, name?: string, rootPath?: string) =>
-      invoke<unknown>('project:add-root', projectId, name, rootPath),
+      invoke<AddRootResult | null>('project:add-root', projectId, name, rootPath),
     removeRoot: (projectId: string, rootId: string) =>
       invoke<void>('project:remove-root', projectId, rootId),
+    createWorktreeRoot: (projectId: string, repoPath: string, projectName: string, name?: string) =>
+      invoke<ProjectRootRecord>('project:create-worktree-root', projectId, repoPath, projectName, name),
     addIntegration: (projectId: string, name: string, type?: string) =>
-      invoke<unknown>('project:add-integration', projectId, name, type),
+      invoke<ProjectIntegrationResult>('project:add-integration', projectId, name, type),
     removeIntegration: (projectId: string, integrationId: string) =>
       invoke<void>('project:remove-integration', projectId, integrationId)
   },
@@ -235,6 +244,8 @@ const api = {
       invoke<BrokerSpawnAgentResult>('broker:spawn-persona', projectId, personaId),
     attachTerminal: (input: BrokerAttachTerminalInput) =>
       invoke<BrokerAttachTerminalResult>('broker:attach-terminal', input),
+    sendInput: (projectId: string | undefined, name: string, data: string) =>
+      invoke<{ name: string; bytes_written: number }>('broker:send-input', projectId, name, data),
     sendInputFast: (projectId: string | undefined, name: string, data: string): void => {
       ipcRenderer.send('broker:send-input-fast', projectId, name, data)
     },

src/renderer/src/components/settings/ProjectSettings.tsx

@@ -842,9 +842,13 @@ export function ProjectSettings(): React.ReactNode {
   const activeChannelName = useProjectStore((s) => s.activeChannelName)
   const setActiveRoot = useProjectStore((s) => s.setActiveRoot)
   const setActiveChannel = useProjectStore((s) => s.setActiveChannel)
+  const setActiveProject = useProjectStore((s) => s.setActiveProject)
   const updateProject = useProjectStore((s) => s.updateProject)
   const removeProject = useProjectStore((s) => s.removeProject)
   const addRoot = useProjectStore((s) => s.addRoot)
+  const clearRootConflict = useProjectStore((s) => s.clearRootConflict)
+  const createWorktreeRoot = useProjectStore((s) => s.createWorktreeRoot)
+  const pendingRootConflict = useProjectStore((s) => s.pendingRootConflict)
   const removeRoot = useProjectStore((s) => s.removeRoot)
   const addChannel = useProjectStore((s) => s.addChannel)
   const removeChannel = useProjectStore((s) => s.removeChannel)
@@ -1023,6 +1027,47 @@ export function ProjectSettings(): React.ReactNode {
                 }}
               />
             ))}
+            {pendingRootConflict?.projectId === project.id && (
+              <div className="rounded-lg border border-[var(--pear-yellow,#f59e0b)]/30 bg-[var(--pear-yellow,#f59e0b)]/10 p-4 text-sm">
+                <p className="mb-1 font-medium text-[var(--pear-text)]">Repo already in another project</p>
+                <p className="mb-3 text-[var(--pear-text-dim)]">
+                  <span className="font-mono text-xs">{pendingRootConflict.path}</span> is already part of{' '}
+                  <strong>{pendingRootConflict.existingProjectName}</strong>. Create an isolated git worktree
+                  so both projects can work independently, or go to the existing project.
+                </p>
+                <div className="flex flex-wrap gap-2">
+                  <button
+                    type="button"
+                    onClick={() =>
+                      void run(async () => {
+                        const root = await createWorktreeRoot(pendingRootConflict.path)
+                        if (root) clearRootConflict()
+                      })
+                    }
+                    className="rounded-md bg-[var(--pear-accent)] px-3 py-1.5 text-xs font-medium text-white hover:bg-[var(--pear-accent-bright)]"
+                  >
+                    Create worktree
+                  </button>
+                  <button
+                    type="button"
+                    onClick={() => {
+                      clearRootConflict()
+                      void setActiveProject(pendingRootConflict.existingProjectId)
+                    }}
+                    className="rounded-md border border-[var(--pear-border)] px-3 py-1.5 text-xs text-[var(--pear-text-dim)] hover:bg-[var(--pear-bg-overlay)] hover:text-[var(--pear-text)]"
+                  >
+                    Go to &ldquo;{pendingRootConflict.existingProjectName}&rdquo;
+                  </button>
+                  <button
+                    type="button"
+                    onClick={clearRootConflict}
+                    className="rounded-md px-3 py-1.5 text-xs text-[var(--pear-text-faint)] hover:text-[var(--pear-text-dim)]"
+                  >
+                    Cancel
+                  </button>
+                </div>
+              </div>
+            )}
           </div>
         </Section>
 

src/renderer/src/components/sidebar/SpawnAgentDialog.tsx

@@ -4,7 +4,7 @@ import { Loader2, X } from 'lucide-react'
 import { ClaudeIcon, CodexIcon } from '@/components/common/AgentIcons'
 import { listProjectPersonas, spawnProjectAgent, spawnProjectPersona, type SpawnAgentCli } from '@/lib/spawn-agent'
 import type { WorkforcePersona } from '@/lib/ipc'
-import { useProjectStore } from '@/stores/project-store'
+import { useProjectStore, type ProjectRoot } from '@/stores/project-store'
 import { useUIStore } from '@/stores/ui-store'
 
 const AGENT_OPTIONS: Array<{ cli: SpawnAgentCli; label: string; Icon: typeof ClaudeIcon }> = [
@@ -20,8 +20,12 @@ export function SpawnAgentDialog(): React.ReactNode {
   const [selectedPersonaId, setSelectedPersonaId] = useState('')
   const [customName, setCustomName] = useState('')
   const [error, setError] = useState<string | null>(null)
+  const [selectedRootId, setSelectedRootId] = useState<string | null>(null)
   const project = useProjectStore((s) => s.getActiveProject())
-  const root = useProjectStore((s) => s.getActiveRoot())
+  const defaultRoot = useProjectStore((s) => s.getActiveRoot())
+  const selectedRoot = project?.roots.find((r) => r.id === selectedRootId)
+  const root: ProjectRoot | undefined = selectedRoot ?? defaultRoot
+  const safeSelectedRootId = project?.roots.some((r) => r.id === selectedRootId) ? selectedRootId ?? '' : root?.id ?? ''
   const closeDialog = useUIStore((s) => s.closeDialog)
   const openDialog = useUIStore((s) => s.openDialog)
   const dialogRef = useRef<HTMLDivElement>(null)
@@ -35,6 +39,12 @@ export function SpawnAgentDialog(): React.ReactNode {
     return () => document.removeEventListener('keydown', handleKeyDown)
   }, [closeDialog])
 
+  useEffect(() => {
+    if (selectedRootId && !project?.roots.some((r) => r.id === selectedRootId)) {
+      setSelectedRootId(root?.id ?? null)
+    }
+  }, [project, root?.id, selectedRootId])
+
   useEffect(() => {
     let cancelled = false
 
@@ -48,7 +58,7 @@ export function SpawnAgentDialog(): React.ReactNode {
 
       setLoadingPersonas(true)
       try {
-        const discovered = await listProjectPersonas(project)
+        const discovered = await listProjectPersonas(project, root)
         if (cancelled) return
         setError(null)
         setPersonas(discovered)
@@ -104,7 +114,7 @@ export function SpawnAgentDialog(): React.ReactNode {
     setError(null)
     setSpawningCli(cli)
     try {
-      await spawnProjectAgent(project, cli, customName)
+      await spawnProjectAgent(project, cli, customName, root)
       closeDialog()
     } catch (err) {
       setError(err instanceof Error ? err.message : String(err))
@@ -127,7 +137,7 @@ export function SpawnAgentDialog(): React.ReactNode {
     setError(null)
     setSpawningPersona(true)
     try {
-      await spawnProjectPersona(project, selectedPersonaId)
+      await spawnProjectPersona(project, selectedPersonaId, root)
       closeDialog()
     } catch (err) {
       setError(err instanceof Error ? err.message : String(err))
@@ -160,6 +170,26 @@ export function SpawnAgentDialog(): React.ReactNode {
         <div className="px-5 py-5">
           {project ? (
             <div className="space-y-3">
+              {project.roots.length > 1 && (
+                <div>
+                  <label htmlFor="spawn-root-select" className="mb-1 block text-xs font-medium text-[var(--pear-text-dim)]">
+                    Spawn into
+                  </label>
+                  <select
+                    id="spawn-root-select"
+                    value={safeSelectedRootId}
+                    onChange={(e) => setSelectedRootId(e.target.value)}
+                    disabled={spawning}
+                    className="h-9 w-full rounded-md border border-[var(--pear-border-subtle)] bg-[var(--pear-bg)] px-3 text-sm text-[var(--pear-text)] outline-none focus:border-[var(--pear-accent-dim)] disabled:opacity-50"
+                  >
+                    {project.roots.map((r) => (
+                      <option key={r.id} value={r.id}>
+                        {r.name}
+                      </option>
+                    ))}
+                  </select>
+                </div>
+              )}
               <div className="truncate text-xs text-[var(--pear-text-faint)]">{root?.path || project.rootPath}</div>
               <div>
                 <label htmlFor="spawn-agent-name" className="mb-1 block text-xs font-medium text-[var(--pear-text-dim)]">

src/renderer/src/components/terminal/TerminalInstance.tsx

@@ -10,11 +10,14 @@ interface Props {
   active: boolean
   mode: TerminalAttachMode
   onActivate?: () => void
+  autoHold?: boolean
+  onAutoHoldStart?: () => Promise<void> | void
+  onAutoHoldRelease?: (flush: boolean) => Promise<void> | void
 }
 
-export function TerminalInstance({ agentName, projectId, visible, active, mode, onActivate }: Props): React.ReactNode {
+export function TerminalInstance({ agentName, projectId, visible, active, mode, onActivate, autoHold, onAutoHoldStart, onAutoHoldRelease }: Props): React.ReactNode {
   const containerRef = useRef<HTMLDivElement>(null)
-  useTerminal(containerRef, agentName, projectId, visible, active, mode)
+  useTerminal(containerRef, agentName, projectId, visible, active, mode, autoHold, onAutoHoldStart, onAutoHoldRelease)
 
   return (
     <div