fraim 2.0.248 → 2.0.249

package/dist/src/cli/utils/pack-git-publish.js

@@ -0,0 +1,248 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openGitHubPullRequest = exports.ALLOWED_GIT_URL = void 0;
+exports.redactGitUrl = redactGitUrl;
+exports.gitCompareUrl = gitCompareUrl;
+exports.parseGitHubSlug = parseGitHubSlug;
+exports.describePackChange = describePackChange;
+exports.publishPackToGitRepo = publishPackToGitRepo;
+/**
+ * Shared git-backed publish for the manager and org packs (issue #1043).
+ *
+ * Before this module, manager-publish.ts and org-publish.ts each carried a
+ * byte-identical clone/branch/commit/push block and their own copy of
+ * gitCompareUrl. Both stopped at a `/compare/<branch>?expand=1` link, which is
+ * not a pull request: it is a form a human still has to open and submit. R4
+ * requires a repo-backed share to produce the PR itself.
+ *
+ * A move is also not just a write. When the source and the destination are in
+ * the same repo-backed pack, the destination write and the source removal must
+ * land in ONE commit, so the invariant "exactly one live copy" is never briefly
+ * false on the branch.
+ */
+const axios_1 = __importDefault(require("axios"));
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const pack_home_1 = require("./pack-home");
+exports.ALLOWED_GIT_URL = /^(https?:\/\/|ssh:\/\/|git:\/\/|file:\/\/|[\w.-]+@[\w.-]+:)/;
+/** Arg-array git, never a shell string, so a path or URL cannot be reinterpreted. */
+function git(args, cwd, timeout = 60_000) {
+    return (0, child_process_1.execFileSync)('git', args, {
+        cwd,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+        timeout,
+    }).toString().trim();
+}
+/**
+ * Committer identity args for a pack commit.
+ *
+ * FRAIM commits on the user's behalf into a pack repo. If the machine has no
+ * git identity configured, `git commit` fails outright with "Author identity
+ * unknown" — a fresh laptop, a container, or CI all hit this. Prefer whatever
+ * identity the user has configured, and fall back to a FRAIM one so publishing
+ * never depends on unrelated global git setup.
+ */
+function committerArgs(cwd) {
+    const configured = (key) => {
+        try {
+            return git(['config', '--get', key], cwd).length > 0;
+        }
+        catch {
+            return false;
+        }
+    };
+    if (configured('user.name') && configured('user.email'))
+        return [];
+    return ['-c', 'user.name=FRAIM', '-c', 'user.email=fraim@users.noreply.github.com'];
+}
+/**
+ * Remove any userinfo (`user:token@`) from a URL before it is shown or recorded.
+ *
+ * A remote configured as `https://x-access-token:<pat>@github.com/o/r.git` is a
+ * common pattern. Every string this module hands back is printed by the CLI and
+ * recorded into share-with-others run evidence, so an un-redacted URL would
+ * write a live credential into a durable artifact.
+ */
+function redactGitUrl(gitUrl) {
+    return gitUrl.replace(/^([a-z+]+:\/\/)[^/@]*@/i, '$1');
+}
+/** Convert a git remote URL to its https browse form, or undefined. */
+function httpsBrowseUrl(gitUrl) {
+    // Strip a trailing slash too: without it a remote ending in "/" produced a
+    // double slash in the compare URL (".../o/r//compare/b?expand=1").
+    const httpUrl = redactGitUrl(gitUrl)
+        .replace(/\.git$/, '')
+        .replace(/^git@([^:]+):/, 'https://$1/')
+        .replace(/\/+$/, '');
+    return /^https?:\/\//.test(httpUrl) ? httpUrl : undefined;
+}
+/** The "open a PR by hand" link. Used only as a fallback when no PR was created. */
+function gitCompareUrl(gitUrl, branch) {
+    const browse = httpsBrowseUrl(gitUrl);
+    return browse ? `${browse}/compare/${branch}?expand=1` : undefined;
+}
+/** Extract { owner, repo } from a GitHub remote URL, or null when it is not GitHub. */
+function parseGitHubSlug(gitUrl) {
+    const browse = httpsBrowseUrl(gitUrl);
+    if (!browse)
+        return null;
+    const match = /^https?:\/\/(?:www\.)?github\.com\/([^/]+)\/([^/]+?)\/?$/.exec(browse);
+    if (!match)
+        return null;
+    return { owner: match[1], repo: match[2] };
+}
+/**
+ * Default opener: GitHub REST, authenticated with GITHUB_TOKEN.
+ *
+ * Mirrors the request shape already used by src/fraim/issues.ts so both paths
+ * authenticate the same way. Resolves null (rather than throwing) when the
+ * remote is not GitHub or no token is present, so the caller reports a branch
+ * plus a reason instead of losing the push that already succeeded.
+ */
+const openGitHubPullRequest = async (input) => {
+    const slug = parseGitHubSlug(input.gitUrl);
+    if (!slug)
+        return null;
+    const token = process.env.GITHUB_TOKEN;
+    if (!token)
+        return null;
+    // GITHUB_API_URL is the standard override (GitHub Actions sets it, and it is
+    // what GitHub Enterprise installs need). Defaults to public GitHub.
+    const apiBase = (process.env.GITHUB_API_URL || 'https://api.github.com').replace(/\/$/, '');
+    const response = await axios_1.default.post(`${apiBase}/repos/${slug.owner}/${slug.repo}/pulls`, { title: input.title, body: input.body, head: input.branch, base: input.baseBranch }, {
+        headers: {
+            Authorization: `Bearer ${token}`,
+            Accept: 'application/vnd.github.v3+json',
+            'Content-Type': 'application/json',
+        },
+        timeout: 30_000,
+    });
+    return { url: String(response.data?.html_url ?? ''), number: Number(response.data?.number ?? 0) };
+};
+exports.openGitHubPullRequest = openGitHubPullRequest;
+/**
+ * Build the commit subject, PR title, and PR body for a pack change.
+ *
+ * Shared so the manager and org publishers describe a change identically. Both
+ * sides had their own copy of this, which is the duplication this module exists
+ * to remove.
+ */
+function describePackChange(packLabel, artifacts, deletions) {
+    const parts = [`${artifacts.length} added or updated`];
+    if (deletions.length > 0)
+        parts.push(`${deletions.length} removed`);
+    const summary = parts.join(', ');
+    const lines = [`Published by FRAIM to the ${packLabel} pack.`, ''];
+    if (artifacts.length > 0) {
+        lines.push('**Added or updated**');
+        for (const a of artifacts)
+            lines.push(`- \`${a.relativePath}\``);
+        lines.push('');
+    }
+    if (deletions.length > 0) {
+        lines.push('**Removed** (the source side of a move, in the same commit)');
+        for (const d of deletions)
+            lines.push(`- \`${d}\``);
+        lines.push('');
+    }
+    const title = `Update ${packLabel} pack: ${summary}`;
+    return { summary, title, body: lines.join('\n') };
+}
+/** Why the default opener declined, so the caller can say something useful. */
+function defaultBlockedReason(gitUrl) {
+    if (!parseGitHubSlug(gitUrl)) {
+        return `The pack remote is not a GitHub repository, so no pull request could be opened automatically. Open one manually against ${redactGitUrl(gitUrl)}.`;
+    }
+    return 'No GITHUB_TOKEN is set, so no pull request could be opened automatically. Set GITHUB_TOKEN and re-run, or open the pull request from the compare link.';
+}
+/**
+ * Publish from the layer's durable local clone (issue #1043 review round 1).
+ *
+ * The clone is a working copy that behaves like a project checkout, not a
+ * throwaway `mkdtemp` snapshot. That has a consequence worth stating: the
+ * user's content lives in this directory, so publishing must never leave the
+ * working tree switched to a feature branch or emptied while a PR is open.
+ *
+ * So the commit is made on whatever branch the copy is already on, and that
+ * commit is pushed to a *new remote ref* with `push origin HEAD:refs/heads/<b>`.
+ * The working copy keeps the content, stays on its branch, and a later
+ * fast-forward after the PR merges is a no-op.
+ *
+ * A push that succeeds is never reported as a failure just because the PR could
+ * not be opened: the branch is always returned so the change is recoverable.
+ */
+async function publishPackToGitRepo(opts) {
+    const dir = opts.cloneDir ?? (0, pack_home_1.defaultCloneDir)('manager');
+    const clone = (0, pack_home_1.ensurePackClone)(opts.gitUrl, dir);
+    if (clone.sha === null) {
+        throw new Error(clone.offlineReason ?? 'The pack repo clone is not available.');
+    }
+    const baseBranch = git(['rev-parse', '--abbrev-ref', 'HEAD'], dir);
+    const branch = `${opts.branchPrefix}${opts.branchSuffix || `${process.pid}-${Date.now()}`}`;
+    const written = new Set();
+    const touched = [];
+    for (const artifact of opts.artifacts) {
+        const dest = path_1.default.join(dir, artifact.relativePath);
+        fs_1.default.mkdirSync(path_1.default.dirname(dest), { recursive: true });
+        fs_1.default.writeFileSync(dest, artifact.content);
+        written.add(artifact.relativePath);
+        touched.push(artifact.relativePath);
+    }
+    // The source side of a move, in the same commit as the write. A path that
+    // is also a write target is skipped: a same-path move is a no-op, not a
+    // delete of what was just written.
+    for (const relativePath of opts.deletions ?? []) {
+        if (written.has(relativePath))
+            continue;
+        const target = path_1.default.join(dir, relativePath);
+        if (!fs_1.default.existsSync(target))
+            continue;
+        fs_1.default.rmSync(target, { force: true });
+        touched.push(relativePath);
+    }
+    // Stage only the paths this publish touched. The clone is a working copy the
+    // user may have other edits in; `git add -A` would sweep them into the PR.
+    if (touched.length > 0)
+        git(['add', '--', ...touched], dir);
+    const staged = git(['diff', '--cached', '--name-only'], dir);
+    if (staged.length > 0) {
+        git([...committerArgs(dir), 'commit', '-m', opts.commitMessage], dir);
+    }
+    git(['push', '--quiet', 'origin', `HEAD:refs/heads/${branch}`], dir);
+    // The push landed. From here nothing may throw the branch away.
+    const opener = opts.openPullRequest ?? exports.openGitHubPullRequest;
+    try {
+        const pr = await opener({
+            gitUrl: opts.gitUrl,
+            branch,
+            baseBranch,
+            title: opts.prTitle,
+            body: opts.prBody,
+        });
+        if (pr?.url)
+            return { branch, baseBranch, prUrl: pr.url, prCreated: true, credentialWarning: clone.credentialWarning };
+        return {
+            branch,
+            baseBranch,
+            prUrl: gitCompareUrl(opts.gitUrl, branch),
+            prCreated: false,
+            prBlockedReason: defaultBlockedReason(opts.gitUrl),
+            credentialWarning: clone.credentialWarning,
+        };
+    }
+    catch (error) {
+        return {
+            branch,
+            baseBranch,
+            prUrl: gitCompareUrl(opts.gitUrl, branch),
+            prCreated: false,
+            prBlockedReason: `The branch was pushed but opening the pull request failed: ${error?.message ?? String(error)}`,
+            credentialWarning: clone.credentialWarning,
+        };
+    }
+}

