total-recall-brain 3.9.0 → 3.11.0

package/src/cli/connect.mjs

@@ -4,6 +4,7 @@ import path from 'node:path';
 import { agentDir as configAgentDir, brainDir as configBrainDir, xdgConfigHome, trBrain, trPat } from '../core/config.mjs';
 import { fileURLToPath } from 'node:url';
 import { resolveAgentDir, getBothBrains, detectProjectBrain } from './agent-dir.mjs';
+import { discoverRepoSkills, projectSkillsAsCommands } from './skill-projection.mjs';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 // Resolve templates dir relative to this file (src/cli/ → ../../templates/)
@@ -78,7 +79,11 @@ const CLIENTS = {
     label: 'Gemini',
     mode: 'symlink',
     target: '.agents/rules/GEMINI.md',
-    writeSlashCommands: true
+    writeSlashCommands: true,
+    // Gemini CLI reads project workspace skills from <project>/.agents/skills/
+    // (the same Agent Skills location Antigravity uses) and turns each into a
+    // /name slash command.
+    skillsProjection: { scope: 'project', dir: path.join('.agents', 'skills') }
   },
   aider: {
     label: 'Aider',
@@ -628,64 +633,6 @@ Instructions:
 }
 
 
-/**
- * Discover repo skills to expose as slash commands.
- * Every <agentDir>/skills/<name>/ directory containing a SKILL.md is a skill.
- * The SKILL.md (Agent Skills standard) is what each IDE turns into /<name>.
- */
-function discoverRepoSkills(agentDir) {
-  const skillsRoot = path.join(agentDir, 'skills');
-  if (!fs.existsSync(skillsRoot)) return [];
-  let entries;
-  try {
-    entries = fs.readdirSync(skillsRoot, { withFileTypes: true });
-  } catch {
-    return [];
-  }
-  const skills = [];
-  for (const entry of entries) {
-    if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
-    const skillDir = path.join(skillsRoot, entry.name);
-    if (!fs.existsSync(path.join(skillDir, 'SKILL.md'))) continue;
-    skills.push({ name: entry.name, skillDir });
-  }
-  return skills;
-}
-
-/**
- * Symlink each discovered skill dir into an IDE's Agent-Skills directory.
- * Idempotent and self-healing: a symlink that is broken or points at a stale
- * location (e.g. after the repo moved) is refreshed even without --force; a
- * real (non-symlink) entry is only replaced with --force.
- */
-function projectSkillsAsCommands(destDir, skills, opts) {
-  fs.mkdirSync(destDir, { recursive: true });
-  const written = [];
-  for (const skill of skills) {
-    const linkPath = path.join(destDir, skill.name);
-    const wantTarget = path.resolve(skill.skillDir);
-    if (pathExists(linkPath)) {
-      const stat = fs.lstatSync(linkPath);
-      if (stat.isSymbolicLink()) {
-        const current = path.resolve(path.dirname(linkPath), fs.readlinkSync(linkPath));
-        if (current === wantTarget && fs.existsSync(linkPath) && !opts.force) {
-          written.push({ name: skill.name, action: 'exists' });
-          continue;
-        }
-        fs.unlinkSync(linkPath); // stale, broken, or --force → refresh
-      } else if (!opts.force) {
-        written.push({ name: skill.name, action: 'skipped' }); // real file/dir in the way
-        continue;
-      } else {
-        fs.rmSync(linkPath, { recursive: true, force: true });
-      }
-    }
-    fs.symlinkSync(skill.skillDir, linkPath);
-    written.push({ name: skill.name, action: 'linked' });
-  }
-  return written;
-}
-
 export default async function connect(args) {
   const opts = parseArgs(args);
   if (opts.help || !opts.client) {

package/src/cli/ingest-openwiki.mjs

@@ -0,0 +1,122 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+
+function printHelp() {
+  console.log(`
+  Usage:
+    total-recall ingest openwiki <openwiki-path> [options]
+
+  Options:
+    --dry-run                 Preview import without writing
+    --global                  Target the global brain
+    --project                 Target the project brain (default)
+    --help, -h                Show this help
+  `);
+}
+
+export async function runOpenWikiIngest(args) {
+  let openwikiPath = null;
+  let dryRun = false;
+  let layerFlag = '--project';
+  let help = false;
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    switch (arg) {
+      case '--dry-run': dryRun = true; break;
+      case '--global': layerFlag = '--global'; break;
+      case '--project': layerFlag = '--project'; break;
+      case '--help': case '-h': help = true; break;
+      default:
+        if (!arg.startsWith('-') && !openwikiPath) {
+          openwikiPath = arg;
+        }
+    }
+  }
+
+  if (help || !openwikiPath) {
+    printHelp();
+    return;
+  }
+
+  if (!fs.existsSync(openwikiPath)) {
+    console.error(`❌ Error: OpenWiki directory not found at ${openwikiPath}`);
+    process.exit(1);
+  }
+
+  console.log(`\n  📥 Importing LangChain OpenWiki from: ${openwikiPath}`);
+  console.log(`  🧠 Target Brain: ${layerFlag.replace('--', '')}`);
+  if (dryRun) console.log('  ⚠️  DRY RUN: No actual writes will be committed.\n');
+
+  // Find all markdown files recursively
+  const mdFiles = [];
+  function scanDir(dir) {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        scanDir(fullPath);
+      } else if (entry.isFile() && entry.name.endsWith('.md')) {
+        mdFiles.push(fullPath);
+      }
+    }
+  }
+  
+  scanDir(openwikiPath);
+
+  let imported = 0;
+  let errors = 0;
+
+  for (const file of mdFiles) {
+    try {
+      const content = fs.readFileSync(file, 'utf8');
+      
+      // Try to extract title from the first heading, else use filename
+      let title = path.basename(file, '.md').replace(/[-_]/g, ' ');
+      const titleMatch = content.match(/^#\\s+(.+)$/m);
+      if (titleMatch) {
+        title = titleMatch[1].trim();
+      }
+
+      const slug = 'openwiki-' + path.basename(file, '.md').toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/(^-|-$)/g, '');
+
+      if (dryRun) {
+        console.log(`  🟢 [DRY RUN] Would import: ${slug} ("${title}")`);
+        imported++;
+        continue;
+      }
+
+      const cliArgs = [
+        process.argv[1],
+        'remember', 'fact',
+        content,
+        '--title', title,
+        '--slug', slug,
+        '--tags', 'openwiki,architecture,auto-generated',
+        layerFlag
+      ];
+
+      const result = spawnSync(process.argv[0], cliArgs, { encoding: 'utf8' });
+      
+      if (result.status === 0) {
+        console.log(`  🟢 Imported: ${slug}`);
+        imported++;
+      } else {
+        console.error(`  🔴 Error importing ${slug}:\\n${result.stderr}`);
+        errors++;
+      }
+    } catch (err) {
+      console.error(`  🔴 Exception on ${file}: ${err.message}`);
+      errors++;
+    }
+  }
+
+  console.log(`\n  Import Summary:`);
+  console.log(`  🟢 Imported: ${imported} files`);
+  console.log(`  🔴 Errors:   ${errors} files`);
+  
+  if (!dryRun && imported > 0) {
+     console.log(`\n  ✅ OpenWiki successfully integrated into Total Recall.`);
+  }
+}

