fraim 2.0.345 → 2.0.348

package/dist/registry/scripts/learning-usage/learning-source-record.js

@@ -0,0 +1,131 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeLearningSourcePath = normalizeLearningSourcePath;
+exports.parseLearningSourceRecord = parseLearningSourceRecord;
+/** Metadata and configured location contract for future learning inputs. */
+const node_path_1 = __importDefault(require("node:path"));
+const artifact_paths_1 = require("../artifact-paths");
+function normalizeLearningSourcePath(value) {
+    const normalized = node_path_1.default.resolve(value).replace(/\\/g, '/');
+    return process.platform === 'win32' ? normalized.toLowerCase() : normalized;
+}
+function validDate(value) {
+    if (!/^\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?Z)?$/.test(value))
+        return false;
+    const date = new Date(value);
+    return Number.isFinite(date.getTime()) && date.toISOString().slice(0, 10) === value.slice(0, 10);
+}
+function safePart(value) {
+    return Boolean(value) && value !== '.' && value !== '..' && !/[\\/:*?"<>|\x00-\x1f]/.test(value)
+        && value.trim() === value && !/[. ]$/.test(value);
+}
+/** Resolve only within the supplied owner. Callers guard physical source containment. */
+function parseLearningSourceRecord(content, filePath, homeRoot, contentRoot, configuredPaths) {
+    const invalid = (reason) => ({ status: 'invalid', reason });
+    const normalized = content.replace(/^\uFEFF/, '');
+    const fm = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/.exec(normalized);
+    if (!fm) {
+        // Diagnose interrupted new records only in the leading metadata block.
+        // Never search document bodies for a marker that could be an example.
+        if (/^---\r?\n/.test(normalized)) {
+            for (const line of normalized.split(/\r?\n/).slice(1)) {
+                if (!line.trim())
+                    continue;
+                if (!/^[ \t]*["']?[A-Za-z][A-Za-z0-9]*["']?[ \t]*:/.test(line))
+                    break;
+                if (/^[ \t]*["']?artifactKind["']?[ \t]*:[ \t]*["']?learning-(?:raw|retrospective)["']?[ \t]*(?:#.*)?$/.test(line)) {
+                    return invalid('Unclosed typed learning frontmatter');
+                }
+            }
+        }
+        return { status: 'unsupported', reason: 'No typed learning frontmatter' };
+    }
+    const fields = {};
+    const duplicates = new Set();
+    let malformedField = false;
+    for (const line of fm[1].split(/\r?\n/)) {
+        const match = /^([A-Za-z][A-Za-z0-9]*):[ \t]*(.*)$/.exec(line);
+        if (!match) {
+            if (/^\s*["']?(artifactKind|author|date|job|runId|sourceId|usageSourceRef|synthesized)["']?\s*:/.test(line))
+                malformedField = true;
+            continue;
+        }
+        if (Object.prototype.hasOwnProperty.call(fields, match[1]))
+            duplicates.add(match[1]);
+        let value = match[2].trim();
+        if (!value.startsWith('"') && !value.startsWith("'"))
+            value = value.replace(/(?:^|\s+)#.*$/, '').trim();
+        if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+        }
+        fields[match[1]] = value;
+    }
+    if (!fields.artifactKind)
+        return malformedField || Object.prototype.hasOwnProperty.call(fields, 'artifactKind')
+            ? invalid('Unsupported metadata key spelling')
+            : { status: 'unsupported', reason: 'No typed learning artifactKind' };
+    if (fields.artifactKind !== 'learning-raw' && fields.artifactKind !== 'learning-retrospective') {
+        return fields.artifactKind.startsWith('learning')
+            ? invalid('Invalid learning artifactKind')
+            : { status: 'unsupported', reason: 'Unsupported artifactKind' };
+    }
+    if (malformedField)
+        return invalid('Unsupported metadata key spelling');
+    if (duplicates.size)
+        return invalid(`Duplicate metadata: ${[...duplicates].join(', ')}`);
+    for (const field of ['author', 'date', 'job', 'runId', 'sourceId', 'usageSourceRef', 'synthesized']) {
+        if (!Object.prototype.hasOwnProperty.call(fields, field))
+            return invalid(`Missing metadata: ${field}`);
+    }
+    if (![fields.author, fields.job, fields.runId].every(safePart))
+        return invalid('Unsafe or empty author, job or runId');
+    if (!validDate(fields.date) || (fields.synthesized && !validDate(fields.synthesized)))
+        return invalid('Invalid date or synthesized date');
+    if (!node_path_1.default.isAbsolute(homeRoot) || !node_path_1.default.isAbsolute(contentRoot) || !node_path_1.default.isAbsolute(filePath))
+        return invalid('Absolute configured root and source path required');
+    const kind = fields.artifactKind === 'learning-raw' ? 'raw' : 'retrospective';
+    const basename = node_path_1.default.basename(filePath);
+    const prefix = `${fields.author}-${fields.runId}-`;
+    const nameKey = (value) => process.platform === 'win32' ? value.toLowerCase() : value;
+    if (!nameKey(basename).startsWith(nameKey(prefix)) || !basename.endsWith('.md') || basename.length <= prefix.length + 3
+        || (kind === 'retrospective' && nameKey(basename) !== nameKey(`${prefix}${fields.job}-retrospective.md`))) {
+        return invalid('Filename does not match recorded author, runId and kind');
+    }
+    let paths;
+    try {
+        paths = configuredPaths ?? (0, artifact_paths_1.resolveLearningPaths)(homeRoot, contentRoot);
+    }
+    catch (error) {
+        return invalid(error instanceof Error ? error.message : 'Invalid artifact configuration');
+    }
+    const pendingPath = node_path_1.default.resolve(kind === 'raw' ? paths.raw : paths.retrospectives, basename).replace(/\\/g, '/');
+    const archivePath = node_path_1.default.resolve(kind === 'raw' ? paths.archiveRaw : paths.archiveRetrospectives, basename).replace(/\\/g, '/');
+    const current = normalizeLearningSourcePath(filePath);
+    const state = current === normalizeLearningSourcePath(pendingPath) ? 'pending'
+        : current === normalizeLearningSourcePath(archivePath) ? 'archived' : null;
+    if (!state)
+        return invalid('Source is outside its configured learning location');
+    if (state === 'archived' && !fields.synthesized)
+        return invalid('Archive has no successful processing date');
+    const reference = fields.usageSourceRef;
+    const relative = node_path_1.default.relative(homeRoot, pendingPath).replace(/\\/g, '/');
+    if (!relative || relative.split('/').some(part => !part || part === '.' || part === '..') || node_path_1.default.isAbsolute(relative))
+        return invalid('Source escapes its owning root');
+    if (!reference || /[\x00-\x1f]/.test(reference) || reference.includes('\\'))
+        return invalid('Invalid usageSourceRef');
+    if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(fields.sourceId)) {
+        return invalid('Sources require an immutable sourceId UUID');
+    }
+    if (node_path_1.default.posix.isAbsolute(reference) || node_path_1.default.win32.isAbsolute(reference) || reference.includes(':')
+        || reference.split('/').some(part => !part || part === '.' || part === '..') || reference !== relative) {
+        return invalid('usageSourceRef must name the owner-relative pending path');
+    }
+    return { status: 'valid', record: { artifactKind: fields.artifactKind, kind, author: fields.author,
+            date: fields.date, job: fields.job, runId: fields.runId, usageSourceRef: fields.usageSourceRef,
+            usageIdentity: `learning-source:${fields.sourceId}`,
+            sourceId: fields.sourceId,
+            synthesized: fields.synthesized, pendingPath, archivePath, state } };
+}

package/dist/src/cli/commands/learning.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.learningCommand = void 0;
+const commander_1 = require("commander");
+const inventory_1 = require("../learning/inventory");
+const queue_operations_1 = require("../learning/queue-operations");
+const usage_1 = require("../learning/usage");
+exports.learningCommand = new commander_1.Command('learning')
+    .description('Run FRAIM learning operations through the packaged CLI');
+exports.learningCommand
+    .command('usage')
+    .description('Inspect historical outcomes, verify recovery, stamp IDs, or prune retained details')
+    .helpOption(false)
+    .allowUnknownOption(true)
+    .allowExcessArguments(true)
+    .action((_options, cmd) => {
+    try {
+        (0, usage_1.runUsageCommand)(cmd.args);
+    }
+    catch (err) {
+        process.stderr.write((err instanceof Error ? err.message : String(err)) + '\n');
+        process.exitCode = 1;
+    }
+});
+exports.learningCommand
+    .command('inventory')
+    .description('Discover and inventory learning sources for a project owner')
+    .option('--projectPath <path>', 'Project root path (defaults to current directory)')
+    .option('--owner <email>', 'Owner email address')
+    .option('--runId <id>', 'Org run ID for cross-participant inventory')
+    .option('--json', 'Output JSON (always true; flag kept for script compatibility)')
+    .action((options) => {
+    try {
+        const projectPath = options.projectPath || process.cwd();
+        const owner = options.owner || '';
+        if (!owner)
+            throw new Error('session-principal-required: pass --owner <email>');
+        const manifest = (0, inventory_1.discoverLearningSources)(projectPath, owner, options.runId);
+        process.stdout.write(JSON.stringify(manifest, null, 2) + '\n');
+        if (!manifest.complete)
+            process.exitCode = 2;
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        process.stderr.write(message + '\n');
+        process.exit(1);
+    }
+});
+exports.learningCommand
+    .command('queue')
+    .description('Propose, apply, assess outcomes, or inspect a learning run')
+    .allowUnknownOption(true)
+    .allowExcessArguments(true)
+    .action((_options, cmd) => {
+    // All flags (--action, --owner, --runId, etc.) are unknown to this command
+    // and land in cmd.args as a flat list, preserving order.
+    (0, queue_operations_1.runQueueCommand)(cmd.args)
+        .then(result => { process.stdout.write(JSON.stringify(result, null, 2) + '\n'); })
+        .catch(err => {
+        const message = err instanceof Error ? err.message : String(err);
+        process.stderr.write(message + '\n');
+        process.exit(1);
+    });
+});

package/dist/src/cli/doctor/checks/scripts-checks.js

@@ -343,6 +343,57 @@ function checkNodeScriptDependencies() {
         }
     };
 }
+/**
+ * Verify the packaged `fraim learning` CLI route is reachable by exercising a
+ * bounded read-only operation through the static-import path introduced in
+ * issue #2024. Exercises actual module loading, not just command registration.
+ */
+function checkLearningCliRoute() {
+    return {
+        name: 'fraim learning CLI route reachable',
+        category: 'scripts',
+        critical: false,
+        run: async () => {
+            const tmpDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'fraim-doctor-'));
+            try {
+                const result = (0, child_process_1.spawnSync)(process.execPath, [process.argv[1], 'learning', 'queue', '--action', 'list', '--owner', 'doctor-check', '--projectPath', tmpDir], {
+                    timeout: 10000,
+                    encoding: 'utf8',
+                    windowsHide: true,
+                    // Isolate from the real Manager home so an existing queue does not
+                    // produce a run-context-mismatch false failure.
+                    env: { ...process.env, FRAIM_USER_DIR: tmpDir },
+                });
+                // Verify the operation, not merely a launcher that happens to exit 0.
+                // This isolated home has no runs; an error/partial result is not healthy.
+                let validEmptyList = false;
+                try {
+                    const payload = JSON.parse(result.stdout);
+                    validEmptyList = result.status === 0 && Array.isArray(payload.runs) && payload.runs.length === 0;
+                }
+                catch { /* Missing or malformed output is a failed probe. */ }
+                if (validEmptyList) {
+                    return {
+                        status: 'passed',
+                        message: 'fraim learning CLI route reachable (packaged static-import path active)',
+                    };
+                }
+                return {
+                    status: 'warning',
+                    message: 'fraim learning subcommand unavailable — learning operations may fail on this installation',
+                    suggestion: 'Run fraim sync to update your local installation, or reinstall fraim from your package manager.',
+                    details: { exitCode: result.status, stderr: result.stderr },
+                };
+            }
+            finally {
+                try {
+                    fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
+                }
+                catch { /* best-effort cleanup */ }
+            }
+        },
+    };
+}
 /**
  * Get all scripts checks
  */
@@ -352,6 +403,7 @@ function getScriptsChecks() {
         checkScriptsSynced(),
         checkScriptsExecutable(),
         checkNodeScriptDependencies(),
-        checkPythonAvailability()
+        checkPythonAvailability(),
+        checkLearningCliRoute(),
     ];
 }

