fraim-framework 2.0.171 → 2.0.174

package/public/ai-hub/script.js

@@ -15,6 +15,8 @@ const TREE_WIDTH_MIN = 176;
 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.
+const AREA_SCOPED_JOBS = new Set(['organization-onboarding', 'organizational-learning-synthesis', 'manager-agreements']);
 
 const state = {
   bootstrap: null,
@@ -36,6 +38,7 @@ const state = {
   pendingCoachingJobId: null,
   pendingCoachingLabel: null,
   conversationPersistTimer: null,
+  conversationRefreshHandle: null,
   conversationDiskAvailable: true,
   // Issue #539: command palette state
   cpSelectedJob: null,    // {id, title, intent, requiredPersonaKey}
@@ -424,16 +427,92 @@ async function hydrateConversationsFromServer() {
     for (const conv of conversations) normalizeGeminiConversationMessages(conv);
     state.conversations[state.projectPath] = conversations;
     const activeCandidates = [state.activeId, payload.activeId].filter(Boolean);
-    state.activeId = activeCandidates.find((id) => conversations.some((conv) => conv.id === id)) || (conversations[0] ? conversations[0].id : null);
+    // Area-scoped jobs must not become the Projects workspace active conversation —
+    // they are shown in their own Company/Manager panels via tfActiveOrgConv/tfActiveMgrConv.
+    const projectConv = (id) => conversations.find((c) => c.id === id && !AREA_SCOPED_JOBS.has(c.jobId));
+    const firstProjectConv = conversations.find((c) => !AREA_SCOPED_JOBS.has(c.jobId));
+    const bestActive = activeCandidates.map(projectConv).find(Boolean) || firstProjectConv || null;
+    state.activeId = bestActive ? bestActive.id : null;
     state.conversationDiskAvailable = true;
     renderRail();
     renderActive();
+    syncConversationRefreshPolling();
   } catch (error) {
     state.conversationDiskAvailable = false;
     console.warn('Could not hydrate conversations from server:', error);
   }
 }
 
+// Background poll: pick up conversations created by scheduled/webhook runs
+// without requiring the user to reload. Merges new/updated conversations into
+// the existing list, preserving the active selection.
+async function bgRefreshConversations() {
+  if (!state.projectPath) return;
+  try {
+    const payload = await requestJson(`/api/ai-hub/conversations?projectPath=${encodeURIComponent(state.projectPath)}`);
+    const incoming = Array.isArray(payload.conversations) ? payload.conversations : [];
+    if (!incoming.length) return;
+    const existing = state.conversations[state.projectPath] || [];
+    const existingIds = new Set(existing.map((c) => c.id));
+    let changed = false;
+    for (const conv of incoming) {
+      normalizeGeminiConversationMessages(conv);
+      if (!existingIds.has(conv.id)) {
+        existing.push(conv);
+        changed = true;
+      } else {
+        // Update status/messages on known conversations (e.g. running → completed)
+        const idx = existing.findIndex((c) => c.id === conv.id);
+        if (idx !== -1 && existing[idx].status !== conv.status) {
+          existing[idx] = conv;
+          changed = true;
+        }
+      }
+    }
+    if (changed) {
+      state.conversations[state.projectPath] = existing;
+      renderRail();
+    }
+  } catch (_) { /* silent — background poll, not critical */ }
+}
+
+let _bgConvPollHandle = null;
+function startBgConvPoll() {
+  if (_bgConvPollHandle) return;
+  _bgConvPollHandle = window.setInterval(bgRefreshConversations, 30000);
+}
+function stopBgConvPoll() {
+  if (_bgConvPollHandle) { window.clearInterval(_bgConvPollHandle); _bgConvPollHandle = null; }
+}
+
+function needsConversationRefresh() {
+  const active = activeConversation();
+  if (!active) return false;
+  if (isManagedDelegationChild(active) && active.status === 'running') return true;
+  const ledger = normalizeDelegationLedger(active.delegation);
+  if (!ledger) return false;
+  return ledger.tasks.some((task) => {
+    const child = delegationTaskConversation(task, ledger);
+    if (!child) return true;
+    if (child.status === 'running') return true;
+    if (child.status === 'completed' && child.managedReviewStatus !== 'reviewed') return true;
+    return false;
+  });
+}
+
+function syncConversationRefreshPolling() {
+  const shouldPoll = needsConversationRefresh();
+  if (shouldPoll && !state.conversationRefreshHandle) {
+    state.conversationRefreshHandle = window.setInterval(() => {
+      hydrateConversationsFromServer().catch((error) =>
+        console.warn('Could not refresh delegated conversations:', error));
+    }, 1500);
+  } else if (!shouldPoll && state.conversationRefreshHandle) {
+    window.clearInterval(state.conversationRefreshHandle);
+    state.conversationRefreshHandle = null;
+  }
+}
+
 function conversationTimestamp(conv) {
   const value = conv && conv.lastUpdatedAt;
   if (typeof value === 'number' && Number.isFinite(value)) return value;
@@ -476,6 +555,7 @@ function panelStateFor(convId) {
 }
 
 function defaultCoachOpen(conv) {
+  if (isManagerOversightConversation(conv)) return false;
   return true;
 }
 
@@ -535,6 +615,7 @@ function syncQuickCoachButtons(conv) {
 function stripReviewHandoffBlocks(text) {
   return String(text || '')
     .replace(/<review_handoff>\s*[\s\S]*?\s*<\/review_handoff>/gi, '')
+    .replace(/\[Thought:\s*true\]\s*/gi, '')
     .replace(/\n{3,}/g, '\n\n')
     .trim();
 }
@@ -707,11 +788,22 @@ function renderRail() {
   // #521: in the project workspace, project-lifecycle jobs (onboarding +
   // sleep-on-learnings) have their own "Project Updates" home, so keep them out
   // of the general Runs list to avoid showing the same run twice.
-  const inWorkspace = !!document.querySelector('.workspace-conv');
+  const inWorkspace = !!document.querySelector('#proj-workspace .workspace-conv');
   const projectUpdateJobs = new Set(['project-onboarding', 'sleep-on-learnings']);
-  const list = projectConversations().filter((conv) =>
+  const allProjectConversations = projectConversations();
+  const managedChildren = allProjectConversations.filter(isManagedDelegationChild);
+  const childrenByManager = new Map();
+  for (const child of managedChildren) {
+    const parentId = child.managedByRunId;
+    if (!parentId) continue;
+    if (!childrenByManager.has(parentId)) childrenByManager.set(parentId, []);
+    childrenByManager.get(parentId).push(child);
+  }
+  const list = allProjectConversations.filter((conv) =>
     (!state.selectedPersonaKey || conv.personaKey === state.selectedPersonaKey) &&
-    !(inWorkspace && projectUpdateJobs.has(conv.jobId))
+    !isManagedDelegationChild(conv) &&
+    !(inWorkspace && projectUpdateJobs.has(conv.jobId)) &&
+    !AREA_SCOPED_JOBS.has(conv.jobId)
   );
 
   // Issue #550: Two-path routing for ad-hoc (freeform) conversations.
@@ -740,50 +832,80 @@ function renderRail() {
     groups.get(key).conversations.push(conv);
   }
 
+  function buildRunButton(conv, options = {}) {
+    const btn = document.createElement('button');
+    btn.type = 'button';
+    btn.className = (options.child ? 'conv-item conv-item--delegated-child' : 'conv-item') + (state.activeId === conv.id ? ' active' : '');
+    btn.dataset.conv = conv.id;
+    const bodyDiv = document.createElement('span');
+    bodyDiv.className = 'conv-body';
+    const titleSpan = document.createElement('span');
+    titleSpan.className = 'conv-title';
+    titleSpan.textContent = conv.title || '';
+    bodyDiv.appendChild(titleSpan);
+    btn.appendChild(bodyDiv);
+    // Issue #566 R7: mark runs of a personalized (taught/customized) job.
+    if (isTaughtJob(conv.jobId)) {
+      const taught = document.createElement('span');
+      taught.className = 'taught-badge';
+      taught.textContent = 'Personalized';
+      taught.title = 'Personalized for this project (taught or customized in your fraim/personalized-employee layer)';
+      btn.appendChild(taught);
+    }
+    const dotClass = conversationStateDotClass(conv);
+    const statusDot = document.createElement('span');
+    statusDot.className = 'state-dot conv-state-dot dot-' + dotClass;
+    statusDot.title = tfDotTitle(dotClass);
+    btn.appendChild(statusDot);
+    const statusSpan = document.createElement('span');
+    statusSpan.className = 'conv-status';
+    statusSpan.textContent = conversationStateLabel(conv);
+    statusSpan.classList.add(conversationUiState(conv));
+    btn.appendChild(statusSpan);
+    // Issue #578: sourceTrigger chip - show scheduled/webhook badge on automated runs.
+    if (conv.sourceTrigger && conv.sourceTrigger !== 'manager') {
+      const trigBadge = document.createElement('span');
+      trigBadge.className = 'trigger-badge trigger-badge--' + conv.sourceTrigger;
+      trigBadge.textContent = conv.sourceTrigger === 'scheduled' ? 'Scheduled' : 'Webhook';
+      trigBadge.title = conv.sourceTrigger === 'scheduled'
+        ? 'This run was started by the built-in cron scheduler'
+        : 'This run was triggered by an inbound webhook';
+      btn.appendChild(trigBadge);
+    }
+    if (conv.compareMode === 'ab') {
+      const badge = document.createElement('span');
+      badge.className = 'ab-badge';
+      badge.textContent = 'A/B';
+      btn.appendChild(badge);
+    }
+    if (!options.child) tfAttachRunDelete(btn, conv, { tree: false }); // #533 R6: delete a run
+    btn.addEventListener('click', () => switchToConversation(conv.id));
+    return btn;
+  }
+
   // Helper: build the run-item buttons shared by employee groups and Watercooler.
   function buildGroupList(conversations) {
     const groupList = document.createElement('div');
     groupList.className = 'conv-employee-list';
     for (const conv of conversations) {
-      const btn = document.createElement('button');
-      btn.type = 'button';
-      btn.className = 'conv-item' + (state.activeId === conv.id ? ' active' : '');
-      btn.dataset.conv = conv.id;
-      const bodyDiv = document.createElement('span');
-      bodyDiv.className = 'conv-body';
-      const titleSpan = document.createElement('span');
-      titleSpan.className = 'conv-title';
-      titleSpan.textContent = conv.title || '';
-      bodyDiv.appendChild(titleSpan);
-      btn.appendChild(bodyDiv);
-      // Issue #566 R7: mark runs of a personalized (taught/customized) job.
-      if (isTaughtJob(conv.jobId)) {
-        const taught = document.createElement('span');
-        taught.className = 'taught-badge';
-        taught.textContent = 'Personalized';
-        taught.title = 'Personalized for this project (taught or customized in your fraim/personalized-employee layer)';
-        btn.appendChild(taught);
-      }
-      const dotClass = conversationStateDotClass(conv);
-      const statusDot = document.createElement('span');
-      statusDot.className = 'state-dot conv-state-dot dot-' + dotClass;
-      statusDot.title = tfDotTitle(dotClass);
-      btn.appendChild(statusDot);
-      const statusSpan = document.createElement('span');
-      statusSpan.className = 'conv-status';
-      statusSpan.textContent = conversationStateLabel(conv);
-      statusSpan.classList.add(conversationUiState(conv));
-      btn.appendChild(statusSpan);
-      // Issue #442: A/B badge on rail entry.
-      if (conv.compareMode === 'ab') {
-        const badge = document.createElement('span');
-        badge.className = 'ab-badge';
-        badge.textContent = 'A/B';
-        btn.appendChild(badge);
-      }
-      tfAttachRunDelete(btn, conv, { tree: false }); // #533 R6: delete a run
-      btn.addEventListener('click', () => switchToConversation(conv.id));
+      const btn = buildRunButton(conv);
       groupList.appendChild(btn);
+      const children = [
+        ...(childrenByManager.get(conv.id) || []),
+        ...(conv.runId && conv.runId !== conv.id ? (childrenByManager.get(conv.runId) || []) : []),
+      ];
+      if (children.length) {
+        const delegatedList = document.createElement('div');
+        delegatedList.className = 'conv-delegated-list';
+        const label = document.createElement('div');
+        label.className = 'conv-delegated-label';
+        label.textContent = 'Mandy-managed workstreams';
+        delegatedList.appendChild(label);
+        for (const child of children) {
+          delegatedList.appendChild(buildRunButton(child, { child: true }));
+        }
+        groupList.appendChild(delegatedList);
+      }
     }
     return groupList;
   }
@@ -887,8 +1009,18 @@ function conversationUiState(conv) {
   // not stay stuck as stopped even if the stopped flag was not cleared.
   if (conv.stopped && conv.status === 'failed') return 'stopped';
   if (conv.status === 'failed') return 'waiting';
+  if (isManagedDelegationChild(conv) && conv.status === 'completed' && conv.managedReviewStatus === 'reviewed') return 'complete';
   if (conv.status === 'completed' && conv.reviewApproved) return 'complete';
-  if (conv.status === 'completed') return 'waiting';
+  if (conv.status === 'completed') {
+    // For fully-delegate runs: if child workstreams are still active, the manager
+    // is waiting for them — show 'working' not 'waiting' so the user isn't prompted
+    // to act when the Hub will auto-route child deliverables back to Mandy.
+    if (isManagerOversightConversation(conv)) {
+      const hasActiveChildren = projectConversations().some(c => c.managedByRunId === conv.runId && c.status === 'running');
+      if (hasActiveChildren) return 'working';
+    }
+    return 'waiting';
+  }
   return 'idle';
 }
 
@@ -903,6 +1035,12 @@ function conversationStateDotClass(conv) {
 }
 
 function conversationStateLabel(conv) {
+  if (isManagedDelegationChild(conv)) {
+    if (conv.status === 'running') return 'Working for Mandy';
+    if (conv.status === 'completed' && conv.managedReviewStatus === 'reviewed') return 'Reviewed by Mandy';
+    if (conv.status === 'completed') return 'Submitted to Mandy';
+    if (conv.status === 'failed') return 'Needs Mandy';
+  }
   const uiState = conversationUiState(conv);
   if (uiState === 'working') return 'Working';
   if (uiState === 'waiting') return 'Waiting on you';
@@ -912,6 +1050,17 @@ function conversationStateLabel(conv) {
   return 'Idle';
 }
 
+function isManagedDelegationChild(conv) {
+  return !!(conv && (conv.managedByRunId || conv.delegationTaskId || conv.humanCoachingDisabled));
+}
+
+function managedByPersonaLabel(conv) {
+  const key = conv && (conv.managedByPersonaKey || 'mandy');
+  if (key === 'mandy') return 'Mandy';
+  const persona = key ? personaMap().get(key) : null;
+  return persona ? persona.displayName : 'Mandy';
+}
+
 function personaMap() {
   const map = new Map();
   for (const persona of state.bootstrap?.personas || []) {
@@ -1183,7 +1332,7 @@ function showHireStrip(job, conversationId, instructions, employeeId) {
   els['hire-strip'].hidden = false;
   // Switch workspace to conv mode so the hire strip (inside .page) is visible
   // even when there is no active conversation (which normally keeps it in mode-brief).
-  const wc = document.querySelector('.workspace-conv');
+  const wc = document.querySelector('#proj-workspace .workspace-conv');
   if (wc) { wc.classList.add('mode-conv'); wc.classList.remove('mode-brief'); }
 }
 
@@ -1289,7 +1438,7 @@ let threadMessageViewportObserver = null;
 // coach, and micro-manage all have room. Toggle the mode class the CSS keys off,
 // and reflect the state in the sidebar's Brief nav entry.
 function tfApplyWorkspaceMode() {
-  const wc = document.querySelector('.workspace-conv');
+  const wc = document.querySelector('#proj-workspace .workspace-conv');
   if (!wc) return;
   const hasConv = typeof activeConversation === 'function' && !!activeConversation();
   wc.classList.toggle('mode-conv', hasConv);
@@ -1317,12 +1466,15 @@ function renderActive() {
     renderedEventCount = 0;
     renderedStatus = null;
     renderedDirectEventCount = 0;
+    syncConversationRefreshPolling();
     return;
   }
   els['empty'].hidden = true;
   els['active-conv'].hidden = false;
   els['active-conv'].dataset.runId = conv.runId || '';
   els['active-title'].textContent = conversationTitle(conv);
+  els['active-conv'].classList.toggle('has-delegation-board', !!normalizeDelegationLedger(conv.delegation));
+  els['active-conv'].classList.toggle('has-manager-oversight', isManagerOversightConversation(conv));
   renderConversationIdentity(conv);
   renderRunStatePill(conv);
   syncCoachEmployeeLabel(conv);
@@ -1348,6 +1500,7 @@ function renderActive() {
   syncThreadUiState(conv);
   syncConversationPanels(conv, switchedConv);
   syncQuickCoachButtons(conv);
+  syncManagedDelegationAccess(conv);
   ensureThreadMessageViewportObserver();
 
   // Messages — append only the rows that aren't already in the DOM, so
@@ -1431,6 +1584,7 @@ function renderActive() {
   // Issue #566 R4 — after the manager confirms success, offer to teach this as a
   // job (ad-hoc) or remember the coached steps for the job (structured).
   renderGrowthOffer(conv);
+  syncManagedDelegationAccess(conv);
   syncThreadMessageViewport();
   const m = els['messages'];
   const runningShouldStickToBottom = !!m && conv.status === 'running'
@@ -1456,6 +1610,9 @@ function renderActive() {
   // simply hide the surfaces.
   renderTracker(conv);
   renderTotals(conv);
+  renderManagerOversightBoard(conv);
+  renderDelegationLedger(conv);
+  syncConversationRefreshPolling();
   syncTemplatePickerVisibility();
   // Issue #442: Direct panel status pill, simple progress indicator, and totals.
   if (isABConv) {
@@ -1903,6 +2060,371 @@ function renderTotals(conv) {
   pushTotalsSpan(totals, costLabel, '', "cost: derived from token totals and the agent's published per-million rate");
 }
 
+function ensureDelegationHost() {
+  const active = els['active-conv'];
+  if (!active) return null;
+  let host = document.getElementById('delegation-ledger');
+  if (host) return host;
+  host = document.createElement('details');
+  host.id = 'delegation-ledger';
+  host.className = 'delegation-ledger panel-details';
+  host.addEventListener('toggle', () => {
+    const conv = activeConversation();
+    if (!conv) return;
+    panelStateFor(conv.id).delegation = host.open;
+  });
+  const status = active.querySelector('.conversation-status');
+  const oversight = document.getElementById('manager-oversight-board');
+  if (oversight && oversight.parentNode) {
+    oversight.parentNode.insertBefore(host, oversight.nextSibling);
+  } else if (status && status.parentNode) {
+    status.parentNode.insertBefore(host, status.nextSibling);
+  } else {
+    active.insertBefore(host, active.firstChild);
+  }
+  return host;
+}
+
+const MANAGER_OVERSIGHT_JOB_IDS = new Set([
+  'fully-delegate',
+  'delivery-governance-review',
+  'project-plan-creation',
+  'stakeholder-status-reporting',
+  'experiment-tracking',
+  'cross-functional-dependency-management',
+]);
+
+function isManagerOversightConversation(conv) {
+  return !!conv && (conv.personaKey === 'mandy' || MANAGER_OVERSIGHT_JOB_IDS.has(conv.jobId) || !!delegationLedgerForConversation(conv));
+}
+
+function ensureManagerOversightHost() {
+  const active = els['active-conv'];
+  if (!active) return null;
+  let host = document.getElementById('manager-oversight-board');
+  if (host) return host;
+  host = document.createElement('details');
+  host.id = 'manager-oversight-board';
+  host.className = 'manager-oversight-board panel-details';
+  host.addEventListener('toggle', () => {
+    const conv = activeConversation();
+    if (!conv) return;
+    panelStateFor(conv.id).managerOversight = host.open;
+  });
+  const status = active.querySelector('.conversation-status');
+  if (status && status.parentNode) {
+    status.parentNode.insertBefore(host, status.nextSibling);
+  } else {
+    active.insertBefore(host, active.firstChild);
+  }
+  return host;
+}
+
+function renderManagerOversightBoard(conv) {
+  const host = ensureManagerOversightHost();
+  if (!host) return;
+  if (!isManagerOversightConversation(conv)) {
+    host.hidden = true;
+    host.innerHTML = '';
+    return;
+  }
+  const ledger = delegationLedgerForConversation(conv);
+  const panelState = panelStateFor(conv.id);
+  const shouldOpen = panelState.managerOversight ?? true;
+  if (host.open !== shouldOpen) host.open = shouldOpen;
+  const childCount = ledger?.tasks?.length || 0;
+  const completedChildren = ledger?.tasks?.filter((task) => {
+    const child = delegationTaskConversation(task, ledger);
+    return child?.status === 'completed' || task.status === 'submitted' || task.status === 'reviewed' || task.status === 'completed';
+  }).length || 0;
+  const reviewedChildren = ledger?.tasks?.filter((task) => {
+    const child = delegationTaskConversation(task, ledger);
+    return child?.managedReviewStatus === 'reviewed' || task.status === 'reviewed';
+  }).length || 0;
+  const artifactCount = Array.isArray(conv.artifacts) ? conv.artifacts.length : 0;
+  const reviewReady = !!reviewHandoffForConversation(conv) || artifactCount > 0;
+  const planRows = ledger?.tasks?.map((task, index) => managerPlanRow(task, ledger, index)) || [];
+
+  host.hidden = false;
+  host.innerHTML = '';
+  const summary = document.createElement('summary');
+  const header = document.createElement('div');
+  header.className = 'manager-oversight-header';
+  const copy = document.createElement('div');
+  copy.className = 'manager-oversight-copy';
+  const kicker = document.createElement('span');
+  kicker.className = 'manager-oversight-kicker';
+  kicker.textContent = 'Execution plan';
+  const title = document.createElement('strong');
+  title.textContent = childCount
+    ? `${childCount} delegated job${childCount === 1 ? '' : 's'} with Mandy review gates`
+    : conv.status === 'running' ? 'Mandy is planning the delegation' : `${conv.jobTitle || conv.title || 'Manager job'} — no delegation emitted`;
+  copy.appendChild(kicker);
+  copy.appendChild(title);
+  const meta = document.createElement('span');
+  meta.className = 'manager-oversight-meta';
+  meta.textContent = childCount
+    ? `${completedChildren}/${childCount} submitted, ${reviewedChildren}/${childCount} reviewed`
+    : conv.status === 'running' ? 'setting up team…' : reviewReady ? `${artifactCount} artifact${artifactCount === 1 ? '' : 's'} surfaced, no delegation graph` : 'delegation graph not returned';
+  header.appendChild(copy);
+  header.appendChild(meta);
+  summary.appendChild(header);
+  host.appendChild(summary);
+
+  const list = document.createElement('div');
+  list.className = 'manager-oversight-list';
+  if (planRows.length) {
+    for (const item of planRows) {
+      const row = document.createElement('div');
+      row.className = `manager-plan-row status-${item.status}`;
+      const number = document.createElement('span');
+      number.className = 'manager-plan-step';
+      number.textContent = String(item.index + 1);
+      const body = document.createElement('div');
+      body.className = 'manager-plan-body';
+      const top = document.createElement('div');
+      top.className = 'manager-plan-top';
+      const titleEl = document.createElement('strong');
+      titleEl.textContent = item.title;
+      const status = document.createElement('span');
+      status.className = `manager-plan-status status-${item.status}`;
+      status.textContent = item.statusLabel;
+      top.appendChild(titleEl);
+      top.appendChild(status);
+      const metaLine = document.createElement('div');
+      metaLine.className = 'manager-plan-meta';
+      metaLine.textContent = `${item.employee} • ${item.dependencyText}`;
+      const review = document.createElement('div');
+      review.className = 'manager-plan-review';
+      review.textContent = item.reviewText;
+      body.appendChild(top);
+      body.appendChild(metaLine);
+      body.appendChild(review);
+      if (item.instructions) {
+        const instructions = document.createElement('div');
+        instructions.className = 'manager-plan-instructions';
+        instructions.textContent = item.instructions;
+        body.appendChild(instructions);
+      }
+      row.appendChild(number);
+      row.appendChild(body);
+      list.appendChild(row);
+    }
+  } else {
+    const empty = document.createElement('div');
+    empty.className = 'manager-plan-empty';
+    const isRunning = conv.status === 'running';
+    const titleEl = document.createElement('strong');
+    titleEl.textContent = isRunning ? 'Delegation plan incoming…' : 'No delegation sequence returned';
+    const detail = document.createElement('span');
+    detail.textContent = isRunning
+      ? 'Mandy is working through the task and will lay out the employee assignments and review gates here once the plan is ready.'
+      : reviewReady
+        ? `This run completed with ${artifactCount} surfaced artifact${artifactCount === 1 ? '' : 's'} but did not emit a delegation sequence. Start a new run to retry.`
+        : 'This run finished without returning a delegation sequence. Start a new run to retry.';
+    empty.appendChild(titleEl);
+    empty.appendChild(detail);
+    list.appendChild(empty);
+  }
+  host.appendChild(list);
+}
+
+function managerPlanRow(task, ledger, index) {
+  const child = delegationTaskConversation(task, ledger);
+  const status = delegatedTaskStatus(task, child);
+  const dependsOn = Array.isArray(task.dependsOn) ? task.dependsOn.filter(Boolean) : [];
+  const dependencyText = dependsOn.length
+    ? `starts after ${dependsOn.join(', ')}`
+    : 'can start immediately';
+  const reviewJob = task.reviewJobId ? ` via ${task.reviewJobId}` : '';
+  const reviewText = task.reviewType || task.reviewHandoff?.reviewRequired || child?.reviewHandoff?.reviewRequired
+    ? `Mandy validates this output${reviewJob} before synthesis`
+    : 'Mandy validates this output before synthesis';
+  return {
+    index,
+    title: task.title || task.jobId || task.taskId || `Delegated job ${index + 1}`,
+    employee: delegationPersonaLabel(task.personaKey),
+    dependencyText,
+    reviewText,
+    instructions: task.instructions || task.latestSummary || '',
+    status,
+    statusLabel: statusLabel(status),
+  };
+}
+
+function delegationPersonaLabel(personaKey) {
+  if (!personaKey) return 'Unassigned';
+  const persona = personaMap().get(personaKey);
+  return persona ? persona.displayName : personaKey;
+}
+
+function delegationTaskConversation(task, ledger) {
+  if (!task || !ledger) return null;
+  const conversations = projectConversations();
+  const ids = new Set([task.conversationId, task.runId].filter(Boolean));
+  const managerIds = new Set([ledger.managerRunId, ledger.rootRunId].filter(Boolean));
+  return conversations.find((conv) =>
+    ids.has(conv.id) ||
+    ids.has(conv.runId) ||
+    (conv.delegationTaskId === task.taskId && (!conv.managedByRunId || managerIds.has(conv.managedByRunId)))
+  ) || null;
+}
+
+function delegatedTaskStatus(task, childConv) {
+  if (!childConv) return task.status;
+  if (childConv.status === 'running') return 'running';
+  if (childConv.status === 'failed') return 'blocked';
+  if (childConv.status === 'completed' && childConv.managedReviewStatus === 'reviewed') return 'reviewed';
+  if (childConv.status === 'completed') return 'submitted';
+  return task.status || 'planned';
+}
+
+function delegatedTaskSummary(task, childConv) {
+  if (childConv) {
+    const latest = latestEmployeeSurfaceText(childConv);
+    if (latest) return latest;
+  }
+  return task.latestSummary || task.instructions || 'Waiting for an update.';
+}
+
+function delegatedTaskArtifacts(task, childConv) {
+  if (childConv?.reviewHandoff?.artifacts?.length) return childConv.reviewHandoff.artifacts;
+  if (childConv?.artifacts?.length) return childConv.artifacts;
+  if (task.reviewHandoff?.artifacts?.length) return task.reviewHandoff.artifacts;
+  return task.artifacts || [];
+}
+
+function renderDelegationLedger(conv) {
+  const host = ensureDelegationHost();
+  if (!host) return;
+  const ledger = delegationLedgerForConversation(conv);
+  if (!ledger) {
+    host.hidden = true;
+    host.innerHTML = '';
+    return;
+  }
+
+  host.hidden = false;
+  const panelState = panelStateFor(conv.id);
+  const shouldOpen = panelState.delegation ?? !isManagerOversightConversation(conv);
+  if (host.open !== shouldOpen) host.open = shouldOpen;
+  host.innerHTML = '';
+  const summaryRow = document.createElement('summary');
+  const header = document.createElement('div');
+  header.className = 'delegation-ledger-header';
+  const copy = document.createElement('div');
+  copy.className = 'delegation-ledger-copy';
+  const kicker = document.createElement('span');
+  kicker.className = 'delegation-ledger-kicker';
+  kicker.textContent = 'Delegation board';
+  const title = document.createElement('strong');
+  title.textContent = ledger.objective;
+  copy.appendChild(kicker);
+  copy.appendChild(title);
+  const meta = document.createElement('span');
+  meta.className = 'delegation-ledger-meta';
+  const orchestrator = delegationPersonaLabel(ledger.orchestratorPersonaKey || conv.personaKey);
+  meta.textContent = `${orchestrator} coordinating ${ledger.tasks.length} workstream${ledger.tasks.length === 1 ? '' : 's'}`;
+  header.appendChild(copy);
+  header.appendChild(meta);
+  summaryRow.appendChild(header);
+  host.appendChild(summaryRow);
+
+  const body = document.createElement('div');
+  body.className = 'delegation-ledger-body';
+
+  if (ledger.latestSummary) {
+    const summary = document.createElement('p');
+    summary.className = 'delegation-ledger-summary';
+    summary.textContent = ledger.latestSummary;
+    body.appendChild(summary);
+  }
+
+  const list = document.createElement('div');
+  list.className = 'delegation-task-list';
+  for (const task of ledger.tasks) {
+    const childConv = delegationTaskConversation(task, ledger);
+    const taskStatus = delegatedTaskStatus(task, childConv);
+    const row = document.createElement('article');
+    row.className = `delegation-task delegation-task--${taskStatus}`;
+    const top = document.createElement('div');
+    top.className = 'delegation-task-top';
+    const assignee = document.createElement('span');
+    assignee.className = 'delegation-task-assignee';
+    assignee.textContent = delegationPersonaLabel(task.personaKey);
+    const status = document.createElement('span');
+    status.className = `delegation-task-status status-${taskStatus}`;
+    status.textContent = childConv ? conversationStateLabel(childConv) : taskStatus;
+    top.appendChild(assignee);
+    top.appendChild(status);
+
+    const taskTitle = document.createElement('strong');
+    taskTitle.className = 'delegation-task-title';
+    taskTitle.textContent = task.title;
+    const detail = document.createElement('div');
+    detail.className = 'delegation-task-detail';
+    detail.textContent = [
+      childConv?.jobId || task.jobId,
+      childConv?.sessionId || task.hostSessionId ? `session ${childConv?.sessionId || task.hostSessionId}` : '',
+      task.hostThreadId ? `thread ${task.hostThreadId}` : '',
+    ].filter(Boolean).join(' · ');
+    const summary = document.createElement('p');
+    summary.className = 'delegation-task-summary';
+    summary.textContent = delegatedTaskSummary(task, childConv);
+
+    row.appendChild(top);
+    row.appendChild(taskTitle);
+    if (detail.textContent) row.appendChild(detail);
+    row.appendChild(summary);
+
+    const artifacts = delegatedTaskArtifacts(task, childConv);
+    if (artifacts.length) {
+      const artifactStrip = document.createElement('div');
+      artifactStrip.className = 'delegation-artifacts';
+      for (const artifact of artifacts) {
+        const chip = document.createElement('button');
+        chip.type = 'button';
+        chip.className = 'delegation-artifact';
+        chip.textContent = artifactLabel(artifact);
+        chip.title = artifactLocalPath(artifact) || artifactExternalUrl(artifact) || artifactLabel(artifact);
+        chip.addEventListener('click', async () => {
+          try {
+            await openReviewArtifact(artifact);
+          } catch (err) {
+            showStatus(err instanceof Error ? err.message : 'Could not open artifact.', true);
+          }
+        });
+        artifactStrip.appendChild(chip);
+      }
+      row.appendChild(artifactStrip);
+    } else if (childConv?.status === 'completed' || taskStatus === 'submitted' || taskStatus === 'reviewed') {
+      const inline = document.createElement('div');
+      inline.className = 'delegation-review-note';
+      inline.textContent = 'Inline deliverable; no file artifact reported';
+      row.appendChild(inline);
+    }
+
+    if (childConv) {
+      const view = document.createElement('button');
+      view.type = 'button';
+      view.className = 'delegation-view-work';
+      view.textContent = 'View work';
+      view.addEventListener('click', () => switchToConversation(childConv.id));
+      row.appendChild(view);
+    }
+
+    if (task.reviewHandoff?.reviewRequired || childConv?.reviewHandoff?.reviewRequired) {
+      const review = document.createElement('div');
+      review.className = 'delegation-review-note';
+      review.textContent = 'Ready for Mandy review';
+      row.appendChild(review);
+    }
+    list.appendChild(row);
+  }
+  body.appendChild(list);
+  host.appendChild(body);
+}
+
 // Issue #442: render Direct totals row using the same pushTotalsSpan helper as FRAIM.
 function renderDirectTotals(conv) {
   const dtotals = els['ab-direct-totals'];
@@ -2098,6 +2620,7 @@ function humanizeSlug(slug) {
 function stripStubReference(text) {
   return String(text || '')
     .replace(/\n?\[Job stub:[^\]]+\]/gi, '')
+    .replace(/\[Thought:\s*true\]\s*/gi, '')
     .replace(/\s+/g, ' ')
     .trim();
 }
@@ -2278,6 +2801,10 @@ function scrollThreadForReview(conv) {
 function syncSendButton() {
   const conv = activeConversation();
   const hasText = els['coach-text'].value.trim().length > 0;
+  if (isManagedDelegationChild(conv)) {
+    els['send'].disabled = true;
+    return;
+  }
   // Send is enabled as soon as the host session exists. We deliberately
   // do NOT gate on status='running' — the manager should be able to
   // coach mid-run (which is exactly what /api/ai-hub/runs/:id/messages
@@ -2291,6 +2818,9 @@ function syncSendButton() {
 }
 
 function defaultCoachNote(conv) {
+  if (isManagedDelegationChild(conv)) {
+    return `${managedByPersonaLabel(conv)} manages coaching and review for this delegated workstream. You can inspect the work, but coach the manager job instead.`;
+  }
   return conv && conv.status === 'running'
     ? 'The employee is still working. Add coaching here to tighten the next step without losing context.'
     : 'The employee is waiting on you. Send the next instruction to continue this run.';
@@ -2308,6 +2838,34 @@ function syncCoachNote(conv = activeConversation()) {
   els['coach-note'].textContent = defaultCoachNote(conv);
 }
 
+function syncManagedDelegationAccess(conv = activeConversation()) {
+  const managed = isManagedDelegationChild(conv);
+  const textarea = els['coach-text'];
+  if (textarea) {
+    textarea.disabled = managed;
+    textarea.placeholder = managed
+      ? `${managedByPersonaLabel(conv)} owns coaching for this delegated workstream`
+      : 'Tell the employee what to do next...';
+  }
+  if (els['send']) els['send'].disabled = managed || els['send'].disabled;
+  if (els['coach-panel']) els['coach-panel'].classList.toggle('coach-panel--managed-readonly', managed);
+  for (const selector of ['#quick-coach-btns button', '#mark-complete-btn', '#other-manager-jobs-btn', '#review-actions button']) {
+    for (const button of document.querySelectorAll(selector)) {
+      if (managed) {
+        if (button.dataset.managedPrevDisabled === undefined) {
+          button.dataset.managedPrevDisabled = button.disabled ? '1' : '0';
+        }
+        button.disabled = true;
+      } else if (button.dataset.managedPrevDisabled !== undefined) {
+        button.disabled = button.dataset.managedPrevDisabled === '1';
+        delete button.dataset.managedPrevDisabled;
+      }
+      button.classList.toggle('managed-disabled', managed);
+    }
+  }
+  if (managed) closeTemplatePopover();
+}
+
 function appendEditableCoachingPrompt(promptText) {
   const textarea = els['coach-text'];
   if (!textarea) return;
@@ -2366,6 +2924,11 @@ function convAwaitingReview(conv) {
   const handoff = reviewHandoffForConversation(conv);
   if (handoff) return handoff.reviewRequired === true;
   if (reviewHandoffIssueForConversation(conv)) return true;
+  // Delegation orchestration runs (fully-delegate with an active ledger) only enter review
+  // via an explicit review_handoff — Mandy's delegation artifacts are orchestration working
+  // output, not deliverables submitted to the human manager. Other manager jobs (e.g.,
+  // stakeholder-status-reporting) may legitimately surface artifacts for human review.
+  if (delegationLedgerForConversation(conv)) return false;
   if (conv.status === 'completed' && Array.isArray(conv.artifacts) && conv.artifacts.length > 0) return true;
   // #521: a plain completed turn is NOT awaiting review — the approve/reject card
   // only belongs when the employee actually submits for review (a review_handoff,
@@ -2475,6 +3038,98 @@ function extractReviewHandoffFromText(text) {
   return null;
 }
 
+const DELEGATION_TASK_STATUSES = new Set(['planned', 'running', 'submitted', 'reviewed', 'blocked', 'completed', 'failed']);
+
+function cleanString(value) {
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+function cleanNullableString(value) {
+  const cleaned = cleanString(value);
+  return cleaned ? cleaned : null;
+}
+
+function normalizeDelegationLedger(raw) {
+  if (!raw || typeof raw !== 'object' || raw.delegationRequired !== true) return null;
+  const objective = cleanString(raw.objective);
+  if (!objective) return null;
+  const tasks = Array.isArray(raw.tasks)
+    ? raw.tasks.map((task, index) => {
+        if (!task || typeof task !== 'object') return null;
+        const title = cleanString(task.title);
+        if (!title) return null;
+        const fallbackTaskId = title.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '') || `task-${index + 1}`;
+        const status = DELEGATION_TASK_STATUSES.has(cleanString(task.status)) ? cleanString(task.status) : 'planned';
+        const artifacts = Array.isArray(task.artifacts)
+          ? task.artifacts.map(normalizeReviewArtifact).filter(Boolean)
+          : [];
+        return {
+          taskId: cleanString(task.taskId) || fallbackTaskId,
+          title,
+          status,
+          personaKey: cleanNullableString(task.personaKey),
+          jobId: cleanNullableString(task.jobId),
+          instructions: cleanString(task.instructions),
+          latestSummary: cleanString(task.latestSummary),
+          hostThreadId: cleanNullableString(task.hostThreadId),
+          hostSessionId: cleanNullableString(task.hostSessionId),
+          runId: cleanNullableString(task.runId),
+          conversationId: cleanNullableString(task.conversationId),
+          dependsOn: Array.isArray(task.dependsOn) ? task.dependsOn.map(cleanString).filter(Boolean) : [],
+          artifacts,
+          reviewHandoff: normalizeReviewHandoff(task.reviewHandoff),
+        };
+      }).filter(Boolean)
+    : [];
+  if (!tasks.length) return null;
+  return {
+    delegationRequired: true,
+    objective,
+    orchestratorPersonaKey: cleanNullableString(raw.orchestratorPersonaKey),
+    rootRunId: cleanNullableString(raw.rootRunId),
+    managerRunId: cleanNullableString(raw.managerRunId),
+    latestSummary: cleanString(raw.latestSummary),
+    tasks,
+  };
+}
+
+function extractDelegationLedgerFromText(text) {
+  if (!text || !/delegationRequired|delegation_ledger|delegationLedger/i.test(text)) return null;
+  const candidates = [];
+  const fenced = String(text).matchAll(/```(?:json)?\s*([\s\S]*?)```/gi);
+  for (const match of fenced) candidates.push(match[1]);
+  const tagged = String(text).match(/<delegation_ledger>\s*([\s\S]*?)\s*<\/delegation_ledger>/i);
+  if (tagged) candidates.push(tagged[1]);
+  const inline = String(text).match(/(\{\s*"delegationRequired"[\s\S]*\})/i);
+  if (inline) candidates.push(inline[1]);
+
+  for (const candidate of candidates) {
+    try {
+      const ledger = normalizeDelegationLedger(JSON.parse(candidate.trim()));
+      if (ledger) return ledger;
+    } catch {
+      // Ignore malformed snippets; the raw transcript is still available.
+    }
+  }
+  return null;
+}
+
+function delegationLedgerForConversation(conv) {
+  if (!conv) return null;
+  const existing = normalizeDelegationLedger(conv.delegation);
+  if (existing) return existing;
+  const messages = conv.messages || [];
+  for (let i = messages.length - 1; i >= 0; i -= 1) {
+    if (messages[i].role !== 'employee') continue;
+    const parsed = extractDelegationLedgerFromText(messages[i].text);
+    if (parsed) {
+      conv.delegation = parsed;
+      return parsed;
+    }
+  }
+  return null;
+}
+
 function hasReviewHandoffSignal(text) {
   return !!(text && /reviewRequired|reviewTarget|review_handoff/i.test(text));
 }
@@ -2622,8 +3277,22 @@ function deriveDeliverableFormat(conv) {
 
   const hay = ((conv && (conv.jobId || '')) + ' ' + (conv && (conv.jobTitle || ''))).toLowerCase();
   // Prefer an explicit artifact path captured from the run when present.
-  const artifact = (conv && conv.artifacts && conv.artifacts[0]) || null;
-  const artifactName = artifact ? artifact.name : '';
+  const artifacts = Array.isArray(conv && conv.artifacts) ? conv.artifacts : [];
+  if (artifacts.length > 1) {
+    return {
+      key: 'artifact_set',
+      label: `${artifacts.length} artifacts`,
+      actions: artifacts.map((artifact, index) => ({
+        id: `open-artifact-${index}`,
+        label: artifactLabel(artifact),
+        primary: index === 0,
+        kind: artifactActionKind(artifact),
+        artifact,
+      })),
+    };
+  }
+  const artifact = artifacts[0] || null;
+  const artifactName = artifact ? (artifact.name || artifact.path || artifact.url || artifact.label || '') : '';
   const ext = artifactName.includes('.') ? artifactName.split('.').pop().toLowerCase() : '';
 
   const isCode = /implementation|fix|refactor|\bpr\b|pull-request|code|bug|engineering/.test(hay)
@@ -3059,7 +3728,7 @@ function tfShowDoneReviewing(conv, docxPath) {
   wrap.className = 'rc-done-reviewing';
   const label = document.createElement('div');
   label.className = 'rdr-label';
-  label.textContent = 'Open the .docx in Word, add your comments, then save. When ready:';
+  label.textContent = 'Open the doc in your preferred editor (Word, Google Docs, etc.), add comments, then save. When ready:';
   const btn = document.createElement('button');
   btn.type = 'button';
   btn.className = 'rdr-done-btn';
@@ -3073,15 +3742,15 @@ function tfShowDoneReviewing(conv, docxPath) {
       ? docxPath.replace((state.projectPath || '').replace(/\\/g, '/').replace(/\/$/, '') + '/', '')
       : '';
     const message = rel
-      ? `I've reviewed the document. My feedback is in the Word comments and tracked changes inside \`${rel}\`. Please read every one and address them all in a revision.`
-      : `I've finished reviewing the .docx. My feedback is in the Word comments and tracked changes — please read them all and address them in a revision.`;
+      ? `I've reviewed the document. My feedback is in the doc comments and tracked changes inside \`${rel}\`. Please read every one and address them all in a revision.`
+      : `I've finished reviewing the doc. My feedback is in the doc comments and tracked changes — please read them all and address them in a revision.`;
     conv.pendingDocxReview = docxPath || null;
     conv.reviewApproved = false;
     upsertConversation(conv);
     try {
       await continueRun(message);
       wrap.remove();
-      showStatus('Comments sent — the employee will read your Word annotations and come back with a revision.', false);
+      showStatus('Comments sent — the employee will read your doc annotations and come back with a revision.', false);
     } catch (err) {
       btn.disabled = false;
       btn.textContent = '✓ Done reviewing — send my comments to the employee';
@@ -3105,7 +3774,7 @@ function tfShowDocxUpload(conv) {
 // is exactly why "Mark complete" left the Project Onboarding dot stale.
 function refreshStatusSurfaces() {
   if (typeof renderRail === 'function') renderRail();
-  if (document.querySelector('.workspace-conv')) {
+  if (document.querySelector('#proj-workspace .workspace-conv')) {
     if (typeof tfRenderTree === 'function') tfRenderTree();
     if (typeof tfRenderProjectContextTop === 'function') tfRenderProjectContextTop();
   }
@@ -3225,8 +3894,17 @@ function wirePopovers() {
 
     if (e.key === 'Escape') {
       const cpModal = document.getElementById('cp-modal');
-      if (cpModal && !cpModal.hidden) {
+      const schedModal = document.getElementById('dep-schedule-modal');
+      const webhookModal = document.getElementById('dep-webhook-modal');
+      const aomModal = document.getElementById('area-onboard-modal');
+      if (aomModal && !aomModal.hidden) {
+        tfCloseAreaOnboardModal();
+      } else if (cpModal && !cpModal.hidden) {
         closePalette();
+      } else if (schedModal && !schedModal.hidden) {
+        schedModal.hidden = true;
+      } else if (webhookModal && !webhookModal.hidden) {
+        webhookModal.hidden = true;
       } else if (els['modal'].classList.contains('open')) {
         closeModal();
       } else {
@@ -4175,6 +4853,9 @@ function foldRunIntoConversation(conv, run) {
   const runHandoff = normalizeReviewHandoff(run.reviewHandoff);
   if (runHandoff) conv.reviewHandoff = runHandoff;
   else reviewHandoffForConversation(conv);
+  const runDelegation = normalizeDelegationLedger(run.delegation);
+  if (runDelegation) conv.delegation = runDelegation;
+  else delegationLedgerForConversation(conv);
   if (Array.isArray(run.artifacts)) {
     conv.artifacts = run.artifacts;
   }
@@ -4186,9 +4867,10 @@ function foldRunIntoConversation(conv, run) {
   // The browser only parses output text when that structured field is absent.
   if (!Array.isArray(run.artifacts)) {
     for (const e of conv.events) {
-      const found = extractArtifact(e.text);
-      if (found && !conv.artifacts.some((a) => a.name === found.name && a.where === found.where)) {
-        conv.artifacts.push(found);
+      for (const found of extractArtifacts(e.text)) {
+        if (!conv.artifacts.some((a) => a.name === found.name && a.where === found.where)) {
+          conv.artifacts.push(found);
+        }
       }
     }
   }
@@ -4210,27 +4892,40 @@ function foldCompareRunIntoConversation(conv, compareRun) {
   };
 }
 
-const ARTIFACT_PATH_RE = /([A-Za-z0-9_\-\.\/]*?(?:docs|public|src|tests)\/[A-Za-z0-9_\-\.\/]+\.[A-Za-z0-9]+)/;
 // Paths under these directories are FRAIM lifecycle bookkeeping (RCAs,
 // raw learnings, evidence dumps, mock files), not deliverables the
 // manager should be drawn to. Excluding them keeps the artifact callout
 // meaningful — it should mean "the employee produced this file for you".
 const ARTIFACT_EXCLUDE_RE = /(^|\/)(retrospectives|evidence|learnings|mocks|raw|archive)\//i;
 function extractArtifact(text) {
-  if (!text) return null;
-  const match = text.match(ARTIFACT_PATH_RE);
-  if (!match) return null;
-  const fullPath = match[1];
-  if (ARTIFACT_EXCLUDE_RE.test(fullPath)) return null;
-  const segments = fullPath.split('/');
-  const name = segments[segments.length - 1];
-  const where = segments.slice(0, -1).join('/') + '/';
-  // Store the absolute path so the agent can re-read the artifact (and any
-  // .docx export written alongside it) without guessing the project root.
-  const absPath = state.projectPath
-    ? state.projectPath.replace(/\\/g, '/').replace(/\/$/, '') + '/' + fullPath
-    : null;
-  return { name, where, path: absPath };
+  return extractArtifacts(text)[0] || null;
+}
+
+function extractArtifacts(text) {
+  if (!text) return [];
+  const artifacts = [];
+  const seen = new Set();
+  const matches = String(text)
+    .split(/[\s`"'()<>{}\[\],;:]+/)
+    .filter((token) => /^(docs|public|src|tests)\//.test(token));
+  for (const candidate of matches) {
+    const fullPath = candidate.replace(/[.)]+$/g, '');
+    if (!/\.[A-Za-z0-9]+$/.test(fullPath)) continue;
+    if (ARTIFACT_EXCLUDE_RE.test(fullPath)) continue;
+    const segments = fullPath.split('/');
+    const name = segments[segments.length - 1];
+    const where = segments.slice(0, -1).join('/') + '/';
+    // Store the absolute path so the agent can re-read the artifact (and any
+    // .docx export written alongside it) without guessing the project root.
+    const absPath = state.projectPath
+      ? state.projectPath.replace(/\\/g, '/').replace(/\/$/, '') + '/' + fullPath
+      : null;
+    const key = absPath || fullPath;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    artifacts.push({ name, where, path: absPath });
+  }
+  return artifacts;
 }
 
 function startPolling() {
@@ -4248,7 +4943,18 @@ function startPolling() {
     }
     try {
       if (!fraimDone) {
-        const run = await requestJson(`/api/ai-hub/runs/${conv.runId}`);
+        const runResp = await fetch(`/api/ai-hub/runs/${conv.runId}`, { headers: { 'x-api-key': 'local-dev' } });
+        if (runResp.status === 404) {
+          // Run no longer in server registry (e.g. after restart). Stop polling.
+          window.clearInterval(state.pollHandle);
+          state.pollHandle = null;
+          conv.status = 'done';
+          upsertConversation(conv);
+          renderRail();
+          renderActive();
+          return;
+        }
+        const run = await runResp.json();
         foldRunIntoConversation(conv, run);
       }
       // Issue #442: also poll the compare run when present and not yet terminal.
@@ -4259,6 +4965,9 @@ function startPolling() {
       upsertConversation(conv);
       renderRail();
       renderActive();
+      // #594 R2: keep the Company/Manager area conv panel in sync while polling.
+      if (tf.area === 'company') tfRenderCompany();
+      else if (tf.area === 'manager') tfRenderManager();
       // #521: when a project-onboarding run posts its understanding (reaches the
       // review gate) or completes, refresh the Brief once so the team's captured
       // context appears there for the manager to review/edit and then approve.
@@ -4311,7 +5020,7 @@ async function tryWordWriteBack(conv) {
     const action = conv.wordStartedWithSelection ? 'insert-after' : 'append-to-doc';
     await requestWordContext(action, { text: outputText });
     await requestWordContext('track-changes-off');
-    showStatus('Result written to document — review tracked changes in Word.');
+    showStatus('Result written to document — review tracked changes.');
   } catch (e) {
     console.warn('Word write-back failed:', e);
   }
@@ -4327,6 +5036,15 @@ function convNeedsPolling(conv) {
 function switchToConversation(id) {
   state.activeId = id;
   persistConversations();
+  // For Company/Manager: move the shared .page into this area's conv-host and
+  // switch from the info view to the full coaching panel.
+  if (tf.area === 'company' || tf.area === 'manager') {
+    tfEnsurePageInArea(tf.area);
+    const host = document.getElementById(tf.area + '-conv-host');
+    const info = document.getElementById(tf.area + '-info-view');
+    if (host) host.hidden = false;
+    if (info) info.hidden = true;
+  }
   renderRail();
   renderActive();
   const conv = activeConversation();
@@ -4467,9 +5185,22 @@ function renderManagerTeamPool() {
   const personas = (state.bootstrap?.personas || []).filter((p) => (p.seatCount || 0) > 0);
   const managerTeamKeys = new Set((state.bootstrap?.managerTeam || []).map((e) => e.personaKey));
   container.innerHTML = '';
+  if (personas.length === 0) {
+    const msg = document.createElement('p');
+    msg.className = 'manager-no-team-msg';
+    msg.textContent = "You haven't hired any specialists yet. Go to Company to see the full roster and hire the team you need.";
+    container.appendChild(msg);
+    const btn = document.createElement('button');
+    btn.className = 'manager-go-company-btn';
+    btn.type = 'button';
+    btn.textContent = 'Go to Company to hire';
+    btn.addEventListener('click', () => tfShowArea('company'));
+    container.appendChild(btn);
+    return;
+  }
   for (const persona of personas) {
     const row = document.createElement('div');
-    row.className = 'team-row';
+    row.className = 'team-row emp-tile';
 
     const dot = document.createElement('span');
     const oos = (persona.seatsInUse || 0) >= (persona.seatCount || 0);
@@ -4922,6 +5653,7 @@ function wireEvents() {
   try {
     await loadBootstrap(null, docUrl);
     await hydrateConversationsFromServer();
+    startBgConvPoll();
   } catch (error) {
     showStatus(error.message, true);
     return;
@@ -5202,7 +5934,6 @@ function renderFirstRunLanding(mode) {
 
 const STORAGE_KEY_PROJECTS_512 = 'fraim.aiHub.projects.v1';
 const STORAGE_KEY_ASSIGNMENTS_512 = 'fraim.aiHub.assignments.v1';
-const STORAGE_KEY_RAIL_512 = 'fraim.aiHub.railCollapsed.v1';
 
 const tf = {
   enabled: false,
@@ -5215,8 +5946,6 @@ const tf = {
   npSelectedEmployees: [],
 };
 
-const TF_STEP_LABELS = { install: 'Install', company: 'Set up company', hire: 'Hire your team', project: 'Start a project' };
-const TF_STEP_ORDER = ['install', 'company', 'hire', 'project'];
 const TF_AVATAR_COLORS = ['#4a7fd4', '#7c6f61', '#5a9e6e', '#b06a4f', '#6b4c92', '#b07a2e', '#2e8b78', '#a24747'];
 function tfAvatarFor(key, index) {
   const color = TF_AVATAR_COLORS[(index || 0) % TF_AVATAR_COLORS.length];
@@ -5299,7 +6028,25 @@ function tfEmployeeDot(projectId, employeeKey) {
 // Area + sub-tab routing
 // ---------------------------------------------------------------------------
 function tfShowArea(area) {
+  if (!state.areaActiveId) state.areaActiveId = {};
+  // Save Projects' active conv when leaving it, so we can restore on return.
+  if (tf.area === 'projects') state.areaActiveId.projects = state.activeId;
+
   tf.area = area;
+
+  if (area === 'projects') {
+    // Restore the saved Projects conv; discard it if it turned out to be area-scoped.
+    const savedId = state.areaActiveId.projects || null;
+    const savedConv = savedId && Object.values(state.conversations || {}).flat().find((c) => c.id === savedId);
+    state.activeId = (savedConv && !AREA_SCOPED_JOBS.has(savedConv.jobId)) ? savedId : null;
+    // Return the shared .page to the Projects workspace and reset Company/Manager hosts.
+    tfEnsurePageInArea('projects');
+    for (const el of document.querySelectorAll('.area-conv-host')) el.hidden = true;
+    for (const el of document.querySelectorAll('.area-info-view')) el.hidden = false;
+    if (typeof renderRail === 'function') renderRail();
+    if (typeof renderActive === 'function') renderActive();
+  }
+
   for (const el of document.querySelectorAll('.hub-area')) {
     const match = el.id === 'area-' + area;
     el.classList.toggle('on', match);
@@ -5354,6 +6101,8 @@ function tfSelectProjectView(view, projectId) {
     tfRenderTree();
     tfRenderProjectContextTop();
     tfApplyWorkspaceMode();
+    // Issue #578: reload deployment roster when entering workspace.
+    loadDeployments();
   }
 }
 
@@ -5835,6 +6584,393 @@ function tfShowProjectBrief() { const a = document.getElementById('proj-brief-ac
 function tfShowProjectLearnings() { const a = document.getElementById('proj-learnings-acc'); if (a) a.open = true; }
 function tfHideProjectLearnings() { /* panels removed in #521; brief/learnings are inline top sections */ }
 
+// ---------------------------------------------------------------------------
+// Issue #578: Deployment roster (scheduled + webhook triggers)
+// ---------------------------------------------------------------------------
+
+async function loadDeployments() {
+  const list = document.getElementById('proj-deployments-list');
+  if (!list) return;
+  try {
+    const [schResp, whResp] = await Promise.all([
+      fetch('/api/ai-hub/schedules'),
+      fetch('/api/ai-hub/webhooks'),
+    ]);
+    const schedules = schResp.ok ? await schResp.json() : [];
+    const webhooks = whResp.ok ? await whResp.json() : [];
+    renderDeploymentList(list, [...schedules, ...webhooks]);
+  } catch {
+    list.textContent = 'Could not load deployments.';
+  }
+}
+
+let _editingDepId = null;
+let _activeSchPreset = null;
+
+function detectPreset(expr) {
+  if (!expr) return null;
+  const parts = expr.trim().split(/\s+/);
+  if (parts.length !== 5) return 'custom';
+  const [min, hour, dom, month, dow] = parts;
+  if (dom !== '*' || month !== '*') return 'custom';
+  if (/^\d+$/.test(min) && /^\d+$/.test(hour)) {
+    if (dow === '*') return 'daily';
+    if (dow === '1-5') return 'weekdays';
+    if (/^\d+$/.test(dow)) return 'weekly';
+  }
+  return 'custom';
+}
+
+function updateSchCronFromPreset(preset, timeValue, dayValue) {
+  const [hStr, mStr] = (timeValue || '09:00').split(':');
+  const h = parseInt(hStr, 10) || 9;
+  const m = parseInt(mStr, 10) || 0;
+  if (preset === 'daily') return `${m} ${h} * * *`;
+  if (preset === 'weekdays') return `${m} ${h} * * 1-5`;
+  if (preset === 'weekly') return `${m} ${h} * * ${dayValue || 1}`;
+  return '';
+}
+
+function applySchPreset(preset) {
+  _activeSchPreset = preset;
+  document.querySelectorAll('#dep-sch-presets .dep-preset-chip').forEach(c => {
+    c.classList.toggle('active', c.dataset.preset === preset);
+  });
+  const timeRow = document.getElementById('dep-sch-time-row');
+  const dayField = document.getElementById('dep-sch-day-field');
+  const customRow = document.getElementById('dep-sch-custom-row');
+  const timeInput = document.getElementById('dep-sch-time');
+  const dayInput = document.getElementById('dep-sch-day');
+  const cronPresetInput = document.getElementById('dep-sch-cron-preset');
+  const preview = document.getElementById('dep-sch-cron-preview');
+  const isCustom = preset === 'custom';
+  const hasTime = preset !== null && !isCustom;
+  if (timeRow) timeRow.hidden = !hasTime;
+  if (dayField) dayField.hidden = preset !== 'weekly';
+  if (customRow) customRow.hidden = !isCustom;
+  if (hasTime && cronPresetInput && timeInput) {
+    const cron = updateSchCronFromPreset(preset, timeInput.value, dayInput ? dayInput.value : '1');
+    cronPresetInput.value = cron;
+    if (preview) preview.textContent = cronToHuman(cron);
+  }
+}
+
+function cronToHuman(expr) {
+  if (!expr) return '';
+  const parts = expr.trim().split(/\s+/);
+  if (parts.length < 5) return expr;
+  const [min, hour, dom, month, dow] = parts;
+  if (min.startsWith('*/') && hour === '*' && dom === '*' && month === '*' && dow === '*') {
+    const n = parseInt(min.slice(2), 10);
+    return 'Every ' + n + ' minute' + (n === 1 ? '' : 's');
+  }
+  if (!min.includes('/') && !min.includes(',') && hour === '*' && dom === '*' && month === '*' && dow === '*') {
+    return 'Every hour at :' + min.padStart(2, '0');
+  }
+  const minuteN = parseInt(min, 10);
+  const hourN = parseInt(hour, 10);
+  const hasSpecificTime = !isNaN(minuteN) && !isNaN(hourN) && !min.includes('/') && !min.includes(',') && !hour.includes('/') && !hour.includes(',');
+  if (!hasSpecificTime) return expr;
+  const ampm = hourN >= 12 ? 'PM' : 'AM';
+  const h12 = hourN % 12 === 0 ? 12 : hourN % 12;
+  const timeStr = h12 + ':' + String(minuteN).padStart(2, '0') + ' ' + ampm;
+  const dayNames = ['Sundays', 'Mondays', 'Tuesdays', 'Wednesdays', 'Thursdays', 'Fridays', 'Saturdays'];
+  if (dom === '*' && month === '*') {
+    if (dow === '*') return 'Daily at ' + timeStr;
+    if (dow === '1-5' || dow === 'MON-FRI' || dow === 'mon-fri') return 'Weekdays at ' + timeStr;
+    if (dow === '0,6' || dow === '6,0' || dow === 'SAT,SUN' || dow === 'SUN,SAT') return 'Weekends at ' + timeStr;
+    const dowN = parseInt(dow, 10);
+    if (!isNaN(dowN) && dowN >= 0 && dowN <= 6) return dayNames[dowN] + ' at ' + timeStr;
+    return 'On ' + dow + ' at ' + timeStr;
+  }
+  return expr;
+}
+
+function renderDeploymentList(container, deployments) {
+  container.innerHTML = '';
+  if (!deployments.length) {
+    const empty = document.createElement('p');
+    empty.className = 'dep-empty';
+    empty.textContent = 'No assignments yet. Use + Schedule or + Trigger above to set up scheduled and triggered assignments.';
+    container.appendChild(empty);
+    return;
+  }
+  for (const dep of deployments) {
+    const card = document.createElement('div');
+    card.className = 'dep-card';
+    const top = document.createElement('div');
+    top.className = 'dep-card-top';
+    const icon = document.createElement('span');
+    icon.className = 'dep-type-icon';
+    icon.textContent = dep.type === 'scheduled' ? '⏱' : '🔗';
+    const label = document.createElement('span');
+    label.className = 'dep-label';
+    label.textContent = dep.label;
+    const typeBadge = document.createElement('span');
+    typeBadge.className = 'dep-type-badge dep-type-badge--' + dep.type;
+    typeBadge.textContent = dep.type === 'scheduled' ? 'Scheduled' : 'Triggered';
+    top.appendChild(icon);
+    top.appendChild(label);
+    top.appendChild(typeBadge);
+    card.appendChild(top);
+
+    if (dep.cronExpr) {
+      const cron = document.createElement('div');
+      cron.className = 'dep-detail';
+      const human = cronToHuman(dep.cronExpr);
+      cron.textContent = human !== dep.cronExpr ? human : dep.cronExpr;
+      if (human !== dep.cronExpr) cron.title = dep.cronExpr;
+      card.appendChild(cron);
+    }
+
+    const employee = (state.bootstrap?.employees || []).find((e) => e.id === dep.hostId);
+    if (employee) {
+      const empRow = document.createElement('div');
+      empRow.className = 'dep-detail dep-detail--emp';
+      empRow.textContent = employee.label;
+      card.appendChild(empRow);
+    }
+
+    if (dep.inboundUrl) {
+      const urlRow = document.createElement('div');
+      urlRow.className = 'dep-detail dep-detail--url';
+      const urlCode = document.createElement('code');
+      urlCode.textContent = dep.inboundUrl;
+      urlCode.className = 'dep-inbound-url dep-inbound-url--inline';
+      const copyBtn = document.createElement('button');
+      copyBtn.type = 'button';
+      copyBtn.className = 'hm-copy-btn';
+      copyBtn.textContent = 'Copy';
+      copyBtn.addEventListener('click', () => { navigator.clipboard.writeText(dep.inboundUrl).then(() => { copyBtn.textContent = 'Copied!'; setTimeout(() => { copyBtn.textContent = 'Copy'; }, 1500); }).catch(() => {}); });
+      urlRow.appendChild(urlCode);
+      urlRow.appendChild(copyBtn);
+      card.appendChild(urlRow);
+    }
+
+    const cardActions = document.createElement('div');
+    cardActions.className = 'dep-card-actions';
+
+    const editBtn = document.createElement('button');
+    editBtn.type = 'button';
+    editBtn.className = 'dep-edit-btn';
+    editBtn.title = 'Edit this assignment';
+    editBtn.textContent = 'Edit';
+    editBtn.addEventListener('click', () => { openDeploymentModal(dep.type === 'scheduled' ? 'schedule' : 'webhook', dep); });
+    cardActions.appendChild(editBtn);
+
+    const delBtn = document.createElement('button');
+    delBtn.type = 'button';
+    delBtn.className = 'dep-del-btn';
+    delBtn.title = 'Remove this assignment';
+    delBtn.textContent = 'Remove';
+    delBtn.addEventListener('click', async () => {
+      const endpoint = dep.type === 'scheduled' ? 'schedules' : 'webhooks';
+      await fetch('/api/ai-hub/' + endpoint + '/' + dep.id, { method: 'DELETE' });
+      await loadDeployments();
+    });
+    cardActions.appendChild(delBtn);
+    card.appendChild(cardActions);
+    container.appendChild(card);
+  }
+}
+
+function initDeploymentButtons() {
+  const addSchBtn = document.getElementById('dep-add-schedule-btn');
+  const addWhBtn = document.getElementById('dep-add-webhook-btn');
+  if (addSchBtn) addSchBtn.addEventListener('click', () => openDeploymentModal('schedule'));
+  if (addWhBtn) addWhBtn.addEventListener('click', () => openDeploymentModal('webhook'));
+
+  // Close buttons
+  const schClose = document.getElementById('dep-schedule-close');
+  const whClose = document.getElementById('dep-webhook-close');
+  if (schClose) schClose.addEventListener('click', () => { document.getElementById('dep-schedule-modal').hidden = true; });
+  if (whClose) whClose.addEventListener('click', () => { document.getElementById('dep-webhook-modal').hidden = true; });
+
+  // Cancel buttons
+  const schCancel = document.getElementById('dep-sch-cancel-btn');
+  const whCancel = document.getElementById('dep-wh-cancel-btn');
+  if (schCancel) schCancel.addEventListener('click', () => { document.getElementById('dep-schedule-modal').hidden = true; });
+  if (whCancel) whCancel.addEventListener('click', () => { document.getElementById('dep-webhook-modal').hidden = true; });
+
+  // Save buttons
+  const schSave = document.getElementById('dep-sch-save-btn');
+  if (schSave) schSave.addEventListener('click', saveScheduleDeployment);
+  const whSave = document.getElementById('dep-wh-save-btn');
+  if (whSave) whSave.addEventListener('click', saveWebhookDeployment);
+
+  // Preset chips
+  document.querySelectorAll('#dep-sch-presets .dep-preset-chip').forEach(chip => {
+    chip.addEventListener('click', () => applySchPreset(chip.dataset.preset));
+  });
+  const schTimeInput = document.getElementById('dep-sch-time');
+  const schDayInput = document.getElementById('dep-sch-day');
+  const cronPresetInput = document.getElementById('dep-sch-cron-preset');
+  if (schTimeInput) {
+    schTimeInput.addEventListener('change', () => {
+      if (_activeSchPreset && _activeSchPreset !== 'custom') {
+        const cron = updateSchCronFromPreset(_activeSchPreset, schTimeInput.value, schDayInput ? schDayInput.value : '1');
+        if (cronPresetInput) cronPresetInput.value = cron;
+        const prev = document.getElementById('dep-sch-cron-preview');
+        if (prev) prev.textContent = cronToHuman(cron);
+      }
+    });
+  }
+  if (schDayInput) {
+    schDayInput.addEventListener('change', () => {
+      if (_activeSchPreset === 'weekly') {
+        const cron = updateSchCronFromPreset('weekly', schTimeInput ? schTimeInput.value : '09:00', schDayInput.value);
+        if (cronPresetInput) cronPresetInput.value = cron;
+        const prev = document.getElementById('dep-sch-cron-preview');
+        if (prev) prev.textContent = cronToHuman(cron);
+      }
+    });
+  }
+
+  // Live cron preview (custom mode)
+  const cronInput = document.getElementById('dep-sch-cron');
+  const cronPreview = document.getElementById('dep-sch-cron-preview');
+  if (cronInput && cronPreview) {
+    cronInput.addEventListener('input', () => {
+      const human = cronToHuman(cronInput.value.trim());
+      cronPreview.textContent = human && human !== cronInput.value.trim() ? human : '';
+    });
+  }
+
+  // Copy inbound URL button
+  const copyBtn = document.getElementById('dep-wh-copy-btn');
+  if (copyBtn) copyBtn.addEventListener('click', () => {
+    const url = document.getElementById('dep-wh-inbound-url').textContent;
+    navigator.clipboard.writeText(url).catch(() => {});
+  });
+}
+
+function openDeploymentModal(type, dep) {
+  const jobs = state.bootstrap?.jobs ?? [];
+  const employees = state.bootstrap?.employees ?? [];
+  const editing = dep != null;
+  _editingDepId = editing ? dep.id : null;
+
+  function populateJobs(sel, currentJobId) {
+    sel.innerHTML = '';
+    for (const j of jobs) {
+      const opt = document.createElement('option');
+      opt.value = j.id;
+      opt.textContent = j.title;
+      sel.appendChild(opt);
+    }
+    if (currentJobId) sel.value = currentJobId;
+  }
+
+  function populateEmployees(sel, currentHostId) {
+    sel.innerHTML = '';
+    const fallback = [{ id: 'claude', label: 'Claude' }, { id: 'codex', label: 'Codex' }, { id: 'gemini', label: 'Gemini' }, { id: 'copilot', label: 'Copilot' }];
+    const list = employees.length ? employees : fallback;
+    for (const e of list) {
+      const opt = document.createElement('option');
+      opt.value = e.id;
+      opt.textContent = e.label;
+      sel.appendChild(opt);
+    }
+    if (currentHostId) sel.value = currentHostId;
+  }
+
+  if (type === 'schedule') {
+    const modal = document.getElementById('dep-schedule-modal');
+    document.getElementById('dep-sch-modal-title').textContent = editing ? 'Edit Scheduled Assignment' : 'New Scheduled Assignment';
+    document.getElementById('dep-sch-save-btn').textContent = editing ? 'Save changes' : 'Add assignment';
+    populateJobs(document.getElementById('dep-sch-job'), dep?.jobId);
+    populateEmployees(document.getElementById('dep-sch-host'), dep?.hostId || 'claude');
+    document.getElementById('dep-sch-error').hidden = true;
+    document.getElementById('dep-sch-label').value = dep?.label ?? '';
+    document.getElementById('dep-sch-instructions').value = dep?.instructions ?? '';
+    // Detect preset and pre-fill time/day
+    const preset = dep?.cronExpr ? detectPreset(dep.cronExpr) : null;
+    if (preset && preset !== 'custom' && dep?.cronExpr) {
+      const parts = dep.cronExpr.trim().split(/\s+/);
+      const m = parseInt(parts[0], 10) || 0;
+      const h = parseInt(parts[1], 10) || 9;
+      document.getElementById('dep-sch-time').value = String(h).padStart(2, '0') + ':' + String(m).padStart(2, '0');
+      if (preset === 'weekly') document.getElementById('dep-sch-day').value = parts[4];
+      document.getElementById('dep-sch-cron-preset').value = dep.cronExpr;
+    } else if (preset === 'custom' && dep?.cronExpr) {
+      document.getElementById('dep-sch-cron').value = dep.cronExpr;
+      const cronPreview = document.getElementById('dep-sch-cron-preview');
+      if (cronPreview) cronPreview.textContent = cronToHuman(dep.cronExpr);
+    } else {
+      document.getElementById('dep-sch-cron').value = '';
+      document.getElementById('dep-sch-time').value = '09:00';
+    }
+    applySchPreset(preset || 'daily');
+    modal.hidden = false;
+  } else {
+    const modal = document.getElementById('dep-webhook-modal');
+    document.getElementById('dep-wh-modal-title').textContent = editing ? 'Edit Triggered Assignment' : 'New Triggered Assignment';
+    document.getElementById('dep-wh-save-btn').textContent = editing ? 'Save changes' : 'Add assignment';
+    populateJobs(document.getElementById('dep-wh-job'), dep?.jobId);
+    populateEmployees(document.getElementById('dep-wh-host'), dep?.hostId || 'claude');
+    document.getElementById('dep-wh-error').hidden = true;
+    document.getElementById('dep-wh-inbound-row').hidden = true;
+    document.getElementById('dep-wh-label').value = dep?.label ?? '';
+    document.getElementById('dep-wh-instructions').value = dep?.instructions ?? '';
+    modal.hidden = false;
+  }
+}
+
+async function saveScheduleDeployment() {
+  const label = document.getElementById('dep-sch-label').value.trim();
+  const jobId = document.getElementById('dep-sch-job').value;
+  const hostId = document.getElementById('dep-sch-host').value;
+  const isCustom = _activeSchPreset === 'custom';
+  const cronExpr = isCustom
+    ? document.getElementById('dep-sch-cron').value.trim()
+    : (document.getElementById('dep-sch-cron-preset').value.trim() || '');
+  const instructions = document.getElementById('dep-sch-instructions').value.trim();
+  const errEl = document.getElementById('dep-sch-error');
+  if (!label || !cronExpr) { errEl.textContent = 'Label and schedule are required.'; errEl.hidden = false; return; }
+  const isEdit = _editingDepId !== null;
+  const url = isEdit ? '/api/ai-hub/schedules/' + _editingDepId : '/api/ai-hub/schedules';
+  const method = isEdit ? 'PUT' : 'POST';
+  try {
+    const resp = await fetch(url, {
+      method,
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ label, jobId, hostId, cronExpr, instructions: instructions || undefined }),
+    });
+    if (!resp.ok) { const e = await resp.json().catch(() => ({})); errEl.textContent = e.error || (isEdit ? 'Failed to update assignment.' : 'Failed to create assignment.'); errEl.hidden = false; return; }
+    _editingDepId = null;
+    document.getElementById('dep-schedule-modal').hidden = true;
+    await loadDeployments();
+  } catch { errEl.textContent = 'Network error — is the Hub running?'; errEl.hidden = false; }
+}
+
+async function saveWebhookDeployment() {
+  const label = document.getElementById('dep-wh-label').value.trim();
+  const jobId = document.getElementById('dep-wh-job').value;
+  const hostId = document.getElementById('dep-wh-host').value;
+  const instructions = document.getElementById('dep-wh-instructions').value.trim();
+  const errEl = document.getElementById('dep-wh-error');
+  if (!label) { errEl.textContent = 'Label is required.'; errEl.hidden = false; return; }
+  const isEdit = _editingDepId !== null;
+  const url = isEdit ? '/api/ai-hub/webhooks/' + _editingDepId : '/api/ai-hub/webhooks';
+  const method = isEdit ? 'PUT' : 'POST';
+  try {
+    const resp = await fetch(url, {
+      method,
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ label, jobId, hostId, instructions: instructions || undefined }),
+    });
+    if (!resp.ok) { const e = await resp.json().catch(() => ({})); errEl.textContent = e.error || (isEdit ? 'Failed to update assignment.' : 'Failed to create assignment.'); errEl.hidden = false; return; }
+    if (!isEdit) {
+      const dep = await resp.json();
+      document.getElementById('dep-wh-inbound-url').textContent = dep.inboundUrl;
+      document.getElementById('dep-wh-inbound-row').hidden = false;
+    }
+    _editingDepId = null;
+    if (isEdit) document.getElementById('dep-webhook-modal').hidden = true;
+    await loadDeployments();
+  } catch { errEl.textContent = 'Network error — is the Hub running?'; errEl.hidden = false; }
+}
+
 // ---------------------------------------------------------------------------
 // Company / Manager / Brain content
 // ---------------------------------------------------------------------------
@@ -5903,6 +7039,54 @@ async function tfSaveContext(key, content) {
   return data;
 }
 
+// #594 R3/R4: GitHub push helpers.
+function tfIsGithubConfigured() {
+  return !!(state.bootstrap && state.bootstrap.repository && state.bootstrap.repository.provider === 'github');
+}
+
+// #594 R4: Render a dismissable inline push bar into `container` when GitHub is
+// configured. Called after a successful inline context save so the manager can
+// push the change to the team repo with one click.
+function tfMaybeShowPushPrompt(key, container) {
+  if (!tfIsGithubConfigured()) return;
+  const existing = container && container.querySelector('.ctx-push-bar');
+  if (existing) existing.remove();
+  const bar = document.createElement('div');
+  bar.className = 'ctx-push-bar';
+  const msg = document.createElement('span');
+  msg.className = 'ctx-push-msg';
+  msg.textContent = 'Change saved locally. Push to share with your team?';
+  const btn = document.createElement('button');
+  btn.className = 'ctx-push-btn';
+  btn.type = 'button';
+  btn.textContent = 'Push to team';
+  btn.addEventListener('click', async () => {
+    btn.disabled = true;
+    btn.textContent = 'Pushing...';
+    try {
+      await requestJson('/api/ai-hub/context/push', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ key }) });
+      bar.remove();
+    } catch {
+      btn.disabled = false;
+      btn.textContent = 'Push to team';
+    }
+  });
+  const dismiss = document.createElement('button');
+  dismiss.className = 'ctx-push-dismiss';
+  dismiss.type = 'button';
+  dismiss.textContent = 'Skip';
+  dismiss.addEventListener('click', () => bar.remove());
+  const autoDismiss = document.createElement('span');
+  autoDismiss.className = 'ctx-push-auto';
+  autoDismiss.textContent = 'Auto-dismisses in 30s';
+  bar.appendChild(msg);
+  bar.appendChild(btn);
+  bar.appendChild(dismiss);
+  bar.appendChild(autoDismiss);
+  if (container) container.appendChild(bar);
+  setTimeout(() => { if (bar.isConnected) bar.remove(); }, 30000);
+}
+
 function tfContextKind(key) {
   return (key === 'orgRules' || key === 'managerRules' || key === 'projectRules') ? 'rules' : 'context';
 }
@@ -6278,6 +7462,7 @@ function tfContextRow(key, label, placeholder, rerender) {
         await tfSaveContext(key, tfContextContentForSave(key, label, readValue()));
         renderView();
         if (typeof rerender === 'function') rerender();
+        tfMaybeShowPushPrompt(key, row);
       } catch (e) {
         save.disabled = false;
         save.textContent = 'Save';
@@ -6425,6 +7610,125 @@ function tfProjectUpdatesSection() {
   return details;
 }
 
+// #594 R2: render a conversation panel (topline + messages + coach input) into an
+// area-level container so org/manager jobs are viewable inside Company/Manager tabs.
+function tfRenderAreaConvPanel(el, conv) {
+  const prevTaVal = (el.querySelector('.area-conv-coach-ta') || {}).value || '';
+  el.innerHTML = '';
+  const topline = document.createElement('div');
+  topline.className = 'conv-topline area-conv-topline';
+  const titleEl = document.createElement('span');
+  titleEl.className = 'conv-job-title';
+  titleEl.textContent = conv.title || conv.jobTitle || '';
+  const dotCls = conversationStateDotClass(conv);
+  const pill = document.createElement('span');
+  pill.className = 'run-state-pill ' + dotCls;
+  pill.textContent = conversationStateLabel(conv);
+  topline.appendChild(titleEl);
+  topline.appendChild(pill);
+  el.appendChild(topline);
+  const thread = document.createElement('div');
+  thread.className = 'area-conv-thread';
+  const msgs = (conv.messages || []).filter((m) => m.role !== 'system');
+  if (msgs.length === 0) {
+    const empty = document.createElement('p');
+    empty.className = 'area-conv-empty';
+    empty.textContent = conv.status === 'running' ? 'Working…' : 'No messages yet.';
+    thread.appendChild(empty);
+  } else {
+    for (const msg of msgs) {
+      const row = document.createElement('div');
+      row.className = 'area-conv-msg area-conv-msg--' + (msg.role || 'employee');
+      const txt = document.createElement('p');
+      txt.className = 'area-conv-msg-text';
+      txt.textContent = msg.text || '';
+      row.appendChild(txt);
+      thread.appendChild(row);
+    }
+  }
+  el.appendChild(thread);
+  // Show the coach input while the job is active — covers 'running' (working)
+  // and 'waiting' uiState (review gate: employee posted and needs manager reply).
+  const uiSt = conversationUiState(conv);
+  const canCoach = uiSt === 'working' || uiSt === 'waiting';
+  if (canCoach) {
+    const coach = document.createElement('div');
+    coach.className = 'area-conv-coach';
+    const ta = document.createElement('textarea');
+    ta.className = 'area-conv-coach-ta';
+    ta.placeholder = 'Coach the team…';
+    ta.rows = 2;
+    if (prevTaVal) ta.value = prevTaVal;
+    const sendBtn = document.createElement('button');
+    sendBtn.type = 'button';
+    sendBtn.className = 'area-conv-coach-send';
+    sendBtn.textContent = 'Send';
+    sendBtn.addEventListener('click', () => {
+      const val = ta.value.trim();
+      if (!val) return;
+      state.activeId = conv.id;
+      continueRun(val);
+      ta.value = '';
+    });
+    coach.appendChild(ta);
+    coach.appendChild(sendBtn);
+    el.appendChild(coach);
+  }
+}
+
+// #594 R2: return the most-relevant org-scoped conversation to show in the Company area.
+// state.conversations is { [projectPath]: ConversationSummary[] } — flatten all.
+function tfActiveOrgConv() {
+  const orgJobs = new Set(['organization-onboarding', 'organizational-learning-synthesis']);
+  const convs = Object.values(state.conversations || {}).flat().filter((c) => orgJobs.has(c.jobId));
+  // Prefer running > waiting (needs coaching) > most recently updated completed.
+  return (
+    convs.find((c) => c.status === 'running') ||
+    convs.find((c) => c.status === 'waiting') ||
+    convs.slice().sort((a, b) => (b.lastUpdatedAt || 0) - (a.lastUpdatedAt || 0))[0] ||
+    null
+  );
+}
+
+// #594 R2: return the org-scoped manager-agreements conversation to show in Manager area.
+function tfActiveMgrConv() {
+  const mgrJobs = new Set(['manager-agreements']);
+  const convs = Object.values(state.conversations || {}).flat().filter((c) => mgrJobs.has(c.jobId));
+  return (
+    convs.find((c) => c.status === 'running') ||
+    convs.find((c) => c.status === 'waiting') ||
+    convs.slice().sort((a, b) => (b.lastUpdatedAt || 0) - (a.lastUpdatedAt || 0))[0] ||
+    null
+  );
+}
+
+// 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.
+function tfEnsurePageInArea(area) {
+  const page = document.getElementById('hub-conv-page');
+  if (!page) return;
+  const target = area === 'projects'
+    ? document.querySelector('#proj-workspace .workspace-conv')
+    : document.getElementById(area + '-conv-host');
+  if (target && page.parentElement !== target) {
+    target.appendChild(page);
+  }
+}
+
+// Toggle a Company/Manager area between its info view (accordions) and conversation panel.
+function tfToggleAreaView(area, view) {
+  const host = document.getElementById(area + '-conv-host');
+  const info = document.getElementById(area + '-info-view');
+  if (view === 'info') {
+    if (host) host.hidden = true;
+    if (info) info.hidden = false;
+    tfEnsurePageInArea('projects');
+    state.activeId = null;
+    renderActive();
+  }
+}
+
 function tfRenderCompany() {
   // #521 R4/R6: company-level jobs live ONLY in this left rail (organization-onboarding
   // + organizational-learning-synthesis) — not in any project's job list, not as
@@ -6432,6 +7736,13 @@ function tfRenderCompany() {
   const rail = document.getElementById('company-rail');
   if (rail) {
     rail.innerHTML = '';
+    const orgConvActive = !!tfActiveOrgConv();
+    const infoBtn = document.createElement('button');
+    infoBtn.type = 'button';
+    infoBtn.className = 'area-rail-info-btn' + (orgConvActive ? '' : ' info-active');
+    infoBtn.textContent = '📋 Company Info';
+    infoBtn.addEventListener('click', () => tfToggleAreaView('company', 'info'));
+    rail.appendChild(infoBtn);
     const head = document.createElement('div'); head.className = 'area-rail-head'; head.textContent = 'Company jobs';
     rail.appendChild(head);
     rail.appendChild(tfAreaRailJob('🏢', 'organization-onboarding', 'Organization onboarding', 'Set up / update org context & rules', () => tfStartOrgOnboarding()));
@@ -6444,32 +7755,145 @@ function tfRenderCompany() {
   const learn = document.getElementById('company-learnings');
   if (profile) {
     profile.innerHTML = '';
-    // Real org_context.md + org_rules.md content, edited inline.
-    profile.appendChild(tfContextRow(
-      'org',
-      'What you do',
-      'Not set up yet — run onboarding to teach your team about your organization, or click Edit to write it directly.',
-      tfRenderCompany
-    ));
-    profile.appendChild(tfContextRow(
-      'orgRules',
-      'Guardrails',
-      'Org-wide rules every employee respects before starting any job. Click Edit to add them.',
-      tfRenderCompany
-    ));
-    // Re-run onboarding moved to the Company jobs rail (#521 R4).
+    const orgCache = tfCtxCache()['org'];
+    if (orgCache && !orgCache.present) {
+      // Context is confirmed absent: show CTA and open the accordion so it is
+      // immediately visible without requiring a manual expand.
+      const ctxAcc = document.getElementById('company-ctx-acc');
+      if (ctxAcc) ctxAcc.open = true;
+      const cta = document.createElement('div');
+      cta.className = 'ctx-cta';
+      const ico = document.createElement('div');
+      ico.className = 'ctx-cta-ico';
+      ico.textContent = '🏢';
+      const title = document.createElement('p');
+      title.className = 'ctx-cta-title';
+      title.textContent = "Your team hasn't been onboarded yet";
+      const msg = document.createElement('p');
+      msg.className = 'ctx-cta-msg';
+      msg.textContent = "Run organization onboarding to teach your employees what you do, how you operate, and the rules they must follow on every job.";
+      const btn = document.createElement('button');
+      btn.className = 'ctx-cta-btn';
+      btn.type = 'button';
+      btn.textContent = 'Run organization onboarding →';
+      btn.addEventListener('click', () => tfStartOrgOnboarding());
+      cta.appendChild(ico);
+      cta.appendChild(title);
+      cta.appendChild(msg);
+      cta.appendChild(btn);
+      profile.appendChild(cta);
+    } else {
+      // Context is present or not yet fetched: render rows (they load themselves).
+      // If not yet fetched, start a background fetch and re-render to possibly switch to CTA.
+      profile.appendChild(tfContextRow(
+        'org',
+        'What you do',
+        'Not set up yet — run onboarding to teach your team about your organization, or click Edit to write it directly.',
+        tfRenderCompany
+      ));
+      profile.appendChild(tfContextRow(
+        'orgRules',
+        'Guardrails',
+        'Org-wide rules every employee respects before starting any job. Click Edit to add them.',
+        tfRenderCompany
+      ));
+      if (!orgCache) {
+        tfFetchContext('org').then(() => tfRenderCompany()).catch(() => {});
+      }
+    }
   }
   if (learn) {
     tfRenderLearningsList(learn, 'org', 'org', 'Nothing here yet — org-wide learnings that apply on every project. Run organizational-learning-synthesis (in Company jobs, left), or add one with + Add learning.');
   }
-  // Issue #540 R1-R3: render persona grid on every company-tab activation.
-  renderPersonaGrid();
+  tfMaybeRenderOrgPushBanner();
+  // Show the full coaching conversation panel when there is an active org conv;
+  // otherwise show the info view (accordions). This uses the shared .page element
+  // moved via tfEnsurePageInArea() so renderActive() renders the full panel.
+  const orgConv = tfActiveOrgConv();
+  const host = document.getElementById('company-conv-host');
+  const info = document.getElementById('company-info-view');
+  if (orgConv && tf.area === 'company') {
+    state.activeId = orgConv.id;
+    tfEnsurePageInArea('company');
+    if (host) host.hidden = false;
+    if (info) info.hidden = true;
+    renderActive();
+  } else {
+    if (host) host.hidden = true;
+    if (info) info.hidden = false;
+    if (tf.area === 'company') tfEnsurePageInArea('projects');
+  }
 }
+
+// #594 R3: show push banner in Company area after an org onboarding run completes
+// and GitHub is configured, so the manager can push the new context to the team repo.
+function tfMaybeRenderOrgPushBanner() {
+  const host = document.getElementById('company-push-banner');
+  if (!host) return;
+  if (!tfIsGithubConfigured()) { host.innerHTML = ''; return; }
+  const orgJobs = ['organization-onboarding', 'organizational-learning-synthesis'];
+  const hasCompleted = Object.values(state.conversations || {}).flat().some(
+    (c) => orgJobs.includes(c.jobId) && c.status === 'completed'
+  );
+  if (!hasCompleted) { host.innerHTML = ''; return; }
+  const dismissed = window.localStorage.getItem('fraim.aiHub.orgPushDismissed');
+  if (dismissed === '1') { host.innerHTML = ''; return; }
+  if (host.querySelector('.push-to-team-banner')) return;
+  host.innerHTML = '';
+  const banner = document.createElement('div');
+  banner.className = 'push-to-team-banner';
+  banner.id = 'company-push-banner-inner';
+  const ico = document.createElement('span');
+  ico.className = 'ptb-ico';
+  ico.textContent = '📤';
+  const copy = document.createElement('div');
+  copy.className = 'ptb-copy';
+  const repo = state.bootstrap && state.bootstrap.repository;
+  const repoLabel = (repo && repo.owner && repo.name) ? (repo.owner + '/' + repo.name) : 'your team repo';
+  copy.innerHTML = '<strong>Push to team?</strong> Your org context was updated locally. Push to <code>' + repoLabel + '</code> so teammates pick it up on their next pull.';
+  const pushBtn = document.createElement('button');
+  pushBtn.className = 'ptb-push-btn';
+  pushBtn.type = 'button';
+  pushBtn.textContent = 'Push to team';
+  pushBtn.addEventListener('click', async () => {
+    pushBtn.disabled = true;
+    pushBtn.textContent = 'Pushing...';
+    try {
+      await requestJson('/api/ai-hub/context/push', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ scope: 'org' }) });
+      window.localStorage.setItem('fraim.aiHub.orgPushDismissed', '1');
+      host.innerHTML = '';
+    } catch {
+      pushBtn.disabled = false;
+      pushBtn.textContent = 'Push to team';
+    }
+  });
+  const dismissBtn = document.createElement('button');
+  dismissBtn.className = 'ptb-dismiss';
+  dismissBtn.type = 'button';
+  dismissBtn.textContent = 'Keep local';
+  dismissBtn.addEventListener('click', () => {
+    window.localStorage.setItem('fraim.aiHub.orgPushDismissed', '1');
+    host.innerHTML = '';
+  });
+  banner.appendChild(ico);
+  banner.appendChild(copy);
+  banner.appendChild(pushBtn);
+  banner.appendChild(dismissBtn);
+  host.appendChild(banner);
+}
+
 function tfRenderManager() {
   // #521 R6: manager-level job (manager-agreements) lives ONLY in this left rail.
   const rail = document.getElementById('manager-rail');
   if (rail) {
     rail.innerHTML = '';
+    const mgrConvActive = !!tfActiveMgrConv();
+    const infoBtn = document.createElement('button');
+    infoBtn.type = 'button';
+    infoBtn.className = 'area-rail-info-btn' + (mgrConvActive ? '' : ' info-active');
+    infoBtn.textContent = '📋 Manager Info';
+    infoBtn.addEventListener('click', () => tfToggleAreaView('manager', 'info'));
+    rail.appendChild(infoBtn);
     const head = document.createElement('div'); head.className = 'area-rail-head'; head.textContent = 'Manager jobs';
     rail.appendChild(head);
     rail.appendChild(tfAreaRailJob('🤝', 'manager-agreements', 'manager-agreements', 'Set up / update how you work', () => tfStartManagerOnboarding()));
@@ -6482,21 +7906,51 @@ function tfRenderManager() {
   const reverse = document.getElementById('reverse-mentoring');
   if (profile) {
     profile.innerHTML = '';
-    // manager_context.md holds feedback style, priorities, and presenting prefs.
-    // We edit it as a whole (honest, single-file) rather than parsing facets.
-    profile.appendChild(tfContextRow(
-      'manager',
-      'How you work',
-      'Not set up yet — run onboarding to teach your team how you like direction, feedback, priorities, and hand-off. Click Edit to write it directly.',
-      tfRenderManager
-    ));
-    profile.appendChild(tfContextRow(
-      'managerRules',
-      'Rules',
-      'Standing rules for how employees should work with you. Click Edit to add them.',
-      tfRenderManager
-    ));
-    // Re-run onboarding moved to the Manager jobs rail (#521 R3).
+    const mgrCache = tfCtxCache()['manager'];
+    if (mgrCache && !mgrCache.present) {
+      // Context is confirmed absent: show CTA and open the accordion.
+      const mgrCtxAcc = document.getElementById('manager-ctx-acc');
+      if (mgrCtxAcc) mgrCtxAcc.open = true;
+      const cta = document.createElement('div');
+      cta.className = 'ctx-cta';
+      const ico = document.createElement('div');
+      ico.className = 'ctx-cta-ico';
+      ico.textContent = '🤝';
+      const title = document.createElement('p');
+      title.className = 'ctx-cta-title';
+      title.textContent = 'Set up your manager profile';
+      const msg = document.createElement('p');
+      msg.className = 'ctx-cta-msg';
+      msg.textContent = "Run manager onboarding so your team knows how you like to work, give feedback, and delegate. Your preferences become standing rules every employee respects.";
+      const btn = document.createElement('button');
+      btn.className = 'ctx-cta-btn';
+      btn.type = 'button';
+      btn.textContent = 'Run manager onboarding →';
+      btn.addEventListener('click', () => tfStartManagerOnboarding());
+      cta.appendChild(ico);
+      cta.appendChild(title);
+      cta.appendChild(msg);
+      cta.appendChild(btn);
+      profile.appendChild(cta);
+    } else {
+      // Context is present or not yet fetched: render rows (they load themselves).
+      // If not yet fetched, start a background fetch and re-render to possibly switch to CTA.
+      profile.appendChild(tfContextRow(
+        'manager',
+        'How you work',
+        'Not set up yet — run onboarding to teach your team how you like direction, feedback, priorities, and hand-off. Click Edit to write it directly.',
+        tfRenderManager
+      ));
+      profile.appendChild(tfContextRow(
+        'managerRules',
+        'Rules',
+        'Standing rules for how employees should work with you. Click Edit to add them.',
+        tfRenderManager
+      ));
+      if (!mgrCache) {
+        tfFetchContext('manager').then(() => tfRenderManager()).catch(() => {});
+      }
+    }
   }
   if (learn) {
     // #533: Manager learnings = "how your team adapts to you" = your work patterns
@@ -6508,42 +7962,25 @@ function tfRenderManager() {
     // the manager-coaching learnings the team has captured for you.
     tfRenderLearningsList(reverse, 'reverse', 'machine', 'Nothing here yet — as your team works with you, coaching on what you can improve on as a manager appears here. Add one with + Add learning.');
   }
-  tfRenderManagerTeam();
   // Issue #540 R4-R7: render manager team pool on every manager-tab activation.
   renderManagerTeamPool();
-}
-function tfRenderManagerTeam() {
-  const section = document.getElementById('manager-team-section');
-  if (!section) return;
-  section.innerHTML = '';
-  const hired = tfHiredPersonas();
-  if (hired.length === 0) {
-    const msg = document.createElement('p');
-    msg.className = 'manager-no-team-msg';
-    msg.textContent = "You haven't hired any specialists yet. Go to Company to see the full roster and hire the team you need.";
-    section.appendChild(msg);
-    const btn = document.createElement('button');
-    btn.className = 'manager-go-company-btn';
-    btn.type = 'button';
-    btn.textContent = 'Go to Company to hire';
-    btn.addEventListener('click', () => tfShowArea('company'));
-    section.appendChild(btn);
-    return;
+  // Show the full coaching conversation panel when there is an active manager conv;
+  // otherwise show the info view (accordions). Uses the shared .page element.
+  const mgrConv = tfActiveMgrConv();
+  const mgrHost = document.getElementById('manager-conv-host');
+  const mgrInfo = document.getElementById('manager-info-view');
+  if (mgrConv && tf.area === 'manager') {
+    state.activeId = mgrConv.id;
+    tfEnsurePageInArea('manager');
+    if (mgrHost) mgrHost.hidden = false;
+    if (mgrInfo) mgrInfo.hidden = true;
+    renderActive();
+  } else {
+    if (mgrHost) mgrHost.hidden = true;
+    if (mgrInfo) mgrInfo.hidden = false;
+    if (tf.area === 'manager') tfEnsurePageInArea('projects');
   }
-  const grid = document.createElement('div');
-  grid.className = 'emp-grid';
-  hired.forEach((p, i) => {
-    const av = tfAvatarFor(p.displayName, i);
-    const tile = document.createElement('div');
-    tile.className = 'emp-tile';
-    tile.innerHTML = '<div class="et-av" style="background:' + av.color + ';">' + av.badge + '</div>' +
-      '<div class="et-name">' + tfEscape(p.displayName) + '</div>' +
-      '<div class="et-role">' + tfEscape(p.role || '') + '</div>';
-    grid.appendChild(tile);
-  });
-  section.appendChild(grid);
 }
-
 // #533: Reverse mentoring now renders the real manager-coaching learnings via
 // tfRenderLearningsList(scope='reverse') — consistent with the other learning
 // sections — replacing the earlier representative-seed feed (tfReverseItems /
@@ -6675,7 +8112,7 @@ async function tfFetchPreservedLearnings(scope, level) {
 // cross-surface render churn that left the project tree unstable. #533)
 function tfReRenderScope(scope, level) {
   if (level === 'project') {
-    if (document.querySelector('.workspace-conv') && typeof tfRenderProjectContextTop === 'function') tfRenderProjectContextTop();
+    if (document.querySelector('#proj-workspace .workspace-conv') && typeof tfRenderProjectContextTop === 'function') tfRenderProjectContextTop();
     return;
   }
   if (scope === 'org') { if (typeof tfRenderCompany === 'function') tfRenderCompany(); return; }
@@ -7033,76 +8470,84 @@ function tfCloseAccountMenu() {
   if (menu) menu.classList.remove('open');
 }
 
-// ---------------------------------------------------------------------------
-// Get-started rail (driven by bootstrap.firstRun {install,company,hire,project})
-// ---------------------------------------------------------------------------
-function tfFirstRunActiveStep(fr) {
-  for (const id of TF_STEP_ORDER) { if (!fr[id]) return id; }
-  return null;
-}
-function tfRenderRail() {
-  const rail = document.getElementById('gs-rail');
-  const pill = document.getElementById('gs-pill');
-  const steps = document.getElementById('gs-steps');
-  if (!rail || !pill || !steps) return;
-  const fr = state.bootstrap && state.bootstrap.firstRun;
-  const allComplete = fr && TF_STEP_ORDER.every((id) => fr[id]);
-  if (!fr || allComplete) { rail.hidden = true; pill.hidden = true; return; }
-  const activeStep = tfFirstRunActiveStep(fr);
-  const collapsed = window.localStorage.getItem(STORAGE_KEY_RAIL_512) === '1';
-  steps.innerHTML = '';
-  TF_STEP_ORDER.forEach((id, i) => {
-    const btn = document.createElement('button');
-    btn.type = 'button';
-    btn.className = 'gs-step' + (fr[id] ? ' done' : (id === activeStep ? ' current' : ''));
-    btn.textContent = TF_STEP_LABELS[id];
-    btn.addEventListener('click', () => tfRailGo(id));
-    steps.appendChild(btn);
-    if (i < TF_STEP_ORDER.length - 1) {
-      const sep = document.createElement('span');
-      sep.className = 'gs-sep';
-      sep.textContent = '›';
-      steps.appendChild(sep);
-    }
-  });
-  const remaining = TF_STEP_ORDER.filter((id) => !fr[id]).length;
-  pill.textContent = '🚀 Finish setup · ' + remaining + ' step' + (remaining === 1 ? '' : 's') + ' left';
-  rail.hidden = collapsed;
-  pill.hidden = !collapsed;
+// Per-job config for the area onboarding pre-flight modal.
+const AREA_ONBOARD_CONFIG = {
+  'organization-onboarding': {
+    title: 'Organization onboarding',
+    desc: 'FRAIM will learn what your company does and write org_context.md and org_rules.md. Add any specific focus areas or context below.',
+  },
+  'organizational-learning-synthesis': {
+    title: 'Learning synthesis',
+    desc: 'FRAIM will consolidate recurring patterns across projects into org-wide learnings. Add any specific focus areas below.',
+  },
+  'manager-agreements': {
+    title: 'Manager agreements',
+    desc: 'FRAIM will learn how you work and write manager_context.md and manager_rules.md. Add any specific direction below.',
+  },
+};
+
+function tfOpenAreaOnboardModal(jobId, baseMessage, area) {
+  tf.aomJob = { jobId, baseMessage, area };
+  const cfg = AREA_ONBOARD_CONFIG[jobId] || { title: jobId, desc: 'Add any specific context for this run.' };
+  const titleEl = document.getElementById('aom-title');
+  const descEl = document.getElementById('aom-desc');
+  const ctx = document.getElementById('aom-context');
+  if (titleEl) titleEl.textContent = cfg.title;
+  if (descEl) descEl.textContent = cfg.desc;
+  if (ctx) ctx.value = '';
+  const modal = document.getElementById('area-onboard-modal');
+  if (modal) modal.hidden = false;
+  if (ctx) ctx.focus();
+}
+
+function tfCloseAreaOnboardModal() {
+  const modal = document.getElementById('area-onboard-modal');
+  if (modal) modal.hidden = true;
+  tf.aomJob = null;
 }
-function tfRailGo(step) {
-  if (step === 'install') { window.location.href = '/account'; return; }
-  if (step === 'company' || step === 'hire') { tfStartOrgOnboarding(); return; }
-  if (step === 'project') { tfShowArea('projects'); tfOpenNewProject(); }
+
+async function tfSubmitAreaOnboardModal() {
+  const { jobId, baseMessage, area } = tf.aomJob || {};
+  if (!jobId) return;
+  const ctx = document.getElementById('aom-context');
+  const userContext = (ctx && ctx.value.trim()) || '';
+  tfCloseAreaOnboardModal();
+  await tfStartOnboardingJob(jobId, baseMessage, area, userContext);
 }
 
-async function tfStartOnboardingJob(jobId, message, targetArea) {
+async function tfStartOnboardingJob(jobId, message, targetArea, userContext) {
   const employeeId = state.selectedEmployeeId || 'claude';
   const allJobs = [
     ...((state.bootstrap && state.bootstrap.jobs) || []),
     ...((state.bootstrap && state.bootstrap.managerTemplates) || []),
   ];
   const job = allJobs.find((j) => j.id === jobId) || { id: jobId, title: jobId };
+  // If the user typed a direction in the pre-flight modal, send only that — the
+  // job already knows what to do from its FRAIM instructions. Fall back to the
+  // job's registry intent (or the base message string) when no context is given.
+  const jobMessage = (job && job.intent && job.intent.trim()) ? job.intent : message;
+  const finalMessage = (userContext && userContext.trim()) ? userContext.trim() : jobMessage;
   if (job && typeof startRun === 'function') {
     if (targetArea) tfShowArea(targetArea);
-    await startRun(job, message, employeeId);
-    tfShowArea('projects');
-    tfSelectProjectView('workspace', tf.activeProjectId);
+    await startRun(job, finalMessage, employeeId);
+    // After run creation refresh the area panel so the conversation becomes visible.
+    if (targetArea === 'company') tfRenderCompany();
+    else if (targetArea === 'manager') tfRenderManager();
   } else if (typeof showStatus === 'function') {
     showStatus('Onboarding job not found in this project yet. Pick a project folder first.', true);
   }
 }
 
-async function tfStartOrgOnboarding() {
-  await tfStartOnboardingJob(
+function tfStartOrgOnboarding() {
+  tfOpenAreaOnboardModal(
     'organization-onboarding',
     'Onboard my organization: learn what we do and the guardrails every employee should follow, then write org_context.md and org_rules.md.',
     'company'
   );
 }
 
-async function tfStartManagerOnboarding() {
-  await tfStartOnboardingJob(
+function tfStartManagerOnboarding() {
+  tfOpenAreaOnboardModal(
     'manager-agreements',
     'Set up my manager agreements: learn how I like to work, how I give feedback, and the standing rules employees should follow with me, then write manager_context.md and manager_rules.md.',
     'manager'
@@ -7111,8 +8556,8 @@ async function tfStartManagerOnboarding() {
 
 // #521 R4: company-level learning synthesis — wired to the real
 // organizational-learning-synthesis job, launched only from the Company rail.
-async function tfStartOrgLearningSynthesis() {
-  await tfStartOnboardingJob(
+function tfStartOrgLearningSynthesis() {
+  tfOpenAreaOnboardModal(
     'organizational-learning-synthesis',
     'Synthesize our company learnings: consolidate the recurring patterns across projects into preserved org-wide learnings, then update org memory.',
     'company'
@@ -7138,36 +8583,59 @@ async function tfStartProjectOnboarding(userInput) {
   await tfStartOnboardingJob('project-onboarding', parts.join('\n\n'), 'projects');
 }
 
-// #521: collect the manager's direction before a (re)processing run so they can
-// steer it. mode 'run' = first onboarding (no context yet); 'reprocess' = refine
-// existing context/rules. The input is optional — Start runs with or without it.
-function tfOpenOnboardInput(mode) {
-  const modal = document.getElementById('onboard-input-modal');
-  const title = document.getElementById('obi-title');
-  const sub = document.getElementById('obi-sub');
-  const input = document.getElementById('obi-input');
-  if (!modal) { tfStartProjectOnboarding(); return; }
-  const reprocess = mode === 'reprocess';
-  if (title) title.textContent = reprocess ? 'Reprocess project onboarding' : 'Run project onboarding';
-  if (sub) {
-    sub.textContent = reprocess
-      ? "Your team re-reads the current context & rules (including your edits) and refines them. Add anything you want them to focus on or incorporate — optional."
-      : "Your team explores the project and captures its context and rules. Tell them what this project is or what to focus on — optional.";
-  }
-  if (input) input.value = '';
-  modal.hidden = false;
-  if (input) input.focus();
+// #594 R7: #onboard-input-modal retired. tfOpenOnboardInput now opens #np-modal
+// with the folder pre-filled and locked so the manager can only supply a direction
+// message (the intent field) before starting the re-run.
+function tfOpenOnboardInput() {
+  tfOpenNewProjectRerun();
 }
 function tfCloseOnboardInput() {
-  const m = document.getElementById('onboard-input-modal');
-  if (m) m.hidden = true;
+  tfCloseNewProject();
 }
 function tfSubmitOnboardInput() {
-  const input = document.getElementById('obi-input');
-  const val = input ? input.value : '';
-  tfCloseOnboardInput();
+  const intent = document.getElementById('np-intent');
+  const val = intent ? intent.value : '';
+  tfCloseNewProject();
   tfStartProjectOnboarding(val);
 }
+function tfOpenNewProjectRerun() {
+  const modal = document.getElementById('np-modal');
+  if (!modal) { tfStartProjectOnboarding(); return; }
+  const folder = document.getElementById('np-folder');
+  const np1Next = document.getElementById('np1-next');
+  const intent = document.getElementById('np-intent');
+  const browseBtn = document.getElementById('np-browse');
+  if (folder) {
+    folder.value = state.projectPath || '';
+    folder.readOnly = true;
+  }
+  if (browseBtn) browseBtn.hidden = true;
+  if (intent) {
+    intent.value = '';
+    const label = intent.closest('.np-field') && intent.closest('.np-field').querySelector('label');
+    if (label) label.dataset.originalText = label.innerHTML;
+    if (label) label.innerHTML = 'Anything new to focus on this time? <span class="np-optional">(optional)</span>';
+  }
+  if (np1Next) { np1Next.disabled = false; np1Next.removeAttribute('disabled'); }
+  // Update Step 1 heading and description for re-run context.
+  const np1Hdr = document.querySelector('#np1 .np-hdr');
+  if (np1Hdr) {
+    const h2 = np1Hdr.querySelector('h2');
+    const desc = np1Hdr.querySelector('p');
+    const stepLabel = np1Hdr.querySelector('.step-label');
+    if (h2) { h2.dataset.originalText = h2.textContent; h2.textContent = 'Update project onboarding'; }
+    if (desc) { desc.dataset.originalText = desc.textContent; desc.textContent = 'Your project folder is already set. Tell the team anything new to focus on this time.'; }
+    if (stepLabel) { stepLabel.dataset.originalText = stepLabel.textContent; stepLabel.textContent = 'Step 1 of 4 — Re-run'; }
+  }
+  const np1Hint = document.querySelector('#np1 .np-field-hint');
+  if (np1Hint) { np1Hint.dataset.originalText = np1Hint.textContent; np1Hint.textContent = 'This project folder is already set — only the direction below will change.'; }
+  modal.dataset.rerun = '1';
+  // Pre-select all hired personas so step 2 starts with a sensible default.
+  tf.npSelectedEmployees = tfHiredPersonas().map((p) => p.key);
+  tfRenderNpEmployees();
+  tfNpGo(1);
+  modal.hidden = false;
+}
 
 // ---------------------------------------------------------------------------
 // New-project modal (4-step)
@@ -7188,7 +8656,26 @@ function tfOpenNewProject() {
 }
 function tfCloseNewProject() {
   const m = document.getElementById('np-modal');
-  if (m) m.hidden = true;
+  if (m) { m.hidden = true; delete m.dataset.rerun; }
+  const folder = document.getElementById('np-folder');
+  if (folder) folder.readOnly = false;
+  const browseBtn = document.getElementById('np-browse');
+  if (browseBtn) browseBtn.hidden = false;
+  const intent = document.getElementById('np-intent');
+  if (intent) {
+    const label = intent.closest('.np-field') && intent.closest('.np-field').querySelector('label');
+    if (label && label.dataset.originalText) { label.innerHTML = label.dataset.originalText; delete label.dataset.originalText; }
+  }
+  // Restore Step 1 heading, description, step-label, and hint to new-project defaults.
+  const np1Hdr = document.querySelector('#np1 .np-hdr');
+  if (np1Hdr) {
+    for (const sel of ['h2', 'p', '.step-label']) {
+      const el = np1Hdr.querySelector(sel);
+      if (el && el.dataset.originalText) { el.textContent = el.dataset.originalText; delete el.dataset.originalText; }
+    }
+  }
+  const np1Hint = document.querySelector('#np1 .np-field-hint');
+  if (np1Hint && np1Hint.dataset.originalText) { np1Hint.textContent = np1Hint.dataset.originalText; delete np1Hint.dataset.originalText; }
 }
 function tfNpGo(n) {
   tf.npStep = n;
@@ -7643,16 +9130,6 @@ function tfWireShell() {
   if (overviewTab) overviewTab.addEventListener('click', () => tfSelectProjectView('overview'));
   const addTab = document.getElementById('ptab-add');
   if (addTab) addTab.addEventListener('click', tfOpenNewProject);
-  const cta = document.getElementById('gs-cta');
-  if (cta) cta.addEventListener('click', () => {
-    const fr = state.bootstrap && state.bootstrap.firstRun;
-    const active = fr && tfFirstRunActiveStep(fr);
-    if (active) tfRailGo(active);
-  });
-  const hide = document.getElementById('gs-hide');
-  if (hide) hide.addEventListener('click', () => { window.localStorage.setItem(STORAGE_KEY_RAIL_512, '1'); tfRenderRail(); });
-  const pill = document.getElementById('gs-pill');
-  if (pill) pill.addEventListener('click', () => { window.localStorage.removeItem(STORAGE_KEY_RAIL_512); tfRenderRail(); });
   const npClose = document.getElementById('np-close');
   if (npClose) npClose.addEventListener('click', tfCloseNewProject);
 
@@ -7690,7 +9167,16 @@ function tfWireShell() {
   }
   const npModal = document.getElementById('np-modal');
   if (npModal) npModal.addEventListener('click', (e) => { if (e.target === npModal) tfCloseNewProject(); });
-  const closers = [['aj-close', tfCloseAssignJob], ['ae-close', tfCloseAddEmp], ['pr-close', tfClosePricing], ['obi-close', tfCloseOnboardInput], ['obi-cancel', tfCloseOnboardInput], ['hm-close', tfCloseHireManager]];
+  // #594: Area onboarding pre-flight modal wiring.
+  const aomClose = document.getElementById('aom-close');
+  if (aomClose) aomClose.addEventListener('click', tfCloseAreaOnboardModal);
+  const aomCancel = document.getElementById('aom-cancel');
+  if (aomCancel) aomCancel.addEventListener('click', tfCloseAreaOnboardModal);
+  const aomStart = document.getElementById('aom-start');
+  if (aomStart) aomStart.addEventListener('click', tfSubmitAreaOnboardModal);
+  const aomModal = document.getElementById('area-onboard-modal');
+  if (aomModal) aomModal.addEventListener('click', (e) => { if (e.target === aomModal) tfCloseAreaOnboardModal(); });
+  const closers = [['aj-close', tfCloseAssignJob], ['ae-close', tfCloseAddEmp], ['pr-close', tfClosePricing], ['hm-close', tfCloseHireManager]];
   for (const [id, fn] of closers) {
     const el = document.getElementById(id);
     if (el) el.addEventListener('click', fn);
@@ -7716,16 +9202,7 @@ function tfWireShell() {
     const q = document.getElementById('hm-query');
     if (q && navigator.clipboard) navigator.clipboard.writeText(q.textContent || '');
   });
-  const hmBtn = document.getElementById('manager-hire-btn');
-  if (hmBtn) hmBtn.addEventListener('click', () => {
-    const mh = state.bootstrap && state.bootstrap.managerHiring;
-    const hired = ((state.bootstrap && state.bootstrap.personas) || []).filter((p) => p.status === 'hired' && mh && mh.roles[p.key]);
-    const first = hired[0] ? hired[0].key : (mh ? Object.keys(mh.roles)[0] : null);
-    openHireManagerModal(first);
-  });
-  const obiStart = document.getElementById('obi-start');
-  if (obiStart) obiStart.addEventListener('click', tfSubmitOnboardInput);
-  const backdrops = [['assign-job-modal', tfCloseAssignJob], ['add-emp-modal', tfCloseAddEmp], ['pricing-modal', tfClosePricing], ['onboard-input-modal', tfCloseOnboardInput], ['hm-modal', tfCloseHireManager]];
+  const backdrops = [['assign-job-modal', tfCloseAssignJob], ['add-emp-modal', tfCloseAddEmp], ['pricing-modal', tfClosePricing], ['hm-modal', tfCloseHireManager]];
   for (const [id, fn] of backdrops) {
     const el = document.getElementById(id);
     if (el) el.addEventListener('click', (e) => { if (e.target === el) fn(); });
@@ -7736,7 +9213,6 @@ function tfWireShell() {
   // dismisses whichever team-flow modal is open (top-most first).
   const escClosers = [
     ['hm-modal', tfCloseHireManager],
-    ['onboard-input-modal', tfCloseOnboardInput],
     ['pricing-modal', tfClosePricing],
     ['add-emp-modal', tfCloseAddEmp],
     ['assign-job-modal', tfCloseAssignJob],
@@ -7805,9 +9281,10 @@ function tfInitShell() {
   } else if (tf.projects.length && !tf.activeProjectId) {
     tf.activeProjectId = tf.projects[0].id;
   }
-  tfRenderRail();
   tfRenderProjectTabs();
   tfShowArea('projects');
+  // Issue #578: wire deployment modal buttons.
+  initDeploymentButtons();
   // Open the workspace by default so the conversation surface (#conversation,
   // #new-conv-btn, #empty, the welcome line, the project button) is visible on
   // load — preserving the contract the shipped #339/#347/#429/#442 Hub UI
@@ -7817,12 +9294,15 @@ function tfInitShell() {
   } else {
     tfSelectProjectView('overview');
   }
+  // Server-hydrated completed runs can arrive before the shell finishes wiring
+  // the project workspace. Re-render once the workspace is selected so manager
+  // delegation boards are visible on first load, not only after a refresh tick.
+  renderActive();
 }
 
 // Refresh shell-derived UI after a bootstrap reload (e.g. project picked).
 function tfRefreshAfterBootstrap() {
   if (!tf.enabled) return;
-  tfRenderRail();
   tfRenderProjectTabs();
   if (tf.area === 'company') tfRenderCompany();
   else if (tf.area === 'manager') tfRenderManager();