@mndrk/memx 0.3.3 → 0.3.4

package/index.js

@@ -1,5 +1,29 @@
 #!/usr/bin/env node
 
+// ============================================================
+// mem - Git-backed Key-Value Store for AI Agents
+//
+// Architecture:
+// - All data stored in central ~/.mem git repository
+// - Each task is a git branch (task/<name>)
+// - index.json maps project directories → task branches
+// - agx orchestrator calls mem commands, never accesses ~/.mem directly
+//
+// Storage structure (per task branch):
+//   goal.md     - task goal, criteria, progress %
+//   state.md    - status, provider, next step, checkpoints
+//   memory.md   - learnings and insights
+//   playbook.md - global learnings (on main branch)
+//
+// Primitives:
+//   mem new "goal" --provider c    Create task (branch + files + commit)
+//   mem branch <name>              Create/switch branch
+//   mem commit "msg"               Commit changes
+//   mem set <key> <value>          Set frontmatter value
+//   mem get <key>                  Get frontmatter value
+//   mem context --json             Get full task context
+// ============================================================
+
 const { execSync, spawn } = require('child_process');
 const fs = require('fs');
 const path = require('path');
@@ -26,9 +50,8 @@ Use \`mem\` to maintain state, track progress, and accumulate learnings across s
 - **Git-backed**: All state is versioned and syncable
 - **Branches = Tasks**: Each task/goal is a separate branch
 - **Two scopes**: Task-local memory + global playbook
-- **Wake system**: Store schedule intent, export to cron
 
-## On Wake (Start of Session)
+## On Session Start
 
 \`\`\`bash
 mem context                 # Load full state: goal, progress, learnings
@@ -75,11 +98,8 @@ mem tasks                   # List all tasks (branches)
 mem switch <name>           # Switch to different task
 \`\`\`
 
-### Wake & Sync
+### Sync
 \`\`\`bash
-mem wake "every 15m"        # Set wake schedule
-mem wake "8am daily"        # Other patterns: monday 9am, */30 * * * *
-mem cron export             # Export as crontab entry
 mem sync                    # Push/pull with remote
 \`\`\`
 
@@ -88,14 +108,14 @@ mem sync                    # Push/pull with remote
 \`\`\`
 .mem/
   goal.md           # Objective + criteria + constraints
-  state.md          # Progress, next step, blockers, wake
+  state.md          # Progress, next step, blockers
   memory.md         # Task-specific learnings
   playbook.md       # Global learnings (shared)
 \`\`\`
 
 ## Typical Session Loop
 
-1. \`mem context\` - Load state on wake
+1. \`mem context\` - Load current state
 2. \`mem next\` - See what to work on
 3. Do work
 4. \`mem checkpoint "..."\` - Save progress
@@ -238,6 +258,23 @@ function git(memDir, ...args) {
   }
 }
 
+// Parallel-safe: read file from branch without checkout
+function gitShow(memDir, branch, filename) {
+  try {
+    const result = require('child_process').spawnSync('git', ['show', `${branch}:${filename}`], {
+      cwd: memDir,
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+    if (result.status !== 0) {
+      return null;
+    }
+    return result.stdout || '';
+  } catch {
+    return null;
+  }
+}
+
 // Get current branch
 function getCurrentBranch(memDir) {
   return git(memDir, 'rev-parse', '--abbrev-ref', 'HEAD');
@@ -759,26 +796,221 @@ function cmdContext(memDir) {
 }
 
 // List tasks
-function cmdTasks(memDir) {
+// Uses git show for parallel-safe reading (no checkout required)
+function cmdTasks(args, memDir) {
+  const jsonMode = args.includes('--json');
+
   if (!memDir) {
-    console.log(`${c.yellow}No .mem repo found.${c.reset}`);
+    if (jsonMode) {
+      console.log(JSON.stringify({ tasks: [], error: 'no_repo' }));
+    } else {
+      console.log(`${c.yellow}No .mem repo found.${c.reset}`);
+    }
     return;
   }
 
-  const current = getCurrentBranch(memDir);
-  const branches = git(memDir, 'branch', '--list').split('\n');
-  
-  console.log(`\n${c.bold}Tasks${c.reset}\n`);
-  
-  branches.forEach(b => {
-    const name = b.replace('*', '').trim();
-    const isCurrent = b.includes('*');
-    const marker = isCurrent ? `${c.green}→${c.reset}` : ' ';
-    const display = name.replace('task/', '');
-    console.log(`${marker} ${isCurrent ? c.cyan : c.dim}${display}${c.reset}`);
+  const currentBranch = getCurrentBranch(memDir);
+  const branches = git(memDir, 'branch', '--list').split('\n')
+    .map(b => b.replace('*', '').trim())
+    .filter(b => b && b !== 'main' && b !== 'master');
+
+  if (branches.length === 0) {
+    if (jsonMode) {
+      console.log(JSON.stringify({ tasks: [] }));
+    } else {
+      console.log(`${c.yellow}No tasks found${c.reset}`);
+    }
+    return;
+  }
+
+  // Build reverse index: branch -> projectDir
+  const index = loadIndex();
+  const branchToDir = {};
+  for (const [dir, branch] of Object.entries(index)) {
+    branchToDir[branch] = dir;
+  }
+
+  // Load task info using git show (parallel-safe, no checkout)
+  const tasks = branches.map(branch => {
+    const taskName = branch.replace('task/', '');
+    let status = 'active';
+    let progress = '—';
+    let goal = '';
+    let provider = 'claude';
+
+    try {
+      // Use git show to read files without checkout (parallel-safe)
+      const stateContent = gitShow(memDir, branch, 'state.md');
+      if (stateContent) {
+        const { frontmatter } = parseFrontmatter(stateContent);
+        status = frontmatter.status || 'active';
+        provider = frontmatter.provider || 'claude';
+      }
+    } catch {}
+
+    try {
+      const goalContent = gitShow(memDir, branch, 'goal.md');
+      if (goalContent) {
+        const progressMatch = goalContent.match(/Progress:\s*(\d+)%/i);
+        if (progressMatch) progress = `${progressMatch[1]}%`;
+
+        const goalMatch = goalContent.match(/^#\s*Goal\s*\n+([^\n#]+)/m);
+        if (goalMatch) goal = goalMatch[1].trim().slice(0, 50);
+      }
+    } catch {}
+
+    return {
+      branch,
+      taskName,
+      status,
+      progress,
+      goal,
+      provider,
+      projectDir: branchToDir[branch] || null,
+      isCurrent: branch === currentBranch
+    };
+  });
+
+  // JSON mode - output structured data for agx
+  if (jsonMode) {
+    console.log(JSON.stringify({ tasks }));
+    return;
+  }
+
+  // Non-interactive if not TTY
+  if (!process.stdin.isTTY) {
+    console.log(`${c.bold}Tasks${c.reset}\n`);
+    tasks.forEach(t => {
+      const marker = t.isCurrent ? `${c.green}→${c.reset}` : ' ';
+      const statusIcon = t.status === 'done' ? `${c.dim}✓${c.reset}`
+                       : t.status === 'blocked' ? `${c.yellow}○${c.reset}`
+                       : `${c.green}●${c.reset}`;
+      console.log(`${marker} ${statusIcon} ${t.taskName}  ${c.dim}${t.progress}${c.reset}`);
+    });
+    return;
+  }
+
+  // Interactive mode
+  let selectedIdx = tasks.findIndex(t => t.isCurrent);
+  if (selectedIdx < 0) selectedIdx = 0;
+  let inDetailView = false;
+
+  const clearScreen = () => process.stdout.write('\x1b[2J\x1b[H');
+  const hideCursor = () => process.stdout.write('\x1b[?25l');
+  const showCursor = () => process.stdout.write('\x1b[?25h');
+
+  const renderList = () => {
+    clearScreen();
+    console.log(`${c.bold}Tasks${c.reset}\n`);
+
+    tasks.forEach((task, idx) => {
+      const selected = idx === selectedIdx;
+      const prefix = selected ? `${c.cyan}❯${c.reset}` : ' ';
+      const statusIcon = task.status === 'done' ? `${c.dim}✓${c.reset}`
+                       : task.status === 'blocked' ? `${c.yellow}○${c.reset}`
+                       : `${c.green}●${c.reset}`;
+      const current = task.isCurrent ? ` ${c.green}(current)${c.reset}` : '';
+      const name = selected ? `${c.bold}${task.taskName}${c.reset}` : task.taskName;
+      const progressText = task.progress !== '—' ? ` ${c.green}${task.progress}${c.reset}` : '';
+
+      console.log(`${prefix} ${statusIcon} ${name}${progressText}${current}`);
+    });
+
+    console.log(`\n${c.dim}↑/↓ select · enter view · s switch · d done · x delete · q quit${c.reset}`);
+  };
+
+  const renderDetail = () => {
+    clearScreen();
+    const task = tasks[selectedIdx];
+    const statusColor = task.status === 'done' ? c.dim
+                      : task.status === 'blocked' ? c.yellow
+                      : c.green;
+
+    console.log(`${c.bold}${c.cyan}${task.taskName}${c.reset}${task.isCurrent ? ` ${c.green}(current)${c.reset}` : ''}\n`);
+    console.log(`  ${c.dim}Status:${c.reset}   ${statusColor}${task.status}${c.reset}`);
+    console.log(`  ${c.dim}Progress:${c.reset} ${task.progress !== '—' ? c.green + task.progress + c.reset : c.dim + '—' + c.reset}`);
+    if (task.goal) console.log(`  ${c.dim}Goal:${c.reset}     ${task.goal}`);
+
+    console.log(`\n${c.dim}esc back · s switch · d done · x delete · q quit${c.reset}`);
+  };
+
+  const render = () => inDetailView ? renderDetail() : renderList();
+
+  const doAction = (action) => {
+    const task = tasks[selectedIdx];
+    showCursor();
+    clearScreen();
+
+    if (action === 'switch') {
+      try {
+        git(memDir, 'checkout', task.branch);
+        console.log(`${c.green}✓${c.reset} Switched to: ${c.bold}${task.taskName}${c.reset}`);
+      } catch (err) {
+        console.log(`${c.red}Error:${c.reset} ${err.message}`);
+      }
+      process.exit(0);
+    } else if (action === 'done') {
+      try {
+        git(memDir, 'checkout', task.branch);
+        const stateFile = path.join(memDir, 'state.md');
+        if (fs.existsSync(stateFile)) {
+          let state = fs.readFileSync(stateFile, 'utf8');
+          state = state.replace(/^status:\s*.+$/m, 'status: done');
+          fs.writeFileSync(stateFile, state);
+          git(memDir, 'add', 'state.md');
+          git(memDir, 'commit', '-m', 'done: marked complete');
+        }
+        console.log(`${c.green}✓${c.reset} Marked ${c.bold}${task.taskName}${c.reset} done`);
+      } catch (err) {
+        console.log(`${c.red}Error:${c.reset} ${err.message}`);
+      }
+      process.exit(0);
+    } else if (action === 'delete') {
+      try {
+        if (task.isCurrent) {
+          git(memDir, 'checkout', 'main');
+        }
+        git(memDir, 'branch', '-D', task.branch);
+        console.log(`${c.red}✗${c.reset} Deleted ${c.bold}${task.taskName}${c.reset}`);
+      } catch (err) {
+        console.log(`${c.red}Error:${c.reset} ${err.message}`);
+      }
+      process.exit(0);
+    }
+  };
+
+  process.stdin.setRawMode(true);
+  process.stdin.resume();
+  hideCursor();
+  render();
+
+  process.stdin.on('data', (key) => {
+    const k = key.toString();
+
+    if (k === 'q' || k === '\x03') {
+      showCursor();
+      clearScreen();
+      process.exit(0);
+    } else if (k === '\x1b[A') { // up
+      selectedIdx = Math.max(0, selectedIdx - 1);
+      render();
+    } else if (k === '\x1b[B') { // down
+      selectedIdx = Math.min(tasks.length - 1, selectedIdx + 1);
+      render();
+    } else if (k === '\r' || k === '\n') { // enter
+      inDetailView = true;
+      render();
+    } else if (k === '\x1b' || k === '\x1b[D') { // esc or left
+      inDetailView = false;
+      render();
+    } else if (k === 's') {
+      doAction('switch');
+    } else if (k === 'd') {
+      doAction('done');
+    } else if (k === 'x') {
+      doAction('delete');
+    }
   });
-  
-  console.log('');
 }
 
 // Switch task
@@ -1299,6 +1531,202 @@ function cmdCriteria(args, memDir) {
 
 // ==================== PRIMITIVES ====================
 
+function cmdBranch(args, memDir) {
+  const name = args[0];
+
+  // Initialize central mem if needed
+  if (!fs.existsSync(CENTRAL_MEM)) {
+    fs.mkdirSync(CENTRAL_MEM, { recursive: true });
+    execSync('git init', { cwd: CENTRAL_MEM, stdio: 'ignore' });
+    writeMemFile(CENTRAL_MEM, 'playbook.md', '# Playbook\n\n');
+    git(CENTRAL_MEM, 'add', '-A');
+    git(CENTRAL_MEM, 'commit', '-m', 'init: central memory');
+    console.log(`${c.green}✓${c.reset} Initialized central memory: ${c.dim}${CENTRAL_MEM}${c.reset}`);
+  }
+
+  const targetDir = memDir || CENTRAL_MEM;
+
+  // No args: list branches
+  if (!name) {
+    const branches = git(targetDir, 'branch', '--list');
+    console.log(branches || `${c.dim}No branches${c.reset}`);
+    return;
+  }
+
+  // Check if branch exists
+  const branches = git(targetDir, 'branch', '--list').split('\n').map(b => b.replace('*', '').trim());
+  const branchExists = branches.includes(name) || branches.includes(`task/${name}`);
+
+  try {
+    if (branchExists) {
+      // Switch to existing branch
+      const branchName = branches.includes(name) ? name : `task/${name}`;
+      git(targetDir, 'checkout', branchName);
+      console.log(`${c.green}✓${c.reset} Switched to: ${c.cyan}${branchName}${c.reset}`);
+    } else {
+      // Create new branch
+      const branchName = name.startsWith('task/') ? name : `task/${name}`;
+      git(targetDir, 'checkout', '-b', branchName);
+      console.log(`${c.green}✓${c.reset} Created branch: ${c.cyan}${branchName}${c.reset}`);
+    }
+  } catch (err) {
+    console.log(`${c.red}Error:${c.reset} ${err.message}`);
+  }
+}
+
+function cmdCommit(args, memDir) {
+  if (!memDir) {
+    // Use central mem
+    memDir = CENTRAL_MEM;
+    if (!fs.existsSync(memDir)) {
+      console.log(`${c.yellow}No .mem repo found.${c.reset} Run ${c.cyan}mem branch <name>${c.reset} first.`);
+      return;
+    }
+  }
+
+  const msg = args.join(' ') || 'checkpoint';
+
+  try {
+    // Check for changes
+    const status = git(memDir, 'status', '--porcelain');
+    if (!status.trim()) {
+      console.log(`${c.dim}No changes to commit${c.reset}`);
+      return;
+    }
+
+    // Add and commit
+    git(memDir, 'add', '-A');
+    git(memDir, 'commit', '-m', msg);
+    console.log(`${c.green}✓${c.reset} Committed: ${c.dim}${msg}${c.reset}`);
+  } catch (err) {
+    console.log(`${c.red}Error:${c.reset} ${err.message}`);
+  }
+}
+
+// ============================================================
+// cmdNew: Create a new task with all necessary files
+// This is the ONLY way to create tasks - agx calls this
+// ============================================================
+function cmdNew(args, memDir) {
+  // Parse flags
+  const jsonMode = args.includes('--json');
+
+  // Parse --provider / -P flag
+  let provider = 'claude';
+  const providerIdx = args.findIndex(a => a === '--provider' || a === '-P');
+  if (providerIdx !== -1 && args[providerIdx + 1]) {
+    provider = args[providerIdx + 1].toLowerCase();
+  }
+
+  // Parse --dir flag for project directory mapping
+  let projectDir = process.cwd();
+  const dirIdx = args.findIndex(a => a === '--dir');
+  if (dirIdx !== -1 && args[dirIdx + 1]) {
+    projectDir = args[dirIdx + 1];
+  }
+
+  // Extract goal text - filter out all flags and their values
+  const flagsWithValues = ['--provider', '-P', '--dir'];
+  const flagsWithoutValues = ['--json'];
+  const goalParts = [];
+  for (let i = 0; i < args.length; i++) {
+    if (flagsWithValues.includes(args[i])) {
+      i++; // skip the flag's value too
+      continue;
+    }
+    if (flagsWithoutValues.includes(args[i])) {
+      continue;
+    }
+    goalParts.push(args[i]);
+  }
+  const goalText = goalParts.join(' ');
+  if (!goalText) {
+    if (jsonMode) {
+      console.log(JSON.stringify({ error: 'missing_goal', usage: 'mem new "<goal>" [--provider c] [--dir /path]' }));
+    } else {
+      console.log(`${c.red}Usage:${c.reset} mem new "<goal>" [--provider c|g|o] [--dir /path]`);
+    }
+    process.exit(1);
+  }
+
+  // Generate task name from goal
+  const taskName = goalText
+    .toLowerCase()
+    .replace(/[^a-z0-9\s]/g, '')
+    .split(/\s+/)
+    .slice(0, 3)
+    .join('-');
+
+  const branch = `task/${taskName}`;
+  const today = new Date().toISOString().split('T')[0];
+
+  try {
+    // Create branch (also initializes central mem if needed)
+    cmdBranch([taskName], memDir);
+
+    // Write goal.md
+    const goalMd = `---
+task: ${taskName}
+created: ${today}
+---
+
+# Goal
+
+${goalText}
+
+## Criteria
+
+- [ ] Define success criteria
+
+## Progress: 0%`;
+    writeMemFile(CENTRAL_MEM, 'goal.md', goalMd);
+
+    // Write state.md with provider
+    const stateMd = `---
+status: active
+provider: ${provider}
+---
+
+# State
+
+## Next Step
+
+Begin work
+
+## Checkpoints
+
+- [ ] Started`;
+    writeMemFile(CENTRAL_MEM, 'state.md', stateMd);
+
+    // Write memory.md
+    writeMemFile(CENTRAL_MEM, 'memory.md', '# Learnings\n\n');
+
+    // Commit
+    git(CENTRAL_MEM, 'add', '-A');
+    git(CENTRAL_MEM, 'commit', '-m', `new: ${taskName}`);
+
+    // Update index mapping (projectDir -> branch)
+    const index = loadIndex();
+    index[projectDir] = branch;
+    saveIndex(index);
+
+    if (jsonMode) {
+      console.log(JSON.stringify({ taskName, branch, projectDir, created: today, goal: goalText, provider }));
+    } else {
+      console.log(`${c.green}✓${c.reset} Created task: ${c.bold}${taskName}${c.reset}`);
+      console.log(`${c.green}✓${c.reset} Provider: ${c.cyan}${provider}${c.reset}`);
+      console.log(`${c.green}✓${c.reset} Mapped: ${c.dim}${projectDir} → ${branch}${c.reset}`);
+    }
+  } catch (err) {
+    if (jsonMode) {
+      console.log(JSON.stringify({ error: err.message }));
+    } else {
+      console.log(`${c.red}Error:${c.reset} ${err.message}`);
+    }
+    process.exit(1);
+  }
+}
+
 function cmdSet(args, memDir) {
   if (!memDir) {
     console.log(`${c.yellow}No .mem repo found.${c.reset}`);
@@ -1402,6 +1830,73 @@ function cmdLog(memDir) {
   console.log(log);
 }
 
+// Live watch memory activity
+function cmdWatch(memDir) {
+  if (!memDir) {
+    console.log(`${c.yellow}No .mem repo found.${c.reset}`);
+    return;
+  }
+
+  const clearScreen = () => process.stdout.write('\x1b[2J\x1b[H');
+
+  const render = () => {
+    clearScreen();
+    console.log('═══════════════════════════════════════════════════════');
+    console.log('                    📝 Memory Activity');
+    console.log('═══════════════════════════════════════════════════════');
+    console.log('');
+
+    // Show main branch
+    console.log(`  ${c.yellow}📌 main${c.reset}`);
+    try {
+      const mainLog = git(memDir, 'log', 'main', '--format=%C(dim)%ar%C(reset)  %C(cyan)%s%C(reset)', '-6');
+      mainLog.split('\n').filter(l => l).forEach(line => console.log(`     ${line}`));
+    } catch (e) {
+      console.log(`     ${c.dim}(no commits)${c.reset}`);
+    }
+
+    // Show task branches
+    try {
+      const branches = git(memDir, 'branch', '--format=%(refname:short)')
+        .split('\n')
+        .filter(b => b.startsWith('task/'))
+        .slice(0, 3);
+
+      for (const branch of branches) {
+        const taskName = branch.replace('task/', '');
+        console.log('');
+        console.log(`  ${c.yellow}📌 ${taskName}${c.reset}`);
+        try {
+          const branchLog = git(memDir, 'log', branch, '--format=%C(dim)%ar%C(reset)  %C(cyan)%s%C(reset)', '-3');
+          branchLog.split('\n').filter(l => l).forEach(line => console.log(`     ${line}`));
+        } catch (e) {
+          console.log(`     ${c.dim}(no commits)${c.reset}`);
+        }
+      }
+    } catch (e) {
+      // No task branches
+    }
+
+    console.log('');
+    console.log('═══════════════════════════════════════════════════════');
+    const now = new Date().toLocaleTimeString('en-US', { hour12: false });
+    console.log(`               ${c.dim}${now} • ctrl+c to exit${c.reset}`);
+  };
+
+  // Initial render
+  render();
+
+  // Update every 2 seconds
+  const interval = setInterval(render, 2000);
+
+  // Handle exit
+  process.on('SIGINT', () => {
+    clearInterval(interval);
+    clearScreen();
+    process.exit(0);
+  });
+}
+
 // ==================== SKILL ====================
 
 function isSkillInstalled(provider) {
@@ -1501,171 +1996,6 @@ function handleSkillCommand(args) {
   console.log('');
 }
 
-// ==================== WAKE ====================
-
-// Parse wake pattern to cron expression
-function parseWakeToCron(pattern) {
-  pattern = pattern.toLowerCase().trim();
-  
-  // Handle intervals: every Xm, every Xh
-  const intervalMatch = pattern.match(/^every\s+(\d+)\s*(m|min|minutes?|h|hr|hours?)$/);
-  if (intervalMatch) {
-    const num = parseInt(intervalMatch[1]);
-    const unit = intervalMatch[2][0];
-    if (unit === 'm') {
-      return `*/${num} * * * *`;
-    } else if (unit === 'h') {
-      return `0 */${num} * * *`;
-    }
-  }
-  
-  // Handle daily: Xam daily, Xpm daily, every day at X
-  const dailyMatch = pattern.match(/^(\d{1,2})(?::(\d{2}))?\s*(am|pm)?\s*(?:daily|every\s*day)?$/);
-  if (dailyMatch) {
-    let hour = parseInt(dailyMatch[1]);
-    const min = dailyMatch[2] ? parseInt(dailyMatch[2]) : 0;
-    const ampm = dailyMatch[3];
-    if (ampm === 'pm' && hour < 12) hour += 12;
-    if (ampm === 'am' && hour === 12) hour = 0;
-    return `${min} ${hour} * * *`;
-  }
-  
-  // Handle weekly: monday 9am, every tuesday at 3pm
-  const weeklyMatch = pattern.match(/^(?:every\s+)?(mon|tue|wed|thu|fri|sat|sun)[a-z]*\s+(?:at\s+)?(\d{1,2})(?::(\d{2}))?\s*(am|pm)?$/);
-  if (weeklyMatch) {
-    const days = { sun: 0, mon: 1, tue: 2, wed: 3, thu: 4, fri: 5, sat: 6 };
-    const day = days[weeklyMatch[1]];
-    let hour = parseInt(weeklyMatch[2]);
-    const min = weeklyMatch[3] ? parseInt(weeklyMatch[3]) : 0;
-    const ampm = weeklyMatch[4];
-    if (ampm === 'pm' && hour < 12) hour += 12;
-    if (ampm === 'am' && hour === 12) hour = 0;
-    return `${min} ${hour} * * ${day}`;
-  }
-  
-  // Already cron format? Pass through
-  if (pattern.match(/^[\d\*\/\-\,]+\s+[\d\*\/\-\,]+\s+[\d\*\/\-\,]+\s+[\d\*\/\-\,]+\s+[\d\*\/\-\,]+$/)) {
-    return pattern;
-  }
-  
-  return null;
-}
-
-// Set/get/clear wake
-function cmdWake(args, memDir) {
-  if (!memDir) {
-    console.log(`${c.yellow}No .mem repo found.${c.reset}`);
-    return;
-  }
-
-  const state = readMemFile(memDir, 'state.md') || '';
-  const { frontmatter, body } = parseFrontmatter(state);
-
-  // No args: show current wake
-  if (args.length === 0) {
-    if (frontmatter.wake) {
-      console.log(`${c.bold}Wake:${c.reset} ${frontmatter.wake}`);
-      if (frontmatter.wake_command) {
-        console.log(`${c.bold}Command:${c.reset} ${frontmatter.wake_command}`);
-      }
-      const cron = parseWakeToCron(frontmatter.wake);
-      if (cron) {
-        console.log(`${c.dim}Cron: ${cron}${c.reset}`);
-      }
-    } else {
-      console.log(`${c.dim}No wake set${c.reset}`);
-      console.log(`${c.dim}Usage: mem wake "every 15m" [--run "command"]${c.reset}`);
-    }
-    return;
-  }
-
-  // Clear wake
-  if (args[0] === 'clear') {
-    delete frontmatter.wake;
-    delete frontmatter.wake_command;
-    writeMemFile(memDir, 'state.md', serializeFrontmatter(frontmatter, body));
-    git(memDir, 'add', 'state.md');
-    git(memDir, 'commit', '-m', 'wake: clear');
-    console.log(`${c.green}✓${c.reset} Wake cleared`);
-    return;
-  }
-
-  // Set wake
-  let pattern = '';
-  let command = '';
-  
-  // Parse args
-  for (let i = 0; i < args.length; i++) {
-    if (args[i] === '--run' || args[i] === '-r') {
-      command = args.slice(i + 1).join(' ');
-      break;
-    }
-    pattern += (pattern ? ' ' : '') + args[i];
-  }
-
-  // Validate pattern
-  const cron = parseWakeToCron(pattern);
-  if (!cron) {
-    console.log(`${c.red}Could not parse wake pattern:${c.reset} ${pattern}`);
-    console.log(`\n${c.dim}Examples:${c.reset}`);
-    console.log(`  mem wake "every 15m"`);
-    console.log(`  mem wake "every 2h"`);
-    console.log(`  mem wake "8am daily"`);
-    console.log(`  mem wake "monday 9am"`);
-    console.log(`  mem wake "*/30 * * * *"  ${c.dim}(raw cron)${c.reset}`);
-    return;
-  }
-
-  frontmatter.wake = pattern;
-  if (command) {
-    frontmatter.wake_command = command;
-  }
-
-  writeMemFile(memDir, 'state.md', serializeFrontmatter(frontmatter, body));
-  git(memDir, 'add', 'state.md');
-  git(memDir, 'commit', '-m', `wake: ${pattern}`);
-
-  console.log(`${c.green}✓${c.reset} Wake set: ${c.bold}${pattern}${c.reset}`);
-  console.log(`${c.dim}Cron: ${cron}${c.reset}`);
-  if (command) {
-    console.log(`${c.dim}Command: ${command}${c.reset}`);
-  }
-  console.log(`\n${c.dim}Export with: ${c.reset}mem cron export`);
-}
-
-// Export to cron format
-function cmdCronExport(memDir) {
-  if (!memDir) {
-    console.log(`${c.yellow}No .mem repo found.${c.reset}`);
-    return;
-  }
-
-  const state = readMemFile(memDir, 'state.md') || '';
-  const { frontmatter } = parseFrontmatter(state);
-
-  if (!frontmatter.wake) {
-    console.log(`${c.yellow}No wake set.${c.reset} Use ${c.cyan}mem wake "pattern"${c.reset} first.`);
-    return;
-  }
-
-  const cron = parseWakeToCron(frontmatter.wake);
-  if (!cron) {
-    console.log(`${c.red}Could not parse wake pattern:${c.reset} ${frontmatter.wake}`);
-    return;
-  }
-
-  // Detect PATH from current environment for cron (which has minimal PATH)
-  const nodeBin = path.dirname(process.execPath);
-  const pathDirs = [nodeBin, '/usr/local/bin', '/usr/bin', '/bin'];
-  const pathPrefix = `PATH=${pathDirs.join(':')}`;
-
-  const command = frontmatter.wake_command || `cd ${memDir} && mem context`;
-  const entry = `${cron} ${pathPrefix} && ${command}`;
-
-  // Just output the cron line (can be piped/appended)
-  console.log(entry);
-}
-
 // ==================== MCP ====================
 
 function startMCPServer(args) {
@@ -1756,7 +2086,7 @@ ${c.bold}PROGRESS${c.reset}
   criteria <n>            Mark criterion #n complete
 
 ${c.bold}QUERY${c.reset}
-  context                 Full hydration for agent wake
+  context                 Full context for agent
   history                 Task progression
   query "<search>"        Search all memory
 
@@ -1772,12 +2102,8 @@ ${c.bold}PRIMITIVES${c.reset}
   get <key>               Get a value
   append <list> <item>    Append to list
   log                     Raw git log
+  watch                   Live tail of memory activity
 
-${c.bold}WAKE${c.reset}
-  wake "<pattern>"        Set wake schedule (every 15m, 8am daily, etc.)
-  wake --run "<cmd>"      Set wake with custom command
-  wake clear              Clear wake schedule
-  cron export             Export wake as crontab entry
 
 ${c.bold}INTEGRATION${c.reset}
   skill                   View LLM skill
@@ -1799,42 +2125,45 @@ ${c.dim}Docs: https://github.com/ramarlina/memx${c.reset}
 // ==================== MAIN ====================
 
 async function main() {
+  // ============================================================
+  // mem: Git-backed key-value store for AI agents
+  //
+  // Architecture:
+  // - All data stored in central ~/.mem git repo
+  // - Each task is a branch (task/<name>)
+  // - index.json maps project directories to task branches
+  // - agx orchestrator uses mem primitives, never accesses ~/.mem directly
+  // ============================================================
+
   const args = process.argv.slice(2);
   const cmd = args[0];
   const cmdArgs = args.slice(1);
-  
-  // Find .mem repo (returns object with memDir, taskBranch, etc.)
-  const memInfo = findMemDir();
-  let memDir = null;
-  
-  if (memInfo) {
-    memDir = memInfo.memDir;
-    // If central mem with task mapping, ensure we're on the right branch
-    if (!memInfo.isLocal && memInfo.taskBranch) {
-      ensureTaskBranch(memDir, memInfo.taskBranch);
-    }
-  }
-  
-  // No command and no .mem? Start interactive onboarding
-  if (!cmd && !memDir) {
-    await interactiveInit();
-    return;
-  }
-  
-  // No command but has central mem with no mapping for this dir?
-  if (!cmd && memInfo && memInfo.unmapped) {
-    console.log(`${c.dim}No task mapped for this directory.${c.reset}`);
-    const create = await prompt(`Create a new task? [Y/n]: `);
-    if (create.toLowerCase() !== 'n') {
+
+  // Always use central ~/.mem repository
+  // This is the single source of truth for all task data
+  const memDir = CENTRAL_MEM;
+
+  // Initialize central mem if it doesn't exist
+  if (!fs.existsSync(memDir)) {
+    // No command? Start interactive onboarding
+    if (!cmd) {
       await interactiveInit();
+      return;
     }
-    return;
+    // For commands like 'branch', let them handle initialization
   }
-  
-  // No command but has .mem? Show status
-  if (!cmd && memDir) {
-    cmdStatus(memDir);
-    console.log(`${c.dim}Run ${c.reset}mem help${c.dim} for all commands${c.reset}\n`);
+
+  // No command? Show status for current directory's mapped task
+  if (!cmd) {
+    const index = loadIndex();
+    const taskBranch = index[process.cwd()];
+    if (taskBranch) {
+      ensureTaskBranch(memDir, taskBranch);
+      cmdStatus(memDir);
+    } else {
+      console.log(`${c.dim}No task mapped for this directory.${c.reset}`);
+      console.log(`${c.dim}Run ${c.reset}mem branch <name>${c.dim} to create one.${c.reset}`);
+    }
     return;
   }
   
@@ -1848,6 +2177,11 @@ async function main() {
     case 'init':
       await cmdInit(cmdArgs, memDir);
       break;
+    case 'new':
+      // Create a new task - this is the primary entry point
+      // agx calls: mem new "goal" --provider claude --dir /project/path
+      cmdNew(cmdArgs, memDir);
+      break;
     case 'status':
       cmdStatus(memDir);
       break;
@@ -1918,7 +2252,7 @@ async function main() {
     // Tasks
     case 'tasks':
     case 'ls':
-      cmdTasks(memDir);
+      cmdTasks(cmdArgs, memDir);
       break;
     case 'switch':
     case 'sw':
@@ -1931,6 +2265,14 @@ async function main() {
       break;
       
     // Primitives
+    case 'branch':
+    case 'br':
+      cmdBranch(cmdArgs, memDir);
+      break;
+    case 'commit':
+    case 'ci':
+      cmdCommit(cmdArgs, memDir);
+      break;
     case 'set':
       cmdSet(cmdArgs, memDir);
       break;
@@ -1943,24 +2285,16 @@ async function main() {
     case 'log':
       cmdLog(memDir);
       break;
-      
+    case 'watch':
+    case 'tail':
+      cmdWatch(memDir);
+      break;
+
     // Skill
     case 'skill':
       handleSkillCommand(args);
       break;
-    
-    // Wake
-    case 'wake':
-      cmdWake(cmdArgs, memDir);
-      break;
-    case 'cron':
-      if (cmdArgs[0] === 'export') {
-        cmdCronExport(memDir);
-      } else {
-        console.log(`${c.dim}Usage: mem cron export${c.reset}`);
-      }
-      break;
-    
+
     // MCP
     case 'mcp':
       if (cmdArgs[0] === 'config') {
@@ -1976,7 +2310,81 @@ async function main() {
   }
 }
 
-main().catch(err => {
-  console.error(`${c.red}Error:${c.reset}`, err.message);
-  process.exit(1);
-});
+// Only run main if executed directly (not when required for tests)
+if (require.main === module) {
+  main().catch(err => {
+    console.error(`${c.red}Error:${c.reset}`, err.message);
+    process.exit(1);
+  });
+}
+
+// Export for testing
+module.exports = {
+  // Constants
+  CONFIG_DIR,
+  CONFIG_FILE,
+  CENTRAL_MEM,
+  INDEX_FILE,
+  MEM_SKILL,
+  c,
+
+  // Utility functions
+  loadConfig,
+  saveConfig,
+  prompt,
+  loadIndex,
+  saveIndex,
+  findMemDir,
+  ensureTaskBranch,
+  git,
+  getCurrentBranch,
+  readMemFile,
+  writeMemFile,
+  parseFrontmatter,
+  serializeFrontmatter,
+
+  // Command functions
+  interactiveInit,
+  setupRemote,
+  cmdInit,
+  cmdStatus,
+  cmdGoal,
+  cmdNext,
+  cmdCheckpoint,
+  cmdLearn,
+  cmdContext,
+  cmdTasks,
+  cmdSwitch,
+  cmdSync,
+  cmdHistory,
+  cmdDone,
+  cmdStuck,
+  cmdQuery,
+  cmdPlaybook,
+  cmdLearnings,
+  cmdPromote,
+  cmdConstraint,
+  cmdProgress,
+  cmdCriteria,
+  cmdBranch,
+  cmdCommit,
+  cmdSet,
+  cmdGet,
+  cmdAppend,
+  cmdLog,
+  cmdWatch,
+  cmdNew,
+
+  // Skill functions
+  isSkillInstalled,
+  installSkillTo,
+  handleSkillCommand,
+
+  // MCP functions
+  startMCPServer,
+  showMCPConfig,
+
+  // Main
+  showHelp,
+  main
+};