fraim-framework 2.0.182 → 2.0.184

package/public/ai-hub/script.js

@@ -50,6 +50,8 @@ const state = {
   _hireStripPending: null,
 };
 
+const bootstrapCache = new Map();
+
 const els = {};
 
 // ---------------------------------------------------------------------------
@@ -120,14 +122,16 @@ async function requestJson(url, options) {
   return payload;
 }
 
-async function loadBootstrap(projectPath, docUrl) {
-  const params = new URLSearchParams();
-  if (projectPath) params.set('projectPath', projectPath);
-  if (docUrl) params.set('docUrl', docUrl);
-  const query = params.toString() ? '?' + params.toString() : '';
-  const fetchOptions = {};
-  if (state.storedApiKey) fetchOptions.headers = { 'x-api-key': state.storedApiKey };
-  const bootstrap = await requestJson(`/api/ai-hub/bootstrap${query}`, fetchOptions);
+function bootstrapCacheKey(projectPath, docUrl) {
+  return `${tfCanonicalProjectPath(projectPath || '')}::${docUrl || ''}`;
+}
+
+function cacheBootstrapPayload(bootstrap, docUrl) {
+  if (!bootstrap || !bootstrap.project || !bootstrap.project.path) return;
+  bootstrapCache.set(bootstrapCacheKey(bootstrap.project.path, docUrl), bootstrap);
+}
+
+function applyBootstrap(bootstrap, docUrl) {
   state.bootstrap = bootstrap;
   state.projectPath = bootstrap.project.path;
   state.selectedEmployeeId = state.selectedEmployeeId || bootstrap.preferences.employeeId;
@@ -162,6 +166,45 @@ async function loadBootstrap(projectPath, docUrl) {
   // Issue #540: render the persona grid and manager team pool.
   renderPersonaGrid();
   renderManagerTeamPool();
+  cacheBootstrapPayload(bootstrap, docUrl);
+}
+
+async function fetchBootstrap(projectPath, docUrl) {
+  const params = new URLSearchParams();
+  if (projectPath) params.set('projectPath', projectPath);
+  if (docUrl) params.set('docUrl', docUrl);
+  const query = params.toString() ? '?' + params.toString() : '';
+  const fetchOptions = {};
+  if (state.storedApiKey) fetchOptions.headers = { 'x-api-key': state.storedApiKey };
+  const bootstrap = await requestJson(`/api/ai-hub/bootstrap${query}`, fetchOptions);
+  cacheBootstrapPayload(bootstrap, docUrl);
+  return bootstrap;
+}
+
+async function refreshBootstrapInBackground(projectPath, docUrl) {
+  try {
+    const bootstrap = await fetchBootstrap(projectPath, docUrl);
+    if (tfCanonicalProjectPath(state.projectPath) !== tfCanonicalProjectPath(bootstrap.project.path)) return;
+    applyBootstrap(bootstrap, docUrl);
+    await hydrateConversationsFromServer();
+    tfRefreshAfterBootstrap();
+  } catch (error) {
+    console.warn('[512] Background project refresh failed:', error);
+  }
+}
+
+async function loadBootstrap(projectPath, docUrl, options) {
+  const opts = options || {};
+  const requestedKey = bootstrapCacheKey(projectPath || state.projectPath, docUrl);
+  if (opts.preferCache && bootstrapCache.has(requestedKey)) {
+    const cached = bootstrapCache.get(requestedKey);
+    applyBootstrap(cached, docUrl);
+    if (opts.backgroundRefresh !== false) refreshBootstrapInBackground(projectPath, docUrl);
+    return cached;
+  }
+  const bootstrap = await fetchBootstrap(projectPath, docUrl);
+  applyBootstrap(bootstrap, docUrl);
+  return bootstrap;
 }
 
 // ---------------------------------------------------------------------------
@@ -348,6 +391,11 @@ function friendlyProjectName(p) {
   return parts.slice(-2).join('/') || p;
 }
 
+function friendlyProjectShortName(p) {
+  const friendly = friendlyProjectName(p);
+  return friendly.split(/[\\/]/).filter(Boolean).pop() || friendly;
+}
+
 // ---------------------------------------------------------------------------
 // Conversation persistence (per project, in localStorage)
 // ---------------------------------------------------------------------------
@@ -620,10 +668,16 @@ function stripReviewHandoffBlocks(text) {
     .trim();
 }
 
-function stripHubInjectedPromptBlocks(text) {
+function stripHubInjectedNotes(text) {
   return String(text || '')
     .replace(/(?:^|\n)\s*\[How to talk to me\][\s\S]*?(?=\n\s*\[[^\]\n]+\]|\n\s*#{1,6}\s|\n\s*[-*]\s|\n{2,}|$)/gi, '\n')
-    .replace(/(?:^|\n)\s*(?:[$/]fraim)\s+[a-z0-9-]+(?:\s*\[[^\]\n]*\])?[^\n]*(?=\n|$)/gi, '\n')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim();
+}
+
+function stripHubInjectedPromptBlocks(text) {
+  return stripHubInjectedNotes(text)
+    .replace(/(?:^|\n)\s*(?:[$/@]fraim)\s+[a-z0-9-]+(?:\s*\[[^\]\n]*\])?[^\n]*(?=\n|$)/gi, '\n')
     .replace(/\n{3,}/g, '\n\n')
     .trim();
 }
@@ -2580,8 +2634,8 @@ function closeTemplatePopover() {
 }
 
 function applyTemplateInvocation(managerJobId) {
-  // The invocation prefix ($fraim / /fraim) is an implementation detail that
-  // the server adds based on the active employee — the user should never see it.
+  // The server adds the invocation prefix based on the active employee. Keep
+  // that syntax out of the editable textarea; the thread shows it after send.
   // Store the job ID as a pending coaching job. The #coach-note shows a
   // human-readable label; the textarea gets editable context the user can amend.
   // When the user clicks Send, continueRun sends { coachingJobId, instructions }.
@@ -2590,7 +2644,7 @@ function applyTemplateInvocation(managerJobId) {
   // for sessions that stored raw invocation text before this change).
   const textarea = els['coach-text'];
   textarea.value = textarea.value
-    .replace(/(?:^|\n|\s)[/$]fraim\s+[a-z0-9-]+(?:\s|$)/ig, ' ')
+    .replace(/(?:^|\n|\s)[$/@]fraim\s+[a-z0-9-]+(?:\s|$)/ig, ' ')
     .replace(/\s+/g, ' ')
     .trim();
   textarea.focus();
@@ -2629,17 +2683,20 @@ function stripStubReference(text) {
 }
 
 function surfaceText(role, text, conv) {
-  const raw = stripHubInjectedPromptBlocks(stripStubReference(text));
+  const withoutStub = stripStubReference(text);
+  const raw = role === 'manager'
+    ? stripHubInjectedNotes(withoutStub)
+    : stripHubInjectedPromptBlocks(withoutStub);
   if (!raw) return '';
 
   if (role === 'manager') {
-    const invocationOnly = raw.match(/^(?:[$/]fraim)\s+([a-z0-9-]+)\s*$/i);
+    const invocationOnly = raw.match(/^(?:[$/@]fraim)\s+([a-z0-9-]+)\s*$/i);
     if (invocationOnly) return raw;
     const slugPattern = '[a-z0-9]+(?:-[a-z0-9]+)+';
-    const invocationWithSlug = new RegExp(`^(?:[$/]fraim)\\s+(${slugPattern})\\s*`, 'i');
+    const invocationWithSlug = new RegExp(`^(?:[$/@]fraim)\\s+(${slugPattern})\\s*`, 'i');
     return raw
       .replace(invocationWithSlug, '')
-      .replace(/^(?:[$/]fraim)\s*/i, '')
+      .replace(/^(?:[$/@]fraim)\s*/i, '')
       .trim();
   }
 
@@ -4592,9 +4649,9 @@ function deriveTitle(jobTitle, instructions) {
   const trimmedJob = (jobTitle || '').trim();
   const raw = (instructions || '').trim();
   // Capture FRAIM job slug before stripping (e.g. "/fraim pricing-strategy-definition" → "pricing-strategy-definition")
-  const fraimSlugMatch = raw.match(/^[/$]fraim\s+([a-z0-9][a-z0-9-]*)(?:\s|$)/i);
+  const fraimSlugMatch = raw.match(/^[$/@]fraim\s+([a-z0-9][a-z0-9-]*)(?:\s|$)/i);
   const stripped = raw
-    .replace(/^[/$]fraim(?:\s+[a-z0-9-]+)?\s*/i, '')
+    .replace(/^[$/@]fraim(?:\s+[a-z0-9-]+)?\s*/i, '')
     .replace(/\s+/g, ' ')
     .trim();
   const words = stripped.split(' ').filter(Boolean).slice(0, 6);
@@ -5956,7 +6013,7 @@ const tf = {
   area: 'projects',          // company | manager | projects | brain
   projectView: 'overview',   // overview | workspace
   activeProjectId: null,
-  projects: [],              // [{ id, name, intent, brief, team:[personaKey] }]
+  projects: [],              // [{ id, name, intent, brief }] — roster derived from hired personas, not stored
   assignments: {},           // { [projectId]: [{ id, employeeKey, jobName, jobId }] }
   npStep: 1,
   npSelectedEmployees: [],
@@ -5978,24 +6035,144 @@ function tfPersonas() { return (state.bootstrap && state.bootstrap.personas) ||
 function tfHiredPersonas() { return tfPersonas().filter((p) => p.status === 'hired'); }
 function tfAvailablePersonas() { return tfPersonas().filter((p) => p.status !== 'hired'); }
 function tfPersonaByKey(key) { return tfPersonas().find((p) => p.key === key) || null; }
+// A project's employee roster is derived from the hired personas in the bootstrap
+// (DB-authoritative), NOT from per-machine local state. With the legacy-workspace
+// bypass every user sees the full employee catalog, and the roster is identical on
+// every machine the user signs in from. Deliberately not persisted to disk /
+// localStorage — see AiHubProjectListEntry in src/ai-hub/types.ts.
+function tfProjectTeamKeys() { return tfHiredPersonas().map((p) => p.key); }
 
 // ---------------------------------------------------------------------------
 // Persistence (projects + assignments, mirrors the conversation model)
 // ---------------------------------------------------------------------------
+function tfCanonicalProjectPath(folderPath) {
+  const value = String(folderPath || '').replace(/\\/g, '/').replace(/\/+$/, '');
+  return /^[A-Za-z]:\//.test(value) ? value.toLowerCase() : value;
+}
+
+function tfProjectIdForPath(folderPath) {
+  const canonical = tfCanonicalProjectPath(folderPath);
+  let hash = 0;
+  for (let i = 0; i < canonical.length; i++) hash = ((hash << 5) - hash + canonical.charCodeAt(i)) | 0;
+  return 'p-' + Math.abs(hash).toString(36);
+}
+
+function tfNormalizeProject(raw, fallbackPath) {
+  if (!raw || typeof raw !== 'object') return null;
+  const folderPath = raw.folderPath || raw.path || raw.folder || fallbackPath || '';
+  if (!folderPath) return null;
+  const cleanPath = String(folderPath);
+  const rawId = typeof raw.id === 'string' ? raw.id.trim() : '';
+  return {
+    id: rawId || tfProjectIdForPath(cleanPath),
+    name: raw.name || friendlyProjectShortName(cleanPath),
+    folderPath: cleanPath,
+    intent: raw.intent || '',
+    outcome: raw.outcome || '',
+    rules: raw.rules || '',
+    brief: raw.brief || raw.intent || '',
+    // Roster is derived from hired personas at render time (tfProjectTeamKeys),
+    // never stored per machine. Any legacy `team` on stored state is dropped.
+    updatedAt: raw.updatedAt || undefined,
+  };
+}
+
+function tfApplyUniqueProjectIds(projects) {
+  const seen = new Set();
+  return (projects || []).map((project) => {
+    const fallbackId = tfProjectIdForPath(project.folderPath || project.path || project.folder);
+    const rawId = typeof project.id === 'string' ? project.id.trim() : '';
+    let id = rawId && rawId !== 'p-current' ? rawId : fallbackId;
+    let suffix = 2;
+    while (seen.has(id)) {
+      id = `${fallbackId}-${suffix}`;
+      suffix += 1;
+    }
+    seen.add(id);
+    return { ...project, id };
+  });
+}
+
+function tfMergeProjects(projects) {
+  const merged = new Map();
+  const add = (project) => {
+    const normalized = tfNormalizeProject(project);
+    if (!normalized) return;
+    const key = tfCanonicalProjectPath(normalized.folderPath);
+    const existing = merged.get(key);
+    if (existing) {
+      const next = { ...existing, ...normalized, folderPath: normalized.folderPath || existing.folderPath };
+      merged.set(key, next);
+    } else {
+      merged.set(key, normalized);
+    }
+  };
+  for (const project of tf.projects || []) add(project);
+  for (const project of projects || []) add(project);
+  tf.projects = tfApplyUniqueProjectIds(Array.from(merged.values()));
+}
+
+function tfProjectForPath(folderPath) {
+  const key = tfCanonicalProjectPath(folderPath);
+  return tf.projects.find((project) => tfCanonicalProjectPath(project.folderPath || project.path || project.folder) === key) || null;
+}
+
+function tfEnsureCurrentProject() {
+  if (!state.projectPath) return null;
+  const current = tfNormalizeProject({
+    id: tfProjectIdForPath(state.projectPath),
+    name: friendlyProjectShortName(state.projectPath),
+    folderPath: state.projectPath,
+  }, state.projectPath);
+  tfMergeProjects([current]);
+  const resolved = tfProjectForPath(state.projectPath);
+  if (!tf.activeProjectId || !tf.projects.some((project) => project.id === tf.activeProjectId)) {
+    tf.activeProjectId = resolved ? resolved.id : tf.projects[0]?.id || null;
+  }
+  return resolved;
+}
+
 function tfLoadStorage() {
-  try { tf.projects = JSON.parse(window.localStorage.getItem(STORAGE_KEY_PROJECTS_512) || '[]'); }
+  try {
+    const stored = JSON.parse(window.localStorage.getItem(STORAGE_KEY_PROJECTS_512) || '[]');
+    const normalized = Array.isArray(stored) ? stored.map((project) => tfNormalizeProject(project)).filter(Boolean) : [];
+    tf.projects = tfApplyUniqueProjectIds(normalized);
+  }
   catch { tf.projects = []; }
   try { tf.assignments = JSON.parse(window.localStorage.getItem(STORAGE_KEY_ASSIGNMENTS_512) || '{}'); }
   catch { tf.assignments = {}; }
 }
 function tfPersistProjects() {
   try { window.localStorage.setItem(STORAGE_KEY_PROJECTS_512, JSON.stringify(tf.projects)); } catch {}
+  if (!state.projectPath) return;
+  requestJson('/api/ai-hub/projects', {
+    method: 'PUT',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ projectPath: state.projectPath, projects: tf.projects }),
+  }).catch((error) => console.warn('[512] Could not persist projects to local disk:', error));
 }
 function tfPersistAssignments() {
   try { window.localStorage.setItem(STORAGE_KEY_ASSIGNMENTS_512, JSON.stringify(tf.assignments)); } catch {}
 }
 function tfProjectAssignments(projectId) { return tf.assignments[projectId] || []; }
 
+function tfSetProjectSwitching(active, project) {
+  const workspace = document.getElementById('proj-workspace');
+  const mask = document.getElementById('proj-switch-mask');
+  const label = document.getElementById('proj-switch-label');
+  if (workspace) {
+    workspace.classList.toggle('project-switching', !!active);
+    workspace.setAttribute('aria-busy', active ? 'true' : 'false');
+  }
+  if (mask) mask.setAttribute('aria-hidden', active ? 'false' : 'true');
+  if (label && project) {
+    label.textContent = `Loading ${project.name || friendlyProjectShortName(project.folderPath || project.path || project.folder)}...`;
+  }
+  document.querySelectorAll('#proj-tabs .ptab').forEach((tab) => {
+    if (tab.id !== 'ptab-add') tab.disabled = !!active;
+  });
+}
+
 // ---------------------------------------------------------------------------
 // Status dots — derived from each conversation's read-side run projection.
 //   red = needs you, amber = working, green = done, grey = idle/no run.
@@ -6023,9 +6200,13 @@ function tfConvForAssignment(assignment) {
 }
 // #521 R6.5: all past runs of a job across the workspace (newest first) — powers
 // the run history under the Company/Manager rail jobs, same as the project tree.
-function tfConversationsForJob(jobId) {
+function tfConversationsForJob(jobId, opts) {
   const out = [];
-  for (const list of Object.values(state.conversations || {})) {
+  const projectPath = opts && opts.projectPath;
+  const lists = projectPath
+    ? [state.conversations[projectPath] || []]
+    : Object.values(state.conversations || {});
+  for (const list of lists) {
     for (const c of (list || [])) if (c && c.jobId === jobId) out.push(c);
   }
   out.sort((a, b) => (b.updatedAt || b.createdAt || 0) - (a.updatedAt || a.createdAt || 0));
@@ -6079,7 +6260,7 @@ function tfShowArea(area) {
   window.scrollTo(0, 0);
 }
 
-function tfSelectProjectView(view, projectId) {
+async function tfSelectProjectView(view, projectId) {
   tf.projectView = view;
   if (projectId) tf.activeProjectId = projectId;
   // Always return to the conversation when changing views.
@@ -6100,9 +6281,16 @@ function tfSelectProjectView(view, projectId) {
     // When switching to a project workspace, switch the active folder so all
     // runs, context reads, and learnings scope to that project's disk location.
     const proj = tf.projects.find((p) => p.id === tf.activeProjectId);
-    if (proj && proj.folderPath && proj.folderPath !== state.projectPath) {
-      tfSwitchProjectFolder(proj.folderPath).catch((e) =>
-        console.warn('[512] tfSwitchProjectFolder failed:', e));
+    const folderPath = proj && (proj.folderPath || proj.path || proj.folder);
+    if (folderPath && tfCanonicalProjectPath(folderPath) !== tfCanonicalProjectPath(state.projectPath)) {
+      try {
+        tfSetProjectSwitching(true, proj);
+        await tfSwitchProjectFolder(folderPath);
+      } catch (e) {
+        console.warn('[512] tfSwitchProjectFolder failed:', e);
+      } finally {
+        tfSetProjectSwitching(false);
+      }
     }
     // #521 fix: invalidate the project-scoped context cache whenever the active
     // project changes — covers new-project creation (where state.projectPath is
@@ -6235,7 +6423,7 @@ function tfRenderOverview() {
     const team = document.createElement('div');
     team.className = 'proj-team';
     const assigned = tfProjectAssignments(proj.id);
-    const empKeys = Array.from(new Set([...(proj.team || []), ...assigned.map((a) => a.employeeKey).filter(Boolean)]));
+    const empKeys = Array.from(new Set([...tfProjectTeamKeys(), ...assigned.map((a) => a.employeeKey).filter(Boolean)]));
     empKeys.slice(0, 6).forEach((key, i) => {
       const persona = tfPersonaByKey(key);
       const av = tfAvatarFor(persona ? persona.displayName : key, i);
@@ -6417,7 +6605,7 @@ function kbMakeCard(conv) {
   // Kanban/Cards overview is read-only. Clicking anywhere on the card navigates to the workspace.
   const navigate = () => {
     if (!conv.id) return;
-    const _proj = conv.projectPath ? tf.projects.find((p) => p.folderPath === conv.projectPath) : null;
+    const _proj = conv.projectPath ? tfProjectForPath(conv.projectPath) : null;
     tfSelectProjectView('workspace', _proj ? _proj.id : tf.activeProjectId);
     switchToConversation(conv.id);
   };
@@ -6537,17 +6725,16 @@ function tfRenderTree() {
   const projectId = tf.activeProjectId;
   const assigned = tfProjectAssignments(projectId);
   const project = tf.projects.find((p) => p.id === projectId);
-  const onProject = (project && project.team) || [];
+  const onProject = tfProjectTeamKeys();
   // Issue #540 R8: include personas on the manager's team so delegate buttons
   // appear in the workspace tree even when the persona hasn't been assigned yet.
   const managerTeamPersonaKeys = (state.bootstrap?.managerTeam || []).map((e) => e.personaKey);
   const empKeys = Array.from(new Set([...onProject, ...assigned.map((a) => a.employeeKey).filter(Boolean), ...managerTeamPersonaKeys]))
-    // #538 follow-up: reconcile against real entitlements. The localStorage
-    // project.team can hold members who are no longer hired (or were seeded
-    // before an entitlement change), which made un-hired personas like swen
-    // appear in a workspace where only beza/pam are actually hired. Drop any
-    // key that resolves to a known persona that is NOT hired; keep hired
-    // personas and genuinely custom employees (no persona record).
+    // #538 follow-up: reconcile against real entitlements. `assigned` job records
+    // and manager-team keys can reference personas that are no longer hired; drop
+    // any key that resolves to a known persona that is NOT hired. Keep hired
+    // personas and genuinely custom employees (no persona record). onProject is
+    // already hired-only (tfProjectTeamKeys), so this is a no-op for it.
     .filter((key) => { const p = tfPersonaByKey(key); return !p || p.status === 'hired'; });
   const managerTeamKeySet = new Set(managerTeamPersonaKeys);
 
@@ -6815,9 +7002,12 @@ async function loadDeployments() {
   const list = document.getElementById('proj-deployments-list');
   if (!list) return;
   try {
+    const params = new URLSearchParams();
+    if (state.projectPath) params.set('projectPath', state.projectPath);
+    const suffix = params.toString() ? '?' + params.toString() : '';
     const [schResp, whResp] = await Promise.all([
-      fetch('/api/ai-hub/schedules'),
-      fetch('/api/ai-hub/webhooks'),
+      fetch('/api/ai-hub/schedules' + suffix),
+      fetch('/api/ai-hub/webhooks' + suffix),
     ]);
     const schedules = schResp.ok ? await schResp.json() : [];
     const webhooks = whResp.ok ? await whResp.json() : [];
@@ -7157,7 +7347,7 @@ async function saveScheduleDeployment() {
     const resp = await fetch(url, {
       method,
       headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ label, jobId, hostId, cronExpr, instructions: instructions || undefined }),
+      body: JSON.stringify({ label, jobId, projectPath: state.projectPath || undefined, 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;
@@ -7180,7 +7370,7 @@ async function saveWebhookDeployment() {
     const resp = await fetch(url, {
       method,
       headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ label, jobId, hostId, instructions: instructions || undefined }),
+      body: JSON.stringify({ label, jobId, projectPath: state.projectPath || undefined, 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) {
@@ -7789,7 +7979,7 @@ function tfProjectUpdatesSection() {
   av.textContent = '🔄';
   const id = document.createElement('div'); id.className = 'eh-id';
   const nm = document.createElement('div'); nm.className = 'eh-name'; nm.style.fontSize = '14px'; nm.textContent = 'Project Updates';
-  const totalRuns = JOBS.reduce((n, j) => n + tfConversationsForJob(j.id).length, 0);
+  const totalRuns = JOBS.reduce((n, j) => n + tfConversationsForJob(j.id, { projectPath: state.projectPath }).length, 0);
   const role = document.createElement('div'); role.className = 'eh-role';
   role.textContent = totalRuns ? (totalRuns + (totalRuns === 1 ? ' run' : ' runs')) : 'Onboarding & learnings';
   id.appendChild(nm); id.appendChild(role);
@@ -7811,7 +8001,7 @@ function tfProjectUpdatesSection() {
     const head = document.createElement('div'); head.className = 'pu-job-name';
     head.textContent = j.ico + '  ' + j.name;
     group.appendChild(head);
-    const runs = tfConversationsForJob(j.id);
+    const runs = tfConversationsForJob(j.id, { projectPath: state.projectPath });
     if (!runs.length) {
       const none = document.createElement('div'); none.className = 'eh-empty'; none.textContent = 'No runs yet.';
       group.appendChild(none);
@@ -9024,7 +9214,7 @@ async function tfCreateProject() {
     intent && `Project intent: ${intent}`,
     val('np-outcome') && `Success looks like: ${val('np-outcome')}`,
     val('np-rules') && `Rules & guardrails: ${val('np-rules')}`,
-    `Team: ${(project.team || []).join(', ') || 'no employees assigned yet'}`,
+    `Team: ${tfProjectTeamKeys().join(', ') || 'no employees assigned yet'}`,
   ].filter(Boolean).join('\n\n');
 
   if (onboardingContext) {
@@ -9045,8 +9235,13 @@ async function tfCreateProject() {
  * the server's preferences store records it so it survives restart.
  */
 async function tfSwitchProjectFolder(folderPath) {
-  if (!folderPath || folderPath === state.projectPath) return;
-  state.projectPath = folderPath;
+  const normalized = tfNormalizeProject({ folderPath });
+  if (!normalized) return;
+  if (tfCanonicalProjectPath(normalized.folderPath) === tfCanonicalProjectPath(state.projectPath)) {
+    await hydrateConversationsFromServer();
+    return;
+  }
+  state.projectPath = normalized.folderPath;
   // #521 fix: the context cache (state._ctxCache) is keyed by context key only
   // (projectContext/projectBrief/projectRules), NOT by project — so without this
   // the new project's Brief section would render the PREVIOUS project's content
@@ -9056,7 +9251,23 @@ async function tfSwitchProjectFolder(folderPath) {
   for (const k of ['projectContext', 'projectBrief', 'projectRules']) delete cache[k];
   // loadBootstrap sends projectPath as a query param — the server records it
   // in its preferences store so this folder becomes the default on next load.
-  await loadBootstrap(folderPath);
+  const cachedConversations = Array.isArray(state.conversations[normalized.folderPath]);
+  const conversationsPromise = cachedConversations ? null : hydrateConversationsFromServer();
+  await loadBootstrap(normalized.folderPath, undefined, { preferCache: true });
+  if (cachedConversations) {
+    renderRail();
+    renderActive();
+    hydrateConversationsFromServer().catch((error) =>
+      console.warn('[512] Could not refresh project conversations:', error)
+    );
+  } else {
+    await conversationsPromise;
+  }
+  tfMergeProjects(state.bootstrap && Array.isArray(state.bootstrap.projects) ? state.bootstrap.projects : []);
+  const currentProject = tfEnsureCurrentProject();
+  if (currentProject) tf.activeProjectId = currentProject.id;
+  tfPersistProjects();
+  tfRefreshAfterBootstrap();
 }
 
 // ---------------------------------------------------------------------------
@@ -9078,7 +9289,7 @@ function tfOpenAssignJob(employeeKey) {
   const filterKey = employeeKey || null;
   const filterPersona = filterKey ? tfPersonaByKey(filterKey) : null;
   const filterName = filterPersona ? (filterPersona.displayName || filterKey) : null;
-  if (title) title.textContent = filterKey ? ('Jobs for ' + filterName) : 'Assign a job';
+  if (title) title.textContent = filterKey ? ('Assign a job to ' + filterName) : 'Assign a job';
 
   const allJobs = (state.bootstrap && state.bootstrap.jobs) || [];
   const personasToShow = filterKey ? hired.filter((p) => p.key === filterKey) : hired;
@@ -9132,7 +9343,7 @@ function tfOpenAssignJob(employeeKey) {
       if (specificJobs.length > 0) {
         const specLabel = document.createElement('div');
         specLabel.className = 'cat-label';
-        specLabel.textContent = (filterName || persona.displayName) + '’s specialty';
+        specLabel.textContent = (filterName || persona.displayName) + "'s jobs";
         listWrap.appendChild(specLabel);
         specificJobs.forEach(function(job) { listWrap.appendChild(buildJobRow(av, job, persona)); });
       }
@@ -9189,10 +9400,9 @@ function tfAssignJobToEmployee(employeeKey, job) {
   if (!projectId) { tfCloseAssignJob(); return; }
   if (!tf.assignments[projectId]) tf.assignments[projectId] = [];
   tf.assignments[projectId].push({ id: 'a-' + Date.now(), employeeKey, jobName: job.title || job.id, jobId: job.id });
-  const proj = tf.projects.find((p) => p.id === projectId);
-  if (proj) { proj.team = proj.team || []; if (!proj.team.includes(employeeKey)) proj.team.push(employeeKey); }
+  // No longer mutate a stored project.team: the roster is derived from hired
+  // personas (tfProjectTeamKeys) and every employee is always available.
   tfPersistAssignments();
-  tfPersistProjects();
   tfCloseAssignJob();
   tfRenderTree();
   tfRenderProjectTabs();
@@ -9211,7 +9421,7 @@ function tfOpenAddEmp(preselectKey) {
   const sub = document.getElementById('ae-sub');
   if (!modal || !body) return;
   body.innerHTML = '';
-  const onProject = (tf.projects.find((p) => p.id === tf.activeProjectId) || {}).team || [];
+  const onProject = tfProjectTeamKeys();
   const onProjectPersonas = onProject.map(tfPersonaByKey).filter(Boolean);
   if (onProjectPersonas.length) {
     const label = document.createElement('div');
@@ -9538,19 +9748,15 @@ function tfInitShell() {
   const tabs = document.getElementById('hub-tabs');
   if (tabs) tabs.hidden = false;
   tfLoadStorage();
+  tfMergeProjects(state.bootstrap && Array.isArray(state.bootstrap.projects) ? state.bootstrap.projects : []);
   tfWireShell();
   tfPopulateAccountMenu(); // #533: show the real account identity, not "SM"
   // Seed a project from the loaded folder so the workspace reuses the existing
   // conversation machinery for that real project path.
-  if (state.projectPath && !tf.projects.length) {
-    const proj = {
-      id: 'p-current',
-      name: friendlyProjectName(state.projectPath),
-      intent: '', brief: '', team: tfHiredPersonas().map((p) => p.key), path: state.projectPath,
-    };
-    tf.projects.push(proj);
-    if (!tf.assignments[proj.id]) tf.assignments[proj.id] = [];
-    tf.activeProjectId = proj.id;
+  const currentProject = tfEnsureCurrentProject();
+  if (currentProject && !tf.assignments[currentProject.id]) tf.assignments[currentProject.id] = [];
+  if (currentProject) {
+    tf.activeProjectId = currentProject.id;
     tfPersistProjects();
   } else if (tf.projects.length && !tf.activeProjectId) {
     tf.activeProjectId = tf.projects[0].id;
@@ -9577,6 +9783,9 @@ function tfInitShell() {
 // Refresh shell-derived UI after a bootstrap reload (e.g. project picked).
 function tfRefreshAfterBootstrap() {
   if (!tf.enabled) return;
+  tfMergeProjects(state.bootstrap && Array.isArray(state.bootstrap.projects) ? state.bootstrap.projects : []);
+  tfEnsureCurrentProject();
+  tfPersistProjects();
   tfRenderProjectTabs();
   if (tf.area === 'company') tfRenderCompany();
   else if (tf.area === 'manager') tfRenderManager();

package/public/ai-hub/styles.css

@@ -2915,6 +2915,50 @@ body.hub-shell { display: flex; flex-direction: column; height: 100vh; overflow:
   display: flex;
   flex: 1;
   min-height: 0;
+  position: relative;
+}
+.proj-switch-mask {
+  position: absolute;
+  inset: 0;
+  z-index: 30;
+  display: none;
+  align-items: center;
+  justify-content: center;
+  background: rgba(250, 250, 250, .74);
+  backdrop-filter: blur(2px);
+  pointer-events: auto;
+}
+#proj-workspace.project-switching .proj-switch-mask { display: flex; }
+.proj-switch-panel {
+  display: inline-flex;
+  align-items: center;
+  gap: 10px;
+  min-height: 38px;
+  max-width: min(320px, calc(100vw - 48px));
+  padding: 9px 14px;
+  border: 1px solid var(--line);
+  border-radius: 8px;
+  background: var(--surface);
+  box-shadow: 0 8px 24px rgba(0, 0, 0, .12);
+  color: var(--text);
+  font-size: 13px;
+  font-weight: 600;
+}
+.proj-switch-spinner {
+  width: 16px;
+  height: 16px;
+  border: 2px solid rgba(0, 0, 0, .14);
+  border-top-color: var(--accent);
+  border-radius: 50%;
+  flex: 0 0 auto;
+  animation: proj-switch-spin .8s linear infinite;
+}
+@keyframes proj-switch-spin {
+  to { transform: rotate(360deg); }
+}
+.ptab:disabled {
+  cursor: wait;
+  opacity: .72;
 }
 .tree-sidebar {
   width: var(--tree-sidebar-width);