termdock 1.4.69 → 1.4.71

package/dist/server/routes/terminal.js

@@ -6,7 +6,7 @@ import { createRequire } from 'module';
 import { fileURLToPath } from 'url';
 import QRCode from 'qrcode';
 import { execFile, spawn } from 'child_process';
-import { randomUUID } from 'crypto';
+import { createHash, randomUUID } from 'crypto';
 import { promisify } from 'util';
 import { caffeinateManager } from '../utils/caffeinate.js';
 import { gitStatusCache } from '../utils/gitStatus.js';
@@ -14,19 +14,22 @@ import { getPtyHostManager } from '../ptyhost/manager.js';
 import { pathValidator } from '../utils/pathValidator.js';
 import { TERMINAL, TMUX } from '../config.js';
 import { localAccessManager } from '../utils/localAccess.js';
-import { normalizeLocalAccessName, getLocaleSetting, setLocaleSetting, getContextDraftHeightSetting, setContextDraftHeightSetting, } from '../utils/settings.js';
+import { normalizeLocalAccessName, getLocaleSetting, setLocaleSetting, getContextDraftHeightSetting, setContextDraftHeightSetting, getAutoRenameAgentsSetting, setAutoRenameAgentsSetting, getAutoRenameNamerSetting, setAutoRenameNamerSetting, getAutoRenameModelsSetting, setAutoRenameModelsSetting, } from '../utils/settings.js';
 import { loadContextDraft, saveContextDraft } from '../utils/contextDraft.js';
 import { getOnboardingServerUrl } from '../onboardingServer.js';
 import { getFocusSequence, removeClientFocusState, scanFocusTrackingMode, setClientFocusState, } from '../utils/tmuxFocus.js';
 import { extractProgramLabelFromArgs, normalizeProgramName, normalizeTmuxMetadataProgram, selectTmuxForegroundProgram, tmuxMetadataChanged, } from '../utils/tmuxProgramDetection.js';
-import { agentBySlug, buildResumeCommand, detectAgentFromCommand, } from '../agent/registry.js';
-import { applyAgentEvent, defaultAgentSessionState, parseAgentEvent, } from '../agent/session.js';
+import { agentBySlug, buildResumeCommand, detectAgentFromCommand, listAgents, } from '../agent/registry.js';
+import { applyAgentEvent, agentEventMatchesCurrentAgent, defaultAgentSessionState, parseAgentEvent, } from '../agent/session.js';
 import { listAllHookAgents, refreshStaleHooksAtLaunch, installHooksForSlug, uninstallHooksForSlug, } from '../agent/installers.js';
-import { loadPlugins, savePlugin, removePlugin, readPluginIcon, } from '../agent/plugins.js';
-import { registerPluginAgents } from '../agent/registry.js';
+import { loadPlugins, savePlugin, removePlugin, readPluginIcon, validateManifest, } from '../agent/plugins.js';
+import { clearPluginAgents, registerPluginAgents } from '../agent/registry.js';
 import { notifyAgentTransition, notifyTerminalExit } from '../notifications/pushService.js';
 import { setClientViewingSession } from '../notifications/pushViewers.js';
 import { getQuotaStatus, refreshQuota, startQuotaManager, } from '../quota/QuotaManager.js';
+import { TermdockAutoUpdateManager } from '../utils/autoUpdate.js';
+import { AUTO_TITLE_MIN_CONTEXT_CHARS, cleanTerminalContext, generateAgentTitle, isNewAgentSessionId, shouldReplaceAutoTitle, } from '../agent/autoTitle.js';
+import { getTitleNamerCatalog, invalidateTitleNamerCatalog } from '../agent/titleNamerCatalog.js';
 const router = express.Router();
 const execFileAsync = promisify(execFile);
 const TERMDOCK_DIR = `${os.homedir()}/.termdock`;
