fraim-framework 2.0.170 → 2.0.173

package/dist/src/core/fraim-config-schema.generated.js

@@ -269,7 +269,8 @@ exports.FRAIM_CONFIG_SCHEMA = {
                     "kind": "enum",
                     "values": [
                         "salesforce",
-                        "customereq"
+                        "customereq",
+                        "attio"
                     ]
                 }
             }
@@ -457,7 +458,8 @@ exports.FRAIM_CONFIG_SCHEMA = {
                                     "kind": "enum",
                                     "values": [
                                         "servicenow",
-                                        "fixture"
+                                        "fixture",
+                                        "facebook_messenger"
                                     ]
                                 },
                                 "table": {
@@ -489,6 +491,9 @@ exports.FRAIM_CONFIG_SCHEMA = {
                                 },
                                 "closeState": {
                                     "kind": "string"
+                                },
+                                "accessScript": {
+                                    "kind": "string"
                                 }
                             }
                         },
@@ -678,6 +683,7 @@ exports.SUPPORTED_FRAIM_CONFIG_PATHS = [
     "automation.support.queue.successState",
     "automation.support.queue.failureState",
     "automation.support.queue.closeState",
+    "automation.support.queue.accessScript",
     "automation.support.requestTypes",
     "automation.support.requestTypes.password_reset",
     "automation.support.requestTypes.password_reset.mode",

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

@@ -225,6 +225,23 @@ class LocalRegistryResolver {
             return null;
         }
     }
+    readWorkspaceRegistryFile(path) {
+        const normalizedPath = path.replace(/\\/g, '/').replace(/^\/+/, '');
+        const registryPath = (0, path_1.join)(this.workspaceRoot, 'registry', ...normalizedPath.split('/'));
+        if (!(0, fs_1.existsSync)(registryPath)) {
+            return null;
+        }
+        try {
+            const content = (0, fs_1.readFileSync)(registryPath, 'utf-8');
+            if (this.shouldFilter && this.shouldFilter(content)) {
+                return null;
+            }
+            return content;
+        }
+        catch {
+            return null;
+        }
+    }
     normalizeRegistryPath(path) {
         const normalized = path.trim().replace(/\\/g, '/').replace(/^\/+/, '');
         return normalized.endsWith('.md') ? normalized : `${normalized}.md`;
@@ -379,6 +396,15 @@ class LocalRegistryResolver {
                     inherited: false
                 };
             }
