fraim 2.0.248 → 2.0.249

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

@@ -12,25 +12,44 @@ exports.managerCommand = new commander_1.Command('manager')
     .description('Manage your portable personal manager context');
 exports.managerCommand
     .command('publish')
-    .description('Publish manager context/rules/learnings files to the configured manager backend')
-    .argument('<files...>', 'Local files to publish: manager_context.md, manager_rules.md, and/or personal learning files')
-    .action(async (files) => {
+    .description('Publish manager context, rules, learnings, capabilities, or employees to the configured manager backend')
+    .argument('<files...>', 'Files to publish: manager_context.md, manager_rules.md, personal learning files, or pack-relative capability paths such as jobs/<cat>/<name>.md and employees/<slug>.json')
+    .option('--remove <paths...>', 'Pack-relative paths to remove in the same change (the source side of a move)')
+    .action(async (files, options) => {
     try {
         const artifacts = files.map((filePath) => {
             if (!fs_1.default.existsSync(filePath))
                 throw new Error(`File not found: ${filePath}`);
             return { relativePath: (0, manager_publish_1.managerPackRelativePathFor)(filePath), content: fs_1.default.readFileSync(filePath, 'utf8') };
         });
-        const result = await (0, manager_publish_1.publishManagerArtifacts)(artifacts);
+        const deletions = (options.remove ?? []).map(manager_publish_1.managerPackRelativePathFor);
+        const result = await (0, manager_publish_1.publishManagerArtifacts)(artifacts, { deletions });
         if (result.backend === 'fraim-cloud') {
             console.log(chalk_1.default.green(`Published ${artifacts.length} manager artifact(s) to your FRAIM account (version ${result.version}).`));
             console.log(chalk_1.default.gray('Run "fraim sync" on each machine to pull the update.'));
+            return;
+        }
+        if (result.backend === 'local-folder') {
+            console.log(chalk_1.default.green(`Wrote ${artifacts.length} manager artifact(s) to your synced folder.`));
+            for (const p of result.writtenPaths ?? [])
+                console.log(chalk_1.default.gray(`  ${p}`));
+            if (result.deletedPaths?.length) {
+                console.log(chalk_1.default.green(`Removed ${result.deletedPaths.length} source file(s).`));
+            }
+            console.log(chalk_1.default.gray('Run "fraim sync" on each machine to pull the update.'));
+            return;
+        }
+        if (result.credentialWarning)
+            console.log(chalk_1.default.yellow(result.credentialWarning));
+        console.log(chalk_1.default.green(`Pushed ${artifacts.length} manager artifact(s) to branch "${result.branch}".`));
+        if (result.prCreated) {
+            console.log(chalk_1.default.cyan(`Opened the pull request: ${result.prUrl}`));
+            console.log(chalk_1.default.gray('After it merges, run "fraim sync" to pull the update.'));
         }
         else {
-            console.log(chalk_1.default.green(`Pushed ${artifacts.length} manager artifact(s) to branch "${result.branch}" in your manager repo.`));
+            console.log(chalk_1.default.yellow(`No pull request was opened. ${result.prBlockedReason ?? ''}`.trim()));
             if (result.prUrl)
-                console.log(chalk_1.default.cyan(`Open the pull request: ${result.prUrl}`));
-            console.log(chalk_1.default.gray('After it merges, run "fraim sync" to pull the update.'));
+                console.log(chalk_1.default.cyan(`Open one here: ${result.prUrl}`));
         }
     }
     catch (error) {

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

@@ -12,25 +12,44 @@ exports.orgCommand = new commander_1.Command('org')
     .description('Manage your shared organization context');
 exports.orgCommand
     .command('publish')
-    .description('Publish org context/rules/learnings/brand files to the configured org backend')
-    .argument('<files...>', 'Local files to publish: org_context.md, org_rules.md, org_brand.json, and/or org-*.md learnings')
-    .action(async (files) => {
+    .description('Publish org context, rules, learnings, brand, capabilities, or employees to the configured org backend')
+    .argument('<files...>', 'Files to publish: org_context.md, org_rules.md, org_brand.json, org-*.md learnings, or pack-relative capability paths such as jobs/<cat>/<name>.md and employees/<slug>.json')
+    .option('--remove <paths...>', 'Pack-relative paths to remove in the same change (the source side of a move)')
+    .action(async (files, options) => {
     try {
         const artifacts = files.map((f) => {
             if (!fs_1.default.existsSync(f))
                 throw new Error(`File not found: ${f}`);
             return { relativePath: (0, org_publish_1.packRelativePathFor)(f), content: fs_1.default.readFileSync(f, 'utf8') };
         });
-        const result = await (0, org_publish_1.publishOrgArtifacts)(artifacts);
+        const deletions = (options.remove ?? []).map(org_publish_1.packRelativePathFor);
+        const result = await (0, org_publish_1.publishOrgArtifacts)(artifacts, { deletions });
         if (result.backend === 'fraim-cloud') {
             console.log(chalk_1.default.green(`Published ${artifacts.length} org artifact(s) to your FRAIM organization (version ${result.version}).`));
             console.log(chalk_1.default.gray('Run "fraim sync" on each machine to pull the update.'));
+            return;
+        }
+        if (result.backend === 'local-folder') {
+            console.log(chalk_1.default.green(`Wrote ${artifacts.length} org artifact(s) to your synced folder.`));
+            for (const p of result.writtenPaths ?? [])
+                console.log(chalk_1.default.gray(`  ${p}`));
+            if (result.deletedPaths?.length) {
+                console.log(chalk_1.default.green(`Removed ${result.deletedPaths.length} source file(s).`));
+            }
+            console.log(chalk_1.default.gray('Run "fraim sync" on each machine to pull the update.'));
+            return;
+        }
+        if (result.credentialWarning)
+            console.log(chalk_1.default.yellow(result.credentialWarning));
+        console.log(chalk_1.default.green(`Pushed ${artifacts.length} org artifact(s) to branch "${result.branch}".`));
+        if (result.prCreated) {
+            console.log(chalk_1.default.cyan(`Opened the pull request: ${result.prUrl}`));
+            console.log(chalk_1.default.gray('After it merges, run "fraim sync" to pull the update.'));
         }
         else {
-            console.log(chalk_1.default.green(`Pushed ${artifacts.length} org artifact(s) to branch "${result.branch}" in your organization repo.`));
+            console.log(chalk_1.default.yellow(`No pull request was opened. ${result.prBlockedReason ?? ''}`.trim()));
             if (result.prUrl)
-                console.log(chalk_1.default.cyan(`Open the pull request: ${result.prUrl}`));
-            console.log(chalk_1.default.gray('After it merges, run "fraim sync" to pull the update.'));
+                console.log(chalk_1.default.cyan(`Open one here: ${result.prUrl}`));
         }
     }
     catch (error) {

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

@@ -230,6 +230,23 @@ const runSync = async (options) => {
         else if (outcome.status === 'absent') {
             console.log(chalk_1.default.yellow(`Org context not synced: ${outcome.error}`));
         }
+        // Issue #1043 round 2: the home is the only read location, so anything
+        // still sitting at the old standard path is invisible to FRAIM. Say so;
+        // silently orphaning a manager's work is worse than a noisy sync.
+        try {
+            const { findStrandedLegacyContent, resolvePackHome } = await Promise.resolve().then(() => __importStar(require('../utils/pack-home')));
+            const stranded = findStrandedLegacyContent('org');
+            if (stranded.length > 0) {
+                const home = resolvePackHome('org');
+                console.log(chalk_1.default.yellow(`${stranded.length} org file(s) are not in your org home and are no longer read:`));
+                for (const rel of stranded.slice(0, 10))
+                    console.log(chalk_1.default.yellow(`  ${rel}`));
+                if (stranded.length > 10)
+                    console.log(chalk_1.default.yellow(`  ...and ${stranded.length - 10} more`));
+                console.log(chalk_1.default.yellow(`Move them into ${home.root} to make them live again. Nothing was deleted.`));
+            }
+        }
+        catch { /* reporting must never fail a sync */ }
         // 'disabled' (no org configured) stays silent.
         // R8.1: one-time publish offer for legacy machine-local org files. The
         // publish itself runs through organization-onboarding (propose-and-approve);
@@ -257,6 +274,23 @@ const runSync = async (options) => {
         else if (outcome.status === 'absent') {
             console.log(chalk_1.default.yellow(`Manager context not synced: ${outcome.error}`));
         }
+        // Issue #1043 round 2: the home is the only read location, so anything
+        // still sitting at the old standard path is invisible to FRAIM. Say so;
+        // silently orphaning a manager's work is worse than a noisy sync.
+        try {
+            const { findStrandedLegacyContent, resolvePackHome } = await Promise.resolve().then(() => __importStar(require('../utils/pack-home')));
+            const stranded = findStrandedLegacyContent('manager');
+            if (stranded.length > 0) {
+                const home = resolvePackHome('manager');
+                console.log(chalk_1.default.yellow(`${stranded.length} manager file(s) are not in your manager home and are no longer read:`));
+                for (const rel of stranded.slice(0, 10))
+                    console.log(chalk_1.default.yellow(`  ${rel}`));
+                if (stranded.length > 10)
+                    console.log(chalk_1.default.yellow(`  ...and ${stranded.length - 10} more`));
+                console.log(chalk_1.default.yellow(`Move them into ${home.root} to make them live again. Nothing was deleted.`));
+            }
+        }
+        catch { /* reporting must never fail a sync */ }
     };
     const isNpx = process.env.npm_config_prefix === undefined || process.env.npm_lifecycle_event === 'npx';
     const isGlobal = !isNpx && (process.env.npm_config_global === 'true' || process.env.npm_config_prefix);

package/dist/src/cli/utils/local-folder-sync.js

@@ -37,42 +37,84 @@ exports.isConflictCopy = isConflictCopy;
 exports.countConflictCopies = countConflictCopies;
 exports.collectLocalFolderFiles = collectLocalFolderFiles;
 exports.writeLocalFolderFile = writeLocalFolderFile;
+exports.removeLocalFolderFiles = removeLocalFolderFiles;
 exports.localFolderVersion = localFolderVersion;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const crypto_1 = __importDefault(require("crypto"));
-/** Pack subdirectories expected in every local-folder backend. */
-exports.LOCAL_FOLDER_PACK_DIRS = ['context', 'rules', 'learnings'];
+const capability_pack_1 = require("../../core/capability-pack");
+/**
+ * Pack subdirectories expected in every local-folder backend.
+ *
+ * Issue #1043: the capability directories (and `employees`) were missing, so a
+ * job, skill, nested rule, or employee record published into a local-folder
+ * pack was never collected on the way back down. The pack was write-only for
+ * those types. `CAPABILITY_DIRS` is the single allowlist for the capability
+ * half; this list is context/rules/learnings plus that, deduplicated because
+ * `rules` appears in both.
+ */
+exports.LOCAL_FOLDER_PACK_DIRS = [
+    ...new Set(['context', 'rules', 'learnings', ...capability_pack_1.CAPABILITY_DIRS]),
+];
 /**
  * Matches the conflict-copy filename patterns produced by OneDrive,
  * SharePoint, Google Drive for Desktop, and Dropbox.
  *
  * Deliberately does NOT match ordinary parenthesised names like
  * "sprint-retro (Q2 2026).md" — only the well-known suffix patterns.
+ *
+ * Issue #1043 widened the extension from `.md` to `.md|.json`: employee
+ * records are JSON pack members and get conflict copies like any other file.
  */
-exports.CONFLICT_COPY_RE = /[\s-](\([^)]*'s conflicted copy \d{4}-\d{2}-\d{2}\)|\(\d+\)|[\w-]+-PC)\.md$/i;
+exports.CONFLICT_COPY_RE = /[\s-](\([^)]*'s conflicted copy \d{4}-\d{2}-\d{2}\)|\(\d+\)|[\w-]+-PC)\.(md|json)$/i;
 /** True when the filename looks like a sync-client conflict copy. */
 function isConflictCopy(fileName) {
     return exports.CONFLICT_COPY_RE.test(fileName);
 }
 /**
- * Count conflict-copy files directly under dirPath/learnings (non-recursive).
- * Used by the Hub UI to surface an amber "N conflicts" indicator.
+ * Walk every pack file under localPath, depth-first, yielding pack-relative
+ * paths with forward slashes.
+ *
+ * Issue #1043: this replaces three separate one-level `readdirSync` loops.
+ * Capability members live at `jobs/<category>/<name>.md`, so a one-level scan
+ * could never see them — which is why a published job neither synced back down
+ * nor moved the pack version.
  */
-function countConflictCopies(localPath) {
-    let count = 0;
+function walkPackFiles(localPath, visit) {
+    const descend = (absDir, relDir) => {
+        let entries;
+        try {
+            entries = fs_1.default.readdirSync(absDir, { withFileTypes: true });
+        }
+        catch {
+            return; // non-fatal — missing or unreadable subdirs are fine
+        }
+        for (const entry of entries) {
+            const abs = path_1.default.join(absDir, entry.name);
+            const rel = `${relDir}/${entry.name}`;
+            if (entry.isDirectory())
+                descend(abs, rel);
+            else if (entry.isFile())
+                visit(rel, abs);
+        }
+    };
     for (const dirName of exports.LOCAL_FOLDER_PACK_DIRS) {
         const dir = path_1.default.join(localPath, dirName);
         if (!fs_1.default.existsSync(dir))
             continue;
-        try {
-            for (const entry of fs_1.default.readdirSync(dir, { withFileTypes: true })) {
-                if (entry.isFile() && isConflictCopy(entry.name))
-                    count++;
-            }
-        }
-        catch { /* non-fatal */ }
+        descend(dir, dirName);
     }
+}
+/**
+ * Count conflict-copy files across the pack directories.
+ * Used by the Hub UI to surface an amber "N conflicts" indicator.
+ */
+function countConflictCopies(localPath) {
+    let count = 0;
+    walkPackFiles(localPath, (rel) => {
+        if (isConflictCopy(path_1.default.basename(rel)))
+            count++;
+    });
     return count;
 }
 /**
@@ -84,25 +126,16 @@ function countConflictCopies(localPath) {
  */
 function collectLocalFolderFiles(localPath, pathGuard) {
     const files = [];
-    for (const dirName of exports.LOCAL_FOLDER_PACK_DIRS) {
-        const dir = path_1.default.join(localPath, dirName);
-        if (!fs_1.default.existsSync(dir))
-            continue;
+    walkPackFiles(localPath, (rel, abs) => {
+        if (isConflictCopy(path_1.default.basename(rel)))
+            return;
+        if (!pathGuard(rel))
+            return;
         try {
-            for (const entry of fs_1.default.readdirSync(dir, { withFileTypes: true })) {
-                if (!entry.isFile())
-                    continue;
-                if (isConflictCopy(entry.name))
-                    continue;
-                const rel = `${dirName}/${entry.name}`;
-                if (!pathGuard(rel))
-                    continue;
-                const content = fs_1.default.readFileSync(path_1.default.join(dir, entry.name), 'utf8');
-                files.push({ relativePath: rel, content });
-            }
+            files.push({ relativePath: rel, content: fs_1.default.readFileSync(abs, 'utf8') });
         }
-        catch { /* non-fatal — missing subdirs are fine */ }
-    }
+        catch { /* non-fatal — skip files we cannot read */ }
+    });
     return files;
 }
 /**
@@ -147,32 +180,51 @@ function writeLocalFolderFile(localPath, relativePath, content, lastSyncedAt) {
         throw err;
     }
 }
+/**
+ * Remove the source side of a move from a local-folder pack.
+ *
+ * Call this only after every destination write has landed, so a partial failure
+ * never leaves the artifact at neither level. 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.
+ *
+ * Returns the absolute paths actually removed.
+ */
+function removeLocalFolderFiles(localPath, deletions, writtenRelativePaths) {
+    const written = new Set(writtenRelativePaths);
+    const removed = [];
+    for (const relativePath of deletions) {
+        if (written.has(relativePath))
+            continue;
+        const target = path_1.default.join(localPath, relativePath);
+        if (!fs_1.default.existsSync(target))
+            continue;
+        fs_1.default.rmSync(target, { force: true });
+        removed.push(target);
+    }
+    return removed;
+}
 /**
  * A stable version string for the local-folder backend — a hex digest
  * of the most recent mtime across all pack files. Changes whenever any
  * file in the folder is written (by this machine or the sync client).
  */
 function localFolderVersion(localPath) {
-    const mtimes = [];
-    for (const dirName of exports.LOCAL_FOLDER_PACK_DIRS) {
-        const dir = path_1.default.join(localPath, dirName);
-        if (!fs_1.default.existsSync(dir))
-            continue;
+    // Issue #1043: the digest mixes in the pack-relative path, not just mtimes.
+    // Two files written in the same filesystem-clock tick produce identical
+    // mtimes, so an mtime-only digest could leave the version unchanged after a
+    // publish and make sync skip the update.
+    const entries = [];
+    walkPackFiles(localPath, (rel, abs) => {
+        if (isConflictCopy(path_1.default.basename(rel)))
+            return;
         try {
-            for (const entry of fs_1.default.readdirSync(dir, { withFileTypes: true })) {
-                if (!entry.isFile() || isConflictCopy(entry.name))
-                    continue;
-                try {
-                    mtimes.push(fs_1.default.statSync(path_1.default.join(dir, entry.name)).mtimeMs);
-                }
-                catch { /* skip files we can't stat */ }
-            }
+            entries.push(`${rel}:${fs_1.default.statSync(abs).mtimeMs}`);
         }
-        catch { /* non-fatal */ }
-    }
-    if (mtimes.length === 0)
+        catch { /* skip files we can't stat */ }
+    });
+    if (entries.length === 0)
         return '0';
     const hash = crypto_1.default.createHash('sha1');
-    hash.update(mtimes.sort((a, b) => a - b).join(','));
+    hash.update(entries.sort().join(','));
     return hash.digest('hex').slice(0, 12);
 }

package/dist/src/cli/utils/manager-pack-sync.js

@@ -3,10 +3,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MANAGER_CACHE_MANAGED_HEADER = exports.MANAGER_SYNC_METADATA_FILE = exports.MANAGER_CACHE_DIRNAME = void 0;
-exports.getManagerCacheDir = getManagerCacheDir;
-exports.readManagerCacheMetadata = readManagerCacheMetadata;
-exports.getManagerCacheAgeHours = getManagerCacheAgeHours;
+exports.MANAGER_MANAGED_HEADER = exports.MANAGER_SYNC_METADATA_FILE = exports.MANAGER_HOME_DIRNAME = void 0;
+exports.getManagerHomeDir = getManagerHomeDir;
+exports.readManagerSyncMetadata = readManagerSyncMetadata;
+exports.getManagerSyncAgeHours = getManagerSyncAgeHours;
 exports.syncManagerCache = syncManagerCache;
 /**
  * Manager cache sync (issue #580).
@@ -25,29 +25,60 @@ const path_1 = __importDefault(require("path"));
 const project_fraim_paths_1 = require("../../core/utils/project-fraim-paths");
 const manager_pack_1 = require("../../core/manager-pack");
 const capability_pack_1 = require("../../core/capability-pack");
-const git_org_sync_1 = require("./git-org-sync");
+const pack_home_1 = require("./pack-home");
 const local_folder_sync_1 = require("./local-folder-sync");
 const user_config_1 = require("./user-config");
-exports.MANAGER_CACHE_DIRNAME = 'manager';
+exports.MANAGER_HOME_DIRNAME = 'manager';
 exports.MANAGER_SYNC_METADATA_FILE = '.manager-sync-metadata.json';
-exports.MANAGER_CACHE_MANAGED_HEADER = '<!-- FRAIM_MANAGER_SYNC_MANAGED_CONTENT -->';
-const MANAGER_PACK_DIRS = ['context', 'rules', 'learnings', 'jobs', 'skills', 'templates', 'scripts'];
-function getManagerCacheDir() {
-    return path_1.default.join((0, project_fraim_paths_1.getUserFraimDirPath)(), exports.MANAGER_CACHE_DIRNAME);
+exports.MANAGER_MANAGED_HEADER = '<!-- FRAIM_MANAGER_SYNC_MANAGED_CONTENT -->';
+// Issue #1043 adds 'employees' so a published employee record is walked out of
+// a git snapshot. isManagerPackRelativePath still decides what is admitted.
+const MANAGER_PACK_DIRS = ['context', 'rules', 'learnings', 'jobs', 'skills', 'templates', 'scripts', 'employees'];
+/**
+ * The layer's single home. Named `getManagerHomeDir` for backward compatibility with
+ * existing callers; issue #1043 round 2 removed the separate cache it used to
+ * point at, so this now resolves the one place the layer lives.
+ */
+function getManagerHomeDir() {
+    return (0, pack_home_1.resolvePackHome)('manager').root;
+}
+/**
+ * Where sync provenance is recorded.
+ *
+ * Deliberately NOT inside the home. The home is the user's own content: for a
+ * git backend it is a real working tree, so a metadata file there shows up as
+ * an untracked change in their pack repo, and for a synced folder it would
+ * replicate machine-local bookkeeping to every other machine. Provenance is
+ * local state, so it belongs in ~/.fraim beside the config.
+ */
+function syncMetadataPath() {
+    return path_1.default.join((0, project_fraim_paths_1.getUserFraimDirPath)(), exports.MANAGER_SYNC_METADATA_FILE);
 }
-function readManagerCacheMetadata() {
+/** Record when and from where this machine last synced. Never touches the home. */
+function writeHomeMetadata(metadata) {
     try {
-        const metadataPath = path_1.default.join(getManagerCacheDir(), exports.MANAGER_SYNC_METADATA_FILE);
-        if (!fs_1.default.existsSync(metadataPath))
+        fs_1.default.mkdirSync((0, project_fraim_paths_1.getUserFraimDirPath)(), { recursive: true });
+        fs_1.default.writeFileSync(syncMetadataPath(), JSON.stringify(metadata, null, 2));
+    }
+    catch { /* provenance is best-effort; never fail a sync over it */ }
+}
+function readManagerSyncMetadata() {
+    try {
+        const metadataPath = syncMetadataPath();
+        if (fs_1.default.existsSync(metadataPath))
+            return JSON.parse(fs_1.default.readFileSync(metadataPath, 'utf8'));
+        // A machine that last synced before provenance moved out of the home.
+        const legacy = path_1.default.join(getManagerHomeDir(), exports.MANAGER_SYNC_METADATA_FILE);
+        if (!fs_1.default.existsSync(legacy))
             return null;
-        return JSON.parse(fs_1.default.readFileSync(metadataPath, 'utf8'));
+        return JSON.parse(fs_1.default.readFileSync(legacy, 'utf8'));
     }
     catch {
         return null;
     }
 }
-function getManagerCacheAgeHours() {
-    const metadata = readManagerCacheMetadata();
+function getManagerSyncAgeHours() {
+    const metadata = readManagerSyncMetadata();
     if (!metadata?.syncedAt)
         return null;
     const syncedAt = Date.parse(metadata.syncedAt);
@@ -57,7 +88,7 @@ function getManagerCacheAgeHours() {
 }
 function decorateManagedManagerFile(content, backend) {
     const normalized = content.replace(/^\uFEFF/, '');
-    if (normalized.startsWith(exports.MANAGER_CACHE_MANAGED_HEADER))
+    if (normalized.startsWith(exports.MANAGER_MANAGED_HEADER))
         return normalized;
     const writePath = backend === 'git'
         ? 'open a pull request against your manager storage repo'
@@ -65,7 +96,7 @@ function decorateManagedManagerFile(content, backend) {
             ? 'edit the file in your synced folder and let the sync client upload it'
             : 'publish the change through your FRAIM manager storage flow';
     const marker = [
-        exports.MANAGER_CACHE_MANAGED_HEADER,
+        exports.MANAGER_MANAGED_HEADER,
         '> [!IMPORTANT]',
         '> Synced from your personal manager storage. Local edits are overwritten on the next sync.',
         `> To change this content, ${writePath}.`,
@@ -106,8 +137,8 @@ async function fetchCloudPack(remoteUrl, apiKey) {
         version: String(response.data?.version ?? '0')
     };
 }
-function materializeCache(files, metadata) {
-    const cacheDir = getManagerCacheDir();
+function materializeCloudHome(files, metadata) {
+    const cacheDir = getManagerHomeDir();
     const stagingDir = `${cacheDir}.staging-${process.pid}`;
     fs_1.default.rmSync(stagingDir, { recursive: true, force: true });
     fs_1.default.mkdirSync(stagingDir, { recursive: true });
@@ -125,7 +156,7 @@ function materializeCache(files, metadata) {
             : file.content;
         fs_1.default.writeFileSync(destination, content);
     }
-    fs_1.default.writeFileSync(path_1.default.join(stagingDir, exports.MANAGER_SYNC_METADATA_FILE), JSON.stringify(metadata, null, 2));
+    // Provenance is written outside the home by writeHomeMetadata.
     fs_1.default.rmSync(cacheDir, { recursive: true, force: true });
     fs_1.default.renameSync(stagingDir, cacheDir);
 }
@@ -147,12 +178,12 @@ async function discoverCloudManagerStorage(options) {
 }
 function failureOutcome(error) {
     const message = error instanceof Error ? error.message : String(error);
-    const existing = readManagerCacheMetadata();
+    const existing = readManagerSyncMetadata();
     if (existing) {
         return {
             status: 'stale',
             metadata: existing,
-            ageHours: getManagerCacheAgeHours() ?? 0,
+            ageHours: getManagerSyncAgeHours() ?? 0,
             error: message
         };
     }
@@ -172,32 +203,35 @@ async function syncManagerCache(options) {
     }
     try {
         if (managerStorage.backend === 'local-folder') {
+            // Issue #1043 round 2: the configured folder IS the home. There is
+            // no cache to materialize into; the OS sync client is the transport
+            // and the files are already the single place FRAIM reads.
             const localPath = managerStorage.localPath;
-            const files = (0, local_folder_sync_1.collectLocalFolderFiles)(localPath, manager_pack_1.isManagerPackRelativePath);
             const metadata = {
                 version: (0, local_folder_sync_1.localFolderVersion)(localPath),
                 backend: 'local-folder',
                 source: localPath,
                 syncedAt: new Date().toISOString(),
             };
-            materializeCache(files, metadata);
+            writeHomeMetadata(metadata);
             return { status: 'synced', metadata };
         }
         if (managerStorage.backend === 'git') {
-            const snapshot = (0, git_org_sync_1.fetchOrgRepoSnapshot)(managerStorage.gitUrl);
-            try {
-                const metadata = {
-                    version: snapshot.sha,
-                    backend: 'git',
-                    source: managerStorage.gitUrl,
-                    syncedAt: new Date().toISOString()
-                };
-                materializeCache(collectGitPackFiles(snapshot.dir), metadata);
-                return { status: 'synced', metadata };
-            }
-            finally {
-                snapshot.cleanup();
-            }
+            // Issue #1043 round 2: the durable clone IS the home. ensurePackClone
+            // already fast-forwarded it, so syncing is that pull, not a copy into
+            // a second location.
+            const home = (0, pack_home_1.resolvePackHome)('manager');
+            const clone = (0, pack_home_1.ensurePackClone)(managerStorage.gitUrl, home.root);
+            if (clone.sha === null)
+                throw new Error(clone.offlineReason ?? 'Pack clone unavailable.');
+            const metadata = {
+                version: clone.sha,
+                backend: 'git',
+                source: managerStorage.gitUrl,
+                syncedAt: new Date().toISOString()
+            };
+            writeHomeMetadata(metadata);
+            return { status: 'synced', metadata };
         }
         const remoteUrl = options?.remoteUrl || process.env.FRAIM_REMOTE_URL || 'https://fraim.wellnessatwork.me';
         const apiKey = options?.apiKey || (0, user_config_1.readUserFraimConfig)().apiKey;
@@ -210,7 +244,10 @@ async function syncManagerCache(options) {
             source: remoteUrl,
             syncedAt: new Date().toISOString()
         };
-        materializeCache(pack.files, metadata);
+        // The cloud has no user-visible folder, so this managed directory is the
+        // home for that backend, not a cache beside one.
+        materializeCloudHome(pack.files, metadata);
+        writeHomeMetadata(metadata);
         return { status: 'synced', metadata };
     }
     catch (error) {