@@ -193,6 +196,67 @@ function sendClientStatePayload(payload) {
 function broadcastControlEvent(payload) {
     sendClientStatePayload(JSON.stringify(payload));
 }
+let serverRestartScheduled = false;
+function requestServerRestartAfterUpdate() {
+    if (serverRestartScheduled)
+        return;
+    serverRestartScheduled = true;
+    // The bridge is detached before this process exits. It waits for the old
+    // PID to release the port, then resolves `termdock` from PATH again so an
+    // npm-replaced global binary is used instead of the old loaded file.
+    const bridgeSource = String.raw `
+const fs = require('node:fs');
+const { spawn } = require('node:child_process');
+const payload = JSON.parse(process.argv[1]);
+const alive = () => { try { process.kill(payload.parentPid, 0); return true; } catch { return false; } };
+const launch = () => {
+  let fd;
+  try { fd = fs.openSync(payload.logFile, 'a'); } catch { fd = 'ignore'; }
+  const command = process.platform === 'win32' ? 'termdock.cmd' : 'termdock';
+  const child = spawn(command, payload.args, {
+    detached: true,
+    stdio: ['ignore', fd, fd],
+    env: process.env,
+  });
+  child.unref();
+  if (typeof fd === 'number') fs.closeSync(fd);
+};
+const deadline = Date.now() + 15000;
+const timer = setInterval(() => {
+  if (alive() && Date.now() < deadline) return;
+  clearInterval(timer);
+  setTimeout(launch, 250);
+}, 100);
+`;
+    const payload = JSON.stringify({
+        parentPid: process.pid,
+        args: process.argv.slice(2),
+        logFile: path.join(TERMDOCK_DIR, 'server.log'),
+    });
+    const bridge = spawn(process.execPath, ['-e', bridgeSource, payload], {
+        detached: true,
+        stdio: 'ignore',
+        env: process.env,
+    });
+    bridge.unref();
+    const exitTimer = setTimeout(() => {
+        process.kill(process.pid, 'SIGTERM');
+    }, 750);
+    exitTimer.unref?.();
+}
+const npmAutoUpdateManager = new TermdockAutoUpdateManager({
+    currentVersion: TERMDOCK_VERSION,
+    stateFilePath: path.join(TERMDOCK_DIR, 'update-state.json'),
+    broadcast: (state) => broadcastControlEvent({ type: 'update-state', state }),
+    requestRestart: requestServerRestartAfterUpdate,
+    log: (message) => console.warn(message),
+});
+// Packaged desktop builds already have a signed app/runtime updater. The npm
+// updater only owns standalone CLI services, otherwise both mechanisms could
+// race to replace the runtime.
+if (process.env.TERMDOCK_DESKTOP !== '1') {
+    npmAutoUpdateManager.start();
+}
 async function flushClientStateBroadcast() {
     if (broadcastClientStateInFlight) {
         broadcastClientStateNeedsRerun = true;
@@ -643,6 +707,12 @@ function normalizePersistedClientSession(input) {
         sessionId: candidate.sessionId,
         name: candidate.name,
         customName: candidate.customName === true ? true : undefined,
+        autoTitle: candidate.autoTitle
+            && typeof candidate.autoTitle.agentSlug === 'string'
+            && typeof candidate.autoTitle.contentHash === 'string'
+            && typeof candidate.autoTitle.updatedAt === 'number'
+            ? candidate.autoTitle
+            : null,
         backendSessionId: typeof candidate.backendSessionId === 'string' && candidate.backendSessionId.trim().length > 0
             ? candidate.backendSessionId
             : null,
@@ -1301,7 +1371,10 @@ async function configureTmuxWheelBindings() {
     ]);
     await runTmux([
         'bind-key', '-n', 'MouseDrag1Pane',
-        "if-shell -F '#{||:#{pane_in_mode},#{mouse_any_flag}}' 'send-keys -M' 'if-shell -F \"#{||:#{e|>=:#{e|-:#{mouse_x},#{@termdock-mouse-down-x}},1},#{e|>=:#{e|-:#{@termdock-mouse-down-x},#{mouse_x}},1},#{e|>=:#{e|-:#{mouse_y},#{@termdock-mouse-down-y}},1},#{e|>=:#{e|-:#{@termdock-mouse-down-y},#{mouse_y}},1}}\" \"copy-mode -M\"'",
+        // xterm reports button-motion in character cells. A one-cell movement is
+        // common mouse jitter during an ordinary click, so require two cells before
+        // treating the gesture as an intentional text-selection drag.
+        "if-shell -F '#{||:#{pane_in_mode},#{mouse_any_flag}}' 'send-keys -M' 'if-shell -F \"#{||:#{||:#{e|>=:#{e|-:#{mouse_x},#{@termdock-mouse-down-x}},2},#{e|>=:#{e|-:#{@termdock-mouse-down-x},#{mouse_x}},2}},#{||:#{e|>=:#{e|-:#{mouse_y},#{@termdock-mouse-down-y}},2},#{e|>=:#{e|-:#{@termdock-mouse-down-y},#{mouse_y}},2}}}\" \"copy-mode -M\"'",
     ]);
     await runTmux([
         'bind-key', '-n', 'DoubleClick1Pane',
@@ -2054,6 +2127,102 @@ function detectSessionAgent(session) {
     }
     return null;
 }
+const AUTO_TITLE_CONTEXT_LIMIT = 24_000;
+const AUTO_TITLE_REEVALUATE_MS = 60 * 60_000;
+const autoTitlePending = new Set();
+function appendAutoTitleContext(session, data) {
+    session.autoTitleContext = (session.autoTitleContext + data).slice(-AUTO_TITLE_CONTEXT_LIMIT);
+}
+function clearAutoTitleForNewAgentSession(sessionId, session) {
+    const record = globalSessionState.sessions.find((item) => item.backendSessionId === sessionId);
+    if (!record?.autoTitle)
+        return;
+    const next = { ...record, customName: undefined, autoTitle: null };
+    upsertGlobalSessionRecord(next);
+    session.autoTitleContext = '';
+    if (next.mode === 'tmux' && next.tmuxSessionName) {
+        void unsetTmuxOption(next.tmuxSessionName, '@termdock-friendly-name');
+    }
+    schedulePersistGlobalState();
+    broadcastClientState();
+    console.log(`[auto-title] cleared stale title for new agent session in ${sessionId}`);
+}
+async function maybeAutoRenameSession(sessionId, agent, rawContext) {
+    if (autoTitlePending.has(sessionId))
+        return;
+    if (!getAutoRenameAgentsSetting().includes(agent.slug))
+        return;
+    const record = globalSessionState.sessions.find((item) => item.backendSessionId === sessionId);
+    if (!record || (record.customName === true && !record.autoTitle))
+        return;
+    if (record.autoTitle && Date.now() - record.autoTitle.updatedAt < AUTO_TITLE_REEVALUATE_MS)
+        return;
+    const context = cleanTerminalContext(rawContext);
+    // A new session gets one cheap attempt after its first real exchange. Short
+    // conversations ("hi" plus a brief reply) are still valid sessions; the
+    // one-hour re-evaluation guard below keeps this from becoming noisy after a
+    // title exists.
+    if (context.length < AUTO_TITLE_MIN_CONTEXT_CHARS)
+        return;
+    const contentHash = createHash('sha256').update(context).digest('hex');
+    if (record.autoTitle?.contentHash === contentHash)
+        return;
+    autoTitlePending.add(sessionId);
+    try {
+        const savedModels = getAutoRenameModelsSetting();
+        const catalog = await getTitleNamerCatalog();
+        const availableModels = new Map(catalog.map((namer) => [
+            namer.slug,
+            new Set(namer.models.map((model) => model.id)),
+        ]));
+        const validModels = Object.fromEntries(Object.entries(savedModels)
+            .filter(([slug, model]) => availableModels.get(slug)?.has(model)));
+        for (const namer of catalog) {
+            if (!validModels[namer.slug] && namer.recommendedModel) {
+                validModels[namer.slug] = namer.recommendedModel;
+            }
+        }
+        const title = await generateAgentTitle(agent.slug, agent.displayName, context, {
+            namer: getAutoRenameNamerSetting(),
+            models: validModels,
+            currentTitle: record.autoTitle ? record.name : undefined,
+        });
+        if (!title)
+            return;
+        // A manual rename performed while the namer was running always wins.
+        const current = globalSessionState.sessions.find((item) => item.backendSessionId === sessionId);
+        if (!current || (current.customName === true && !current.autoTitle))
+            return;
+        if (current.autoTitle && !shouldReplaceAutoTitle(current.name, title)) {
+            upsertGlobalSessionRecord({
+                ...current,
+                autoTitle: { agentSlug: agent.slug, contentHash, updatedAt: Date.now() },
+            });
+            await persistGlobalStateNow();
+            console.log(`[auto-title] kept ${sessionId} title ${JSON.stringify(current.name)}`);
+            return;
+        }
+        const next = {
+            ...current,
+            name: title,
+            customName: true,
+            autoTitle: { agentSlug: agent.slug, contentHash, updatedAt: Date.now() },
+        };
+        if (next.mode === 'tmux' && next.tmuxSessionName) {
+            await setTmuxOption(next.tmuxSessionName, '@termdock-friendly-name', title);
+        }
+        upsertGlobalSessionRecord(next);
+        await persistGlobalStateNow();
+        broadcastClientState();
+        console.log(`[auto-title] renamed ${sessionId} (${agent.slug}) to ${JSON.stringify(title)}`);
+    }
+    catch (error) {
+        console.warn(`[auto-title] failed for ${sessionId}: ${getErrorMessage(error)}`);
+    }
+    finally {
+        autoTitlePending.delete(sessionId);
+    }
+}
 /** Status → indicator glyph. Colors stay client-side (CSS theme vars) so
  *  dark/light themes render correctly; the wire carries semantics only. */
 const AGENT_STATUS_INDICATOR = {
@@ -2074,7 +2243,8 @@ function isPaneAtShellPrompt(session) {
 function buildAgentStatusPayload(sessionId, session) {
     const state = session.agentSession;
     const status = state ? state.status : null;
-    const indicator = status ? AGENT_STATUS_INDICATOR[status] : null;
+    const presentation = state?.presentation ?? null;
+    const indicator = presentation?.indicator ?? (status ? AGENT_STATUS_INDICATOR[status] : null);
     let agent = session.agent;
     let nativeSessionId = state?.sessionId ?? null;
     // The agent just exited: keep offering its last conversation for resume
@@ -2094,6 +2264,9 @@ function buildAgentStatusPayload(sessionId, session) {
         type: 'agent-status',
         agentStatus: status,
         agentIndicator: indicator ?? null,
+        agentStatusDetail: presentation
+            ? { id: presentation.id, label: presentation.label, tone: presentation.tone ?? 'neutral' }
+            : null,
         agent: agent
             ? { slug: agent.slug, displayName: agent.displayName, accentColor: agent.accentColor, icon: agent.icon, isPlugin: agent.isPlugin ?? false, iconMode: agent.iconMode, iconVersion: agent.iconVersion }
             : null,
@@ -2218,7 +2391,10 @@ function applyAgentSignals(sessionId, session, events, notification) {
     // that a poll blip may have started in syncAgentIdentity.
     session.agentLeftAt = null;
     let identityChanged = false;
+    let completedTurnAgent = null;
     for (const event of events) {
+        if (!agentEventMatchesCurrentAgent(session.agent, event))
+            continue;
         // An event naming an agent brands the pane even when the process poll
         // can't see through a wrapper: identity via protocol.
         if (!session.agent && event.agent) {
@@ -2227,7 +2403,25 @@ function applyAgentSignals(sessionId, session, events, notification) {
         }
         const state = session.agentSession ?? defaultAgentSessionState();
         session.agentSession = state;
+        const previousNativeSessionId = state.sessionId
+            ?? globalSessionState.sessions.find((item) => item.backendSessionId === sessionId)?.agentResume?.sessionId
+            ?? null;
+        if (event.kind === 'session-start' && isNewAgentSessionId(previousNativeSessionId, event.sessionId)) {
+            clearAutoTitleForNewAgentSession(sessionId, session);
+        }
+        if (event.kind === 'prompt-submit') {
+            // Before the first automatic title, keep accumulating short turns until
+            // there is enough substance to name the session. Once titled, only the
+            // latest turn is relevant to the conservative re-evaluation path.
+            const persisted = globalSessionState.sessions.find((item) => item.backendSessionId === sessionId);
+            if (persisted?.autoTitle) {
+                session.autoTitleContext = '';
+            }
+        }
         applyAgentEvent(state, event);
+        if (event.kind === 'stop') {
+            completedTurnAgent = event.agent ?? session.agent;
+        }
         if (event.kind === 'session-start' || event.kind === 'session-end' || event.kind === 'stop') {
             persistAgentResumeBinding(sessionId, session);
         }
@@ -2259,6 +2453,13 @@ function applyAgentSignals(sessionId, session, events, notification) {
     // one of the git probe's triggers.
     maybeRefreshGitStatusForAgent(sessionId, session);
     broadcastAgentStatus(sessionId, session, identityChanged);
+    if (completedTurnAgent) {
+        const agent = completedTurnAgent;
+        // Let the current PTY chunk reach the rolling context before reading it.
+        setTimeout(() => {
+            void maybeAutoRenameSession(sessionId, agent, session.autoTitleContext);
+        }, 250).unref?.();
+    }
 }
 // ── Git status (branch + diff size) ──
 //
@@ -2407,6 +2608,9 @@ try {
     }
     for (const err of errors) {
         console.warn(`[agent-plugins] validation error in "${err.slug}": ${err.errors.join('; ')}`);
+        if (err.migration?.aiPrompt) {
+            console.warn(`[agent-plugins] AI migration prompt for "${err.slug}": ${err.migration.aiPrompt}`);
+        }
     }
 }
 catch { /* plugin loading must never block startup */ }
@@ -3376,6 +3580,7 @@ function processSessionOutput(sessionId, session, data, opts) {
     }
     catch { /* sniff failure should never block data */ }
     if (opts.broadcast) {
+        appendAutoTitleContext(session, data);
         broadcastEvent(sessionId, seq !== undefined ? { type: 'data', data, seq } : { type: 'data', data });
     }
 }
@@ -3546,6 +3751,7 @@ async function spawnTerminalSession(req, input) {
         activeProgram: null,
         agent: null,
         agentSession: null,
+        autoTitleContext: '',
         lastAgentReviewed: null,
         agentLeftAt: null,
         gitStatus: null,
@@ -3627,6 +3833,7 @@ async function adoptPtyHostSessions() {
             activeProgram: null,
             agent: null,
             agentSession: null,
+            autoTitleContext: '',
             lastAgentReviewed: null,
             agentLeftAt: null,
             gitStatus: null,
@@ -4036,9 +4243,11 @@ router.patch('/session-inventory/sessions/:frontendSessionId', async (req, res)
     const next = { ...previous, lastActivity: Date.now() };
     if (typeof body.name === 'string' && body.name.trim().length > 0) {
         next.name = body.name.trim();
+        next.autoTitle = null;
     }
     if (typeof body.customName === 'boolean') {
         next.customName = body.customName ? true : undefined;
+        next.autoTitle = null;
     }
     if (Object.prototype.hasOwnProperty.call(body, 'backendSessionId')) {
         next.backendSessionId = typeof body.backendSessionId === 'string' && body.backendSessionId.trim().length > 0
@@ -4166,6 +4375,9 @@ async function getSettingsPayload() {
         networkAvailable: caffeinateManager.isNetworkAvailable(),
         locale: getLocaleSetting(),
         contextDraftHeight: getContextDraftHeightSetting(),
+        autoRenameAgents: getAutoRenameAgentsSetting(),
+        autoRenameNamer: getAutoRenameNamerSetting(),
+        autoRenameModels: getAutoRenameModelsSetting(),
         localAccess: {
             ...localAccess,
             interfaces,
@@ -4177,6 +4389,25 @@ async function getSettingsPayload() {
 router.get('/settings', async (_req, res) => {
     res.json(await getSettingsPayload());
 });
+router.get('/auto-title/catalog', async (req, res) => {
+    const force = req.query.refresh === '1';
+    res.json({ namers: await getTitleNamerCatalog(force) });
+});
+router.get('/update', (_req, res) => {
+    res.json(npmAutoUpdateManager.getState());
+});
+router.post('/update/check', async (_req, res) => {
+    res.json(await npmAutoUpdateManager.checkNow());
+});
+router.post('/update/restart', (_req, res) => {
+    try {
+        const state = npmAutoUpdateManager.confirmRestart();
+        res.status(202).json(state);
+    }
+    catch (error) {
+        res.status(409).json({ error: error instanceof Error ? error.message : String(error) });
+    }
+});
 router.put('/settings', async (req, res) => {
     const body = req.body ?? {};
     if (typeof body.preventSleep === 'boolean') {
@@ -4197,6 +4428,36 @@ router.put('/settings', async (req, res) => {
             }
         }
     }
+    if (Array.isArray(body.autoRenameAgents)) {
+        const knownSlugs = new Set(listAgents().map((agent) => agent.slug));
+        const requested = body.autoRenameAgents
+            .filter((slug) => typeof slug === 'string' && knownSlugs.has(slug));
+        setAutoRenameAgentsSetting(requested);
+    }
+    if (typeof body.autoRenameNamer === 'string') {
+        const available = new Set((await getTitleNamerCatalog()).filter((entry) => entry.available).map((entry) => entry.slug));
+        if (body.autoRenameNamer !== 'auto' && !available.has(body.autoRenameNamer)) {
+            res.status(400).json({ error: 'Unsupported automatic title agent', code: 'AUTO_RENAME_NAMER_INVALID' });
+            return;
+        }
+        setAutoRenameNamerSetting(body.autoRenameNamer);
+    }
+    if (body.autoRenameModels && typeof body.autoRenameModels === 'object') {
+        const requested = body.autoRenameModels;
+        const catalog = await getTitleNamerCatalog();
+        const allowed = new Map(catalog.map((namer) => [namer.slug, new Set(namer.models.map((model) => model.id))]));
+        const models = {};
+        for (const [slug, model] of Object.entries(requested)) {
+            if (model === undefined || model === '')
+                continue;
+            if (typeof model !== 'string' || !allowed.get(slug)?.has(model)) {
+                res.status(400).json({ error: `Unsupported ${slug} title model`, code: 'AUTO_RENAME_MODEL_INVALID' });
+                return;
+            }
+            models[slug] = model;
+        }
+        setAutoRenameModelsSetting(models);
+    }
     if (body.localAccess && typeof body.localAccess === 'object') {
         const localAccessBody = body.localAccess;
         if (localAccessBody.reset === true) {
@@ -4239,8 +4500,79 @@ router.put('/context-draft', (req, res) => {
     res.json(doc);
 });
 // ── Agent hooks API (rich status channel installers, built-in + plugin) ──
-router.get('/agent-hooks', (_req, res) => {
-    res.json({ agents: listAllHookAgents() });
+router.get('/agent-hooks', async (_req, res) => {
+    res.json({ agents: await listAllHookAgents() });
+});
+router.get('/agent-launchers', async (_req, res) => {
+    const pathEntries = buildAugmentedPath().split(path.delimiter).filter(Boolean);
+    const executableExtensions = process.platform === 'win32'
+        ? (process.env.PATHEXT || '.EXE;.CMD;.BAT;.COM').split(';')
+        : [''];
+    const detected = [];
+    for (const agent of listAgents()) {
+        let command = null;
+        for (const alias of agent.aliases) {
+            for (const directory of pathEntries) {
+                for (const extension of executableExtensions) {
+                    const candidate = path.join(directory, `${alias}${extension}`);
+                    try {
+                        await fs.promises.access(candidate, process.platform === 'win32' ? fs.constants.F_OK : fs.constants.X_OK);
+                        command = alias;
+                        break;
+                    }
+                    catch { /* keep looking */ }
+                }
+                if (command)
+                    break;
+            }
+            if (command)
+                break;
+        }
+        if (command)
+            detected.push({ slug: agent.slug, displayName: agent.displayName, command });
+    }
+    res.json({ agents: detected });
+});
+router.get('/directory-suggestions', async (req, res) => {
+    const rawQuery = typeof req.query.q === 'string' ? req.query.q.trim() : '';
+    const expandedQuery = rawQuery === '~'
+        ? os.homedir()
+        : rawQuery.startsWith(`~${path.sep}`)
+            ? path.join(os.homedir(), rawQuery.slice(2))
+            : rawQuery;
+    const absoluteQuery = expandedQuery || os.homedir();
+    const hasTrailingSeparator = absoluteQuery.endsWith(path.sep);
+    const parentCandidate = hasTrailingSeparator ? absoluteQuery : path.dirname(absoluteQuery);
+    const namePrefix = hasTrailingSeparator ? '' : path.basename(absoluteQuery).toLowerCase();
+    try {
+        const parent = req.pathValidator
+            ? await req.pathValidator.validateAsync(parentCandidate)
+            : await fs.promises.realpath(parentCandidate);
+        const entries = await fs.promises.readdir(parent, { withFileTypes: true });
+        const matching = entries
+            .filter((entry) => !entry.name.startsWith('.') && entry.name.toLowerCase().startsWith(namePrefix))
+            .slice(0, 30);
+        const directories = [];
+        for (const entry of matching) {
+            const candidate = path.join(parent, entry.name);
+            if (entry.isDirectory()) {
+                directories.push(candidate);
+            }
+            else if (entry.isSymbolicLink()) {
+                try {
+                    if ((await fs.promises.stat(candidate)).isDirectory())
+                        directories.push(candidate);
+                }
+                catch { /* omit broken/inaccessible symlinks */ }
+            }
+            if (directories.length >= 10)
+                break;
+        }
+        res.json({ directories });
+    }
+    catch {
+        res.json({ directories: [] });
+    }
 });
 router.post('/agent-hooks/:agent/install', async (req, res) => {
     const agent = req.params.agent;
@@ -4275,9 +4607,10 @@ router.get('/agent-plugins', (_req, res) => {
             iconMode: p.manifest.iconMode ?? 'mask',
             hasHooks: p.manifest.hooks !== undefined,
             hasResume: p.manifest.resume !== undefined,
+            hasTitleNamer: p.manifest.titleNamer !== undefined,
             hasIcon: p.iconPath !== null,
         })),
-        errors: errors.map((e) => ({ slug: e.slug, errors: e.errors })),
+        errors: errors.map((e) => ({ slug: e.slug, errors: e.errors, code: e.code, migration: e.migration })),
     });
 });
 router.post('/agent-plugins', async (req, res) => {
@@ -4295,8 +4628,21 @@ router.post('/agent-plugins', async (req, res) => {
             res.status(409).json({ error: `Plugin "${existing.manifest.slug}" already exists` });
             return;
         }
-        const dir = savePlugin(manifest);
-        res.json({ slug: manifest.slug, dir, state: 'created' });
+        const validation = validateManifest(manifest, path.join(os.homedir(), '.termdock', 'agent-plugins', 'pending'));
+        if ('error' in validation) {
+            res.status(400).json({
+                error: validation.error.errors.join('\n'),
+                code: validation.error.code ?? 'AGENT_PLUGIN_MANIFEST_INVALID',
+                migration: validation.error.migration,
+            });
+            return;
+        }
+        const dir = savePlugin(validation.manifest);
+        invalidateTitleNamerCatalog();
+        clearPluginAgents();
+        const loaded = loadPlugins();
+        registerPluginAgents(loaded.plugins);
+        res.json({ slug: validation.manifest.slug, dir, state: 'created' });
     }
     catch (error) {
         res.status(400).json({ error: error.message });
@@ -4305,11 +4651,32 @@ router.post('/agent-plugins', async (req, res) => {
 router.delete('/agent-plugins/:slug', async (req, res) => {
     const { slug } = req.params;
     try {
+        const plugin = loadPlugins().plugins.find((entry) => entry.manifest.slug === slug);
+        if (!plugin) {
+            res.status(404).json({ error: `Plugin "${slug}" not found` });
+            return;
+        }
+        // Uninstall while the manifest is still present: after deletion we no
+        // longer know the target file or event shape and would orphan commands in
+        // the Agent's config.
+        if (plugin.manifest.hooks)
+            await uninstallHooksForSlug(slug);
         removePlugin(slug);
+        invalidateTitleNamerCatalog();
+        setAutoRenameAgentsSetting(getAutoRenameAgentsSetting().filter((entry) => entry !== slug));
+        if (getAutoRenameNamerSetting() === slug)
+            setAutoRenameNamerSetting('auto');
+        const models = getAutoRenameModelsSetting();
+        if (models[slug]) {
+            delete models[slug];
+            setAutoRenameModelsSetting(models);
+        }
+        clearPluginAgents();
+        registerPluginAgents(loadPlugins().plugins);
         res.json({ slug, state: 'removed' });
     }
     catch (error) {
-        res.status(404).json({ error: error.message });
+        res.status(400).json({ error: error.message });
     }
 });
 router.get('/agent-plugin-icon/:slug', (req, res) => {
@@ -5508,6 +5875,7 @@ export function handleControlWebSocket(ws, clientId) {
         }
         try {
             ws.send(JSON.stringify({ type: 'client-state', seq: initialSeq, state: globalSessionState, inventory: inventory ?? latestSessionInventory }));
+            ws.send(JSON.stringify({ type: 'update-state', state: npmAutoUpdateManager.getState() }));
         }
         catch {
             controlClients.delete(clientId);