package/src/cli/ingest.mjs

@@ -40,6 +40,8 @@ function printHelp() {
                            Use 'total-recall ingest google-takeout --help' for details
     okf <path>             Ingest an Open Knowledge Format (OKF) bundle directory
                            Use 'total-recall ingest okf --help' for details
+    openwiki <path>        Ingest a LangChain OpenWiki directory
+                           Use 'total-recall ingest openwiki --help' for details
 
   IDE Session Ingest:
     Scans known local directories for conversation history from:
@@ -55,6 +57,7 @@ function printHelp() {
     total-recall ingest [options]
     total-recall ingest google-takeout <path> [options]
     total-recall ingest okf <path> [options]
+    total-recall ingest openwiki <path> [options]
 
   Options:
     --sources <list>   Comma-separated source filter (e.g. claude-code,codex)
@@ -77,6 +80,12 @@ export default async function ingest(args) {
     return;
   }
 
+  if (args[0] === 'openwiki') {
+    const { runOpenWikiIngest } = await import('./ingest-openwiki.mjs');
+    await runOpenWikiIngest(args.slice(1));
+    return;
+  }
+
   const opts = parseArgs(args);
   if (opts.help) { printHelp(); return; }
 

package/src/cli/init.mjs

@@ -30,6 +30,7 @@ import path from 'node:path';
 import os from 'node:os';
 import { fileURLToPath } from 'node:url';
 import { exec, spawn, spawnSync } from 'node:child_process';
+import { projectSkillsForScope, detectActiveSkillTargets } from './skill-projection.mjs';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const ROOT = path.join(__dirname, '..', '..');
@@ -83,7 +84,8 @@ function parseArgs(args) {
     domain: null,
     tunnelName: null,
     tunnelCredentials: null,
-    yes: false
+    yes: false,
+    force: false
   };
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
@@ -97,6 +99,7 @@ function parseArgs(args) {
     else if (arg === '--tunnel-name') opts.tunnelName = args[++i];
     else if (arg === '--tunnel-credentials') opts.tunnelCredentials = args[++i];
     else if (arg === '--yes' || arg === '-y') opts.yes = true;
+    else if (arg === '--force') opts.force = true;
   }
   return opts;
 }
@@ -474,7 +477,7 @@ export default async function init(args) {
   }
 
   // ── Symlink nested brain skills to top-level .agent/skills/ ──
-  // Skills inside the brain (e.g. .agent/skills/total-recall/skills/ssss/) are
+  // Skills inside the brain (e.g. .agent/skills/total-recall/skills/tr-ssss/) are
   // invisible to IDEs because they only scan .agent/skills/<name>/ one level
   // deep. Create symlinks so they appear as slash commands.
   const nestedSkillsDir = path.join(brainDir, 'skills');
@@ -498,6 +501,43 @@ export default async function init(args) {
     }
   }
 
