fraim-hub 2.0.246 → 2.0.248

package/dist/src/ai-hub/host-session-state.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hostSessionState = exports.HostSessionState = void 0;
+class HostSessionState {
+    keyFor(owner) {
+        const configuredAgentId = typeof owner.configuredAgentId === 'string' ? owner.configuredAgentId.trim() : '';
+        return configuredAgentId || `${owner.baseHostId}-default`;
+    }
+    applySession(target, owner, sessionId, options = {}) {
+        const normalizedSessionId = sessionId.trim();
+        if (!normalizedSessionId)
+            return;
+        const at = options.at || new Date().toISOString();
+        const key = this.keyFor(owner);
+        target.hostSessions = {
+            ...(target.hostSessions || {}),
+            [key]: {
+                configuredAgentId: owner.configuredAgentId || null,
+                baseHostId: owner.baseHostId,
+                sessionId: normalizedSessionId,
+                status: options.status || 'valid',
+                sourceRunId: options.sourceRunId ?? target.id ?? null,
+                updatedAt: at,
+            },
+        };
+        target.sessionId = normalizedSessionId;
+    }
+    mergeFromRun(record, run) {
+        const owner = {
+            configuredAgentId: run.configuredAgentId || record.configuredAgentId || null,
+            baseHostId: (run.baseHostId || run.hostId || record.baseHostId || record.agentName),
+        };
+        record.hostSessions = { ...(record.hostSessions || {}) };
+        for (const [key, session] of Object.entries(run.hostSessions || {})) {
+            record.hostSessions[key] = { ...session };
+        }
+        if (run.sessionId) {
+            const projectedRun = {
+                id: run.id,
+                sessionId: record.sessionId || undefined,
+                hostSessions: record.hostSessions,
+            };
+            this.applySession(projectedRun, owner, run.sessionId, { sourceRunId: run.id });
+            record.hostSessions = projectedRun.hostSessions;
+        }
+        const active = this.resolve(record, owner);
+        record.sessionId = active?.sessionId || run.sessionId || record.sessionId || null;
+    }
+    resolve(conversation, owner) {
+        if (!conversation)
+            return null;
+        const sessions = conversation.hostSessions || {};
+        const key = this.keyFor(owner);
+        const exact = sessions[key];
+        if (this.isResumableForOwner(exact, owner))
+            return exact;
+        const fallback = Object.values(sessions).find((session) => this.isResumableForOwner(session, owner));
+        if (fallback)
+            return fallback;
+        const legacySessionId = typeof conversation.sessionId === 'string' ? conversation.sessionId.trim() : '';
+        if (!legacySessionId)
+            return null;
+        return {
+            configuredAgentId: owner.configuredAgentId || null,
+            baseHostId: owner.baseHostId,
+            sessionId: legacySessionId,
+            status: 'suspect',
+            sourceRunId: typeof conversation.runId === 'string' ? conversation.runId : null,
+            updatedAt: typeof conversation.lastUpdatedAt === 'string' ? conversation.lastUpdatedAt : new Date().toISOString(),
+        };
+    }
+    markInvalid(conversation, owner, sessionId, reason, at = new Date().toISOString()) {
+        const normalizedSessionId = sessionId.trim();
+        if (!normalizedSessionId)
+            return;
+        const key = this.keyFor(owner);
+        const existing = conversation.hostSessions?.[key];
+        conversation.hostSessions = { ...(conversation.hostSessions || {}) };
+        conversation.hostSessions[key] = {
+            configuredAgentId: owner.configuredAgentId || existing?.configuredAgentId || null,
+            baseHostId: owner.baseHostId,
+            sessionId: normalizedSessionId,
+            status: 'invalid',
+            sourceRunId: existing?.sourceRunId || (typeof conversation.runId === 'string' ? conversation.runId : null),
+            updatedAt: existing?.updatedAt || at,
+            invalidatedAt: at,
+            invalidationReason: reason,
+        };
+        if (conversation.sessionId === normalizedSessionId) {
+            const replacement = this.resolve({ ...conversation, sessionId: null }, owner);
+            conversation.sessionId = replacement?.sessionId || null;
+        }
+    }
+    markInvalidRun(run, owner, sessionId, reason, at = new Date().toISOString()) {
+        const normalizedSessionId = sessionId.trim();
+        if (!normalizedSessionId)
+            return;
+        const key = this.keyFor(owner);
+        const existing = run.hostSessions?.[key];
+        run.hostSessions = { ...(run.hostSessions || {}) };
+        run.hostSessions[key] = {
+            configuredAgentId: owner.configuredAgentId || existing?.configuredAgentId || null,
+            baseHostId: owner.baseHostId,
+            sessionId: normalizedSessionId,
+            status: 'invalid',
+            sourceRunId: existing?.sourceRunId || run.id || null,
+            updatedAt: existing?.updatedAt || at,
+            invalidatedAt: at,
+            invalidationReason: reason,
+        };
+        if (run.sessionId === normalizedSessionId) {
+            run.sessionId = undefined;
+        }
+    }
+    hasInvalidSession(conversation, owner, sessionId) {
+        const normalizedSessionId = sessionId.trim();
+        if (!conversation || !normalizedSessionId)
+            return false;
+        const key = this.keyFor(owner);
+        const exact = conversation.hostSessions?.[key];
+        if (exact?.status === 'invalid' && exact.sessionId === normalizedSessionId)
+            return true;
+        return Object.values(conversation.hostSessions || {}).some((session) => (session.status === 'invalid'
+            && session.sessionId === normalizedSessionId
+            && session.baseHostId === owner.baseHostId));
+    }
+    isResumableForOwner(session, owner) {
+        if (!session || !session.sessionId || session.status === 'invalid')
+            return false;
+        if (session.baseHostId !== owner.baseHostId)
+            return false;
+        const requestedConfiguredAgentId = typeof owner.configuredAgentId === 'string' ? owner.configuredAgentId.trim() : '';
+        const sessionConfiguredAgentId = typeof session.configuredAgentId === 'string' ? session.configuredAgentId.trim() : '';
+        return !requestedConfiguredAgentId || !sessionConfiguredAgentId || requestedConfiguredAgentId === sessionConfiguredAgentId;
+    }
+}
+exports.HostSessionState = HostSessionState;
+exports.hostSessionState = new HostSessionState();

package/dist/src/ai-hub/hosts.js

@@ -1578,7 +1578,10 @@ function parseHostLine(hostId, line) {
         if (parsed.type === 'result') {
             // Don't emit message — the 'assistant' event already captured the turn text.
             // result carries usage data (parsed by parseUsageSignal above via withSignal).
-            return withSignal({ sessionId: parsed.session_id, raw: trimmed });
+            // Claude result events can echo the requested resume id even when resume failed
+            // with "No conversation found with session ID". Treat system events as the
+            // authoritative session source instead of reinforcing a stale pointer.
+            return withSignal({ raw: trimmed });
         }
         return withSignal({ raw: trimmed });
     }

package/dist/src/ai-hub/preferences.js

