@cluesmith/codev 2.0.0-rc.73 → 2.0.0-rc.74

package/dist/agent-farm/servers/tower-routes.js

@@ -20,7 +20,7 @@ import { fileURLToPath } from 'node:url';
 import { parseJsonBody, isRequestAllowed } from '../utils/server-utils.js';
 import { isRateLimited, normalizeProjectPath, getLanguageForExt, getMimeTypeForFile, serveStaticFile, } from './tower-utils.js';
 import { handleTunnelEndpoint } from './tower-tunnel.js';
-import { getKnownProjectPaths, getInstances, getDirectorySuggestions, launchInstance, killTerminalWithShepherd, stopInstance, } from './tower-instances.js';
+import { getKnownProjectPaths, getInstances, getDirectorySuggestions, launchInstance, killTerminalWithShellper, stopInstance, } from './tower-instances.js';
 import { getProjectTerminals, getTerminalManager, getProjectTerminalsEntry, getNextShellId, saveTerminalSession, isSessionPersistent, deleteTerminalSession, deleteProjectTerminalSessions, saveFileTab, deleteFileTab, getTerminalsForProject, } from './tower-terminals.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -223,22 +223,22 @@ async function handleTerminalCreate(req, res, ctx) {
         const cwd = typeof body.cwd === 'string' ? body.cwd : undefined;
         const env = typeof body.env === 'object' && body.env !== null ? body.env : undefined;
         const label = typeof body.label === 'string' ? body.label : undefined;
-        // Optional session persistence via shepherd
+        // Optional session persistence via shellper
         const projectPath = typeof body.projectPath === 'string' ? body.projectPath : null;
         const termType = typeof body.type === 'string' && ['builder', 'shell'].includes(body.type) ? body.type : null;
         const roleId = typeof body.roleId === 'string' ? body.roleId : null;
         const requestPersistence = body.persistent === true;
         let info;
         let persistent = false;