package/dist/src/cli/utils/pack-home.js

@@ -0,0 +1,279 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.packsDir = packsDir;
+exports.defaultCloneDir = defaultCloneDir;
+exports.resolvePackHome = resolvePackHome;
+exports.packReadRoots = packReadRoots;
+exports.findStrandedLegacyContent = findStrandedLegacyContent;
+exports.gitUrlHasUserinfo = gitUrlHasUserinfo;
+exports.ensurePackClone = ensurePackClone;
+/**
+ * Where a layer's details live (issue #1043, review rounds 1 and 2).
+ *
+ * **Everything is a home. There are no caches.** Each layer has exactly one
+ * place, named by config, and that place holds the whole layer: context, rules,
+ * learnings, jobs, skills, templates, and employees. Some homes are synced to
+ * other machines, some are local only, but it is always the single place.
+ *
+ *   single-machine  ->  the standard local path; local only, nothing to publish
+ *   local-folder    ->  the configured folder; the OS sync client replicates it
+ *   git             ->  a durable local clone that behaves like a project checkout
+ *   fraim-cloud     ->  a managed local directory the API syncs to and from
+ *
+ * This replaced an earlier model in which the manager layer had three locations
+ * (a writable home, a second copy at `~/.fraim/manager/`, and the real storage
+ * behind the backend) and the org layer had two with no writable home at all,
+ * which is why an org-level write used to be refused outright. Round 1 collapsed
+ * that to home-plus-cache; round 2 removed the cache. A read now has exactly one
+ * answer, so no copy can silently diverge from another.
+ */
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const project_fraim_paths_1 = require("../../core/utils/project-fraim-paths");
+const user_config_1 = require("./user-config");
+/**
+ * Make a user-supplied path deterministic.
+ *
+ * A relative localPath would otherwise resolve against process.cwd(), so the
+ * same config would point at different directories depending on where the CLI
+ * or the Hub server happened to start. Anchor it to the user FRAIM dir instead.
+ */
+function absolutize(p) {
+    return path_1.default.isAbsolute(p) ? p : path_1.default.resolve((0, project_fraim_paths_1.getUserFraimDirPath)(), p);
+}
+/** FRAIM-managed directory for pack copies that have no user-chosen location. */
+function packsDir() {
+    return path_1.default.join((0, project_fraim_paths_1.getUserFraimDirPath)(), 'packs');
+}
+/**
+ * The standard local home, used when the layer is not synced anywhere.
+ *
+ * Both layers keep their historical paths so existing machines need no
+ * migration. Inventing a new location here would orphan content that is
+ * already on disk: `~/.fraim/org/` has always been where org content lives,
+ * and `~/.fraim/personalized-employee/` is where a manager authors.
+ */
+function standardHome(layer) {
+    if (layer === 'manager')
+        return path_1.default.join((0, project_fraim_paths_1.getUserFraimDirPath)(), 'personalized-employee');
+    return path_1.default.join((0, project_fraim_paths_1.getUserFraimDirPath)(), 'org');
+}
+/**
+ * Where the cloud backend materializes. Also the historical path for each
+ * layer, so switching to or from `fraim-cloud` does not relocate anything.
+ */
+function cloudHome(layer) {
+    return path_1.default.join((0, project_fraim_paths_1.getUserFraimDirPath)(), layer === 'org' ? 'org' : 'manager');
+}
+/** Default clone directory when a git backend does not name one. */
+function defaultCloneDir(layer) {
+    return path_1.default.join(packsDir(), `${layer}-repo`);
+}
+/**
+ * Resolve where this layer's details live. Never throws and never touches the
+ * network; call `ensurePackClone` separately when the git working copy has to
+ * be present and current.
+ */
+function resolvePackHome(layer) {
+    const config = (0, user_config_1.getLayerBackend)(layer);
+    const standard = standardHome(layer);
+    if (!config || config.backend === 'single-machine') {
+        return {
+            layer,
+            backend: config?.backend ?? 'single-machine',
+            root: standard,
+            synced: false,
+            requiresPublish: false,
+        };
+    }
+    if (config.backend === 'local-folder' && config.localPath) {
+        return {
+            layer,
+            backend: 'local-folder',
+            root: absolutize(config.localPath),
+            synced: true,
+            // The sync client replicates the write; there is nothing further to do.
+            requiresPublish: false,
+            legacyRoot: standard,
+        };
+    }
+    if (config.backend === 'git' && config.gitUrl) {
+        return {
+            layer,
+            backend: 'git',
+            root: config.localPath ? absolutize(config.localPath) : defaultCloneDir(layer),
+            synced: true,
+            requiresPublish: true,
+            gitUrl: config.gitUrl,
+            legacyRoot: standard,
+        };
+    }
+    if (config.backend === 'fraim-cloud') {
+        return {
+            layer,
+            backend: 'fraim-cloud',
+            root: cloudHome(layer),
+            synced: true,
+            requiresPublish: true,
+            legacyRoot: standard,
+        };
+    }
+    // A backend named but missing its required pointer (git without gitUrl,
+    // local-folder without localPath). Fall back to the standard home rather
+    // than inventing a location.
+    return {
+        layer,
+        backend: config.backend,
+        root: standard,
+        synced: false,
+        requiresPublish: false,
+    };
+}
+/**
+ * Where to read this layer from. Exactly one directory: the home.
+ *
+ * Kept as an array because callers iterate it, and because narrowing from three
+ * roots to one was the point of round 2. If this ever returns more than one
+ * entry again, the single-place invariant has been lost.
+ */
+function packReadRoots(layer) {
+    return [resolvePackHome(layer).root];
+}
+/**
+ * Content sitting at the standard local path that the configured home does not
+ * hold. Since the home is the single read location, this content is stranded:
+ * it still exists on disk but nothing reads it.
+ *
+ * Returned so callers can *tell the user*, rather than silently orphaning work
+ * authored before a synced backend was configured. Nothing is moved or deleted
+ * here; relocating is a deliberate act, following the `org-migration.ts`
+ * precedent of reporting and archiving rather than removing.
+ */
+function findStrandedLegacyContent(layer) {
+    const home = resolvePackHome(layer);
+    if (!home.legacyRoot || home.legacyRoot === home.root)
+        return [];
+    if (!fs_1.default.existsSync(home.legacyRoot))
+        return [];
+    const stranded = [];
+    const walk = (absDir, relDir) => {
+        let entries;
+        try {
+            entries = fs_1.default.readdirSync(absDir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const rel = relDir ? `${relDir}/${entry.name}` : entry.name;
+            const abs = path_1.default.join(absDir, entry.name);
+            if (entry.isDirectory())
+                walk(abs, rel);
+            else if (entry.isFile() && !fs_1.default.existsSync(path_1.default.join(home.root, rel)))
+                stranded.push(rel);
+        }
+    };
+    walk(home.legacyRoot, '');
+    return stranded.sort();
+}
+const ALLOWED_GIT_URL = /^(https?:\/\/|ssh:\/\/|git:\/\/|file:\/\/|[\w.-]+@[\w.-]+:)/;
+/** True when the URL embeds `user:password@` or `user@` before the host. */
+function gitUrlHasUserinfo(gitUrl) {
+    return /^[a-z+]+:\/\/[^/@]+@/i.test(gitUrl);
+}
+function credentialWarningFor(gitUrl) {
+    if (!gitUrlHasUserinfo(gitUrl))
+        return undefined;
+    return ('The configured pack remote embeds credentials in its URL. git stores the remote verbatim in the ' +
+        'clone .git/config, and this clone is durable, so that credential now sits on disk at a predictable path. ' +
+        'Use a credential helper or SSH key and remove the userinfo from gitUrl in ~/.fraim/config.json.');
+}
+function isGitWorkTree(dir) {
+    return fs_1.default.existsSync(path_1.default.join(dir, '.git'));
+}
+function git(args, cwd, timeout = 60_000) {
+    return (0, child_process_1.execFileSync)('git', args, {
+        cwd,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+        timeout,
+    }).toString().trim();
+}
+/**
+ * Make the git pack home present and as current as the network allows.
+ *
+ * This is the "works like a project" behavior: clone once into a durable
+ * directory, then refresh with fetch plus a fast-forward-only merge. A
+ * fast-forward-only merge is deliberate. It can refuse, and refusing is
+ * correct: local commits that have not been pushed must never be silently
+ * rebased or merged away.
+ *
+ * Network failure is not an error. The existing local copy is returned with
+ * `offlineReason` set, so reads keep working on a plane.
+ */
+function ensurePackClone(gitUrl, dir) {
+    if (!ALLOWED_GIT_URL.test(gitUrl)) {
+        const scheme = /^([A-Za-z][A-Za-z0-9+.-]*):/.exec(gitUrl)?.[1] ?? '(none)';
+        throw new Error(`Pack repo URL has an unsupported scheme '${scheme}'. Expected https, ssh, git, file, or scp-style user@host:path.`);
+    }
+    if (!isGitWorkTree(dir)) {
+        // Never clear a non-empty directory to make room for the clone. The
+        // clone target is a user-supplied path; if they point it at a folder
+        // that already holds something, wiping it would destroy their data over
+        // a config typo. Refuse and say exactly what to do.
+        if (fs_1.default.existsSync(dir) && fs_1.default.readdirSync(dir).length > 0) {
+            throw new Error(`Cannot use '${dir}' as the pack clone: it already contains files and is not a git repository. ` +
+                `Point localPath at an empty or non-existent directory, or clone the pack repo there yourself.`);
+        }
+        fs_1.default.mkdirSync(dir, { recursive: true });
+        try {
+            // Full clone, not depth-1: this is a working copy, not a snapshot.
+            git(['clone', '--quiet', '--', gitUrl, '.'], dir);
+            return { dir, sha: git(['rev-parse', 'HEAD'], dir), created: true, updated: false, credentialWarning: credentialWarningFor(gitUrl) };
+        }
+        catch (error) {
+            fs_1.default.rmSync(dir, { recursive: true, force: true });
+            return {
+                dir,
+                sha: null,
+                created: false,
+                updated: false,
+                offlineReason: `Could not clone the pack repo: ${error?.message ?? String(error)}`,
+            };
+        }
+    }
+    const before = (() => {
+        try {
+            return git(['rev-parse', 'HEAD'], dir);
+        }
+        catch {
+            return null;
+        }
+    })();
+    try {
+        git(['fetch', '--quiet', 'origin'], dir);
+        git(['merge', '--ff-only', '--quiet', '@{u}'], dir);
+    }
+    catch (error) {
+        return {
+            dir,
+            sha: before,
+            created: false,
+            updated: false,
+            offlineReason: `Using the local copy; could not fast-forward from the remote: ${error?.message ?? String(error)}`,
+        };
+    }
+    const after = (() => {
+        try {
+            return git(['rev-parse', 'HEAD'], dir);
+        }
+        catch {
+            return before;
+        }
+    })();
+    return { dir, sha: after, created: false, updated: after !== before, credentialWarning: credentialWarningFor(gitUrl) };
+}

package/dist/src/cli/utils/user-config.js

@@ -91,7 +91,11 @@ function getOrganizationConfig() {
         const gitUrl = typeof raw.gitUrl === 'string' ? raw.gitUrl.trim() : '';
         if (!gitUrl)
             return null;
-        return { backend: 'git', gitUrl, id: raw.id };
+        // Issue #1043: a git backend also carries where the durable clone lives.
+        // Dropping localPath here made the pointer unusable and silently forced
+        // the default clone directory.
+        const localPath = typeof raw.localPath === 'string' ? raw.localPath.trim() : '';
+        return { backend: 'git', gitUrl, id: raw.id, ...(localPath ? { localPath } : {}) };
     }
     if (raw.backend === 'fraim-cloud') {
         return { backend: 'fraim-cloud', id: raw.id };
@@ -119,7 +123,11 @@ function getManagerStorageConfig() {
         const gitUrl = typeof raw.gitUrl === 'string' ? raw.gitUrl.trim() : '';
         if (!gitUrl)
             return null;
-        return { backend: 'git', gitUrl, id: raw.id };
+        // Issue #1043: a git backend also carries where the durable clone lives.
+        // Dropping localPath here made the pointer unusable and silently forced
+        // the default clone directory.
+        const localPath = typeof raw.localPath === 'string' ? raw.localPath.trim() : '';
+        return { backend: 'git', gitUrl, id: raw.id, ...(localPath ? { localPath } : {}) };
     }
     if (raw.backend === 'fraim-cloud') {
         return { backend: 'fraim-cloud', id: raw.id };

package/dist/src/core/capability-pack.js

@@ -9,13 +9,20 @@
  * Phase-1 scope: jobs, skills, rules/<category>/…, templates, scripts.
  * (Scripts are accepted by isCapabilityPackPath so the guard is correct from
  * Phase 1; the server-side security gate for scripts is Phase 3 work.)
+ *
+ * Issue #1043 adds `employees`. A custom employee record was the one
+ * personalization type with no pack representation, so it could not be
+ * published or synced by any backend and share-with-others could never move
+ * one between levels. Making it a pack member reuses the publish validator,
+ * the sync materializer, and the resolver overlay guard, which is the whole
+ * point of this module being the single allowlist.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CAPABILITY_DIRS = void 0;
 exports.isCapabilityPackPath = isCapabilityPackPath;
 exports.isScriptPath = isScriptPath;
 exports.shouldDecorateAsMarkdown = shouldDecorateAsMarkdown;
-exports.CAPABILITY_DIRS = ['jobs', 'skills', 'rules', 'templates', 'scripts'];
+exports.CAPABILITY_DIRS = ['jobs', 'skills', 'rules', 'templates', 'scripts', 'employees'];
 /**
  * Returns true when `rel` is a valid capability-pack member path:
  *
@@ -24,6 +31,7 @@ exports.CAPABILITY_DIRS = ['jobs', 'skills', 'rules', 'templates', 'scripts'];
  *   templates/<category>/<name>.md
  *   rules/<category>/<name>.md          (depth ≥ 2 — flat rules/<name>.md is reserved)
  *   scripts/<name>.<ext>
+ *   employees/<slug>.json               (flat — employees have no category)
  *
  * Rejects: path traversal (../ or \), absolute paths (/), control characters,
  * flat rules/<name>.md (reserved for org_rules.md / manager_rules.md).
@@ -56,6 +64,20 @@ function isCapabilityPackPath(rel) {
         const name = rest[0];
         return name.length > 0 && /\.[a-zA-Z]+$/.test(name);
     }
+    if (dir === 'employees') {
+        // employees/<slug>.json — flat, like scripts. Employees have no category
+        // dimension: custom-employees.ts resolves them by bare slug, so a
+        // categorized path would not round-trip back to a readable record.
+        if (rest.length !== 1)
+            return false;
+        const name = rest[0];
+        if (!name.endsWith('.json'))
+            return false;
+        // The slug must be a real name. Requiring an alphanumeric rejects
+        // degenerate filenames like "..json" (slug ".") that pass a bare
+        // length check but name no employee.
+        return /[A-Za-z0-9]/.test(name.slice(0, -'.json'.length));
+    }
     if (dir === 'rules') {
         // rules/<category>/<name>.md — depth exactly 2 (no flat rules/)
         if (rest.length !== 2)

package/dist/src/core/manager-pack.js

@@ -15,7 +15,28 @@ exports.MANAGER_PACK_RELATIVE_PATH_RE = /^(context\/manager_context\.md|rules\/m
 function isManagerPackRelativePath(value) {
     return exports.MANAGER_PACK_RELATIVE_PATH_RE.test(value) || (0, capability_pack_1.isCapabilityPackPath)(value);
 }
+/**
+ * Infer the manager-pack location for a local file by its path or name:
+ *   manager_context.md            -> context/manager_context.md
+ *   manager_rules.md              -> rules/manager_rules.md
+ *   <user>-<family>.md            -> learnings/<user>-<family>.md
+ *   jobs/<cat>/<name>.md | skills/<cat>/<name>.md | rules/<cat>/<name>.md |
+ *   templates/<cat>/<name>.md | scripts/<name>.<ext> | employees/<slug>.json
+ *                                 -> capability path returned as-is
+ *
+ * Issue #1043: the capability branch was previously missing here even though
+ * isManagerPackRelativePath already ACCEPTED capability paths. An accepting
+ * validator paired with a rejecting resolver meant `fraim manager publish`
+ * threw for every job, skill, nested rule, and employee. This mirrors
+ * org-publish.packRelativePathFor, which has handled it since issue #869
+ * Phase 2, so both packs now resolve capability paths identically.
+ */
 function managerPackRelativePathForFileName(fileName) {
+    // Normalize separators before the allowlist check: isCapabilityPackPath
+    // rejects backslashes outright, and on Windows the CLI receives them.
+    const normalized = fileName.replace(/\\/g, '/').replace(/^\/+/, '');
+    if ((0, capability_pack_1.isCapabilityPackPath)(normalized))
+        return normalized;
     const base = path_1.default.basename(fileName);
     if (base === 'manager_context.md')
         return exports.MANAGER_CONTEXT_RELATIVE_PATH;
@@ -23,10 +44,5 @@ function managerPackRelativePathForFileName(fileName) {
         return exports.MANAGER_RULES_RELATIVE_PATH;
     if (exports.MANAGER_LEARNING_FILE_RE.test(base))
         return `learnings/${base}`;
-    // Capability files carry their full relative path as-is (e.g. jobs/cat/name.md).
-    // callers that have the full relative path should pass it directly to
-    // isManagerPackRelativePath; this filename-only lookup cannot reconstruct the
-    // category from a bare basename, so return null and let the caller supply the
-    // full path.
     return null;
 }