fraim-hub 2.0.348 → 2.0.350

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

@@ -213,6 +213,7 @@ function summarizeProject(projectPath) {
             path: '',
             exists: false,
             hasFraim: false,
+            isOnboarded: false,
             message: 'Choose a project path to load FRAIM jobs.',
         };
     }
@@ -221,17 +222,20 @@ function summarizeProject(projectPath) {
             path: projectPath,
             exists: false,
             hasFraim: false,
+            isOnboarded: (0, project_fraim_paths_1.workspaceOnboardingReady)(projectPath),
             message: 'Project path does not exist on this machine.',
         };
     }
     const fraimDir = (0, project_fraim_paths_1.getWorkspaceFraimDir)(projectPath);
     const hasFraim = fs_1.default.existsSync(fraimDir);
+    const isOnboarded = (0, project_fraim_paths_1.workspaceOnboardingReady)(projectPath);
     if (!hasFraim) {
         return {
             path: projectPath,
             exists: true,
             hasFraim: false,
-            needsOnboarding: true,
+            isOnboarded,
+            needsOnboarding: isOnboarded === false,
             message: 'This folder has not been set up with FRAIM yet. Onboarding will get your AI employee started.',
         };
     }
@@ -239,6 +243,8 @@ function summarizeProject(projectPath) {
         path: projectPath,
         exists: true,
         hasFraim: true,
+        isOnboarded,
+        needsOnboarding: isOnboarded === false,
     };
 }
 function resolveLayerRoot(projectPath, layer) {

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

@@ -2398,29 +2398,63 @@ function detectCodexCompactTaskFailure(line) {
     }
     return null;
 }
