fraim-hub 2.0.244 → 2.0.246

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/restart-recovery-policy.js

@@ -0,0 +1,108 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RestartRecoveryPolicy = exports.DEFAULT_RESTART_RECOVERY_LEASE_MS = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const crypto_1 = require("crypto");
+const conversation_store_1 = require("./conversation-store");
+exports.DEFAULT_RESTART_RECOVERY_LEASE_MS = 60_000;
+function normalizedDirectoryPath(projectPath) {
+    const resolved = path_1.default.resolve(projectPath);
+    return process.platform === 'win32' ? resolved.toLowerCase() : resolved;
+}
+function sameDirectoryPath(left, right) {
+    return normalizedDirectoryPath(left) === normalizedDirectoryPath(right);
+}
+function timestampMs(value) {
+    if (typeof value === 'number')
+        return Number.isFinite(value) ? value : 0;
+    if (typeof value === 'string') {
+        const parsed = Date.parse(value);
+        if (Number.isFinite(parsed))
+            return parsed;
+        const numeric = Number(value);
+        return Number.isFinite(numeric) ? numeric : 0;
+    }
+    return 0;
+}
+function restartRecoveryBucketOwnershipReason(conversation, bucketKey) {
+    if (!bucketKey)
+        return null;
+    const scope = (conversation.scope ?? conversation.invokedArea) || 'project';
+    if (scope === 'manager')
+        return bucketKey === conversation_store_1.MANAGER_SCOPE_KEY ? null : 'bucket_scope_mismatch';
+    if (scope === 'company')
+        return bucketKey === conversation_store_1.COMPANY_SCOPE_KEY ? null : 'bucket_scope_mismatch';
+    if (bucketKey === conversation_store_1.MANAGER_SCOPE_KEY || bucketKey === conversation_store_1.COMPANY_SCOPE_KEY)
+        return 'bucket_scope_mismatch';
+    const ownProjectPath = typeof conversation.projectPath === 'string' ? conversation.projectPath.trim() : '';
+    if (ownProjectPath && !sameDirectoryPath(ownProjectPath, bucketKey))
+        return 'bucket_project_mismatch';
+    return null;
+}
+class RestartRecoveryPolicy {
+    constructor(options = {}) {
+        this.nowMs = options.nowMs || Date.now;
+        this.recoveryLeaseMs = options.recoveryLeaseMs ?? exports.DEFAULT_RESTART_RECOVERY_LEASE_MS;
+        this.projectExists = options.projectExists || ((projectPath) => fs_1.default.existsSync(projectPath));
+        this.machineLevelJobIds = options.machineLevelJobIds || new Set();
+    }
+    classify(conversation, bucketKey, options = {}) {
+        const bucketReason = restartRecoveryBucketOwnershipReason(conversation, bucketKey);
+        if (bucketReason)
+            return { action: 'skip', reason: bucketReason };
+        if (conversation.status !== 'running')
+            return { action: 'skip', reason: 'not_running' };
+        const pauseReason = typeof conversation.pauseReason === 'string' ? conversation.pauseReason : '';
+        if (['stopped', 'done', 'awaiting_review', 'awaiting_user', 'error'].includes(pauseReason)) {
+            return { action: 'skip', reason: `pause_${pauseReason}` };
+        }
+        if (!conversation.sessionId || typeof conversation.sessionId !== 'string' || !conversation.sessionId.trim()) {
+            return { action: 'skip', reason: 'missing_session' };
+        }
+        if (!conversation.jobId || typeof conversation.jobId !== 'string' || !conversation.jobId.trim()) {
+            return { action: 'skip', reason: 'missing_job' };
+        }
+        const scope = conversation.scope || 'project';
+        const projectPath = typeof conversation.projectPath === 'string' ? conversation.projectPath : '';
+        if (scope === 'project' && !this.machineLevelJobIds.has(conversation.jobId) && (!projectPath || !this.projectExists(projectPath))) {
+            return { action: 'skip', reason: 'missing_project' };
+        }
+        if (conversation.reviewHandoff?.reviewRequired) {
+            return { action: 'skip', reason: 'awaiting_review' };
+        }
+        if (options.activeRunExists) {
+            return { action: 'defer', reason: 'active_run_exists' };
+        }
+        const recoveredAt = timestampMs(conversation.restartRecovery?.recoveredAt);
+        if (recoveredAt > 0 && this.nowMs() - recoveredAt < this.recoveryLeaseMs) {
+            return { action: 'defer', reason: 'recent_recovery' };
+        }
+        return { action: 'recover', attempt: 1 };
+    }
+    buildContinueMessage(run, decision) {
+        return [
+            '[FRAIM Hub system recovery]',
+            'The FRAIM Hub process restarted while this run was marked in progress in durable conversation state.',
+            'This is not a manager-authored instruction. Do not say the manager asked you to continue.',
+            `Run id: ${run.id}`,
+            `Conversation id: ${run.conversationId || 'unknown'}`,
+            `Session id: ${run.sessionId || 'unknown'}`,
+            `Restart recovery attempt: ${decision.attempt}`,
+            'Resume only if the tracked FRAIM phase is non-terminal and not waiting for human review or approval.',
+        ].join('\n');
+    }
+    createRecoveryEvent(run, decision) {
+        const now = new Date(this.nowMs()).toISOString();
+        return {
+            id: (0, crypto_1.randomUUID)(),
+            channel: 'system',
+            createdAt: now,
+            text: `Hub restart recovery attempt ${decision.attempt} for run ${run.id} session ${run.sessionId || 'unknown'}.`,
+        };
+    }
+}
+exports.RestartRecoveryPolicy = RestartRecoveryPolicy;

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