+  // ── Step 3.7: Project skills as slash commands into the IDEs in use ──
+  // Scope matches the brain: `init --project` projects PROJECT skills into the
+  // repo's IDE skill dirs for IDEs actually used here (.claude/, .agents/, or
+  // the current process); `init` projects GLOBAL skills into installed IDEs'
+  // global skill dirs. Codex (global-only) is opt-in for project skills.
+  const skillScope = isProject ? 'project' : 'global';
+  logStep('3.7/4', `Projecting ${skillScope} skills as slash commands (IDEs in use)`);
+  if (opts.dryRun) {
+    const targets = detectActiveSkillTargets({ scope: skillScope, cwd });
+    for (const t of targets.filter(t => t.supported)) {
+      const destLabel = t.destDir ? path.relative(cwd, t.destDir) || t.destDir : '(n/a)';
+      log(`  ${t.active ? 'would wire' : 'available (opt-in)'}: ${t.label} → ${destLabel}/`);
+    }
+  } else {
+    try {
+      const { skills, wired, available } = projectSkillsForScope({
+        scope: skillScope, cwd, agentDir, opts: { force: opts.force }
+      });
+      if (skills.length === 0) {
+        log('  No skills found yet — author one under .agent/skills/<name>/SKILL.md');
+      } else if (wired.length === 0) {
+        log(`  No in-use IDE detected for ${skillScope} skills — run \`npx total-recall connect <ide>\` to wire them.`);
+      } else {
+        for (const t of wired) {
+          const n = t.results.filter(r => ['linked', 'exists', 'source'].includes(r.action)).length;
+          logOk(`${t.label}: ${n} skill(s) → ${path.relative(cwd, t.destDir) || t.destDir}/`);
+        }
+        log(`  Slash commands: ${skills.map(s => '/' + s.name).join(', ')}`);
+        if (available.length > 0) {
+          log(`  Also available (opt-in): ${available.map(t => t.clients.join('/')).join(', ')} — \`npx total-recall connect <ide>\``);
+        }
+      }
+    } catch (err) {
+      logWarn(`Could not project skills into IDEs: ${err.message}`);
+    }
+  }
+
   // ── Step 4: Run compile to inject memory block into existing IDE files ──
   logStep('4/4', 'Compiling vault and injecting into IDE instruction files');
 

