fraim-hub 2.0.228 → 2.0.231

package/dist/src/ai-hub/conversation-store.js

@@ -757,7 +757,7 @@ class AiHubConversationStore {
     }
     // Update the index header for one conversation and return the (header-shaped) project state.
     reindexAfterUpsert(bucketDir, bucketKey, conv, activeId) {
-        const idx = this.readIndex(bucketDir) ?? { activeId: null, headers: [] };
+        const idx = this.loadIndex(bucketDir, bucketKey);
         const headers = idx.headers.filter((h) => h.id !== conv.id);
         headers.push(toHeader(conv));
         headers.sort(newestFirst);

package/dist/src/ai-hub/custom-employees.js

@@ -0,0 +1,148 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readCustomEmployees = readCustomEmployees;
+exports.writeCustomEmployee = writeCustomEmployee;
+exports.deleteCustomEmployee = deleteCustomEmployee;
+exports.slugifyDisplayName = slugifyDisplayName;
+exports.resolveEmployee = resolveEmployee;
+exports.buildCustomEmployeePersona = buildCustomEmployeePersona;
+// Issue #945: read/write store for user-authored employees, slug utilities,
+// and the display/attribution resolver union.
+//
+// INVARIANT: resolveEmployee is only for display and run attribution.
+// Entitlement reads (isPersonaHireKey, getProtectedPersonaForJob,
+// evaluatePersonaAccess) must never call resolveEmployee.
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const persona_hiring_1 = require("../config/persona-hiring");
+const EMPLOYEES_DIR_REL = path_1.default.join('fraim', 'personalized-employee', 'employees');
+function employeesDir(projectDir) {
+    return path_1.default.join(projectDir, EMPLOYEES_DIR_REL);
+}
+function slugFor(key) {
+    // key is 'custom:<slug>' — file is named '<slug>.json'
+    return key.replace(/^custom:/, '');
+}
+function safeSlug(key) {
+    // Reject keys whose slug component contains path separators or traversal sequences.
+    const slug = slugFor(key);
+    if (!slug || /[/\\]|\.\./.test(slug))
+        return null;
+    return slug;
+}
+function filePath(projectDir, key) {
+    const slug = safeSlug(key);
+    if (!slug)
+        return null;
+    return path_1.default.join(employeesDir(projectDir), `${slug}.json`);
+}
+function readCustomEmployees(projectDir) {
+    const dir = employeesDir(projectDir);
+    if (!fs_1.default.existsSync(dir))
+        return [];
+    const results = [];
+    for (const file of fs_1.default.readdirSync(dir)) {
+        if (!file.endsWith('.json'))
+            continue;
+        try {
+            const raw = fs_1.default.readFileSync(path_1.default.join(dir, file), 'utf8');
+            const parsed = JSON.parse(raw);
+            if (parsed && typeof parsed.key === 'string' && parsed.key.startsWith('custom:')) {
+                results.push(parsed);
+            }
+        }
+        catch {
+            // silently skip malformed files
+        }
+    }
+    return results;
+}
+function writeCustomEmployee(projectDir, employee) {
+    const fp = filePath(projectDir, employee.key);
+    if (!fp)
+        throw new Error(`Invalid employee key: ${employee.key}`);
+    const dir = employeesDir(projectDir);
+    fs_1.default.mkdirSync(dir, { recursive: true });
+    fs_1.default.writeFileSync(fp, JSON.stringify(employee, null, 2), 'utf8');
+}
+function deleteCustomEmployee(projectDir, key) {
+    const fp = filePath(projectDir, key);
+    if (!fp || !fs_1.default.existsSync(fp))
+        return false;
+    fs_1.default.unlinkSync(fp);
+    return true;
+}
+function slugifyDisplayName(displayName, existingKeys = []) {
+    const base = displayName
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        || 'employee';
+    let candidate = `custom:${base}`;
+    if (!existingKeys.includes(candidate))
+        return candidate;
+    let i = 2;
+    while (existingKeys.includes(`${candidate}-${i}`))
+        i++;
+    return `${candidate}-${i}`;
+}
+function resolveEmployee(key, customEmployees) {
+    // Custom: key starts with 'custom:'
+    if (key.startsWith('custom:')) {
+        const emp = customEmployees.find((e) => e.key === key);
+        if (!emp)
+            return null;
+        return {
+            key: emp.key,
+            displayName: emp.displayName,
+            role: emp.role,
+            avatarUrl: buildCustomAvatarUrl(emp),
+            origin: 'custom',
+        };
+    }
+    // Catalog
+    if ((0, persona_hiring_1.isPersonaHireKey)(key)) {
+        const entry = persona_hiring_1.PERSONA_HIRE_CATALOG[key];
+        return {
+            key,
+            displayName: entry.displayName,
+            role: entry.role,
+            avatarUrl: (0, persona_hiring_1.buildPersonaAvatarUrl)(key),
+            origin: 'catalog',
+        };
+    }
+    return null;
+}
+// Converts a CustomEmployee to an AiHubPersona for bootstrap / rail rendering.
+// status is always 'hired' (no lock on custom employees); no hireUrl; no seat accounting.
+// jobIds is included so the UI can scope the delegate picker without a second fetch.
+function buildCustomEmployeePersona(emp) {
+    return {
+        key: emp.key,
+        displayName: emp.displayName,
+        role: emp.role,
+        avatarUrl: buildCustomAvatarUrl(emp),
+        pricingLabel: '',
+        status: 'hired',
+        hireUrl: '',
+        seatCount: 0,
+        seatsInUse: 0,
+        origin: 'custom',
+        jobIds: emp.jobIds,
+    };
+}
+// Builds an avatar URL for a custom employee.
+// - 'emoji': renders a simple letter-based DiceBear avatar seeded on the display name
+// - 'generated': uses the value as the DiceBear seed directly
+// - 'image': returns an empty string (image upload is deferred; caller falls back to icon)
+function buildCustomAvatarUrl(emp) {
+    const { icon, displayName } = emp;
+    if (icon.kind === 'image')
+        return '';
+    const seed = icon.kind === 'generated' ? icon.value : displayName;
+    const params = new URLSearchParams({ seed, backgroundColor: 'e0e7ff', radius: '50' });
+    return `https://api.dicebear.com/9.x/notionists/svg?${params.toString()}`;
+}

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

@@ -683,12 +683,15 @@ const EMPLOYEE_LABELS = {
     claude: 'Claude Code',
     gemini: 'Gemini CLI',
     copilot: 'GitHub Copilot CLI',
+    antigravity: 'Antigravity CLI',
 };
 // GitHub Copilot CLI binary name after `npm install -g @github/copilot`.
 // The @github/copilot package installs a binary named `copilot` on PATH.
 // Note: the package name is @github/copilot (NOT @github/copilot-cli which
 // does not exist on npm). The binary is `copilot` (NOT `github-copilot-cli`).
 const COPILOT_BINARY = 'copilot';
+// Issue #928: agy has no npm package; installed via https://antigravity.google/cli/
+const AGY_BINARY = 'agy';
 const executableName = (command) => command;
 function quoteWindowsArg(value) {
     if (value.length === 0) {
@@ -721,6 +724,8 @@ const availableByVersionProbe = (command) => {
 function agentBinaryName(id) {
     if (id === 'copilot')
         return COPILOT_BINARY;
+    if (id === 'antigravity')
+        return AGY_BINARY;
     return executableName(id);
 }
 function detectEmployees() {
@@ -989,6 +994,18 @@ function buildStartPlan(hostId, message, sessionId) {
             env: browser.env,
         };
     }
+    // Issue #928: agy (Antigravity CLI) is TUI-only — no subprocess/headless mode.
+    // supportsSubprocessStream:false is a capability flag for future Branch A
+    // (subprocess mode). Currently unused by spawnHostProcess; TUI output is
+    // handled gracefully by the antigravity branch in parseHostLine.
+    if (hostId === 'antigravity') {
+        return {
+            command: AGY_BINARY,
+            args: ['--dangerously-skip-permissions'],
+            stdin: transformHeadlessFraimMessage(message, 'start'),
+            supportsSubprocessStream: false,
+        };
+    }
     const browser = sharedBrowserHostConfig('claude');
     return {
         command: executableName('claude'),
@@ -1038,6 +1055,15 @@ function buildContinuePlan(hostId, sessionId, message) {
             env: browser.env,
         };
     }
+    // Issue #928: agy resume uses --conversation <sessionId>.
+    if (hostId === 'antigravity') {
+        return {
+            command: AGY_BINARY,
+            args: ['--dangerously-skip-permissions', '--conversation', sessionId],
+            stdin: transformHeadlessFraimMessage(message, 'continue'),
+            supportsSubprocessStream: false,
+        };
+    }
     const browser = sharedBrowserHostConfig('claude');
     return {
         command: executableName('claude'),
@@ -1097,6 +1123,14 @@ function buildDirectStartPlan(hostId, message, sessionId) {
             stdin: DIRECT_PREAMBLE + message,
         };
     }
+    if (hostId === 'antigravity') {
+        return {
+            command: AGY_BINARY,
+            args: ['--dangerously-skip-permissions'],
+            stdin: DIRECT_PREAMBLE + message,
+            supportsSubprocessStream: false,
+        };
+    }
     return {
         command: executableName('claude'),
         args: [
@@ -1204,6 +1238,11 @@ function parseHostLine(hostId, line) {
             return withSignal({ raw: trimmed });
         }
         catch {
+            // Issue #928: detect IneligibleTierError before other notice checks so
+            // the Hub can surface the Antigravity migration prompt.
+            if (trimmed.startsWith('IneligibleTierError')) {
+                return withSignal({ raw: trimmed, geminiDeprecated: true });
+            }
             if (isGeminiCliNotice(trimmed)) {
                 return withSignal({ raw: trimmed });
             }
@@ -1211,6 +1250,11 @@ function parseHostLine(hostId, line) {
             return withSignal(message ? { message, raw: trimmed } : { raw: trimmed });
         }
     }
+    // Issue #928: antigravity (agy) is TUI-only. Return raw for any line received;
+    // TUI output is not a structured event stream.
+    if (hostId === 'antigravity') {
+        return withSignal({ raw: trimmed });
+    }
     // GitHub Copilot CLI output: JSON stream where each event carries a `type`
     // field. Known event shapes (from the agentic CLI stream):
     //   { "type": "session.started", "session_id": "..." }  — session id
@@ -1441,6 +1485,7 @@ class FakeHostRuntime {
             { id: 'claude', label: 'Claude Code', available: true, detail: 'Test double employee.', supportsRaw: true },
             { id: 'gemini', label: 'Gemini CLI', available: true, detail: 'Test double employee.', supportsRaw: true },
             { id: 'copilot', label: 'GitHub Copilot CLI', available: true, detail: 'Test double agent tool.', supportsRaw: true },
+            { id: 'antigravity', label: 'Antigravity CLI', available: true, detail: 'Test double agent tool.', supportsRaw: false },
         ];
         // Remembered across turns like a resumed agent session: the job label from the
         // start turn. Issue #732 — a same-job continue no longer carries a /fraim <job>
@@ -1531,6 +1576,7 @@ class ScriptedHostRuntime {
             { id: 'claude', label: 'Claude Code', available: true, detail: 'Scripted test double.', supportsRaw: true },
             { id: 'gemini', label: 'Gemini CLI', available: true, detail: 'Scripted test double.', supportsRaw: true },
             { id: 'copilot', label: 'GitHub Copilot CLI', available: true, detail: 'Scripted test double.', supportsRaw: true },
+            { id: 'antigravity', label: 'Antigravity CLI', available: true, detail: 'Scripted test double.', supportsRaw: false },
         ];
         // Track each active run so the test can emit signals at it. The Hub
         // passes the run id as the requested start session id in test/demo paths;

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

@@ -147,7 +147,7 @@ class AiHubPreferencesStore {
             const removedProjectPaths = normalizeRemovedProjectPaths(raw.removedProjectPaths);
             return {
                 projectPath: raw.projectPath || projectPath,
-                employeeId: (raw.employeeId === 'claude' || raw.employeeId === 'codex' || raw.employeeId === 'gemini' || raw.employeeId === 'copilot') ? raw.employeeId : DEFAULT_EMPLOYEE,
+                employeeId: (raw.employeeId === 'claude' || raw.employeeId === 'codex' || raw.employeeId === 'gemini' || raw.employeeId === 'copilot' || raw.employeeId === 'antigravity') ? raw.employeeId : DEFAULT_EMPLOYEE,
                 categoryId: typeof raw.categoryId === 'string' && raw.categoryId.length > 0 ? raw.categoryId : DEFAULT_CATEGORY,
                 recentJobIds: Array.isArray(raw.recentJobIds) ? raw.recentJobIds.filter((value) => typeof value === 'string') : [],
                 recentJobInstructions: (typeof raw.recentJobInstructions === 'object' && raw.recentJobInstructions !== null && !Array.isArray(raw.recentJobInstructions))

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

@@ -51,6 +51,7 @@ const learning_context_builder_1 = require("../local-mcp-server/learning-context
 const brand_store_1 = require("../core/brand-store");
 const project_fraim_paths_1 = require("../core/utils/project-fraim-paths");
 const catalog_1 = require("./catalog");
+const custom_employees_1 = require("./custom-employees");
 const agent_token_prices_1 = require("../local-mcp-server/agent-token-prices");
 const hosts_1 = require("./hosts");
 const configured_agents_1 = require("./configured-agents");
@@ -66,6 +67,7 @@ const org_publish_1 = require("../cli/utils/org-publish");
 const version_utils_1 = require("../cli/utils/version-utils");
 const hub_latest_version_1 = require("./hub-latest-version");
 const semver = __importStar(require("semver"));
+const BOOTSTRAP_PERSONA_FIRST_PAINT_BUDGET_MS = 250;
 let personaHiringModule;
 let managerHiringModule;
 function loadPersonaHiringModule() {
@@ -311,7 +313,7 @@ class AiHubRunRegistry {
     }
 }
 // ─── Issue #578: Deployment + Host stores ─────────────────────────────────────
-const VALID_EMPLOYEE_IDS = ['codex', 'claude', 'gemini', 'copilot'];
+const VALID_EMPLOYEE_IDS = ['codex', 'claude', 'gemini', 'copilot', 'antigravity'];
 const SCHEDULED_FIRE_LEASE_TTL_MS = 2 * 60 * 1000;
 const SCHEDULED_FIRE_LEASE_PRUNE_MS = 7 * 24 * 60 * 60 * 1000;
 function startSessionSeedForHost(hostId, runId) {
@@ -1777,13 +1779,16 @@ class AiHubServer {
         this.managedBrowser.stop();
     }
     getHttpsPort() { return this.httpsPort; }
-    knownProjects(projectPath, extras = []) {
+    knownProjects(projectPath, extras = [], options = {}) {
         // #866 R2: guard against path.resolve('') === cwd. When there is no active
         // project, keep the path empty so no invocation-directory project is injected.
         const activeProjectPath = projectPath || this.projectPath;
         const normalizedProjectPath = activeProjectPath ? path_1.default.resolve(activeProjectPath) : '';
         const preferences = this.preferencesStore.load(normalizedProjectPath);
-        const conversationProjects = this.conversationStore.listProjectPaths().map((folderPath) => ({ folderPath }));
+        const includeConversationProjects = options.includeConversationProjects !== false;
+        const conversationProjects = includeConversationProjects
+            ? this.conversationStore.listProjectPaths().map((folderPath) => ({ folderPath }))
+            : [];
         return (0, preferences_1.normalizeAiHubProjectList)([
             ...(preferences.projects || []),
             ...conversationProjects,
@@ -1825,10 +1830,25 @@ class AiHubServer {
         // Issue #750: the apiKey always comes from ~/.fraim/config.json — no header
         // override, no ai-hub-state.json copy, no fallback chain.
         const resolvedApiKey = resolveApiKey();
-        const { personas, subscriptionActive, workspaceId, userKey } = await this.computePersonas(resolvedApiKey);
-        const managerTeam = await this.computeManagerTeam(resolvedApiKey);
+        const managerTeamPromise = this.computeManagerTeam(resolvedApiKey).catch((err) => {
+            console.warn('[ai-hub] manager-team lookup failed:', err?.message || err);
+            return [];
+        });
+        const personaProjectionPromise = this.computePersonas(resolvedApiKey, managerTeamPromise);
+        const fallbackPersonaProjection = this.fallbackPersonaProjection(resolvedApiKey);
+        const personaProjection = await this.withFirstPaintBudget(personaProjectionPromise, fallbackPersonaProjection, 'persona projection');
+        const managerTeam = personaProjection === fallbackPersonaProjection
+            ? []
+            : await this.withFirstPaintBudget(managerTeamPromise, [], 'manager team');
+        const { personas, subscriptionActive, workspaceId, userKey } = personaProjection;
+        void personaProjectionPromise.catch(() => undefined);
+        void managerTeamPromise.catch(() => undefined);
         const resolvedUserEmail = userKey ?? null;
-        const projects = this.knownProjects(normalizedProjectPath);
+        // Issue #975: do not scan every conversation-store bucket on first paint.
+        // Large long-lived Hub installs can have thousands of buckets; the Projects
+        // API still performs the full merge, and the client refreshes it after the
+        // shell is visible.
+        const projects = this.knownProjects(normalizedProjectPath, [], { includeConversationProjects: false });
         preferences = { ...preferences, projectPath: normalizedProjectPath, projects };
         this.preferencesStore.save(preferences);
         // Issue #347: enrich the activeRun the same way GET /runs/:id does
@@ -1986,11 +2006,15 @@ class AiHubServer {
             ...(run.pauseReason !== undefined && { pauseReason: run.pauseReason }),
             createdAt: run.createdAt,
             lastUpdatedAt,
-            messages: run.messages.map((message) => ({
-                role: message.role,
-                text: message.text,
-                at: Date.parse(message.createdAt) || Date.now(),
-            })),
+            messages: run.messages.map((message) => {
+                const at = Date.parse(message.createdAt);
+                return {
+                    role: message.role,
+                    text: message.text,
+                    createdAt: message.createdAt,
+                    ...(Number.isFinite(at) && at > 0 ? { at } : {}),
+                };
+            }),
             events: run.events.map((event) => ({
                 channel: event.channel,
                 text: event.text,
@@ -2550,19 +2574,9 @@ class AiHubServer {
         const message = (invocationForm ?? (0, manager_turns_1.buildSameJobContinueMessage)(userText)) + (0, manager_turns_1.buildCommunicationStyleNote)();
         return { message, display };
     }
-    async computePersonas(apiKey) {
+    async computePersonas(apiKey, managerTeamPromise) {
         const allBundles = listHubPersonaBundles();
-        const fallbackPersonas = allBundles.map((bundle) => ({
-            key: bundle.personaKey,
-            displayName: bundle.catalogMetadata.displayName,
-            role: bundle.catalogMetadata.role,
-            avatarUrl: buildHubPersonaAvatarUrl(bundle.personaKey),
-            pricingLabel: bundle.catalogMetadata.pricingLabel,
-            status: 'locked',
-            hireUrl: buildHubPersonaHireUrl(bundle.personaKey, bundle.defaultHireMode),
-            seatCount: 0,
-            seatsInUse: 0,
-        }));
+        const fallbackProjection = this.fallbackPersonaProjection(apiKey);
         // Issue #701: persona state comes from the hosted server (GET /api/personas/me)
         // via the user's API key — never a local MongoDB connection. Issue #925: resolve
         // it in a transport-aware way so a transient outage does not collapse to the same
@@ -2579,15 +2593,16 @@ class AiHubServer {
         // (feature-off, legacy bypass, per-entitlement gating) lives solely in
         // persona-entitlement-service.resolvePersonaAccessStatuses — the Hub does not
         // re-derive it.
+        const customPersonas = (0, custom_employees_1.readCustomEmployees)(this.projectPath).map(custom_employees_1.buildCustomEmployeePersona);
         if (!state) {
-            return { personas: fallbackPersonas, subscriptionActive: false, workspaceId: null, userKey };
+            return { ...fallbackProjection, userKey };
         }
         try {
             const verdictByKey = new Map((state.personas || []).map((p) => [p.personaKey, p]));
             // seatsInUse (manager-team assignments) is display-only accounting fetched
             // separately; it is not part of the access verdict.
             const seatsInUseByKey = {};
-            const team = await this.remoteGateway.listManagerTeam(apiKey);
+            const team = managerTeamPromise ? await managerTeamPromise : await this.remoteGateway.listManagerTeam(apiKey);
             for (const entry of team) {
                 seatsInUseByKey[entry.personaKey] = (seatsInUseByKey[entry.personaKey] ?? 0) + 1;
             }
@@ -2604,14 +2619,56 @@ class AiHubServer {
                     hireUrl: buildHubPersonaHireUrl(bundle.personaKey, bundle.defaultHireMode),
                     seatCount: verdict?.seatCount ?? 0,
                     seatsInUse: seatsInUseByKey[bundle.personaKey] ?? 0,
+                    origin: 'catalog',
                 };
             });
-            return { personas, subscriptionActive: state.subscriptionActive, workspaceId: state.workspaceId, userKey };
+            // Issue #945: union custom employees — they are always 'hired' and carry no
+            // entitlement. Custom personas are appended so catalog order is unchanged.
+            return { personas: [...personas, ...customPersonas], subscriptionActive: state.subscriptionActive, workspaceId: state.workspaceId, userKey };
         }
         catch (err) {
             console.error('[ai-hub] persona lookup failed:', err);
             // Keep the (already-resolved) identity even if per-persona accounting fails.
-            return { personas: fallbackPersonas, subscriptionActive: false, workspaceId: null, userKey };
+            return { ...fallbackProjection, userKey };
+        }
+    }
+    fallbackPersonaProjection(apiKey) {
+        const fallbackPersonas = listHubPersonaBundles().map((bundle) => ({
+            key: bundle.personaKey,
+            displayName: bundle.catalogMetadata.displayName,
+            role: bundle.catalogMetadata.role,
+            avatarUrl: buildHubPersonaAvatarUrl(bundle.personaKey),
+            pricingLabel: bundle.catalogMetadata.pricingLabel,
+            status: 'locked',
+            hireUrl: buildHubPersonaHireUrl(bundle.personaKey, bundle.defaultHireMode),
+            seatCount: 0,
+            seatsInUse: 0,
+            origin: 'catalog',
+        }));
+        const customPersonas = (0, custom_employees_1.readCustomEmployees)(this.projectPath).map(custom_employees_1.buildCustomEmployeePersona);
+        return {
+            personas: [...fallbackPersonas, ...customPersonas],
+            subscriptionActive: false,
+            workspaceId: null,
+            userKey: apiKey ? this.lastResolvedIdentityByApiKey.get(apiKey) ?? null : null,
+        };
+    }
+    async withFirstPaintBudget(promise, fallback, label) {
+        let timeout;
+        try {
+            return await Promise.race([
+                promise,
+                new Promise((resolve) => {
+                    timeout = setTimeout(() => {
+                        console.warn(`[ai-hub] bootstrap ${label} exceeded first-paint budget; hydrating after render`);
+                        resolve(fallback);
+                    }, BOOTSTRAP_PERSONA_FIRST_PAINT_BUDGET_MS);
+                }),
+            ]);
+        }
+        finally {
+            if (timeout)
+                clearTimeout(timeout);
         }
     }
     // Issue #925: prefer the transport-aware gateway result when available; fall back to
@@ -2747,6 +2804,29 @@ class AiHubServer {
             // Hub project, not whatever directory happened to launch the process.
             res.json(await this.bootstrapResponse(projectPath || this.defaultProjectPath()));
         });
+        this.app.get('/api/ai-hub/personas', async (req, res) => {
+            const projectPath = typeof req.query.projectPath === 'string' && req.query.projectPath.length > 0
+                ? path_1.default.resolve(req.query.projectPath)
+                : this.defaultProjectPath();
+            const apiKey = resolveApiKey();
+            const managerTeamPromise = this.computeManagerTeam(apiKey).catch((err) => {
+                console.warn('[ai-hub] manager-team lookup failed:', err?.message || err);
+                return [];
+            });
+            const { personas, subscriptionActive, workspaceId, userKey } = await this.computePersonas(apiKey, managerTeamPromise);
+            const managerTeam = await managerTeamPromise;
+            const jobCount = (0, catalog_1.discoverEmployeeJobs)(projectPath, { includeRegistry: true })
+                .filter((job) => !FRAIM_INTERNAL_JOB_IDS.has(job.id))
+                .length;
+            res.json({
+                personas,
+                subscriptionActive,
+                workspaceId,
+                userEmail: userKey ?? null,
+                managerTeam,
+                firstRun: this.computeFirstRun(projectPath, jobCount, personas),
+            });
+        });
         // Issue #512 (S3, R14) — Brain summary as a standalone route, returning the
         // same projection folded into bootstrap. Useful for the avatar→Brain view
         // without re-fetching the whole bootstrap payload.
@@ -2927,19 +3007,30 @@ class AiHubServer {
                     return res.status(400).json({ error: 'projectPath required for project conversations' });
                 }
                 const projectPath = scope ? (0, conversation_store_1.conversationScopeKey)(scope, '') : ensureDirectoryPath(body.projectPath);
-                const patchFields = Object.keys(body).filter((key) => key !== 'projectPath' && key !== 'scope' && key !== 'activeId');
+                const patch = { ...body };
+                delete patch.projectPath;
+                delete patch.scope;
+                delete patch.activeId;
+                const patchFields = Object.keys(patch);
+                let saved = null;
                 if (patchFields.length > 0) {
-                    this.conversationStore.patchConversation(projectPath, req.params.conversationId, body);
+                    saved = this.conversationStore.patchConversation(projectPath, req.params.conversationId, patch);
                 }
                 if (body.activeId !== undefined) {
                     // Body-safe: set activeId via the index, never by rewriting conversation bodies (#820).
-                    this.conversationStore.setActiveId(projectPath, body.activeId);
+                    saved = this.conversationStore.setActiveId(projectPath, body.activeId);
                 }
                 if (patchFields.length === 0 && body.activeId !== undefined) {
                     return res.json({ projectPath, scope: scope ?? 'project', activeId: body.activeId, source: 'disk' });
                 }
-                const loaded = this.conversationStore.loadProject(projectPath);
-                return res.json({ projectPath, ...loaded, source: 'disk' });
+                const conversation = saved?.conversations.find((entry) => entry.id === req.params.conversationId) ?? null;
+                return res.json({
+                    projectPath,
+                    scope: scope ?? 'project',
+                    activeId: saved?.activeId ?? null,
+                    conversation,
+                    source: 'disk',
+                });
             }
             catch (error) {
                 return res.status(400).json({ error: error instanceof Error ? error.message : 'Could not persist conversation.' });
@@ -4452,6 +4543,81 @@ class AiHubServer {
                 return res.status(500).json({ error: msg });
             }
         });
+        // ─── Issue #945: Custom Employee CRUD ────────────────────────────────────
+        // GET /api/ai-hub/custom-employees — list project-scoped custom employees.
+        this.app.get('/api/ai-hub/custom-employees', (req, res) => {
+            const projectPath = req.query.projectPath || this.projectPath;
+            const employees = (0, custom_employees_1.readCustomEmployees)(projectPath);
+            return res.json(employees);
+        });
+        // POST /api/ai-hub/custom-employees — create a new custom employee.
+        this.app.post('/api/ai-hub/custom-employees', (req, res) => {
+            const { projectPath: reqProjectPath, displayName, role, icon, jobIds } = req.body;
+            const projectPath = reqProjectPath || this.projectPath;
+            if (!displayName || typeof displayName !== 'string' || !displayName.trim()) {
+                return res.status(400).json({ error: 'displayName is required.' });
+            }
+            if (!Array.isArray(jobIds) || jobIds.length === 0) {
+                return res.status(400).json({ error: 'jobIds must be a non-empty array.' });
+            }
+            const existing = (0, custom_employees_1.readCustomEmployees)(projectPath).map((e) => e.key);
+            const key = (0, custom_employees_1.slugifyDisplayName)(displayName.trim(), existing);
+            const VALID_ICON_KINDS = new Set(['emoji', 'generated', 'image']);
+            const iconKind = (icon?.kind && VALID_ICON_KINDS.has(icon.kind) ? icon.kind : 'generated');
+            const employee = {
+                key,
+                displayName: displayName.trim(),
+                role: (role ?? '').trim() || 'AI Employee',
+                icon: { kind: iconKind, value: icon?.value ?? displayName.trim() },
+                jobIds,
+                createdBy: '',
+                scope: 'project',
+                createdAt: new Date().toISOString(),
+            };
+            (0, custom_employees_1.writeCustomEmployee)(projectPath, employee);
+            return res.status(201).json(employee);
+        });
+        // PATCH /api/ai-hub/custom-employees/:key — update an existing custom employee.
+        this.app.patch('/api/ai-hub/custom-employees/:key', (req, res) => {
+            const key = decodeURIComponent(req.params.key);
+            if (!key.startsWith('custom:') || /[/\\]|\.\./.test(key.replace(/^custom:/, ''))) {
+                return res.status(400).json({ error: 'Invalid employee key.' });
+            }
+            const projectPath = req.body.projectPath || this.projectPath;
+            const existing = (0, custom_employees_1.readCustomEmployees)(projectPath);
+            const record = existing.find((e) => e.key === key);
+            if (!record) {
+                return res.status(404).json({ error: `Custom employee ${key} not found.` });
+            }
+            const { displayName, role, icon, jobIds } = req.body;
+            const VALID_ICON_KINDS_PATCH = new Set(['emoji', 'generated', 'image']);
+            const patchedIcon = icon !== undefined
+                ? { kind: (VALID_ICON_KINDS_PATCH.has(icon.kind) ? icon.kind : record.icon.kind), value: icon.value ?? record.icon.value }
+                : undefined;
+            const updated = {
+                ...record,
+                ...(displayName !== undefined ? { displayName } : {}),
+                ...(role !== undefined ? { role } : {}),
+                ...(patchedIcon !== undefined ? { icon: patchedIcon } : {}),
+                ...(jobIds !== undefined ? { jobIds } : {}),
+            };
+            (0, custom_employees_1.writeCustomEmployee)(projectPath, updated);
+            return res.json(updated);
+        });
+        // DELETE /api/ai-hub/custom-employees/:key — remove a custom employee.
+        this.app.delete('/api/ai-hub/custom-employees/:key', (req, res) => {
+            const key = decodeURIComponent(req.params.key);
+            if (!key.startsWith('custom:') || /[/\\]|\.\./.test(key.replace(/^custom:/, ''))) {
+                return res.status(400).json({ error: 'Invalid employee key.' });
+            }
+            const projectPath = req.query.projectPath || this.projectPath;
+            const removed = (0, custom_employees_1.deleteCustomEmployee)(projectPath, key);
+            if (!removed) {
+                return res.status(404).json({ error: `Custom employee ${key} not found.` });
+            }
+            return res.json({ key, removed: true });
+        });
+        // ─── End Issue #945 ───────────────────────────────────────────────────────
         // GET /api/ai-hub/hosts — list registered remote hosts with health status.
         this.app.get('/api/ai-hub/hosts', async (_req, res) => {
             const hosts = this.hostConfigStore.load();

package/dist/src/first-run/types.js

@@ -58,6 +58,15 @@ exports.FIRST_RUN_AGENT_OPTIONS = [
         launchCommand: 'copilot',
         installPackage: '@github/copilot',
     },
+    {
+        id: 'antigravity-cli',
+        label: 'Antigravity CLI',
+        detectAliases: ['agy', 'antigravity', 'antigravity-cli'],
+        loginCommand: 'agy auth login',
+        launchCommand: 'agy',
+        // agy has no npm package — install via https://antigravity.google/cli/
+        installPackage: '',
+    },
 ];
 /**
  * The canonical row set, in display order. Each row starts in `pending`;

package/package.json

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