fraim-framework 2.0.185 → 2.0.187

package/public/ai-hub/script.js

@@ -16,7 +16,25 @@ const TREE_WIDTH_MAX = 380;
 const TREE_WIDTH_DEFAULT = 216;
 const PAGE_SCOPED_JOBS = new Set(['organization-onboarding', 'manager-agreements', 'project-onboarding', 'organizational-learning-synthesis']);
 // Jobs scoped to the Company/Manager area — never shown in the Projects workspace rail.
+// These are the truly area-only jobs. Issue #702: persona jobs (e.g. Ashley's) are NOT
+// listed here — a persona can run a job from a project OR from the Manager tab, and a
+// run's placement is decided per-invocation by conv.invokedArea, not by job id.
 const AREA_SCOPED_JOBS = new Set(['organization-onboarding', 'organizational-learning-synthesis', 'manager-agreements']);
+// Issue #708: project-independent conversation scope buckets (match server sentinels).
+const MANAGER_CONV_KEY = '@manager';
+const COMPANY_CONV_KEY = '@company';
+// A conversation's scope: prefer the persisted `scope`, fall back to the legacy `invokedArea`.
+function convScope(conv) {
+  const s = conv && (conv.scope || conv.invokedArea);
+  return (s === 'manager' || s === 'company') ? s : 'project';
+}
+// Which state.conversations bucket a conversation belongs to.
+function convBucketKey(conv) {
+  const s = convScope(conv);
+  if (s === 'manager') return MANAGER_CONV_KEY;
+  if (s === 'company') return COMPANY_CONV_KEY;
+  return (conv && typeof conv.projectPath === 'string' && conv.projectPath) ? conv.projectPath : state.projectPath;
+}
 
 const state = {
   bootstrap: null,
@@ -117,7 +135,11 @@ async function requestJson(url, options) {
   if (!response.ok) {
     const errVal = payload && payload.error;
     const message = (errVal && typeof errVal === 'object' ? errVal.message : errVal) || `Request failed (${response.status}).`;
-    throw new Error(message);
+    const error = new Error(message);
+    // #719: callers branch on the HTTP status (e.g. DELETE 404 already-removed vs
+    // 409 sequencing error) — carry it on the thrown error.
+    error.status = response.status;
+    throw error;
   }
   return payload;
 }
@@ -444,16 +466,30 @@ function projectConversationPayload() {
 }
 
 function scheduleConversationDiskPersist() {
-  if (!state.projectPath) return;
+  // Issue #708: no early-return on missing projectPath — manager/company scope buckets
+  // must persist even when no project is selected (their whole point is project-independence).
   if (state.conversationPersistTimer) window.clearTimeout(state.conversationPersistTimer);
   state.conversationPersistTimer = window.setTimeout(async () => {
     state.conversationPersistTimer = null;
     try {
-      await requestJson('/api/ai-hub/conversations', {
-        method: 'PUT',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(projectConversationPayload()),
-      });
+      if (state.projectPath) {
+        await requestJson('/api/ai-hub/conversations', {
+          method: 'PUT',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify(projectConversationPayload()),
+        });
+      }
+      // Issue #708: persist scope buckets (manager/company) to their project-independent
+      // home so their runs survive project switches/removal and reload correctly.
+      for (const [scope, key] of [['manager', MANAGER_CONV_KEY], ['company', COMPANY_CONV_KEY]]) {
+        const bucket = state.conversations[key];
+        if (!Array.isArray(bucket)) continue;
+        await requestJson('/api/ai-hub/conversations', {
+          method: 'PUT',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ scope, activeId: null, conversations: bucket }),
+        });
+      }
       state.conversationDiskAvailable = true;
     } catch (error) {
       state.conversationDiskAvailable = false;
@@ -468,7 +504,28 @@ function persistConversations(options) {
 }
 
 async function hydrateConversationsFromServer() {
-  if (!state.projectPath) return;
+  // Issue #708: load the project-independent scope buckets (manager/company) first, so
+  // manager runs are present regardless of whether a project is selected.
+  try {
+    for (const [scope, key] of [['manager', MANAGER_CONV_KEY], ['company', COMPANY_CONV_KEY]]) {
+      const scopePayload = await requestJson(`/api/ai-hub/conversations?scope=${scope}`);
+      const scopeConvs = Array.isArray(scopePayload.conversations) ? scopePayload.conversations : [];
+      for (const conv of scopeConvs) normalizeGeminiConversationMessages(conv);
+      // Only materialize a scope bucket when it has content (or already exists). Creating
+      // empty @manager/@company buckets on every project hydrate pollutes state.conversations
+      // and, because they land ahead of the project bucket, breaks the "project bucket is the
+      // primary key" invariant that project-scoped rendering relies on (#550 Watercooler).
+      if (scopeConvs.length || Array.isArray(state.conversations[key])) {
+        state.conversations[key] = scopeConvs;
+      }
+    }
+  } catch (error) {
+    console.warn('Could not hydrate manager/company conversations:', error);
+  }
+  if (!state.projectPath) {
+    if (typeof tfRenderManager === 'function' && typeof tf !== 'undefined' && tf.area === 'manager') tfRenderManager();
+    return;
+  }
   try {
     const payload = await requestJson(`/api/ai-hub/conversations?projectPath=${encodeURIComponent(state.projectPath)}`);
     const conversations = Array.isArray(payload.conversations) ? payload.conversations : [];
@@ -509,9 +566,10 @@ async function bgRefreshConversations() {
         existing.push(conv);
         changed = true;
       } else {
-        // Update status/messages on known conversations (e.g. running → completed)
+        // Update known conversations when the server projection changes. This
+        // includes job/persona recognition for running ad-hoc jobs.
         const idx = existing.findIndex((c) => c.id === conv.id);
-        if (idx !== -1 && existing[idx].status !== conv.status) {
+        if (idx !== -1 && conversationProjectionChanged(existing[idx], conv)) {
           existing[idx] = conv;
           changed = true;
         }
@@ -533,7 +591,7 @@ function stopBgConvPoll() {
   if (_bgConvPollHandle) { window.clearInterval(_bgConvPollHandle); _bgConvPollHandle = null; }
 }
 
-function needsConversationRefresh() {
+function needsDelegatedConversationRefresh() {
   const active = activeConversation();
   if (!active) return false;
   if (isManagedDelegationChild(active) && active.status === 'running') return true;
@@ -548,12 +606,49 @@ function needsConversationRefresh() {
   });
 }
 
+function needsConversationRefresh() {
+  return runningProjectConversations().length > 0 || needsDelegatedConversationRefresh();
+}
+
+async function refreshRunningConversations() {
+  const running = runningProjectConversations();
+  if (!running.length) return false;
+  let changed = false;
+  for (const conv of running) {
+    try {
+      const run = await requestJson(`/api/ai-hub/runs/${encodeURIComponent(conv.runId)}`);
+      foldRunIntoConversation(conv, run);
+      upsertConversation(conv);
+      changed = true;
+    } catch (_) {
+      // The run may have just completed and left the in-memory registry before
+      // the conversation store hydrated. The next conversation refresh catches it.
+    }
+  }
+  if (changed) {
+    renderRail();
+    renderActive();
+    if (tf.area === 'company') tfRenderCompany();
+    else if (tf.area === 'manager') tfRenderManager();
+  }
+  return changed;
+}
+
+async function refreshConversationProjections() {
+  await refreshRunningConversations();
+  if (needsDelegatedConversationRefresh()) {
+    await hydrateConversationsFromServer();
+  } else {
+    syncConversationRefreshPolling();
+  }
+}
+
 function syncConversationRefreshPolling() {
   const shouldPoll = needsConversationRefresh();
   if (shouldPoll && !state.conversationRefreshHandle) {
     state.conversationRefreshHandle = window.setInterval(() => {
-      hydrateConversationsFromServer().catch((error) =>
-        console.warn('Could not refresh delegated conversations:', error));
+      refreshConversationProjections().catch((error) =>
+        console.warn('Could not refresh conversations:', error));
     }, 1500);
   } else if (!shouldPoll && state.conversationRefreshHandle) {
     window.clearInterval(state.conversationRefreshHandle);
@@ -578,6 +673,32 @@ function projectConversations() {
   return state.conversations[key] || [];
 }
 
+function conversationProjectionChanged(existing, incoming) {
+  if (!existing || !incoming) return true;
+  const fields = [
+    'jobId',
+    'jobTitle',
+    'personaKey',
+    'runId',
+    'sessionId',
+    'status',
+    'managedReviewStatus',
+    'compareRunId',
+    'sourceTrigger',
+  ];
+  if (fields.some((field) => (existing[field] ?? null) !== (incoming[field] ?? null))) return true;
+  const existingMessages = Array.isArray(existing.messages) ? existing.messages.length : 0;
+  const incomingMessages = Array.isArray(incoming.messages) ? incoming.messages.length : 0;
+  if (existingMessages !== incomingMessages) return true;
+  const existingEvents = Array.isArray(existing.events) ? existing.events.length : 0;
+  const incomingEvents = Array.isArray(incoming.events) ? incoming.events.length : 0;
+  return existingEvents !== incomingEvents;
+}
+
+function runningProjectConversations() {
+  return projectConversations().filter((conv) => conv && conv.status === 'running' && conv.runId);
+}
+
 function setProjectConversations(list) {
   const key = state.projectPath || '';
   state.conversations[key] = list;
@@ -743,12 +864,15 @@ function syncConversationPanels(conv, switchedConv) {
 }
 
 function upsertConversation(conv) {
-  const list = projectConversations().slice();
+  // Issue #708: route to the conversation's scope bucket (manager/company → sentinel
+  // key; project → its project bucket) so manager runs have a project-independent home.
+  const key = convBucketKey(conv);
+  const list = (state.conversations[key] || []).slice();
   const idx = list.findIndex((c) => c.id === conv.id);
   if (idx >= 0) list[idx] = conv;
   else list.unshift(conv);
-  setProjectConversations(list);
-  persistConversations();
+  state.conversations[key] = list;
+  persistConversations({ scope: convScope(conv) });
 }
 
 function newConversationId() {
@@ -854,7 +978,9 @@ function renderRail() {
   const list = allProjectConversations.filter((conv) =>
     (!state.selectedPersonaKey || conv.personaKey === state.selectedPersonaKey) &&
     !isManagedDelegationChild(conv) &&
-    !AREA_SCOPED_JOBS.has(conv.jobId)
+    !AREA_SCOPED_JOBS.has(conv.jobId) &&
+    // #702/#708: manager/company-scoped runs surface on those tabs, not in a project.
+    convScope(conv) === 'project'
   );
 
   // Issue #550: Two-path routing for ad-hoc (freeform) conversations.
@@ -2034,11 +2160,29 @@ function renderTracker(conv) {
 
   const stages = Array.isArray(conv.run.stages) ? conv.run.stages : [];
   if (stages.length === 0) {
-    tracker.hidden = true;
+    // Issue #711 — adhoc runs (jobId '__freeform__') declare no phases, so
+    // there is no pizza tracker. We still surface the run totals (tokens,
+    // cost, duration) that the server derives for every run. Keep the tracker
+    // container visible in "totals-only" mode so renderTotals has a place to
+    // render; otherwise hide the whole section.
+    if (conv.run.totals) {
+      tracker.hidden = false;
+      tracker.classList.add('tracker--totals-only');
+      tracker.classList.remove('tracker-compact');
+      const rowsHost = els['tracker-rows'];
+      if (rowsHost) rowsHost.innerHTML = '';
+      const activeLabel = tracker.querySelector('.tracker-active-label');
+      if (activeLabel) activeLabel.textContent = '';
+      const note = els['tracker-note'];
+      if (note) { note.hidden = true; note.textContent = ''; }
+    } else {
+      tracker.hidden = true;
+    }
     renderedTrackerKey = null;
     return;
   }
 
+  tracker.classList.remove('tracker--totals-only');
   tracker.hidden = false;
   tracker.dataset.stageCount = String(stages.length);
   const rowCapacity = trackerRowCapacity(tracker, stages);
@@ -4753,7 +4897,7 @@ function deriveTitle(jobTitle, instructions) {
 // The browser sends raw manager instructions. AI Hub normalizes assigned
 // FRAIM jobs into host-facing invocations so the Hub UI and channel callers
 // share one start/continue contract.
-async function startRun(job, instructions, employeeId, preassignedConvId) {
+async function startRun(job, instructions, employeeId, preassignedConvId, invokedArea) {
   const isFreeform = job.id === '__freeform__';
   // In task-pane/extension mode: get a fresh selection snapshot and prepend
   // document context to the instructions so the agent knows what the user is
@@ -4792,6 +4936,16 @@ async function startRun(job, instructions, employeeId, preassignedConvId) {
     compareRun: null,
     // Issue #489: capture selection state at job-start so write-back knows insert-after vs append.
     wordStartedWithSelection: document.body.dataset.surface === 'task-pane' && !!(state.wordContext && state.wordContext.hasSelection),
+    // Issue #702: remember which area this run was launched from so its run surfaces
+    // where it was invoked (project-invoked → that project; manager-invoked → Manager tab).
+    // Defaults to the current area.
+    invokedArea: invokedArea || (typeof tf !== 'undefined' && tf.area) || 'projects',
+    // Issue #708: persisted scope drives which store bucket the run lives in
+    // (manager/company get a project-independent home). Derived from invocation area.
+    scope: (function () {
+      const a = invokedArea || (typeof tf !== 'undefined' && tf.area) || 'projects';
+      return (a === 'manager' || a === 'company') ? a : 'project';
+    })(),
   };
   upsertConversation(conv);
   state.activeId = conv.id;
@@ -4958,6 +5112,18 @@ async function continueRun(text) {
 }
 
 function foldRunIntoConversation(conv, run) {
+  // Issue #710: server run identity is canonical. The browser may have
+  // created this conversation as provisional __freeform__ state, but every
+  // server snapshot can promote it to a real catalog job.
+  if (run.jobId) {
+    conv.jobId = run.jobId;
+  }
+  if (run.jobTitle !== undefined && run.jobTitle !== null) {
+    conv.jobTitle = run.jobTitle;
+  }
+  if (run.personaKey !== undefined) {
+    conv.personaKey = run.personaKey;
+  }
   // Issue #347: keep the latest server snapshot under conv.run so the
   // tracker / totals renderers can read it without re-doing work. Stages,
   // currentPhase, phaseHistory, and totals are all server-derived per
@@ -4967,6 +5133,7 @@ function foldRunIntoConversation(conv, run) {
     currentPhase: run.currentPhase || null,
     phaseHistory: run.phaseHistory || [],
     totals: run.totals || null,
+    runDiscriminant: run.runDiscriminant || null,
   };
   // Replace the conversation's events with the run's events (single source of truth on the server).
   // If this conversation was restarted on a different agent, prepend the prior run's events so
@@ -4984,10 +5151,6 @@ function foldRunIntoConversation(conv, run) {
   conv.messages = priorMessages.length > 0 ? [...priorMessages, ...newMessages] : newMessages;
   // Track session for resumption.
   if (run.sessionId) conv.sessionId = run.sessionId;
-  // R4: persist the persona key from the server-side run record.
-  if (run.personaKey !== undefined && conv.personaKey == null) {
-    conv.personaKey = run.personaKey;
-  }
   const runHandoff = normalizeReviewHandoff(run.reviewHandoff);
   if (runHandoff) {
     conv.reviewHandoff = runHandoff;
@@ -6233,11 +6396,18 @@ function tfConvForAssignment(assignment) {
 function tfConversationsForJob(jobId, opts) {
   const out = [];
   const projectPath = opts && opts.projectPath;
+  // #702: optional invokedArea filter so the Manager rail shows only manager-invoked
+  // runs of a persona job (project-invoked runs of the same job stay in the project).
+  const invokedArea = opts && opts.invokedArea;
   const lists = projectPath
     ? [state.conversations[projectPath] || []]
     : Object.values(state.conversations || {});
   for (const list of lists) {
-    for (const c of (list || [])) if (c && c.jobId === jobId) out.push(c);
+    for (const c of (list || [])) {
+      if (!c || c.jobId !== jobId) continue;
+      if (invokedArea && (c.invokedArea || 'projects') !== invokedArea) continue;
+      out.push(c);
+    }
   }
   out.sort((a, b) => (b.updatedAt || b.createdAt || 0) - (a.updatedAt || a.createdAt || 0));
   return out;
@@ -6497,6 +6667,9 @@ 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);
     grid.appendChild(card);
   }
   const addCard = document.createElement('div');
@@ -6509,6 +6682,167 @@ function tfRenderOverview() {
   tfSwitchOverviewView(storedView || (tf.projects.length >= 3 ? 'kanban' : 'cards'));
 }
 
+// ---------------------------------------------------------------------------
+// Issue #719: remove a project from the Hub (Overview card 🗑 + inline confirm)
+// ---------------------------------------------------------------------------
+
+// The card-positioned sibling of tfAttachRunDelete: a hover/focus-revealed 🗑 in
+// the card's top-right. Keyboard-operable (tabindex + Enter/Space) per R11.
+function tfAttachProjectRemove(cardEl, proj) {
+  if (!cardEl || !proj) return;
+  const del = document.createElement('span');
+  del.className = 'proj-del';
+  del.textContent = '🗑';
+  del.title = 'Remove this project from the Hub';
+  del.setAttribute('role', 'button');
+  del.setAttribute('aria-label', 'Remove project from Hub');
+  del.tabIndex = 0;
+  del.addEventListener('click', (e) => {
+    e.preventDefault();
+    e.stopPropagation();
+    tfConfirmProjectRemove(proj, cardEl);
+  });
+  del.addEventListener('keydown', (e) => {
+    if (e.key !== 'Enter' && e.key !== ' ') return;
+    e.preventDefault();
+    e.stopPropagation();
+    tfConfirmProjectRemove(proj, cardEl);
+  });
+  cardEl.appendChild(del);
+}
+
+function tfCloseProjectConfirm() {
+  document.querySelectorAll('.del-confirm').forEach((n) => n.remove());
+  document.removeEventListener('keydown', tfProjectConfirmEscape, true);
+}
+function tfProjectConfirmEscape(e) {
+  if (e.key === 'Escape') tfCloseProjectConfirm();
+}
+
+// Inline confirm anchored inside the card — the run-delete idiom (tfConfirmRunDelete)
+// with the project scope-of-loss copy. Loads run/schedule state from the server so
+// the copy can state the schedule count (R6) and block removal while runs are in
+// progress (R7). Nothing is deleted until the confirm button is clicked (C1).
+function tfConfirmProjectRemove(proj, cardEl) {
+  tfCloseProjectConfirm();
+  const box = document.createElement('div');
+  box.className = 'del-confirm';
+  // Any click inside the confirm must not bubble into the card's open-workspace handler.
+  box.addEventListener('click', (e) => e.stopPropagation());
+  const msg = document.createElement('div');
+  msg.textContent = 'Remove "' + (proj.name || 'this project') + '" from the Hub? Its run history, job assignments, and Hub settings are forgotten. The project’s files on disk are untouched.';
+  const detail = document.createElement('div');
+  detail.className = 'dc-detail';
+  detail.textContent = 'Checking for runs and schedules…';
+  const row = document.createElement('div'); row.className = 'dc-row';
+  const del = document.createElement('button'); del.className = 'dc-del'; del.type = 'button'; del.textContent = 'Remove project';
+  del.disabled = true; // enabled once the run/schedule check resolves (C1/R7)
+  del.addEventListener('click', (e) => {
+    e.stopPropagation();
+    if (del.disabled) return;
+    tfCloseProjectConfirm();
+    tfRemoveProject(proj);
+  });
+  const cancel = document.createElement('button'); cancel.className = 'dc-cancel'; cancel.type = 'button'; cancel.textContent = 'Cancel';
+  cancel.addEventListener('click', (e) => { e.stopPropagation(); tfCloseProjectConfirm(); });
+  row.appendChild(del); row.appendChild(cancel);
+  box.appendChild(msg); box.appendChild(detail); box.appendChild(row);
+  cardEl.appendChild(box);
+  document.addEventListener('keydown', tfProjectConfirmEscape, true);
+
+  const encodedPath = encodeURIComponent(proj.folderPath || '');
+  Promise.all([
+    requestJson('/api/ai-hub/conversations?projectPath=' + encodedPath).catch(() => null),
+    requestJson('/api/ai-hub/schedules?projectPath=' + encodedPath).catch(() => []),
+    requestJson('/api/ai-hub/webhooks?projectPath=' + encodedPath).catch(() => []),
+  ]).then(([convPayload, schedules, webhooks]) => {
+    if (!box.isConnected) return;
+    const serverConvs = (convPayload && Array.isArray(convPayload.conversations)) ? convPayload.conversations : [];
+    const cachedConvs = state.conversations[proj.folderPath] || [];
+    const running = [...serverConvs, ...cachedConvs].some((c) => c && c.status === 'running');
+    if (running) {
+      // R7: never forget in-flight work — block until the runs finish or are stopped.
+      detail.textContent = 'Runs are in progress in this project. Stop them or wait for them to finish before removing.';
+      del.disabled = true;
+      return;
+    }
+    const scheduleCount = Array.isArray(schedules) ? schedules.length : 0;
+    const webhookCount = Array.isArray(webhooks) ? webhooks.length : 0;
+    const parts = [];
+    if (scheduleCount) parts.push(scheduleCount + ' scheduled deployment' + (scheduleCount === 1 ? '' : 's'));
+    if (webhookCount) parts.push(webhookCount + ' webhook' + (webhookCount === 1 ? '' : 's'));
+    detail.textContent = parts.length ? (parts.join(' and ') + ' will also be removed.') : '';
+    if (!parts.length) detail.remove();
+    del.disabled = false;
+  });
+}
+
+// R10: adopt a server projects list as the authoritative tf.projects — a REPLACE,
+// not a tfMergeProjects union, so a later tfPersistProjects PUT cannot re-add a
+// removed project from stale in-memory state.
+function tfAdoptServerProjects(projects) {
+  const normalized = (Array.isArray(projects) ? projects : [])
+    .map((project) => tfNormalizeProject(project))
+    .filter(Boolean);
+  tf.projects = tfApplyUniqueProjectIds(normalized);
+}
+
+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.
+  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;
+    }
+  }
+
+  let payload;
+  try {
+    payload = await requestJson(
+      '/api/ai-hub/projects/' + encodeURIComponent(proj.id) + '?projectPath=' + encodeURIComponent(state.projectPath),
+      { method: 'DELETE' },
+    );
+  } catch (error) {
+    if (error && error.status === 404) {
+      // Already removed elsewhere (double-click / second tab): treat as success
+      // for rendering and adopt the server's current list.
+      try { payload = { projects: (await requestJson('/api/ai-hub/projects?projectPath=' + encodeURIComponent(state.projectPath))).projects }; }
+      catch { payload = { projects: tf.projects.filter((p) => p.id !== proj.id) }; }
+      showStatus('That project was already removed.', false);
+    } else if (error && error.status === 409) {
+      showStatus('Switch to another project first, then remove this one.', true);
+      return;
+    } else {
+      // Server unreachable or rejected: no optimistic client mutation.
+      showStatus('Could not remove the project: ' + (error && error.message ? error.message : 'request failed.'), true);
+      return;
+    }
+  }
+
+  // R3/R10: drop every client layer, adopting the server list as authoritative.
+  tfAdoptServerProjects(payload && payload.projects);
+  delete tf.assignments[proj.id];
+  tfPersistAssignments();
+  for (const key of Object.keys(state.conversations || {})) {
+    if (tfCanonicalProjectPath(key) === removedCanonical) delete state.conversations[key];
+  }
+  if (!tf.projects.some((p) => p.id === tf.activeProjectId)) {
+    tf.activeProjectId = tf.projects[0] ? tf.projects[0].id : null;
+  }
+  tfPersistProjects();
+  tfRenderProjectTabs();
+  tfRenderOverview();
+  if (typeof renderRail === 'function') renderRail();
+  showStatus('"' + (proj.name || 'Project') + '" was removed from the Hub. Its files on disk are untouched.', false);
+}
+
 // ---------------------------------------------------------------------------
 // Issue #671: Kanban view for Projects Overview
 // ---------------------------------------------------------------------------
@@ -8009,10 +8343,12 @@ function tfActiveOrgConv() {
   );
 }
 
-// #594 R2: return the org-scoped manager-agreements conversation to show in Manager area.
+// #594 R2: return the manager-scoped conversation to show in Manager area.
+// #702: manager-tab runs are those invoked from the manager area (any persona job),
+// plus the area-only manager-agreements job (older runs predate invokedArea). An active
+// manager-invoked run surfaces in the Manager conversation host (Coach panel included).
 function tfActiveMgrConv() {
-  const mgrJobs = new Set(['manager-agreements']);
-  const convs = Object.values(state.conversations || {}).flat().filter((c) => mgrJobs.has(c.jobId));
+  const convs = Object.values(state.conversations || {}).flat().filter((c) => c && (convScope(c) === 'manager' || c.jobId === 'manager-agreements'));
   return (
     convs.find((c) => c.status === 'running') ||
     convs.find((c) => c.status === 'waiting') ||
@@ -8021,6 +8357,93 @@ function tfActiveMgrConv() {
   );
 }
 
+// #702: is a persona hired (has a company seat) so its manager-tab jobs should show?
+// (MANAGER_ASHLEY_JOBS is defined once at the top of this file as the single source of truth.)
+function tfIsPersonaHired(personaKey) {
+  const personas = (state.bootstrap && state.bootstrap.personas) || [];
+  const p = personas.find((x) => x && x.key === personaKey);
+  return !!(p && (p.status === 'hired' || (p.seatCount || 0) > 0));
+}
+
+// #702: launch a persona job from the Manager tab. Reuses the area pre-flight modal +
+// run routing (targetArea 'manager'), so the run opens in #manager-conv-host with the
+// Coach panel and is tagged invokedArea='manager' — exactly like manager-agreements.
+function tfStartManagerPersonaJob(jobId) {
+  tfOpenAreaOnboardModal(jobId, 'Run ' + jobId + ' across the projects I manage and my calendar.', 'manager');
+}
+
+// #702: run-item button matching the Projects rail (conv-item), for the manager
+// employee group. Mirrors the core of renderRail's buildRunButton so runs look
+// identical on both tabs.
+function tfBuildManagerRunItem(conv) {
+  const btn = document.createElement('button');
+  btn.className = 'conv-item';
+  btn.type = 'button';
+  btn.dataset.conv = conv.id;
+  const body = document.createElement('span'); body.className = 'conv-body';
+  const title = document.createElement('span'); title.className = 'conv-title';
+  title.textContent = conv.title || conv.jobTitle || conv.jobId || 'Run';
+  body.appendChild(title); btn.appendChild(body);
+  const dotClass = conversationStateDotClass(conv);
+  const dot = document.createElement('span'); dot.className = 'state-dot conv-state-dot dot-' + dotClass;
+  if (typeof tfDotTitle === 'function') dot.title = tfDotTitle(dotClass);
+  btn.appendChild(dot);
+  const status = document.createElement('span'); status.className = 'conv-status';
+  status.textContent = conversationStateLabel(conv);
+  status.classList.add(conversationUiState(conv));
+  btn.appendChild(status);
+  tfAttachRunDelete(btn, conv, { tree: false });
+  btn.addEventListener('click', () => switchToConversation(conv.id));
+  return btn;
+}
+
+// #702: render a hired persona as an employee group on the Manager rail — the SAME
+// visual as the Projects rail employee groups (avatar + name + role + count + "+" that
+// opens the job palette), with the persona's MANAGER-invoked runs listed under it.
+// Keeps a persona looking like an employee, consistent across tabs.
+function tfRenderManagerPersonaGroup(rail, persona) {
+  const sample = { personaKey: persona.key };
+  const runs = Object.values(state.conversations || {}).flat()
+    .filter((c) => c && c.personaKey === persona.key && convScope(c) === 'manager')
+    .sort((a, b) => (b.lastUpdatedAt || 0) - (a.lastUpdatedAt || 0));
+  const details = document.createElement('details');
+  details.className = 'conv-employee-group';
+  details.open = true;
+  const summary = document.createElement('summary');
+  summary.className = 'conv-employee-tab';
+  const avatar = buildConversationEmployeeAvatar(sample, 'conv-employee-avatar');
+  const copy = document.createElement('span'); copy.className = 'conv-employee-tab-copy';
+  const label = document.createElement('strong'); label.className = 'conv-employee-tab-label';
+  label.textContent = persona.displayName || persona.key;
+  const detail = document.createElement('small'); detail.className = 'conv-employee-tab-detail';
+  detail.textContent = persona.role || 'AI Employee';
+  copy.appendChild(label); copy.appendChild(detail);
+  const addBtn = document.createElement('button'); addBtn.type = 'button'; addBtn.className = 'conv-employee-add';
+  addBtn.textContent = '+';
+  addBtn.title = 'Launch a job for ' + (persona.displayName || persona.key);
+  addBtn.setAttribute('aria-label', 'Launch a job for ' + (persona.displayName || persona.key));
+  addBtn.addEventListener('click', (e) => {
+    e.preventDefault(); e.stopPropagation();
+    // Launch from the Manager tab: palette prefiltered to this persona. Runs started
+    // while the manager tab is active default to invokedArea='manager'.
+    openPalette({ employeeId: (state.bootstrap && state.bootstrap.preferences && state.bootstrap.preferences.employeeId) || 'claude', prefixSearch: '/' + persona.key });
+  });
+  const count = document.createElement('span'); count.className = 'conv-employee-tab-count';
+  count.textContent = String(runs.length);
+  summary.appendChild(avatar); summary.appendChild(copy); summary.appendChild(addBtn); summary.appendChild(count);
+  details.appendChild(summary);
+  const listDiv = document.createElement('div'); listDiv.className = 'conv-employee-list';
+  if (!runs.length) {
+    const hint = document.createElement('div'); hint.className = 'eh-empty';
+    hint.textContent = 'No runs yet — + to launch a job.';
+    listDiv.appendChild(hint);
+  } else {
+    for (const c of runs) listDiv.appendChild(tfBuildManagerRunItem(c));
+  }
+  details.appendChild(listDiv);
+  rail.appendChild(details);
+}
+
 // Move the shared .page conversation panel into the specified area's workspace-conv host.
 // All .workspace-conv CSS rules (header/rail hidden, conv fills space) apply automatically
 // because the area-conv-host elements carry the workspace-conv class.
@@ -8216,6 +8639,30 @@ function tfRenderManager() {
     rail.appendChild(infoBtn);
     // #693 R1 (PR round 2): the "Manager jobs" launcher list is retired.
     // Manager agreements now runs from the "Context & rules" section it populates.
+    // Issue #702: for each hired persona with catalog jobs, render an EMPLOYEE GROUP on
+    // the Manager rail — the same avatar + name + runs + "+" presentation as the Projects
+    // rail (tfRenderManagerPersonaGroup reuses conv-employee-group), so a persona looks
+    // identical on both tabs. Data-driven from bootstrap job metadata (job.requiredPersonaKey),
+    // not a hardcoded list. Runs launched here are tagged invokedArea='manager'; the same
+    // employee's job launched inside a project stays in that project.
+    const mgrPersonas = (state.bootstrap && state.bootstrap.personas) || [];
+    const catalogJobs = (state.bootstrap && state.bootstrap.jobs) || [];
+    let anyMgrEmployee = false;
+    for (const persona of mgrPersonas) {
+      if (!tfIsPersonaHired(persona.key)) continue;
+      if (!catalogJobs.some((j) => j && j.requiredPersonaKey === persona.key)) continue;
+      if (!anyMgrEmployee) {
+        const head = document.createElement('div'); head.className = 'area-rail-head'; head.textContent = 'Your employees';
+        rail.appendChild(head);
+        anyMgrEmployee = true;
+      }
+      tfRenderManagerPersonaGroup(rail, persona);
+    }
+    if (anyMgrEmployee) {
+      const pNote = document.createElement('div'); pNote.className = 'area-rail-note';
+      pNote.textContent = "These employees work across every project you manage. Launch a job here (＋) for cross-project work — its run stays on this tab; the same employee's job launched inside a project stays there. Coach and verify like any employee.";
+      rail.appendChild(pNote);
+    }
   }
   const profile = document.getElementById('manager-profile');
   const learn = document.getElementById('manager-learnings');
@@ -8847,6 +9294,15 @@ const AREA_ONBOARD_CONFIG = {
     title: 'Manager agreements',
     desc: 'FRAIM will learn how you work and write manager_context.md and manager_rules.md. Add any specific direction below.',
   },
+  // Issue #702: Ashley's manager-tab jobs.
+  'executive-assistant': {
+    title: 'Ashley — what needs you today',
+    desc: "Ashley reviews the projects you manage plus your calendar and briefs you on what needs your attention. Add any specific focus below.",
+  },
+  'weekly-operating-review': {
+    title: 'Ashley — weekly operating review',
+    desc: 'Ashley produces your weekly portfolio operating brief. Add any specific focus areas below.',
+  },
 };
 
 function tfOpenAreaOnboardModal(jobId, baseMessage, area) {
@@ -8892,7 +9348,7 @@ async function tfStartOnboardingJob(jobId, message, targetArea, userContext) {
   const finalMessage = (userContext && userContext.trim()) ? userContext.trim() : jobMessage;
   if (job && typeof startRun === 'function') {
     if (targetArea) tfShowArea(targetArea);
-    await startRun(job, finalMessage, employeeId);
+    await startRun(job, finalMessage, employeeId, undefined, targetArea);
     // After run creation refresh the area panel so the conversation becomes visible.
     if (targetArea === 'company') tfRenderCompany();
     else if (targetArea === 'manager') tfRenderManager();