fraim-hub 2.0.344 → 2.0.346

package/dist/registry/scripts/learning/completion-state.js

@@ -16,6 +16,7 @@ const node_path_1 = __importDefault(require("node:path"));
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_crypto_1 = require("node:crypto");
 const artifact_paths_1 = require("../artifact-paths");
+const corpus_audit_1 = require("./corpus-audit");
 const sourcePathKey = (file) => {
     const value = node_path_1.default.resolve(file).replace(/\\/g, '/');
     return process.platform === 'win32' ? value.toLowerCase() : value;
@@ -233,7 +234,7 @@ function decodeCompletion(markdown, expected = {}) {
     catch {
         fail();
     }
-    if (!keys(state, ['schemaVersion', 'runId', 'owner', 'finalizationState', 'decisions', 'sourceDispositions', 'cleanup', 'reconciliations', 'retrospective', 'processedSources', 'sourceParticipants']) || state.schemaVersion !== 1 || !text(state.runId) || !/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(state.runId) || !ownerValid(state.owner)
+    if (!keys(state, ['schemaVersion', 'runId', 'owner', 'finalizationState', 'decisions', 'sourceDispositions', 'cleanup', 'reconciliations', 'retrospective', 'processedSources', 'sourceParticipants', 'corpusAudit', 'reconciliationHistory']) || state.schemaVersion !== 1 || !text(state.runId) || !/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(state.runId) || !ownerValid(state.owner)
         || !['pending', 'complete'].includes(state.finalizationState) || !Array.isArray(state.decisions) || !Array.isArray(state.sourceDispositions) || !Array.isArray(state.cleanup))
         fail();
     if ((expected.runId && expected.runId !== state.runId) || (expected.owner && !sameOwner(expected.owner, state.owner)))
@@ -281,6 +282,48 @@ function decodeCompletion(markdown, expected = {}) {
             fail();
     }
     const decisions = new Map(state.decisions.map((item) => [item.actionId, item]));
+    if (state.corpusAudit !== undefined) {
+        try {
+            (0, corpus_audit_1.validateCorpusAudit)(state.corpusAudit);
+        }
+        catch {
+            fail();
+        }
+        for (const item of state.corpusAudit.dispositions)
+            for (const binding of item.actionBindings) {
+                const decision = decisions.get(binding.actionId);
+                if (!decision || decision.digest !== binding.digest || decision.revision !== binding.revision || decision.decision.reviewer !== state.corpusAudit.reviewer)
+                    fail();
+            }
+    }
+    if (state.reconciliationHistory !== undefined) {
+        if (!Array.isArray(state.reconciliationHistory))
+            fail();
+        const seen = new Set();
+        const validRef = (ref) => keys(ref, ['owner', 'relativePath', 'entryId', 'learningSubject']) && ownerValid(ref.owner)
+            && typeof ref.relativePath === 'string' && ref.relativePath.startsWith('learnings/') && !ref.relativePath.includes('\\') && !ref.relativePath.includes(':')
+            && !ref.relativePath.split('/').some((part) => !part || part === '.' || part === '..') && /^L-[a-f0-9]{10}$/.test(ref.entryId)
+            && (ref.learningSubject === undefined || text(ref.learningSubject));
+        for (const history of state.reconciliationHistory) {
+            const decision = decisions.get(history.actionId);
+            if (!keys(history, ['actionId', 'revision', 'digest', 'target', 'resultHash', 'occurrences']) || !decision || seen.has(history.actionId)
+                || decision.decision.action !== 'approve' || history.revision !== decision.revision || history.digest !== decision.digest
+                || !validRef(history.target) || canonicalJournal(history.target) !== canonicalJournal(decision.target) || !hash(history.resultHash)
+                || !Array.isArray(history.occurrences) || !history.occurrences.length)
+                fail();
+            seen.add(history.actionId);
+            const locations = new Set();
+            for (const occurrence of history.occurrences) {
+                if (!keys(occurrence, ['ref', 'sha256', 'before']) || !validRef(occurrence.ref) || occurrence.ref.entryId !== history.target.entryId
+                    || !text(occurrence.before) || !hash(occurrence.sha256) || (0, node_crypto_1.createHash)('sha256').update(occurrence.before).digest('hex') !== occurrence.sha256)
+                    fail();
+                const location = canonicalJournal([occurrence.ref.owner, occurrence.ref.relativePath]);
+                if (locations.has(location))
+                    fail();
+                locations.add(location);
+            }
+        }
+    }
     const outcome = (item) => item.decision.action === 'approve' ? 'applied' : 'rejected';
     const dispositions = new Set();
     for (const source of state.sourceDispositions) {

package/dist/registry/scripts/learning/corpus-audit.js

@@ -0,0 +1,205 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.corpusEntryKey = corpusEntryKey;
+exports.collectLearningCorpus = collectLearningCorpus;
+exports.validateCorpusAudit = validateCorpusAudit;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const owner_identity_1 = require("./owner-identity");
+const { learningEntryBlocks } = require('./entry-format');
+const stable = (value) => JSON.stringify(value, (_key, item) => item && typeof item === 'object' && !Array.isArray(item)
+    ? Object.fromEntries(Object.keys(item).sort().map(key => [key, item[key]])) : item);
+const hash = (value) => (0, node_crypto_1.createHash)('sha256').update(value).digest('hex');
+const keys = (value, allowed) => !!value && typeof value === 'object' && !Array.isArray(value) && Object.keys(value).every(key => allowed.includes(key));
+function corpusEntryKey(entry) {
+    return (0, owner_identity_1.ownerKey)(entry.ref.owner) + ':' + entry.ref.relativePath + ':' + (entry.ref.entryId ?? `unassigned:${entry.occurrence}`);
+}
+function corpusFingerprint(homes, entries) { return hash(stable({ homes, entries })); }
+/** Only persisted identity and bytes are mechanical; audience and semantic conflicts require review. */
+function collectLearningCorpus(homes, subjects, readerRoots = []) {
+    const entries = [], errors = [], seen = new Set();
+    const identities = [...new Map(homes.map(home => [(0, owner_identity_1.ownerKey)(home.owner), home.owner])).values()].sort((a, b) => (0, owner_identity_1.ownerKey)(a).localeCompare((0, owner_identity_1.ownerKey)(b)));
+    const escaped = [...new Set([...subjects, 'org'])].map(subject => subject.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
+    const family = new RegExp(`^(?:${escaped.join('|')})-(?:[a-z][a-z-]*-)?(?:preferences|mistake-patterns|validated-patterns|manager-coaching)(\\.cold)?\\.md$`);
+    const excluded = new Set(['raw', 'retrospectives', 'archive', 'review-queue', 'review-archive', 'review-evidence']);
+    for (const home of [...homes].sort((a, b) => (0, owner_identity_1.ownerKey)(a.owner).localeCompare((0, owner_identity_1.ownerKey)(b.owner)))) {
+        const walk = (directory) => {
+            try {
+                if (node_fs_1.default.lstatSync(directory).isSymbolicLink())
+                    throw new Error('symlink-corpus-not-followed');
+                for (const item of node_fs_1.default.readdirSync(directory, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+                    const file = node_path_1.default.join(directory, item.name);
+                    if (item.isSymbolicLink()) {
+                        if (!excluded.has(item.name))
+                            errors.push({ path: file.replace(/\\/g, '/'), reason: 'symlink-corpus-not-followed' });
+                        continue;
+                    }
+                    if (item.isDirectory()) {
+                        if (!excluded.has(item.name))
+                            walk(file);
+                        continue;
+                    }
+                    if (!family.test(item.name))
+                        continue;
+                    try {
+                        if (item.isSymbolicLink())
+                            throw new Error('symlink-corpus-not-followed');
+                        const real = node_fs_1.default.realpathSync(file);
+                        const key = process.platform === 'win32' ? real.toLowerCase() : real;
+                        if (seen.has(key))
+                            continue;
+                        seen.add(key);
+                        const relativePath = node_path_1.default.relative(home.contentRoot, file).replace(/\\/g, '/');
+                        (0, owner_identity_1.ownerArtifactPath)(home, relativePath);
+                        const body = node_fs_1.default.readFileSync(file, 'utf8');
+                        if (/^<{7}/m.test(body))
+                            throw new Error('corpus-merge-conflict');
+                        const blocks = learningEntryBlocks(body), ids = new Set();
+                        let unassigned = 0;
+                        for (const block of blocks) {
+                            // Match the runtime reader's handwritten identity contract.
+                            // Approved mutations still use the author's narrower generated-ID schema.
+                            const declarations = block.text.split(/\r?\n/).map(line => line.trim()).filter(line => /^\*\*Id\*\*:/i.test(line));
+                            const id = declarations[0]?.match(/^\*\*Id\*\*:\s*(L-[0-9A-Za-z]{6,24})\s*$/)?.[1] ?? null;
+                            if ((declarations.length && (!id || declarations.length !== 1)) || (id && ids.has(id))
+                                || !/^#{2,6}\s+\[P-(CRITICAL|HIGH|MED|LOW)\]\s+\S/.test(block.text)) {
+                                errors.push({ path: file.replace(/\\/g, '/'), reason: 'ambiguous-corpus-entry' });
+                                continue;
+                            }
+                            if (id)
+                                ids.add(id);
+                            entries.push({ ref: { owner: home.owner, relativePath, ...(id ? { entryId: id } : {}) }, sha256: hash(block.text),
+                                ...(!id ? { occurrence: unassigned++ } : {}) });
+                        }
+                    }
+                    catch (error) {
+                        errors.push({ path: file.replace(/\\/g, '/'), reason: error.code || error.message });
+                    }
+                }
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT')
+                    errors.push({ path: directory.replace(/\\/g, '/'), reason: error.code || error.message });
+            }
+        };
+        try {
+            walk((0, owner_identity_1.ownerArtifactPath)(home, 'learnings'));
+        }
+        catch (error) {
+            errors.push({ path: home.contentRoot, reason: error.message });
+        }
+    }
+    // Legacy reader locations are explicitly discoverable but cannot acquire a
+    // writable OwnerRef just by being present. Report every unowned family file.
+    const inspectReaderRoot = (directory) => {
+        try {
+            if (node_fs_1.default.lstatSync(directory).isSymbolicLink())
+                throw new Error('symlink-corpus-not-followed');
+            for (const item of node_fs_1.default.readdirSync(directory, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+                const file = node_path_1.default.join(directory, item.name);
+                if (excluded.has(item.name))
+                    continue;
+                if (item.isSymbolicLink()) {
+                    errors.push({ path: file.replace(/\\/g, '/'), reason: 'symlink-corpus-not-followed' });
+                    continue;
+                }
+                if (item.isDirectory()) {
+                    inspectReaderRoot(file);
+                    continue;
+                }
+                if (!family.test(item.name))
+                    continue;
+                try {
+                    const real = node_fs_1.default.realpathSync(file), key = process.platform === 'win32' ? real.toLowerCase() : real;
+                    if (seen.has(key))
+                        continue;
+                    seen.add(key);
+                    errors.push({ path: file.replace(/\\/g, '/'), reason: 'reader-live-home-unowned' });
+                }
+                catch (error) {
+                    errors.push({ path: file.replace(/\\/g, '/'), reason: error.code || error.message });
+                }
+            }
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                errors.push({ path: directory.replace(/\\/g, '/'), reason: error.code || error.message });
+        }
+    };
+    for (const directory of [...new Set(readerRoots)].sort()) {
+        // An explicit configured alias of an owned learning root is already scanned.
+        try {
+            const key = (file) => { const real = node_fs_1.default.realpathSync(file); return process.platform === 'win32' ? real.toLowerCase() : real; };
+            const real = key(directory);
+            if (homes.some(home => { try {
+                return key(node_path_1.default.join(home.contentRoot, 'learnings')) === real;
+            }
+            catch {
+                return false;
+            } }))
+                continue;
+        }
+        catch { /* Missing/unreadable roots are handled by the scanner below. */ }
+        inspectReaderRoot(directory);
+    }
+    entries.sort((a, b) => corpusEntryKey(a).localeCompare(corpusEntryKey(b)));
+    const groups = new Map();
+    for (const entry of entries)
+        if (entry.ref.entryId)
+            groups.set(entry.ref.entryId, [...(groups.get(entry.ref.entryId) || []), entry]);
+    const duplicates = [...groups].filter(([, occurrences]) => occurrences.length > 1).map(([entryId, occurrences]) => ({ entryId, occurrences })).sort((a, b) => a.entryId.localeCompare(b.entryId));
+    return { schemaVersion: 1, homes: identities, entries, duplicates, fingerprint: corpusFingerprint(identities, entries), complete: !errors.length, errors };
+}
+/** Shared by journal replay and the strict compact receipt decoder. No filesystem access. */
+function validateCorpusAudit(audit, reviewer) {
+    const fail = () => { throw new Error('invalid-corpus-audit'); };
+    if (!keys(audit, ['snapshot', 'reviewer', 'dispositions']) || typeof audit.reviewer !== 'string' || !audit.reviewer.trim() || (reviewer && audit.reviewer !== reviewer)
+        || !keys(audit.snapshot, ['schemaVersion', 'homes', 'entries', 'duplicates', 'fingerprint', 'complete', 'errors']) || audit.snapshot.schemaVersion !== 1 || audit.snapshot.complete !== true || !Array.isArray(audit.snapshot.errors) || audit.snapshot.errors.length
+        || !Array.isArray(audit.snapshot.homes) || !Array.isArray(audit.snapshot.entries) || !Array.isArray(audit.dispositions))
+        fail();
+    const snapshot = audit.snapshot;
+    for (const owner of snapshot.homes)
+        (0, owner_identity_1.validateOwner)(owner);
+    if (new Set(snapshot.homes.map(owner_identity_1.ownerKey)).size !== snapshot.homes.length || snapshot.fingerprint !== corpusFingerprint(snapshot.homes, snapshot.entries))
+        fail();
+    const entries = new Map();
+    for (const entry of snapshot.entries) {
+        if (!keys(entry, ['ref', 'sha256', 'occurrence']) || !keys(entry.ref, ['owner', 'relativePath', 'entryId']))
+            fail();
+        (0, owner_identity_1.validateOwner)(entry.ref?.owner);
+        if (!snapshot.homes.some(owner => (0, owner_identity_1.ownerKey)(owner) === (0, owner_identity_1.ownerKey)(entry.ref.owner))
+            || (entry.ref.entryId === undefined ? !Number.isSafeInteger(entry.occurrence) || entry.occurrence < 0 : !/^L-[0-9A-Za-z]{6,24}$/.test(entry.ref.entryId) || entry.occurrence !== undefined)
+            || !/^learnings\//.test(entry.ref.relativePath) || /[\\:]/.test(entry.ref.relativePath) || entry.ref.relativePath.split('/').some(part => !part || part === '.' || part === '..')
+            || !/^[a-f0-9]{64}$/.test(entry.sha256) || entries.has(corpusEntryKey(entry)))
+            fail();
+        entries.set(corpusEntryKey(entry), entry);
+    }
+    const groups = new Map();
+    for (const entry of snapshot.entries)
+        if (entry.ref.entryId)
+            groups.set(entry.ref.entryId, [...(groups.get(entry.ref.entryId) || []), entry]);
+    const duplicates = [...groups].filter(([, occurrences]) => occurrences.length > 1).map(([entryId, occurrences]) => ({ entryId, occurrences })).sort((a, b) => a.entryId.localeCompare(b.entryId));
+    if (stable(snapshot.duplicates) !== stable(duplicates))
+        fail();
+    if (audit.dispositions.length !== entries.size)
+        fail();
+    const seen = new Set();
+    for (const item of audit.dispositions) {
+        if (!keys(item, ['ref', 'sha256', 'occurrence', 'outcome', 'rationale', 'actionIds', 'actionBindings']) || !keys(item.ref, ['owner', 'relativePath', 'entryId']))
+            fail();
+        const key = corpusEntryKey(item);
+        if (seen.has(key) || entries.get(key)?.sha256 !== item.sha256 || entries.get(key)?.occurrence !== item.occurrence || !['retained', 'action'].includes(item.outcome)
+            || typeof item.rationale !== 'string' || !item.rationale.trim() || !Array.isArray(item.actionIds) || new Set(item.actionIds).size !== item.actionIds.length
+            || (item.outcome === 'retained' ? item.actionIds.length !== 0 : item.actionIds.length === 0)
+            || !Array.isArray(item.actionBindings) || item.actionBindings.length !== item.actionIds.length)
+            fail();
+        for (const [index, binding] of item.actionBindings.entries())
+            if (!keys(binding, ['actionId', 'revision', 'digest']) || binding.actionId !== item.actionIds[index] || !Number.isInteger(binding.revision) || binding.revision < 1 || !/^[a-f0-9]{64}$/.test(binding.digest))
+                fail();
+        seen.add(key);
+    }
+}

package/dist/registry/scripts/learning/owner-identity.js

@@ -0,0 +1,137 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ownerArtifactRoot = void 0;
+exports.ownerPath = ownerPath;
+exports.validateOwner = validateOwner;
+exports.ownerKey = ownerKey;
+exports.assertSameOwner = assertSameOwner;
+exports.resolveOwnerHome = resolveOwnerHome;
+exports.ownerArtifactPath = ownerArtifactPath;
+exports.configuredArtifactPath = configuredArtifactPath;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+/** A recorded home path is immutable; moving storage requires a newly reviewed run. */
+function ownerPath(root) {
+    const absolute = node_path_1.default.resolve(root).replace(/\\/g, '/');
+    return process.platform === 'win32' ? absolute.toLowerCase() : absolute;
+}
+function validateOwner(owner) {
+    if (!owner || !['Project', 'Manager', 'Org'].includes(owner.level)
+        || Object.keys(owner).some(key => !['level', 'path'].includes(key))
+        || typeof owner.path !== 'string' || !node_path_1.default.isAbsolute(owner.path)
+        || /[\x00-\x1f]/.test(owner.path) || owner.path !== ownerPath(owner.path)) {
+        throw new Error('owner-unresolved: a canonical absolute home path is required');
+    }
+}
+function ownerKey(owner) {
+    validateOwner(owner);
+    return JSON.stringify([owner.level, owner.path]);
+}
+function assertSameOwner(expected, actual) {
+    if (ownerKey(expected) !== ownerKey(actual))
+        throw new Error('owner-path-conflict: the approved home differs from the configured path');
+}
+/** Pure read: resolve existing configured homes without migration or identity configuration. */
+function resolveOwnerHome(projectPath, level, options) {
+    const load = (relative) => options.runtimeModule(projectPath, relative);
+    const paths = load('core/utils/project-fraim-paths');
+    let home;
+    if (level === 'Project') {
+        const root = paths.getWorkspaceFraimPath(projectPath);
+        home = { root, artifactRoot: node_path_1.default.resolve(projectPath), contentRoot: node_path_1.default.join(root, 'personalized-employee'), requiresPublish: false, backend: 'project' };
+    }
+    else {
+        if (!['Manager', 'Org'].includes(level))
+            throw new Error('owner-unresolved: invalid owner level');
+        const configFile = node_path_1.default.join(paths.getUserFraimDirPath(), 'config.json');
+        let config;
+        try {
+            config = node_fs_1.default.existsSync(configFile) ? JSON.parse(node_fs_1.default.readFileSync(configFile, 'utf8')) : {};
+        }
+        catch {
+            throw new Error('home-unavailable: user configuration is invalid');
+        }
+        if (!config || typeof config !== 'object' || Array.isArray(config))
+            throw new Error('home-unavailable: user configuration is invalid');
+        const raw = level === 'Manager' ? config.managerStorage : config.organization;
+        if (raw !== undefined && (!raw || typeof raw !== 'object' || Array.isArray(raw)
+            || !['git', 'local-folder', 'fraim-cloud', 'single-machine'].includes(raw.backend)
+            || (raw.backend === 'git' && (typeof raw.gitUrl !== 'string' || !raw.gitUrl.trim()))
+            || (raw.backend === 'local-folder' && (typeof raw.localPath !== 'string' || !raw.localPath.trim())))) {
+            throw new Error('home-unavailable: invalid configured storage home');
+        }
+        const resolved = load('cli/utils/pack-home').resolvePackHome(level === 'Manager' ? 'manager' : 'org', { migrateLegacy: false });
+        home = { root: resolved.root, contentRoot: resolved.contentRoot, requiresPublish: resolved.requiresPublish, backend: resolved.backend, ...(resolved.gitUrl ? { gitUrl: resolved.gitUrl } : {}) };
+    }
+    const owner = { level, path: ownerPath(home.root) };
+    if (options.expectedOwner)
+        assertSameOwner(options.expectedOwner, owner);
+    if (!node_fs_1.default.existsSync(home.root) || !node_fs_1.default.statSync(home.root).isDirectory()
+        || (home.backend === 'git' && !node_fs_1.default.existsSync(node_path_1.default.join(home.root, '.git')))) {
+        throw new Error('home-unavailable: configured home is not available locally');
+    }
+    return { ...home, level, owner };
+}
+/** Resolve a relative artifact without permitting lexical or realpath escapes, including junctions. */
+function ownerArtifactPath(home, relativePath) {
+    assertSameOwner(home.owner, { level: home.level, path: ownerPath(home.root) });
+    if (!relativePath || node_path_1.default.isAbsolute(relativePath) || relativePath.includes('\\')
+        || relativePath.includes(':') || relativePath.split('/').some(part => !part || part === '.' || part === '..')) {
+        throw new Error('invalid-artifact-path');
+    }
+    // Shared project capabilities live in the repository registry, outside its personalized pack.
+    const shared = home.level === 'Project' && relativePath.startsWith('registry/');
+    const containmentRoot = shared ? node_path_1.default.dirname(home.root) : home.root;
+    // The workspace configuration has one explicit reference; arbitrary parent paths stay forbidden.
+    const workspaceConfig = home.level === 'Project' && relativePath === 'config.json';
+    const contentRoot = shared ? containmentRoot : workspaceConfig ? home.root : home.contentRoot;
+    const target = node_path_1.default.resolve(contentRoot, relativePath);
+    const existingAncestor = (file) => {
+        let current = file;
+        while (!node_fs_1.default.existsSync(current)) {
+            const parent = node_path_1.default.dirname(current);
+            if (parent === current)
+                throw new Error('home-unavailable');
+            current = parent;
+        }
+        return current;
+    };
+    const realRoot = node_fs_1.default.realpathSync(containmentRoot);
+    const ancestor = node_fs_1.default.realpathSync(existingAncestor(target));
+    const relative = node_path_1.default.relative(realRoot, ancestor);
+    if (relative === '..' || relative.startsWith('..' + node_path_1.default.sep) || node_path_1.default.isAbsolute(relative))
+        throw new Error('invalid-artifact-path: escaped owner home');
+    // Also reject escaping a content root via a symlink to a sibling in the pack.
+    if (node_fs_1.default.existsSync(contentRoot)) {
+        const contentRelative = node_path_1.default.relative(node_fs_1.default.realpathSync(contentRoot), ancestor);
+        if (contentRelative === '..' || contentRelative.startsWith('..' + node_path_1.default.sep) || node_path_1.default.isAbsolute(contentRelative))
+            throw new Error('invalid-artifact-path: escaped content root');
+    }
+    return target;
+}
+/** Explicit artifact base; never infer a project from its personalized directory. */
+const ownerArtifactRoot = (home) => home.artifactRoot ?? home.root;
+exports.ownerArtifactRoot = ownerArtifactRoot;
+/** Configured artifacts may sit outside the personalized pack, but never outside their owner. */
+function configuredArtifactPath(home, file) {
+    assertSameOwner(home.owner, { level: home.level, path: ownerPath(home.root) });
+    const root = node_path_1.default.resolve((0, exports.ownerArtifactRoot)(home));
+    const target = node_path_1.default.resolve(file);
+    const relative = node_path_1.default.relative(root, target);
+    if (!relative || relative === '..' || relative.startsWith('..' + node_path_1.default.sep) || node_path_1.default.isAbsolute(relative))
+        throw new Error('invalid-artifact-path: escaped owner home');
+    for (let current = target; ownerPath(current) !== ownerPath(root); current = node_path_1.default.dirname(current)) {
+        try {
+            if (node_fs_1.default.lstatSync(current).isSymbolicLink())
+                throw new Error('invalid-artifact-path: linked artifact');
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+    }
+    return target;
+}

package/dist/src/ai-hub/conversation-store.js

@@ -11,6 +11,7 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const project_fraim_paths_1 = require("../core/utils/project-fraim-paths");
 const conversation_store_lock_1 = require("./conversation-store-lock");
+const proposal_set_contract_1 = require("../core/proposal-set-contract");
 const atomic_json_file_1 = require("./atomic-json-file");
 const conversation_search_projection_1 = require("./conversation-search-projection");
 // Issue #708: reserved, project-independent bucket keys for non-project scopes.
@@ -169,6 +170,45 @@ function conversationContinuityCompatible(left, right) {
         return false;
     return true;
 }
+// Acknowledged review snapshots are append-only presentation history. Merge under
+// the bucket lock so delayed browser patches and richer run projections cannot erase them.
+function mergeLearningReviewTurns(...sources) {
+    const turns = [];
+    const seen = new Set();
+    for (const source of sources) {
+        if (!Array.isArray(source))
+            continue;
+        for (const turn of source) {
+            if (!turn || !Number.isInteger(turn.messageCount) || turn.messageCount < 0
+                || !turn.proposalSet || (0, proposal_set_contract_1.validateProposalSet)(turn.proposalSet)
+                || !Array.isArray(turn.proposalSet.proposals) || !turn.proposalSet.proposals.length
+                || !Array.isArray(turn.decisions) || turn.decisions.length !== turn.proposalSet.proposals.length)
+                continue;
+            const proposals = turn.proposalSet.proposals;
+            if (!proposals.every((p, i) => {
+                const d = turn.decisions[i];
+                return d && d.proposalId === p.proposalId && d.revision === p.revision
+                    && ['approve', 'reject'].includes(d.action) && ['project', 'manager', 'org'].includes(d.level)
+                    && typeof d.reason === 'string';
+            }))
+                continue;
+            const indices = proposals.flatMap((p, i) => {
+                const key = JSON.stringify([p.proposalId, p.revision]);
+                if (seen.has(key))
+                    return [];
+                seen.add(key);
+                return [i];
+            });
+            if (indices.length)
+                turns.push({
+                    messageCount: turn.messageCount,
+                    proposalSet: { ...turn.proposalSet, proposals: indices.map((i) => proposals[i]) },
+                    decisions: indices.map((i) => turn.decisions[i]),
+                });
+        }
+    }
+    return turns;
+}
 // Place a raw conversation into a bucket, deduping by id. When the id already exists, keep the
 // richer copy (more run history); tie-break on newer lastUpdatedAt. Order-independent.
 function placeConversationInBucket(bucket, conv) {
@@ -196,6 +236,9 @@ function placeConversationInBucket(bucket, conv) {
         && timestampValue(value?.lastUpdatedAt) > timestampValue(existing.lastUpdatedAt)) {
         bucket.conversations[idx] = withStableConversationCreatedAt(existing, conv);
     }
+    const history = mergeLearningReviewTurns(existing.learningReviewTurns, conv.learningReviewTurns);
+    if (history.length)
+        bucket.conversations[idx].learningReviewTurns = history;
 }
 function stableConversationCreatedAt(existing, incoming) {
     const existingValue = existing?.createdAt;
@@ -651,8 +694,18 @@ class AiHubConversationStore {
                 }
                 catch { /* ignore */ }
             }
-            for (const conv of state.conversations)
+            for (const conv of state.conversations) {
+                try {
+                    const prior = JSON.parse(fs_1.default.readFileSync(this.convFilePath(bucketDir, conv.id), 'utf8')).conversation;
+                    if (conversationContinuityCompatible(prior, conv)) {
+                        const history = mergeLearningReviewTurns(prior?.learningReviewTurns, conv.learningReviewTurns);
+                        if (history.length)
+                            conv.learningReviewTurns = history;
+                    }
+                }
+                catch { /* no prior copy */ }
                 this.writeConvFile(bucketDir, bucketKey, conv);
+            }
             this.writeIndex(bucketDir, bucketKey, state.activeId, state.conversations);
             // Issue #1065 (GDPR Art. 17 / C1): deletion must reach every copy. The whole-bucket
             // rewrite prunes conversation shards that are no longer wanted; prune the matching
@@ -903,12 +956,19 @@ class AiHubConversationStore {
                 this.writeConvFile(bucketDir, key, candidate);
                 return this.reindexAfterUpsert(bucketDir, key, candidate, undefined);
             }
+            const history = mergeLearningReviewTurns(existing.learningReviewTurns, patch.learningReviewTurns);
             if (patch.lastUpdatedAt !== undefined && timestampValue(patch.lastUpdatedAt) < timestampValue(existing.lastUpdatedAt)) {
+                if (JSON.stringify(history) !== JSON.stringify(mergeLearningReviewTurns(existing.learningReviewTurns))) {
+                    existing.learningReviewTurns = history;
+                    this.writeConvFile(bucketDir, key, existing);
+                    return this.reindexAfterUpsert(bucketDir, key, existing, undefined);
+                }
                 return this.stateFromIndex(bucketDir, key);
             }
             const merged = normalizeConversation(key, {
                 ...existing,
                 ...patch,
+                ...(history.length ? { learningReviewTurns: history } : {}),
                 id: existing.id,
                 projectPath: key,
                 agentName: patch.agentName || existing.agentName,

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

@@ -5856,6 +5856,7 @@ class AiHubServer {
             }
             try {
                 const result = (0, learning_context_builder_1.applyLearningEntryChange)(resolveProjectPath(req), userEmail, ref, b.action, {
+                    originalId: b.originalId,
                     originalTitle: b.originalTitle,
                     severity: b.severity,
                     title: b.title,