+            const workspaceRegistryContent = this.readWorkspaceRegistryFile(path);
+            if (workspaceRegistryContent !== null) {
+                return {
+                    content: workspaceRegistryContent,
+                    source: 'local',
+                    personalized: false,
+                    inherited: false
+                };
+            }
             // No useful override or synced content, fetch from remote
             try {
                 const rawContent = await this.fetchRemoteWithFallback(path);

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

@@ -8,6 +8,10 @@ exports.getWorkspaceFraimDir = getWorkspaceFraimDir;
 exports.workspaceFraimExists = workspaceFraimExists;
 exports.getWorkspaceConfigPath = getWorkspaceConfigPath;
 exports.getWorkspaceFraimPath = getWorkspaceFraimPath;
+exports.assertWorkspaceFraimRoot = assertWorkspaceFraimRoot;
+exports.assertWorkspaceFraimPath = assertWorkspaceFraimPath;
+exports.createWorkspaceFraimPathAsserter = createWorkspaceFraimPathAsserter;
+exports.assertExactWorkspaceFraimPath = assertExactWorkspaceFraimPath;
 exports.getWorkspaceFraimDisplayPath = getWorkspaceFraimDisplayPath;
 exports.getUserFraimDisplayPath = getUserFraimDisplayPath;
 exports.getUserFraimDirPath = getUserFraimDirPath;
@@ -35,8 +39,38 @@ function normalizeDisplayPath(fullPath) {
 function getWorkspaceFraimDir(projectRoot = process.cwd()) {
     return (0, path_1.join)(projectRoot, exports.WORKSPACE_FRAIM_DIRNAME);
 }
+function isPathInsideOrEqual(parentPath, childPath) {
+    const relativePath = (0, path_1.relative)(parentPath, childPath);
+    return relativePath === '' || (relativePath.length > 0 &&
+        !relativePath.startsWith('..') &&
+        !(0, path_1.isAbsolute)(relativePath));
+}
+function realpathIfExists(fullPath) {
+    try {
+        return fs_1.realpathSync.native(fullPath);
+    }
+    catch {
+        return null;
+    }
+}
+function deepestExistingAncestor(fullPath) {
+    let current = (0, path_1.resolve)(fullPath);
+    while (!(0, fs_1.existsSync)(current)) {
+        const parent = (0, path_1.dirname)(current);
+        if (parent === current) {
+            return null;
+        }
+        current = parent;
+    }
+    return current;
+}
 function workspaceFraimExists(projectRoot = process.cwd()) {
-    return (0, fs_1.existsSync)(getWorkspaceFraimDir(projectRoot));
+    try {
+        return (0, fs_1.readdirSync)(projectRoot, { withFileTypes: true }).some((entry) => entry.isDirectory() && entry.name === exports.WORKSPACE_FRAIM_DIRNAME);
+    }
+    catch {
+        return false;
+    }
 }
 function getWorkspaceConfigPath(projectRoot = process.cwd()) {
     return (0, path_1.join)(getWorkspaceFraimDir(projectRoot), 'config.json');
@@ -44,6 +78,59 @@ function getWorkspaceConfigPath(projectRoot = process.cwd()) {
 function getWorkspaceFraimPath(projectRoot = process.cwd(), ...parts) {
     return (0, path_1.join)(getWorkspaceFraimDir(projectRoot), ...parts);
 }
+function assertWorkspaceFraimRoot(projectRoot = process.cwd()) {
+    const resolvedProjectRoot = (0, path_1.resolve)(projectRoot);
+    const fraimDir = getWorkspaceFraimDir(resolvedProjectRoot);
+    if (!workspaceFraimExists(resolvedProjectRoot)) {
+        throw new Error(`Refusing to use FRAIM workspace root "${resolvedProjectRoot}": expected exact lowercase fraim directory at "${fraimDir}".`);
+    }
+    const projectRootRealPath = realpathIfExists(resolvedProjectRoot);
+    const fraimRealPath = realpathIfExists(fraimDir);
+    if (projectRootRealPath &&
+        fraimRealPath &&
+        !isPathInsideOrEqual(projectRootRealPath, fraimRealPath)) {
+        throw new Error(`Refusing to use FRAIM workspace root "${resolvedProjectRoot}": "${fraimDir}" resolves outside the project root.`);
+    }
+    return fraimDir;
+}
+function assertWorkspaceFraimPath(projectRoot = process.cwd(), targetPath) {
+    createWorkspaceFraimPathAsserter(projectRoot)(targetPath);
+}
+function createWorkspaceFraimPathAsserter(projectRoot = process.cwd()) {
+    const fraimDir = assertWorkspaceFraimRoot(projectRoot);
+    const resolvedFraimDir = (0, path_1.resolve)(fraimDir);
+    const fraimRealPath = realpathIfExists(fraimDir);
+    const realpathCache = new Map();
+    const cachedRealpath = (fullPath) => {
+        const resolvedPath = (0, path_1.resolve)(fullPath);
+        if (!realpathCache.has(resolvedPath)) {
+            realpathCache.set(resolvedPath, realpathIfExists(resolvedPath));
+        }
+        return realpathCache.get(resolvedPath) ?? null;
+    };
+    return (targetPath) => {
+        const resolvedTargetPath = (0, path_1.resolve)(targetPath);
+        if (resolvedTargetPath === resolvedFraimDir ||
+            !isPathInsideOrEqual(resolvedFraimDir, resolvedTargetPath)) {
+            throw new Error(`Refusing to use FRAIM workspace path "${resolvedTargetPath}": expected a path under "${resolvedFraimDir}".`);
+        }
+        const existingAncestor = deepestExistingAncestor(resolvedTargetPath);
+        const ancestorRealPath = existingAncestor ? cachedRealpath(existingAncestor) : null;
+        if (fraimRealPath &&
+            ancestorRealPath &&
+            !isPathInsideOrEqual(fraimRealPath, ancestorRealPath)) {
+            throw new Error(`Refusing to use FRAIM workspace path "${resolvedTargetPath}": existing path "${existingAncestor}" resolves outside "${fraimDir}".`);
+        }
+    };
+}
+function assertExactWorkspaceFraimPath(projectRoot = process.cwd(), targetPath, ...parts) {
+    const expectedPath = (0, path_1.resolve)(getWorkspaceFraimDir((0, path_1.resolve)(projectRoot)), ...parts);
+    const resolvedTargetPath = (0, path_1.resolve)(targetPath);
+    if (resolvedTargetPath !== expectedPath) {
+        throw new Error(`Refusing to use FRAIM workspace path "${resolvedTargetPath}": expected exact managed path "${expectedPath}".`);
+    }
+    assertWorkspaceFraimPath(projectRoot, targetPath);
+}
 function getWorkspaceFraimDisplayPath(relativePath = '') {
     const normalized = normalizeRelativePath(relativePath);
     return normalized.length > 0
@@ -120,7 +207,7 @@ function getConfiguredPortableLearningsDisplayPath(projectRoot = process.cwd())
 function getEffectiveFraimDir(projectRoot = process.cwd(), userFraimDir) {
     // 1. Check for project-level fraim/ directory
     const projectFraimDir = getWorkspaceFraimDir(projectRoot);
-    if ((0, fs_1.existsSync)(projectFraimDir)) {
+    if (workspaceFraimExists(projectRoot)) {
         return projectFraimDir;
     }
     // 2. Fall back to user-level ~/.fraim/

package/dist/src/first-run/session-service.js

@@ -174,8 +174,8 @@ function normalizeRows(rows) {
         ...(existingById.get(canonical.id) || {}),
     }));
 }
-function buildConfiguredSurfaces() {
-    const ides = (0, ide_detector_1.detectInstalledIDEs)();
+function buildRunnableAgentSurfaces() {
+    const ides = (0, ide_detector_1.detectInstalledIDEs)('cli-runnable');
     const hints = (0, ide_global_integration_1.describeOnboardingInvocationSurfaces)(ides);
     return ides.map((ide, index) => ({
         id: ide.configType,
@@ -333,7 +333,7 @@ class FirstRunSessionService {
             byId.set(surface.id, surface);
         }
         if (this.fakeMode !== 'no-agents') {
-            for (const surface of buildConfiguredSurfaces()) {
+            for (const surface of buildRunnableAgentSurfaces()) {
                 byId.set(surface.id, surface);
             }
         }
@@ -547,6 +547,15 @@ class FirstRunSessionService {
             this.persist();
             return this.respond('Fake-mode fraim ok.', true);
         }
+        // FRAIM_SKIP_SYNC signals an isolated/test environment. Skip all external
+        // writes (MCP config files, global config.json, slash commands) so tests
+        // that auto-trigger this path cannot corrupt the real user config.
+        if (process.env.FRAIM_SKIP_SYNC) {
+            row.status = 'ok';
+            row.verb = 'Ready.';
+            this.persist();
+            return this.respond('FRAIM configured.', true);
+        }
         try {
             if (!forceConfigure && !commandVersion('fraim')) {
                 const prefix = path_1.default.join((0, script_sync_utils_1.getUserFraimDir)(), 'node');

package/dist/src/local-mcp-server/artifact-retention-cleanup.js

@@ -0,0 +1,255 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ARTIFACT_RETENTION_CATEGORIES = void 0;
+exports.resolveArtifactRetentionConfig = resolveArtifactRetentionConfig;
+exports.runArtifactCleanup = runArtifactCleanup;
+exports.planArtifactCleanup = planArtifactCleanup;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const project_fraim_paths_1 = require("../core/utils/project-fraim-paths");
+exports.ARTIFACT_RETENTION_CATEGORIES = [
+    'learning_archive',
+    'retrospectives',
+    'evidence',
+    'feedback',
+    'cleanup_manifests',
+];
+function readWorkspaceConfig(workspaceRoot) {
+    try {
+        const configPath = (0, project_fraim_paths_1.getWorkspaceConfigPath)(workspaceRoot);
+        if (!node_fs_1.default.existsSync(configPath))
+            return {};
+        return JSON.parse(node_fs_1.default.readFileSync(configPath, 'utf8'));
+    }
+    catch {
+        return {};
+    }
+}
+function validRetentionValue(value) {
+    return Number.isInteger(value) && value >= -1;
+}
+function normalizeRelative(workspaceRoot, absolutePath) {
+    return node_path_1.default.relative(workspaceRoot, absolutePath).replace(/\\/g, '/');
+}
+function parseRetentionValue(category, value, fallback, invalidValues) {
+    if (validRetentionValue(value))
+        return value;
+    invalidValues.push({
+        category,
+        value,
+        fallback,
+        reason: 'Retention values must be integers greater than or equal to -1.',
+    });
+    return fallback;
+}
+function resolveArtifactRetentionConfig(workspaceRoot) {
+    const config = readWorkspaceConfig(workspaceRoot);
+    const configuredRetention = config?.artifact_retention_period;
+    const rawRetention = configuredRetention && typeof configuredRetention === 'object' && !Array.isArray(configuredRetention)
+        ? configuredRetention
+        : {};
+    const invalidValues = [];
+    const rawDefault = rawRetention?.default;
+    const defaultValue = validRetentionValue(rawDefault)
+        ? rawDefault
+        : parseRetentionValue('default', rawDefault, -1, invalidValues);
+    const values = {};
+    for (const category of exports.ARTIFACT_RETENTION_CATEGORIES) {
+        values[category] = category in rawRetention
+            ? parseRetentionValue(category, rawRetention[category], defaultValue, invalidValues)
+            : defaultValue;
+    }
+    return { values, defaultValue, invalidValues };
+}
+function listFiles(dirPath) {
+    if (!node_fs_1.default.existsSync(dirPath))
+        return [];
+    const out = [];
+    const stack = [dirPath];
+    while (stack.length) {
+        const current = stack.pop();
+        let entries;
+        try {
+            entries = node_fs_1.default.readdirSync(current, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const fullPath = node_path_1.default.join(current, entry.name);
+            if (entry.isDirectory())
+                stack.push(fullPath);
+            else if (entry.isFile())
+                out.push(fullPath);
+        }
+    }
+    return out;
+}
+function fileMtime(absolutePath) {
+    try {
+        return node_fs_1.default.statSync(absolutePath).mtime;
+    }
+    catch {
+        return undefined;
+    }
+}
+function readFrontmatter(content) {
+    const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    if (!match)
+        return {};
+    const values = {};
+    for (const line of match[1].split(/\r?\n/)) {
+        const kv = line.match(/^([A-Za-z0-9_-]+):\s*(.*)$/);
+        if (kv)
+            values[kv[1]] = kv[2].trim();
+    }
+    return values;
+}
+function synthesizedDate(absolutePath) {
+    try {
+        const frontmatter = readFrontmatter(node_fs_1.default.readFileSync(absolutePath, 'utf8'));
+        const value = frontmatter.synthesized;
+        if (!value)
+            return undefined;
+        const parsed = new Date(value);
+        return Number.isNaN(parsed.getTime()) ? undefined : parsed;
+    }
+    catch {
+        return undefined;
+    }
+}
+function userScoped(fileName, activeUserEmail) {
+    return fileName.startsWith(`${activeUserEmail}-`);
+}
+function collectCandidates(workspaceRoot, activeUserEmail) {
+    const candidates = [];
+    const add = (category, absolutePath, eligible, reason, eligibilityDate) => {
+        candidates.push({
+            category,
+            absolutePath,
+            relativePath: normalizeRelative(workspaceRoot, absolutePath),
+            eligible,
+            reason,
+            eligibilityDate,
+        });
+    };
+    const archiveDir = node_path_1.default.join(workspaceRoot, 'fraim', 'personalized-employee', 'learnings', 'archive');
+    for (const filePath of listFiles(archiveDir)) {
+        const fileName = node_path_1.default.basename(filePath);
+        if (!fileName.endsWith('.md') || !userScoped(fileName, activeUserEmail))
+            continue;
+        add('learning_archive', filePath, true, 'Archived learning source for active user.', fileMtime(filePath));
+    }
+    const retrospectivesDir = node_path_1.default.join(workspaceRoot, 'docs', 'retrospectives');
+    for (const filePath of listFiles(retrospectivesDir)) {
+        const fileName = node_path_1.default.basename(filePath);
+        if (!fileName.endsWith('.md') || !userScoped(fileName, activeUserEmail))
+            continue;
+        const date = synthesizedDate(filePath);
+        if (date)
+            add('retrospectives', filePath, true, 'Retrospective has synthesized frontmatter.', date);
+        else
+            add('retrospectives', filePath, false, 'Retrospective has no synthesized frontmatter.');
+    }
+    const evidenceDir = node_path_1.default.join(workspaceRoot, 'docs', 'evidence');
+    for (const filePath of listFiles(evidenceDir)) {
+        const fileName = node_path_1.default.basename(filePath);
+        const isMarkdown = fileName.endsWith('.md');
+        const isJson = fileName.endsWith('.json');
+        if (fileName.includes('cleanup-manifest') || fileName.includes('cleanup_manifest')) {
+            if (!isMarkdown && !isJson)
+                continue;
+            add('cleanup_manifests', filePath, true, 'Cleanup manifest file.', fileMtime(filePath));
+            continue;
+        }
+        if (!isMarkdown)
+            continue;
+        if (fileName.endsWith('-feedback.md')) {
+            add('feedback', filePath, true, 'Feedback evidence file.', fileMtime(filePath));
+            continue;
+        }
+        add('evidence', filePath, true, 'Evidence file.', fileMtime(filePath));
+    }
+    return candidates;
+}
+function daysBetween(from, to) {
+    return Math.floor((to.getTime() - from.getTime()) / 86_400_000);
+}
+function shouldDelete(candidate, retentionValue, now) {
+    if (!candidate.eligible)
+        return { delete: false, reason: candidate.reason };
+    if (retentionValue === -1)
+        return { delete: false, reason: 'Retention value -1 means never cleanup.' };
+    if (!candidate.eligibilityDate || Number.isNaN(candidate.eligibilityDate.getTime())) {
+        return { delete: false, reason: 'Eligibility date is unavailable or invalid.' };
+    }
+    if (retentionValue === 0)
+        return { delete: true, reason: 'Retention value 0 means cleanup immediately when eligible.' };
+    const ageDays = daysBetween(candidate.eligibilityDate, now);
+    if (ageDays >= retentionValue) {
+        return { delete: true, reason: `Eligible artifact age ${ageDays} days meets retention ${retentionValue} days.` };
+    }
+    return { delete: false, reason: `Eligible artifact age ${ageDays} days is below retention ${retentionValue} days.` };
+}
+function incrementCount(report, action) {
+    if (action === 'would_delete')
+        report.counts.wouldDelete++;
+    else
+        report.counts[action]++;
+}
+function runArtifactCleanup(workspaceRoot, options) {
+    const now = options.now ?? new Date();
+    const retention = resolveArtifactRetentionConfig(workspaceRoot);
+    const candidates = collectCandidates(workspaceRoot, options.activeUserEmail);
+    const report = {
+        generatedAt: now.toISOString(),
+        apply: options.apply,
+        retention: retention.values,
+        invalidConfig: retention.invalidValues,
+        counts: { retained: 0, wouldDelete: 0, deleted: 0, skipped: 0, failed: 0 },
+        items: [],
+    };
+    for (const candidate of candidates) {
+        const retentionValue = retention.values[candidate.category];
+        const decision = shouldDelete(candidate, retentionValue, now);
+        let action;
+        let error;
+        if (!candidate.eligible) {
+            action = 'skipped';
+        }
+        else if (!decision.delete) {
+            action = 'retained';
+        }
+        else if (!options.apply) {
+            action = 'would_delete';
+        }
+        else {
+            try {
+                node_fs_1.default.unlinkSync(candidate.absolutePath);
+                action = 'deleted';
+            }
+            catch (err) {
+                action = 'failed';
+                error = err instanceof Error ? err.message : String(err);
+            }
+        }
+        incrementCount(report, action);
+        report.items.push({
+            category: candidate.category,
+            path: candidate.relativePath,
+            action,
+            reason: error ? `Deletion failed: ${decision.reason}` : decision.reason,
+            retentionValue,
+            eligibilityDate: candidate.eligibilityDate?.toISOString().slice(0, 10),
+            cleanupDate: action === 'deleted' || action === 'would_delete' ? now.toISOString().slice(0, 10) : undefined,
+            error,
+        });
+    }
+    return report;
+}
+function planArtifactCleanup(workspaceRoot, options) {
+    return runArtifactCleanup(workspaceRoot, { ...options, apply: false });
+}

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

@@ -25,8 +25,7 @@ const REPO_LEARNINGS_REL = (0, project_fraim_paths_1.getWorkspaceFraimDisplayPat
 const DEFAULT_THRESHOLD = 3.0;
 const AGING_HORIZON_DAYS = 7;
 const MAX_ENTRIES_SCANNED = 200;
-const BACKLOG_MIN = 5;
-const OLDEST_AGE_DAYS_TRIGGER = 3;
+const L0_SLEEP_ON_LEARNINGS_PROMPT_MIN = 5;
 // ── Single source of truth for the learning-entry format contract (#533) ──────
 // The `## [P-…] <title>` entry format is a tight contract shared by three sides:
 //   1. EMIT — the synthesis jobs (sleep-on-learnings, organizational-learning-
@@ -309,51 +308,49 @@ function isUnsynthesizedRetrospective(filePath) {
         return false;
     }
 }
-/** Oldest mtime-age in days across this user's L0 signals. 0 if none. */
-function computeOldestL0AgeDays(workspaceRoot, userId) {
-    const learningsBase = (0, project_fraim_paths_1.getWorkspaceLearningsDir)(workspaceRoot);
-    const now = Date.now();
-    let oldest = 0;
-    const consider = (filePath) => {
-        try {
-            const st = (0, fs_1.statSync)(filePath);
-            const ageDays = Math.floor((now - st.mtimeMs) / (1000 * 60 * 60 * 24));
-            if (ageDays > oldest)
-                oldest = ageDays;
-        }
-        catch {
-            // ignore
-        }
-    };
-    const rawDir = (0, path_1.join)(learningsBase, 'raw');
-    if ((0, fs_1.existsSync)(rawDir)) {
+function pendingL0SortKey(fileName) {
+    const timestamp = fileName.match(/\d{4}-\d{2}-\d{2}(?:T\d{2}-\d{2}-\d{2})?/);
+    return timestamp?.[0] || fileName;
+}
+function collectPendingL0SourceFiles(workspaceRoot, resolvedUserId, roots) {
+    const sources = [];
+    const rawPath = (0, path_1.join)(roots.repoLearningsBase, 'raw');
+    if ((0, fs_1.existsSync)(rawPath)) {
         try {
-            for (const f of (0, fs_1.readdirSync)(rawDir)) {
-                if (!f.startsWith(`${userId}-`))
+            for (const fileName of (0, fs_1.readdirSync)(rawPath)) {
+                if (!fileName.startsWith(`${resolvedUserId}-`))
                     continue;
-                consider((0, path_1.join)(rawDir, f));
+                sources.push({
+                    kind: 'coaching-moment',
+                    displayPath: `${REPO_LEARNINGS_REL}/raw/${fileName}`,
+                    sortKey: pendingL0SortKey(fileName)
+                });
             }
         }
         catch {
-            // ignore
+            // Ignore read failures.
         }
     }
-    const retroDir = (0, path_1.join)(workspaceRoot, 'docs', 'retrospectives');
-    if ((0, fs_1.existsSync)(retroDir)) {
+    const retrospectivesPath = (0, path_1.join)(workspaceRoot, 'docs', 'retrospectives');
+    if ((0, fs_1.existsSync)(retrospectivesPath)) {
         try {
-            for (const f of (0, fs_1.readdirSync)(retroDir)) {
-                if (!f.startsWith(`${userId}-`) || !f.endsWith('.md'))
+            for (const fileName of (0, fs_1.readdirSync)(retrospectivesPath)) {
+                if (!fileName.startsWith(`${resolvedUserId}-`) || !fileName.endsWith('.md'))
                     continue;
-                if (!isUnsynthesizedRetrospective((0, path_1.join)(retroDir, f)))
+                if (!isUnsynthesizedRetrospective((0, path_1.join)(retrospectivesPath, fileName)))
                     continue;
-                consider((0, path_1.join)(retroDir, f));
+                sources.push({
+                    kind: 'retrospective',
+                    displayPath: `docs/retrospectives/${fileName}`,
+                    sortKey: pendingL0SortKey(fileName)
+                });
             }
         }
         catch {
-            // ignore
+            // Ignore read failures.
         }
     }
-    return oldest;
+    return sources.sort((a, b) => b.sortKey.localeCompare(a.sortKey) || a.displayPath.localeCompare(b.displayPath));
 }
 /**
  * Resolve an L2 org-scope learning file (issue #563): a repo-local override
@@ -395,28 +392,9 @@ function buildLearningContextSection(workspaceRoot, userId, forJob) {
     const l1Validated = resolvePersonalLearningFile(roots.repoLearningsBase, roots.managerCacheBase, roots.managerCacheDisplayBase, roots.globalPersonalBase, roots.globalPersonalDisplayBase, `${resolvedUserId}-validated-patterns.md`);
     const l1MistakeStats = l1Mistake.present ? scanMistakePatternFile(l1Mistake.path, threshold, 'mistake-patterns') : null;
     const l1ValidatedStats = l1Validated.present ? scanMistakePatternFile(l1Validated.path, threshold, 'validated-patterns') : null;
-    let l0CoachingCount = 0;
-    const rawPath = (0, path_1.join)(roots.repoLearningsBase, 'raw');
-    if ((0, fs_1.existsSync)(rawPath)) {
-        try {
-            l0CoachingCount = (0, fs_1.readdirSync)(rawPath).filter(f => f.startsWith(`${resolvedUserId}-`)).length;
-        }
-        catch {
-            // Ignore read failures.
-        }
-    }
-    let l0RetroCount = 0;
-    const retrospectivesPath = (0, path_1.join)(workspaceRoot, 'docs', 'retrospectives');
-    if ((0, fs_1.existsSync)(retrospectivesPath)) {
-        try {
-            l0RetroCount = (0, fs_1.readdirSync)(retrospectivesPath)
-                .filter(f => f.startsWith(`${resolvedUserId}-`) && f.endsWith('.md'))
-                .filter(f => isUnsynthesizedRetrospective((0, path_1.join)(retrospectivesPath, f))).length;
-        }
-        catch {
-            // Ignore read failures.
-        }
-    }
+    const pendingL0Sources = collectPendingL0SourceFiles(workspaceRoot, resolvedUserId, roots);
+    const l0CoachingCount = pendingL0Sources.filter(source => source.kind === 'coaching-moment').length;
+    const l0RetroCount = pendingL0Sources.filter(source => source.kind === 'retrospective').length;
     const hasL2 = l2MistakePresent || l2PrefPresent || l2CoachPresent || l2ValidatedPresent;
     const hasL1 = l1Mistake.present || l1Pref.present || l1Coach.present || l1Validated.present;
     const hasContent = hasL2 || hasL1 || l0CoachingCount > 0 || l0RetroCount > 0;
@@ -458,6 +436,7 @@ function buildLearningContextSection(workspaceRoot, userId, forJob) {
         section += '\n';
     }
     if (l0CoachingCount > 0 || l0RetroCount > 0) {
+        const totalL0 = pendingL0Sources.length;
         section += '### L0 - Your unprocessed signals\n';
         if (l0CoachingCount > 0) {
             section += `${l0CoachingCount} coaching moment${l0CoachingCount !== 1 ? 's' : ''} in \`${REPO_LEARNINGS_REL}/raw/${resolvedUserId}-*\`\n`;
@@ -465,12 +444,16 @@ function buildLearningContextSection(workspaceRoot, userId, forJob) {
         if (l0RetroCount > 0) {
             section += `${l0RetroCount} retrospective${l0RetroCount !== 1 ? 's' : ''} in \`docs/retrospectives/${resolvedUserId}-*\` with unsynthesized or missing \`synthesized\` frontmatter\n`;
         }
+        section += 'Pending L0 Source Files:\n';
+        for (const source of pendingL0Sources) {
+            section += `- \`${source.displayPath}\`\n`;
+        }
+        section += 'Read these pending L0 source files before continuing; they are unsynthesized learnings for the current agent.\n';
+        if (totalL0 >= L0_SLEEP_ON_LEARNINGS_PROMPT_MIN) {
+            section += `This is ${totalL0} pending L0 file${totalL0 !== 1 ? 's' : ''}; to speed up future starts, run \`sleep-on-learnings\` to synthesize or archive them.\n`;
+        }
         section += '\n';
     }
-    const totalL0 = l0CoachingCount + l0RetroCount;
-    const oldestAgeDays = totalL0 > 0 ? computeOldestL0AgeDays(workspaceRoot, resolvedUserId) : 0;
-    const agingRisk = l1MistakeStats?.agingRisk ?? 0;
-    const backlogTriggered = totalL0 >= BACKLOG_MIN || (oldestAgeDays >= OLDEST_AGE_DAYS_TRIGGER && totalL0 > 0);
     if (forJob) {
         if (hasL2 || hasL1) {
             section += 'Use the relevant patterns and preferences in this job.\n';
@@ -478,23 +461,12 @@ function buildLearningContextSection(workspaceRoot, userId, forJob) {
                 section += 'Treat manager-coaching as feedback for how the manager should continue or improve managing AI, not as agent instruction.\n';
             }
         }
-        if (backlogTriggered) {
-            section += '\n';
-            section += `Warning: ${totalL0} unprocessed signals pending. Consider running \`sleep-on-learnings\` before starting today's work.\n`;
-            section += renderBacklogDetail(oldestAgeDays, agingRisk);
-        }
     }
     else {
         section += 'Use this synthesized learning context throughout the session.\n';
         if (l1Coach.present || l2CoachPresent) {
             section += 'Manager-coaching entries are manager-facing feedback, not instructions for the AI to follow.\n';
         }
-        if (backlogTriggered) {
-            section += '\n';
-            section += `Warning: synthesis overdue with ${totalL0} unprocessed signals.\n`;
-            section += 'Run `sleep-on-learnings` before starting today\'s work.\n';
-            section += renderBacklogDetail(oldestAgeDays, agingRisk);
-        }
     }
     return section;
 }
@@ -960,15 +932,3 @@ function isTruthyFlag(value) {
         return false;
     return normalized === 'true' || normalized === 'yes' || normalized === '1';
 }
-function renderBacklogDetail(oldestAgeDays, agingRisk) {
-    if (oldestAgeDays <= 0 && agingRisk <= 0)
-        return '';
-    const parts = [];
-    if (oldestAgeDays > 0)
-        parts.push(`oldest ${oldestAgeDays}d`);
-    parts.push('debrief takes ~3 minutes');
-    if (agingRisk > 0) {
-        parts.push(`${agingRisk} high-score pattern${agingRisk !== 1 ? 's' : ''} aging out within ${AGING_HORIZON_DAYS}d`);
-    }
-    return `Detail: ${parts.join('; ')}.\n`;
-}