+const CODEX_PERMANENT_REFRESH_FAILURES = new Set([
+    'Your access token could not be refreshed because your refresh token was already used. Please log out and sign in again.',
+    'Your access token could not be refreshed because your refresh token has expired. Please log out and sign in again.',
+    'Your access token could not be refreshed because your refresh token was revoked. Please log out and sign in again.',
+    'Your access token could not be refreshed. Please log out and sign in again.',
+    'Your access token could not be refreshed because you have since logged out or signed in to another account. Please sign in again.',
+]);
+// Exec has no typed auth code. Scope transport 401s to Codex's own OpenAI
+// Responses endpoints; tools, MCP servers and custom relays can also return 401.
+function isCodexProviderAuthFailure(message) {
+    if (typeof message !== 'string')
+        return false;
+    if (message === 'workspace routing discovery unauthorized (401)')
+        return true;
+    const transport = /^unexpected status 401 Unauthorized: [\s\S]*?, url: ([^\s,]+)(?:, [\s\S]*)?$/.exec(message);
+    if (!transport)
+        return false;
+    try {
+        const endpoint = new URL(transport[1]);
+        if (!['https:', 'wss:'].includes(endpoint.protocol) || endpoint.username || endpoint.password || endpoint.port || endpoint.hash)
+            return false;
+        const responsePath = endpoint.hostname === 'api.openai.com' ? '/v1/responses'
+            : endpoint.hostname === 'chatgpt.com' ? '/backend-api/codex/responses' : null;
+        return responsePath !== null && (endpoint.pathname === responsePath || endpoint.pathname === `${responsePath}/compact`);
+    }
+    catch {
+        return false;
+    }
+}
 function wireHostProcess(hostId, child, handlers, spawnCwd) {
-    // Exec's JSON error has no auth code. Require independent provider stderr
-    // provenance AND the same terminal protocol error; never scan tool/prose text.
-    const codexRefreshFailure = 'Your access token could not be refreshed because your refresh token was already used. Please log out and sign in again.';
-    let codexAuthDiagnostic = false;
-    let codexTerminalAuthFailure = false;
+    // Refresh failures need matching auth-manager stderr. Provider 401s need a
+    // terminal turn.failed. Both require normal failed exit; never scan prose.
+    const codexAuthDiagnostics = new Set();
+    let codexTerminalRefreshFailure = null;
+    let codexTerminalProviderFailure = null;
     const observeCodexAuth = (line, channel) => {
         if (hostId !== 'codex')
             return;
         if (channel === 'stderr') {
             const clean = line.replace(/\x1b\[[0-9;]*m/g, '').trim();
             const diagnostic = clean.match(/^(?:\d{4}-\d{2}-\d{2}T[\d:.]+Z\s+)?ERROR\s+codex_login::auth::manager:\s+Failed to refresh token: (.+)$/);
-            if (diagnostic?.[1] === codexRefreshFailure)
-                codexAuthDiagnostic = true;
+            if (diagnostic && CODEX_PERMANENT_REFRESH_FAILURES.has(diagnostic[1]))
+                codexAuthDiagnostics.add(diagnostic[1]);
             return;
         }
         try {
             const event = JSON.parse(line);
+            if (event.type === 'turn.failed') {
+                codexTerminalProviderFailure = isCodexProviderAuthFailure(event.error?.message) ? event.error.message : null;
+            }
             if (event.type === 'turn.failed' || event.type === 'error') {
-                codexTerminalAuthFailure = (event.type === 'turn.failed' ? event.error?.message : event.message) === codexRefreshFailure;
+                const message = event.type === 'turn.failed' ? event.error?.message : event.message;
+                codexTerminalRefreshFailure = CODEX_PERMANENT_REFRESH_FAILURES.has(message) ? message : null;
             }
             else if (event.type === 'turn.started' || event.type === 'turn.completed') {
-                codexTerminalAuthFailure = false;
+                codexTerminalRefreshFailure = null;
+                codexTerminalProviderFailure = null;
             }
         }
         catch { /* Plain stdout cannot establish authentication failure. */ }
@@ -2474,8 +2508,9 @@ function wireHostProcess(hostId, child, handlers, spawnCwd) {
     // `exitCode ?? 0` guard. Pass -1 for any signal-terminated child so the
     // non-zero branch fires and recovery is attempted.
     child.on('close', (code, signal) => {
-        if (!signal && code !== null && code !== 0 && codexAuthDiagnostic && codexTerminalAuthFailure) {
-            handlers.onEvent({ hostAuthenticationRequired: true, hostError: codexRefreshFailure, raw: codexRefreshFailure }, 'system');
+        const failure = codexTerminalProviderFailure || (codexTerminalRefreshFailure && codexAuthDiagnostics.has(codexTerminalRefreshFailure) ? codexTerminalRefreshFailure : null);
+        if (!signal && code !== null && code !== 0 && failure) {
+            handlers.onEvent({ hostAuthenticationRequired: true, hostError: failure, raw: failure }, 'system');
         }
         handlers.onExit(signal ? -1 : code);
     });

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

@@ -383,20 +383,21 @@ function directoryExists(projectPath) {
 // project list. This deliberately never falls back to process.cwd() — the launch
 // directory must not masquerade as a project.
 //
-// Issue #1253: existence alone is not validity. Eligibility is a positive rule —
-// a recorded path qualifies only if it IS a FRAIM project. The temp/Home/Desktop/
-// Downloads filters narrow that rule further; they do not define it. Framing
-// eligibility as an exclusion list is what let C:\Windows stay pinned forever:
-// it was simply not on the list, and such a list is unbounded by construction.
+// A recorded folder must be a discoverable FRAIM project or a deliberately added
+// project list entry. The latter remains selectable before onboarding (#2039).
+// Existing temporary/Home/Desktop/Downloads safeguards still apply; a stale bare
+// recorded path is not enough to turn an arbitrary directory into a project.
 function resolveHubProjectPath(preferencesStore, options = {}) {
-    const recorded = preferencesStore.load('').projectPath;
+    const preferences = preferencesStore.load('');
+    const recorded = preferences.projectPath;
     if (typeof recorded === 'string' && recorded.trim().length > 0) {
         const resolved = path_1.default.resolve(recorded);
         const allowedTemporary = options.allowTemporaryRelatedTo
             ? isRelatedTemporaryProjectPath(resolved, options.allowTemporaryRelatedTo)
             : false;
         if (!isLikelyTemporaryProjectPath(resolved) || allowedTemporary) {
-            if (directoryExists(resolved) && (0, project_fraim_paths_1.workspaceFraimExists)(resolved))
+            const explicitlyAdded = preferences.projects?.some((project) => sameDirectoryPath(project.folderPath, resolved));
+            if (directoryExists(resolved) && ((0, project_fraim_paths_1.workspaceFraimExists)(resolved) || explicitlyAdded))
                 return { projectPath: resolved };
             // A missing folder can be a moved project. Report it separately from a
             // non-FRAIM folder so the Hub can show the rehome path instead of leaving
@@ -419,10 +420,15 @@ function resolveHubProjectPath(preferencesStore, options = {}) {
  * handed to `preferencesStore.save()`.
  */
 function decorateProjectsWithFraimStatus(projects) {
-    return projects.map((project) => ({
-        ...project,
-        hasFraim: !!project.folderPath && (0, project_fraim_paths_1.workspaceFraimExists)(path_1.default.resolve(project.folderPath)),
-    }));
+    return projects.map((project) => {
+        const isOnboarded = project.folderPath ? (0, project_fraim_paths_1.workspaceOnboardingReady)(path_1.default.resolve(project.folderPath)) : false;
+        return {
+            ...project,
+            hasFraim: !!project.folderPath && (0, project_fraim_paths_1.workspaceFraimExists)(path_1.default.resolve(project.folderPath)),
+            isOnboarded,
+            needsOnboarding: isOnboarded === false,
+        };
+    });
 }
 class AiHubRunRegistry {
     constructor() {
@@ -2411,6 +2417,18 @@ function normalizedDirectoryPath(projectPath) {
 function sameDirectoryPath(left, right) {
     return normalizedDirectoryPath(left) === normalizedDirectoryPath(right);
 }
+function onboardingConversationIsActive(conversation) {
+    if (conversation.status === 'running')
+        return true;
+    if (conversation.pauseReason === 'done' || conversation.reviewApproved === true)
+        return false;
+    const handoff = normalizeReviewHandoff(conversation.reviewHandoff);
+    if (handoff)
+        return handoff.reviewRequired;
+    if (conversation.pauseReason === 'awaiting_review')
+        return false;
+    return conversation.status === 'completed' && (conversation.artifacts || []).some((artifact) => Boolean(artifact.path || artifact.url || (('where' in artifact) && artifact.where && artifact.name)));
+}
 function isPathInsideDirectory(candidatePath, parentPath) {
     const relative = path_1.default.relative(path_1.default.resolve(parentPath), path_1.default.resolve(candidatePath));
     return relative === '' || (!!relative && !relative.startsWith('..') && !path_1.default.isAbsolute(relative));
@@ -2480,8 +2498,9 @@ function resolveApiKey() {
 }
 // Read persisted Get-started step states from ~/.fraim/install-state.json
 // (architecture §3.5) and ~/.fraim/preferences.json. Returns a partial — any
-// missing key falls back to derivation. Persisted `true` is sticky so the rail
-// never re-shows once a step is completed (R13.4).
+// missing key falls back to derivation. Persisted `true` is sticky for install,
+// company, and hire (R13.4). computeFirstRun ignores the legacy project flag:
+// project readiness is derived live from the selected project's config presence.
 function readPersistedFirstRun() {
     const out = {};
     const apply = (source) => {
@@ -3000,6 +3019,7 @@ class AiHubServer {
     constructor(options = {}) {
         this.app = (0, express_1.default)();
         this.runRegistry = new AiHubRunRegistry();
+        this.projectSelectionGeneration = 0;
         this.activeAvailabilityWarnings = new Set();
         // Issue #925: the last identity successfully resolved from the hosted authority,
         // keyed by the exact apiKey it was resolved for. When the authority is transiently
@@ -3584,10 +3604,26 @@ class AiHubServer {
             this.conversationStore.moveProjectBucket(oldProjectPath, newProjectPath);
         }
     }
-    async bootstrapResponse(projectPath) {
+    async bootstrapResponse(projectPath, explicitSelection = false) {
         // #866 R2: guard against path.resolve('') === cwd; '' means "no active project".
         const activeProjectPath = projectPath || this.projectPath;
         const normalizedProjectPath = activeProjectPath ? path_1.default.resolve(activeProjectPath) : '';
+        if (explicitSelection) {
+            this.projectSelectionGeneration += 1;
+            // Record the chosen directory before slow employee/persona reads. A
+            // pathless refresh during that work must already resolve this selection.
+            if (directoryExists(normalizedProjectPath)) {
+                const selectedPreferences = this.preferencesStore.load('');
+                this.preferencesStore.save({
+                    ...selectedPreferences,
+                    projectPath: normalizedProjectPath,
+                    projects: (0, preferences_1.normalizeAiHubProjectList)(selectedPreferences.projects || [], normalizedProjectPath, {
+                        removedProjectPaths: selectedPreferences.removedProjectPaths || [],
+                    }),
+                });
+            }
+        }
+        const selectionGeneration = this.projectSelectionGeneration;
         // Issue #1010: prefer the non-blocking parallel probe on the first-paint path. On a
         // cache miss the synchronous form would spawnSync per agent (~2.7s) and freeze the
         // event loop, making every concurrent request wait. Falls back to the sync form for
@@ -3616,7 +3652,8 @@ class AiHubServer {
             const firstAvailable = employees.find((e) => e.available);
             if (firstAvailable) {
                 preferences = { ...preferences, employeeId: firstAvailable.id };
-                this.preferencesStore.save(preferences);
+                if (selectionGeneration === this.projectSelectionGeneration)
+                    this.preferencesStore.save(preferences);
             }
         }
         const project = (0, catalog_1.summarizeProject)(normalizedProjectPath);
@@ -3682,7 +3719,8 @@ class AiHubServer {
         // shell is visible.
         const projects = this.knownProjects(normalizedProjectPath, [], { includeConversationProjects: false });
         preferences = { ...preferences, projectPath: normalizedProjectPath, projects };
-        this.preferencesStore.save(preferences);
+        if (selectionGeneration === this.projectSelectionGeneration)
+            this.preferencesStore.save(preferences);
         // Issue #1253: `hasFraim` is decorated AFTER the save above, never before. The
         // line that persists `preferences` takes whatever list it is handed, so a
         // derived field attached upstream of it silently becomes persisted state. See
@@ -5174,8 +5212,7 @@ class AiHubServer {
         const companyDone = tc.orgContext.present || tc.managerContext.present || tc.orgRules.present || tc.managerRules.present;
         // hire = any persona hired (entitlement active).
         const hireDone = personas.some((p) => p.status === 'hired');
-        // project = a project brief exists OR the workspace has FRAIM jobs set up.
-        const projectDone = tc.projectContext.present || tc.projectBrief.present || tc.projectRules.present || tc.projectQa.present || jobCount > 0;
+        const projectDone = (0, project_fraim_paths_1.workspaceOnboardingReady)(projectPath) === true;
         const derived = {
             install: true, // the Hub is running, so the toolchain install step is satisfied.
             company: companyDone,
@@ -5187,7 +5224,7 @@ class AiHubServer {
             install: persisted.install ?? derived.install,
             company: persisted.company || derived.company,
             hire: persisted.hire || derived.hire,
-            project: persisted.project || derived.project,
+            project: derived.project,
         };
     }
     // Issue #512 (S3, R3) — presence + display paths of the three-layer context
@@ -5722,7 +5759,7 @@ class AiHubServer {
             }
             // #719 / local Hub package: a bare reload must land on the user-level saved
             // Hub project, not whatever directory happened to launch the process.
-            res.json(await this.bootstrapResponse(projectPath || this.defaultProjectPath()));
+            res.json(await this.bootstrapResponse(projectPath || this.defaultProjectPath(), !!projectPath));
         });
         this.app.get('/api/ai-hub/personas', async (req, res) => {
             const projectPath = typeof req.query.projectPath === 'string' && req.query.projectPath.length > 0
@@ -6540,7 +6577,7 @@ class AiHubServer {
                     .filter((id) => id.length > 0));
                 const retainedProjects = this.knownProjects(projectPath).filter((project) => !(project.id && incomingProjectIds.has(project.id)));
                 const projects = this.preferencesStore.saveProjects(projectPath, [...retainedProjects, ...body.projects], { reviveRemovedPaths: Array.isArray(body.reviveRemovedPaths) ? body.reviveRemovedPaths : [] });
-                return res.json({ projectPath, projects, source: 'disk' });
+                return res.json({ projectPath, projects: decorateProjectsWithFraimStatus(projects), source: 'disk' });
             }
             catch (error) {
                 return res.status(400).json({ error: error instanceof Error ? error.message : 'Could not persist projects.' });
@@ -7160,6 +7197,35 @@ class AiHubServer {
                 if (!jobId) {
                     throw new Error('Choose a FRAIM job before starting a run.');
                 }
+                // A project has one active onboarding workflow, including review gates.
+                // Disk records cover review after restart; optimistic records without a
+                // run id cannot block their own first launch.
+                if (jobId === 'project-onboarding' && scope === 'project') {
+                    const conversations = this.conversationStore.loadProject(projectPath).conversations;
+                    const liveRun = this.runRegistry.all().find((run) => {
+                        if (run.jobId !== jobId || run.scope === 'manager' || run.scope === 'company'
+                            || !sameDirectoryPath(run.projectPath, projectPath))
+                            return false;
+                        const stored = conversations.find((conversation) => conversation.id === (run.conversationId || run.id));
+                        return onboardingConversationIsActive({
+                            ...run,
+                            reviewApproved: stored?.reviewApproved,
+                            pauseReason: stored?.pauseReason === 'done' ? 'done' : run.pauseReason,
+                        });
+                    });
+                    const existing = conversations.find((conversation) => !!conversation.runId
+                        && conversation.jobId === jobId && conversation.scope !== 'manager' && conversation.scope !== 'company'
+                        && !!conversation.projectPath && sameDirectoryPath(conversation.projectPath, projectPath)
+                        && onboardingConversationIsActive(conversation));
+                    if (liveRun || existing) {
+                        return res.status(409).json({
+                            code: 'project_onboarding_active',
+                            error: 'Project onboarding is already in progress.',
+                            existingConversationId: liveRun ? (liveRun.conversationId || liveRun.id) : existing.id,
+                            existingRunId: liveRun?.id || existing?.runId,
+                        });
+                    }
+                }
                 // #1394: Dedup guard — return an already-running identical run rather than spawning a second
                 // process. Key includes managerDisplay (messages[0].text) so runs for different issues are
                 // never blocked even when they share the same jobId + hostId + projectPath.

package/dist/src/core/utils/local-registry-resolver.js

@@ -50,6 +50,7 @@ class LocalRegistryResolver {
     constructor(options) {
         this.workspaceRoot = options.workspaceRoot;
         this.effectiveFraimDir = options.effectiveFraimDir;
+        this.userLevelOnly = options.userLevelOnly ?? false;
         this.remoteContentResolver = options.remoteContentResolver;
         this.parser = new inheritance_parser_1.InheritanceParser(options.maxDepth);
         this.shouldFilter = options.shouldFilter;
@@ -87,7 +88,14 @@ class LocalRegistryResolver {
      * Check if a local override exists for the given path
      */
     hasLocalOverride(path) {
-        return (0, fs_1.existsSync)(this.getOverridePath(path));
+        return !this.userLevelOnly && (0, fs_1.existsSync)(this.getOverridePath(path));
+    }
+    /** Whether an effective personalized layer should replace a remote baseline response. */
+    hasPersonalizedOverride(path) {
+        return this.hasLocalOverride(path)
+            || this.readManagerLocalOverlayFile(path) !== null
+            || this.readManagerOverlayFile(path) !== null
+            || this.readOrgOverlayFile(path) !== null;
     }
     /**
      * Find the actual relative path for a registry item by searching subdirectories.
@@ -108,11 +116,11 @@ class LocalRegistryResolver {
             // `jobs/<category>/<name>.md`, so the job was reported not found even
             // though the file existed.
             const searchRoots = [
-                this.getFraimPath('personalized-employee', dir),
+                ...(!this.userLevelOnly ? [this.getFraimPath('personalized-employee', dir)] : []),
                 (0, path_1.join)(this.managerLocalRoot, dir),
                 (0, path_1.join)(this.managerCacheRoot, dir),
                 (0, path_1.join)(this.orgCacheRoot, dir),
-                (0, path_1.join)(this.workspaceRoot, 'registry', dir),
+                ...(!this.userLevelOnly ? [(0, path_1.join)(this.workspaceRoot, 'registry', dir)] : []),
                 // Installed projects discover categorized capabilities in machine catalogs.
                 this.getSyncedCatalogRoot('ai-employee', dir),
                 ...(type !== 'skills' ? [this.getSyncedCatalogRoot('ai-manager', dir)] : []),
@@ -326,6 +334,8 @@ class LocalRegistryResolver {
         }
     }
     readWorkspaceRegistryFile(path) {
+        if (this.userLevelOnly)
+            return null;
         const normalizedPath = path.replace(/\\/g, '/').replace(/^\/+/, '');
         const registryRoot = (0, path_1.join)(this.workspaceRoot, 'registry');
         const registryPath = (0, path_1.join)(registryRoot, ...normalizedPath.split('/'));

package/dist/src/core/utils/project-fraim-paths.js

@@ -7,6 +7,7 @@ exports.WORKSPACE_SYNCED_CONTENT_DIRS = exports.WORKSPACE_FRAIM_DIRNAME = void 0
 exports.getWorkspaceFraimDir = getWorkspaceFraimDir;
 exports.workspaceFraimExists = workspaceFraimExists;
 exports.getWorkspaceConfigPath = getWorkspaceConfigPath;
+exports.workspaceOnboardingReady = workspaceOnboardingReady;
 exports.getWorkspaceFraimPath = getWorkspaceFraimPath;
 exports.assertWorkspaceFraimRoot = assertWorkspaceFraimRoot;
 exports.assertWorkspaceFraimPath = assertWorkspaceFraimPath;
@@ -75,6 +76,19 @@ function workspaceFraimExists(projectRoot = process.cwd()) {
 function getWorkspaceConfigPath(projectRoot = process.cwd()) {
     return (0, path_1.join)(getWorkspaceFraimDir(projectRoot), 'config.json');
 }
+/** Config presence is readiness; unreadable filesystem state is not absence. */
+function workspaceOnboardingReady(projectRoot) {
+    if (!projectRoot)
+        return false;
+    try {
+        (0, fs_1.statSync)(getWorkspaceConfigPath(projectRoot));
+        return true;
+    }
+    catch (error) {
+        const code = error.code;
+        return code === 'ENOENT' || code === 'ENOTDIR' ? false : null;
+    }
+}
 function getWorkspaceFraimPath(projectRoot = process.cwd(), ...parts) {
     return (0, path_1.join)(getWorkspaceFraimDir(projectRoot), ...parts);
 }

package/dist/src/local-mcp-server/learning-context-builder.js

@@ -1535,6 +1535,7 @@ function readRejectedProposals(workspaceRoot, userId) {
         return [];
     const out = [];
     const seen = new Set();
+    const projectOwnerPath = (0, owner_identity_1.ownerPath)((0, project_fraim_paths_1.getWorkspaceFraimDir)(workspaceRoot));
     const headingRe = /^## (Rejected|Superseded): (.+)$/m;
     const reasonRe = /^Reason: (.+)$/m;
     const revisitRe = /^Revisit when: (.+)$/m;
@@ -1567,7 +1568,9 @@ function readRejectedProposals(workspaceRoot, userId) {
             let proposal = {};
             if (json) {
                 try {
-                    proposal = JSON.parse(json[1]);
+                    const parsed = JSON.parse(json[1]);
+                    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed))
+                        proposal = parsed;
                 }
                 catch {
                     // Keep the human-readable half; the JSON only enriches it.
@@ -1576,12 +1579,24 @@ function readRejectedProposals(workspaceRoot, userId) {
             const decision = (proposal.decision || {});
             const content = (proposal.content || {});
             const trace = (content.trace || {});
+            let targetOwner;
+            try {
+                const owner = proposal.target?.owner;
+                (0, owner_identity_1.validateOwner)(owner);
+                targetOwner = { level: owner.level, path: owner.path };
+            }
+            catch {
+                // Older/damaged targets remain visible as unknown; never infer
+                // their project from the shared history file's location.
+            }
+            if (targetOwner?.level === 'Project' && targetOwner.path !== projectOwnerPath)
+                continue;
             const claimKey = typeof proposal.claimKey === 'string' && proposal.claimKey
                 ? proposal.claimKey
                 : parts[1] || heading[2];
             // The same claim can appear in more than one configured base. The first
             // base supplies display metadata for that same recorded decision.
-            const key = `${claimKey}:${String(decision.at || '')}`;
+            const key = JSON.stringify([claimKey, String(decision.at || ''), targetOwner?.level, targetOwner?.path]);
             if (seen.has(key))
                 continue;
             seen.add(key);
@@ -1596,6 +1611,7 @@ function readRejectedProposals(workspaceRoot, userId) {
                 rejectedAt: typeof decision.at === 'string' ? decision.at : '',
                 ...(typeof trace.recurrences === 'number' ? { recurrencesAtRejection: trace.recurrences } : {}),
                 displayPath,
+                ...(targetOwner ? { targetOwner } : {}),
             });
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fraim-hub",
-  "version": "2.0.348",
+  "version": "2.0.350",
   "description": "FRAIM Hub local companion package.",
   "author": "Sid Mathur <sid.mathur@gmail.com>",
   "homepage": "https://github.com/mathursrus/FRAIM#readme",
@@ -246,7 +246,7 @@
     "electron-updater": "^6.8.9",
     "express": "^5.2.1",
     "extract-zip": "^2.0.1",
-    "fraim": "2.0.348",
+    "fraim": "2.0.350",
     "mongodb": "^7.0.0",
     "node-cron": "4.2.1",
     "node-edge-tts": "^1.2.10",

package/public/ai-hub/review.css

@@ -833,6 +833,13 @@
 }
 
 /* Card body clamp */
+.learn-prop .lr-owner {
+  min-width: 0;
+  max-width: 100%;
+  flex-shrink: 1;
+  overflow-wrap: anywhere;
+}
+
 .learn-prop .lp-body.lp-clamped {
   display: -webkit-box;
   -webkit-line-clamp: 3;