@@ -112,16 +112,15 @@ function normalizeAiHubProjectList(projects, currentProjectPath, options = {}) {
     const byPath = new Map();
     const currentCanonical = currentProjectPath ? canonicalProjectPath(currentProjectPath) : null;
     const removedKeys = new Set(normalizeRemovedProjectPaths(options.removedProjectPaths));
-    const add = (entry, isCurrent = false) => {
+    const add = (entry) => {
         if (!entry)
             return;
         const displayPath = normalizeProjectPath(entry.folderPath);
         const dedupKey = canonicalProjectPath(displayPath);
-        // Issue #788: the current project is always shown in its own workspace, even when
-        // tombstoned (#719 never-empty Hub). This is a display override ONLY — the tombstone
-        // is neither erased here nor in persistence, so switching away re-hides the project
-        // and no subsequent add can resurrect it.
-        if (!isCurrent && removedKeys.has(dedupKey))
+        // Issue #1044: tombstoned paths are never shown, even when the path is the active
+        // project. The caller must switch to a different project (or clear projectPath) before
+        // deleting — the server now enforces this only when other projects remain (#719 reverted).
+        if (removedKeys.has(dedupKey))
             return;
         if (!options.includeMissing && dedupKey !== currentCanonical && !projectPathExists(displayPath))
             return;
@@ -129,7 +128,7 @@ function normalizeAiHubProjectList(projects, currentProjectPath, options = {}) {
         byPath.set(dedupKey, existing ? { ...existing, ...entry, folderPath: existing.folderPath } : { ...entry, folderPath: displayPath });
     };
     if (currentProjectPath)
-        add(normalizeProjectEntry({ folderPath: currentProjectPath }, currentProjectPath), true);
+        add(normalizeProjectEntry({ folderPath: currentProjectPath }, currentProjectPath));
     for (const project of projects)
         add(normalizeProjectEntry(project));
     return withUniqueProjectIds(Array.from(byPath.values()));

package/dist/src/ai-hub/server.js

@@ -55,6 +55,7 @@ const custom_employees_1 = require("./custom-employees");
 const agent_token_prices_1 = require("../local-mcp-server/agent-token-prices");
 const hosts_1 = require("./hosts");
 const configured_agents_1 = require("./configured-agents");
+const host_session_state_1 = require("./host-session-state");
 const url_safety_1 = require("./url-safety");
 const manager_turns_1 = require("./manager-turns");
 const preferences_1 = require("./preferences");
@@ -117,6 +118,10 @@ function buildReviewApprovalSystemEventText(instructions) {
         return 'review_approved send_delivery cleanup_branch';
     return null;
 }
+function extractMissingHostSessionId(text) {
+    const match = text.match(/No conversation found with session ID:\s*([a-zA-Z0-9-]+)/i);
+    return match?.[1]?.trim() || null;
+}
 function loadManagerHiringModule() {
     const cached = managerHiringModule;
     if (cached !== undefined) {
@@ -1444,7 +1449,10 @@ function ensureDirectoryPath(projectPath) {
     }
     return resolved;
 }
-function readRunScope(raw) {
+function readRunScope(raw, jobId) {
+    if ((raw === undefined || raw === null) && jobId && MACHINE_LEVEL_JOB_IDS.has(jobId)) {
+        return 'manager';
+    }
     return raw === 'manager' || raw === 'company' ? raw : 'project';
 }
 // Working directory for a project-independent run when no project exists: the user-level
@@ -1612,7 +1620,7 @@ function classifyExit(run, exitCode) {
             if (lastDeclared && lastDeclared.id === currentPhase) {
                 return { action: 'done', pauseReason: 'done' };
             }
-            return { action: 'resume', pauseReason: 'working' };
+            return { action: 'park', pauseReason: 'awaiting_user' };
         }
         // Phase mid-flight (started but not completed/incomplete): conservative park.
         return { action: 'park', pauseReason: 'awaiting_user' };
@@ -2229,7 +2237,7 @@ class AiHubServer {
     conversationRecordFromRun(run) {
         const lastUpdatedAt = run.updatedAt || new Date().toISOString();
         const stages = deriveStages(run, run.projectPath);
-        return {
+        const record = {
             id: run.conversationId || run.id,
             projectPath: path_1.default.resolve(run.projectPath),
             title: run.conversationTitle || run.jobTitle || run.jobId,
@@ -2279,6 +2287,7 @@ class AiHubServer {
             handoffSummary: run.handoffSummary || null,
             continuityDecision: run.continuityDecision,
             forkedFromConversationId: run.forkedFromConversationId ?? null,
+            hostSessions: { ...(run.hostSessions || {}) },
             restartRecovery: run.restartRecovery || null,
             restartRecoverySkippedReason: run.restartRecoverySkippedReason || null,
             // Issue #578: preserve trigger source so the UI can render the chip.
@@ -2296,6 +2305,8 @@ class AiHubServer {
                 runDiscriminant: run.runDiscriminant || null,
             },
         };
+        host_session_state_1.hostSessionState.mergeFromRun(record, run);
+        return record;
     }
     persistRunConversationNow(run, activeId) {
         try {
@@ -2344,7 +2355,7 @@ class AiHubServer {
             onEvent: (event, channel) => {
                 this.runRegistry.update(run.id, (current) => {
                     if (event.sessionId) {
-                        current.sessionId = event.sessionId;
+                        host_session_state_1.hostSessionState.applySession(current, { configuredAgentId: current.configuredAgentId || null, baseHostId: current.baseHostId || current.hostId }, event.sessionId, { sourceRunId: current.id });
                         current.resumeCommand = (0, hosts_1.buildInteractiveResumeCommand)(run.hostId, event.sessionId);
                     }
                     appendHostMessage(current, run.hostId, event, channel);
@@ -3906,7 +3917,7 @@ class AiHubServer {
                         onEvent: (event, channel) => {
                             this.runRegistry.update(run.id, (current) => {
                                 if (event.sessionId) {
-                                    current.sessionId = event.sessionId;
+                                    host_session_state_1.hostSessionState.applySession(current, { configuredAgentId: current.configuredAgentId || null, baseHostId: current.baseHostId || current.hostId }, event.sessionId, { sourceRunId: current.id });
                                     current.resumeCommand = (0, hosts_1.buildInteractiveResumeCommand)(run.hostId, event.sessionId);
                                 }
                                 appendHostMessage(current, run.hostId, event, channel);
@@ -4039,10 +4050,14 @@ class AiHubServer {
                 || (requestedFolderPath ? known.find((project) => sameDirectoryPath(project.folderPath, requestedFolderPath)) : undefined);
             if (!entry)
                 return res.status(404).json({ error: 'Project not found.' });
-            // The current projectPath is unconditionally re-injected on every load, so
-            // deleting it would resurrect on the next request — reject as a sequencing
-            // error; the client switches workspaces before deleting (R5/D4).
-            if (sameDirectoryPath(entry.folderPath, projectPath)) {
+            // Issue #1044: when the project being removed is the active workspace AND other
+            // projects remain, the client must switch first (the current path is re-injected
+            // on every load, so it would resurface). When it is the LAST project, allow the
+            // delete and let the Hub reach an empty state — projectPath is cleared by the
+            // tombstone filter (normalizeAiHubProjectList no longer bypasses for isCurrent).
+            const isCurrentProject = sameDirectoryPath(entry.folderPath, projectPath);
+            const otherProjectsExist = known.some((p) => p.id !== entry.id);
+            if (isCurrentProject && otherProjectsExist) {
                 return res.status(409).json({ error: 'Cannot remove the current project. Switch to another project first.' });
             }
             // A live schedule/webhook would fire later, write a conversation under the
@@ -4452,7 +4467,7 @@ class AiHubServer {
             try {
                 // Issue #892: project-independent (manager/company) runs resolve a working dir
                 // even with no project; project runs still require an existing project directory.
-                const scope = readRunScope(req.body.scope);
+                const scope = readRunScope(req.body.scope, req.body.jobId);
                 const projectPath = this.resolveRunProjectPath(req.body.projectPath, scope);
                 const requestedHostId = req.body.hostId;
                 const instructions = (req.body.instructions || '').trim();
@@ -4877,14 +4892,14 @@ class AiHubServer {
                 const body = (req.body ?? {});
                 // Issue #892: a mid-flight project-independent onboarding (manager/company) must
                 // resume even with no project (e.g. after a Hub restart).
-                const scope = readRunScope(body.scope);
+                const scope = readRunScope(body.scope, body.jobId);
                 const projectPath = this.resolveRunProjectPath(body.projectPath, scope);
                 const requestedHostId = body.hostId;
-                const sessionId = (body.sessionId || '').trim();
+                const requestedSessionId = (body.sessionId || '').trim();
                 const jobId = (body.jobId || '').trim();
                 const instructions = (body.instructions || '').trim();
                 const coachingJobId = body.coachingJobId?.trim() || undefined;
-                if (!sessionId)
+                if (!requestedSessionId)
                     throw new Error('A host sessionId is required to resume.');
                 if (!jobId)
                     throw new Error('A jobId is required to resume.');
@@ -4904,6 +4919,17 @@ class AiHubServer {
                     ? this.conversationStore.loadProject(conversationBucketKey).conversations.find((entry) => entry.id === requestedConversationId)
                     : inferredConversation ?? undefined;
                 const persistedRun = readPersistedRunProjection(persistedConversation);
+                const resolvedHostSession = host_session_state_1.hostSessionState.resolve(persistedConversation, {
+                    configuredAgentId: configuredAgent.id,
+                    baseHostId: hostId,
+                });
+                if (!resolvedHostSession && host_session_state_1.hostSessionState.hasInvalidSession(persistedConversation, { configuredAgentId: configuredAgent.id, baseHostId: hostId }, requestedSessionId)) {
+                    return res.status(409).json({
+                        error: 'The saved host session was already marked invalid. Start a fresh handoff-backed run instead of retrying the same session.',
+                        hostSessionStatus: 'invalid',
+                    });
+                }
+                const sessionId = resolvedHostSession?.sessionId || requestedSessionId;
                 const now = new Date().toISOString();
                 const run = {
                     id: (0, crypto_1.randomUUID)(),
@@ -4911,6 +4937,7 @@ class AiHubServer {
                     conversationTitle: typeof body.conversationTitle === 'string' && body.conversationTitle.trim() ? body.conversationTitle.trim() : undefined,
                     jobTitle: typeof body.jobTitle === 'string' && body.jobTitle.trim() ? body.jobTitle.trim() : jobId,
                     jobId, hostId, configuredAgentId: configuredAgent.id, configuredAgentLabel: configuredAgent.label, baseHostId: configuredAgent.baseHostId, projectPath, status: 'running', sessionId,
+                    hostSessions: persistedConversation?.hostSessions ? { ...persistedConversation.hostSessions } : undefined,
                     // Issue #892: keep the invocation scope so a resumed manager/company run stays
                     // in its project-independent conversation bucket.
                     scope,
@@ -4927,6 +4954,7 @@ class AiHubServer {
                     personaKey: getHubPersonaForJob(jobId),
                     continuityDecision: conversationId ? 'same_continuity' : 'new_conversation',
                 };
+                host_session_state_1.hostSessionState.applySession(run, { configuredAgentId: configuredAgent.id, baseHostId: hostId }, sessionId, { sourceRunId: run.id, status: resolvedHostSession?.status || 'suspect' });
                 // Continue-turn message (FRAIM invocation for the job + instructions) plus
                 // the shared-browser note so the resumed agent knows about it.
                 const preparedResume = this.prepareContinueMessage(run, instructions, coachingJobId);
@@ -4945,11 +4973,15 @@ class AiHubServer {
                     onEvent: (event, channel) => {
                         this.runRegistry.update(run.id, (current) => {
                             if (event.sessionId) {
-                                current.sessionId = event.sessionId;
+                                host_session_state_1.hostSessionState.applySession(current, { configuredAgentId: current.configuredAgentId || null, baseHostId: current.baseHostId || current.hostId }, event.sessionId, { sourceRunId: current.id });
                                 current.resumeCommand = (0, hosts_1.buildInteractiveResumeCommand)(hostId, event.sessionId);
                             }
                             appendHostMessage(current, hostId, event, channel);
                             if (event.raw) {
+                                const missingSessionId = extractMissingHostSessionId(event.raw);
+                                if (missingSessionId) {
+                                    host_session_state_1.hostSessionState.markInvalidRun(current, { configuredAgentId: current.configuredAgentId || null, baseHostId: current.baseHostId || current.hostId }, missingSessionId, 'host-reported-missing-session');
+                                }
                                 current.events.push((0, hosts_1.createHubEvent)(channel, event.raw));
                                 applyReviewProjection(current, event.raw);
                             }
@@ -5446,14 +5478,23 @@ class AiHubServer {
                 return res.status(404).json({ error: `Custom employee ${key} not found.` });
             }
             const { displayName, role, icon, jobIds } = req.body;
+            if (displayName !== undefined && (typeof displayName !== 'string' || !displayName.trim())) {
+                return res.status(400).json({ error: 'displayName is required.' });
+            }
+            if (jobIds !== undefined && (!Array.isArray(jobIds) || jobIds.length === 0)) {
+                return res.status(400).json({ error: 'jobIds must be a non-empty array.' });
+            }
+            const nextDisplayName = displayName !== undefined ? displayName.trim() : record.displayName;
             const VALID_ICON_KINDS_PATCH = new Set(['emoji', 'generated', 'image']);
             const patchedIcon = icon !== undefined
                 ? { kind: (VALID_ICON_KINDS_PATCH.has(icon.kind) ? icon.kind : record.icon.kind), value: icon.value ?? record.icon.value }
-                : undefined;
+                : (displayName !== undefined && record.icon.kind === 'generated')
+                    ? { ...record.icon, value: nextDisplayName }
+                    : undefined;
             const updated = {
                 ...record,
-                ...(displayName !== undefined ? { displayName } : {}),
-                ...(role !== undefined ? { role } : {}),
+                ...(displayName !== undefined ? { displayName: nextDisplayName } : {}),
+                ...(role !== undefined ? { role: role.trim() } : {}),
                 ...(patchedIcon !== undefined ? { icon: patchedIcon } : {}),
                 ...(jobIds !== undefined ? { jobIds } : {}),
             };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fraim-hub",
-  "version": "2.0.246",
+  "version": "2.0.248",
   "description": "FRAIM Hub local companion package.",
   "bin": {
     "fraim-hub": "bin/fraim-hub.js",
@@ -161,7 +161,7 @@
     "electron": "^41.2.2",
     "electron-updater": "^6.8.9",
     "express": "^5.2.1",
-    "fraim": "2.0.246",
+    "fraim": "2.0.248",
     "mongodb": "^7.0.0",
     "node-cron": "4.2.1",
     "node-edge-tts": "^1.2.10",

package/public/ai-hub/script.js

@@ -67,6 +67,7 @@ const state = {
   pendingConnectedSurfaceAfterAuth: null,
   panelState: {},            // { [convId]: { coach?: boolean } }
   wordContext: null,         // WordContext pushed from taskpane.html via postMessage
+  taskPaneProjects: [],
   // Pending coaching job selected via a quick-coach button or template picker.
   // Sent as coachingJobId in the next continueRun call and then cleared.
   // The invocation prefix ($fraim / /fraim) is added server-side based on
@@ -248,6 +249,13 @@ function applyBootstrap(bootstrap, docUrl) {
   bootstrap = mergePersonaProjection(bootstrap, state.bootstrap);
   state.bootstrap = bootstrap;
   state.projectPath = bootstrap.project.path;
+  // Issue #1044: seed client-side tombstone set from server preferences so
+  // tfEnsureCurrentProject does not re-inject a path the user just deleted.
+  if (bootstrap.preferences && Array.isArray(bootstrap.preferences.removedProjectPaths)) {
+    for (const p of bootstrap.preferences.removedProjectPaths) {
+      if (typeof p === 'string' && p.length > 0) tf.removedPaths.add(tfCanonicalProjectPath(p));
+    }
+  }
   state.remoteBaseUrl = bootstrap.remoteBaseUrl || null;
   if (bootstrap.preferences && bootstrap.preferences.apiKey) {
     state.storedApiKey = bootstrap.preferences.apiKey;
@@ -420,6 +428,7 @@ function applyWordContext(ctx, partial) {
   }
   renderWordContextBar();
   renderWordContextInModal();
+  renderTaskPaneLauncher();
 }
 
 function setupWordBridge() {
@@ -520,6 +529,217 @@ function renderWordContextInModal() {
   body.textContent = buildWordContextBlock(wc);
 }
 
+function isTaskPaneSurface() {
+  return document.body.dataset.surface === 'task-pane' || document.body.dataset.surface === 'extension';
+}
+
+function taskPaneProjectEntries() {
+  const byPath = new Map();
+  const add = (project) => {
+    if (!project) return;
+    const folderPath = project.folderPath || project.path || project.folder || '';
+    if (!folderPath || byPath.has(tfCanonicalProjectPath(folderPath))) return;
+    byPath.set(tfCanonicalProjectPath(folderPath), {
+      ...project,
+      folderPath,
+      name: project.name || friendlyProjectShortName(folderPath),
+    });
+  };
+  add({ folderPath: state.projectPath, name: friendlyProjectShortName(state.projectPath) });
+  (state.taskPaneProjects || []).forEach(add);
+  ((state.bootstrap && state.bootstrap.projects) || []).forEach(add);
+  return Array.from(byPath.values());
+}
+
+function taskPaneJobEntries() {
+  const jobs = [
+    ...((state.bootstrap && state.bootstrap.jobs) || []),
+    ...((state.bootstrap && state.bootstrap.managerTemplates) || []),
+  ];
+  const seen = new Set();
+  return jobs
+    .filter((job) => job && job.id && !PAGE_SCOPED_JOBS.has(job.id))
+    .filter((job) => {
+      if (seen.has(job.id)) return false;
+      seen.add(job.id);
+      return true;
+    });
+}
+
+function taskPaneInstructionSeed() {
+  const wc = state.wordContext || {};
+  if (wc.selection) return wc.selection;
+  if (wc.bodyPreview) return wc.bodyPreview.slice(0, 500);
+  return '';
+}
+
+function taskPaneSetOptions(select, entries, valueOf, labelOf, selectedValue) {
+  if (!select) return;
+  const previous = select.value;
+  select.innerHTML = '';
+  entries.forEach((entry) => {
+    const opt = document.createElement('option');
+    opt.value = valueOf(entry);
+    opt.textContent = labelOf(entry);
+    select.appendChild(opt);
+  });
+  const wanted = selectedValue || previous;
+  if (wanted && entries.some((entry) => valueOf(entry) === wanted)) select.value = wanted;
+}
+
+function ensureTaskPaneLauncher() {
+  let root = document.getElementById('task-pane-launcher');
+  if (root) return root;
+  root = document.createElement('section');
+  root.id = 'task-pane-launcher';
+  root.className = 'task-pane-launcher';
+
+  const header = document.createElement('div');
+  header.className = 'tp-launcher-header';
+  const title = document.createElement('div');
+  title.className = 'tp-launcher-title';
+  title.textContent = 'Delegate from Word';
+  const context = document.createElement('div');
+  context.id = 'task-pane-context-summary';
+  context.className = 'tp-launcher-context';
+  header.appendChild(title);
+  header.appendChild(context);
+  root.appendChild(header);
+
+  const fields = [
+    ['Project', 'task-pane-project-select', 'select'],
+    ['Agent tool', 'task-pane-employee-select', 'select'],
+    ['Job', 'task-pane-job-select', 'select'],
+    ['Instructions', 'task-pane-instructions', 'textarea'],
+  ];
+  fields.forEach(([labelText, id, tag]) => {
+    const label = document.createElement('label');
+    label.className = 'tp-launcher-field';
+    label.setAttribute('for', id);
+    const span = document.createElement('span');
+    span.textContent = labelText;
+    const input = document.createElement(tag);
+    input.id = id;
+    if (tag === 'textarea') {
+      input.rows = 4;
+      input.placeholder = 'Add the outcome you want from this Word context.';
+      input.addEventListener('input', () => { input.dataset.userTouched = '1'; });
+    }
+    label.appendChild(span);
+    label.appendChild(input);
+    root.appendChild(label);
+  });
+
+  const actions = document.createElement('div');
+  actions.className = 'tp-launcher-actions';
+  const status = document.createElement('div');
+  status.id = 'task-pane-start-status';
+  status.className = 'tp-launcher-status';
+  const start = document.createElement('button');
+  start.id = 'task-pane-start-job';
+  start.className = 'send-button';
+  start.type = 'button';
+  start.textContent = 'Start job';
+  start.addEventListener('click', taskPaneStartSelectedJob);
+  actions.appendChild(status);
+  actions.appendChild(start);
+  root.appendChild(actions);
+
+  document.body.insertBefore(root, document.body.firstChild);
+  document.getElementById('task-pane-project-select')?.addEventListener('change', (event) => {
+    const statusEl = document.getElementById('task-pane-start-status');
+    const project = taskPaneProjectEntries().find((entry) => entry.folderPath === event.target.value);
+    if (statusEl && project) statusEl.textContent = `Project: ${project.name || friendlyProjectShortName(project.folderPath)}`;
+  });
+  return root;
+}
+
+function renderTaskPaneLauncher() {
+  if (!isTaskPaneSurface() || !state.bootstrap) return;
+  ensureTaskPaneLauncher();
+  const projects = taskPaneProjectEntries();
+  const jobs = taskPaneJobEntries();
+  const agents = hubConfiguredAgents().filter((agent) => agent.available !== false && agent.enabled !== false);
+  const projectSelect = document.getElementById('task-pane-project-select');
+  const employeeSelect = document.getElementById('task-pane-employee-select');
+  const jobSelect = document.getElementById('task-pane-job-select');
+  const instructions = document.getElementById('task-pane-instructions');
+  const start = document.getElementById('task-pane-start-job');
+  const context = document.getElementById('task-pane-context-summary');
+
+  taskPaneSetOptions(projectSelect, projects, (project) => project.folderPath, (project) => project.name || friendlyProjectShortName(project.folderPath), state.projectPath);
+  taskPaneSetOptions(employeeSelect, agents, (agent) => agent.id, (agent) => agent.label || agent.id, state.selectedEmployeeId);
+  taskPaneSetOptions(jobSelect, jobs, (job) => job.id, (job) => job.title || job.id, null);
+
+  if (instructions && instructions.dataset.userTouched !== '1') {
+    instructions.value = taskPaneInstructionSeed();
+  }
+  if (context) {
+    const wc = state.wordContext || {};
+    const projectName = friendlyProjectShortName(state.projectPath);
+    const selected = wc.selection ? wc.selection.split(/\s+/).filter(Boolean).length + ' selected words' : 'Word context ready';
+    context.textContent = projectName ? `${projectName} - ${selected}` : selected;
+  }
+  if (start) start.disabled = projects.length === 0 || agents.length === 0 || jobs.length === 0;
+}
+
+async function refreshTaskPaneProjects() {
+  if (!isTaskPaneSurface()) return;
+  const query = state.projectPath ? '?projectPath=' + encodeURIComponent(state.projectPath) : '';
+  const payload = await requestJson('/api/ai-hub/projects' + query).catch(() => null);
+  state.taskPaneProjects = payload && Array.isArray(payload.projects) ? payload.projects : [];
+  renderTaskPaneLauncher();
+}
+
+async function taskPaneSwitchProject(folderPath) {
+  if (!folderPath || tfCanonicalProjectPath(folderPath) === tfCanonicalProjectPath(state.projectPath)) return;
+  const priorEmployee = document.getElementById('task-pane-employee-select')?.value || state.selectedEmployeeId;
+  await loadBootstrap(folderPath, new URLSearchParams(window.location.search).get('docUrl') || '', { preferCache: true });
+  await hydrateConversationsFromServer();
+  const latestEmployee = document.getElementById('task-pane-employee-select')?.value || priorEmployee;
+  if (latestEmployee && hubConfiguredAgents().some((agent) => agent.id === latestEmployee)) {
+    state.selectedEmployeeId = latestEmployee;
+  }
+  await refreshTaskPaneProjects();
+  renderRail();
+  renderActive();
+}
+
+async function taskPaneStartSelectedJob() {
+  const projectSelect = document.getElementById('task-pane-project-select');
+  const employeeSelect = document.getElementById('task-pane-employee-select');
+  const jobSelect = document.getElementById('task-pane-job-select');
+  const instructions = document.getElementById('task-pane-instructions');
+  const start = document.getElementById('task-pane-start-job');
+  const statusEl = document.getElementById('task-pane-start-status');
+  const selectedProject = projectSelect && projectSelect.value;
+  const requestedEmployeeId = employeeSelect && employeeSelect.value;
+  if (selectedProject && tfCanonicalProjectPath(selectedProject) !== tfCanonicalProjectPath(state.projectPath)) {
+    await taskPaneSwitchProject(selectedProject);
+    const updatedEmployeeSelect = document.getElementById('task-pane-employee-select');
+    if (updatedEmployeeSelect && requestedEmployeeId) updatedEmployeeSelect.value = requestedEmployeeId;
+  }
+  const jobs = taskPaneJobEntries();
+  const job = jobs.find((entry) => entry.id === (jobSelect && jobSelect.value));
+  const employeeId = requestedEmployeeId || (employeeSelect && employeeSelect.value);
+  if (!job || !employeeId) return;
+  if (start) start.disabled = true;
+  if (statusEl) statusEl.textContent = 'Starting...';
+  try {
+    const result = await startRun(job, instructions ? instructions.value : '', employeeId, undefined, 'projects');
+    if (result && result.ok) {
+      if (statusEl) statusEl.textContent = 'Started.';
+    } else if (statusEl) {
+      statusEl.textContent = (result && result.error) || 'Could not start.';
+    }
+  } catch (error) {
+    if (statusEl) statusEl.textContent = 'Could not start.';
+    console.warn('[ai-hub] task-pane start failed:', error);
+  } finally {
+    renderTaskPaneLauncher();
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Concept popover population (drives the welcome-line "see ... jobs" lists)
 // ---------------------------------------------------------------------------
@@ -1593,6 +1813,128 @@ function aggregateDotClass(dots) {
   return 'grey';
 }
 
+function closeEmployeeManageMenu() {
+  const existing = document.querySelector('.emp-manage-pop');
+  if (existing) existing.remove();
+}
+
+async function refreshCustomEmployeeSurfaces() {
+  const projectPath = (state.bootstrap && state.bootstrap.preferences && state.bootstrap.preferences.projectPath) || state.projectPath || '';
+  if (typeof loadBootstrap === 'function') {
+    await loadBootstrap(projectPath);
+  } else {
+    if (typeof renderRail === 'function') renderRail();
+    if (typeof tfRenderTree === 'function') tfRenderTree();
+    if (typeof renderActive === 'function') renderActive();
+  }
+}
+
+function openEmployeeManageMenu(group, anchorEl, detailsEl) {
+  closeEmployeeManageMenu();
+  const pop = document.createElement('div');
+  pop.className = 'emp-manage-pop';
+  pop.dataset.employeeKey = group.key;
+
+  const edit = document.createElement('button');
+  edit.type = 'button';
+  edit.className = 'emp-manage-edit';
+  edit.textContent = 'Edit';
+  edit.addEventListener('click', (e) => {
+    e.preventDefault();
+    e.stopPropagation();
+    closeEmployeeManageMenu();
+    const persona = typeof tfPersonaByKey === 'function' ? tfPersonaByKey(group.key) : null;
+    if (persona) openInlineCreateEmployee({ mode: 'edit', employee: persona });
+  });
+  pop.appendChild(edit);
+
+  const del = document.createElement('button');
+  del.type = 'button';
+  del.className = 'emp-manage-delete';
+  del.textContent = 'Delete';
+  del.addEventListener('click', (e) => {
+    e.preventDefault();
+    e.stopPropagation();
+    closeEmployeeManageMenu();
+    showCustomEmployeeDeleteConfirm(group, detailsEl);
+  });
+  pop.appendChild(del);
+
+  const dismiss = (e) => {
+    if (!pop.contains(e.target) && e.target !== anchorEl) {
+      closeEmployeeManageMenu();
+      document.removeEventListener('click', dismiss, true);
+    }
+  };
+  setTimeout(() => document.addEventListener('click', dismiss, true), 0);
+
+  document.body.appendChild(pop);
+  if (anchorEl) {
+    const rect = anchorEl.getBoundingClientRect();
+    pop.style.position = 'fixed';
+    pop.style.top = (rect.bottom + 4) + 'px';
+    pop.style.left = Math.max(8, rect.right - 112) + 'px';
+  }
+}
+
+function showCustomEmployeeDeleteConfirm(group, detailsEl) {
+  if (!detailsEl) return;
+  const existing = detailsEl.querySelector('.emp-del-confirm');
+  if (existing) {
+    existing.remove();
+    return;
+  }
+  document.querySelectorAll('.emp-del-confirm').forEach((el) => el.remove());
+  detailsEl.open = true;
+  const confirm = document.createElement('div');
+  confirm.className = 'del-confirm emp-del-confirm';
+  confirm.innerHTML = '<div>Delete ' + tfEscape(group.label) + '?</div>' +
+    '<div class="dc-detail">The employee definition leaves the active roster. Prior conversations and artifacts remain.</div>';
+  const row = document.createElement('div');
+  row.className = 'dc-row';
+  const cancel = document.createElement('button');
+  cancel.type = 'button';
+  cancel.className = 'dc-cancel';
+  cancel.textContent = 'Cancel';
+  cancel.addEventListener('click', (e) => {
+    e.preventDefault();
+    e.stopPropagation();
+    confirm.remove();
+  });
+  const del = document.createElement('button');
+  del.type = 'button';
+  del.className = 'dc-del';
+  del.textContent = 'Delete employee';
+  const detail = confirm.querySelector('.dc-detail');
+  del.addEventListener('click', async (e) => {
+    e.preventDefault();
+    e.stopPropagation();
+    del.disabled = true;
+    del.textContent = 'Deleting...';
+    try {
+      const projectPath = (state.bootstrap && state.bootstrap.preferences && state.bootstrap.preferences.projectPath) || state.projectPath || '';
+      const resp = await fetch('/api/ai-hub/custom-employees/' + encodeURIComponent(group.key) + '?projectPath=' + encodeURIComponent(projectPath), {
+        method: 'DELETE',
+      });
+      if (!resp.ok && resp.status !== 404) throw new Error('Server error: ' + resp.status);
+      if (state.cpPersonaOverride === group.key && typeof closePalette === 'function') closePalette();
+      const overlay = document.querySelector('.ipe-overlay');
+      if (overlay) overlay.remove();
+      await refreshCustomEmployeeSurfaces();
+    } catch (error) {
+      del.disabled = false;
+      del.textContent = 'Delete employee';
+      if (detail) detail.textContent = 'Could not delete employee. Try again.';
+    }
+  });
+  row.appendChild(cancel);
+  row.appendChild(del);
+  confirm.appendChild(row);
+  const summary = detailsEl.querySelector('summary');
+  if (summary && summary.nextSibling) detailsEl.insertBefore(confirm, summary.nextSibling);
+  else detailsEl.appendChild(confirm);
+}
+
 // ---------------------------------------------------------------------------
 // Rail rendering
 // ---------------------------------------------------------------------------
@@ -1919,28 +2261,53 @@ function renderRail() {
     const count = document.createElement('span');
     count.className = 'conv-employee-tab-count';
     count.textContent = String(group.conversations.length);
-    const addBtn = document.createElement('button');
-    addBtn.type = 'button';
-    addBtn.className = 'conv-employee-add';
-    addBtn.textContent = '+';
-    addBtn.title = 'Assign a job to ' + group.label;
-    addBtn.setAttribute('aria-label', 'Assign a job to ' + group.label);
-    addBtn.addEventListener('click', (e) => {
-      e.preventDefault();
-      e.stopPropagation();
-      // Issue #945: custom employees open the standard palette pre-filtered to their assigned jobs.
-      // prefixSearch uses the display name so the user sees /nova, not /custom:nova.
-      // personaKey is passed separately so renderCpRows can look up the jobIds correctly.
-      if (group.key.startsWith('custom:')) {
-        const displaySlug = group.label ? group.label.toLowerCase().replace(/\s+/g, '-') : group.key.replace('custom:', '');
-        openPalette({ prefixSearch: '/' + displaySlug, personaKey: group.key });
-        return;
-      }
-      const personaKey = group.sample && group.sample.personaKey ? group.key : null;
-      openPalette(personaKey ? { employeeId: state.bootstrap && state.bootstrap.preferences ? state.bootstrap.preferences.employeeId : 'claude', prefixSearch: '/' + personaKey } : {});
-    });
-    // Issue #945: add Personalized badge for user-authored employees (no hire CTA).
-    if (group.key.startsWith('custom:')) {
+    const groupPersona = getConversationPersona(group.sample);
+    const groupIsRemoved = isRemovedCustomPersona(groupPersona);
+    const groupIsActiveCustom = group.key.startsWith('custom:') && isActiveCustomPersona(groupPersona);
+    let addBtn = null;
+    if (!groupIsRemoved) {
+      addBtn = document.createElement('button');
+      addBtn.type = 'button';
+      addBtn.className = 'conv-employee-add';
+      addBtn.textContent = '+';
+      addBtn.title = 'Assign a job to ' + group.label;
+      addBtn.setAttribute('aria-label', 'Assign a job to ' + group.label);
+      addBtn.addEventListener('click', (e) => {
+        e.preventDefault();
+        e.stopPropagation();
+        // Issue #945: custom employees open the standard palette pre-filtered to their assigned jobs.
+        // prefixSearch uses the display name so the user sees /nova, not /custom:nova.
+        // personaKey is passed separately so renderCpRows can look up the jobIds correctly.
+        if (group.key.startsWith('custom:')) {
+          const displaySlug = group.label ? group.label.toLowerCase().replace(/\s+/g, '-') : group.key.replace('custom:', '');
+          openPalette({ prefixSearch: '/' + displaySlug, personaKey: group.key });
+          return;
+        }
+        const personaKey = group.sample && group.sample.personaKey ? group.key : null;
+        openPalette(personaKey ? { employeeId: state.bootstrap && state.bootstrap.preferences ? state.bootstrap.preferences.employeeId : 'claude', prefixSearch: '/' + personaKey } : {});
+      });
+    }
+    let manageBtn = null;
+    if (groupIsActiveCustom) {
+      manageBtn = document.createElement('button');
+      manageBtn.type = 'button';
+      manageBtn.className = 'conv-employee-manage';
+      manageBtn.textContent = '...';
+      manageBtn.title = 'Manage ' + group.label;
+      manageBtn.setAttribute('aria-label', 'Manage ' + group.label);
+      manageBtn.addEventListener('click', (e) => {
+        e.preventDefault();
+        e.stopPropagation();
+        openEmployeeManageMenu(group, manageBtn, details);
+      });
+    }
+    if (groupIsRemoved) {
+      details.classList.add('conv-employee-group--removed');
+      const removed = document.createElement('span');
+      removed.className = 'emp-removed-pill';
+      removed.textContent = 'Removed';
+      label.appendChild(removed);
+    } else if (groupIsActiveCustom) {
       const badge = document.createElement('span');
       badge.className = 'taught-badge';
       badge.textContent = 'Personalized';
@@ -1960,7 +2327,8 @@ function renderRail() {
     }
     summary.appendChild(avatar);
     summary.appendChild(copy);
-    summary.appendChild(addBtn);
+    if (addBtn) summary.appendChild(addBtn);
+    if (manageBtn) summary.appendChild(manageBtn);
     summary.appendChild(count);
     details.appendChild(summary);
     if (group.conversations.length > 0) {
@@ -2121,10 +2489,57 @@ function personaMap() {
   return map;
 }
 
+function customEmployeeNameFromKey(key) {
+  const slug = String(key || '').replace(/^custom:/, '');
+  const words = slug.split(/[-_]+/).filter(Boolean);
+  const label = words.map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(' ');
+  return label || 'Employee';
+}
+
+function conversationPersonaSnapshot(conv) {
+  const snap = conv && conv.personaSnapshot;
+  if (!snap || typeof snap !== 'object') return null;
+  return {
+    displayName: typeof snap.displayName === 'string' && snap.displayName.trim()
+      ? snap.displayName.trim()
+      : '',
+    role: typeof snap.role === 'string' && snap.role.trim()
+      ? snap.role.trim()
+      : '',
+    avatarUrl: typeof snap.avatarUrl === 'string' && snap.avatarUrl.trim()
+      ? snap.avatarUrl.trim()
+      : '',
+  };
+}
+
+function removedCustomPersonaForConversation(conv) {
+  const key = conv && conv.personaKey;
+  if (!key || !key.startsWith('custom:')) return null;
+  const snapshot = conversationPersonaSnapshot(conv);
+  const name = (snapshot && snapshot.displayName) || customEmployeeNameFromKey(key);
+  return {
+    key,
+    displayName: 'Removed employee: ' + name,
+    role: (snapshot && snapshot.role) || 'Historical employee',
+    avatarUrl: (snapshot && snapshot.avatarUrl) || '',
+    origin: 'custom',
+    jobIds: [],
+    removed: true,
+  };
+}
+
+function isRemovedCustomPersona(persona) {
+  return !!(persona && persona.removed);
+}
+
+function isActiveCustomPersona(persona) {
+  return !!(persona && !persona.removed && (persona.origin === 'custom' || String(persona.key || '').startsWith('custom:')));
+}
+
 function getConversationPersona(conv) {
   if (!conv || !conv.personaKey) return null;
   if (conv.personaKey === GENERIC_WORKER_PERSONA_KEY) return GENERIC_WORKER_PERSONA;
-  return personaMap().get(conv.personaKey) || null;
+  return personaMap().get(conv.personaKey) || removedCustomPersonaForConversation(conv);
 }
 
 // Unprotected jobs default to mandy so unassigned work surfaces
@@ -6779,6 +7194,17 @@ async function startRun(job, instructions, employeeId, preassignedConvId, invoke
   // Issue #442: read the A/B toggle state from the modal before it closes.
   const abToggle = document.getElementById('ab-toggle');
   const isAB = !isFreeform && abToggle && abToggle.checked;
+  const assignedPersonaKey = assignedPersonaKeyForJob(job);
+  const assignedPersona = assignedPersonaKey && assignedPersonaKey.startsWith('custom:')
+    ? (typeof tfPersonaByKey === 'function' ? tfPersonaByKey(assignedPersonaKey) : null)
+    : null;
+  const personaSnapshot = assignedPersona
+    ? {
+        displayName: assignedPersona.displayName || assignedPersonaKey,
+        role: assignedPersona.role || '',
+        avatarUrl: assignedPersona.avatarUrl || '',
+      }
+    : null;
 
   const conv = {
     id: preassignedConvId || newConversationId(),
@@ -6792,7 +7218,8 @@ async function startRun(job, instructions, employeeId, preassignedConvId, invoke
     baseHostId: baseHostIdForAgent(employeeId),
     // Structured jobs without a protected employee default to MANdy; freeform
     // described goals remain employee-less until promotion assigns ownership.
-    personaKey: assignedPersonaKeyForJob(job),
+    personaKey: assignedPersonaKey,
+    ...(personaSnapshot ? { personaSnapshot } : {}),
     runId: null,
     sessionId: null,
     status: 'running',
@@ -7071,6 +7498,9 @@ function foldRunIntoConversation(conv, run) {
   conv.title = conversationTitle(conv);
   // Track session for resumption.
   if (run.sessionId) conv.sessionId = run.sessionId;
+  if (run.hostSessions && typeof run.hostSessions === 'object') {
+    conv.hostSessions = { ...(conv.hostSessions || {}), ...run.hostSessions };
+  }
   const runHandoff = normalizeReviewHandoff(run.reviewHandoff);
   if (runHandoff) {
     conv.reviewHandoff = runHandoff;
@@ -8233,13 +8663,13 @@ function wireEvents() {
   }
 
   // Task-pane and extension surfaces: skip welcome/onboarding, show active job
-  // or open the new-job picker. Layout is compact (rail hidden via CSS).
+  // plus a compact project/job launcher. Layout is compact (full shell hidden via CSS).
   if (surface === 'task-pane' || surface === 'extension') {
+    await refreshTaskPaneProjects();
+    renderTaskPaneLauncher();
     const conv = activeConversation();
     if (conv && conv.projectPath === state.projectPath) {
       if (convNeedsPolling(conv)) startPolling();
-    } else {
-      openModal();
     }
     return;
   }
@@ -9028,9 +9458,8 @@ function tfRenderOverview() {
     }
     card.appendChild(team);
     card.addEventListener('click', () => tfSelectProjectView('workspace', proj.id));
-    // #719 R1/R1b: hover/focus-revealed remove control — Overview cards only, and
-    // only while another project remains (the Hub always keeps at least one).
-    if (tf.projects.length > 1) tfAttachProjectRemove(card, proj);
+    // Issue #1044: remove button shown on every project card — the Hub can be empty.
+    tfAttachProjectRemove(card, proj);
     grid.appendChild(card);
   }
   const addCard = document.createElement('div');
@@ -9200,17 +9629,19 @@ async function tfRefreshProjectsFromServerInBackground() {
 
 async function tfRemoveProject(proj) {
   const removedCanonical = tfCanonicalProjectPath(proj.folderPath || '');
-  // R5/D4: never delete the workspace we are standing in — the server re-injects
-  // the current projectPath on every load, so switch to another project first.
+  // Issue #1044: when other projects exist, switch away from the active one before
+  // deleting it (the server returns 409 if we don't). When it is the last project,
+  // skip the switch — the server now permits the delete and the Hub shows empty state.
   if (removedCanonical === tfCanonicalProjectPath(state.projectPath)) {
     const next = tf.projects.find((p) => p.id !== proj.id && tfCanonicalProjectPath(p.folderPath || '') !== removedCanonical);
-    if (!next) { showStatus('Cannot remove the only project in the Hub.', true); return; }
-    try {
-      await tfSwitchProjectFolder(next.folderPath);
-      tf.activeProjectId = next.id;
-    } catch (e) {
-      showStatus('Could not switch to another project first; nothing was removed.', true);
-      return;
+    if (next) {
+      try {
+        await tfSwitchProjectFolder(next.folderPath);
+        tf.activeProjectId = next.id;
+      } catch (e) {
+        showStatus('Could not switch to another project first; nothing was removed.', true);
+        return;
+      }
     }
   }
 
@@ -13942,10 +14373,16 @@ function openCustomEmployeePicker(employeeKey, persona, anchorEl) {
   }
 }
 
-// Renders the inline create card for a new custom employee.
-function openInlineCreateEmployee() {
+// Renders the inline create/edit card for a custom employee.
+function openInlineCreateEmployee(options) {
+  const opts = options || {};
+  const editEmployee = opts.mode === 'edit' ? opts.employee : null;
+  const isEdit = !!(editEmployee && editEmployee.key);
   const existingOverlay = document.querySelector('.ipe-overlay');
-  if (existingOverlay) { existingOverlay.remove(); return; }
+  if (existingOverlay) {
+    existingOverlay.remove();
+    if (!isEdit) return;
+  }
   const projectPath = (state.bootstrap && state.bootstrap.preferences && state.bootstrap.preferences.projectPath) || state.projectPath || '';
   const jobs = (state.bootstrap && state.bootstrap.jobs) ? state.bootstrap.jobs : [];
 
@@ -13961,7 +14398,7 @@ function openInlineCreateEmployee() {
   const hdr = document.createElement('div');
   hdr.className = 'modal-hdr';
   const hdrTitle = document.createElement('h2');
-  hdrTitle.textContent = 'New employee';
+  hdrTitle.textContent = isEdit ? 'Edit employee' : 'New employee';
   const closeBtn = document.createElement('button');
   closeBtn.type = 'button';
   closeBtn.className = 'modal-close';
@@ -13988,6 +14425,7 @@ function openInlineCreateEmployee() {
   nameInput.placeholder = 'e.g. Nova';
   nameInput.setAttribute('aria-label', 'Employee name');
   nameInput.autocomplete = 'off';
+  if (isEdit) nameInput.value = editEmployee.displayName || '';
   nameField.appendChild(nameLabel);
   nameField.appendChild(nameInput);
   body.appendChild(nameField);
@@ -14003,12 +14441,13 @@ function openInlineCreateEmployee() {
   roleInput.name = 'role';
   roleInput.placeholder = 'e.g. AI Data Analyst';
   roleInput.autocomplete = 'off';
+  if (isEdit) roleInput.value = editEmployee.role || '';
   roleField.appendChild(roleLabel);
   roleField.appendChild(roleInput);
   body.appendChild(roleField);
 
   // Job picker — searchable list matching the command palette style.
-  const selectedJobIds = new Set();
+  const selectedJobIds = new Set(isEdit && Array.isArray(editEmployee.jobIds) ? editEmployee.jobIds : []);
   const jobsField = document.createElement('div');
   jobsField.className = 'ipe-card-field';
   const jobsLabel = document.createElement('div');
@@ -14098,7 +14537,7 @@ function openInlineCreateEmployee() {
   const createBtn = document.createElement('button');
   createBtn.type = 'button';
   createBtn.className = 'ipe-btn-create';
-  createBtn.textContent = 'Create';
+  createBtn.textContent = isEdit ? 'Save' : 'Create';
   createBtn.addEventListener('click', async () => {
     const displayName = nameInput.value.trim();
     const pickedJobIds = Array.from(selectedJobIds);
@@ -14115,7 +14554,7 @@ function openInlineCreateEmployee() {
     }
     errorEl.style.display = 'none';
     createBtn.disabled = true;
-    createBtn.textContent = 'Creating…';
+    createBtn.textContent = isEdit ? 'Saving...' : 'Creating...';
     try {
       const body = {
         projectPath,
@@ -14124,26 +14563,30 @@ function openInlineCreateEmployee() {
         icon: { kind: 'generated', value: displayName },
         jobIds: pickedJobIds,
       };
-      const resp = await fetch('/api/ai-hub/custom-employees', {
-        method: 'POST',
+      const resp = await fetch(isEdit
+        ? '/api/ai-hub/custom-employees/' + encodeURIComponent(editEmployee.key)
+        : '/api/ai-hub/custom-employees', {
+        method: isEdit ? 'PATCH' : 'POST',
         headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify(body),
       });
-      if (!resp.ok) throw new Error('Server error: ' + resp.status);
-      overlay.remove();
-      // Refresh bootstrap so the new employee shows in the tree.
-      if (typeof tfBootstrap === 'function') {
-        await tfBootstrap();
-      } else if (typeof loadBootstrap === 'function') {
-        await loadBootstrap();
+      if (!resp.ok) {
+        const error = new Error('Server error: ' + resp.status);
+        error.status = resp.status;
+        throw error;
       }
-      if (typeof renderRail === 'function') renderRail();
-      if (typeof tfRenderTree === 'function') tfRenderTree();
+      overlay.remove();
+      await refreshCustomEmployeeSurfaces();
     } catch (err) {
       createBtn.disabled = false;
-      createBtn.textContent = 'Create';
-      errorEl.textContent = 'Could not create employee. Try again.';
+      createBtn.textContent = isEdit ? 'Save' : 'Create';
+      errorEl.textContent = isEdit
+        ? (err && err.status === 404 ? 'This employee no longer exists.' : 'Could not save employee. Try again.')
+        : 'Could not create employee. Try again.';
       errorEl.style.display = '';
+      if (isEdit && err && err.status === 404) {
+        await refreshCustomEmployeeSurfaces().catch(() => undefined);
+      }
     }
   });
   actions.appendChild(cancelBtn);

package/public/ai-hub/styles.css

@@ -596,6 +596,72 @@ img.conv-employee-avatar {
   background: var(--accent-soft);
   border-color: rgba(0,113,227,.28);
 }
+.conv-employee-manage {
+  width: 20px;
+  height: 20px;
+  border-radius: 6px;
+  border: 1px solid var(--line);
+  background: var(--surface);
+  color: var(--muted);
+  font-size: 13px;
+  line-height: 14px;
+  font-weight: 700;
+  text-align: center;
+  cursor: pointer;
+  flex-shrink: 0;
+  padding: 0 0 3px;
+}
+.conv-employee-manage:hover,
+.conv-employee-manage:focus-visible {
+  background: var(--accent-soft);
+  color: var(--accent);
+  border-color: rgba(0,113,227,.28);
+}
+.emp-manage-pop {
+  z-index: var(--z-dropdown-menu);
+  min-width: 112px;
+  display: grid;
+  gap: 2px;
+  padding: 5px;
+  border: 1px solid var(--line);
+  border-radius: 8px;
+  background: var(--surface);
+  box-shadow: var(--shadow-lg);
+}
+.emp-manage-pop button {
+  border: 0;
+  border-radius: 6px;
+  background: transparent;
+  color: var(--text);
+  font-size: 12px;
+  text-align: left;
+  padding: 6px 8px;
+}
+.emp-manage-pop button:hover,
+.emp-manage-pop button:focus-visible {
+  background: var(--accent-soft);
+  outline: none;
+}
+.emp-manage-delete { color: var(--danger) !important; }
+.conv-employee-group--removed .conv-employee-tab-label {
+  color: var(--muted);
+  letter-spacing: 0;
+  text-transform: none;
+}
+.emp-removed-pill {
+  display: inline-flex;
+  align-items: center;
+  margin-left: 6px;
+  padding: 1px 5px;
+  border-radius: 999px;
+  background: var(--warn-soft);
+  color: var(--warn);
+  font-size: 9px;
+  font-weight: 700;
+  letter-spacing: 0;
+  text-transform: uppercase;
+}
+.emp-del-confirm { margin-left: 28px; margin-right: 4px; }
 /* Issue #1008: No FRAIM employee group modifier */
 /* R4: dashed avatar placeholder — no image or persona initials */
 .conv-employee-avatar--absence,
@@ -2804,6 +2870,81 @@ body:is([data-surface="task-pane"],[data-surface="extension"]) {
   font-size: 13px;
   overflow: auto;
 }
+body:is([data-surface="task-pane"],[data-surface="extension"]) .hub-tabs,
+body:is([data-surface="task-pane"],[data-surface="extension"]) .hub-area,
+body:is([data-surface="task-pane"],[data-surface="extension"]) .proj-tabs {
+  display: none !important;
+}
+.task-pane-launcher { display: none; }
+body:is([data-surface="task-pane"],[data-surface="extension"]) .task-pane-launcher {
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+  padding: 12px;
+  border-bottom: 1px solid var(--border, rgba(0,0,0,0.07));
+  background: var(--surface, #fff);
+}
+.tp-launcher-header {
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+}
+.tp-launcher-title {
+  font-size: 14px;
+  font-weight: 650;
+  color: var(--text, #171717);
+}
+.tp-launcher-context,
+.tp-launcher-status {
+  min-height: 16px;
+  font-size: 11px;
+  color: var(--muted);
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.tp-launcher-field {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+  min-width: 0;
+  font-size: 11px;
+  font-weight: 600;
+  color: var(--muted);
+}
+.tp-launcher-field select,
+.tp-launcher-field textarea {
+  width: 100%;
+  min-width: 0;
+  border: 1px solid var(--border, rgba(0,0,0,0.12));
+  border-radius: 8px;
+  background: var(--panel, #fff);
+  color: var(--text, #171717);
+  font: inherit;
+  font-size: 12px;
+}
+.tp-launcher-field select {
+  height: 34px;
+  padding: 0 8px;
+}
+.tp-launcher-field textarea {
+  min-height: 78px;
+  resize: vertical;
+  padding: 8px;
+  line-height: 1.35;
+}
+.tp-launcher-actions {
+  display: grid;
+  grid-template-columns: 1fr auto;
+  align-items: center;
+  gap: 8px;
+}
+body:is([data-surface="task-pane"],[data-surface="extension"]) #task-pane-start-job {
+  min-height: 34px;
+  padding: 7px 12px;
+  border-radius: 8px;
+  font-size: 12px;
+}
 body:is([data-surface="task-pane"],[data-surface="extension"]) .page {
   padding: 10px 12px 8px;
   gap: 10px;