package/src/cli/skill-projection.mjs

@@ -0,0 +1,214 @@
+/**
+ * Scope-aware skill → slash-command projection.
+ *
+ * A "repo skill" is any <skills-root>/<name>/SKILL.md directory (the Agent
+ * Skills standard). Each IDE turns such a directory into a /<name> slash
+ * command, but every IDE looks in a *different* place, and the right place
+ * depends on the *scope* of the skill:
+ *
+ *   PROJECT skills (authored in <repo>/.agent/skills or <repo>/.agents/skills)
+ *     → project into the *repo's* IDE skill dirs, and only for IDEs actually
+ *       in use in this repo (project marker dir present, or current process is
+ *       that IDE). They belong to this repo, not the whole machine.
+ *
+ *   GLOBAL skills (authored in ~/.agent/skills)
+ *     → project into each IDE's *global* skill dir, for IDEs installed on this
+ *       machine. They are available in every repo.
+ *
+ * This mirrors the brain model: `init --project` ⇒ project skills; `init`
+ * (global) ⇒ global skills. Codex has no project-local skills dir (it only
+ * reads ~/.codex/skills globally), so it participates in GLOBAL projection only;
+ * pushing project skills to Codex is opt-in via `connect codex`.
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+/**
+ * IDE skill descriptors. Each IDE declares how it is detected and where its
+ * skills live, per scope:
+ *   project: { dir, markers, env }  — repo-relative dest; detected by repo
+ *            marker dirs or current-process env vars. null ⇒ no project skills.
+ *   global:  { dir, markers }       — home-relative dest; detected by home
+ *            marker dirs (i.e. the IDE is installed). null ⇒ no global skills.
+ */
+export const IDE_SKILLS = [
+  {
+    id: 'claude-code',
+    label: 'Claude Code',
+    clients: ['claude-code'],
+    project: { dir: ['.claude', 'skills'], markers: ['.claude'], env: ['CLAUDECODE', 'CLAUDE_CODE_ENTRYPOINT'] },
+    global:  { dir: ['.claude', 'skills'], markers: ['.claude'] }
+  },
+  {
+    id: 'agents',
+    label: 'Antigravity / Gemini',
+    clients: ['antigravity', 'gemini'],
+    // Antigravity & Gemini both read <repo>/.agents/skills as the workspace
+    // Agent-Skills location. Their *global* surface is ~/.gemini/commands
+    // (markdown commands), wired by the slash-command writer, not here.
+    project: { dir: ['.agents', 'skills'], markers: ['.agents', '.gemini'], env: ['ANTIGRAVITY', 'GEMINI_CLI'] },
+    global:  null
+  },
+  {
+    id: 'codex',
+    label: 'Codex',
+    clients: ['codex'],
+    // Codex only discovers skills globally under ~/.codex/skills. There is no
+    // project-local dir, so project skills are opt-in (namespaced) via connect.
+    project: null,
+    global:  { dir: ['.codex', 'skills'], markers: ['.codex'] }
+  }
+];
+
+function pathExists(filePath) {
+  try {
+    fs.lstatSync(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Skill source roots, in priority order. The canonical Total Recall location
+ * (.agent/skills, singular) wins, but we also scan the Antigravity-native
+ * .agents/skills (plural) so a skill authored in either place is discovered.
+ */
+export function skillSourceRoots(agentDir) {
+  const roots = [path.join(agentDir, 'skills')];
+  const parent = path.dirname(agentDir);
+  if (path.basename(agentDir) === '.agent') {
+    roots.push(path.join(parent, '.agents', 'skills'));
+  }
+  return roots;
+}
+
+/**
+ * Discover repo skills to expose as slash commands.
+ * Every <root>/<name>/ directory containing a SKILL.md is a skill. When the
+ * same name appears in more than one source root, the canonical root wins.
+ */
+export function discoverRepoSkills(agentDir) {
+  const seen = new Map();
+  for (const skillsRoot of skillSourceRoots(agentDir)) {
+    if (!fs.existsSync(skillsRoot)) continue;
+    let entries;
+    try {
+      entries = fs.readdirSync(skillsRoot, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
+      if (seen.has(entry.name)) continue;
+      const skillDir = path.join(skillsRoot, entry.name);
+      if (!fs.existsSync(path.join(skillDir, 'SKILL.md'))) continue;
+      seen.set(entry.name, { name: entry.name, skillDir });
+    }
+  }
+  return [...seen.values()];
+}
+
+/**
+ * Symlink each discovered skill dir into one IDE's Agent-Skills directory.
+ * Idempotent, self-healing, and strictly additive: a symlink that is broken or
+ * stale is refreshed even without --force; a *real* (non-symlink) entry is
+ * never clobbered unless --force (so a user's own skill always wins a name
+ * collision); a skill whose source already *is* the destination is left alone.
+ */
+export function projectSkillsAsCommands(destDir, skills, opts = {}) {
+  fs.mkdirSync(destDir, { recursive: true });
+  const written = [];
+  for (const skill of skills) {
+    const linkPath = path.join(destDir, skill.name);
+    const wantTarget = path.resolve(skill.skillDir);
+
+    if (path.resolve(linkPath) === wantTarget) {
+      written.push({ name: skill.name, action: 'source' });
+      continue;
+    }
+
+    if (pathExists(linkPath)) {
+      const stat = fs.lstatSync(linkPath);
+      if (stat.isSymbolicLink()) {
+        const current = path.resolve(path.dirname(linkPath), fs.readlinkSync(linkPath));
+        if (current === wantTarget && fs.existsSync(linkPath) && !opts.force) {
+          written.push({ name: skill.name, action: 'exists' });
+          continue;
+        }
+        fs.unlinkSync(linkPath); // stale, broken, or --force → refresh
+      } else if (!opts.force) {
+        written.push({ name: skill.name, action: 'skipped' }); // user's real file/dir wins
+        continue;
+      } else {
+        fs.rmSync(linkPath, { recursive: true, force: true });
+      }
+    }
+    fs.symlinkSync(skill.skillDir, linkPath);
+    written.push({ name: skill.name, action: 'linked' });
+  }
+  return written;
+}
+
+/**
+ * Is an IDE target active for the given scope?
+ *   project → repo has a marker dir, or the current process is this IDE (env)
+ *   global  → the IDE is installed (home marker dir present)
+ */
+function isTargetActive(target, scope, cwd, env) {
+  const spec = target[scope];
+  if (!spec) return false;
+  if (scope === 'project') {
+    if ((spec.markers || []).some(m => pathExists(path.join(cwd, m)))) return true;
+    if ((spec.env || []).some(v => env[v] != null && env[v] !== '')) return true;
+    return false;
+  }
+  // global
+  return (spec.markers || []).some(m => pathExists(path.join(os.homedir(), m)));
+}
+
+/**
+ * Resolve which IDE targets are active (and where they project to) for a scope.
+ * Returns every target annotated with { active, destDir } so callers can both
+ * wire the active ones and advertise the inactive ones as opt-in.
+ */
+export function detectActiveSkillTargets({ scope, cwd = process.cwd(), env = process.env }) {
+  return IDE_SKILLS.map(target => {
+    const spec = target[scope];
+    const active = isTargetActive(target, scope, cwd, env);
+    let destDir = null;
+    if (spec) {
+      destDir = scope === 'global'
+        ? path.join(os.homedir(), ...spec.dir)
+        : path.join(cwd, ...spec.dir);
+    }
+    return { id: target.id, label: target.label, clients: target.clients, scope, supported: !!spec, active, destDir };
+  });
+}
+
+/**
+ * Project discovered skills into every *active* IDE skill dir for one scope.
+ * Used by `init`: project skills on `init --project`, global skills on `init`.
+ *
+ * @returns {{ scope, skills, wired: Array, available: Array }}
+ *   wired     — targets we projected into (active + supported)
+ *   available — supported-but-inactive targets, surfaced as opt-in `connect`
+ */
+export function projectSkillsForScope({ scope, cwd = process.cwd(), agentDir, opts = {}, env = process.env }) {
+  const skills = discoverRepoSkills(agentDir);
+  const targets = detectActiveSkillTargets({ scope, cwd, env });
+  const wired = [];
+  const available = [];
+
+  for (const target of targets) {
+    if (!target.supported) continue;
+    if (target.active && skills.length > 0) {
+      const results = projectSkillsAsCommands(target.destDir, skills, opts);
+      wired.push({ ...target, results });
+    } else if (!target.active) {
+      available.push(target);
+    }
+  }
+  return { scope, skills, wired, available };
+}

package/src/cli/skill.mjs

@@ -1,16 +1,30 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { fileURLToPath } from 'node:url';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 import { spawnSync } from 'node:child_process';
+import { resolveAgentDir, parseLayerFlag } from './agent-dir.mjs';
 
 // Helper to resolve agent directories dynamically
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const ROOT = path.resolve(__dirname, '../../');
-const agentDir = path.join(ROOT, '.agent');
-const skillsDir = path.join(agentDir, 'skills');
 
-// Direct dynamic imports for scripts layer to preserve environment paths
-const scriptsPath = path.join(agentDir, 'skills', 'total-recall', 'skills', 'skill', 'scripts');
+export function resolveSkillScriptPath(scriptName, { agentDir = resolveAgentDir(), root = ROOT } = {}) {
+  const candidates = [
+    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),
+    path.join(root, 'scaffold', '.agent', 'skills', 'total-recall', 'skills', 'skill', 'scripts', scriptName),
+  ];
+  const found = candidates.find(candidate => fs.existsSync(candidate));
+  if (!found) {
+    throw new Error(`Could not find bundled skill helper "${scriptName}". Checked: ${candidates.join(', ')}`);
+  }
+  return found;
+}
+
+async function importSkillScript(scriptName, options) {
+  return import(pathToFileURL(resolveSkillScriptPath(scriptName, options)).href);
+}
 
 function printHelp() {
   console.log(`
@@ -28,6 +42,8 @@ function printHelp() {
     remove <name>         Safely delete a skill package and hot-recompile shims (alias: rm)
 
   Options:
+    --global              Target the global brain (~/.agent)
+    --project             Target the current repo's project brain
     --help, -h            Show this help menu
   
   Examples:
@@ -40,15 +56,24 @@ function printHelp() {
 }
 
 export default async function skillCli(args) {
-  if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
+  const { layer, remainingArgs } = parseLayerFlag(args);
+  if (remainingArgs.length === 0 || remainingArgs.includes('--help') || remainingArgs.includes('-h')) {
     printHelp();
     return;
   }
 
-  const command = args[0];
+  let agentDir;
+  try {
+    agentDir = resolveAgentDir(layer);
+  } catch (err) {
+    console.error(`❌ ${err.message}`);
+    process.exit(1);
+  }
+  const skillsDir = path.join(agentDir, 'skills');
+  const command = remainingArgs[0];
 
   if (command === 'find') {
-    const query = args[1];
+    const query = remainingArgs[1];
     if (!query) {
       console.error('❌ You must provide a search query.');
       console.error('Usage: npx total-recall skill find <query>');
@@ -56,7 +81,7 @@ export default async function skillCli(args) {
     }
 
     try {
-      const { searchAndSort } = await import('../../.agent/skills/total-recall/skills/skill/scripts/find-skills.mjs');
+      const { searchAndSort } = await importSkillScript('find-skills.mjs', { agentDir });
       const results = searchAndSort(query);
       
       if (results.length === 0) {
@@ -100,7 +125,7 @@ export default async function skillCli(args) {
   } 
   
   else if (command === 'install' || command === 'add' || command === 'load') {
-    const pkg = args[1];
+    const pkg = remainingArgs[1];
     if (!pkg) {
       console.error('❌ You must provide a skill package to load.');
       console.error('Usage: npx total-recall skill load <owner/repo@skill>');
@@ -108,8 +133,8 @@ export default async function skillCli(args) {
     }
 
     try {
-      const { installSkill } = await import('../../.agent/skills/total-recall/skills/skill/scripts/install-skill.mjs');
-      const res = installSkill(pkg);
+      const { installSkill } = await importSkillScript('install-skill.mjs', { agentDir });
+      const res = installSkill(pkg, { cwd: process.cwd(), agentDir });
       if (!res.success) {
         process.exit(1);
       }
@@ -120,7 +145,7 @@ export default async function skillCli(args) {
   } 
   
   else if (command === 'scan') {
-    const target = args[1];
+    const target = remainingArgs[1];
     if (!target) {
       console.error('❌ You must specify a local skill directory to scan.');
       console.error('Usage: npx total-recall skill scan <skill-name>');
@@ -130,7 +155,7 @@ export default async function skillCli(args) {
     const targetDir = path.resolve(skillsDir, target);
 
     try {
-      const { runScan } = await import('../../.agent/skills/total-recall/skills/skill/scripts/scan-skill.mjs');
+      const { runScan } = await importSkillScript('scan-skill.mjs', { agentDir });
       const result = runScan(targetDir);
       process.exit(result.success ? 0 : 1);
     } catch (err) {
@@ -176,7 +201,7 @@ export default async function skillCli(args) {
   } 
   
   else if (command === 'remove' || command === 'rm') {
-    const target = args[1];
+    const target = remainingArgs[1];
     if (!target) {
       console.error('❌ You must specify a skill name to remove.');
       console.error('Usage: npx total-recall skill remove <skill-name>');
@@ -197,7 +222,8 @@ export default async function skillCli(args) {
     console.log('🔄 Hot-recompiling active shims to reflect changes...');
     const child = spawnSync('npx', ['total-recall', 'compile'], { 
       encoding: 'utf8',
-      cwd: ROOT
+      cwd: process.cwd(),
+      env: { ...process.env, AGENT_DIR: agentDir },
     });
 
     if (child.error || child.status !== 0) {
@@ -208,7 +234,7 @@ export default async function skillCli(args) {
   } 
   
   else if (command === 'create' || command === 'new') {
-    const target = args[1];
+    const target = remainingArgs[1];
     if (!target) {
       console.error('❌ You must specify a skill name to create.');
       console.error('Usage: npx total-recall skill create <skill-name>');
@@ -285,7 +311,7 @@ Provide a high-level explanation of the skill's capabilities and context.
   }
 
   else if (command === 'edit') {
-    const target = args[1];
+    const target = remainingArgs[1];
     if (!target) {
       console.error('❌ You must specify a skill name to edit.');
       console.error('Usage: npx total-recall skill edit <skill-name>');