@wipcomputer/wip-ldm-os 0.4.70 → 0.4.72

package/SKILL.md

@@ -9,7 +9,7 @@ license: MIT
 compatibility: Requires git, npm, node. Node.js 18+.
 metadata:
   display-name: "LDM OS"
-  version: "0.4.70"
+  version: "0.4.72"
   homepage: "https://github.com/wipcomputer/wip-ldm-os"
   author: "Parker Todd Brooks"
   category: infrastructure

package/bin/ldm.js

@@ -20,7 +20,7 @@
  *   ldm --version         Show version
  */
 
-import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, cpSync, chmodSync, unlinkSync, readlinkSync, renameSync } from 'node:fs';
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, cpSync, chmodSync, unlinkSync, readlinkSync, renameSync, statSync } from 'node:fs';
 import { join, basename, resolve, dirname } from 'node:path';
 import { execSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
@@ -53,11 +53,16 @@ try {
   PKG_VERSION = JSON.parse(readFileSync(pkgPath, 'utf8')).version;
 } catch {}
 
-// Read catalog
-const catalogPath = join(__dirname, '..', 'catalog.json');
+// Read catalog: prefer ~/.ldm/catalog.json (user-editable), fall back to npm package (#262)
+const localCatalogPath = join(LDM_ROOT, 'catalog.json');
+const packageCatalogPath = join(__dirname, '..', 'catalog.json');
 let CATALOG = { components: [] };
 try {
-  CATALOG = JSON.parse(readFileSync(catalogPath, 'utf8'));
+  if (existsSync(localCatalogPath)) {
+    CATALOG = JSON.parse(readFileSync(localCatalogPath, 'utf8'));
+  } else {
+    CATALOG = JSON.parse(readFileSync(packageCatalogPath, 'utf8'));
+  }
 } catch {}
 
 // Auto-sync version.json when CLI version drifts (#33)
@@ -320,6 +325,19 @@ function loadCatalog() {
   return CATALOG.components || [];
 }
 
+// Seed ~/.ldm/catalog.json from the npm package if it doesn't exist (#262)
+function seedLocalCatalog() {
+  if (existsSync(localCatalogPath)) return false;
+  try {
+    const pkgCatalog = readFileSync(packageCatalogPath, 'utf8');
+    mkdirSync(LDM_ROOT, { recursive: true });
+    writeFileSync(localCatalogPath, pkgCatalog);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 function findInCatalog(id) {
   const q = id.toLowerCase();
   // Strip org/ prefix for matching (e.g. "wipcomputer/openclaw-tavily" -> "openclaw-tavily")
@@ -357,7 +375,8 @@ function findInCatalog(id) {
 // Replaces the old execSync('ldm install ${c.repo}') which spawned
 // a full installer process for each component.
 async function installCatalogComponent(c) {
-  const { installFromPath } = await import('../lib/deploy.mjs');
+  const { installFromPath, setFlags: setDeployFlags } = await import('../lib/deploy.mjs');
+  setDeployFlags({ dryRun: DRY_RUN, jsonOutput: JSON_OUTPUT, origin: 'catalog' }); // #262
   const repoTarget = c.repo;
   const repoName = basename(repoTarget);
   const repoPath = join(LDM_TMP, repoName);
@@ -392,6 +411,174 @@ async function installCatalogComponent(c) {
 }
 
 // ── Bridge deploy (#245) ──
+// Deploy all scripts from scripts/ to ~/.ldm/bin/
+// Called from both cmdInit() and cmdInstallCatalog() so script fixes land on every update.
+function deployScripts() {
+  const scriptsSrc = join(__dirname, '..', 'scripts');
+  if (!existsSync(scriptsSrc)) return 0;
+  mkdirSync(join(LDM_ROOT, 'bin'), { recursive: true });
+  let count = 0;
+  for (const file of readdirSync(scriptsSrc)) {
+    if (!file.endsWith('.sh')) continue;
+    const src = join(scriptsSrc, file);
+    const dest = join(LDM_ROOT, 'bin', file);
+    cpSync(src, dest);
+    chmodSync(dest, 0o755);
+    count++;
+  }
+  if (count > 0) {
+    console.log(`  + ${count} script(s) deployed to ~/.ldm/bin/`);
+  }
+  return count;
+}
+
+// Deploy personalized docs to both settings/docs/ and library/documentation/
+// Called from both cmdInit() and cmdInstallCatalog() so doc fixes land on every update.
+function deployDocs() {
+  const docsSrc = join(__dirname, '..', 'shared', 'docs');
+  if (!existsSync(docsSrc)) return 0;
+
+  let workspacePath = '';
+  try {
+    const ldmConfig = JSON.parse(readFileSync(join(LDM_ROOT, 'config.json'), 'utf8'));
+    workspacePath = (ldmConfig.workspace || '').replace('~', HOME);
+  } catch { return 0; }
+  if (!workspacePath || !existsSync(workspacePath)) return 0;
+
+  // Read config for template vars
+  let ldmConfig;
+  try {
+    ldmConfig = JSON.parse(readFileSync(join(LDM_ROOT, 'config.json'), 'utf8'));
+  } catch { return 0; }
+
+  const sc = ldmConfig;
+
+  // Agents from config (rich objects with harness/machine/prefix)
+  const agentsObj = sc.agents || {};
+  const agentsList = Object.entries(agentsObj).map(([id, a]) => `${id} (${a.harness} on ${a.machine})`).join(', ');
+  const agentsDetail = Object.entries(agentsObj).map(([id, a]) => `- **${id}**: ${a.harness} on ${a.machine}, branch prefix \`${a.prefix}/\``).join('\n');
+
+  // Harnesses from config
+  const harnessConfig = sc.harnesses || {};
+  const harnessesDetected = Object.entries(harnessConfig).filter(([,h]) => h.detected).map(([name]) => name);
+  const harnessesList = harnessesDetected.length > 0 ? harnessesDetected.join(', ') : 'run ldm install to detect';
+
+  const templateVars = {
+    'name': sc.name || '',
+    'org': sc.org || '',
+    'timezone': sc.timezone || '',
+    'paths.workspace': (sc.paths?.workspace || '').replace('~', HOME),
+    'paths.ldm': (sc.paths?.ldm || '').replace('~', HOME),
+    'paths.openclaw': (sc.paths?.openclaw || '').replace('~', HOME),
+    'paths.icloud': (sc.paths?.icloud || '').replace('~', HOME),
+    'memory.local': (sc.memory?.local || '').replace('~', HOME),
+    'deploy.website': sc.deploy?.website || '',
+    'backup.keep': String(sc.backup?.keep || 7),
+    'agents_list': agentsList,
+    'agents_detail': agentsDetail,
+    'harnesses_list': harnessesList,
+  };
+
+  function renderTemplates(destDir) {
+    mkdirSync(destDir, { recursive: true });
+    let count = 0;
+    for (const file of readdirSync(docsSrc)) {
+      if (!file.endsWith('.tmpl')) continue;
+      let content = readFileSync(join(docsSrc, file), 'utf8');
+      content = content.replace(/\{\{([^}]+)\}\}/g, (match, key) => {
+        return templateVars[key.trim()] || match;
+      });
+      const outName = file.replace('.tmpl', '');
+      writeFileSync(join(destDir, outName), content);
+      count++;
+    }
+    return count;
+  }
+
+  // Deploy to settings/docs/ (agent reference)
+  const docsDest = join(workspacePath, 'settings', 'docs');
+  const docsCount = renderTemplates(docsDest);
+  if (docsCount > 0) {
+    console.log(`  + ${docsCount} personalized doc(s) deployed to ${docsDest.replace(HOME, '~')}/`);
+  }
+
+  // Deploy to library/documentation/ (human-readable library copy)
+  const libraryDest = join(workspacePath, 'library', 'documentation');
+  if (existsSync(join(workspacePath, 'library'))) {
+    const libCount = renderTemplates(libraryDest);
+    if (libCount > 0) {
+      console.log(`  + ${libCount} doc(s) deployed to ${libraryDest.replace(HOME, '~')}/`);
+    }
+  }
+
+  return docsCount;
+}
+
+// Check backup health: is a trigger configured, did it run recently, is iCloud set up?
+// Called from cmdInstallCatalog() on every install.
+function checkBackupHealth() {
+  const config = readJSON(join(LDM_ROOT, 'config.json'));
+  if (!config) return;
+
+  const backup = config.backup || {};
+  const issues = [];
+
+  // Check iCloud offsite
+  const icloudPath = config.paths?.icloudBackup || backup.icloudPath;
+  if (!icloudPath) {
+    issues.push('iCloud offsite not configured. Add paths.icloudBackup to ~/.ldm/config.json');
+  } else {
+    const expandedPath = icloudPath.replace(/^~/, HOME);
+    if (!existsSync(expandedPath)) {
+      try { mkdirSync(expandedPath, { recursive: true }); } catch {}
+      if (!existsSync(expandedPath)) {
+        issues.push(`iCloud path does not exist: ${icloudPath}`);
+      }
+    }
+  }
+
+  // Check LaunchAgent
+  try {
+    const label = backup.triggerLabel || 'ai.openclaw.ldm-backup';
+    const result = execSync(`launchctl list ${label} 2>/dev/null`, { encoding: 'utf8', timeout: 3000 });
+    if (!result) issues.push(`LaunchAgent ${label} not loaded`);
+  } catch {
+    issues.push('Backup LaunchAgent not loaded. Backups may not run automatically.');
+  }
+
+  // Check last backup age
+  const backupRoot = join(LDM_ROOT, 'backups');
+  if (existsSync(backupRoot)) {
+    const dirs = readdirSync(backupRoot)
+      .filter(d => d.match(/^20\d{2}-\d{2}-\d{2}--/) && statSync(join(backupRoot, d)).isDirectory())
+      .sort()
+      .reverse();
+    if (dirs.length > 0) {
+      const latest = dirs[0];
+      const latestDate = latest.replace(/--.*/, '').replace(/-/g, '/');
+      const age = Date.now() - new Date(latestDate).getTime();
+      const hours = Math.round(age / (1000 * 60 * 60));
+      if (hours > 36) {
+        issues.push(`Last backup is ${hours} hours old (${latest}). Expected within 24 hours.`);
+      }
+    } else {
+      issues.push('No backups found. Run: ldm backup');
+    }
+  }
+
+  // Check backup script exists
+  const scriptPath = join(LDM_ROOT, 'bin', 'ldm-backup.sh');
+  if (!existsSync(scriptPath)) {
+    issues.push('Backup script missing at ~/.ldm/bin/ldm-backup.sh. Run: ldm init');
+  }
+
+  if (issues.length > 0) {
+    for (const issue of issues) {
+      console.log(`  ! Backup: ${issue}`);
+    }
+  }
+}
+
 // The bridge (src/bridge/) builds to dist/bridge/ and ships in the npm package.
 // After `npm install -g`, the updated files live at the npm package location but
 // never get copied to ~/.ldm/extensions/lesa-bridge/dist/. This function fixes that.
@@ -653,10 +840,15 @@ async function cmdInit() {
 
   // Seed registry if missing
   if (!existsSync(REGISTRY_PATH)) {
-    writeJSON(REGISTRY_PATH, { _format: 'v1', extensions: {} });
+    writeJSON(REGISTRY_PATH, { _format: 'v2', extensions: {} });
     console.log(`  + registry.json created`);
   }
 
+  // Seed local catalog from npm package (#262)
+  if (seedLocalCatalog()) {
+    console.log(`  + catalog.json seeded to ~/.ldm/catalog.json`);
+  }
+
   // Install global git pre-commit hook (blocks commits on main)
   const hooksDir = join(LDM_ROOT, 'hooks');
   const preCommitDest = join(hooksDir, 'pre-commit');
@@ -700,29 +892,8 @@ async function cmdInit() {
     }
   }
 
-  // Deploy backup + restore scripts (#119)
-  const backupSrc = join(__dirname, '..', 'scripts', 'ldm-backup.sh');
-  const backupDest = join(LDM_ROOT, 'bin', 'ldm-backup.sh');
-  if (existsSync(backupSrc)) {
-    mkdirSync(join(LDM_ROOT, 'bin'), { recursive: true });
-    cpSync(backupSrc, backupDest);
-    chmodSync(backupDest, 0o755);
-    console.log(`  + ldm-backup.sh deployed to ~/.ldm/bin/`);
-  }
-  const restoreSrc = join(__dirname, '..', 'scripts', 'ldm-restore.sh');
-  const restoreDest = join(LDM_ROOT, 'bin', 'ldm-restore.sh');
-  if (existsSync(restoreSrc)) {
-    cpSync(restoreSrc, restoreDest);
-    chmodSync(restoreDest, 0o755);
-    console.log(`  + ldm-restore.sh deployed to ~/.ldm/bin/`);
-  }
-  const summarySrc = join(__dirname, '..', 'scripts', 'ldm-summary.sh');
-  const summaryDest = join(LDM_ROOT, 'bin', 'ldm-summary.sh');
-  if (existsSync(summarySrc)) {
-    cpSync(summarySrc, summaryDest);
-    chmodSync(summaryDest, 0o755);
-    console.log(`  + ldm-summary.sh deployed to ~/.ldm/bin/`);
-  }
+  // Deploy all scripts from scripts/ to ~/.ldm/bin/ (#119)
+  deployScripts();
 
   // Deploy shared rules to ~/.ldm/shared/rules/ and to harnesses
   const rulesSrc = join(__dirname, '..', 'shared', 'rules');
@@ -835,67 +1006,8 @@ async function cmdInit() {
     }
   } catch {}
 
-  // Deploy personalized docs to settings/docs/ (from templates + config.json)
-  const docsSrc = join(__dirname, '..', 'shared', 'docs');
-  if (existsSync(docsSrc)) {
-    let workspacePath = '';
-    try {
-      const ldmConfig = JSON.parse(readFileSync(join(LDM_ROOT, 'config.json'), 'utf8'));
-      workspacePath = (ldmConfig.workspace || '').replace('~', HOME);
-
-      if (workspacePath && existsSync(workspacePath)) {
-        const docsDest = join(workspacePath, 'settings', 'docs');
-        mkdirSync(docsDest, { recursive: true });
-        let docsCount = 0;
-
-        // Build template values from ~/.ldm/config.json (unified config)
-        // Legacy: settings/config.json was a separate file, now merged into config.json
-        const sc = ldmConfig;
-        const lc = ldmConfig;
-
-        // Agents from settings config (rich objects with harness/machine/prefix)
-        const agentsObj = sc.agents || {};
-        const agentsList = Object.entries(agentsObj).map(([id, a]) => `${id} (${a.harness} on ${a.machine})`).join(', ');
-        const agentsDetail = Object.entries(agentsObj).map(([id, a]) => `- **${id}**: ${a.harness} on ${a.machine}, branch prefix \`${a.prefix}/\``).join('\n');
-
-        // Harnesses from ldm config
-        const harnessConfig = lc.harnesses || {};
-        const harnessesDetected = Object.entries(harnessConfig).filter(([,h]) => h.detected).map(([name]) => name);
-        const harnessesList = harnessesDetected.length > 0 ? harnessesDetected.join(', ') : 'run ldm install to detect';
-
-        const templateVars = {
-          'name': sc.name || '',
-          'org': sc.org || '',
-          'timezone': sc.timezone || '',
-          'paths.workspace': (sc.paths?.workspace || '').replace('~', HOME),
-          'paths.ldm': (sc.paths?.ldm || '').replace('~', HOME),
-          'paths.openclaw': (sc.paths?.openclaw || '').replace('~', HOME),
-          'paths.icloud': (sc.paths?.icloud || '').replace('~', HOME),
-          'memory.local': (sc.memory?.local || '').replace('~', HOME),
-          'deploy.website': sc.deploy?.website || '',
-          'backup.keep': String(sc.backup?.keep || 7),
-          'agents_list': agentsList,
-          'agents_detail': agentsDetail,
-          'harnesses_list': harnessesList,
-        };
-
-        for (const file of readdirSync(docsSrc)) {
-          if (!file.endsWith('.tmpl')) continue;
-          let content = readFileSync(join(docsSrc, file), 'utf8');
-          // Replace template vars
-          content = content.replace(/\{\{([^}]+)\}\}/g, (match, key) => {
-            return templateVars[key.trim()] || match;
-          });
-          const outName = file.replace('.tmpl', '');
-          writeFileSync(join(docsDest, outName), content);
-          docsCount++;
-        }
-        if (docsCount > 0) {
-          console.log(`  + ${docsCount} personalized doc(s) deployed to ${docsDest.replace(HOME, '~')}/`);
-        }
-      }
-    } catch {}
-  }
+  // Deploy personalized docs to settings/docs/ and library/documentation/
+  deployDocs();
 
   // Deploy LaunchAgents to ~/Library/LaunchAgents/
   // Templates use {{HOME}} and {{OPENCLAW_GATEWAY_TOKEN}} placeholders, replaced at deploy time.
@@ -1064,7 +1176,7 @@ async function cmdInstall() {
   // Refresh harness detection (catches newly installed harnesses)
   detectHarnesses();
 
-  setFlags({ dryRun: DRY_RUN, jsonOutput: JSON_OUTPUT });
+  setFlags({ dryRun: DRY_RUN, jsonOutput: JSON_OUTPUT, origin: 'manual' });
 
   // --help flag (#81)
   if (args.includes('--help') || args.includes('-h')) {
@@ -1108,6 +1220,7 @@ async function cmdInstall() {
   // Check if target is a catalog ID (e.g. "memory-crystal")
   const catalogEntry = findInCatalog(resolvedTarget);
   if (catalogEntry) {
+    setFlags({ dryRun: DRY_RUN, jsonOutput: JSON_OUTPUT, origin: 'catalog' }); // #262
     console.log('');
     console.log(`  Resolved "${target}" via catalog to ${catalogEntry.repo}`);
 
@@ -1234,6 +1347,98 @@ async function cmdInstall() {
   }
 }
 
+// ── Registry migration (#262) ──
+// Upgrades old v1 registry entries to v2 format with source info.
+// Runs once per install. Idempotent: entries that already have source are skipped.
+
+function migrateRegistry() {
+  const registry = readJSON(REGISTRY_PATH);
+  if (!registry?.extensions) return 0;
+
+  const components = loadCatalog();
+  let migrated = 0;
+
+  for (const [name, entry] of Object.entries(registry.extensions)) {
+    // Skip entries that have already been migrated to v2 format.
+    // An entry is fully migrated if it has: installed (object), paths, origin,
+    // and source is either structured (object with type) or explicitly null.
+    const hasV2Installed = entry.installed && typeof entry.installed === 'object' && entry.installed.version;
+    const sourceIsResolved = entry.source === null || (typeof entry.source === 'object' && entry.source?.type);
+    if (hasV2Installed && entry.paths && entry.origin && sourceIsResolved) continue;
+
+    const newSource = { type: 'github' };
+    let hasSource = false;
+
+    // Try 1: match against catalog for source info
+    const catalogMatch = components.find(c => {
+      const matches = c.registryMatches || [c.id];
+      return matches.includes(name) || c.id === name;
+    });
+    if (catalogMatch) {
+      if (catalogMatch.repo) { newSource.repo = catalogMatch.repo; hasSource = true; }
+      if (catalogMatch.npm) { newSource.npm = catalogMatch.npm; hasSource = true; }
+      if (!entry.origin) entry.origin = 'catalog';
+    }
+
+    // Try 2: read from the installed extension's package.json repository field
+    if (!hasSource || !newSource.repo) {
+      const extPkgPath = join(LDM_EXTENSIONS, name, 'package.json');
+      const extPkg = readJSON(extPkgPath);
+      if (extPkg?.name && !newSource.npm) {
+        newSource.npm = extPkg.name;
+        hasSource = true;
+      }
+      if (extPkg?.repository) {
+        const raw = typeof extPkg.repository === 'string'
+          ? extPkg.repository
+          : extPkg.repository.url || '';
+        const ghMatch = raw.match(/github\.com[:/]([^/]+\/[^/.]+)/);
+        if (ghMatch) {
+          newSource.repo = ghMatch[1].replace(/\.git$/, '');
+          hasSource = true;
+        }
+      }
+    }
+
+    if (hasSource) {
+      entry.source = newSource;
+    } else if (typeof entry.source === 'string') {
+      // Legacy string source (path or URL). Clear it since we couldn't build structured source.
+      entry.source = null;
+    }
+
+    // Migrate flat version to installed block
+    if (!entry.installed || typeof entry.installed !== 'object') {
+      entry.installed = {
+        version: entry.version || 'unknown',
+        installedAt: entry.updatedAt || new Date().toISOString(),
+        updatedAt: entry.updatedAt || new Date().toISOString(),
+      };
+    }
+
+    // Migrate flat paths to paths block
+    if (!entry.paths) {
+      entry.paths = {};
+      if (entry.ldmPath) entry.paths.ldm = entry.ldmPath;
+      if (entry.ocPath) entry.paths.openclaw = entry.ocPath;
+    }
+
+    // Set origin if missing
+    if (!entry.origin) {
+      entry.origin = 'manual';
+    }
+
+    migrated++;
+  }
+
+  if (migrated > 0) {
+    registry._format = 'v2';
+    writeJSON(REGISTRY_PATH, registry);
+  }
+
+  return migrated;
+}
+
 // ── Auto-detect unregistered extensions ──
 
 function autoDetectExtensions() {
@@ -1318,11 +1523,29 @@ async function cmdInstallCatalog() {
 
   autoDetectExtensions();
 
+  // Migrate old registry entries to v2 format (#262)
+  const migrated = migrateRegistry();
+  if (migrated > 0) {
+    console.log(`  + Migrated ${migrated} registry entries to v2 format (source info added)`);
+  }
+
+  // Seed local catalog if missing (#262)
+  if (seedLocalCatalog()) {
+    console.log(`  + catalog.json seeded to ~/.ldm/catalog.json`);
+  }
+
   // Deploy bridge files after self-update or on every catalog install (#245, #251)
   // After npm install -g, the new bridge files are in the npm package but not
   // in the extension directories. This copies them to both LDM and OpenClaw targets.
   deployBridge();
 
+  // Deploy scripts and docs on every install so fixes land without re-init
+  deployScripts();
+  deployDocs();
+
+  // Check backup configuration
+  checkBackupHealth();
+
   const { detectSystemState, reconcileState, formatReconciliation } = await import('../lib/state.mjs');
   const state = detectSystemState();
   const reconciled = reconcileState(state);
@@ -1528,7 +1751,9 @@ async function cmdInstallCatalog() {
     console.log('');
   }
 
-  // Build the update plan: check ALL installed extensions against npm (#55)
+  // Build the update plan from REGISTRY entries (#262)
+  // The registry is the source of truth. Each entry has source info (npm, repo)
+  // that tells us where to check for updates.
   const npmUpdates = [];
 
   // Check CLI self-update (#132)
@@ -1548,59 +1773,104 @@ async function cmdInstallCatalog() {
     }
   } catch {}
 
-  // Check every installed extension against npm via catalog
-  console.log('  Checking npm for updates...');
-  for (const [name, entry] of Object.entries(reconciled)) {
-    if (!entry.deployedLdm && !entry.deployedOc) continue; // not installed
+  // Check every registered extension for updates (#262)
+  // Source of truth: registry entry's source.npm and source.repo fields.
+  // Fallback: extension's package.json (for old entries without source info).
+  console.log('  Checking for updates...');
+  const registryEntries = Object.entries(registry?.extensions || {});
+  const checkedNames = new Set(); // track what we've checked
 
-    // Get npm package name from the installed extension's own package.json
-    const extPkgPath = join(LDM_EXTENSIONS, name, 'package.json');
-    const extPkg = readJSON(extPkgPath);
-    const npmPkg = extPkg?.name;
-    if (!npmPkg) continue; // no package name, skip
+  for (const [name, regEntry] of registryEntries) {
+    // Skip entries with no installed version
+    const currentVersion = regEntry?.installed?.version || regEntry?.version;
+    if (!currentVersion) continue;
 
-    // Find catalog entry for the repo URL (used for clone if update needed)
+    // Skip pinned components (e.g. OpenClaw)
     const catalogEntry = components.find(c => {
       const matches = c.registryMatches || [c.id];
       return matches.includes(name) || c.id === name;
     });
-
-    // Skip pinned components (e.g. OpenClaw). Upgrades must be explicit.
     if (catalogEntry?.pinned) continue;
 
-    // Fallback: use repository.url from extension's package.json (#82)
-    let repoUrl = catalogEntry?.repo || null;
-    if (!repoUrl && extPkg?.repository) {
-      const raw = typeof extPkg.repository === 'string'
-        ? extPkg.repository
-        : extPkg.repository.url || '';
-      const ghMatch = raw.match(/github\.com[:/]([^/]+\/[^/.]+)/);
-      if (ghMatch) repoUrl = ghMatch[1];
+    // Get npm package name from registry source (v2) or extension's package.json (legacy)
+    const sourceNpm = regEntry?.source?.npm;
+    const sourceRepo = regEntry?.source?.repo;
+    let npmPkg = sourceNpm || null;
+
+    // Fallback: read from installed extension's package.json
+    if (!npmPkg) {
+      const extPkgPath = join(LDM_EXTENSIONS, name, 'package.json');
+      const extPkg = readJSON(extPkgPath);
+      npmPkg = extPkg?.name || null;
     }
 
-    const currentVersion = entry.ldmVersion || entry.ocVersion;
-    if (!currentVersion) continue;
+    // Determine repo URL for cloning updates
+    let repoUrl = sourceRepo || catalogEntry?.repo || null;
+    if (!repoUrl) {
+      const extPkgPath = join(LDM_EXTENSIONS, name, 'package.json');
+      const extPkg = readJSON(extPkgPath);
+      if (extPkg?.repository) {
+        const raw = typeof extPkg.repository === 'string'
+          ? extPkg.repository
+          : extPkg.repository.url || '';
+        const ghMatch = raw.match(/github\.com[:/]([^/]+\/[^/.]+)/);
+        if (ghMatch) repoUrl = ghMatch[1];
+      }
+    }
 
-    try {
-      const latestVersion = execSync(`npm view ${npmPkg} version 2>/dev/null`, {
-        encoding: 'utf8', timeout: 10000,
-      }).trim();
+    // Check npm for updates (fast, one HTTP call)
+    if (npmPkg) {
+      try {
+        const latestVersion = execSync(`npm view ${npmPkg} version 2>/dev/null`, {
+          encoding: 'utf8', timeout: 10000,
+        }).trim();
 
-      if (latestVersion && latestVersion !== currentVersion) {
-        npmUpdates.push({
-          ...entry,
-          catalogRepo: repoUrl,
-          catalogNpm: npmPkg,
-          currentVersion,
-          latestVersion,
-          hasUpdate: true,
+        if (latestVersion && latestVersion !== currentVersion) {
+          npmUpdates.push({
+            name,
+            catalogRepo: repoUrl,
+            catalogNpm: npmPkg,
+            currentVersion,
+            latestVersion,
+            hasUpdate: true,
+          });
+        }
+      } catch {}
+      checkedNames.add(name);
+      continue;
+    }
+
+    // No npm package. Check GitHub tags via git ls-remote (#262).
+    // Works for private repos with SSH access.
+    if (repoUrl) {
+      try {
+        const sshUrl = `git@github.com:${repoUrl}.git`;
+        const tags = execSync(`git ls-remote --tags --sort=-v:refname "${sshUrl}" 2>/dev/null`, {
+          encoding: 'utf8', timeout: 15000,
         });
-      }
-    } catch {}
+        // Parse latest semver tag
+        const tagMatch = tags.match(/refs\/tags\/v?(\d+\.\d+\.\d+)/);
+        if (tagMatch) {
+          const latestVersion = tagMatch[1];
+          if (latestVersion !== currentVersion) {
+            npmUpdates.push({
+              name,
+              catalogRepo: repoUrl,
+              catalogNpm: repoUrl, // display repo URL since no npm package
+              currentVersion,
+              latestVersion,
+              hasUpdate: true,
+            });
+          }
+        }
+      } catch {}
+      checkedNames.add(name);
+    }
   }
 
-  // Check global CLIs not tracked by extension loop (#81)
+  // Check global CLIs not tracked by registry (#81)
   for (const [binName, binInfo] of Object.entries(state.cliBinaries || {})) {
+    if (checkedNames.has(binName)) continue;
     const catalogComp = components.find(c =>
       (c.cliMatches || []).includes(binName)
     );
@@ -1635,18 +1905,17 @@ async function cmdInstallCatalog() {
   // Check parent packages for toolbox-style repos (#132)
   // If sub-tools are installed but the parent npm package has a newer version,
   // report the parent as needing an update (not the individual sub-tool).
-  // Don't skip packages already found by the extension loop. The parent check
-  // REPLACES sub-tool entries with the parent name.
   const checkedParentNpm = new Set();
   for (const comp of components) {
     if (!comp.npm || checkedParentNpm.has(comp.npm)) continue;
     if (!comp.registryMatches || comp.registryMatches.length === 0) continue;
 
     // If any registryMatch is installed, check the parent package
-    const installedMatch = comp.registryMatches.find(m => reconciled[m]);
+    const installedMatch = comp.registryMatches.find(m => registry?.extensions?.[m]);
     if (!installedMatch) continue;
 
-    const currentVersion = reconciled[installedMatch]?.ldmVersion || reconciled[installedMatch]?.ocVersion || '?';
+    const matchEntry = registry.extensions[installedMatch];
+    const currentVersion = matchEntry?.installed?.version || matchEntry?.version || '?';
 
     try {
       const latest = execSync(`npm view ${comp.npm} version 2>/dev/null`, {
@@ -1654,8 +1923,6 @@ async function cmdInstallCatalog() {
       }).trim();
       if (latest && latest !== currentVersion) {
         // Remove any sub-tool entries that belong to this parent.
-        // Match by name in registryMatches (sub-tools have their own npm names,
-        // not the parent's, so catalogNpm comparison doesn't work).
         const parentMatches = new Set(comp.registryMatches || []);
         for (let i = npmUpdates.length - 1; i >= 0; i--) {
           if (!npmUpdates[i].isCLI && parentMatches.has(npmUpdates[i].name)) {
@@ -1841,7 +2108,7 @@ async function cmdInstallCatalog() {
   const manifestPath = createRevertManifest(
     `ldm install (update ${totalUpdates} extensions)`,
     npmUpdates.map(e => ({
-      action: 'update-from-catalog',
+      action: 'update-from-registry',
       name: e.name,
       currentVersion: e.currentVersion,
       latestVersion: e.latestVersion,
@@ -1852,11 +2119,11 @@ async function cmdInstallCatalog() {
   console.log('');
 
   const { setFlags, installFromPath } = await import('../lib/deploy.mjs');
-  setFlags({ dryRun: DRY_RUN, jsonOutput: JSON_OUTPUT });
+  setFlags({ dryRun: DRY_RUN, jsonOutput: JSON_OUTPUT, origin: 'catalog' }); // #262
 
   let updated = 0;
 
-  // Update from npm via catalog repos (#55) and CLIs (#81)
+  // Update from registry sources (#262, replaces old catalog-based update loop)
   for (const entry of npmUpdates) {
     // CLI self-update is handled by the self-update block at the top of cmdInstallCatalog()
     if (entry.isCLI) continue;
@@ -1882,14 +2149,20 @@ async function cmdInstallCatalog() {
       execSync(`ldm install ${entry.catalogRepo}`, { stdio: 'inherit' });
       updated++;
 
-      // For parent packages, update registry version for all sub-tools (#139)
+      // For parent packages, update registry version for all sub-tools (#139, #262)
       if (entry.isParent && entry.registryMatches) {
         const registry = readJSON(REGISTRY_PATH);
         if (registry?.extensions) {
+          const now = new Date().toISOString();
           for (const subTool of entry.registryMatches) {
             if (registry.extensions[subTool]) {
               registry.extensions[subTool].version = entry.latestVersion;
-              registry.extensions[subTool].updatedAt = new Date().toISOString();
+              registry.extensions[subTool].updatedAt = now;
+              // Also update v2 installed block
+              if (registry.extensions[subTool].installed) {
+                registry.extensions[subTool].installed.version = entry.latestVersion;
+                registry.extensions[subTool].installed.updatedAt = now;
+              }
             }
           }
           writeFileSync(REGISTRY_PATH, JSON.stringify(registry, null, 2));
@@ -2293,14 +2566,18 @@ function cmdStatus() {
     if (latest && latest !== PKG_VERSION) cliUpdate = latest;
   } catch {}
 
-  // Check extensions against npm
+  // Check extensions against npm using registry source info (#262)
   const updates = [];
   for (const [name, info] of Object.entries(registry?.extensions || {})) {
-    const extPkgPath = join(LDM_EXTENSIONS, name, 'package.json');
-    const extPkg = readJSON(extPkgPath);
-    const npmPkg = extPkg?.name;
+    // Use registry source.npm (v2) or fall back to extension's package.json
+    let npmPkg = info?.source?.npm || null;
+    if (!npmPkg) {
+      const extPkgPath = join(LDM_EXTENSIONS, name, 'package.json');
+      const extPkg = readJSON(extPkgPath);
+      npmPkg = extPkg?.name;
+    }
     if (!npmPkg) continue;
-    const currentVersion = extPkg.version || info.version;
+    const currentVersion = info?.installed?.version || info.version;
     if (!currentVersion) continue;
     try {
       const latest = execSync(`npm view ${npmPkg} version 2>/dev/null`, {

package/catalog.json

@@ -301,6 +301,24 @@
       "installs": {
         "ocPlugin": "Web search and content extraction"
       }
+    },
+    {
+      "id": "private-mode",
+      "name": "Private Mode",
+      "description": "Privacy controls for AI agents. Pause memory capture, scan storage, wipe history.",
+      "npm": "private-mode",
+      "repo": "wipcomputer/wip-private-mode-private",
+      "registryMatches": [
+        "private-mode",
+        "wip-private-mode"
+      ],
+      "cliMatches": [],
+      "recommended": false,
+      "status": "stable",
+      "postInstall": null,
+      "installs": {
+        "ocPlugin": "Private mode toggle, memory status indicator, wipe scan/search/execute"
+      }
     }
   ]
 }

package/docs/backup/README.md

@@ -0,0 +1,108 @@
+# Backup
+
+## One Script, One Place
+
+`~/.ldm/bin/ldm-backup.sh` runs daily at 3:00 AM via LaunchAgent `ai.openclaw.ldm-backup`. It backs up everything to `~/.ldm/backups/`, then tars it to iCloud for offsite.
+
+## What Gets Backed Up
+
+| Source | Method | What's in it |
+|--------|--------|-------------|
+| `~/.ldm/memory/crystal.db` | sqlite3 .backup | Irreplaceable memory (all agents) |
+| `~/.ldm/agents/` | cp -a | Identity files, journals, daily logs |
+| `~/.ldm/state/` | cp -a | Config, version, registry |
+| `~/.ldm/config.json` | cp | Workspace pointer, org |
+| `~/.openclaw/memory/main.sqlite` | sqlite3 .backup | OC conversations |
+| `~/.openclaw/memory/context-embeddings.sqlite` | sqlite3 .backup | Embeddings |
+| `~/.openclaw/workspace/` | tar | Shared context, daily logs |
+| `~/.openclaw/agents/main/sessions/` | tar | OC session JSONL |
+| `~/.openclaw/openclaw.json` | cp | OC config |
+| `~/.claude/CLAUDE.md` | cp | CC instructions |
+| `~/.claude/settings.json` | cp | CC settings |
+| `~/.claude/projects/` | tar | CC auto-memory + transcripts |
+| Workspace directory | tar (excludes node_modules, .git/objects, old backups, _trash) | Entire workspace |
+
+**NOT backed up:** node_modules/, .git/objects/ (reconstructable), extensions (reinstallable), ~/.claude/cache.
+
+## Backup Structure
+
+```
+~/.ldm/backups/2026-03-24--09-50-22/
+  ldm/
+    memory/crystal.db
+    agents/
+    state/
+    config.json
+  openclaw/
+    memory/main.sqlite
+    memory/context-embeddings.sqlite
+    workspace.tar
+    sessions.tar
+    openclaw.json
+  claude/
+    CLAUDE.md
+    settings.json
+    projects.tar
+  <workspace>.tar
+```
+
+## iCloud Offsite
+
+After local backup, the entire dated folder is compressed and copied to iCloud. The destination path is read from `~/.ldm/config.json` at `paths.icloudBackup`.
+
+One file per backup. iCloud syncs it across devices. Rotation matches the local retention setting.
+
+## How to Run
+
+```bash
+~/.ldm/bin/ldm-backup.sh                    # run backup now
+~/.ldm/bin/ldm-backup.sh --dry-run          # preview what would be backed up
+~/.ldm/bin/ldm-backup.sh --keep 14          # keep 14 days instead of 7
+~/.ldm/bin/ldm-backup.sh --include-secrets   # include ~/.ldm/secrets/
+```
+
+You can also run via the CLI:
+
+```bash
+ldm backup                                   # run backup now
+ldm backup --dry-run                         # preview with sizes
+ldm backup --pin "before upgrade"            # pin latest backup so rotation skips it
+```
+
+## How to Restore
+
+```bash
+~/.ldm/bin/ldm-restore.sh                           # list available backups
+~/.ldm/bin/ldm-restore.sh 2026-03-24--09-50-22      # restore everything
+~/.ldm/bin/ldm-restore.sh --only ldm <backup>       # restore only crystal.db + agents
+~/.ldm/bin/ldm-restore.sh --only openclaw <backup>  # restore only OC data
+~/.ldm/bin/ldm-restore.sh --from-icloud <file>      # restore from iCloud tar
+~/.ldm/bin/ldm-restore.sh --dry-run <backup>        # preview
+```
+
+After restore: `openclaw gateway restart` then `crystal status` to verify.
+
+## Schedule
+
+| What | When | How |
+|------|------|-----|
+| Backup | 3:00 AM | LaunchAgent `ai.openclaw.ldm-backup` |
+
+One LaunchAgent. One script. No Full Disk Access currently (target: midnight via LDMDevTools.app once PID error is fixed). Verify is built into the script (exit code + log).
+
+## Config
+
+All backup settings live in `~/.ldm/config.json`:
+- `paths.workspace` ... workspace path
+- `paths.icloudBackup` ... iCloud offsite destination
+- `backup.keep` ... retention days (default: 7)
+- `backup.includeSecrets` ... whether to include `~/.ldm/secrets/`
+- `org` ... used for tar filename prefix
+
+## Logs
+
+`~/.ldm/logs/backup.log` (LaunchAgent stdout/stderr)
+
+## Technical Details
+
+See [TECHNICAL.md](./TECHNICAL.md) for config schema, LaunchAgent plist, rotation logic, and script internals.

package/docs/backup/TECHNICAL.md

@@ -0,0 +1,112 @@
+# Backup: Technical Details
+
+## Config Schema
+
+All backup settings are in `~/.ldm/config.json`. The backup script reads these at runtime.
+
+```json
+{
+  "org": "wipcomputerinc",
+  "paths": {
+    "workspace": "~/wipcomputerinc",
+    "ldm": "~/.ldm",
+    "claude": "~/.claude",
+    "openclaw": "~/.openclaw",
+    "icloudBackup": "~/Library/Mobile Documents/com~apple~CloudDocs/wipcomputerinc-icloud/backups"
+  },
+  "backup": {
+    "keep": 7,
+    "includeSecrets": false
+  }
+}
+```
+
+| Key | Type | Default | Description |
+|-----|------|---------|-------------|
+| `paths.workspace` | string | required | Root workspace directory to back up |
+| `paths.icloudBackup` | string | optional | iCloud destination for offsite copies |
+| `backup.keep` | number | 7 | Days of backups to keep before rotation |
+| `backup.includeSecrets` | boolean | false | Whether to include `~/.ldm/secrets/` |
+| `org` | string | required | Used as prefix in iCloud tar filenames |
+
+## Script Location
+
+- **Source:** `scripts/ldm-backup.sh` in the wip-ldm-os-private repo
+- **Deployed to:** `~/.ldm/bin/ldm-backup.sh`
+- **Deployed by:** `deployScripts()` in `bin/ldm.js`, called during both `ldm init` and `ldm install`
+- **Restore script:** `scripts/ldm-restore.sh` deployed to `~/.ldm/bin/ldm-restore.sh`
+
+All `.sh` files in the repo's `scripts/` directory are deployed to `~/.ldm/bin/` on every `ldm install`. This means script fixes land automatically on the next update without requiring a full `ldm init`.
+
+## LaunchAgent
+
+**Label:** `ai.openclaw.ldm-backup`
+**Plist source:** `shared/launchagents/ai.openclaw.ldm-backup.plist`
+**Deployed to:** `~/Library/LaunchAgents/ai.openclaw.ldm-backup.plist`
+
+```xml
+<key>StartCalendarInterval</key>
+<dict>
+  <key>Hour</key>
+  <integer>3</integer>
+  <key>Minute</key>
+  <integer>0</integer>
+</dict>
+```
+
+The plist uses `{{HOME}}` placeholders that are replaced at deploy time by `ldm init`.
+
+**Logs:** stdout and stderr both go to `~/.ldm/logs/backup.log`.
+
+**No Full Disk Access (FDA):** The LaunchAgent runs at 3:00 AM without FDA. Some paths (like `~/Library/Messages/`) are inaccessible without FDA. The target is to move the trigger to midnight via LDMDevTools.app (which has FDA) once the PID error is resolved.
+
+### Dead Triggers (Cleaned Automatically)
+
+The `cleanDeadBackupTriggers()` function in `ldm.js` removes old competing triggers on every `ldm init`:
+- Old cron entries referencing `LDMDevTools.app`
+- `com.wipcomputer.daily-backup` LaunchAgent
+- OpenClaw `backup-verify` cron entries
+
+Only `ai.openclaw.ldm-backup` should exist.
+
+## Rotation Logic
+
+The backup script handles rotation after a successful backup:
+
+1. List all dated directories in `~/.ldm/backups/` (format: `YYYY-MM-DD--HH-MM-SS`)
+2. Sort by name (which sorts chronologically)
+3. Skip any directory containing a `.pinned` marker file
+4. Delete directories beyond the `keep` count (oldest first)
+5. Same rotation logic applies to iCloud tars at `paths.icloudBackup`
+
+**Pinning:** `ldm backup --pin "reason"` creates a `.pinned` file in the latest backup directory. Pinned backups are never rotated.
+
+## iCloud Offsite Details
+
+After the local backup completes:
+
+1. Tar + gzip the entire dated backup directory
+2. Filename format: `<org>-<machine>-<timestamp>.tar.gz`
+3. Copy to `paths.icloudBackup` (from config.json)
+4. Apply the same rotation (keep N, skip pinned)
+5. iCloud syncs the file to all devices automatically
+
+The iCloud path must exist. The script does not create it. `ldm init` does not create it either. Create it manually if it does not exist.
+
+## SQLite Safety
+
+SQLite files are backed up using `sqlite3 .backup`, not `cp`. This ensures a consistent snapshot even if the database is being written to. The script checks for the `sqlite3` binary and skips database backup with a warning if it is not found.
+
+Files backed up this way:
+- `~/.ldm/memory/crystal.db`
+- `~/.openclaw/memory/main.sqlite`
+- `~/.openclaw/memory/context-embeddings.sqlite`
+
+## Excludes
+
+The workspace tar excludes:
+- `node_modules/` ... reconstructable via npm install
+- `.git/objects/` ... reconstructable via git fetch
+- `backups/` ... avoids recursive backup
+- `_trash/` ... already deleted content
+- `*.tar.gz` ... avoids backing up old backup archives

package/lib/deploy.mjs

@@ -30,10 +30,12 @@ const REGISTRY_PATH = join(LDM_EXTENSIONS, 'registry.json');
 
 let DRY_RUN = false;
 let JSON_OUTPUT = false;
+let INSTALL_ORIGIN = 'manual'; // #262: tracks how an extension was installed
 
 export function setFlags(opts = {}) {
   DRY_RUN = opts.dryRun || false;
   JSON_OUTPUT = opts.jsonOutput || false;
+  if (opts.origin) INSTALL_ORIGIN = opts.origin;
 }
 
 function log(msg) { if (!JSON_OUTPUT) console.log(`  ${msg}`); }
@@ -164,16 +166,104 @@ function getHarnesses() {
 function updateRegistry(name, info) {
   const registry = loadRegistry();
   const existing = registry.extensions[name];
-  const isCore = CORE_EXTENSIONS.has(name);
+  const now = new Date().toISOString();
+
+  // Build the v2 registry entry (#262)
+  // Merge source info: keep existing source unless new info provides it
+  const existingSource = existing?.source;
+  let newSource = info._source || existingSource || null;
+  // Legacy: info.source was a string (path or URL). Convert to object.
+  if (typeof existingSource === 'string' && !newSource) {
+    newSource = null; // Drop legacy string source, migration will fix it
+  }
+  if (typeof info.source === 'string') {
+    // Legacy caller passing a string. Don't overwrite structured source.
+    if (!newSource || typeof newSource === 'string') newSource = null;
+  }
+
+  // Build paths object from ldmPath/ocPath
+  const paths = existing?.paths || {};
+  if (info.ldmPath) paths.ldm = info.ldmPath;
+  if (info.ocPath) paths.openclaw = info.ocPath;
+  // Backwards compat: also keep flat ldmPath/ocPath
+  const ldmPath = info.ldmPath || existing?.ldmPath || paths.ldm;
+  const ocPath = info.ocPath || existing?.ocPath || paths.openclaw;
+
+  // Build installed block
+  const installed = existing?.installed || {};
+  if (typeof installed === 'object' && installed !== null) {
+    installed.version = info.version || installed.version || existing?.version;
+    if (!installed.installedAt) installed.installedAt = now;
+    installed.updatedAt = now;
+  }
+
+  // Origin: keep existing, or use from info, or default to "manual"
+  const origin = info._origin || existing?.origin || 'manual';
+
   registry.extensions[name] = {
-    ...existing,
-    ...info,
-    enabled: existing?.enabled ?? true,  // New installs are enabled by default. User runs ldm disable to turn off.
-    updatedAt: new Date().toISOString(),
+    // v2 structured fields (#262)
+    source: newSource,
+    installed,
+    paths,
+    interfaces: info.interfaces || existing?.interfaces || [],
+    origin,
+    // Backwards-compatible flat fields (read by existing code)
+    name: info.name || existing?.name || name,
+    version: info.version || existing?.version || 'unknown',
+    ldmPath,
+    ocPath,
+    enabled: existing?.enabled ?? true,
+    updatedAt: now,
   };
   saveRegistry(registry);
 }
 
+/**
+ * Build structured source info from a repo path and package.json (#262).
+ * Returns { type, repo, npm } or null if we can't determine the source.
+ */
+function buildSourceInfo(repoPath, pkg) {
+  const source = { type: 'github' };
+  let hasInfo = false;
+
+  // Extract GitHub repo from package.json repository field
+  if (pkg?.repository) {
+    const raw = typeof pkg.repository === 'string'
+      ? pkg.repository
+      : pkg.repository.url || '';
+    const ghMatch = raw.match(/github\.com[:/]([^/]+\/[^/.]+)/);
+    if (ghMatch) {
+      source.repo = ghMatch[1].replace(/\.git$/, '');
+      hasInfo = true;
+    }
+  }
+
+  // Extract npm package name
+  if (pkg?.name) {
+    source.npm = pkg.name;
+    hasInfo = true;
+  }
+
+  // If the repo path is inside ~/.ldm/tmp/, it was cloned from somewhere.
+  // Try to get the remote URL from git.
+  if (!source.repo) {
+    try {
+      const remote = execSync('git remote get-url origin 2>/dev/null', {
+        cwd: repoPath,
+        encoding: 'utf8',
+        timeout: 5000,
+      }).trim();
+      const ghMatch = remote.match(/github\.com[:/]([^/]+\/[^/.]+)/);
+      if (ghMatch) {
+        source.repo = ghMatch[1].replace(/\.git$/, '');
+        hasInfo = true;
+      }
+    } catch {}
+  }
+
+  return hasInfo ? source : null;
+}
+
 // ── Migration detection ──
 
 function findExistingInstalls(toolName, pkg, ocPluginConfig) {
@@ -905,18 +995,15 @@ export function installSingleTool(toolPath) {
   }
 
   let installed = 0;
-  // Don't store /tmp/ clone paths as source (#54). Use the repo URL from package.json if available.
-  let source = toolPath;
-  const isTmpPath = toolPath.startsWith('/tmp/') || toolPath.startsWith('/private/tmp/');
-  if (isTmpPath && pkg?.repository?.url) {
-    source = pkg.repository.url.replace(/^git\+/, '').replace(/\.git$/, '');
-  } else if (isTmpPath) {
-    source = null; // better than a /tmp/ path
-  }
+
+  // Build structured source info for registry (#262)
+  const sourceInfo = buildSourceInfo(toolPath, pkg);
   const registryInfo = {
     name: toolName,
     version: pkg?.version || 'unknown',
-    source,
+    source: null, // legacy field, kept for backwards compat
+    _source: sourceInfo,  // v2 structured source, consumed by updateRegistry
+    _origin: INSTALL_ORIGIN, // #262: "catalog", "manual", or "dependency"
     interfaces: ifaceNames,
   };
 
@@ -1140,4 +1227,4 @@ export function disableExtension(name) {
 
 // ── Exports for ldm CLI ──
 
-export { loadRegistry, saveRegistry, updateRegistry, readJSON, writeJSON, runBuildIfNeeded, resolveLocalDeps, CORE_EXTENSIONS };
+export { loadRegistry, saveRegistry, updateRegistry, readJSON, writeJSON, runBuildIfNeeded, resolveLocalDeps, buildSourceInfo, CORE_EXTENSIONS };

package/lib/state.mjs

@@ -160,7 +160,7 @@ export function reconcileState(systemState) {
       inRegistry: !!reg,
       registryVersion: reg?.version || null,
       registrySource: reg?.source || null,
-      registryHasSource: !!(reg?.source && existsSync(reg.source)),
+      registryHasSource: !!(reg?.source && (typeof reg.source === 'string' ? existsSync(reg.source) : !!reg.source.repo)),
       registryInterfaces: reg?.interfaces || [],
       // Deployed
       deployedLdm: !!ldm,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wipcomputer/wip-ldm-os",
-  "version": "0.4.70",
+  "version": "0.4.72",
   "type": "module",
   "description": "LDM OS: identity, memory, and sovereignty infrastructure for AI agents",
   "engines": {

package/shared/docs/how-backup-works.md.tmpl

@@ -2,7 +2,7 @@
 
 ## One Script, One Place
 
-`~/.ldm/bin/ldm-backup.sh` runs daily at midnight via LDM Dev Tools.app. It backs up everything to `~/.ldm/backups/`, then tars it to iCloud for offsite.
+`~/.ldm/bin/ldm-backup.sh` runs daily at 3:00 AM via LaunchAgent `ai.openclaw.ldm-backup`. It backs up everything to `~/.ldm/backups/`, then tars it to iCloud for offsite.
 
 ## What Gets Backed Up
 
@@ -48,14 +48,14 @@
 
 ## iCloud Offsite
 
-After local backup, the entire dated folder is compressed and copied to iCloud:
+After local backup, the entire dated folder is compressed and copied to iCloud. The iCloud path is read from `~/.ldm/config.json` at `paths.icloudBackup`.
 
 ```
 ~/Library/Mobile Documents/com~apple~CloudDocs/wipcomputerinc-icloud/backups/
   wipcomputerinc-lesa-2026-03-24--09-50-22.tar.gz
 ```
 
-One file per backup. iCloud syncs it across devices. Rotates to 7 days.
+One file per backup. iCloud syncs it across devices. Rotates to {{backup.keep}} days.
 
 ## How to Run
 
@@ -83,19 +83,22 @@ After restore: `openclaw gateway restart` then `crystal status` to verify.
 
 | What | When | How |
 |------|------|-----|
-| Backup | Midnight | cron -> LDM Dev Tools.app -> ~/.ldm/bin/ldm-backup.sh |
+| Backup | 3:00 AM | LaunchAgent `ai.openclaw.ldm-backup` runs `~/.ldm/bin/ldm-backup.sh` |
 
-One cron entry. One script. One app. Verify is built into the script (exit code + log).
+One LaunchAgent. One script. No Full Disk Access currently (target: midnight via LDMDevTools.app once PID error is fixed). Verify is built into the script (exit code + log).
 
 ## Config
 
-Backup reads from two config files:
-- `~/.ldm/config.json` ... workspace path, org name
-- `~/wipcomputerinc/settings/config.json` ... backup.keep (retention days), paths.icloudBackup
+All backup settings live in `~/.ldm/config.json`:
+- `paths.workspace` ... workspace path
+- `paths.icloudBackup` ... iCloud offsite destination
+- `backup.keep` ... retention days (default: 7)
+- `backup.includeSecrets` ... whether to include `~/.ldm/secrets/`
+- `org` ... used for tar filename prefix
 
 ## Logs
 
-`~/.ldm/logs/cron.log` (via LDM Dev Tools.app stdout)
+`~/.ldm/logs/backup.log` (LaunchAgent stdout/stderr)
 
 ---
 
@@ -103,6 +106,6 @@ Backup reads from two config files:
 
 **Local backups:** `~/.ldm/backups/`
 **iCloud offsite:** `~/Library/Mobile Documents/com~apple~CloudDocs/wipcomputerinc-icloud/backups/`
-**Schedule:** Midnight via LDM Dev Tools.app
-**Retention:** 7 days local, 7 days iCloud
+**Schedule:** 3:00 AM via LaunchAgent `ai.openclaw.ldm-backup`
+**Retention:** {{backup.keep}} days local, {{backup.keep}} days iCloud
 **Script:** `~/.ldm/bin/ldm-backup.sh` (deployed by `ldm install`)