package/dist/src/cli/fraim.js

@@ -23,6 +23,7 @@ const workspace_config_1 = require("./commands/workspace-config");
 const org_1 = require("./commands/org");
 const manager_1 = require("./commands/manager");
 const cleanup_artifacts_1 = require("./commands/cleanup-artifacts");
+const learning_1 = require("./commands/learning");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const program = new commander_1.Command();
@@ -68,4 +69,5 @@ program.addCommand(workspace_config_1.workspaceConfigCommand);
 program.addCommand(org_1.orgCommand);
 program.addCommand(manager_1.managerCommand);
 program.addCommand(cleanup_artifacts_1.cleanupArtifactsCommand);
+program.addCommand(learning_1.learningCommand);
 program.parse(process.argv);

package/dist/src/cli/learning/inventory.js

@@ -0,0 +1,285 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.discoverLearningSources = discoverLearningSources;
+/** Deterministic, read-only synthesis input inventory for the packaged CLI. */
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const queue_operations_1 = require("./queue-operations");
+const project_fraim_paths_1 = require("../../core/utils/project-fraim-paths");
+const pack_home_1 = require("../utils/pack-home");
+const user_config_1 = require("../utils/user-config");
+const run_record_1 = require("../../../registry/scripts/learning/run-record");
+const completion_state_1 = require("../../../registry/scripts/learning/completion-state");
+const artifact_paths_1 = require("../../../registry/scripts/artifact-paths");
+const local_runtime_1 = require("../../../registry/scripts/learning-usage/local-runtime");
+const learning_source_record_1 = require("../../../registry/scripts/learning-usage/learning-source-record");
+const corpus_audit_1 = require("../../../registry/scripts/learning/corpus-audit");
+const digest = (value) => (0, node_crypto_1.createHash)('sha256').update(value).digest('hex');
+const canonical = (file) => {
+    let resolved = node_path_1.default.resolve(file);
+    try {
+        resolved = node_fs_1.default.realpathSync.native(resolved);
+    }
+    catch { /* Missing paths remain explicit. */ }
+    return resolved.replace(/\\/g, '/');
+};
+const compare = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+function discoverLearningSources(projectPath, owner, orgRunId) {
+    if (!/^[a-zA-Z0-9@._+-]+$/.test(owner) || owner === '.' || owner === '..')
+        throw new Error('invalid-owner');
+    projectPath = canonical(projectPath);
+    const errors = [];
+    const directories = [];
+    const files = new Map();
+    const homes = [];
+    const reservationHomes = [];
+    const configFile = node_path_1.default.join((0, project_fraim_paths_1.getUserFraimDirPath)(), 'config.json');
+    let configError;
+    let config = {};
+    try {
+        config = (0, local_runtime_1.readJsonIfObject)(configFile, { strict: true });
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT') {
+            configError = 'unreadable-or-malformed-home-config';
+            errors.push({ path: canonical(configFile), reason: configError });
+        }
+    }
+    for (const level of ['Manager', 'Project', 'Org']) {
+        const layer = level.toLowerCase();
+        const home = level === 'Project'
+            ? { root: projectPath, contentRoot: (0, project_fraim_paths_1.getWorkspaceFraimPath)(projectPath, 'personalized-employee'), backend: 'project' }
+            : (0, pack_home_1.resolvePackHome)(layer, { migrateLegacy: false });
+        const record = { level, root: canonical(home.root), contentRoot: canonical(home.contentRoot), backend: home.backend, status: 'available', ...(home.legacyRoot ? { legacyRoot: canonical(home.legacyRoot) } : {}) };
+        const configured = config?.[level === 'Manager' ? 'managerStorage' : 'organization'];
+        const invalidBackend = configured != null && (!(0, user_config_1.getLayerBackend)(layer)
+            || (configured.localPath != null && (typeof configured.localPath !== 'string' || !configured.localPath.trim())));
+        if (level !== 'Project' && (configError || invalidBackend || (0, user_config_1.isLayerMisconfigured)(layer))) {
+            record.status = 'unavailable';
+            record.reason = configError || 'misconfigured-home';
+        }
+        else {
+            try {
+                if (!node_fs_1.default.statSync(home.root).isDirectory())
+                    throw new Error('home-not-directory');
+            }
+            catch (error) {
+                record.status = error.code === 'ENOENT' ? 'missing' : 'unavailable';
+                record.reason = error.code || error.message;
+            }
+        }
+        if (record.status === 'available')
+            reservationHomes.push(record);
+        if (record.status !== 'unavailable') {
+            try {
+                record.artifactPaths = (0, artifact_paths_1.resolveArtifactPaths)(record.root, record.contentRoot);
+            }
+            catch (error) {
+                record.status = 'unavailable';
+                record.reason = error.message;
+                errors.push({ path: canonical(node_path_1.default.join(node_path_1.default.dirname(record.contentRoot), 'config.json')), reason: error.message });
+            }
+        }
+        homes.push(record);
+    }
+    let orgContext;
+    const participantOwners = new Map();
+    if (orgRunId !== undefined) {
+        const orgHome = homes.find(home => home.level === 'Org');
+        if (!orgHome?.artifactPaths || orgHome.status !== 'available')
+            throw new Error('org-run-home-unavailable');
+        for (const home of homes.filter(home => home.status === 'available'))
+            participantOwners.set(home.level, (0, queue_operations_1.resolveQueueHome)(projectPath, home.level).owner);
+        orgContext = new run_record_1.RunRecord((0, artifact_paths_1.resolveRunJournalDirectory)(orgHome.root), orgRunId, participantOwners.get('Org'), owner, node_path_1.default.join(orgHome.artifactPaths.evidence, 'sleep')).read();
+        for (const grant of orgContext.sourceParticipants ?? []) {
+            if (participantOwners.get(grant.owner.level)?.path !== grant.owner.path)
+                throw new Error('source-participant-home-changed');
+        }
+    }
+    const runDirectories = (home) => [(0, artifact_paths_1.resolveRunJournalDirectory)(home.root),
+        ...(home.level === 'Project' ? [(0, artifact_paths_1.resolveRunJournalDirectory)((0, project_fraim_paths_1.getWorkspaceFraimPath)(projectPath))] : [])];
+    const reservations = new Set();
+    let reservationFailure;
+    for (const directory of reservationHomes.flatMap(runDirectories)) {
+        try {
+            (0, completion_state_1.readSourceReservations)([directory]).forEach(file => reservations.add(file));
+        }
+        catch (error) {
+            reservationFailure = 'source-reservations-unavailable';
+            errors.push({ path: canonical(directory), reason: error.message });
+        }
+    }
+    const read = (file, level, role) => {
+        const key = canonical(file);
+        const previous = files.get(key);
+        if (previous) {
+            if (!previous.levels.includes(level))
+                previous.levels.push(level);
+            if (!previous.roles.includes(role))
+                previous.roles.push(role);
+            return;
+        }
+        const record = { path: key, levels: [level], roles: [role], owner: null, readStatus: 'error', processing: 'error', sourceRefs: [] };
+        files.set(key, record);
+        try {
+            if (node_fs_1.default.lstatSync(file).isSymbolicLink())
+                throw new Error('symlink-source-not-followed');
+            const bytes = node_fs_1.default.readFileSync(file);
+            record.sha256 = digest(bytes);
+            record.readStatus = 'read';
+            const content = bytes.toString('utf8');
+            record.processing = role === 'raw' || role === 'retrospective' ? 'eligible' : 'context';
+            if (role === 'run-history' || role === 'completion-history') {
+                try {
+                    const state = role === 'run-history' ? (0, run_record_1.readSupportedRunRecord)(file) : (0, run_record_1.decodeCompletion)(content, { runId: node_path_1.default.basename(file).replace(/-completion\.md$/, '') });
+                    if (!state) {
+                        record.processing = 'excluded';
+                        record.reason = 'unsupported-run-history';
+                        return;
+                    }
+                    record.owner = 'reviewer' in state ? state.reviewer : null;
+                    if (state.owner.level === 'Manager' && record.owner !== null && record.owner !== owner) {
+                        record.processing = 'excluded';
+                        record.reason = 'other-author';
+                    }
+                    const actions = 'actions' in state ? Object.values(state.actions) : state.decisions;
+                    record.pendingReviewActionIds = 'pendingReviewActionIds' in state ? state.pendingReviewActionIds : [];
+                    if (actions.some(action => action.decision?.action === 'reject'))
+                        record.roles.push('rejection-history');
+                    record.sourceRefs = [...new Set([...actions.flatMap(action => action.sourceRefs), ...state.sourceDispositions.map(source => source.sourceRef)])].sort(compare);
+                }
+                catch (error) {
+                    if (role === 'run-history')
+                        throw error;
+                    record.processing = 'excluded';
+                    record.reason = 'unsupported-run-history';
+                }
+            }
+            else if (['raw', 'retrospective', 'archived-raw', 'archived-retrospective'].includes(role)) {
+                const home = homes.find(home => home.level === level);
+                const parsed = (0, learning_source_record_1.parseLearningSourceRecord)(content, file, home.root, home.contentRoot, home.artifactPaths);
+                if (parsed.status !== 'valid') {
+                    record.processing = parsed.status === 'unsupported' ? 'excluded' : 'error';
+                    record.reason = parsed.status === 'unsupported' ? 'unsupported-learning-source' : parsed.reason;
+                    if (parsed.status === 'invalid')
+                        errors.push({ path: key, reason: parsed.reason });
+                }
+                else {
+                    const metadata = parsed.record;
+                    record.owner = metadata.author;
+                    record.sourceRefs = [metadata.usageIdentity];
+                    if (orgContext ? !(0, completion_state_1.sourceAuthorAllowed)(orgContext, metadata.author, participantOwners.get(home.level)) : metadata.author !== owner) {
+                        record.processing = 'excluded';
+                        record.reason = 'other-author';
+                    }
+                    else if (metadata.state === 'archived')
+                        record.processing = 'context';
+                    else if (reservations.has((0, completion_state_1.sourcePathKey)(file))) {
+                        record.processing = 'excluded';
+                        record.reason = 'source-reserved-by-pending-run';
+                    }
+                    else if (metadata.synthesized) {
+                        record.processing = 'excluded';
+                        record.reason = 'already-synthesized';
+                    }
+                    else if (reservationFailure)
+                        record.completionDeferredReason = reservationFailure;
+                }
+            }
+            else if (role === 'manager-feedback') {
+                const header = content.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/)?.[1];
+                if (!header || !/^artifactKind: work-evidence\s*$/m.test(header) || !/^containsFeedback: true\s*$/m.test(header)) {
+                    record.processing = 'excluded';
+                    record.reason = 'not-feedback-evidence';
+                }
+            }
+            else
+                record.owner = node_path_1.default.basename(file).startsWith('org-') ? 'org' : owner;
+            if (record.processing !== 'excluded') {
+                record.content = content;
+                record.sourceRefs = [...new Set([...record.sourceRefs, ...content.matchAll(/https:\/\/github\.com\/[^\s)<>"']+\/(?:pull|issues)\/\d+(?:#[^\s)<>"']+)?/g)].map(value => typeof value === 'string' ? value : value[0]))].sort(compare);
+            }
+            else
+                record.sourceRefs = [];
+        }
+        catch (error) {
+            record.processing = 'error';
+            record.reason = error.code || error.message;
+            errors.push({ path: key, reason: record.reason });
+        }
+    };
+    const walk = (directory, level, select, excludeDirectories = []) => {
+        const state = { path: canonical(directory), level, status: 'scanned' };
+        directories.push(state);
+        try {
+            if (node_fs_1.default.lstatSync(directory).isSymbolicLink())
+                throw new Error('symlink-directory-not-followed');
+            for (const entry of node_fs_1.default.readdirSync(directory, { withFileTypes: true }).sort((a, b) => compare(a.name, b.name))) {
+                const file = node_path_1.default.join(directory, entry.name);
+                if (entry.isDirectory()) {
+                    if (!excludeDirectories.includes(entry.name) && !excludeDirectories.includes(canonical(file)))
+                        walk(file, level, select, excludeDirectories);
+                }
+                else {
+                    const role = select(entry.name, file);
+                    if (role)
+                        read(file, level, role);
+                }
+            }
+        }
+        catch (error) {
+            state.status = error.code === 'ENOENT' ? 'missing' : 'error';
+            if (state.status === 'error')
+                errors.push({ path: state.path, reason: error.code || error.message });
+        }
+    };
+    const escapedOwner = owner.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const family = new RegExp(`^(?:${escapedOwner}|org)-(?:[a-z][a-z-]*-)?(?:preferences|mistake-patterns|validated-patterns|manager-coaching)(\\.cold)?\\.md$`);
+    for (const home of homes) {
+        if (home.status !== 'available')
+            continue;
+        const learning = node_path_1.default.join(home.contentRoot, 'learnings');
+        const outputs = home.artifactPaths;
+        walk(learning, home.level, name => name === `${owner}-rejected-proposals.md` ? 'rejection-history'
+            : family.test(name) ? (name.endsWith('.cold.md') ? 'cold-family' : 'active-family') : undefined, ['raw', 'retrospectives', 'archive', 'review-queue', 'review-archive', 'review-evidence', ...[outputs.raw, outputs.retrospectives, node_path_1.default.dirname(outputs.archiveRaw)].map(canonical)]);
+        walk(outputs.archiveRaw, home.level, name => name.endsWith('.md') ? 'archived-raw' : undefined);
+        walk(outputs.archiveRetrospectives, home.level, name => name.endsWith('.md') ? 'archived-retrospective' : undefined);
+        const reviewRole = (name) => name.endsWith('.queue.jsonl') ? 'run-history' : name.endsWith('-completion.md') ? 'completion-history' : undefined;
+        for (const directory of runDirectories(home))
+            walk(directory, home.level, reviewRole);
+        walk(node_path_1.default.join(outputs.evidence, 'sleep'), home.level, reviewRole);
+        walk(outputs.evidence, home.level, name => name.endsWith('.md') && !name.endsWith('-completion.md') ? 'manager-feedback' : undefined);
+        walk(outputs.retrospectives, home.level, name => name.endsWith('.md') ? 'retrospective' : undefined);
+        walk(outputs.raw, home.level, name => name.endsWith('.md') ? 'raw' : undefined);
+    }
+    const corpusRecords = homes.filter(home => home.level !== 'Org' || config.organization || orgRunId !== undefined);
+    const corpusHomes = corpusRecords.filter(home => home.status === 'available').flatMap(home => {
+        try {
+            return [(0, queue_operations_1.resolveQueueHome)(projectPath, home.level)];
+        }
+        catch (error) {
+            errors.push({ path: home.root, reason: error.message });
+            return [];
+        }
+    });
+    const corpus = (0, corpus_audit_1.collectLearningCorpus)(corpusHomes, [owner, ...(orgContext?.sourceParticipants?.map(grant => grant.author) || [])], (0, queue_operations_1.resolveReaderCorpusRoots)(projectPath));
+    for (const issue of corpus.errors)
+        if (issue.reason === 'reader-live-home-unowned') {
+            read(issue.path, 'Manager', issue.path.endsWith('.cold.md') ? 'cold-family' : 'active-family');
+        }
+    if (corpusRecords.some(home => home.status !== 'available') || corpusHomes.length !== corpusRecords.length)
+        corpus.complete = false;
+    const manifest = {
+        schemaVersion: 1, owner, projectPath, homes,
+        corpus,
+        ...(orgContext ? { orgRunId: orgContext.runId, sourceParticipants: orgContext.sourceParticipants ?? [] } : {}),
+        directories: directories.sort((a, b) => compare(a.path, b.path) || compare(a.level, b.level)),
+        files: [...files.values()].map(file => ({ ...file, levels: file.levels.sort(compare), roles: file.roles.sort(compare) })).sort((a, b) => compare(a.path, b.path)),
+        errors: errors.sort((a, b) => compare(a.path, b.path) || compare(a.reason, b.reason)),
+    };
+    return { ...manifest, manifestHash: digest(JSON.stringify(manifest)), complete: !errors.length && homes.every(home => home.status === 'available') && corpus.complete };
+}