fraim-framework 2.0.184 → 2.0.185

package/dist/src/ai-hub/desktop-main.js

@@ -21,15 +21,6 @@ let isQuitting = false; // distinguishes window-close (→ tray) from app-quit
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
-function tryCreateDbService() {
-    try {
-        const loaded = require('../fraim/db-service');
-        return new loaded.FraimDbService();
-    }
-    catch {
-        return undefined;
-    }
-}
 function preferredWindowSize() {
     const { workAreaSize } = electron_1.screen.getPrimaryDisplay();
     return {
@@ -255,7 +246,8 @@ async function launchDesktopShell(options) {
     const certBundle = await (0, cert_store_1.loadOrCreateCert)();
     server = new server_1.AiHubServer({
         projectPath: options.projectPath,
-        dbService: tryCreateDbService(),
+        // Issue #701: no local DB. Persona/manager-team state resolves through the hosted
+        // server via the Hub's default remote gateway (authenticated by the user's API key).
         httpsPort,
         certBundle,
         folderPicker: async () => {

package/dist/src/ai-hub/remote-hub-gateway.js

@@ -0,0 +1,88 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpHubRemoteGateway = void 0;
+exports.resolveFraimRemoteUrl = resolveFraimRemoteUrl;
+const axios_1 = __importDefault(require("axios"));
+function resolveFraimRemoteUrl(explicit) {
+    return (explicit || process.env.FRAIM_REMOTE_URL || 'https://fraim.wellnessatwork.me').replace(/\/+$/, '');
+}
+/**
+ * Default HTTP-backed gateway. Mirrors the ProviderClient axios pattern:
+ * base URL from FRAIM_REMOTE_URL, `x-api-key` auth header, 10s timeout.
+ */
+class HttpHubRemoteGateway {
+    constructor(serverUrl) {
+        this.baseURL = resolveFraimRemoteUrl(serverUrl);
+    }
+    client(apiKey) {
+        return axios_1.default.create({
+            baseURL: this.baseURL,
+            headers: { 'x-api-key': apiKey, 'Content-Type': 'application/json' },
+            timeout: 10000,
+        });
+    }
+    async getPersonaState(apiKey) {
+        if (!apiKey)
+            return null;
+        try {
+            const res = await this.client(apiKey).get('/api/personas/me');
+            return res.data;
+        }
+        catch (err) {
+            // 401 (no/expired key) or 404 (feature disabled) => treat as "no state" so the Hub
+            // renders a clean locked/not-signed-in view instead of crashing.
+            const status = err?.response?.status;
+            if (status === 401 || status === 404)
+                return null;
+            console.warn('[ai-hub] getPersonaState failed:', err?.message || err);
+            return null;
+        }
+    }
+    async listManagerTeam(apiKey) {
+        if (!apiKey)
+            return [];
+        try {
+            const res = await this.client(apiKey).get('/api/ai-hub/manager-team');
+            const team = (res.data?.team ?? []);
+            return Array.isArray(team) ? team : [];
+        }
+        catch (err) {
+            const status = err?.response?.status;
+            if (status === 401 || status === 404)
+                return [];
+            console.warn('[ai-hub] listManagerTeam failed:', err?.message || err);
+            return [];
+        }
+    }
+    async assignManagerTeam(apiKey, personaKey) {
+        if (!apiKey)
+            return { status: 401, body: { error: 'authentication_required' } };
+        try {
+            const res = await this.client(apiKey).post('/api/ai-hub/manager-team/assign', { personaKey });
+            return { status: res.status, body: res.data };
+        }
+        catch (err) {
+            if (err?.response)
+                return { status: err.response.status, body: err.response.data };
+            console.warn('[ai-hub] assignManagerTeam failed:', err?.message || err);
+            return { status: 500, body: { error: 'internal_error' } };
+        }
+    }
+    async removeManagerTeam(apiKey, personaKey) {
+        if (!apiKey)
+            return;
+        try {
+            await this.client(apiKey).delete(`/api/ai-hub/manager-team/assign/${encodeURIComponent(personaKey)}`);
+        }
+        catch (err) {
+            const status = err?.response?.status;
+            if (status === 401 || status === 404)
+                return;
+            console.warn('[ai-hub] removeManagerTeam failed:', err?.message || err);
+        }
+    }
+}
+exports.HttpHubRemoteGateway = HttpHubRemoteGateway;

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

@@ -56,6 +56,7 @@ const hosts_1 = require("./hosts");
 const manager_turns_1 = require("./manager-turns");
 const preferences_1 = require("./preferences");
 const conversation_store_1 = require("./conversation-store");
+const remote_hub_gateway_1 = require("./remote-hub-gateway");
 const managed_browser_1 = require("./managed-browser");
 const managed_agent_paths_1 = require("../cli/utils/managed-agent-paths");
 let personaHiringModule;
@@ -137,29 +138,6 @@ function buildHubManagerHiringCatalog() {
         roles: {},
     };
 }
-async function getHubWorkspacePersonaState(dbService, userId, apiKey) {
-    try {
-        // eslint-disable-next-line @typescript-eslint/no-var-requires
-        const service = require('../services/persona-entitlement-service');
-        return await service.getWorkspacePersonaState(dbService, userId, apiKey);
-    }
-    catch {
-        return null;
-    }
-}
-function createDefaultDbService() {
-    try {
-        // eslint-disable-next-line @typescript-eslint/no-var-requires
-        const { FraimDbService } = require('../fraim/db-service');
-        return new FraimDbService();
-    }
-    catch {
-        return undefined;
-    }
-}
-function supportsManagerSeatAssignments(dbService) {
-    return typeof dbService.countHubManagerAssignments === 'function';
-}
 class AiHubRunRegistry {
     constructor() {
         this.runs = new Map();
@@ -398,19 +376,22 @@ function normalizeReviewHandoff(raw) {
         const url = safeHttpUrl(rawTarget?.url);
         if (!url)
             return null;
+        if (artifacts.length > 0)
+            return null;
         return {
             reviewRequired: true,
             reviewTarget: { type: 'pull_request', label: targetLabel || 'Pull request', url },
-            artifacts,
+            artifacts: [],
             summary: typeof value.summary === 'string' ? value.summary.trim() : '',
             feedbackMode: typeof value.feedbackMode === 'string' ? value.feedbackMode.trim() : 'pull_request_comments',
         };
     }
-    if (targetType === 'artifact_set' && artifacts.length > 0) {
+    const fileArtifacts = artifacts.filter((artifact) => artifact.path && !artifact.url);
+    if (targetType === 'artifact_set' && fileArtifacts.length > 0 && fileArtifacts.length === artifacts.length) {
         return {
             reviewRequired: true,
             reviewTarget: { type: 'artifact_set', label: targetLabel || `${artifacts.length} artifact${artifacts.length === 1 ? '' : 's'}` },
-            artifacts,
+            artifacts: fileArtifacts,
             summary: typeof value.summary === 'string' ? value.summary.trim() : '',
             feedbackMode: typeof value.feedbackMode === 'string' ? value.feedbackMode.trim() : 'inline',
         };
@@ -573,31 +554,6 @@ function extractDelegationLedgerFromText(text) {
     }
     return null;
 }
-const ARTIFACT_EXCLUDE_RE = /(^|[\\/])(retrospectives|evidence|learnings|mocks|raw|archive)[\\/]/i;
-function extractReviewArtifactsFromText(text, projectPath) {
-    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 relativePath = candidate.replace(/[.)]+$/g, '').replace(/\\/g, '/');
-        if (!/\.[A-Za-z0-9]+$/.test(relativePath))
-            continue;
-        if (ARTIFACT_EXCLUDE_RE.test(relativePath))
-            continue;
-        const parts = relativePath.split('/').filter(Boolean);
-        const name = parts[parts.length - 1] || relativePath;
-        const artifactPath = path_1.default.isAbsolute(relativePath) ? relativePath : path_1.default.join(projectPath, relativePath);
-        if (seen.has(artifactPath))
-            continue;
-        seen.add(artifactPath);
-        artifacts.push({ type: path_1.default.extname(name).replace(/^\./, '') || 'file', label: name, path: artifactPath });
-    }
-    return artifacts;
-}
 function applyReviewProjection(run, text) {
     const delegation = extractDelegationLedgerFromText(text);
     if (delegation) {
@@ -610,41 +566,9 @@ function applyReviewProjection(run, text) {
     const handoff = extractReviewHandoffFromText(text);
     if (handoff) {
         run.reviewHandoff = handoff;
-        run.artifacts = handoff.artifacts;
+        run.artifacts = handoff.reviewTarget?.type === 'artifact_set' ? handoff.artifacts : [];
         return;
     }
-    const artifacts = extractReviewArtifactsFromText(text, run.projectPath);
-    if (!artifacts.length)
-        return;
-    run.artifacts = run.artifacts || [];
-    for (const artifact of artifacts) {
-        if (!run.artifacts.some((entry) => (entry.path && artifact.path && entry.path === artifact.path) || (entry.url && artifact.url && entry.url === artifact.url))) {
-            run.artifacts.push(artifact);
-        }
-    }
-}
-function mergeReviewArtifacts(existing, discovered) {
-    const merged = [...(existing || [])];
-    for (const artifact of discovered) {
-        if (!merged.some((entry) => (entry.path && artifact.path && entry.path === artifact.path) || (entry.url && artifact.url && entry.url === artifact.url))) {
-            merged.push(artifact);
-        }
-    }
-    return merged;
-}
-function extractRunReviewArtifacts(run) {
-    const discovered = [];
-    for (const message of run.messages || []) {
-        if (message.role !== 'employee')
-            continue;
-        discovered.push(...extractReviewArtifactsFromText(message.text, run.projectPath));
-    }
-    for (const event of run.events || []) {
-        if (event.channel !== 'stdout')
-            continue;
-        discovered.push(...extractReviewArtifactsFromText(event.text, run.projectPath));
-    }
-    return mergeReviewArtifacts(run.artifacts, discovered);
 }
 function emptyTotals() {
     return {
@@ -750,8 +674,13 @@ function applySeekMentoringSignal(run, signal) {
     const callJobId = signal.jobId || signal.jobName;
     if (callJobId && targetJobId && callJobId !== targetJobId)
         return;
-    if (signal.reviewHandoff)
-        run.reviewHandoff = signal.reviewHandoff;
+    if (signal.reviewHandoff) {
+        const normalizedReviewHandoff = normalizeReviewHandoff(signal.reviewHandoff);
+        run.reviewHandoff = normalizedReviewHandoff || signal.reviewHandoff;
+        run.artifacts = normalizedReviewHandoff?.reviewTarget?.type === 'artifact_set'
+            ? normalizedReviewHandoff.artifacts
+            : [];
+    }
     if (signal.delegationLedger &&
         run.jobId === 'fully-delegate' &&
         signal.phaseStatus === 'complete' &&
@@ -1154,14 +1083,14 @@ class AiHubServer {
             explicitPath: process.env.FRAIM_BROWSER_PATH || undefined,
         });
         this.hostRuntime = options.hostRuntime || (process.env.FRAIM_AI_HUB_FAKE_HOST === '1' ? new hosts_1.FakeHostRuntime() : new hosts_1.CliHostRuntime());
-        if (options.dbService !== undefined) {
-            this.dbService = options.dbService;
-            this.ownsDbService = false;
-        }
-        else {
-            this.dbService = createDefaultDbService();
-            this.ownsDbService = this.dbService !== undefined;
-        }
+        // Issue #701: the AI Hub is a loopback companion that never touches MongoDB directly —
+        // on every machine (dev, CI, prod) it resolves persona/manager-team state from the hosted
+        // server through the same code path. The hosted server is the sole owner of DB access.
+        // A dbService is used ONLY when explicitly injected (e.g. the hosted server embedding the
+        // Hub, or a test); it is never auto-created, so there is no dev/prod divergence.
+        this.dbService = options.dbService;
+        this.ownsDbService = false;
+        this.remoteGateway = options.remoteGateway ?? new remote_hub_gateway_1.HttpHubRemoteGateway();
         this.deploymentStore = options.deploymentStore ?? new DeploymentStore();
         this.hostConfigStore = options.hostConfigStore ?? new HostConfigStore();
         this.app.use(express_1.default.json({ limit: '10mb' }));
@@ -1429,8 +1358,9 @@ class AiHubServer {
             requiredPersonaKey: getProtectedPersonaForHubJob(job.id),
         }));
         const managerTemplates = (0, catalog_1.discoverManagerTemplates)(normalizedProjectPath, catalogOptions);
-        const { personas, subscriptionActive, workspaceId, userKey } = await this.computePersonas(apiKey || preferences.apiKey);
-        const managerTeam = await this.computeManagerTeam(workspaceId, userKey);
+        const resolvedApiKey = apiKey || preferences.apiKey;
+        const { personas, subscriptionActive, workspaceId, userKey } = await this.computePersonas(resolvedApiKey);
+        const managerTeam = await this.computeManagerTeam(resolvedApiKey);
         const projects = this.knownProjects(normalizedProjectPath);
         preferences = { ...preferences, projectPath: normalizedProjectPath, projects };
         this.preferencesStore.save(preferences);
@@ -1906,18 +1836,18 @@ class AiHubServer {
             seatCount: 0,
             seatsInUse: 0,
         }));
-        if (!this.dbService) {
-            return { personas: fallbackPersonas, subscriptionActive: false, workspaceId: null, userKey: null };
-        }
         try {
-            const state = await getHubWorkspacePersonaState(this.dbService, getHubUserEmail(), 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. A null result means
+            // no/expired key or the feature is off; render the locked fallback (not-signed-in).
+            const state = await this.remoteGateway.getPersonaState(apiKey);
             if (!state) {
                 return { personas: fallbackPersonas, subscriptionActive: false, workspaceId: null, userKey: null };
             }
             // Legacy bypass: persona gating is not active for this workspace, so all personas are accessible.
             // Mirrors the evaluatePersonaAccess legacy bypass in persona-entitlement-service.ts.
+            // Seats are not assignable on legacy workspaces (the hosted server is always DB-backed).
             if (!state.subscriptionActive) {
-                const legacySeatCount = supportsManagerSeatAssignments(this.dbService) ? 0 : 1;
                 const allPersonas = allBundles.map((bundle) => ({
                     key: bundle.personaKey,
                     displayName: bundle.catalogMetadata.displayName,
@@ -1926,7 +1856,7 @@ class AiHubServer {
                     pricingLabel: '',
                     status: 'hired',
                     hireUrl: buildHubPersonaHireUrl(bundle.personaKey, bundle.defaultHireMode),
-                    seatCount: legacySeatCount,
+                    seatCount: 0,
                     seatsInUse: 0,
                 }));
                 return { personas: allPersonas, subscriptionActive: false, workspaceId: state.workspaceId, userKey: state.userId ?? null };
@@ -1942,13 +1872,13 @@ class AiHubServer {
                     seatCountByKey[e.personaKey] = (seatCountByKey[e.personaKey] ?? 0) + (e.jobCreditsRemaining ?? 1);
                 }
             }
-            // seatsInUse is the count of manager-assignment rows for this workspace/persona.
-            const workspaceId = state.workspaceId;
+            // seatsInUse for display: derived from the hosted manager team. Authoritative
+            // out-of-stock enforcement lives on the hosted assign endpoint (server-side),
+            // so this display count does not need to be workspace-wide.
             const seatsInUseByKey = {};
-            if (this.dbService) {
-                await Promise.all(Object.keys(seatCountByKey).map(async (pKey) => {
-                    seatsInUseByKey[pKey] = await this.dbService.countHubManagerAssignments(workspaceId, pKey);
-                }));
+            const team = await this.remoteGateway.listManagerTeam(apiKey);
+            for (const entry of team) {
+                seatsInUseByKey[entry.personaKey] = (seatsInUseByKey[entry.personaKey] ?? 0) + 1;
             }
             const personas = allBundles.map((bundle) => ({
                 key: bundle.personaKey,
@@ -1961,23 +1891,16 @@ class AiHubServer {
                 seatCount: seatCountByKey[bundle.personaKey] ?? 0,
                 seatsInUse: seatsInUseByKey[bundle.personaKey] ?? 0,
             }));
-            return { personas, subscriptionActive: state.subscriptionActive, workspaceId, userKey: state.userId ?? null };
+            return { personas, subscriptionActive: state.subscriptionActive, workspaceId: state.workspaceId, userKey: state.userId ?? null };
         }
         catch (err) {
-            console.error('[ai-hub] persona entitlement lookup failed:', err);
+            console.error('[ai-hub] persona lookup failed:', err);
             return { personas: fallbackPersonas, subscriptionActive: false, workspaceId: null, userKey: null };
         }
     }
-    async computeManagerTeam(workspaceId, userKey) {
-        if (!workspaceId || !userKey || !this.dbService)
-            return [];
-        try {
-            const rows = await this.dbService.getHubManagerAssignments(workspaceId, userKey);
-            return rows.map((r) => ({ personaKey: r.personaKey, assignedAt: r.assignedAt.toISOString() }));
-        }
-        catch {
-            return [];
-        }
+    async computeManagerTeam(apiKey) {
+        // Issue #701: manager team comes from the hosted server, not local Mongo.
+        return this.remoteGateway.listManagerTeam(apiKey);
     }
     registerRoutes() {
         // Issue #512: Serve the account and analytics pages from public/.
@@ -2121,57 +2044,25 @@ class AiHubServer {
                 return res.status(400).json({ error: error instanceof Error ? error.message : 'Could not write learning.' });
             }
         });
-        // Issue #540: POST /api/ai-hub/manager-team/assign
-        // Assigns a persona to the authenticated manager's team (uses X-Fraim-Api-Key header).
-        // Returns 404 {error:'no_company_seat'} when the workspace has purchased no seats for the persona.
-        // Returns 409 {error:'out_of_stock'} when all company seats are already assigned to other managers.
+        // Issue #540/#701: POST /api/ai-hub/manager-team/assign
+        // Proxies to the hosted server (which owns the DB + seat enforcement). The Hub
+        // accepts the local X-Fraim-Api-Key header and forwards it as the hosted x-api-key.
+        // Hosted returns 404 no_company_seat / 409 out_of_stock; those are passed through.
         this.app.post('/api/ai-hub/manager-team/assign', async (req, res) => {
             const apiKey = typeof req.headers['x-fraim-api-key'] === 'string' ? req.headers['x-fraim-api-key'] : undefined;
             const { personaKey } = (req.body ?? {});
             if (!personaKey)
                 return res.status(400).json({ error: 'personaKey required' });
-            if (!this.dbService) {
-                return res.status(404).json({ error: 'no_company_seat', personaKey });
-            }
-            try {
-                const { workspaceId, userKey, personas } = await this.computePersonas(apiKey);
-                if (!workspaceId || !userKey) {
-                    return res.status(404).json({ error: 'no_company_seat', personaKey });
-                }
-                const persona = personas.find((p) => p.key === personaKey);
-                if (!persona || persona.seatCount === 0) {
-                    return res.status(404).json({ error: 'no_company_seat', personaKey });
-                }
-                if (persona.seatsInUse >= persona.seatCount) {
-                    return res.status(409).json({ error: 'out_of_stock', personaKey, seatCount: persona.seatCount });
-                }
-                await this.dbService.addHubManagerAssignment(workspaceId, userKey, personaKey);
-                const team = await this.computeManagerTeam(workspaceId, userKey);
-                return res.json({ managerTeam: team });
-            }
-            catch (err) {
-                console.error('[ai-hub] assign manager seat failed:', err);
-                return res.status(500).json({ error: 'internal_error' });
-            }
+            const result = await this.remoteGateway.assignManagerTeam(apiKey, personaKey);
+            return res.status(result.status).json(result.body);
         });
-        // Issue #540: DELETE /api/ai-hub/manager-team/assign/:personaKey
-        // Removes a persona from the authenticated manager's team.
+        // Issue #540/#701: DELETE /api/ai-hub/manager-team/assign/:personaKey
+        // Proxies the seat release to the hosted server.
         this.app.delete('/api/ai-hub/manager-team/assign/:personaKey', async (req, res) => {
             const apiKey = typeof req.headers['x-fraim-api-key'] === 'string' ? req.headers['x-fraim-api-key'] : undefined;
             const { personaKey } = req.params;
-            if (!this.dbService)
-                return res.status(204).end();
-            try {
-                const { workspaceId, userKey } = await this.computePersonas(apiKey);
-                if (workspaceId && userKey) {
-                    await this.dbService.removeHubManagerAssignment(workspaceId, userKey, personaKey);
-                }
-                return res.status(204).end();
-            }
-            catch (err) {
-                console.error('[ai-hub] remove manager seat failed:', err);
-                return res.status(500).json({ error: 'internal_error' });
-            }
+            await this.remoteGateway.removeManagerTeam(apiKey, personaKey);
+            return res.status(204).end();
         });
         this.app.get('/api/ai-hub/conversations', (req, res) => {
             const projectPath = typeof req.query.projectPath === 'string' && req.query.projectPath.length > 0
@@ -3435,7 +3326,7 @@ class AiHubServer {
                 liveTotals.waitingDurationMs = Math.max(0, liveTotals.waitingDurationMs - overflow);
             }
         }
-        return { ...run, stages, totals: liveTotals, artifacts: extractRunReviewArtifacts(run) };
+        return { ...run, stages, totals: liveTotals, artifacts: run.artifacts || [] };
     }
 }
 exports.AiHubServer = AiHubServer;

package/dist/src/api/ai-hub/manager-team.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getManagerTeamFor = getManagerTeamFor;
+exports.assignManagerSeatFor = assignManagerSeatFor;
+exports.removeManagerSeatFor = removeManagerSeatFor;
+exports.listManagerTeam = listManagerTeam;
+exports.assignManagerTeam = assignManagerTeam;
+exports.removeManagerTeam = removeManagerTeam;
+const persona_entitlement_service_1 = require("../../services/persona-entitlement-service");
+async function loadTeam(dbService, workspaceId, userKey) {
+    const rows = await dbService.getHubManagerAssignments(workspaceId, userKey);
+    return rows.map((r) => ({ personaKey: r.personaKey, assignedAt: r.assignedAt.toISOString() }));
+}
+/** Seats purchased for a persona in this workspace. Mirrors computePersonas' seatCountByKey:
+ *  legacy (unsubscribed) workspaces have no assignable seats. */
+function seatCountForPersona(state, personaKey) {
+    if (!state.subscriptionActive)
+        return 0;
+    return state.entitlements
+        .filter((e) => e.personaKey === personaKey && e.status === 'active')
+        .reduce((sum, e) => sum + (e.jobCreditsRemaining ?? 1), 0);
+}
+// ── Core operations (shared by hosted handlers and the Hub's local-DB gateway) ──────
+async function getManagerTeamFor(dbService, userId, apiKey) {
+    const state = await (0, persona_entitlement_service_1.getWorkspacePersonaState)(dbService, userId, apiKey);
+    return loadTeam(dbService, state.workspaceId, state.userId);
+}
+async function assignManagerSeatFor(dbService, userId, apiKey, personaKey) {
+    const state = await (0, persona_entitlement_service_1.getWorkspacePersonaState)(dbService, userId, apiKey);
+    const seatCount = seatCountForPersona(state, personaKey);
+    if (seatCount === 0)
+        return { status: 404, body: { error: 'no_company_seat', personaKey } };
+    const seatsInUse = await dbService.countHubManagerAssignments(state.workspaceId, personaKey);
+    if (seatsInUse >= seatCount)
+        return { status: 409, body: { error: 'out_of_stock', personaKey, seatCount } };
+    await dbService.addHubManagerAssignment(state.workspaceId, state.userId, personaKey);
+    return { status: 200, body: { managerTeam: await loadTeam(dbService, state.workspaceId, state.userId) } };
+}
+async function removeManagerSeatFor(dbService, userId, apiKey, personaKey) {
+    const state = await (0, persona_entitlement_service_1.getWorkspacePersonaState)(dbService, userId, apiKey);
+    await dbService.removeHubManagerAssignment(state.workspaceId, state.userId, personaKey);
+}
+// ── Hosted HTTP handlers (thin wrappers over the core, authed via req.apiKeyData) ───
+async function listManagerTeam(req, res, dbService) {
+    const apiKeyData = req.apiKeyData;
+    if (!apiKeyData?.userId) {
+        res.status(401).json({ error: 'Authentication required' });
+        return;
+    }
+    try {
+        res.json({ team: await getManagerTeamFor(dbService, apiKeyData.userId, apiKeyData.key) });
+    }
+    catch (error) {
+        console.error('[api] listManagerTeam failed:', error);
+        res.status(500).json({ error: 'internal_error', details: error?.message || String(error) });
+    }
+}
+async function assignManagerTeam(req, res, dbService) {
+    const apiKeyData = req.apiKeyData;
+    if (!apiKeyData?.userId) {
+        res.status(401).json({ error: 'Authentication required' });
+        return;
+    }
+    const { personaKey } = (req.body ?? {});
+    if (!personaKey) {
+        res.status(400).json({ error: 'personaKey required' });
+        return;
+    }
+    try {
+        const result = await assignManagerSeatFor(dbService, apiKeyData.userId, apiKeyData.key, personaKey);
+        res.status(result.status).json(result.body);
+    }
+    catch (error) {
+        console.error('[api] assignManagerTeam failed:', error);
+        res.status(500).json({ error: 'internal_error', details: error?.message || String(error) });
+    }
+}
+async function removeManagerTeam(req, res, dbService) {
+    const apiKeyData = req.apiKeyData;
+    if (!apiKeyData?.userId) {
+        res.status(401).json({ error: 'Authentication required' });
+        return;
+    }
+    const personaKey = String(req.params.personaKey ?? '');
+    try {
+        await removeManagerSeatFor(dbService, apiKeyData.userId, apiKeyData.key, personaKey);
+        res.status(204).end();
+    }
+    catch (error) {
+        console.error('[api] removeManagerTeam failed:', error);
+        res.status(500).json({ error: 'internal_error', details: error?.message || String(error) });
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fraim-framework",
-  "version": "2.0.184",
+  "version": "2.0.185",
   "description": "FRAIM: AI Workforce Infrastructure — the organizational capability that turns AI agents into an accountable workforce, their operators into capable AI managers, and executives into leaders with clear optics on AI proficiency.",
   "main": "index.js",
   "bin": {