-        // Try shepherd if persistence was requested
-        const shepherdManager = ctx.getShepherdManager();
-        if (requestPersistence && shepherdManager && command && cwd) {
+        // Try shellper if persistence was requested
+        const shellperManager = ctx.getShellperManager();
+        if (requestPersistence && shellperManager && command && cwd) {
             try {
                 const sessionId = crypto.randomUUID();
                 // Strip CLAUDECODE so spawned Claude processes don't detect nesting
                 const sessionEnv = { ...(env || process.env) };
                 delete sessionEnv['CLAUDECODE'];
-                const client = await shepherdManager.createSession({
+                const client = await shellperManager.createSession({
                     sessionId,
                     command,
                     args: args || [],
@@ -249,14 +249,14 @@ async function handleTerminalCreate(req, res, ctx) {
                     restartOnExit: false,
                 });
                 const replayData = client.getReplayData() ?? Buffer.alloc(0);
-                const shepherdInfo = shepherdManager.getSessionInfo(sessionId);
+                const shellperInfo = shellperManager.getSessionInfo(sessionId);
                 const session = manager.createSessionRaw({
                     label: label || `terminal-${sessionId.slice(0, 8)}`,
                     cwd,
                 });
                 const ptySession = manager.getSession(session.id);
                 if (ptySession) {
-                    ptySession.attachShepherd(client, replayData, shepherdInfo.pid, sessionId);
+                    ptySession.attachShellper(client, replayData, shellperInfo.pid, sessionId);
                 }
                 info = session;
                 persistent = true;
@@ -268,16 +268,16 @@ async function handleTerminalCreate(req, res, ctx) {
                     else {
                         entry.shells.set(roleId, session.id);
                     }
-                    saveTerminalSession(session.id, projectPath, termType, roleId, shepherdInfo.pid, shepherdInfo.socketPath, shepherdInfo.pid, shepherdInfo.startTime);
-                    ctx.log('INFO', `Registered shepherd terminal ${session.id} as ${termType} "${roleId}" for project ${projectPath}`);
+                    saveTerminalSession(session.id, projectPath, termType, roleId, shellperInfo.pid, shellperInfo.socketPath, shellperInfo.pid, shellperInfo.startTime);
+                    ctx.log('INFO', `Registered shellper terminal ${session.id} as ${termType} "${roleId}" for project ${projectPath}`);
                 }
             }
-            catch (shepherdErr) {
-                ctx.log('WARN', `Shepherd creation failed for terminal, falling back: ${shepherdErr.message}`);
+            catch (shellperErr) {
+                ctx.log('WARN', `Shellper creation failed for terminal, falling back: ${shellperErr.message}`);
             }
         }
         // Fallback: non-persistent session (graceful degradation per plan)
-        // Shepherd is the only persistence backend for new sessions.
+        // Shellper is the only persistence backend for new sessions.
         if (!info) {
             info = await manager.createSession({ command, args, cols, rows, cwd, env, label });
             persistent = false;
@@ -290,7 +290,7 @@ async function handleTerminalCreate(req, res, ctx) {
                     entry.shells.set(roleId, info.id);
                 }
                 saveTerminalSession(info.id, projectPath, termType, roleId, info.pid);
-                ctx.log('WARN', `Terminal ${info.id} for ${projectPath} is non-persistent (shepherd unavailable)`);
+                ctx.log('WARN', `Terminal ${info.id} for ${projectPath} is non-persistent (shellper unavailable)`);
             }
         }
         res.writeHead(201, { 'Content-Type': 'application/json' });
@@ -324,9 +324,9 @@ async function handleTerminalRoutes(req, res, url, match) {
         res.end(JSON.stringify(session.info));
         return;
     }
-    // DELETE /api/terminals/:id - Kill terminal (disable shepherd auto-restart if applicable)
+    // DELETE /api/terminals/:id - Kill terminal (disable shellper auto-restart if applicable)
     if (req.method === 'DELETE' && (!subpath || subpath === '')) {
-        if (!(await killTerminalWithShepherd(manager, terminalId))) {
+        if (!(await killTerminalWithShellper(manager, terminalId))) {
             res.writeHead(404, { 'Content-Type': 'application/json' });
             res.end(JSON.stringify({ error: 'NOT_FOUND', message: `Session ${terminalId} not found` }));
             return;
@@ -798,7 +798,7 @@ async function handleProjectRoutes(req, res, ctx, url) {
 // ============================================================================
 async function handleProjectState(res, projectPath) {
     // Refresh cache via getTerminalsForProject (handles SQLite sync
-    // and shepherd reconnection in one place)
+    // and shellper reconnection in one place)
     const encodedPath = Buffer.from(projectPath).toString('base64url');
     const proxyUrl = `/project/${encodedPath}/`;
     const { gateStatus } = await getTerminalsForProject(projectPath, proxyUrl);
@@ -877,15 +877,15 @@ async function handleProjectShellCreate(res, ctx, projectPath) {
         const shellCmd = process.env.SHELL || '/bin/bash';
         const shellArgs = [];
         let shellCreated = false;
-        // Try shepherd first for persistent shell session
-        const shepherdManager = ctx.getShepherdManager();
-        if (shepherdManager) {
+        // Try shellper first for persistent shell session
+        const shellperManager = ctx.getShellperManager();
+        if (shellperManager) {
             try {
                 const sessionId = crypto.randomUUID();
                 // Strip CLAUDECODE so spawned Claude processes don't detect nesting
                 const shellEnv = { ...process.env };
                 delete shellEnv['CLAUDECODE'];
-                const client = await shepherdManager.createSession({
+                const client = await shellperManager.createSession({
                     sessionId,
                     command: shellCmd,
                     args: shellArgs,
@@ -896,18 +896,18 @@ async function handleProjectShellCreate(res, ctx, projectPath) {
                     restartOnExit: false,
                 });
                 const replayData = client.getReplayData() ?? Buffer.alloc(0);
-                const shepherdInfo = shepherdManager.getSessionInfo(sessionId);
+                const shellperInfo = shellperManager.getSessionInfo(sessionId);
                 const session = manager.createSessionRaw({
                     label: `Shell ${shellId.replace('shell-', '')}`,
                     cwd: projectPath,
                 });
                 const ptySession = manager.getSession(session.id);
                 if (ptySession) {
-                    ptySession.attachShepherd(client, replayData, shepherdInfo.pid, sessionId);
+                    ptySession.attachShellper(client, replayData, shellperInfo.pid, sessionId);
                 }
                 const entry = getProjectTerminalsEntry(projectPath);
                 entry.shells.set(shellId, session.id);
-                saveTerminalSession(session.id, projectPath, 'shell', shellId, shepherdInfo.pid, shepherdInfo.socketPath, shepherdInfo.pid, shepherdInfo.startTime);
+                saveTerminalSession(session.id, projectPath, 'shell', shellId, shellperInfo.pid, shellperInfo.socketPath, shellperInfo.pid, shellperInfo.startTime);
                 shellCreated = true;
                 res.writeHead(200, { 'Content-Type': 'application/json' });
                 res.end(JSON.stringify({
@@ -918,12 +918,12 @@ async function handleProjectShellCreate(res, ctx, projectPath) {
                     persistent: true,
                 }));
             }
-            catch (shepherdErr) {
-                ctx.log('WARN', `Shepherd creation failed for shell, falling back: ${shepherdErr.message}`);
+            catch (shellperErr) {
+                ctx.log('WARN', `Shellper creation failed for shell, falling back: ${shellperErr.message}`);
             }
         }
         // Fallback: non-persistent session (graceful degradation per plan)
-        // Shepherd is the only persistence backend for new sessions.
+        // Shellper is the only persistence backend for new sessions.
         if (!shellCreated) {
             const session = await manager.createSession({
                 command: shellCmd,
@@ -935,7 +935,7 @@ async function handleProjectShellCreate(res, ctx, projectPath) {
             const entry = getProjectTerminalsEntry(projectPath);
             entry.shells.set(shellId, session.id);
             saveTerminalSession(session.id, projectPath, 'shell', shellId, session.pid);
-            ctx.log('WARN', `Shell ${shellId} for ${projectPath} is non-persistent (shepherd unavailable)`);
+            ctx.log('WARN', `Shell ${shellId} for ${projectPath} is non-persistent (shellper unavailable)`);
             res.writeHead(200, { 'Content-Type': 'application/json' });
             res.end(JSON.stringify({
                 id: shellId,
@@ -1173,8 +1173,8 @@ async function handleProjectTabDelete(res, ctx, projectPath, tabId) {
         }
     }
     if (terminalId) {
-        // Disable shepherd auto-restart if applicable, then kill the PtySession
-        await killTerminalWithShepherd(manager, terminalId);
+        // Disable shellper auto-restart if applicable, then kill the PtySession
+        await killTerminalWithShellper(manager, terminalId);
         // TICK-001: Delete from SQLite
         deleteTerminalSession(terminalId);
         res.writeHead(204);
@@ -1188,15 +1188,15 @@ async function handleProjectTabDelete(res, ctx, projectPath, tabId) {
 async function handleProjectStopAll(res, projectPath) {
     const entry = getProjectTerminalsEntry(projectPath);
     const manager = getTerminalManager();
-    // Kill all terminals (disable shepherd auto-restart if applicable)
+    // Kill all terminals (disable shellper auto-restart if applicable)
     if (entry.architect) {
-        await killTerminalWithShepherd(manager, entry.architect);
+        await killTerminalWithShellper(manager, entry.architect);
     }
     for (const terminalId of entry.shells.values()) {
-        await killTerminalWithShepherd(manager, terminalId);
+        await killTerminalWithShellper(manager, terminalId);
     }
     for (const terminalId of entry.builders.values()) {
-        await killTerminalWithShepherd(manager, terminalId);
+        await killTerminalWithShellper(manager, terminalId);
     }
     // Clear registry
     getProjectTerminals().delete(projectPath);

package/dist/agent-farm/servers/tower-server.js

@@ -26,8 +26,8 @@ const __dirname = path.dirname(__filename);
 const DEFAULT_PORT = 4100;
 // Rate limiting: cleanup interval for token bucket
 const rateLimitCleanupInterval = startRateLimitCleanup();
-// Shepherd session manager (initialized at startup)
-let shepherdManager = null;
+// Shellper session manager (initialized at startup)
+let shellperManager = null;
 // Parse arguments with Commander
 const program = new Command()
     .name('tower-server')
@@ -84,14 +84,14 @@ async function gracefulShutdown(signal) {
         }
         terminalWss.close();
     }
-    // 3. Shepherd clients: do NOT call shepherdManager.shutdown() here.
-    // SessionManager.shutdown() disconnects sockets, which triggers ShepherdClient
+    // 3. Shellper clients: do NOT call shellperManager.shutdown() here.
+    // SessionManager.shutdown() disconnects sockets, which triggers ShellperClient
     // 'close' events → PtySession exit(-1) → SQLite row deletion. This would erase
     // the rows that reconcileTerminalSessions() needs on restart.
-    // Instead, let the process exit naturally — OS closes all sockets, and shepherds
+    // Instead, let the process exit naturally — OS closes all sockets, and shellpers
     // detect the disconnection and keep running. SQLite rows are preserved.
-    if (shepherdManager) {
-        log('INFO', 'Shepherd sessions will continue running (sockets close on process exit)');
+    if (shellperManager) {
+        log('INFO', 'Shellper sessions will continue running (sockets close on process exit)');
     }
     // 4. Stop rate limit cleanup
     clearInterval(rateLimitCleanupInterval);
@@ -168,7 +168,7 @@ const routeCtx = {
     templatePath,
     reactDashboardPath,
     hasReactDashboard,
-    getShepherdManager: () => shepherdManager,
+    getShellperManager: () => shellperManager,
     broadcastNotification,
     addSseClient: (client) => {
         sseClients.push(client);
@@ -189,23 +189,23 @@ const server = http.createServer(async (req, res) => {
 // SECURITY: Bind to localhost only to prevent network exposure
 server.listen(port, '127.0.0.1', async () => {
     log('INFO', `Tower server listening at http://localhost:${port}`);
-    // Initialize shepherd session manager for persistent terminals
+    // Initialize shellper session manager for persistent terminals
     const socketDir = path.join(homedir(), '.codev', 'run');
-    const shepherdScript = path.join(__dirname, '..', '..', 'terminal', 'shepherd-main.js');
-    shepherdManager = new SessionManager({
+    const shellperScript = path.join(__dirname, '..', '..', 'terminal', 'shellper-main.js');
+    shellperManager = new SessionManager({
         socketDir,
-        shepherdScript,
+        shellperScript,
         nodeExecutable: process.execPath,
     });
-    const staleCleaned = await shepherdManager.cleanupStaleSockets();
+    const staleCleaned = await shellperManager.cleanupStaleSockets();
     if (staleCleaned > 0) {
-        log('INFO', `Cleaned up ${staleCleaned} stale shepherd socket(s)`);
+        log('INFO', `Cleaned up ${staleCleaned} stale shellper socket(s)`);
     }
-    log('INFO', 'Shepherd session manager initialized');
+    log('INFO', 'Shellper session manager initialized');
     // Spec 0105 Phase 4: Initialize terminal management module
     initTerminals({
         log,
-        shepherdManager,
+        shellperManager,
         registerKnownProject,
         getKnownProjectPaths,
     });
@@ -216,7 +216,7 @@ server.listen(port, '127.0.0.1', async () => {
         log,
         projectTerminals: getProjectTerminals(),
         getTerminalManager,
-        shepherdManager,
+        shellperManager,
         getProjectTerminalsEntry,
         saveTerminalSession,
         deleteTerminalSession,

package/dist/agent-farm/servers/tower-terminals.d.ts

@@ -15,8 +15,8 @@ import type { ProjectTerminals, TerminalEntry, DbTerminalSession } from './tower
 export interface TerminalDeps {
     /** Logging function */
     log: (level: 'INFO' | 'ERROR' | 'WARN', msg: string) => void;
-    /** Shepherd session manager for persistent terminals */
-    shepherdManager: SessionManager | null;
+    /** Shellper session manager for persistent terminals */
+    shellperManager: SessionManager | null;
     /** Register a known project path (from tower-instances) */
     registerKnownProject: (projectPath: string) => void;
     /** Get all known project paths (from tower-instances) */
@@ -47,9 +47,9 @@ export declare function getNextShellId(projectPath: string): string;
  * Save a terminal session to SQLite.
  * Guards against race conditions by checking if project is still active.
  */
-export declare function saveTerminalSession(terminalId: string, projectPath: string, type: 'architect' | 'builder' | 'shell', roleId: string | null, pid: number | null, shepherdSocket?: string | null, shepherdPid?: number | null, shepherdStartTime?: number | null): void;
+export declare function saveTerminalSession(terminalId: string, projectPath: string, type: 'architect' | 'builder' | 'shell', roleId: string | null, pid: number | null, shellperSocket?: string | null, shellperPid?: number | null, shellperStartTime?: number | null): void;
 /**
- * Check if a terminal session is persistent (shepherd-backed).
+ * Check if a terminal session is persistent (shellper-backed).
  * A session is persistent if it can survive a Tower restart.
  */
 export declare function isSessionPersistent(_terminalId: string, session: PtySession): boolean;
@@ -89,11 +89,11 @@ export declare function processExists(pid: number): boolean;
 /**
  * Reconcile terminal sessions on startup.
  *
- * DUAL-SOURCE STRATEGY (shepherd + SQLite):
+ * DUAL-SOURCE STRATEGY (shellper + SQLite):
  *
- * Phase 1 — Shepherd reconnection:
- *   For SQLite rows with shepherd_socket IS NOT NULL, attempt to reconnect
- *   via SessionManager.reconnectSession(). Shepherd processes survive Tower
+ * Phase 1 — Shellper reconnection:
+ *   For SQLite rows with shellper_socket IS NOT NULL, attempt to reconnect
+ *   via SessionManager.reconnectSession(). Shellper processes survive Tower
  *   restarts as detached OS processes.
  *
  * Phase 2 — SQLite sweep:

package/dist/agent-farm/servers/tower-terminals.js

@@ -13,7 +13,7 @@ import { getGateStatusForProject } from '../utils/gate-status.js';
 import { GateWatcher } from '../utils/gate-watcher.js';
 import { saveFileTab as saveFileTabToDb, deleteFileTab as deleteFileTabFromDb, loadFileTabsForProject as loadFileTabsFromDb, } from '../utils/file-tabs.js';
 import { TerminalManager } from '../../terminal/pty-manager.js';
-import { normalizeProjectPath } from './tower-utils.js';
+import { normalizeProjectPath, buildArchitectArgs } from './tower-utils.js';
 // ============================================================================
 // Module-private state (lifecycle driven by orchestrator)
 // ============================================================================
@@ -110,7 +110,7 @@ export function getNextShellId(projectPath) {
  * Save a terminal session to SQLite.
  * Guards against race conditions by checking if project is still active.
  */
-export function saveTerminalSession(terminalId, projectPath, type, roleId, pid, shepherdSocket = null, shepherdPid = null, shepherdStartTime = null) {
+export function saveTerminalSession(terminalId, projectPath, type, roleId, pid, shellperSocket = null, shellperPid = null, shellperStartTime = null) {
     try {
         const normalizedPath = normalizeProjectPath(projectPath);
         // Race condition guard: only save if project is still in the active registry
@@ -121,9 +121,9 @@ export function saveTerminalSession(terminalId, projectPath, type, roleId, pid,
         }
         const db = getGlobalDb();
         db.prepare(`
-      INSERT OR REPLACE INTO terminal_sessions (id, project_path, type, role_id, pid, shepherd_socket, shepherd_pid, shepherd_start_time)
+      INSERT OR REPLACE INTO terminal_sessions (id, project_path, type, role_id, pid, shellper_socket, shellper_pid, shellper_start_time)
       VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(terminalId, normalizedPath, type, roleId, pid, shepherdSocket, shepherdPid, shepherdStartTime);
+    `).run(terminalId, normalizedPath, type, roleId, pid, shellperSocket, shellperPid, shellperStartTime);
         _deps?.log('INFO', `Saved terminal session to SQLite: ${terminalId} (${type}) for ${path.basename(normalizedPath)}`);
     }
     catch (err) {
@@ -131,11 +131,11 @@ export function saveTerminalSession(terminalId, projectPath, type, roleId, pid,
     }
 }
 /**
- * Check if a terminal session is persistent (shepherd-backed).
+ * Check if a terminal session is persistent (shellper-backed).
  * A session is persistent if it can survive a Tower restart.
  */
 export function isSessionPersistent(_terminalId, session) {
-    return session.shepherdBacked;
+    return session.shellperBacked;
 }
 /**
  * Delete a terminal session from SQLite
@@ -244,11 +244,11 @@ export function processExists(pid) {
 /**
  * Reconcile terminal sessions on startup.
  *
- * DUAL-SOURCE STRATEGY (shepherd + SQLite):
+ * DUAL-SOURCE STRATEGY (shellper + SQLite):
  *
- * Phase 1 — Shepherd reconnection:
- *   For SQLite rows with shepherd_socket IS NOT NULL, attempt to reconnect
- *   via SessionManager.reconnectSession(). Shepherd processes survive Tower
+ * Phase 1 — Shellper reconnection:
+ *   For SQLite rows with shellper_socket IS NOT NULL, attempt to reconnect
+ *   via SessionManager.reconnectSession(). Shellper processes survive Tower
  *   restarts as detached OS processes.
  *
  * Phase 2 — SQLite sweep:
@@ -262,13 +262,13 @@ export async function reconcileTerminalSessions() {
         return;
     const manager = getTerminalManager();
     const db = getGlobalDb();
-    let shepherdReconnected = 0;
+    let shellperReconnected = 0;
     let orphanReconnected = 0;
     let killed = 0;
     let cleaned = 0;
     // Track matched session IDs across all phases
     const matchedSessionIds = new Set();
-    // ---- Phase 1: Shepherd reconnection ----
+    // ---- Phase 1: Shellper reconnection ----
     let allDbSessions;
     try {
         allDbSessions = db.prepare('SELECT * FROM terminal_sessions').all();
@@ -277,19 +277,19 @@ export async function reconcileTerminalSessions() {
         _deps.log('WARN', `Failed to read terminal sessions: ${err.message}`);
         allDbSessions = [];
     }
-    const shepherdSessions = allDbSessions.filter(s => s.shepherd_socket !== null);
-    if (shepherdSessions.length > 0) {
-        _deps.log('INFO', `Found ${shepherdSessions.length} shepherd session(s) in SQLite — reconnecting...`);
+    const shellperSessions = allDbSessions.filter(s => s.shellper_socket !== null);
+    if (shellperSessions.length > 0) {
+        _deps.log('INFO', `Found ${shellperSessions.length} shellper session(s) in SQLite — reconnecting...`);
     }
-    for (const dbSession of shepherdSessions) {
+    for (const dbSession of shellperSessions) {
         const projectPath = dbSession.project_path;
         // Skip sessions whose project path doesn't exist or is in temp directory
         if (!fs.existsSync(projectPath)) {
-            _deps.log('INFO', `Skipping shepherd session ${dbSession.id} — project path no longer exists: ${projectPath}`);
-            // Kill orphaned shepherd process before removing row
-            if (dbSession.shepherd_pid && processExists(dbSession.shepherd_pid)) {
+            _deps.log('INFO', `Skipping shellper session ${dbSession.id} — project path no longer exists: ${projectPath}`);
+            // Kill orphaned shellper process before removing row
+            if (dbSession.shellper_pid && processExists(dbSession.shellper_pid)) {
                 try {
-                    process.kill(dbSession.shepherd_pid, 'SIGTERM');
+                    process.kill(dbSession.shellper_pid, 'SIGTERM');
                     killed++;
                 }
                 catch { /* not killable */ }
@@ -300,11 +300,11 @@ export async function reconcileTerminalSessions() {
         }
         const tmpDirs = ['/tmp', '/private/tmp', '/var/folders', '/private/var/folders'];
         if (tmpDirs.some(d => projectPath === d || projectPath.startsWith(d + '/'))) {
-            _deps.log('INFO', `Skipping shepherd session ${dbSession.id} — project is in temp directory: ${projectPath}`);
-            // Kill orphaned shepherd process before removing row
-            if (dbSession.shepherd_pid && processExists(dbSession.shepherd_pid)) {
+            _deps.log('INFO', `Skipping shellper session ${dbSession.id} — project is in temp directory: ${projectPath}`);
+            // Kill orphaned shellper process before removing row
+            if (dbSession.shellper_pid && processExists(dbSession.shellper_pid)) {
                 try {
-                    process.kill(dbSession.shepherd_pid, 'SIGTERM');
+                    process.kill(dbSession.shellper_pid, 'SIGTERM');
                     killed++;
                 }
                 catch { /* not killable */ }
@@ -313,8 +313,8 @@ export async function reconcileTerminalSessions() {
             cleaned++;
             continue;
         }
-        if (!_deps.shepherdManager) {
-            _deps.log('WARN', `Shepherd manager not initialized — cannot reconnect ${dbSession.id}`);
+        if (!_deps.shellperManager) {
+            _deps.log('WARN', `Shellper manager not initialized — cannot reconnect ${dbSession.id}`);
             continue;
         }
         try {
@@ -337,25 +337,25 @@ export async function reconcileTerminalSessions() {
                 delete cleanEnv['CLAUDECODE'];
                 restartOptions = {
                     command: cmdParts[0],
-                    args: cmdParts.slice(1),
+                    args: buildArchitectArgs(cmdParts.slice(1), projectPath),
                     cwd: projectPath,
                     env: cleanEnv,
                     restartDelay: 2000,
                     maxRestarts: 50,
                 };
             }
-            const client = await _deps.shepherdManager.reconnectSession(dbSession.id, dbSession.shepherd_socket, dbSession.shepherd_pid, dbSession.shepherd_start_time, restartOptions);
+            const client = await _deps.shellperManager.reconnectSession(dbSession.id, dbSession.shellper_socket, dbSession.shellper_pid, dbSession.shellper_start_time, restartOptions);
             if (!client) {
-                _deps.log('INFO', `Shepherd session ${dbSession.id} is stale (PID/socket dead) — will clean up`);
+                _deps.log('INFO', `Shellper session ${dbSession.id} is stale (PID/socket dead) — will clean up`);
                 continue; // Will be cleaned up in Phase 2
             }
             const replayData = client.getReplayData() ?? Buffer.alloc(0);
             const label = dbSession.type === 'architect' ? 'Architect' : `${dbSession.type} ${dbSession.role_id || 'unknown'}`;
-            // Create a PtySession backed by the reconnected shepherd client
+            // Create a PtySession backed by the reconnected shellper client
             const session = manager.createSessionRaw({ label, cwd: projectPath });
             const ptySession = manager.getSession(session.id);
             if (ptySession) {
-                ptySession.attachShepherd(client, replayData, dbSession.shepherd_pid, dbSession.id);
+                ptySession.attachShellper(client, replayData, dbSession.shellper_pid, dbSession.id);
             }
             // Register in projectTerminals Map
             const entry = getProjectTerminalsEntry(projectPath);
@@ -370,7 +370,7 @@ export async function reconcileTerminalSessions() {
             }
             // Update SQLite with new terminal ID
             db.prepare('DELETE FROM terminal_sessions WHERE id = ?').run(dbSession.id);
-            saveTerminalSession(session.id, projectPath, dbSession.type, dbSession.role_id, dbSession.shepherd_pid, dbSession.shepherd_socket, dbSession.shepherd_pid, dbSession.shepherd_start_time);
+            saveTerminalSession(session.id, projectPath, dbSession.type, dbSession.role_id, dbSession.shellper_pid, dbSession.shellper_socket, dbSession.shellper_pid, dbSession.shellper_start_time);
             _deps.registerKnownProject(projectPath);
             // Clean up on exit
             if (ptySession) {
@@ -383,11 +383,11 @@ export async function reconcileTerminalSessions() {
                 });
             }
             matchedSessionIds.add(dbSession.id);
-            shepherdReconnected++;
-            _deps.log('INFO', `Reconnected shepherd session → ${session.id} (${dbSession.type} for ${path.basename(projectPath)})`);
+            shellperReconnected++;
+            _deps.log('INFO', `Reconnected shellper session → ${session.id} (${dbSession.type} for ${path.basename(projectPath)})`);
         }
         catch (err) {
-            _deps.log('WARN', `Failed to reconnect shepherd session ${dbSession.id}: ${err.message}`);
+            _deps.log('WARN', `Failed to reconnect shellper session ${dbSession.id}: ${err.message}`);
         }
     }
     // ---- Phase 2: Sweep stale SQLite rows ----
@@ -409,9 +409,9 @@ export async function reconcileTerminalSessions() {
         db.prepare('DELETE FROM terminal_sessions WHERE id = ?').run(session.id);
         cleaned++;
     }
-    const total = shepherdReconnected + orphanReconnected;
+    const total = shellperReconnected + orphanReconnected;
     if (total > 0 || killed > 0 || cleaned > 0) {
-        _deps.log('INFO', `Reconciliation complete: ${shepherdReconnected} shepherd, ${orphanReconnected} orphan, ${killed} killed, ${cleaned} stale rows cleaned`);
+        _deps.log('INFO', `Reconciliation complete: ${shellperReconnected} shellper, ${orphanReconnected} orphan, ${killed} killed, ${cleaned} stale rows cleaned`);
     }
     else {
         _deps.log('INFO', 'No terminal sessions to reconcile');
@@ -457,7 +457,7 @@ export function stopGateWatcher() {
 export async function getTerminalsForProject(projectPath, proxyUrl) {
     const manager = getTerminalManager();
     const terminals = [];
-    // Query SQLite first, then augment with shepherd reconnection
+    // Query SQLite first, then augment with shellper reconnection
     const dbSessions = getTerminalSessionsForProject(projectPath);
     // Use normalized path for cache consistency
     const normalizedPath = normalizeProjectPath(projectPath);
@@ -478,8 +478,8 @@ export async function getTerminalsForProject(projectPath, proxyUrl) {
     for (const dbSession of dbSessions) {
         // Verify session still exists in TerminalManager (runtime state)
         let session = manager.getSession(dbSession.id);
-        if (!session && dbSession.shepherd_socket && _deps?.shepherdManager) {
-            // PTY session gone but shepherd may still be alive — reconnect on-the-fly
+        if (!session && dbSession.shellper_socket && _deps?.shellperManager) {
+            // PTY session gone but shellper may still be alive — reconnect on-the-fly
             try {
                 // Restore auto-restart for architect sessions (same as startup reconciliation)
                 let restartOptions;
@@ -500,21 +500,21 @@ export async function getTerminalsForProject(projectPath, proxyUrl) {
                     delete cleanEnv['CLAUDECODE'];
                     restartOptions = {
                         command: cmdParts[0],
-                        args: cmdParts.slice(1),
+                        args: buildArchitectArgs(cmdParts.slice(1), dbSession.project_path),
                         cwd: dbSession.project_path,
                         env: cleanEnv,
                         restartDelay: 2000,
                         maxRestarts: 50,
                     };
                 }
-                const client = await _deps.shepherdManager.reconnectSession(dbSession.id, dbSession.shepherd_socket, dbSession.shepherd_pid, dbSession.shepherd_start_time, restartOptions);
+                const client = await _deps.shellperManager.reconnectSession(dbSession.id, dbSession.shellper_socket, dbSession.shellper_pid, dbSession.shellper_start_time, restartOptions);
                 if (client) {
                     const replayData = client.getReplayData() ?? Buffer.alloc(0);
                     const label = dbSession.type === 'architect' ? 'Architect' : `${dbSession.type} ${dbSession.role_id || dbSession.id}`;
                     const newSession = manager.createSessionRaw({ label, cwd: dbSession.project_path });
                     const ptySession = manager.getSession(newSession.id);
                     if (ptySession) {
-                        ptySession.attachShepherd(client, replayData, dbSession.shepherd_pid, dbSession.id);
+                        ptySession.attachShellper(client, replayData, dbSession.shellper_pid, dbSession.id);
                         // Clean up on exit (same as startup reconciliation path)
                         ptySession.on('exit', () => {
                             const currentEntry = getProjectTerminalsEntry(dbSession.project_path);
@@ -525,14 +525,14 @@ export async function getTerminalsForProject(projectPath, proxyUrl) {
                         });
                     }
                     deleteTerminalSession(dbSession.id);
-                    saveTerminalSession(newSession.id, dbSession.project_path, dbSession.type, dbSession.role_id, dbSession.shepherd_pid, dbSession.shepherd_socket, dbSession.shepherd_pid, dbSession.shepherd_start_time);
+                    saveTerminalSession(newSession.id, dbSession.project_path, dbSession.type, dbSession.role_id, dbSession.shellper_pid, dbSession.shellper_socket, dbSession.shellper_pid, dbSession.shellper_start_time);
                     dbSession.id = newSession.id;
                     session = manager.getSession(newSession.id);
-                    _deps.log('INFO', `Reconnected to shepherd on-the-fly → ${newSession.id}`);
+                    _deps.log('INFO', `Reconnected to shellper on-the-fly → ${newSession.id}`);
                 }
             }
             catch (err) {
-                _deps.log('WARN', `Failed shepherd on-the-fly reconnect for ${dbSession.id}: ${err.message}`);
+                _deps.log('WARN', `Failed shellper on-the-fly reconnect for ${dbSession.id}: ${err.message}`);
             }
         }
         if (!session) {