@@ -60,6 +60,7 @@ const manager_turns_1 = require("./manager-turns");
 const preferences_1 = require("./preferences");
 const conversation_store_1 = require("./conversation-store");
 const conversation_store_lock_1 = require("./conversation-store-lock");
+const restart_recovery_policy_1 = require("./restart-recovery-policy");
 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");
@@ -186,7 +187,6 @@ const MACHINE_LEVEL_JOB_IDS = new Set([
 const DEFAULT_CONVERSATION_FLUSH_DELAY_MS = 2000;
 const HUB_RESTART_RECOVERY_LOCK_TIMEOUT_MS = 5000;
 const HUB_RESTART_RECOVERY_LOCK_STALE_MS = 10000;
-const HUB_RESTART_RECOVERY_CONTINUE_MESSAGE = 'Continue where you left off. The Hub process restarted and recovered this in-progress run from durable conversation state.';
 function conversationFlushDelayMs() {
     const configured = Number(process.env.FRAIM_HUB_CONVERSATION_FLUSH_MS);
     if (Number.isFinite(configured) && configured >= 0)
@@ -1578,47 +1578,6 @@ function isHumanActionGate(run) {
     const lastEntry = phaseHistory.length > 0 ? phaseHistory[phaseHistory.length - 1] : null;
     return lastEntry?.latestStatus === 'incomplete' || lastEntry?.latestStatus === 'failure';
 }
-function restartRecoveryBucketOwnershipReason(conversation, bucketKey) {
-    if (!bucketKey)
-        return null;
-    const scope = (conversation.scope ?? conversation.invokedArea) || 'project';
-    if (scope === 'manager')
-        return bucketKey === conversation_store_1.MANAGER_SCOPE_KEY ? null : 'bucket_scope_mismatch';
-    if (scope === 'company')
-        return bucketKey === conversation_store_1.COMPANY_SCOPE_KEY ? null : 'bucket_scope_mismatch';
-    if (bucketKey === conversation_store_1.MANAGER_SCOPE_KEY || bucketKey === conversation_store_1.COMPANY_SCOPE_KEY)
-        return 'bucket_scope_mismatch';
-    const ownProjectPath = typeof conversation.projectPath === 'string' ? conversation.projectPath.trim() : '';
-    if (ownProjectPath && !sameDirectoryPath(ownProjectPath, bucketKey))
-        return 'bucket_project_mismatch';
-    return null;
-}
-function classifyRestartRecoveryEligibility(conversation, bucketKey) {
-    const bucketReason = restartRecoveryBucketOwnershipReason(conversation, bucketKey);
-    if (bucketReason)
-        return { eligible: false, reason: bucketReason };
-    if (conversation.status !== 'running')
-        return { eligible: false, reason: 'not_running' };
-    const pauseReason = typeof conversation.pauseReason === 'string' ? conversation.pauseReason : '';
-    if (['stopped', 'done', 'awaiting_review', 'awaiting_user', 'error'].includes(pauseReason)) {
-        return { eligible: false, reason: `pause_${pauseReason}` };
-    }
-    if (!conversation.sessionId || typeof conversation.sessionId !== 'string' || !conversation.sessionId.trim()) {
-        return { eligible: false, reason: 'missing_session' };
-    }
-    if (!conversation.jobId || typeof conversation.jobId !== 'string' || !conversation.jobId.trim()) {
-        return { eligible: false, reason: 'missing_job' };
-    }
-    const scope = conversation.scope || 'project';
-    const projectPath = typeof conversation.projectPath === 'string' ? conversation.projectPath : '';
-    if (scope === 'project' && !MACHINE_LEVEL_JOB_IDS.has(conversation.jobId) && (!projectPath || !fs_1.default.existsSync(projectPath))) {
-        return { eligible: false, reason: 'missing_project' };
-    }
-    if (conversation.reviewHandoff?.reviewRequired) {
-        return { eligible: false, reason: 'awaiting_review' };
-    }
-    return { eligible: true };
-}
 function classifyExit(run, exitCode) {
     if (run.stoppedByUser) {
         return { action: 'park', pauseReason: 'stopped' };
@@ -1708,6 +1667,7 @@ class AiHubServer {
         this.deploymentStoreProvided = Boolean(options.deploymentStore);
         this.deploymentStore = options.deploymentStore ?? new DeploymentStore();
         this.hostConfigStore = options.hostConfigStore ?? new HostConfigStore();
+        this.restartRecoveryPolicy = new restart_recovery_policy_1.RestartRecoveryPolicy({ machineLevelJobIds: MACHINE_LEVEL_JOB_IDS });
         this.app.use(express_1.default.json({ limit: '10mb' }));
         // CORS + Chrome Private Network Access for browser extensions and Office add-in task panes
         // calling the Hub from a public origin (word-edit.officeapps.live.com, etc.).
@@ -2455,9 +2415,11 @@ class AiHubServer {
                 for (const bucketKey of bucketKeys) {
                     const headers = this.conversationStore.loadProjectHeaders(bucketKey);
                     for (const header of headers) {
-                        const quickDecision = classifyRestartRecoveryEligibility(header, bucketKey);
-                        if (!quickDecision.eligible) {
-                            if (header.status === 'running') {
+                        const quickDecision = this.restartRecoveryPolicy.classify(header, bucketKey, {
+                            activeRunExists: Boolean(header.runId && this.runRegistry.get(header.runId)),
+                        });
+                        if (quickDecision.action !== 'recover') {
+                            if (quickDecision.action === 'skip' && header.status === 'running') {
                                 const skipped = this.conversationStore.loadConversation(bucketKey, header.id);
                                 if (skipped)
                                     this.markRestartRecoverySkipped(bucketKey, skipped, quickDecision.reason || 'ineligible');
@@ -2467,11 +2429,13 @@ class AiHubServer {
                         const conversation = this.conversationStore.loadConversation(bucketKey, header.id);
                         if (!conversation)
                             continue;
-                        const decision = classifyRestartRecoveryEligibility(conversation, bucketKey);
-                        if (decision.eligible) {
-                            candidates.push({ bucketKey, conversation });
+                        const decision = this.restartRecoveryPolicy.classify(conversation, bucketKey, {
+                            activeRunExists: Boolean(conversation.runId && this.runRegistry.get(conversation.runId)),
+                        });
+                        if (decision.action === 'recover') {
+                            candidates.push({ bucketKey, conversation, decision });
                         }
-                        else if (conversation.status === 'running') {
+                        else if (decision.action === 'skip' && conversation.status === 'running') {
                             this.markRestartRecoverySkipped(bucketKey, conversation, decision.reason || 'ineligible');
                         }
                     }
@@ -2498,7 +2462,8 @@ class AiHubServer {
                         const activeId = activeIdByBucket.get(candidate.bucketKey) ?? null;
                         this.persistRunConversationNow(run, activeId);
                         recoveredBucketKeys.add(candidate.bucketKey);
-                        this.continueRecoveredRun(run, HUB_RESTART_RECOVERY_CONTINUE_MESSAGE, {
+                        this.continueRecoveredRun(run, this.restartRecoveryPolicy.buildContinueMessage(run, candidate.decision), {
+                            recoveryEvent: this.restartRecoveryPolicy.createRecoveryEvent(run, candidate.decision),
                             postPark: (updated) => this.maybeStartDelegatedChildRuns(updated),
                             activeId,
                         });
@@ -2616,18 +2581,18 @@ class AiHubServer {
     continueRecoveredRun(run, instructions, options = {}) {
         if (!run.sessionId)
             return;
-        const prepared = this.prepareContinueMessage(run, instructions);
         this.runRegistry.update(run.id, (current) => {
             current.status = 'running';
             current.pauseReason = 'working';
-            current.messages.push((0, hosts_1.createHubMessage)('manager', prepared.display || instructions));
+            if (options.recoveryEvent)
+                current.events.push(options.recoveryEvent);
         });
         const currentRun = this.runRegistry.get(run.id) || run;
         const sessionId = currentRun.sessionId;
         if (!sessionId)
             return;
         const launch = this.resolveLaunchAgent(currentRun.configuredAgentId, currentRun.hostId);
-        const child = this.hostRuntime.continueRun(currentRun.hostId, currentRun.projectPath, sessionId, prepared.message, {
+        const child = this.hostRuntime.continueRun(currentRun.hostId, currentRun.projectPath, sessionId, instructions, {
             onEvent: (event, channel) => {
                 this.runRegistry.update(currentRun.id, (current) => {
                     if (event.sessionId) {
@@ -3188,8 +3153,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,