total-recall-brain 3.13.0 → 3.13.2

package/src/cli/setup.mjs

@@ -315,14 +315,31 @@ async function remoteSetup(ip, user, opts = {}) {
 
 // ─── GitHub fork ─────────────────────────────────────────────────────────────
 
-const UPSTREAM_OWNER = 'gregiteen';
-const UPSTREAM_REPO  = 'total-recall';
+// Published package upstream for optional fork-during-setup (env only — no third-party product repos)
+function resolveUpstreamGithub() {
+  if (process.env.TR_UPSTREAM_OWNER && process.env.TR_UPSTREAM_REPO) {
+    return { owner: process.env.TR_UPSTREAM_OWNER, repo: process.env.TR_UPSTREAM_REPO };
+  }
+  const repoUrl =
+    process.env.TR_UPSTREAM_REPO_URL ||
+    process.env.npm_package_repository_url ||
+    '';
+  const m = String(repoUrl).match(/github\.com[/:]([^/]+)\/([^/.]+)/i);
+  if (m) return { owner: m[1], repo: m[2].replace(/\.git$/, '') };
+  return null;
+}
 
 async function forkRepo(githubToken) {
-  info('Forking gregiteen/total-recall to your GitHub account...');
+  const upstream = resolveUpstreamGithub();
+  if (!upstream) {
+    throw new Error(
+      'No upstream configured for fork. Set TR_UPSTREAM_OWNER + TR_UPSTREAM_REPO (or package repository.url).',
+    );
+  }
+  info(`Forking ${upstream.owner}/${upstream.repo} to your GitHub account...`);
   const res = await httpRequest(
     'POST',
-    `https://api.github.com/repos/${UPSTREAM_OWNER}/${UPSTREAM_REPO}/forks`,
+    `https://api.github.com/repos/${upstream.owner}/${upstream.repo}/forks`,
     {
       headers: {
         Authorization: `Bearer ${githubToken}`,
@@ -436,10 +453,20 @@ export default async function setup(args) {
             ok('Run `npx total-recall sync --push` anytime to back up your vault to GitHub.');
           } catch (e) {
             warn(`Could not fork: ${e.message}`);
-            warn('You can fork manually at https://github.com/gregiteen/total-recall');
+            const u = resolveUpstreamGithub();
+            warn(
+              u
+                ? `You can fork manually at https://github.com/${u.owner}/${u.repo}`
+                : 'Set TR_UPSTREAM_OWNER/TR_UPSTREAM_REPO to enable auto-fork, or fork your package upstream manually.',
+            );
           }
         } else {
-          info('[dry-run] would fork gregiteen/total-recall to your account');
+          const u = resolveUpstreamGithub();
+          info(
+            u
+              ? `[dry-run] would fork ${u.owner}/${u.repo} to your account`
+              : '[dry-run] would fork package upstream (set TR_UPSTREAM_* if needed)',
+          );
         }
         // Store GitHub token for sync --push
         const secretsPath = path.join(resolveBrainDir(), 'config', 'secrets.enc');
@@ -595,7 +622,7 @@ export default async function setup(args) {
     { label: 'Cursor',        value: 'cursor' },
     { label: 'Aider',         value: 'aider' },
     { label: 'Obsidian',      value: 'obsidian' },
-    { label: 'UltraChat',     value: 'ultrachat' },
+    { label: 'HTTP host app', value: 'http-api' },
   ];
 
   const selectedIDEs = await chooseMultiple(

package/src/cli/share.mjs

@@ -1,7 +1,7 @@
 import crypto from 'node:crypto';
 import { parseLayerFlag, resolveBrainDir, getBothBrains, defaultLayerForCategory } from './agent-dir.mjs';
 import { createMemoryNode } from '../core/vault.mjs';
-import { writeNodeValidated } from '../core/validated-write.mjs';
+import { writeNodeValidatedAsync } from '../core/validated-write.mjs';
 import { addToQueue } from '../core/research-queue.mjs';
 import { compileSurface } from '../core/surface.mjs';
 import path from 'node:path';
@@ -161,7 +161,7 @@ export default async function share(args) {
     }];
   }
 
-  const vaultResult = writeNodeValidated(node, vaultDir);
+  const vaultResult = await writeNodeValidatedAsync(node, vaultDir);
   if (!vaultResult.success) {
     console.error(`  ❌ Validation failed: ${vaultResult.validation.errors.join('; ')}`);
     process.exit(1);

package/src/cli/skill.mjs

@@ -2,14 +2,36 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { spawnSync } from 'node:child_process';
-import { resolveAgentDir, parseLayerFlag } from './agent-dir.mjs';
+import { resolveAgentDir, resolveBrainDir, parseLayerFlag } from './agent-dir.mjs';
+import {
+  registerSkill,
+  listRegistered,
+  listInstalls,
+  deploySkill,
+  skillStatus,
+  syncLocalSkillsToRegistry,
+  unregisterSkill,
+  resolveRegistryPath,
+  syncAllSkillsTwoWay,
+  syncSkillTwoWay,
+  discoverAllSkills,
+  pushAllSkills,
+  pullAllSkills,
+  loadKnownRepoRoots,
+  parseSyncReposEnv,
+  trackRepo,
+  normalizeRepoPaths,
+} from '../core/skills-registry.mjs';
 
 // Helper to resolve agent directories dynamically
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const ROOT = path.resolve(__dirname, '../../');
 
 export function resolveSkillScriptPath(scriptName, { agentDir = resolveAgentDir(), root = ROOT } = {}) {
+  // skill-deploy module (TR_CORE_FOCUS); keep legacy nested-skill paths for old brains.
   const candidates = [
+    path.join(agentDir, 'skills', 'total-recall', 'modules', 'skill-deploy', 'scripts', scriptName),
+    path.join(root, 'scaffold', '.agent', 'skills', 'total-recall', 'modules', 'skill-deploy', 'scripts', scriptName),
     path.join(agentDir, 'skills', 'total-recall', 'skills', 'tr-skill', 'scripts', scriptName),
     path.join(agentDir, 'skills', 'total-recall', 'skills', 'skill', 'scripts', scriptName),
     path.join(root, 'scaffold', '.agent', 'skills', 'total-recall', 'skills', 'tr-skill', 'scripts', scriptName),
@@ -28,33 +50,85 @@ async function importSkillScript(scriptName, options) {
 
 function printHelp() {
   console.log(`
-  total-recall skill — Sovereign AI Capability Registry & Manager
+  total-recall skill — Skills registry, install, and cross-repo deploy
 
   Usage: total-recall skill <command> [options]
 
-  Commands:
-    find <query>          Search skills.sh registry sorted by absolute installs rating
-    install <package>     Download/load a skill, run static security audit, and compile shims (alias: load, add)
-    create <name>         Scaffold a new SSSS-compliant skill folder structure (alias: new)
-    edit <name>           Open the local skill's SKILL.md file in your preferred editor
-    scan <name>           Run security audit scan on an installed local skill directory
-    list                  List all locally active parent skills and nested sub-skills (alias: ls)
-    remove <name>         Safely delete a skill package and hot-recompile shims (alias: rm)
+  Install / local:
+    find <query>          Search skills.sh registry (sorted by installs)
+    install <package>     Download skill, security scan, compile, auto-register (alias: load, add)
+    create <name>         Scaffold a new skill folder (alias: new)
+    edit <name>           Open local SKILL.md in $EDITOR
+    scan <name>           Security audit on installed skill dir
+    list                  List local brain skills with SKILL.md (alias: ls)
+    remove <name>         Delete skill from brain skills dir (alias: rm)
+
+  Registry / deploy / multi-repo sync (TR_CORE_FOCUS):
+    register <path|name>  Add skill to global skills-registry (from path or local name)
+    registry              List catalog entries in skills-registry/index.yaml
+    deploy <id>           Copy skill into a repo (.agent/skills/<id>/) and record install map
+    status [id]           Registry + install map + drift (omit id = summary)
+    sync-registry         Register all local brain skills into the catalog
+    unregister <id>       Remove catalog entry (does not delete repo copies)
+    track <path>          Track any repo (full project brain + registry) for skill sync
+    discover              Scan tracked / --repo / cwd repos for skills
+    sync [id]             Two-way sync skill(s) across those repos
+    push                  One-way: catalog/source → all installs
+    pull                  One-way: prefer installs → source → fan-out
+
+  deploy options:
+    --repo <path>         Target repository root (default: cwd)
+    --adapt               Rewrite description with openwiki + package.json stack signals
+    --force               Replace existing destination
+
+  discover / sync options (any user repos — no hardcoded paths):
+    --repo <path>         Include this repo (repeatable). Works with absolute or relative paths
+    --register            Permanently track --repo paths (project registry + full brain)
+    --ensure-brains       Ensure full TR brain layout on all known roots
+    --prefer newest|registry|install   Sync winner policy (default: newest)
+    --dry-run             Show actions without writing
+    --include-core        Also sync total-recall core skill (off by default)
+    --skip-discover       Do not re-scan repos before sync
+
+  How any repo is included:
+    1. npx total-recall skill track /path/to/any-repo
+       (or: brain register /path && brain ensure /path)
+    2. One-shot: skill discover --repo /path --register
+    3. Env: TR_SYNC_REPOS="/path/a:/path/b"
+    4. cwd is auto-included when it looks like a project
 
   Options:
     --global              Target the global brain (~/.agent)
     --project             Target the current repo's project brain
     --help, -h            Show this help menu
-  
+
   Examples:
-    npx total-recall skill find git
-    npx total-recall skill load github/awesome-copilot@prd
-    npx total-recall skill create my-awesome-skill
-    npx total-recall skill edit my-awesome-skill
-    npx total-recall skill scan total-recall
+    npx total-recall skill track .
+    npx total-recall skill track /path/to/my-app
+    npx total-recall skill discover --repo /path/to/app1 --repo /path/to/app2 --register
+    npx total-recall skill sync --repo /path/to/app1 --repo /path/to/app2
+    npx total-recall skill deploy my-skill --repo /path/to/my-app --adapt
+    npx total-recall skill sync --prefer newest
 `);
 }
 
+/** Collect all --repo <path> values from argv */
+function parseRepoFlags(args) {
+  const repos = [];
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--repo' && args[i + 1]) {
+      repos.push(args[++i]);
+    }
+  }
+  return repos;
+}
+
+function parseFlagValue(args, flag) {
+  const i = args.indexOf(flag);
+  if (i === -1) return null;
+  return args[i + 1] || null;
+}
+
 export default async function skillCli(args) {
   const { layer, remainingArgs } = parseLayerFlag(args);
   if (remainingArgs.length === 0 || remainingArgs.includes('--help') || remainingArgs.includes('-h')) {
@@ -63,8 +137,10 @@ export default async function skillCli(args) {
   }
 
   let agentDir;
+  let brainDir;
   try {
     agentDir = resolveAgentDir(layer);
+    brainDir = resolveBrainDir(layer);
   } catch (err) {
     console.error(`❌ ${err.message}`);
     process.exit(1);
@@ -133,11 +209,30 @@ export default async function skillCli(args) {
     }
 
     try {
-      const { installSkill } = await importSkillScript('install-skill.mjs', { agentDir });
+      const { installSkill, inferSkillName, installedSkillCandidates } = await importSkillScript('install-skill.mjs', { agentDir });
       const res = installSkill(pkg, { cwd: process.cwd(), agentDir });
       if (!res.success) {
         process.exit(1);
       }
+      // Auto-register installed skill into global catalog when discoverable
+      try {
+        const candidates = installedSkillCandidates(pkg, { cwd: process.cwd(), agentDir }).filter((p) =>
+          fs.existsSync(path.join(p, 'SKILL.md')),
+        );
+        const name = inferSkillName(pkg);
+        const hit = candidates[0] || (name && fs.existsSync(path.join(skillsDir, name, 'SKILL.md'))
+          ? path.join(skillsDir, name)
+          : null);
+        if (hit) {
+          const entry = registerSkill(brainDir, hit, {
+            source: pkg,
+            source_type: 'registry',
+          });
+          console.log(`📇 Registered in catalog: ${entry.id} → ${resolveRegistryPath(brainDir)}`);
+        }
+      } catch (regErr) {
+        console.warn(`⚠️  Installed but registry update skipped: ${regErr.message}`);
+      }
     } catch (err) {
       console.error('❌ Loading skill failed:', err.message);
       process.exit(1);
@@ -170,32 +265,23 @@ export default async function skillCli(args) {
       return;
     }
 
-    const dirs = fs.readdirSync(skillsDir).filter(d => 
-      fs.statSync(path.join(skillsDir, d)).isDirectory()
-    );
+    // Only list packages with SKILL.md (real agent skills). Skip modules/, etc.
+    const dirs = fs.readdirSync(skillsDir).filter((d) => {
+      const skillPath = path.join(skillsDir, d);
+      if (!fs.statSync(skillPath).isDirectory()) return false;
+      return fs.existsSync(path.join(skillPath, 'SKILL.md'));
+    });
 
     if (dirs.length === 0) {
       console.log('No installed skills found in the active brain.');
       return;
     }
 
-    console.log('\n📦 Installed Sovereign Skills:');
+    console.log('\n📦 Installed Skills (SKILL.md present):');
     console.log('------------------------------------------------------------');
     for (const d of dirs) {
-      const skillPath = path.join(skillsDir, d);
-      const subSkillsPath = path.join(skillPath, 'skills');
-      let subSkills = [];
-
-      if (fs.existsSync(subSkillsPath) && fs.statSync(subSkillsPath).isDirectory()) {
-        subSkills = fs.readdirSync(subSkillsPath).filter(sd => 
-          fs.statSync(path.join(subSkillsPath, sd)).isDirectory()
-        );
-      }
-
-      console.log(` • ${d.padEnd(20)} [Universal Skill Package]`);
-      if (subSkills.length > 0) {
-        console.log(`   └ Sub-skills: ${subSkills.map(s => `🧩 ${s}`).join(', ')}`);
-      }
+      const note = d === 'total-recall' ? ' [TR core skill]' : '';
+      console.log(` • ${d.padEnd(20)}${note}`);
     }
     console.log('------------------------------------------------------------\n');
   } 
@@ -331,6 +417,281 @@ Provide a high-level explanation of the skill's capabilities and context.
     process.exit(child.status || 0);
   }
 
+  // ─── Registry / deploy ──────────────────────────────────────────────────────
+
+  else if (command === 'register') {
+    const target = remainingArgs[1];
+    if (!target) {
+      console.error('❌ Usage: total-recall skill register <path-or-local-name>');
+      process.exit(1);
+    }
+    try {
+      let skillPath = path.resolve(target);
+      if (!fs.existsSync(path.join(skillPath, 'SKILL.md'))) {
+        skillPath = path.join(skillsDir, target);
+      }
+      const entry = registerSkill(brainDir, skillPath, {
+        source: target,
+        source_type: fs.existsSync(path.resolve(target)) ? 'path' : 'local',
+      });
+      console.log(`\n  ✅ Registered: ${entry.id}`);
+      console.log(`     version=${entry.version} hash=${entry.content_hash}`);
+      console.log(`     catalog: ${resolveRegistryPath(brainDir)}\n`);
+    } catch (err) {
+      console.error(`❌ ${err.message}`);
+      process.exit(1);
+    }
+  }
+
+  else if (command === 'registry') {
+    const entries = listRegistered(brainDir);
+    if (!entries.length) {
+      console.log(`\n  Catalog empty. Register with: total-recall skill register <path>`);
+      console.log(`  Path: ${resolveRegistryPath(brainDir)}\n`);
+      return;
+    }
+    console.log(`\n  📇 Skills catalog (${entries.length}) — ${resolveRegistryPath(brainDir)}\n`);
+    for (const e of entries) {
+      console.log(`  • ${e.id.padEnd(24)} v${e.version}  hash=${e.content_hash || '-'}`);
+      if (e.description) console.log(`      ${String(e.description).slice(0, 90)}`);
+    }
+    console.log('');
+  }
+
+  else if (command === 'deploy') {
+    const skillId = remainingArgs[1];
+    if (!skillId) {
+      console.error('❌ Usage: total-recall skill deploy <id-or-path> [--repo <path>] [--adapt] [--force]');
+      process.exit(1);
+    }
+    const repo = parseFlagValue(remainingArgs, '--repo') || process.cwd();
+    const adapt = remainingArgs.includes('--adapt');
+    const force = remainingArgs.includes('--force');
+    try {
+      const result = deploySkill(brainDir, skillId, {
+        repo,
+        agentSkillsDir: skillsDir,
+        adapt,
+        force,
+      });
+      console.log(`\n  ✅ Deployed: ${result.skillId}`);
+      console.log(`     → ${result.destDir}`);
+      console.log(`     hash=${result.install.content_hash} adapted=${result.adapt.adapted}`);
+      console.log(`     Install map updated in ${resolveRegistryPath(brainDir)}\n`);
+    } catch (err) {
+      console.error(`❌ Deploy failed: ${err.message}`);
+      process.exit(1);
+    }
+  }
+
+  else if (command === 'status') {
+    const skillId = remainingArgs[1];
+    if (!skillId) {
+      const catalog = listRegistered(brainDir);
+      const installs = listInstalls(brainDir);
+      console.log(`\n  Registry: ${resolveRegistryPath(brainDir)}`);
+      console.log(`  Catalog skills: ${catalog.length}`);
+      console.log(`  Install map entries: ${installs.length}`);
+      if (installs.length) {
+        console.log('\n  Installs:');
+        for (const i of installs) {
+          console.log(`    • ${i.skill_id} → ${i.path}`);
+        }
+      }
+      console.log('');
+      return;
+    }
+    try {
+      const st = skillStatus(brainDir, skillId);
+      console.log(`\n  Skill: ${skillId}`);
+      console.log(`  Registered: ${st.registered}`);
+      if (st.entry) {
+        console.log(`  Version: ${st.entry.version}  hash=${st.entry.content_hash}`);
+        console.log(`  Source: ${st.entry.source_path || st.entry.source}`);
+      }
+      console.log(`  Installs: ${st.install_count}  drift=${st.any_drift ? 'YES' : 'no'}`);
+      for (const inst of st.installs) {
+        console.log(
+          `    • ${inst.path}\n      exists=${inst.exists} live=${inst.live_hash || '-'} drift=${inst.drift}`,
+        );
+      }
+      console.log('');
+    } catch (err) {
+      console.error(`❌ ${err.message}`);
+      process.exit(1);
+    }
+  }
+
+  else if (command === 'sync-registry') {
+    const result = syncLocalSkillsToRegistry(brainDir, skillsDir);
+    console.log(`\n  ✅ Synced ${result.registered.length} skill(s) into catalog`);
+    if (result.registered.length) {
+      console.log(`     ${result.registered.join(', ')}`);
+    }
+    console.log(`     ${resolveRegistryPath(brainDir)}\n`);
+  }
+
+  else if (command === 'unregister') {
+    const skillId = remainingArgs[1];
+    if (!skillId) {
+      console.error('❌ Usage: total-recall skill unregister <id>');
+      process.exit(1);
+    }
+    const result = unregisterSkill(brainDir, skillId);
+    if (!result.success) {
+      console.error(`❌ ${result.error}`);
+      process.exit(1);
+    }
+    console.log(`  ✅ Unregistered catalog entry: ${skillId}`);
+  }
+
+  else if (command === 'track') {
+    const target = remainingArgs[1];
+    if (!target || target.startsWith('--')) {
+      console.error('❌ Usage: total-recall skill track <any-repo-path>');
+      console.error('   Example: total-recall skill track .');
+      console.error('            total-recall skill track /path/to/my-app');
+      process.exit(1);
+    }
+    try {
+      const result = trackRepo(brainDir, target);
+      console.log(`\n  ✅ Tracking repo as full Total Recall project brain`);
+      console.log(`     Repo:  ${result.repoRoot}`);
+      console.log(`     Brain: ${result.brainDir}`);
+      console.log(`     Skills sync will include this path on discover/sync.\n`);
+    } catch (err) {
+      console.error(`❌ ${err.message}`);
+      process.exit(1);
+    }
+  }
+
+  else if (command === 'discover') {
+    const includeCore = remainingArgs.includes('--include-core');
+    const ensureBrains = remainingArgs.includes('--ensure-brains');
+    const registerExtra = remainingArgs.includes('--register');
+    const extraRepos = parseRepoFlags(remainingArgs);
+    const result = discoverAllSkills(brainDir, {
+      includeCore,
+      ensureBrains,
+      extraRepos,
+      registerExtra,
+    });
+    const roots = loadKnownRepoRoots(brainDir, { extraRepos });
+    const envRoots = parseSyncReposEnv();
+    console.log(`\n  🔍 Discover complete`);
+    console.log(`     Repos scanned: ${result.repos}`);
+    if (roots.length) {
+      for (const r of roots) console.log(`       • ${r}`);
+    }
+    console.log(`     Skills found:  ${result.discovered}`);
+    console.log(`     Registered:    ${result.registered.length}`);
+    console.log(`     Install rows:  +${result.installs_added}`);
+    if (result.registered.length) {
+      console.log(`     IDs: ${result.registered.slice(0, 20).join(', ')}${result.registered.length > 20 ? '…' : ''}`);
+    }
+    if (envRoots.length) console.log(`     TR_SYNC_REPOS: ${envRoots.join(', ')}`);
+    if (extraRepos.length) {
+      console.log(
+        `     --repo: ${normalizeRepoPaths(extraRepos).join(', ')}${registerExtra ? ' [tracked permanently]' : ' [one-shot]'}`,
+      );
+    }
+    if (!roots.length) {
+      console.log(`     Tip: total-recall skill track .   # any repo you want`);
+    }
+    console.log('');
+  }
+
+  else if (command === 'sync' || command === 'push' || command === 'pull') {
+    const skillId = remainingArgs[1] && !remainingArgs[1].startsWith('--') ? remainingArgs[1] : null;
+    const dryRun = remainingArgs.includes('--dry-run');
+    const includeCore = remainingArgs.includes('--include-core');
+    const skipDiscover = remainingArgs.includes('--skip-discover');
+    const ensureBrains = remainingArgs.includes('--ensure-brains');
+    const registerExtra = remainingArgs.includes('--register');
+    const extraRepos = parseRepoFlags(remainingArgs);
+    let prefer = parseFlagValue(remainingArgs, '--prefer') || 'newest';
+    if (command === 'push') prefer = 'registry';
+    if (command === 'pull') prefer = 'install';
+
+    const syncOpts = {
+      prefer,
+      dryRun,
+      includeCore,
+      skipDiscover,
+      ensureBrains,
+      extraRepos,
+      registerExtra,
+    };
+
+    console.log(`\n  🔄 Skill ${command} (prefer=${prefer}${dryRun ? ', dry-run' : ''})…\n`);
+
+    if (skillId) {
+      if (!skipDiscover) {
+        discoverAllSkills(brainDir, {
+          includeCore,
+          extraRepos,
+          registerExtra,
+          ensureBrains,
+        });
+      }
+      const r = syncSkillTwoWay(brainDir, skillId, {
+        prefer,
+        dryRun,
+        includeCore,
+      });
+      if (r.skipped) {
+        console.log(`  ⏭  ${skillId}: ${r.reason}`);
+      } else if (r.in_sync) {
+        console.log(`  ✅ ${skillId}: already in sync (${r.locations} copies, hash=${r.hash})`);
+      } else {
+        console.log(`  🏆 Winner: ${r.winner?.path} (${r.winner?.role})`);
+        for (const a of r.actions || []) {
+          console.log(`     ${dryRun ? 'would copy' : 'copied'} → ${a.to}`);
+        }
+        if (!(r.actions || []).length) console.log(`  ✅ ${skillId}: no copies needed`);
+      }
+      console.log('');
+      return;
+    }
+
+    const report =
+      command === 'push'
+        ? pushAllSkills(brainDir, syncOpts)
+        : command === 'pull'
+          ? pullAllSkills(brainDir, syncOpts)
+          : syncAllSkillsTwoWay(brainDir, syncOpts);
+
+    if (report.roots?.length) {
+      console.log(`  Roots (${report.roots.length}):`);
+      for (const r of report.roots) console.log(`    • ${r}`);
+    }
+    console.log(`  Repos scanned:   ${report.discovery?.repos ?? '?'}`);
+    console.log(`  Discovered:      ${report.discovery?.discovered ?? 0}`);
+    console.log(`  Skills checked:  ${report.skills}`);
+    console.log(`  Already synced:  ${report.already_in_sync}`);
+    console.log(`  Updated:         ${report.updated}`);
+    console.log(`  File copies:     ${report.copies}`);
+    if (report.results) {
+      for (const r of report.results) {
+        if (r.skipped && r.reason === 'core') continue;
+        if (r.in_sync) continue;
+        if (r.actions?.length) {
+          console.log(`\n  • ${r.skillId} ← ${r.winner?.role || '?'} ${r.winner?.path || ''}`);
+          for (const a of r.actions) {
+            console.log(`      ${dryRun ? 'would →' : '→'} ${a.to}`);
+          }
+        } else if (r.skipped) {
+          console.log(`  ⏭  ${r.skillId}: ${r.reason}`);
+        }
+      }
+    }
+    console.log(
+      dryRun
+        ? '\n  Dry-run only. Re-run without --dry-run to apply.\n'
+        : '\n  ✅ Sync finished. Check: npx total-recall skill status\n',
+    );
+  }
+
   else {
     console.error(`❌ Unknown skill command: ${command}`);
     printHelp();

package/src/cli/sync.mjs

@@ -312,13 +312,13 @@ function pushToFork() {
   const root = gitRun(['rev-parse', '--show-toplevel'], { silent: true, ignoreErrors: true });
   if (!root) throw new Error('Not inside a git repository.');
 
-  // Warn if origin appears to be the upstream (not a personal fork)
+  // Optional: refuse push when origin is the published upstream (set TR_UPSTREAM_REPO yourself)
   const originUrl = gitRun(['remote', 'get-url', 'origin'], { silent: true, ignoreErrors: true });
-  if (originUrl.includes('gregiteen/total-recall')) {
-    console.error('  ⚠️  origin is the upstream repo, not your personal fork.');
+  if (process.env.TR_UPSTREAM_REPO && originUrl && originUrl.includes(process.env.TR_UPSTREAM_REPO)) {
+    console.error('  ⚠️  origin matches TR_UPSTREAM_REPO (upstream), not your personal fork.');
     console.error('  Set up your fork first:');
     console.error('    git remote rename origin upstream');
-    console.error('    git remote add origin https://github.com/YOUR_USERNAME/total-recall.git');
+    console.error('    git remote add origin https://github.com/YOUR_USERNAME/<your-fork>.git');
     throw new Error('Configure your fork as origin before using sync --push.');
   }