fraim-hub 2.0.243 → 2.0.245

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

@@ -22,14 +22,27 @@ const project_fraim_paths_1 = require("../core/utils/project-fraim-paths");
 //   - <project>/fraim/ai-employee/jobs/<category>/           - synced baseline
 //   - <project>/fraim/personalized-employee/jobs/<category>/ - taught/customized override
 // Only the personalized-employee layer is "personalized" (issue #566).
+// Issue #1002: the machine-level layers are added here so a capability authored
+// at the manager level is DISCOVERABLE, not merely resolvable by exact name.
+// Order matters and mirrors LocalRegistryResolver.resolveFile precedence
+// inverted, because later entries win on a {categoryId, jobId} collision:
+//   synced baseline < company cache < manager synced cache < manager local < project
+// A job that resolves from the manager level must therefore also DISPLAY as the
+// manager's, otherwise the rail would show a baseline job the runtime never runs.
 const EMPLOYEE_JOB_LAYERS = [
     { segments: ['ai-employee', 'jobs'], personalized: false },
-    { segments: ['personalized-employee', 'jobs'], personalized: true },
+    { base: 'user', segments: ['org', 'jobs'], personalized: true, scope: 'org' },
+    { base: 'user', segments: ['manager', 'jobs'], personalized: true, scope: 'manager' },
+    { base: 'user', segments: ['personalized-employee', 'jobs'], personalized: true, scope: 'manager' },
+    { segments: ['personalized-employee', 'jobs'], personalized: true, scope: 'project' },
 ];
 // Manager templates use the matching layer model.
 const MANAGER_JOB_LAYERS = [
     { segments: ['ai-manager', 'jobs'], personalized: false },
-    { segments: ['personalized-employee', 'manager-jobs'], personalized: true },
+    { base: 'user', segments: ['org', 'manager-jobs'], personalized: true, scope: 'org' },
+    { base: 'user', segments: ['manager', 'manager-jobs'], personalized: true, scope: 'manager' },
+    { base: 'user', segments: ['personalized-employee', 'manager-jobs'], personalized: true, scope: 'manager' },
+    { segments: ['personalized-employee', 'manager-jobs'], personalized: true, scope: 'project' },
 ];
 const REGISTRY_EMPLOYEE_JOB_LAYERS = [
     { base: 'project', segments: ['registry', 'jobs', 'ai-employee'], personalized: false },
@@ -93,7 +106,18 @@ function readMarkdownFileNames(dirPath) {
         .map((entry) => entry.name)
         .sort((a, b) => a.localeCompare(b));
 }
-function parseJobStub(filePath, categoryId, categoryLabel, projectPath, personalized) {
+/**
+ * Issue #1002: a stub that lives under the machine-level FRAIM home is displayed
+ * as `~/.fraim/...` rather than as a long `../../..` walk out of the project,
+ * which is what path.relative would otherwise produce for a user-level layer.
+ */
+function stubDisplayPath(filePath, projectPath, userLevel) {
+    if (!userLevel)
+        return toPosix(path_1.default.relative(projectPath, filePath));
+    const rel = toPosix(path_1.default.relative((0, project_fraim_paths_1.getUserFraimDirPath)(), filePath));
+    return (0, project_fraim_paths_1.getUserFraimDisplayPath)(rel);
+}
+function parseJobStub(filePath, categoryId, categoryLabel, projectPath, personalized, scope, userLevel) {
     const content = fs_1.default.readFileSync(filePath, 'utf8');
     const fileName = path_1.default.basename(filePath, '.md');
     const frontmatter = readJobFrontmatter(filePath);
@@ -107,11 +131,12 @@ function parseJobStub(filePath, categoryId, categoryLabel, projectPath, personal
         categoryLabel,
         intent,
         outcome,
-        stubPath: toPosix(path_1.default.relative(projectPath, filePath)),
+        stubPath: stubDisplayPath(filePath, projectPath, userLevel),
         personalized: !!personalized,
+        ...(scope ? { scope } : {}),
     };
 }
-function parseManagerStub(filePath, groupId, groupLabel, projectPath) {
+function parseManagerStub(filePath, groupId, groupLabel, projectPath, scope, userLevel) {
     const content = fs_1.default.readFileSync(filePath, 'utf8');
     const fileName = path_1.default.basename(filePath, '.md');
     const frontmatter = readJobFrontmatter(filePath);
@@ -123,7 +148,8 @@ function parseManagerStub(filePath, groupId, groupLabel, projectPath) {
         groupId,
         groupLabel,
         intent,
-        stubPath: toPosix(path_1.default.relative(projectPath, filePath)),
+        stubPath: stubDisplayPath(filePath, projectPath, userLevel),
+        ...(scope ? { scope } : {}),
     };
 }
 function summarizeProject(projectPath) {
@@ -163,6 +189,8 @@ function summarizeProject(projectPath) {
 function resolveLayerRoot(projectPath, layer) {
     if (layer.base === 'project')
         return path_1.default.join(projectPath, ...layer.segments);
+    if (layer.base === 'user')
+        return path_1.default.join((0, project_fraim_paths_1.getUserFraimDirPath)(), ...layer.segments);
     return path_1.default.join((0, project_fraim_paths_1.getWorkspaceFraimDir)(projectPath), ...layer.segments);
 }
 function discoverLayers(projectPath, layers) {
@@ -175,6 +203,8 @@ function discoverLayers(projectPath, layers) {
                 categoryId: categoryName,
                 categoryDir: path_1.default.join(layerRoot, categoryName),
                 personalized: layer.personalized,
+                scope: layer.scope,
+                userLevel: layer.base === 'user',
             });
         }
     }
@@ -193,7 +223,7 @@ function discoverEmployeeJobs(projectPath, options = {}) {
         const categoryLabel = humanizeName(layer.categoryId);
         for (const fileName of readMarkdownFileNames(layer.categoryDir)) {
             const filePath = path_1.default.join(layer.categoryDir, fileName);
-            const job = parseJobStub(filePath, layer.categoryId, categoryLabel, projectPath, layer.personalized);
+            const job = parseJobStub(filePath, layer.categoryId, categoryLabel, projectPath, layer.personalized, layer.scope, layer.userLevel);
             // Later layers override earlier layers on {category, jobId} collision —
             // personalized-employee wins over the synced ai-employee baseline. The
             // winning job carries its own layer's `personalized` flag (issue #566).
@@ -219,7 +249,7 @@ function discoverManagerTemplates(projectPath, options = {}) {
         const groupLabel = humanizeName(layer.categoryId);
         for (const fileName of readMarkdownFileNames(layer.categoryDir)) {
             const filePath = path_1.default.join(layer.categoryDir, fileName);
-            const template = parseManagerStub(filePath, layer.categoryId, groupLabel, projectPath);
+            const template = parseManagerStub(filePath, layer.categoryId, groupLabel, projectPath, layer.scope, layer.userLevel);
             templatesByKey.set(`${template.groupId}::${template.id}`, template);
         }
     }

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

@@ -17,63 +17,129 @@ exports.buildCustomEmployeePersona = buildCustomEmployeePersona;
 // evaluatePersonaAccess) must never call resolveEmployee.
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+const project_fraim_paths_1 = require("../core/utils/project-fraim-paths");
 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`);
+// Issue #1002: the manager level is the default home for a custom employee, so
+// an employee the manager created is available in every project on the machine.
+// Two roots, matching capability precedence: the writable home wins over the
+// synced cache, so a just-created employee appears before any publish or sync.
+function managerEmployeesDirs() {
+    return {
+        local: path_1.default.join((0, project_fraim_paths_1.getUserFraimDirPath)(), 'personalized-employee', 'employees'),
+        cache: path_1.default.join((0, project_fraim_paths_1.getUserFraimDirPath)(), 'manager', 'employees'),
+    };
 }
-function readCustomEmployees(projectDir) {
-    const dir = employeesDir(projectDir);
+function readEmployeesFromDir(dir, scope) {
     if (!fs_1.default.existsSync(dir))
         return [];
-    const results = [];
-    for (const file of fs_1.default.readdirSync(dir)) {
+    let names;
+    try {
+        names = fs_1.default.readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const file of names) {
         if (!file.endsWith('.json'))
             continue;
         try {
-            const raw = fs_1.default.readFileSync(path_1.default.join(dir, file), 'utf8');
-            const parsed = JSON.parse(raw);
+            const parsed = JSON.parse(fs_1.default.readFileSync(path_1.default.join(dir, file), 'utf8'));
             if (parsed && typeof parsed.key === 'string' && parsed.key.startsWith('custom:')) {
-                results.push(parsed);
+                // The record's own scope is authoritative when present; otherwise the
+                // directory it was found in names its level. A record written before this
+                // change carries scope 'project' and is found in the project dir, so both
+                // agree and nothing is reinterpreted.
+                out.push({ ...parsed, scope: parsed.scope ?? scope });
             }
         }
         catch {
             // silently skip malformed files
         }
     }
-    return results;
+    return out;
+}
+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;
+}
+/**
+ * Read every custom employee visible from this project, across levels.
+ *
+ * Issue #1002: precedence matches capability resolution. The project copy wins
+ * on a key collision, then the manager's writable home, then the synced manager
+ * cache. Reading the manager level here is what makes the manager-level default
+ * usable: without it an employee created at the manager level would exist on
+ * disk and appear in no roster.
+ */
+function readCustomEmployees(projectDir) {
+    const dirs = managerEmployeesDirs();
+    const byKey = new Map();
+    // Lowest precedence first, so a later write overwrites on key collision.
+    for (const emp of readEmployeesFromDir(dirs.cache, 'manager'))
+        byKey.set(emp.key, emp);
+    for (const emp of readEmployeesFromDir(dirs.local, 'manager'))
+        byKey.set(emp.key, emp);
+    for (const emp of readEmployeesFromDir(employeesDir(projectDir), 'project'))
+        byKey.set(emp.key, emp);
+    return [...byKey.values()];
+}
+/**
+ * Write a custom employee at its declared level.
+ *
+ * Issue #1002 R1: the manager level is the default, so a record with no scope,
+ * or scope 'manager', is written to the manager's writable home and is available
+ * in every project. Only scope 'project' writes into the repository.
+ */
 function writeCustomEmployee(projectDir, employee) {
-    const fp = filePath(projectDir, employee.key);
-    if (!fp)
-        throw new Error(`Invalid employee key: ${employee.key}`);
-    const dir = employeesDir(projectDir);
+    const scope = employee.scope ?? 'manager';
+    const record = { ...employee, scope };
+    const slug = safeSlug(record.key);
+    if (!slug)
+        throw new Error(`Invalid employee key: ${record.key}`);
+    const dir = scope === 'project' ? employeesDir(projectDir) : managerEmployeesDirs().local;
     fs_1.default.mkdirSync(dir, { recursive: true });
-    fs_1.default.writeFileSync(fp, JSON.stringify(employee, null, 2), 'utf8');
+    fs_1.default.writeFileSync(path_1.default.join(dir, `${slug}.json`), JSON.stringify(record, null, 2), 'utf8');
 }
+/**
+ * Delete a custom employee wherever it lives. Issue #1002: a manager-level
+ * employee is not in the project directory, so deleting only there would report
+ * success while leaving the record live in every other project.
+ */
 function deleteCustomEmployee(projectDir, key) {
-    const fp = filePath(projectDir, key);
-    if (!fp || !fs_1.default.existsSync(fp))
+    const slug = safeSlug(key);
+    if (!slug)
         return false;
-    fs_1.default.unlinkSync(fp);
-    return true;
+    const dirs = managerEmployeesDirs();
+    const candidates = [
+        path_1.default.join(employeesDir(projectDir), `${slug}.json`),
+        path_1.default.join(dirs.local, `${slug}.json`),
+        path_1.default.join(dirs.cache, `${slug}.json`),
+    ];
+    let removed = false;
+    for (const fp of candidates) {
+        if (!fs_1.default.existsSync(fp))
+            continue;
+        try {
+            fs_1.default.unlinkSync(fp);
+            removed = true;
+        }
+        catch {
+            // keep going, and report whether anything was removed
+        }
+    }
+    return removed;
 }
 function slugifyDisplayName(displayName, existingKeys = []) {
     const base = displayName

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

@@ -3188,8 +3188,12 @@ class AiHubServer {
     computeBrain(projectPath, jobCount, userEmail) {
         const learnings = (0, learning_context_builder_1.countPreservedLearnings)(projectPath, userEmail || '');
         if (!userEmail) {
+            // Issue #1002 R11: reverseMentoring is individual-keyed like manager and
+            // project, so it is zeroed on the same condition. Missing it would leak a
+            // count for a user whose identity was never resolved.
             learnings.manager = 0;
             learnings.project = 0;
+            learnings.reverseMentoring = 0;
         }
         return {
             learnings,