fraim 2.0.343 → 2.0.344

package/dist/registry/scripts/artifact-paths.js

@@ -0,0 +1,108 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_ARTIFACT_PATHS = void 0;
+exports.resolveArtifactPaths = resolveArtifactPaths;
+exports.resolveLearningPaths = resolveLearningPaths;
+exports.resolveRunJournalDirectory = resolveRunJournalDirectory;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const local_runtime_1 = require("./learning-usage/local-runtime");
+/** Existing layout suffixes, also used to validate saved receipts; these are not config keys. */
+exports.DEFAULT_ARTIFACT_PATHS = { evidence: 'docs/evidence', raw: 'learnings/raw', retrospectives: 'learnings/retrospectives', archive: 'learnings/archive' };
+const key = (value) => process.platform === 'win32' ? value.toLowerCase() : value;
+const within = (root, target) => {
+    const rel = node_path_1.default.relative(key(root), key(target));
+    return rel === '' || (rel !== '..' && !rel.startsWith('..' + node_path_1.default.sep) && !node_path_1.default.isAbsolute(rel));
+};
+function existingAncestor(target) {
+    let current = target;
+    while (!node_fs_1.default.existsSync(current)) {
+        const parent = node_path_1.default.dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    return current;
+}
+function relativeDirectory(value, field) {
+    if (typeof value !== 'string' || !value || value.includes('\\') || /[:*?"<>|\x00-\x1f]/.test(value)
+        || node_path_1.default.isAbsolute(value) || value.split('/').some(part => !part || part === '.' || part === '..' || /[. ]$/.test(part))) {
+        throw new Error(`Invalid artifactPaths.${field}: expected a relative directory within its owning home`);
+    }
+}
+function directory(root, value, field) {
+    relativeDirectory(value, field);
+    const target = node_path_1.default.resolve(root, value);
+    if (!within(root, target))
+        throw new Error(`Invalid artifactPaths.${field}: path escapes owning home`);
+    // Reads never provision homes. Existing links must not redirect a writer outside its owner.
+    if (node_fs_1.default.existsSync(root) && !within(node_fs_1.default.realpathSync(root), node_fs_1.default.realpathSync(existingAncestor(target)))) {
+        throw new Error(`Invalid artifactPaths.${field}: linked path escapes owning home`);
+    }
+    if (node_fs_1.default.existsSync(target) && !node_fs_1.default.statSync(target).isDirectory())
+        throw new Error(`Invalid artifactPaths.${field}: target is not a directory`);
+    return target.replace(/\\/g, '/');
+}
+function resolveArtifactPaths(homeRoot, contentRoot) {
+    if (!node_path_1.default.isAbsolute(homeRoot) || !node_path_1.default.isAbsolute(contentRoot))
+        throw new Error('Absolute owning homeRoot and contentRoot are required');
+    homeRoot = node_path_1.default.resolve(homeRoot);
+    contentRoot = node_path_1.default.resolve(contentRoot);
+    if (!within(homeRoot, contentRoot))
+        throw new Error('Personalized contentRoot escapes owning homeRoot');
+    const configPath = node_path_1.default.join(node_path_1.default.dirname(contentRoot), 'config.json');
+    let config = {};
+    try {
+        config = (0, local_runtime_1.readJsonIfObject)(configPath, { strict: true });
+    }
+    catch {
+        throw new Error(`Cannot read artifact configuration: ${configPath}`);
+    }
+    const configured = config.artifactPaths === undefined ? {} : config.artifactPaths;
+    // Defaults follow the configured home layout, but every value has the same root-relative basis.
+    // Resolve only in memory: config.json stores user overrides, never materialized defaults.
+    const contentDirectory = node_path_1.default.relative(homeRoot, contentRoot).replace(/\\/g, '/');
+    const defaults = {
+        evidence: exports.DEFAULT_ARTIFACT_PATHS.evidence,
+        rawLearnings: node_path_1.default.posix.join(contentDirectory, exports.DEFAULT_ARTIFACT_PATHS.raw),
+        learningRetrospectives: node_path_1.default.posix.join(contentDirectory, exports.DEFAULT_ARTIFACT_PATHS.retrospectives),
+        learningArchive: node_path_1.default.posix.join(contentDirectory, exports.DEFAULT_ARTIFACT_PATHS.archive),
+    };
+    if (!configured || typeof configured !== 'object' || Array.isArray(configured)
+        || Object.keys(configured).some(field => !Object.prototype.hasOwnProperty.call(defaults, field)))
+        throw new Error('Invalid artifactPaths configuration: use evidence, rawLearnings, learningRetrospectives or learningArchive');
+    const values = { ...defaults, ...configured };
+    for (const [field, value] of Object.entries(values))
+        relativeDirectory(value, field);
+    const outputs = {
+        evidence: directory(homeRoot, values.evidence, 'evidence'),
+        raw: directory(homeRoot, values.rawLearnings, 'rawLearnings'),
+        retrospectives: directory(homeRoot, values.learningRetrospectives, 'learningRetrospectives'),
+        archive: directory(homeRoot, values.learningArchive, 'learningArchive'),
+    };
+    const entries = Object.entries(outputs);
+    for (let index = 0; index < entries.length; index++)
+        for (const [otherField, other] of entries.slice(index + 1)) {
+            const [field, target] = entries[index];
+            if (within(target, other) || within(other, target))
+                throw new Error(`Artifact directories overlap: ${field} and ${otherField}`);
+        }
+    return { configPath: configPath.replace(/\\/g, '/'), evidence: outputs.evidence, raw: outputs.raw,
+        retrospectives: outputs.retrospectives,
+        archiveRaw: directory(homeRoot, values.learningArchive + '/raw', 'learningArchive'),
+        archiveRetrospectives: directory(homeRoot, values.learningArchive + '/retrospectives', 'learningArchive') };
+}
+/** Learning readers use the same owner and mapping as inventory and completion. */
+function resolveLearningPaths(homeRoot, contentRoot) {
+    const { evidence, ...learningPaths } = resolveArtifactPaths(homeRoot, contentRoot);
+    return learningPaths;
+}
+/** Recovery journals stay discoverable when configurable evidence outputs move. */
+function resolveRunJournalDirectory(homeRoot) {
+    if (!node_path_1.default.isAbsolute(homeRoot))
+        throw new Error('Absolute owning homeRoot is required');
+    return directory(node_path_1.default.resolve(homeRoot), exports.DEFAULT_ARTIFACT_PATHS.evidence + '/sleep', 'runJournal');
+}

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

@@ -3,14 +3,186 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.COMPLETION_END = exports.COMPLETION_START = void 0;
+exports.COMPLETION_END = exports.COMPLETION_START = exports.UnsupportedRunHistoryError = exports.sourcePathKey = void 0;
+exports.cycleRetrospectivePath = cycleRetrospectivePath;
 exports.validateProcessedSources = validateProcessedSources;
+exports.canonicalJournal = canonicalJournal;
+exports.readRunJournal = readRunJournal;
+exports.readSourceReservations = readSourceReservations;
+exports.normalizeSourceParticipants = normalizeSourceParticipants;
+exports.sourceAuthorAllowed = sourceAuthorAllowed;
 exports.decodeCompletion = decodeCompletion;
 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 sourcePathKey = (file) => {
+    const value = node_path_1.default.resolve(file).replace(/\\/g, '/');
+    return process.platform === 'win32' ? value.toLowerCase() : value;
+};
+exports.sourcePathKey = sourcePathKey;
+function cycleRetrospectivePath(runId, author, level, directory = artifact_paths_1.DEFAULT_ARTIFACT_PATHS.retrospectives) {
+    return `${directory}/${author}-${runId}-${level === 'Org' ? 'organizational-learning-synthesis' : 'sleep-on-learnings'}-retrospective.md`;
+}
 function validateProcessedSources(sources) {
-    if (!Array.isArray(sources) || new Set(sources.map(item => item.path)).size !== sources.length || sources.some(item => !item || !node_path_1.default.isAbsolute(item.path) || !node_path_1.default.isAbsolute(item.destination) || !['raw', 'retrospective'].includes(item.kind)
-        || !/^[a-f0-9]{64}$/.test(item.sha256) || !/^[a-f0-9]{64}$/.test(item.resultHash) || !/^\d{4}-\d{2}-\d{2}$/.test(item.synthesizedAt)))
+    if (!Array.isArray(sources))
         throw new Error('invalid-processed-sources');
+    const paths = new Set();
+    for (const item of sources) {
+        if (!item || !node_path_1.default.isAbsolute(item.path) || !node_path_1.default.isAbsolute(item.destination) || !['raw', 'retrospective'].includes(item.kind)
+            || !/^[a-f0-9]{64}$/.test(item.sha256) || !/^[a-f0-9]{64}$/.test(item.resultHash)
+            || !/^\d{4}-\d{2}-\d{2}$/.test(item.synthesizedAt) || !Number.isFinite(Date.parse(item.synthesizedAt))
+            || new Date(item.synthesizedAt).toISOString().slice(0, 10) !== item.synthesizedAt)
+            throw new Error('invalid-processed-sources');
+        const source = (0, exports.sourcePathKey)(item.path), destination = (0, exports.sourcePathKey)(item.destination);
+        if (/[\x00-\x1f]/.test(item.path + item.destination) || source === destination
+            || (0, exports.sourcePathKey)(node_path_1.default.basename(item.path)) !== (0, exports.sourcePathKey)(node_path_1.default.basename(item.destination))
+            || paths.has(source) || paths.has(destination))
+            throw new Error('invalid-processed-sources');
+        const folder = item.kind === 'raw' ? 'raw' : 'retrospectives';
+        if (item.layout !== undefined) {
+            const layout = item.layout;
+            if (!layout || Object.keys(layout).some(key => !['homeRoot', 'contentRoot', 'sourceDirectory', 'archiveDirectory'].includes(key)) || ['contentRoot', 'sourceDirectory', 'archiveDirectory', ...(layout.homeRoot !== undefined ? ['homeRoot'] : [])].some(key => typeof layout[key] !== 'string' || !node_path_1.default.isAbsolute(layout[key]) || /[\x00-\x1f]/.test(layout[key])))
+                throw new Error('invalid-processed-sources');
+            const contentRoot = (0, exports.sourcePathKey)(layout.homeRoot ?? layout.contentRoot);
+            for (const directory of [layout.sourceDirectory, layout.archiveDirectory, ...(layout.homeRoot ? [layout.contentRoot] : [])]) {
+                const relative = node_path_1.default.relative(contentRoot, (0, exports.sourcePathKey)(directory));
+                if (!relative || relative === '..' || relative.startsWith('..' + node_path_1.default.sep) || node_path_1.default.isAbsolute(relative))
+                    throw new Error('invalid-processed-sources');
+            }
+            if ((0, exports.sourcePathKey)(node_path_1.default.dirname(item.path)) !== (0, exports.sourcePathKey)(layout.sourceDirectory)
+                || (0, exports.sourcePathKey)(node_path_1.default.dirname(item.destination)) !== (0, exports.sourcePathKey)(layout.archiveDirectory)
+                || node_path_1.default.basename(layout.archiveDirectory) !== folder)
+                throw new Error('invalid-processed-sources');
+        }
+        else {
+            // Only the already supported default-layout receipts omit a frozen layout.
+            const sourceDir = item.kind === 'raw' ? artifact_paths_1.DEFAULT_ARTIFACT_PATHS.raw : artifact_paths_1.DEFAULT_ARTIFACT_PATHS.retrospectives;
+            const suffix = `/${sourceDir}/${node_path_1.default.basename(item.path).toLowerCase()}`;
+            const contentRoot = node_path_1.default.resolve(item.path, ...sourceDir.split('/').map(() => '..'), '..');
+            const expected = (0, exports.sourcePathKey)(node_path_1.default.join(contentRoot, artifact_paths_1.DEFAULT_ARTIFACT_PATHS.archive, folder, node_path_1.default.basename(item.path)));
+            if (!source.toLowerCase().endsWith(suffix) || destination !== expected)
+                throw new Error('invalid-processed-sources');
+        }
+        paths.add(source);
+        paths.add(destination);
+    }
+}
+function canonicalJournal(value) {
+    return Array.isArray(value) ? '[' + value.map(canonicalJournal).join(',') + ']'
+        : value && typeof value === 'object' ? '{' + Object.keys(value).filter(key => value[key] !== undefined).sort().map(key => JSON.stringify(key) + ':' + canonicalJournal(value[key])).join(',') + '}' : JSON.stringify(value);
+}
+const journalHash = (value) => (0, node_crypto_1.createHash)('sha256').update(canonicalJournal(value)).digest('hex');
+class UnsupportedRunHistoryError extends Error {
+    constructor() { super('unsupported-run-history'); }
+}
+exports.UnsupportedRunHistoryError = UnsupportedRunHistoryError;
+/** Recognize the receipts written before typed sources and archive subdirectories existed. */
+function historicalProcessedSources(sources) {
+    if (!Array.isArray(sources))
+        return false;
+    const paths = new Set();
+    return sources.every(item => {
+        if (!keys(item, ['path', 'destination', 'kind', 'sha256', 'resultHash', 'synthesizedAt'])
+            || !text(item.path) || !text(item.destination) || !node_path_1.default.isAbsolute(item.path) || !node_path_1.default.isAbsolute(item.destination)
+            || /[\x00-\x1f]/.test(item.path + item.destination) || !hash(item.sha256) || !hash(item.resultHash)
+            || typeof item.synthesizedAt !== 'string' || !/^\d{4}-\d{2}-\d{2}$/.test(item.synthesizedAt)
+            || !Number.isFinite(Date.parse(item.synthesizedAt)) || new Date(item.synthesizedAt).toISOString().slice(0, 10) !== item.synthesizedAt)
+            return false;
+        const source = (0, exports.sourcePathKey)(item.path), destination = (0, exports.sourcePathKey)(item.destination);
+        if (paths.has(source))
+            return false;
+        paths.add(source);
+        if (item.kind === 'retrospective') {
+            // A current learnings/retrospectives receipt with a broken destination is not historical.
+            return source === destination && /\/retrospectives\/.+/.test(source)
+                && !/\/learnings\/retrospectives\//.test(source);
+        }
+        return item.kind === 'raw' && /\/learnings\/raw\/.+/.test(source)
+            && destination === source.replace(/\/learnings\/raw\//, '/learnings/archive/') && item.sha256 === item.resultHash;
+    });
+}
+/** Shared, read-only boundary: validate the full chain before excluding a recognized prior format. */
+function readRunJournal(file) {
+    const raw = node_fs_1.default.readFileSync(file, 'utf8');
+    if (!raw.endsWith('\n'))
+        throw new Error('journal-truncated: explicit recovery required');
+    const events = [], operations = new Set();
+    let lastHash = '';
+    for (const line of raw.trimEnd().split('\n')) {
+        let event;
+        try {
+            event = JSON.parse(line);
+        }
+        catch {
+            throw new Error('journal-corrupt');
+        }
+        if (!event || !event.payload || event.sequence !== events.length + 1 || event.previousHash !== lastHash
+            || event.payloadHash !== journalHash(event.payload) || typeof event.operationId !== 'string'
+            || !/^[a-zA-Z0-9][a-zA-Z0-9_.-]{0,159}$/.test(event.operationId))
+            throw new Error('journal-corrupt');
+        if (operations.has(event.operationId))
+            throw new Error('journal-duplicate-operation');
+        operations.add(event.operationId);
+        events.push(event);
+        lastHash = journalHash(event);
+    }
+    const created = events[0]?.payload;
+    if (created?.type !== 'created' || created.data?.schemaVersion !== 1 || !ownerValid(created.data.owner)
+        || !/^[a-zA-Z0-9][a-zA-Z0-9_.-]{0,159}$/.test(created.data.runId) || !text(created.data.reviewer))
+        throw new Error('invalid-run');
+    const plans = events.filter(event => event.payload.type === 'source-completion').map(event => event.payload.data);
+    try {
+        for (const sources of plans)
+            validateProcessedSources(sources);
+    }
+    catch (error) {
+        if (keys(created.data, ['schemaVersion', 'runId', 'owner', 'reviewer'])
+            && plans.length > 0 && plans.every(historicalProcessedSources))
+            return { events, lastHash, format: 'historical' };
+        throw error;
+    }
+    return { events, lastHash, format: 'current' };
+}
+/** Only exact, hash-chain-verified current archive plans reserve files. Older plans are outside this lifecycle. */
+function readSourceReservations(runDirectories, excludingRunFile) {
+    const reserved = new Set();
+    for (const directory of new Set(runDirectories.map(dir => node_path_1.default.resolve(dir)))) {
+        let names;
+        try {
+            names = node_fs_1.default.readdirSync(directory);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                continue;
+            throw error;
+        }
+        for (const name of names.filter(name => name.endsWith('.queue.jsonl'))) {
+            const file = node_path_1.default.join(directory, name);
+            if (excludingRunFile && (0, exports.sourcePathKey)(file) === (0, exports.sourcePathKey)(excludingRunFile))
+                continue;
+            try {
+                if (node_fs_1.default.lstatSync(file).isSymbolicLink())
+                    throw new Error('run-path-link-conflict');
+                const journal = readRunJournal(file);
+                if (journal.format === 'historical')
+                    continue;
+                for (const event of journal.events)
+                    if (event.payload.type === 'source-completion') {
+                        for (const source of event.payload.data) {
+                            reserved.add((0, exports.sourcePathKey)(source.path));
+                            reserved.add((0, exports.sourcePathKey)(source.destination));
+                        }
+                    }
+            }
+            catch (error) {
+                if (error.code === 'ENOENT')
+                    continue;
+                throw Object.assign(new Error('source-reservation-journal-conflict'), { cause: error });
+            }
+        }
+    }
+    return [...reserved].sort();
 }
 exports.COMPLETION_START = '<!-- fraim-sleep-decisions:v1 -->';
 exports.COMPLETION_END = '<!-- /fraim-sleep-decisions -->';
@@ -22,6 +194,27 @@ const ownerValid = (value) => object(value) && ['Project', 'Manager', 'Org'].inc
     && keys(value, ['level', 'path']) && text(value.path) && node_path_1.default.isAbsolute(value.path)
     && !/[\x00-\x1f]/.test(value.path) && value.path === (process.platform === 'win32' ? node_path_1.default.resolve(value.path).replace(/\\/g, '/').toLowerCase() : node_path_1.default.resolve(value.path));
 const sameOwner = (a, b) => a.level === b.level && a.path === b.path;
+/** Explicit session grants are bound to an Org run, never inferred from source metadata. */
+function normalizeSourceParticipants(value, owner) {
+    if (owner.level !== 'Org' || !Array.isArray(value))
+        throw new Error('invalid-source-participants');
+    const identities = new Set();
+    const result = value.map(item => {
+        if (!keys(item, ['author', 'owner']) || !text(item.author) || item.author.trim() !== item.author
+            || /[\\/:*?"<>|\x00-\x1f]/.test(item.author) || /[. ]$/.test(item.author) || !ownerValid(item.owner))
+            throw new Error('invalid-source-participants');
+        const identity = JSON.stringify([item.author, item.owner.level, item.owner.path]);
+        if (identities.has(identity))
+            throw new Error('invalid-source-participants');
+        identities.add(identity);
+        return { author: item.author, owner: { ...item.owner } };
+    });
+    return result.sort((a, b) => JSON.stringify(a).localeCompare(JSON.stringify(b)));
+}
+function sourceAuthorAllowed(context, author, owner) {
+    return author === context.reviewer || (context.owner.level === 'Org'
+        && !!context.sourceParticipants?.some(grant => grant.author === author && sameOwner(grant.owner, owner)));
+}
 function decodeCompletion(markdown, expected = {}) {
     const fail = () => { throw new Error('invalid-completion-decisions'); };
     if ((markdown.match(/<!--\s*fraim-sleep-decisions:/g) || []).length !== 1 || markdown.split(exports.COMPLETION_START).length !== 2 || markdown.split(exports.COMPLETION_END).length !== 2)
@@ -40,16 +233,23 @@ function decodeCompletion(markdown, expected = {}) {
     catch {
         fail();
     }
-    if (!keys(state, ['schemaVersion', 'runId', 'owner', 'finalizationState', 'decisions', 'sourceDispositions', 'cleanup', 'reconciliations', 'retrospective', 'processedSources']) || 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']) || 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)))
         fail();
     if (state.retrospective !== undefined && (!keys(state.retrospective, ['relativePath', 'sha256'])
-        || state.retrospective.relativePath !== `retrospectives/${state.runId}-sleep-postmortem.md` || !hash(state.retrospective.sha256)))
+        || typeof state.retrospective.relativePath !== 'string' || node_path_1.default.isAbsolute(state.retrospective.relativePath)
+        || state.retrospective.relativePath.includes('\\') || state.retrospective.relativePath.includes(':')
+        || /[\x00-\x1f]/.test(state.retrospective.relativePath)
+        || state.retrospective.relativePath.split('/').some((part) => !part || part === '.' || part === '..')
+        || !node_path_1.default.basename(state.retrospective.relativePath).endsWith(`-${state.runId}-${state.owner.level === 'Org' ? 'organizational-learning-synthesis' : 'sleep-on-learnings'}-retrospective.md`)
+        || !hash(state.retrospective.sha256)))
         fail();
     if (state.processedSources !== undefined)
         validateProcessedSources(state.processedSources);
+    if (state.sourceParticipants !== undefined)
+        normalizeSourceParticipants(state.sourceParticipants, state.owner);
     const ids = new Set();
     for (const item of state.decisions) {
         if (!keys(item, ['actionId', 'revision', 'digest', 'owner', 'claimKey', 'evidenceFingerprint', 'sourceRefs', 'decision', 'publicationRef', 'target', 'dependencies']) || !text(item.actionId) || ids.has(item.actionId) || !Number.isInteger(item.revision) || item.revision < 1 || !hash(item.digest) || !ownerValid(item.owner)

package/dist/registry/scripts/learning-usage/local-runtime.js

@@ -0,0 +1,217 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WORKSPACE_FRAIM_DIRNAME = exports.LEARNING_DOMAINS = void 0;
+exports.getWorkspaceFraimDir = getWorkspaceFraimDir;
+exports.getWorkspaceConfigPath = getWorkspaceConfigPath;
+exports.getWorkspaceFraimPath = getWorkspaceFraimPath;
+exports.getWorkspaceFraimDisplayPath = getWorkspaceFraimDisplayPath;
+exports.getUserFraimDirPath = getUserFraimDirPath;
+exports.getUserFraimDisplayPath = getUserFraimDisplayPath;
+exports.getUserFraimLearningsDir = getUserFraimLearningsDir;
+exports.getWorkspaceLearningsDir = getWorkspaceLearningsDir;
+exports.getConfiguredPortableLearningsDir = getConfiguredPortableLearningsDir;
+exports.getConfiguredPortableLearningsDisplayPath = getConfiguredPortableLearningsDisplayPath;
+exports.readBrandFromDir = readBrandFromDir;
+exports.resolvePackHome = resolvePackHome;
+exports.readJsonIfObject = readJsonIfObject;
+exports.isPathInsideOrEqual = isPathInsideOrEqual;
+const fs_1 = require("fs");
+const os_1 = __importDefault(require("os"));
+const path_1 = require("path");
+/** Share domain data with the MCP runtime and proposal authoring helpers. */
+exports.LEARNING_DOMAINS = Object.freeze(JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(__dirname, '../learning/learning-domains.json'), 'utf8')).domains);
+exports.WORKSPACE_FRAIM_DIRNAME = 'fraim';
+function getWorkspaceFraimDir(projectRoot = process.cwd()) {
+    return (0, path_1.join)(projectRoot, exports.WORKSPACE_FRAIM_DIRNAME);
+}
+function getWorkspaceConfigPath(projectRoot = process.cwd()) {
+    return (0, path_1.join)(getWorkspaceFraimDir(projectRoot), 'config.json');
+}
+function getWorkspaceFraimPath(projectRoot = process.cwd(), ...parts) {
+    return (0, path_1.join)(getWorkspaceFraimDir(projectRoot), ...parts);
+}
+function getWorkspaceFraimDisplayPath(relativePath = '') {
+    const normalized = normalizeRelativePath(relativePath);
+    return normalized.length > 0 ? `${exports.WORKSPACE_FRAIM_DIRNAME}/${normalized}` : `${exports.WORKSPACE_FRAIM_DIRNAME}/`;
+}
+function getUserFraimDirPath() {
+    const override = process.env.FRAIM_USER_DIR;
+    if (override)
+        return override;
+    if (process.env.FRAIM_TEST_SANDBOX === '1') {
+        throw new Error('FRAIM_USER_DIR is unset inside a sandboxed test run (FRAIM_TEST_SANDBOX=1). ' +
+            'Refusing to fall back to the real ~/.fraim.');
+    }
+    return (0, path_1.join)(os_1.default.homedir(), '.fraim');
+}
+function getUserFraimDisplayPath(relativePath = '') {
+    const normalized = normalizeRelativePath(relativePath);
+    return normalized.length > 0 ? `~/.fraim/${normalized}` : '~/.fraim/';
+}
+function getUserFraimLearningsDir() {
+    return (0, path_1.join)(getUserFraimDirPath(), 'personalized-employee', 'learnings');
+}
+function getWorkspaceLearningsDir(projectRoot = process.cwd()) {
+    return getWorkspaceFraimPath(projectRoot, 'personalized-employee', 'learnings');
+}
+function getConfiguredPortableLearningsDir(projectRoot = process.cwd()) {
+    const config = readWorkspaceConfig(projectRoot);
+    const configured = resolveConfiguredLearningGlobalPath(config?.learning?.globalPath);
+    return configured || getUserFraimLearningsDir();
+}
+function getConfiguredPortableLearningsDisplayPath(projectRoot = process.cwd()) {
+    const config = readWorkspaceConfig(projectRoot);
+    const configured = resolveConfiguredLearningGlobalPath(config?.learning?.globalPath);
+    if (configured)
+        return normalizeDisplayPath(configured);
+    return getUserFraimDisplayPath('personalized-employee/learnings').replace(/\/$/, '');
+}
+function readBrandFromDir(dir) {
+    const brandPath = (0, path_1.join)(dir, 'org_brand.json');
+    try {
+        if (!(0, fs_1.existsSync)(brandPath))
+            return null;
+        const parsed = JSON.parse((0, fs_1.readFileSync)(brandPath, 'utf8'));
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function resolvePackHome(layer) {
+    const config = getLayerBackend(layer);
+    const standard = standardHome(layer);
+    const make = (root, extra) => ({
+        layer,
+        root,
+        contentRoot: (0, path_1.join)(root, 'personalized-employee'),
+        ...extra,
+    });
+    if (!config || config.backend === 'single-machine') {
+        return make(standard, {
+            backend: config?.backend ?? 'single-machine',
+            synced: false,
+            requiresPublish: false,
+        });
+    }
+    if (config.backend === 'local-folder' && config.localPath) {
+        return make(absolutize(config.localPath), {
+            backend: 'local-folder',
+            synced: true,
+            requiresPublish: false,
+            legacyRoot: standard,
+        });
+    }
+    if (config.backend === 'git' && config.gitUrl) {
+        return make(config.localPath ? absolutize(config.localPath) : defaultCloneDir(layer), {
+            backend: 'git',
+            synced: true,
+            requiresPublish: true,
+            gitUrl: config.gitUrl,
+            legacyRoot: standard,
+        });
+    }
+    if (config.backend === 'fraim-cloud') {
+        return make(cloudHome(layer), {
+            backend: 'fraim-cloud',
+            synced: true,
+            requiresPublish: true,
+            legacyRoot: standard,
+        });
+    }
+    return make(standard, {
+        backend: config.backend,
+        synced: false,
+        requiresPublish: false,
+    });
+}
+function normalizeRelativePath(relativePath) {
+    return relativePath.replace(/^[\\/]+/, '').replace(/[\\/]+/g, '/');
+}
+function normalizeDisplayPath(fullPath) {
+    return fullPath.replace(/\\/g, '/');
+}
+/** Existing config reader; strict consumers reject damaged configuration instead of guessing defaults. */
+function readJsonIfObject(filePath, options = {}) {
+    try {
+        if (!options.strict && !(0, fs_1.existsSync)(filePath))
+            return {};
+        const content = (0, fs_1.readFileSync)(filePath, 'utf8');
+        const parsed = JSON.parse(options.strict ? content.replace(/^\uFEFF/, '') : content);
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed))
+            return parsed;
+        if (options.strict)
+            throw new Error(`Invalid configuration object: ${filePath}`);
+        return {};
+    }
+    catch (error) {
+        if (options.strict && error.code !== 'ENOENT')
+            throw error;
+        return {};
+    }
+}
+function readWorkspaceConfig(projectRoot) {
+    return readJsonIfObject(getWorkspaceConfigPath(projectRoot));
+}
+function readUserFraimConfig() {
+    return readJsonIfObject((0, path_1.join)(getUserFraimDirPath(), 'config.json'));
+}
+function getLayerBackend(layer) {
+    const raw = (layer === 'manager'
+        ? readUserFraimConfig().managerStorage
+        : readUserFraimConfig().organization);
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const backend = raw.backend;
+    if (backend !== 'single-machine' && backend !== 'local-folder' && backend !== 'git' && backend !== 'fraim-cloud') {
+        return null;
+    }
+    const localPath = typeof raw.localPath === 'string' ? raw.localPath.trim() : '';
+    const gitUrl = typeof raw.gitUrl === 'string' ? raw.gitUrl.trim() : '';
+    const id = typeof raw.id === 'string' ? raw.id : undefined;
+    if (backend === 'local-folder')
+        return localPath ? { backend, localPath, id } : null;
+    if (backend === 'git')
+        return gitUrl ? { backend, gitUrl, id, ...(localPath ? { localPath } : {}) } : null;
+    return { backend, id };
+}
+function resolveConfiguredLearningGlobalPath(rawPath) {
+    if (typeof rawPath !== 'string')
+        return null;
+    const trimmed = rawPath.trim();
+    if (!trimmed)
+        return null;
+    if (/^[a-z]+:\/\//i.test(trimmed))
+        return null;
+    if (trimmed.startsWith('~')) {
+        const homeRelative = trimmed.slice(1).replace(/^[\\/]+/, '');
+        return (0, path_1.normalize)((0, path_1.join)(os_1.default.homedir(), homeRelative));
+    }
+    if (!(0, path_1.isAbsolute)(trimmed))
+        return null;
+    return (0, path_1.normalize)(trimmed);
+}
+function absolutize(p) {
+    return (0, path_1.isAbsolute)(p) ? p : (0, path_1.resolve)(getUserFraimDirPath(), p);
+}
+function packsDir() {
+    return (0, path_1.join)(getUserFraimDirPath(), 'packs');
+}
+function standardHome(layer) {
+    if (layer === 'manager')
+        return getUserFraimDirPath();
+    return (0, path_1.join)(getUserFraimDirPath(), 'org');
+}
+function cloudHome(layer) {
+    return (0, path_1.join)(getUserFraimDirPath(), layer === 'org' ? 'org' : 'manager');
+}
+function defaultCloneDir(layer) {
+    return (0, path_1.join)(packsDir(), `${layer}-repo`);
+}
+function isPathInsideOrEqual(parentPath, childPath) {
+    const rel = (0, path_1.relative)(parentPath, childPath);
+    return rel === '' || (rel.length > 0 && !rel.startsWith('..') && !(0, path_1.isAbsolute)(rel));
+}

package/dist/src/cli/commands/init-project.js

@@ -14,7 +14,6 @@ const platform_detection_1 = require("../utils/platform-detection");
 const ide_detector_1 = require("../setup/ide-detector");
 const claude_code_telemetry_1 = require("../setup/claude-code-telemetry");
 const fraim_gitignore_1 = require("../utils/fraim-gitignore");
-const agent_adapters_1 = require("../utils/agent-adapters");
 const project_fraim_paths_1 = require("../../core/utils/project-fraim-paths");
 const project_bootstrap_1 = require("../utils/project-bootstrap");
 const user_config_1 = require("../utils/user-config");
@@ -148,9 +147,6 @@ const runInitProject = async (options = {}) => {
     }
     [
         'jobs',
-        'ai-employee/jobs',
-        'ai-employee/skills',
-        'ai-manager/jobs',
         'personalized-employee',
     ].forEach((dir) => {
         const dirPath = path_1.default.join(fraimDir, dir);
@@ -172,7 +168,7 @@ const runInitProject = async (options = {}) => {
         console.log(chalk_1.default.green('Removed legacy FRAIM sync block from .gitignore'));
     }
     if (!process.env.FRAIM_SKIP_SYNC) {
-        await (0, sync_1.runSync)({ projectRoot, failHard, projectAdapters: options.projectAdapters });
+        await (0, sync_1.runSync)({ projectRoot, failHard });
         result.syncPerformed = true;
     }
     else {
@@ -191,16 +187,10 @@ const runInitProject = async (options = {}) => {
     if (claudeCodeAvailable) {
         (0, claude_code_telemetry_1.ensureClaudeCodeTelemetryEnv)();
     }
-    if (options.projectAdapters) {
-        const adapterUpdates = (0, agent_adapters_1.ensureAgentAdapterFiles)(projectRoot, detectedConfigTypes.length > 0 ? detectedConfigTypes : null);
-        if (adapterUpdates.length > 0) {
-            console.log(chalk_1.default.green(`Updated FRAIM agent adapter files: ${adapterUpdates.join(', ')}`));
-        }
-    }
     (0, project_bootstrap_1.printInitProjectSummary)(result);
 };
 exports.runInitProject = runInitProject;
 exports.initProjectCommand = new commander_1.Command('init-project')
     .description('Initialize FRAIM in the current project (requires global setup)')
-    .option('--project-adapters', 'Write legacy project-local FRAIM agent adapter files')
+    .option('--project-adapters', 'Deprecated compatibility option (no effect; use machine-level FRAIM setup)')
     .action((options) => (0, exports.runInitProject)({ projectAdapters: Boolean(options.projectAdapters) }));