fraim-hub 2.0.266 → 2.0.267

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

@@ -62,8 +62,24 @@ const KNOWN_LABEL_OVERRIDES = {
     // shouldn't be split on dashes by the default humanizer.
     '1-1': '1:1',
 };
+// Issue #1090: this reads JOB-LEVEL `## Intent` / `## Outcome` only.
+//
+// The previous expression was unanchored (`## ${heading}`), which had two
+// consequences on a personalized override that customizes phases:
+//
+//   1. `#### Intent` CONTAINS the substring `## Intent`, so a phase-level heading
+//      satisfied a job-level query and the first phase's Intent was promoted to
+//      job-level metadata.
+//   2. The terminator `\r?\n## ` requires a space as the 4th character, so it
+//      could not stop at `#### Steps` and Outcome swallowed the Steps and Skills
+//      blocks until `---` or end of file.
+//
+// The start anchor is written as `(?:^|\r?\n)` rather than using the `m` flag,
+// because under `m` the trailing `$` would match end-of-LINE and truncate a
+// multi-line Outcome to its first bullet. Terminating on any heading level
+// `#{1,6} ` fixes (2).
 const sectionValue = (content, heading) => {
-    const match = content.match(new RegExp(`## ${heading}\\r?\\n([\\s\\S]*?)(?:\\r?\\n## |\\r?\\n---|$)`));
+    const match = content.match(new RegExp(`(?:^|\\r?\\n)## ${heading}[ \\t]*\\r?\\n([\\s\\S]*?)(?:\\r?\\n#{1,6} |\\r?\\n---|$)`));
     if (!match)
         return [];
     return match[1]
@@ -72,6 +88,62 @@ const sectionValue = (content, heading) => {
         .filter(Boolean)
         .map((line) => line.replace(/^[-*]\s*/, '').trim());
 };
+/**
+ * Issue #1090: resolve the baseline stub that an `extends`-only override inherits
+ * from, so job-level Intent/Outcome can be inherited rather than scavenged from
+ * the override's first phase.
+ *
+ * `extends` is written as `<category>/<job-name>`. Only NON-personalized layers
+ * are searched: an override extending another override is not a supported shape,
+ * and following one would risk a cycle.
+ */
+function resolveExtendedStubPath(projectPath, extendsValue) {
+    const relative = toPosix(extendsValue).replace(/\.md$/i, '');
+    if (!relative || relative.includes('..'))
+        return null;
+    const candidateRoots = [
+        path_1.default.join(projectPath, 'fraim', 'ai-employee', 'jobs'),
+        path_1.default.join(projectPath, 'fraim', 'ai-manager', 'jobs'),
+        path_1.default.join(projectPath, 'registry', 'jobs', 'ai-employee'),
+        path_1.default.join(projectPath, 'registry', 'jobs', 'ai-manager'),
+        path_1.default.join((0, project_fraim_paths_1.getUserFraimDirPath)(), 'ai-employee', 'jobs'),
+    ];
+    for (const root of candidateRoots) {
+        const candidate = path_1.default.join(root, `${relative}.md`);
+        if (fs_1.default.existsSync(candidate))
+            return candidate;
+    }
+    return null;
+}
+/**
+ * Job-level Intent/Outcome for a stub, following `extends` when the stub itself
+ * declares none. Returns empty arrays rather than throwing when nothing resolves,
+ * so a broken `extends` degrades to the existing "No intent summary available."
+ * behaviour instead of breaking catalog discovery.
+ */
+function jobLevelSections(content, filePath, projectPath) {
+    const intent = sectionValue(content, 'Intent');
+    const outcome = sectionValue(content, 'Outcome');
+    if (intent.length > 0 || outcome.length > 0)
+        return { intent, outcome };
+    const frontmatter = readJobFrontmatter(filePath);
+    const extendsValue = typeof frontmatter?.extends === 'string' ? frontmatter.extends.trim() : '';
+    if (!extendsValue)
+        return { intent, outcome };
+    const basePath = resolveExtendedStubPath(projectPath, extendsValue);
+    if (!basePath)
+        return { intent, outcome };
+    try {
+        const baseContent = fs_1.default.readFileSync(basePath, 'utf8');
+        return {
+            intent: sectionValue(baseContent, 'Intent'),
+            outcome: sectionValue(baseContent, 'Outcome'),
+        };
+    }
+    catch {
+        return { intent, outcome };
+    }
+}
 const humanizeName = (raw) => {
     const lower = raw.toLowerCase();
     if (KNOWN_LABEL_OVERRIDES[lower])
@@ -122,8 +194,9 @@ function parseJobStub(filePath, categoryId, categoryLabel, projectPath, personal
     const fileName = path_1.default.basename(filePath, '.md');
     const frontmatter = readJobFrontmatter(filePath);
     const title = frontmatter?.displayName?.trim() || humanizeName(fileName);
-    const intent = sectionValue(content, 'Intent')[0] || 'No intent summary available.';
-    const outcome = sectionValue(content, 'Outcome');
+    const sections = jobLevelSections(content, filePath, projectPath);
+    const intent = sections.intent[0] || 'No intent summary available.';
+    const outcome = sections.outcome;
     return {
         id: fileName,
         title,

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

@@ -27,6 +27,7 @@ const HEADER_OMITTED_FIELDS = [
     'artifacts',
     'run',
     'delegation',
+    'handoffSummary',
     '_bodyLoaded',
     '_stopping',
     '_priorEvents',

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

@@ -174,6 +174,60 @@ function getHubPersonaForJob(jobName) {
         return null;
     return getProtectedPersonaForHubJob(jobName) ?? DEFAULT_UNASSIGNED_PERSONA_KEY;
 }
+/**
+ * Issue #1090: derive a conversation's owning persona at read time instead of
+ * trusting the value frozen onto the record when it was created.
+ *
+ * The stored value is a snapshot. Re-assigning a job to a different employee,
+ * hiring a custom employee for it, or changing the protected-persona bundle used
+ * to leave every existing run reporting the old owner forever, with no way to
+ * correct it. Deriving on read means the Hub always reflects current ownership.
+ *
+ * One case must NOT be derived: a Mandy-delegated child workstream gets its
+ * persona per-task from the delegation ledger, which is not a function of jobId.
+ * Deriving there would silently reassign every delegated workstream to the job's
+ * default owner, so those keep their stored key.
+ */
+function resolveConversationPersonaKey(conversation, projectPath, customJobOwners) {
+    const isDelegatedChild = Boolean(conversation.managedByRunId || conversation.delegationTaskId);
+    if (isDelegatedChild)
+        return conversation.personaKey ?? null;
+    const jobId = conversation.jobId ?? '';
+    if (!jobId || jobId === '__freeform__')
+        return null;
+    // `customJobOwners` is the hoisted form of getCustomPersonaForJob, used when
+    // deriving a whole list. See buildCustomJobOwnerIndex for why.
+    const custom = customJobOwners
+        ? customJobOwners.get(jobId) ?? null
+        : getCustomPersonaForJob(projectPath, jobId);
+    return custom ?? getHubPersonaForJob(jobId);
+}
+/**
+ * Issue #1090: `getCustomPersonaForJob` calls `readCustomEmployees`, which walks
+ * the org, manager, and project employee directories from disk on every call.
+ * Deriving persona per conversation in a list would therefore do one full disk
+ * walk PER CONVERSATION - O(N) filesystem work on a hot read path, which the Hub
+ * performance budgets correctly flag on a project with a large rail.
+ *
+ * Building the jobId -> persona index once per request keeps the derivation O(1)
+ * per conversation and the disk walk at exactly one.
+ */
+function buildCustomJobOwnerIndex(projectPath) {
+    const index = new Map();
+    for (const employee of (0, custom_employees_1.readCustomEmployees)(projectPath)) {
+        if (!Array.isArray(employee.jobIds))
+            continue;
+        for (const jobId of employee.jobIds) {
+            if (!index.has(jobId))
+                index.set(jobId, employee.key);
+        }
+    }
+    return index;
+}
+/** Apply read-time persona derivation to a conversation record before serving it. */
+function withDerivedPersona(conversation, projectPath, customJobOwners) {
+    return { ...conversation, personaKey: resolveConversationPersonaKey(conversation, projectPath, customJobOwners) };
+}
 // Issue #991: consult custom employee records before falling back to the catalog.
 // Returns the key of the first custom employee whose jobIds array includes jobId,
 // or null if no custom employee owns it.
@@ -2758,7 +2812,7 @@ class AiHubServer {
             issueNumber: conversation.issueNumber ?? null,
             agentSwitches: conversation.agentSwitches || [],
             handoffSummary: conversation.handoffSummary || null,
-            personaKey: conversation.personaKey ?? getHubPersonaForJob(conversation.jobId),
+            personaKey: resolveConversationPersonaKey(conversation, projectPath),
             orchestratedDelegationTaskIds: conversation.delegation?.tasks
                 ?.filter((task) => task.taskId && (task.conversationId || task.runId || ['running', 'submitted', 'completed', 'reviewed', 'blocked'].includes(task.status)))
                 .map((task) => task.taskId) || [],
@@ -3886,14 +3940,23 @@ class AiHubServer {
                 const conversation = this.conversationStore.loadConversation(key, conversationId);
                 if (!conversation)
                     return res.status(404).json({ error: 'conversation not found' });
-                return res.json({ projectPath: key, scope: scope ?? 'project', conversation, source: 'disk' });
+                // Issue #1090: ownership is derived on read, never served from the frozen record.
+                return res.json({ projectPath: key, scope: scope ?? 'project', conversation: withDerivedPersona(conversation, key), source: 'disk' });
             }
             if (req.query.headersOnly === '1' || req.query.headersOnly === 'true') {
-                const headers = this.conversationStore.loadProjectHeaders(key);
+                // One disk walk for the whole list, not one per conversation.
+                const customOwners = buildCustomJobOwnerIndex(key);
+                const headers = this.conversationStore.loadProjectHeaders(key)
+                    .map((header) => withDerivedPersona(header, key, customOwners));
                 return res.json({ projectPath: key, scope: scope ?? 'project', headersOnly: true, conversations: headers, source: 'disk' });
             }
             const loaded = this.conversationStore.loadProject(key);
-            return res.json({ projectPath: key, scope: scope ?? 'project', ...loaded, source: 'disk' });
+            const fullCustomOwners = buildCustomJobOwnerIndex(key);
+            const derived = {
+                ...loaded,
+                conversations: (loaded.conversations || []).map((conversation) => withDerivedPersona(conversation, key, fullCustomOwners)),
+            };
+            return res.json({ projectPath: key, scope: scope ?? 'project', ...derived, source: 'disk' });
         });
         this.app.put('/api/ai-hub/conversations', (req, res) => {
             try {
@@ -4089,7 +4152,7 @@ class AiHubServer {
                         totals: persistedRun?.totals || emptyTotals(),
                         lastStatusChangeAt: now,
                         runDiscriminant: persistedRun?.runDiscriminant || undefined,
-                        personaKey: conversation.personaKey ?? getHubPersonaForJob(conversation.jobId),
+                        personaKey: resolveConversationPersonaKey(conversation, bucketKey),
                         artifacts: Array.isArray(conversation.artifacts) ? conversation.artifacts : [],
                         reviewHandoff: conversation.reviewHandoff || null,
                         delegation: conversation.delegation || null,

package/package.json

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

package/public/ai-hub/script.js

@@ -1028,8 +1028,18 @@ function normalizeGeminiConversationMessages(conv) {
 // request 413s, the error is swallowed, and the client-owned fields in the SAME
 // payload (e.g. pauseReason='done' from "Mark complete") never persist. Strip them
 // here; the server's PUT handler merges them back from the stored record.
-const SERVER_OWNED_CONV_FIELDS = ['messages', 'events', 'artifacts', 'run', 'delegation'];
-const CLIENT_ONLY_CONV_FIELDS = ['_bodyLoaded', '_stopping'];
+const SERVER_OWNED_CONV_FIELDS = ['messages', 'events', 'artifacts', 'run', 'delegation', 'handoffSummary'];
+// Issue #1090: `_bodyFetched` records that THIS CLIENT successfully fetched the
+// body, which is a different claim from "the record has body fields". A run can
+// legitimately finish with no messages, events, artifacts, run, or delegation;
+// before this marker existed such a body was indistinguishable from one that had
+// never been hydrated, so the transcript hung on "Loading conversation…" and
+// re-fetched on every poll tick forever.
+//
+// It is listed in CLIENT_ONLY_CONV_FIELDS so `cleanConversationHeader()` strips
+// any inbound value. That is what preserves issue #913: a marker arriving over
+// the wire is never trusted, only one this client set after a real fetch.
+const CLIENT_ONLY_CONV_FIELDS = ['_bodyLoaded', '_bodyFetched', '_stopping'];
 function slimConversationForPersist(conv) {
   if (!conv || typeof conv !== 'object') return conv;
   const slim = { ...conv };
@@ -1043,6 +1053,11 @@ function slimConversationsForPersist(list) {
 
 function conversationHasBody(conv) {
   if (!conv) return false;
+  // Issue #1090: a body this client already fetched counts as hydrated even when
+  // it carries none of the server-owned fields, so an empty transcript settles
+  // instead of looping. Issue #913 stays satisfied because `_bodyFetched` is
+  // client-only and stripped from every inbound header.
+  if (conv._bodyFetched === true) return true;
   return SERVER_OWNED_CONV_FIELDS.some((field) => Object.prototype.hasOwnProperty.call(conv, field));
 }
 
@@ -1062,6 +1077,12 @@ function mergeConversationHeader(existing, header) {
       merged[field] = existing[field];
     }
   }
+  // Issue #1090: carry the client's own fetch marker forward. A header refresh
+  // must not erase the fact that we already hydrated this body, or the next
+  // render re-enters the loading state and re-fetches. This is deliberately NOT
+  // recomputed from field presence, which is what made the marker inert before.
+  if (existing._bodyFetched === true) merged._bodyFetched = true;
+  else delete merged._bodyFetched;
   if (conversationHasBody(existing)) merged._bodyLoaded = true;
   else delete merged._bodyLoaded;
   return merged;
@@ -1070,6 +1091,9 @@ function mergeConversationHeader(existing, header) {
 function mergeConversationBody(existing, body) {
   const merged = existing ? { ...existing, ...body } : body;
   merged._bodyLoaded = true;
+  // Issue #1090: the body request came back, so this conversation is hydrated
+  // regardless of which fields the response happened to contain.
+  merged._bodyFetched = true;
   return merged;
 }
 
@@ -3162,9 +3186,12 @@ let renderedConvId = null;
 let renderedMessageCount = 0;
 let renderedMessageFingerprints = [];
 let renderedEventCount = 0;
+let renderedEventWindowStart = 0;
 let renderedStatus = null;
 let renderedDirectEventCount = 0;
 let threadMessageViewportObserver = null;
+const MICRO_LOG_VISIBLE_EVENT_LIMIT = 300;
+const MICRO_LOG_EVENT_TEXT_LIMIT = 1000;
 const conversationFocusState = {
   open: false,
   previousFocus: null,
@@ -3192,6 +3219,43 @@ function tfApplyWorkspaceMode() {
   if (briefNav) briefNav.classList.toggle('active', !hasConv);
 }
 
+function microLogVisibleWindow(events) {
+  const list = Array.isArray(events) ? events : [];
+  const start = Math.max(0, list.length - MICRO_LOG_VISIBLE_EVENT_LIMIT);
+  return {
+    start,
+    events: list.slice(start),
+    hiddenCount: start,
+  };
+}
+
+function formatMicroLogLine(event) {
+  const channel = event && event.channel ? event.channel : 'system';
+  let text = event && event.text !== undefined && event.text !== null ? String(event.text) : '';
+  if (text.length > MICRO_LOG_EVENT_TEXT_LIMIT) {
+    text = text.slice(0, MICRO_LOG_EVENT_TEXT_LIMIT) + '\n... [event truncated in UI; full event is stored in the run history]';
+  }
+  return `[${channel}] ${text}\n`;
+}
+
+function renderMicroLogEvents(events) {
+  const windowed = microLogVisibleWindow(events);
+  if (windowed.start !== renderedEventWindowStart || events.length < renderedEventCount) {
+    els['micro-log'].textContent = '';
+    renderedEventCount = windowed.start;
+    renderedEventWindowStart = windowed.start;
+    if (windowed.hiddenCount > 0) {
+      els['micro-log'].appendChild(document.createTextNode(
+        `[system] Showing latest ${windowed.events.length} of ${events.length} events. Full event history remains stored.\n`
+      ));
+    }
+  }
+  for (let i = Math.max(renderedEventCount, windowed.start); i < events.length; i += 1) {
+    els['micro-log'].appendChild(document.createTextNode(formatMicroLogLine(events[i])));
+  }
+  renderedEventCount = events.length;
+}
+
 function syncConversationFocusTitle(conv) {
   if (!els['conversation-focus-title']) return;
   els['conversation-focus-title'].textContent = conv ? conversationTitle(conv) : 'Focused conversation';
@@ -3304,6 +3368,7 @@ function renderActive() {
     renderedMessageCount = 0;
     renderedMessageFingerprints = [];
     renderedEventCount = 0;
+    renderedEventWindowStart = 0;
     renderedStatus = null;
     renderedDirectEventCount = 0;
     syncConversationRefreshPolling();
@@ -3337,6 +3402,7 @@ function renderActive() {
     renderedMessageCount = 0;
     renderedMessageFingerprints = [];
     renderedEventCount = 0;
+    renderedEventWindowStart = 0;
     renderedDirectEventCount = 0;
     // A pending coaching job is scoped to the active conversation — discard it
     // whenever the user switches to a different conversation.
@@ -3425,15 +3491,7 @@ function renderActive() {
   // Micro-manage — only append new events. textContent assignment on the
   // <pre> wipes the entire log every tick which is wasteful.
   const events = conv.events || [];
-  if (events.length < renderedEventCount) {
-    els['micro-log'].textContent = '';
-    renderedEventCount = 0;
-  }
-  for (let i = renderedEventCount; i < events.length; i += 1) {
-    const line = `[${events[i].channel || 'system'}] ${events[i].text}\n`;
-    els['micro-log'].appendChild(document.createTextNode(line));
-  }
-  renderedEventCount = events.length;
+  renderMicroLogEvents(events);
   renderResumeCommand(conv);
 
   // Coaching state — only enable Send when there's text and the run is resumable.