fraim-hub 2.0.265 → 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-lock.js

@@ -51,9 +51,11 @@ function withBucketLock(lockPath, fn, opts = {}) {
             fd = fs_1.default.openSync(lockPath, 'wx'); // O_CREAT | O_EXCL: fails if the lock already exists
         }
         catch (error) {
-            if (error.code !== 'EEXIST')
+            const code = error.code;
+            const retryableContention = code === 'EEXIST' || code === 'EPERM' || code === 'EACCES';
+            if (!retryableContention)
                 throw error;
-            if (isLockStale(lockPath, staleMs)) {
+            if (fs_1.default.existsSync(lockPath) && isLockStale(lockPath, staleMs)) {
                 try {
                     fs_1.default.unlinkSync(lockPath);
                 }

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/host-session-state.js

@@ -89,6 +89,7 @@ class HostSessionState {
         if (conversation.sessionId === normalizedSessionId) {
             const replacement = this.resolve({ ...conversation, sessionId: null }, owner);
             conversation.sessionId = replacement?.sessionId || null;
+            conversation.resumeCommand = null;
         }
     }
     markInvalidRun(run, owner, sessionId, reason, at = new Date().toISOString()) {
@@ -110,6 +111,7 @@ class HostSessionState {
         };
         if (run.sessionId === normalizedSessionId) {
             run.sessionId = undefined;
+            run.resumeCommand = null;
         }
     }
     hasInvalidSession(conversation, owner, sessionId) {

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

@@ -10,6 +10,7 @@ exports.parseUsageSignal = parseUsageSignal;
 exports.parseAgentIdentitySignal = parseAgentIdentitySignal;
 exports.__setAgentAvailabilityPathForTests = __setAgentAvailabilityPathForTests;
 exports.invalidateEmployeeDetectionCache = invalidateEmployeeDetectionCache;
+exports.__clearEmployeeDetectionMemoryCacheForTests = __clearEmployeeDetectionMemoryCacheForTests;
 exports.__setEmployeeDetectionTtlForTests = __setEmployeeDetectionTtlForTests;
 exports.__getEmployeeProbeRoundsForTests = __getEmployeeProbeRoundsForTests;
 exports.__resetEmployeeProbeRoundsForTests = __resetEmployeeProbeRoundsForTests;
@@ -940,6 +941,13 @@ function invalidateEmployeeDetectionCache() {
     }
     catch { /* best effort */ }
 }
+/** Test seam only. Simulates a process restart while preserving persisted last-known data. */
+function __clearEmployeeDetectionMemoryCacheForTests() {
+    cachedEmployees = null;
+    cachedEmployeesAtMs = 0;
+    cachedEmployeesContext = null;
+    inFlightDetection = null;
+}
 /** Test seam only. Mirrors __resetLatestVersionCache in hub-latest-version.ts. */
 function __setEmployeeDetectionTtlForTests(ttlMs) {
     employeeDetectionTtlMs = ttlMs ?? EMPLOYEE_DETECTION_TTL_MS;
@@ -1493,6 +1501,9 @@ function parseHostLine(hostId, line) {
     if (hostId === 'codex') {
         try {
             const parsed = JSON.parse(trimmed);
+            if (parsed.type === 'system' && parsed.subtype === 'status' && parsed.status === 'compacting') {
+                return withSignal({ raw: trimmed, hostLifecycle: { status: 'compacting', source: hostId } });
+            }
             if (parsed.type === 'thread.started' && parsed.thread_id) {
                 return withSignal({ sessionId: parsed.thread_id, raw: trimmed });
             }