cnagent 2.0.7 → 2.1.0

package/bin/cn

@@ -36,15 +36,31 @@ const HELP = `cn - Coherent Network agent CLI
 Usage: cn <command> [options]
 
 Commands:
+  # Agent decisions (output)
+  delete <thread>     GTD: discard
+  defer <thread>      GTD: postpone
+  delegate <t> <peer> GTD: forward
+  do <thread>         GTD: claim/start
+  done <thread>       GTD: complete → archive
+  reply <thread> <msg> Append to thread
+  send <peer> <msg>   Message to peer (or self)
+  
+  # cn operations (orchestrator)
+  next                Get next inbox item (with cadence)
+  sync                Fetch inbound + send outbound
+  inbox               List inbox (cn internal)
+  outbox              List outbox (cn internal)
+  read <thread>       Read thread with cadence
+  
+  # Hub management
   init [name]         Create new hub
   status              Show hub state
-  inbox               Manage inbound messages
-    check             List inbound branches
-    process           Materialize as threads
-    flush             Execute decisions
+  commit [msg]        Stage + commit
+  push                Push to origin
+  save [msg]          Commit + push
   peer                Manage peers
-  doctor              Check system health
-  update              Update cn to latest version
+  doctor              Health check
+  update              Update cn
 
 Aliases:
   i = inbox, s = status, d = doctor
@@ -60,7 +76,7 @@ Examples:
 `;
 
 // Expand aliases
-const aliases = { i: 'inbox', s: 'status', d: 'doctor', p: 'peer', t: 'thread' };
+const aliases = { i: 'inbox', o: 'outbox', s: 'status', d: 'doctor', p: 'peer', t: 'thread' };
 const expandAlias = (cmd) => aliases[cmd] || cmd;
 
 // Find hub path
@@ -85,16 +101,1170 @@ function deriveName(hubPath) {
   return base.startsWith('cn-') ? base.slice(3) : base;
 }
 
-// Run inbox tool
+// Append-only action log
+function logAction(hubPath, action, details = {}) {
+  const logsDir = path.join(hubPath, 'logs');
+  if (!fs.existsSync(logsDir)) {
+    fs.mkdirSync(logsDir, { recursive: true });
+  }
+  const entry = {
+    ts: new Date().toISOString(),
+    action,
+    ...details
+  };
+  fs.appendFileSync(
+    path.join(logsDir, 'cn.log'),
+    JSON.stringify(entry) + '\n'
+  );
+}
+
+// Run inbox commands (threads/inbox/ model)
 function runInbox(subCmd, hubPath, name) {
-  const inboxJs = path.join(__dirname, '..', 'dist', 'inbox.js');
-  if (!fs.existsSync(inboxJs)) {
-    fail('inbox.js not found. Run from cn-agent directory or install globally.');
+  const inboxDir = path.join(hubPath, 'threads', 'inbox');
+  const peersPath = path.join(hubPath, 'state', 'peers.md');
+  
+  // Ensure inbox dir exists
+  if (!fs.existsSync(inboxDir)) {
+    fs.mkdirSync(inboxDir, { recursive: true });
+  }
+  
+  // Load peers
+  let peers = {};
+  if (fs.existsSync(peersPath)) {
+    const peersContent = fs.readFileSync(peersPath, 'utf8');
+    peers = parsePeers(peersContent);
+  }
+  
+  if (subCmd === 'check') {
+    // Actor model: check MY repo for inbound branches from peers (peer/*)
+    info(`Checking inbox for ${name}...`);
+    
+    // Fetch my own repo
+    try {
+      execSync('git fetch origin', { cwd: hubPath, stdio: 'pipe' });
+    } catch (err) {
+      warn('Failed to fetch origin');
+    }
+    
+    let totalInbound = 0;
+    
+    for (const [peerName, peer] of Object.entries(peers)) {
+      if (peer.kind === 'template') continue; // Skip template repo
+      
+      try {
+        // Find branches from this peer in MY repo (peerName/*)
+        const branches = execSync(`git branch -r | grep "origin/${peerName}/" | sed 's/.*origin\\///'`, { 
+          cwd: hubPath, 
+          encoding: 'utf8',
+          stdio: ['pipe', 'pipe', 'pipe']
+        }).trim().split('\n').filter(b => b);
+        
+        if (branches.length > 0) {
+          logAction(hubPath, 'inbox.fetch', { from: peerName, branches, count: branches.length });
+          warn(`From ${peerName}: ${branches.length} inbound`);
+          branches.forEach(b => console.log(`  ← ${b}`));
+          totalInbound += branches.length;
+        } else {
+          console.log(`  ${c.dim}${peerName}: no inbound${c.reset}`);
+        }
+      } catch (err) {
+        // No branches found
+        console.log(`  ${c.dim}${peerName}: no inbound${c.reset}`);
+      }
+    }
+    
+    if (totalInbound === 0) {
+      ok('Inbox clear');
+    }
+    return;
+  }
+  
+  if (subCmd === 'process') {
+    // Actor model: materialize inbound branches from MY repo to threads/inbox/
+    info('Processing inbox...');
+    let processed = 0;
+    
+    for (const [peerName, peer] of Object.entries(peers)) {
+      if (peer.kind === 'template') continue; // Skip template repo
+      
+      try {
+        // Find branches from this peer in MY repo
+        const branches = execSync(`git branch -r | grep "origin/${peerName}/" | sed 's/.*origin\\///'`, { 
+          cwd: hubPath, 
+          encoding: 'utf8',
+          stdio: ['pipe', 'pipe', 'pipe']
+        }).trim().split('\n').filter(b => b);
+        
+        for (const branch of branches) {
+          // Get files from this branch
+          try {
+            const files = execSync(`git diff main...origin/${branch} --name-only 2>/dev/null || git diff master...origin/${branch} --name-only`, {
+              cwd: hubPath,
+              encoding: 'utf8',
+              stdio: ['pipe', 'pipe', 'pipe']
+            }).trim().split('\n').filter(f => f.endsWith('.md'));
+            
+            for (const file of files) {
+              // Get file content from branch
+              const content = execSync(`git show origin/${branch}:${file}`, {
+                cwd: hubPath,
+                encoding: 'utf8',
+                stdio: ['pipe', 'pipe', 'pipe']
+              });
+              
+              // Write to inbox with metadata
+              const inboxFileName = `${peerName}-${path.basename(branch)}.md`;
+              const inboxFilePath = path.join(inboxDir, inboxFileName);
+              
+              // Skip if already materialized
+              if (fs.existsSync(inboxFilePath)) {
+                continue;
+              }
+              
+              // Add/update frontmatter
+              const meta = {
+                from: peerName,
+                branch: branch,
+                file: file,
+                received: new Date().toISOString()
+              };
+              const finalContent = ensureFrontmatter(content, meta);
+              fs.writeFileSync(inboxFilePath, finalContent);
+              
+              logAction(hubPath, 'inbox.materialize', { from: peerName, branch, file, inboxFile: inboxFileName });
+              ok(`Materialized: ${inboxFileName}`);
+              processed++;
+            }
+          } catch (err) {
+            // Branch might not have files or diff failed
+          }
+        }
+      } catch (err) {
+        // No branches found
+      }
+    }
+    
+    if (processed === 0) {
+      info('No new threads to materialize');
+    } else {
+      ok(`Processed ${processed} thread(s)`);
+    }
+    return;
+  }
+  
+  if (subCmd === 'flush') {
+    // Scan inbox for agent replies, send back
+    info('Scanning inbox for replies...');
+    
+    const threads = fs.readdirSync(inboxDir)
+      .filter(f => f.endsWith('.md'))
+      .map(f => {
+        const filePath = path.join(inboxDir, f);
+        const content = fs.readFileSync(filePath, 'utf8');
+        const meta = parseFrontmatter(content);
+        return { file: f, path: filePath, content, meta };
+      });
+    
+    let replied = 0;
+    for (const t of threads) {
+      // Check if agent has replied (look for ## Reply section or reply: true in frontmatter)
+      const hasReply = t.meta.reply === 'true' || t.content.includes('\n## Reply\n') || t.content.includes('\n## Response\n');
+      
+      if (!hasReply) continue;
+      
+      const from = t.meta.from;
+      if (!from) continue;
+      
+      const peer = peers[from];
+      if (!peer || !peer.clone) continue;
+      
+      try {
+        const threadName = path.basename(t.file, '.md');
+        const branchName = `${name}/${threadName}-reply`;
+        
+        // Push reply to peer's clone
+        execSync(`git checkout main 2>/dev/null || git checkout master`, { cwd: peer.clone, stdio: 'pipe' });
+        execSync(`git pull --ff-only 2>/dev/null || true`, { cwd: peer.clone, stdio: 'pipe' });
+        execSync(`git checkout -b ${branchName} 2>/dev/null || git checkout ${branchName}`, { cwd: peer.clone, stdio: 'pipe' });
+        
+        const peerThreadDir = path.join(peer.clone, 'threads', 'adhoc');
+        if (!fs.existsSync(peerThreadDir)) {
+          fs.mkdirSync(peerThreadDir, { recursive: true });
+        }
+        
+        // Copy reply thread
+        const replyFileName = `${name}-${threadName}-reply.md`;
+        fs.copyFileSync(t.path, path.join(peerThreadDir, replyFileName));
+        
+        execSync(`git add "threads/adhoc/${replyFileName}"`, { cwd: peer.clone, stdio: 'pipe' });
+        execSync(`git commit -m "${name}: reply to ${threadName}"`, { cwd: peer.clone, stdio: 'pipe' });
+        execSync(`git push -u origin ${branchName} -f`, { cwd: peer.clone, stdio: 'pipe' });
+        execSync(`git checkout main 2>/dev/null || git checkout master`, { cwd: peer.clone, stdio: 'pipe' });
+        
+        // Archive the inbox thread (move to threads/archived/)
+        const archivedDir = path.join(hubPath, 'threads', 'archived');
+        if (!fs.existsSync(archivedDir)) {
+          fs.mkdirSync(archivedDir, { recursive: true });
+        }
+        const archivedContent = updateFrontmatter(t.content, { replied: new Date().toISOString() });
+        fs.writeFileSync(path.join(archivedDir, t.file), archivedContent);
+        fs.unlinkSync(t.path);
+        
+        logAction(hubPath, 'inbox.reply', { to: from, thread: t.file, branch: branchName, result: 'ok' });
+        ok(`Replied to ${from}: ${t.file}`);
+        replied++;
+      } catch (err) {
+        logAction(hubPath, 'inbox.reply', { to: from, thread: t.file, result: 'error', error: err.message });
+        fail(`Failed to reply: ${err.message}`);
+        execSync(`git checkout main 2>/dev/null || git checkout master 2>/dev/null || true`, { cwd: peer.clone, stdio: 'pipe' });
+      }
+    }
+    
+    if (replied === 0) {
+      info('No replies to send');
+    } else {
+      ok(`Sent ${replied} reply(s)`);
+    }
+    return;
+  }
+}
+
+// Ensure content has frontmatter with given fields
+function ensureFrontmatter(content, meta) {
+  const existing = parseFrontmatter(content);
+  const merged = { ...existing, ...meta };
+  
+  // Remove existing frontmatter if present
+  const withoutFm = content.replace(/^---\n[\s\S]*?\n---\n*/, '');
+  
+  // Build new frontmatter
+  const fmLines = Object.entries(merged).map(([k, v]) => `${k}: ${v}`).join('\n');
+  return `---\n${fmLines}\n---\n\n${withoutFm}`;
+}
+
+// Run outbox commands (threads/outbox/ model)
+function runOutbox(subCmd, hubPath, name) {
+  const outboxDir = path.join(hubPath, 'threads', 'outbox');
+  const sentDir = path.join(hubPath, 'threads', 'sent');
+  const peersPath = path.join(hubPath, 'state', 'peers.md');
+  
+  // Ensure directories exist
+  if (!fs.existsSync(outboxDir)) {
+    fs.mkdirSync(outboxDir, { recursive: true });
+  }
+  if (!fs.existsSync(sentDir)) {
+    fs.mkdirSync(sentDir, { recursive: true });
+  }
+  
+  // Load peers
+  let peers = {};
+  if (fs.existsSync(peersPath)) {
+    const peersContent = fs.readFileSync(peersPath, 'utf8');
+    peers = parsePeers(peersContent);
+  }
+  
+  // Scan outbox for threads
+  const threads = fs.readdirSync(outboxDir)
+    .filter(f => f.endsWith('.md'))
+    .map(f => {
+      const filePath = path.join(outboxDir, f);
+      const content = fs.readFileSync(filePath, 'utf8');
+      const meta = parseFrontmatter(content);
+      return { file: f, path: filePath, content, meta };
+    });
+  
+  if (subCmd === 'check') {
+    if (threads.length === 0) {
+      ok('Outbox clear');
+      return;
+    }
+    warn(`${threads.length} pending send(s):`);
+    threads.forEach(t => {
+      const to = t.meta.to || '(no recipient)';
+      console.log(`  → ${to}: ${t.file}`);
+    });
+    return;
+  }
+  
+  if (subCmd === 'flush') {
+    if (threads.length === 0) {
+      ok('Outbox clear');
+      return;
+    }
+    
+    info(`Flushing ${threads.length} thread(s)...`);
+    
+    for (const t of threads) {
+      const to = t.meta.to;
+      if (!to) {
+        logAction(hubPath, 'outbox.skip', { thread: t.file, reason: 'no recipient (to: field missing)' });
+        warn(`Skipping ${t.file}: no 'to:' in frontmatter`);
+        continue;
+      }
+      
+      const peer = peers[to];
+      if (!peer) {
+        logAction(hubPath, 'outbox.skip', { thread: t.file, to, reason: 'unknown peer' });
+        fail(`Unknown peer: ${to}`);
+        continue;
+      }
+      
+      if (!peer.clone) {
+        logAction(hubPath, 'outbox.skip', { thread: t.file, to, reason: 'no clone path configured' });
+        fail(`No clone path for peer: ${to}`);
+        continue;
+      }
+      
+      try {
+        const threadName = path.basename(t.file, '.md');
+        const branchName = `${name}/${threadName}`;
+        
+        // Actor model: push to PEER's repo (their clone)
+        // 1. Ensure peer clone is on main and up to date
+        execSync(`git checkout main 2>/dev/null || git checkout master`, { cwd: peer.clone, stdio: 'pipe' });
+        execSync(`git pull --ff-only 2>/dev/null || true`, { cwd: peer.clone, stdio: 'pipe' });
+        
+        // 2. Create branch in peer's clone
+        execSync(`git checkout -b ${branchName} 2>/dev/null || git checkout ${branchName}`, { cwd: peer.clone, stdio: 'pipe' });
+        
+        // 3. Copy thread to peer's threads/adhoc/ (standardized location)
+        const peerThreadDir = path.join(peer.clone, 'threads', 'adhoc');
+        if (!fs.existsSync(peerThreadDir)) {
+          fs.mkdirSync(peerThreadDir, { recursive: true });
+        }
+        const peerThreadPath = path.join(peerThreadDir, t.file);
+        fs.copyFileSync(t.path, peerThreadPath);
+        
+        // 4. Commit and push
+        execSync(`git add "threads/adhoc/${t.file}"`, { cwd: peer.clone, stdio: 'pipe' });
+        execSync(`git commit -m "${name}: ${threadName}"`, { cwd: peer.clone, stdio: 'pipe' });
+        execSync(`git push -u origin ${branchName} -f`, { cwd: peer.clone, stdio: 'pipe' });
+        
+        // 5. Return to main
+        execSync(`git checkout main 2>/dev/null || git checkout master`, { cwd: peer.clone, stdio: 'pipe' });
+        
+        // Move to sent/
+        const sentPath = path.join(sentDir, t.file);
+        const sentContent = updateFrontmatter(t.content, { sent: new Date().toISOString() });
+        fs.writeFileSync(sentPath, sentContent);
+        fs.unlinkSync(t.path);
+        
+        logAction(hubPath, 'outbox.send', { to, thread: t.file, branch: branchName, clone: peer.clone, result: 'ok' });
+        ok(`Sent to ${to}: ${t.file}`);
+      } catch (err) {
+        logAction(hubPath, 'outbox.send', { to, thread: t.file, result: 'error', error: err.message });
+        fail(`Failed to send ${t.file}: ${err.message}`);
+        execSync(`git checkout main 2>/dev/null || true`, { cwd: hubPath, stdio: 'pipe' });
+      }
+    }
+    
+    ok('Outbox flush complete');
+  }
+}
+
+// Commit command — agent requests, cn executes
+function runCommit(hubPath, name, message) {
+  // Check for uncommitted changes
+  const status = execSync('git status --porcelain', { cwd: hubPath, encoding: 'utf8' }).trim();
+  
+  if (!status) {
+    info('Nothing to commit');
+    return;
+  }
+  
+  // Default message if none provided
+  if (!message || message.trim() === '') {
+    message = `${name}: auto-commit ${new Date().toISOString().slice(0, 10)}`;
+  }
+  
+  try {
+    // Stage all changes
+    execSync('git add -A', { cwd: hubPath, stdio: 'pipe' });
+    
+    // Commit
+    execSync(`git commit -m "${message.replace(/"/g, '\\"')}"`, { cwd: hubPath, stdio: 'pipe' });
+    
+    logAction(hubPath, 'commit', { message, result: 'ok' });
+    ok(`Committed: ${message}`);
+  } catch (err) {
+    logAction(hubPath, 'commit', { message, result: 'error', error: err.message });
+    fail(`Commit failed: ${err.message}`);
+  }
+}
+
+// Push command — push to origin
+function runPush(hubPath, name) {
+  try {
+    // Get current branch
+    const branch = execSync('git branch --show-current', { cwd: hubPath, encoding: 'utf8' }).trim();
+    
+    // Push
+    execSync(`git push origin ${branch}`, { cwd: hubPath, stdio: 'pipe' });
+    
+    logAction(hubPath, 'push', { branch, result: 'ok' });
+    ok(`Pushed to origin/${branch}`);
+  } catch (err) {
+    logAction(hubPath, 'push', { result: 'error', error: err.message });
+    fail(`Push failed: ${err.message}`);
+  }
+}
+
+// Write file — agent requests, cn executes
+function runWrite(hubPath, filePath, content) {
+  if (!filePath) {
+    fail('Usage: cn write <path> <content>');
+    fail('       echo "content" | cn write <path>');
+    process.exit(1);
+  }
+  
+  // Resolve path relative to hub
+  const fullPath = path.isAbsolute(filePath) ? filePath : path.join(hubPath, filePath);
+  
+  // Security: ensure path is within hub
+  if (!fullPath.startsWith(hubPath)) {
+    fail('Path must be within hub directory');
+    process.exit(1);
+  }
+  
+  // Interpret escape sequences in content
+  content = content.replace(/\\n/g, '\n').replace(/\\t/g, '\t');
+  
+  try {
+    // Ensure parent directory exists
+    const dir = path.dirname(fullPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    
+    fs.writeFileSync(fullPath, content);
+    logAction(hubPath, 'write', { path: filePath, bytes: content.length, result: 'ok' });
+    ok(`Wrote ${filePath} (${content.length} bytes)`);
+  } catch (err) {
+    logAction(hubPath, 'write', { path: filePath, result: 'error', error: err.message });
+    fail(`Write failed: ${err.message}`);
+  }
+}
+
+// Append to file
+function runAppend(hubPath, filePath, content) {
+  if (!filePath) {
+    fail('Usage: cn append <path> <content>');
+    process.exit(1);
+  }
+  
+  const fullPath = path.isAbsolute(filePath) ? filePath : path.join(hubPath, filePath);
+  
+  if (!fullPath.startsWith(hubPath)) {
+    fail('Path must be within hub directory');
+    process.exit(1);
+  }
+  
+  // Interpret escape sequences
+  content = content.replace(/\\n/g, '\n').replace(/\\t/g, '\t');
+  
+  try {
+    fs.appendFileSync(fullPath, content);
+    logAction(hubPath, 'append', { path: filePath, bytes: content.length, result: 'ok' });
+    ok(`Appended to ${filePath} (${content.length} bytes)`);
+  } catch (err) {
+    logAction(hubPath, 'append', { path: filePath, result: 'error', error: err.message });
+    fail(`Append failed: ${err.message}`);
+  }
+}
+
+// Make directory
+function runMkdir(hubPath, dirPath) {
+  if (!dirPath) {
+    fail('Usage: cn mkdir <path>');
+    process.exit(1);
+  }
+  
+  const fullPath = path.isAbsolute(dirPath) ? dirPath : path.join(hubPath, dirPath);
+  
+  if (!fullPath.startsWith(hubPath)) {
+    fail('Path must be within hub directory');
+    process.exit(1);
+  }
+  
+  try {
+    fs.mkdirSync(fullPath, { recursive: true });
+    logAction(hubPath, 'mkdir', { path: dirPath, result: 'ok' });
+    ok(`Created ${dirPath}`);
+  } catch (err) {
+    logAction(hubPath, 'mkdir', { path: dirPath, result: 'error', error: err.message });
+    fail(`Mkdir failed: ${err.message}`);
+  }
+}
+
+// Remove file
+function runRm(hubPath, filePath) {
+  if (!filePath) {
+    fail('Usage: cn rm <path>');
+    process.exit(1);
+  }
+  
+  const fullPath = path.isAbsolute(filePath) ? filePath : path.join(hubPath, filePath);
+  
+  if (!fullPath.startsWith(hubPath)) {
+    fail('Path must be within hub directory');
+    process.exit(1);
+  }
+  
+  // Safety: don't allow deleting critical files
+  const critical = ['spec/SOUL.md', 'spec/USER.md', 'state/peers.md'];
+  const relPath = path.relative(hubPath, fullPath);
+  if (critical.includes(relPath)) {
+    fail(`Cannot delete critical file: ${relPath}`);
+    process.exit(1);
+  }
+  
+  try {
+    if (fs.existsSync(fullPath)) {
+      const stat = fs.statSync(fullPath);
+      if (stat.isDirectory()) {
+        fs.rmSync(fullPath, { recursive: true });
+      } else {
+        fs.unlinkSync(fullPath);
+      }
+      logAction(hubPath, 'rm', { path: filePath, result: 'ok' });
+      ok(`Removed ${filePath}`);
+    } else {
+      info(`${filePath} does not exist`);
+    }
+  } catch (err) {
+    logAction(hubPath, 'rm', { path: filePath, result: 'error', error: err.message });
+    fail(`Remove failed: ${err.message}`);
+  }
+}
+
+// Thread operations — agent-facing API (no file paths)
+function runThread(hubPath, name, args) {
+  const subCmd = args[0];
+  const subArgs = args.slice(1);
+  
+  switch (subCmd) {
+    case 'list':
+      threadList(hubPath, name, subArgs);
+      break;
+    case 'new':
+      threadNew(hubPath, name, subArgs);
+      break;
+    case 'show':
+      threadShow(hubPath, name, subArgs[0]);
+      break;
+    case 'reply':
+      threadReply(hubPath, name, subArgs[0], subArgs.slice(1).join(' '));
+      break;
+    case 'close':
+      threadClose(hubPath, name, subArgs[0]);
+      break;
+    case 'fetch':
+      threadFetch(hubPath, name);
+      break;
+    case 'send':
+      threadSend(hubPath, name);
+      break;
+    case 'sync':
+      threadFetch(hubPath, name);
+      threadSend(hubPath, name);
+      break;
+    default:
+      fail(`Unknown thread command: ${subCmd}`);
+      console.log('Usage: cn thread <list|new|show|reply|close|fetch|send|sync>');
+      process.exit(1);
+  }
+}
+
+// List threads
+function threadList(hubPath, name, args) {
+  const filter = args.find(a => a.startsWith('--'))?.slice(2) || 'all';
+  const dirs = {
+    inbox: path.join(hubPath, 'threads', 'inbox'),
+    outbox: path.join(hubPath, 'threads', 'outbox'),
+    daily: path.join(hubPath, 'threads', 'daily'),
+    adhoc: path.join(hubPath, 'threads', 'adhoc'),
+  };
+  
+  const listDir = (dir, prefix) => {
+    if (!fs.existsSync(dir)) return [];
+    return fs.readdirSync(dir)
+      .filter(f => f.endsWith('.md'))
+      .map(f => `${prefix}/${f.replace('.md', '')}`);
+  };
+  
+  let threads = [];
+  if (filter === 'all' || filter === 'inbox') threads.push(...listDir(dirs.inbox, 'inbox'));
+  if (filter === 'all' || filter === 'outbox') threads.push(...listDir(dirs.outbox, 'outbox'));
+  if (filter === 'all' || filter === 'daily') threads.push(...listDir(dirs.daily, 'daily'));
+  if (filter === 'all' || filter === 'adhoc') threads.push(...listDir(dirs.adhoc, 'adhoc'));
+  
+  if (threads.length === 0) {
+    info('No threads');
+  } else {
+    console.log(`Threads (${threads.length}):`);
+    threads.forEach(t => console.log(`  ${t}`));
+  }
+}
+
+// Create new thread
+function threadNew(hubPath, name, args) {
+  const title = args.find(a => !a.startsWith('--'));
+  const toFlag = args.find(a => a.startsWith('--to='))?.slice(5);
+  const isDaily = args.includes('--daily');
+  const isAdhoc = args.includes('--adhoc');
+  
+  if (!title) {
+    fail('Usage: cn thread new <title> [--to <peer>|--daily|--adhoc]');
+    process.exit(1);
+  }
+  
+  // Determine directory and ID
+  let dir, threadId, frontmatter;
+  const slug = title.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+  const today = new Date().toISOString().slice(0, 10).replace(/-/g, '');
+  
+  if (toFlag) {
+    dir = path.join(hubPath, 'threads', 'outbox');
+    threadId = `outbox/${slug}`;
+    frontmatter = `---\nto: ${toFlag}\ncreated: ${new Date().toISOString()}\n---\n\n`;
+  } else if (isDaily) {
+    dir = path.join(hubPath, 'threads', 'daily');
+    threadId = `daily/${today}`;
+    frontmatter = `---\ndate: ${today}\n---\n\n`;
+  } else if (isAdhoc) {
+    dir = path.join(hubPath, 'threads', 'adhoc');
+    threadId = `adhoc/${slug}`;
+    frontmatter = `---\ncreated: ${new Date().toISOString()}\n---\n\n`;
+  } else {
+    // Default to adhoc
+    dir = path.join(hubPath, 'threads', 'adhoc');
+    threadId = `adhoc/${slug}`;
+    frontmatter = `---\ncreated: ${new Date().toISOString()}\n---\n\n`;
+  }
+  
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  
+  const filePath = path.join(dir, `${path.basename(threadId)}.md`);
+  const content = `${frontmatter}# ${title}\n\n`;
+  
+  fs.writeFileSync(filePath, content);
+  logAction(hubPath, 'thread.new', { id: threadId, title, result: 'ok' });
+  ok(`Created thread: ${threadId}`);
+}
+
+// Show thread content
+function threadShow(hubPath, name, threadId) {
+  if (!threadId) {
+    fail('Usage: cn thread show <id>');
+    process.exit(1);
+  }
+  
+  const filePath = threadIdToPath(hubPath, threadId);
+  if (!fs.existsSync(filePath)) {
+    fail(`Thread not found: ${threadId}`);
+    process.exit(1);
+  }
+  
+  const content = fs.readFileSync(filePath, 'utf8');
+  console.log(content);
+}
+
+// Reply to thread
+function threadReply(hubPath, name, threadId, message) {
+  if (!threadId || !message) {
+    fail('Usage: cn thread reply <id> <message>');
+    process.exit(1);
+  }
+  
+  const filePath = threadIdToPath(hubPath, threadId);
+  if (!fs.existsSync(filePath)) {
+    fail(`Thread not found: ${threadId}`);
+    process.exit(1);
+  }
+  
+  // Interpret escape sequences
+  message = message.replace(/\\n/g, '\n').replace(/\\t/g, '\t');
+  
+  const timestamp = new Date().toISOString();
+  const reply = `\n\n## Reply (${timestamp})\n\n${message}`;
+  
+  fs.appendFileSync(filePath, reply);
+  logAction(hubPath, 'thread.reply', { id: threadId, bytes: message.length, result: 'ok' });
+  ok(`Replied to: ${threadId}`);
+}
+
+// Close/archive thread
+function threadClose(hubPath, name, threadId) {
+  if (!threadId) {
+    fail('Usage: cn thread close <id>');
+    process.exit(1);
+  }
+  
+  const filePath = threadIdToPath(hubPath, threadId);
+  if (!fs.existsSync(filePath)) {
+    fail(`Thread not found: ${threadId}`);
+    process.exit(1);
+  }
+  
+  const archivedDir = path.join(hubPath, 'threads', 'archived');
+  if (!fs.existsSync(archivedDir)) {
+    fs.mkdirSync(archivedDir, { recursive: true });
+  }
+  
+  const fileName = path.basename(filePath);
+  const archivedPath = path.join(archivedDir, fileName);
+  
+  // Add closed timestamp to frontmatter
+  let content = fs.readFileSync(filePath, 'utf8');
+  content = updateFrontmatter(content, { closed: new Date().toISOString() });
+  
+  fs.writeFileSync(archivedPath, content);
+  fs.unlinkSync(filePath);
+  
+  logAction(hubPath, 'thread.close', { id: threadId, result: 'ok' });
+  ok(`Closed thread: ${threadId} → archived`);
+}
+
+// Fetch inbound threads
+function threadFetch(hubPath, name) {
+  runInbox('check', hubPath, name);
+  runInbox('process', hubPath, name);
+}
+
+// Send outbound threads
+function threadSend(hubPath, name) {
+  runOutbox('flush', hubPath, name);
+}
+
+// Convert thread ID to file path
+function threadIdToPath(hubPath, threadId) {
+  // threadId format: "inbox/pi-clp" or "daily/20260205"
+  const parts = threadId.split('/');
+  if (parts.length !== 2) {
+    return path.join(hubPath, 'threads', threadId + '.md');
+  }
+  return path.join(hubPath, 'threads', parts[0], parts[1] + '.md');
+}
+
+// === CLEAN AGENT API ===
+
+// Determine cadence from thread location
+function getCadence(filePath) {
+  if (filePath.includes('/inbox/')) return 'inbox';
+  if (filePath.includes('/daily/')) return 'daily';
+  if (filePath.includes('/weekly/')) return 'weekly';
+  if (filePath.includes('/monthly/')) return 'monthly';
+  if (filePath.includes('/quarterly/')) return 'quarterly';
+  if (filePath.includes('/yearly/')) return 'yearly';
+  if (filePath.includes('/adhoc/')) return 'adhoc';
+  if (filePath.includes('/doing/')) return 'doing';
+  if (filePath.includes('/deferred/')) return 'deferred';
+  if (filePath.includes('/outbox/')) return 'outbox';
+  return 'unknown';
+}
+
+// Get next inbox item (for agent processing)
+function getNextInboxItem(hubPath) {
+  const inboxDir = path.join(hubPath, 'threads', 'inbox');
+  if (!fs.existsSync(inboxDir)) return null;
+  
+  const threads = fs.readdirSync(inboxDir).filter(f => f.endsWith('.md'));
+  if (threads.length === 0) return null;
+  
+  // Return first item (FIFO)
+  const f = threads[0];
+  const filePath = path.join(inboxDir, f);
+  const content = fs.readFileSync(filePath, 'utf8');
+  const meta = parseFrontmatter(content);
+  
+  return {
+    id: f.replace('.md', ''),
+    cadence: 'inbox',
+    from: meta.from || 'unknown',
+    content: content,
+    path: filePath
+  };
+}
+
+// List inbox (threads needing triage)
+function listInbox(hubPath, name) {
+  const inboxDir = path.join(hubPath, 'threads', 'inbox');
+  if (!fs.existsSync(inboxDir)) {
+    console.log('(empty)');
+    return;
+  }
+  
+  const threads = fs.readdirSync(inboxDir).filter(f => f.endsWith('.md'));
+  if (threads.length === 0) {
+    console.log('(empty)');
+    return;
+  }
+  
+  threads.forEach(f => {
+    const id = f.replace('.md', '');
+    const content = fs.readFileSync(path.join(inboxDir, f), 'utf8');
+    const meta = parseFrontmatter(content);
+    const from = meta.from || 'unknown';
+    const title = content.match(/^#\s+(.+)$/m)?.[1] || id;
+    console.log(`${from}/${id}  "${title}"`);
+  });
+}
+
+// List outbox (pending sends)
+function listOutbox(hubPath, name) {
+  const outboxDir = path.join(hubPath, 'threads', 'outbox');
+  if (!fs.existsSync(outboxDir)) {
+    console.log('(empty)');
+    return;
+  }
+  
+  const threads = fs.readdirSync(outboxDir).filter(f => f.endsWith('.md'));
+  if (threads.length === 0) {
+    console.log('(empty)');
+    return;
+  }
+  
+  threads.forEach(f => {
+    const id = f.replace('.md', '');
+    const content = fs.readFileSync(path.join(outboxDir, f), 'utf8');
+    const meta = parseFrontmatter(content);
+    const to = meta.to || 'unknown';
+    const title = content.match(/^#\s+(.+)$/m)?.[1] || id;
+    console.log(`→ ${to}  "${title}"`);
+  });
+}
+
+// Read thread content (with cadence metadata)
+function readThread(hubPath, threadId) {
+  if (!threadId) {
+    fail('Usage: cn read <thread>');
+    process.exit(1);
+  }
+  
+  const filePath = findThread(hubPath, threadId);
+  if (!filePath) {
+    fail(`Thread not found: ${threadId}`);
+    process.exit(1);
+  }
+  
+  const content = fs.readFileSync(filePath, 'utf8');
+  const cadence = getCadence(filePath);
+  const meta = parseFrontmatter(content);
+  
+  // Output with cadence header
+  console.log(`[cadence: ${cadence}]`);
+  if (meta.from) console.log(`[from: ${meta.from}]`);
+  if (meta.to) console.log(`[to: ${meta.to}]`);
+  console.log('');
+  console.log(content);
+}
+
+// Reply to thread
+function replyThread(hubPath, name, threadId, message) {
+  if (!threadId || !message) {
+    fail('Usage: cn reply <thread> <message>');
+    process.exit(1);
+  }
+  
+  const filePath = findThread(hubPath, threadId);
+  if (!filePath) {
+    fail(`Thread not found: ${threadId}`);
+    process.exit(1);
+  }
+  
+  message = message.replace(/\\n/g, '\n').replace(/\\t/g, '\t');
+  const timestamp = new Date().toISOString();
+  const reply = `\n\n## Reply (${timestamp})\n\n${message}`;
+  
+  fs.appendFileSync(filePath, reply);
+  logAction(hubPath, 'reply', { thread: threadId, bytes: message.length });
+  ok(`Replied to ${threadId}`);
+}
+
+// Send message to peer (creates outbox thread)
+function sendToPeer(hubPath, name, peer, message) {
+  if (!peer || !message) {
+    fail('Usage: cn send <peer> <message>');
+    process.exit(1);
+  }
+  
+  const outboxDir = path.join(hubPath, 'threads', 'outbox');
+  if (!fs.existsSync(outboxDir)) {
+    fs.mkdirSync(outboxDir, { recursive: true });
+  }
+  
+  const slug = message.slice(0, 30).toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+  const fileName = `${slug}.md`;
+  const filePath = path.join(outboxDir, fileName);
+  
+  message = message.replace(/\\n/g, '\n').replace(/\\t/g, '\t');
+  const content = `---
+to: ${peer}
+created: ${new Date().toISOString()}
+---
+
+# ${message.split('\n')[0]}
+
+${message}
+`;
+  
+  fs.writeFileSync(filePath, content);
+  logAction(hubPath, 'send', { to: peer, thread: slug });
+  ok(`Created message to ${peer}: ${slug}`);
+  info('Run "cn sync" to send');
+}
+
+// GTD: Delete (discard thread)
+function gtdDelete(hubPath, name, threadId) {
+  if (!threadId) {
+    fail('Usage: cn delete <thread>');
+    process.exit(1);
+  }
+  
+  const filePath = findThread(hubPath, threadId);
+  if (!filePath) {
+    fail(`Thread not found: ${threadId}`);
+    process.exit(1);
+  }
+  
+  fs.unlinkSync(filePath);
+  logAction(hubPath, 'gtd.delete', { thread: threadId });
+  ok(`Deleted: ${threadId}`);
+}
+
+// GTD: Defer (postpone - move to deferred/)
+function gtdDefer(hubPath, name, threadId, until) {
+  if (!threadId) {
+    fail('Usage: cn defer <thread> [until]');
+    process.exit(1);
+  }
+  
+  const filePath = findThread(hubPath, threadId);
+  if (!filePath) {
+    fail(`Thread not found: ${threadId}`);
+    process.exit(1);
+  }
+  
+  const deferredDir = path.join(hubPath, 'threads', 'deferred');
+  if (!fs.existsSync(deferredDir)) {
+    fs.mkdirSync(deferredDir, { recursive: true });
+  }
+  
+  let content = fs.readFileSync(filePath, 'utf8');
+  content = updateFrontmatter(content, { deferred: new Date().toISOString(), until: until || 'unspecified' });
+  
+  const destPath = path.join(deferredDir, path.basename(filePath));
+  fs.writeFileSync(destPath, content);
+  fs.unlinkSync(filePath);
+  
+  logAction(hubPath, 'gtd.defer', { thread: threadId, until });
+  ok(`Deferred: ${threadId}` + (until ? ` until ${until}` : ''));
+}
+
+// GTD: Delegate (forward to peer)
+function gtdDelegate(hubPath, name, threadId, peer) {
+  if (!threadId || !peer) {
+    fail('Usage: cn delegate <thread> <peer>');
+    process.exit(1);
+  }
+  
+  const filePath = findThread(hubPath, threadId);
+  if (!filePath) {
+    fail(`Thread not found: ${threadId}`);
+    process.exit(1);
+  }
+  
+  // Read content and create outbox item
+  let content = fs.readFileSync(filePath, 'utf8');
+  content = updateFrontmatter(content, { to: peer, delegated: new Date().toISOString(), 'delegated-by': name });
+  
+  const outboxDir = path.join(hubPath, 'threads', 'outbox');
+  if (!fs.existsSync(outboxDir)) {
+    fs.mkdirSync(outboxDir, { recursive: true });
+  }
+  
+  const destPath = path.join(outboxDir, path.basename(filePath));
+  fs.writeFileSync(destPath, content);
+  fs.unlinkSync(filePath);
+  
+  logAction(hubPath, 'gtd.delegate', { thread: threadId, to: peer });
+  ok(`Delegated to ${peer}: ${threadId}`);
+  info('Run "cn sync" to send');
+}
+
+// GTD: Do (claim - move to doing/)
+function gtdDo(hubPath, name, threadId) {
+  if (!threadId) {
+    fail('Usage: cn do <thread>');
+    process.exit(1);
+  }
+  
+  const filePath = findThread(hubPath, threadId);
+  if (!filePath) {
+    fail(`Thread not found: ${threadId}`);
     process.exit(1);
   }
-  const args = [inboxJs, subCmd, hubPath, name];
-  const result = spawn('node', args, { stdio: 'inherit' });
-  result.on('close', (code) => process.exit(code));
+  
+  const doingDir = path.join(hubPath, 'threads', 'doing');
+  if (!fs.existsSync(doingDir)) {
+    fs.mkdirSync(doingDir, { recursive: true });
+  }
+  
+  let content = fs.readFileSync(filePath, 'utf8');
+  content = updateFrontmatter(content, { started: new Date().toISOString() });
+  
+  const destPath = path.join(doingDir, path.basename(filePath));
+  fs.writeFileSync(destPath, content);
+  fs.unlinkSync(filePath);
+  
+  logAction(hubPath, 'gtd.do', { thread: threadId });
+  ok(`Started: ${threadId}`);
+}
+
+// GTD: Done (complete - archive)
+function gtdDone(hubPath, name, threadId) {
+  if (!threadId) {
+    fail('Usage: cn done <thread>');
+    process.exit(1);
+  }
+  
+  const filePath = findThread(hubPath, threadId);
+  if (!filePath) {
+    fail(`Thread not found: ${threadId}`);
+    process.exit(1);
+  }
+  
+  const archivedDir = path.join(hubPath, 'threads', 'archived');
+  if (!fs.existsSync(archivedDir)) {
+    fs.mkdirSync(archivedDir, { recursive: true });
+  }
+  
+  let content = fs.readFileSync(filePath, 'utf8');
+  content = updateFrontmatter(content, { completed: new Date().toISOString() });
+  
+  const destPath = path.join(archivedDir, path.basename(filePath));
+  fs.writeFileSync(destPath, content);
+  fs.unlinkSync(filePath);
+  
+  logAction(hubPath, 'gtd.done', { thread: threadId });
+  ok(`Completed: ${threadId} → archived`);
+}
+
+// Find thread across all locations
+function findThread(hubPath, threadId) {
+  // Direct path format (inbox/foo)
+  if (threadId.includes('/')) {
+    const direct = threadIdToPath(hubPath, threadId);
+    if (fs.existsSync(direct)) return direct;
+  }
+  
+  // Search in all locations
+  const locations = ['inbox', 'outbox', 'doing', 'deferred', 'daily', 'adhoc'];
+  for (const loc of locations) {
+    const tryPath = path.join(hubPath, 'threads', loc, threadId + '.md');
+    if (fs.existsSync(tryPath)) return tryPath;
+  }
+  
+  return null;
+}
+
+// Parse YAML frontmatter
+function parseFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return {};
+  const yaml = match[1];
+  const meta = {};
+  yaml.split('\n').forEach(line => {
+    const [key, ...rest] = line.split(':');
+    if (key && rest.length) {
+      meta[key.trim().toLowerCase()] = rest.join(':').trim();
+    }
+  });
+  return meta;
+}
+
+// Update frontmatter field
+function updateFrontmatter(content, updates) {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) {
+    // No frontmatter, add it
+    const lines = Object.entries(updates).map(([k, v]) => `${k}: ${v}`).join('\n');
+    return `---\n${lines}\n---\n\n${content}`;
+  }
+  let yaml = match[1];
+  for (const [key, val] of Object.entries(updates)) {
+    const regex = new RegExp(`^${key}:.*$`, 'm');
+    if (regex.test(yaml)) {
+      yaml = yaml.replace(regex, `${key}: ${val}`);
+    } else {
+      yaml += `\n${key}: ${val}`;
+    }
+  }
+  return content.replace(/^---\n[\s\S]*?\n---/, `---\n${yaml}\n---`);
+}
+
+// Parse outbox.md table
+function parseOutbox(content) {
+  const items = [];
+  const lines = content.split('\n');
+  let inTable = false;
+  
+  for (const line of lines) {
+    if (line.startsWith('| To')) {
+      inTable = true;
+      continue;
+    }
+    if (line.startsWith('|--')) continue;
+    if (!inTable || !line.startsWith('|')) continue;
+    
+    const cols = line.split('|').map(c => c.trim()).filter(c => c);
+    if (cols.length >= 3) {
+      items.push({
+        to: cols[0],
+        thread: cols[1],
+        status: cols[2] || 'pending',
+        sent: cols[3] || null
+      });
+    }
+  }
+  return items;
+}
+
+// Write outbox.md
+function writeOutbox(outboxPath, items) {
+  let content = `# Outbox
+
+Agent writes pending sends here. cn reads and executes.
+
+| To | Thread | Status | Sent |
+|----|--------|--------|------|
+`;
+  for (const item of items) {
+    content += `| ${item.to} | ${item.thread} | ${item.status} | ${item.sent || '—'} |\n`;
+  }
+  fs.writeFileSync(outboxPath, content);
+}
+
+// Parse peers.md
+function parsePeers(content) {
+  const peers = {};
+  // Match each peer block
+  const blocks = content.split(/(?=- name:)/);
+  for (const block of blocks) {
+    const nameMatch = block.match(/- name:\s*(\S+)/);
+    if (!nameMatch) continue;
+    const name = nameMatch[1];
+    const hubMatch = block.match(/hub:\s*(\S+)/);
+    const cloneMatch = block.match(/clone:\s*(\S+)/);
+    peers[name] = { 
+      name, 
+      hub: hubMatch ? hubMatch[1] : null,
+      clone: cloneMatch ? cloneMatch[1] : null
+    };
+  }
+  return peers;
 }
 
 // Doctor command
@@ -276,26 +1446,40 @@ function writeRuntimeMd(hubPath, cnVersion) {
     fs.mkdirSync(stateDir, { recursive: true });
   }
   
-  // Get template info
+  // Get template version and commit
   let templateVersion = 'unknown';
-  let templateCommit = 'unknown';
+  let cnCommit = 'unknown';
+  const cnDir = path.join(__dirname, '..');
   try {
-    const pkgPath = path.join(__dirname, '..', 'package.json');
+    const pkgPath = path.join(cnDir, 'package.json');
     if (fs.existsSync(pkgPath)) {
       const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
       templateVersion = pkg.version || 'unknown';
     }
-    templateCommit = execSync('git rev-parse --short HEAD 2>/dev/null || echo unknown', { 
+    cnCommit = execSync('git rev-parse --short HEAD 2>/dev/null', { 
       encoding: 'utf8', 
-      cwd: hubPath 
-    }).trim();
+      cwd: cnDir 
+    }).trim() || 'unknown';
   } catch {}
   
-  // Gather runtime info
-  const nodeVersion = process.version;
-  const platform = `${process.platform} ${process.arch}`;
+  // Gather runtime info (agent-relevant only)
   const hubName = deriveName(hubPath);
   
+  // Hub commit hash
+  let hubCommit = 'unknown';
+  try {
+    hubCommit = execSync('git rev-parse --short HEAD 2>/dev/null', { 
+      encoding: 'utf8', 
+      cwd: hubPath 
+    }).trim() || 'unknown';
+  } catch {}
+  
+  // OpenClaw version
+  let openclawVersion = 'not installed';
+  try {
+    openclawVersion = execSync('openclaw --version 2>/dev/null', { encoding: 'utf8' }).trim();
+  } catch {}
+  
   let peerCount = 0;
   try {
     const peersPath = path.join(hubPath, 'state', 'peers.md');
@@ -312,12 +1496,11 @@ Auto-generated by \`cn update\`. Do not edit manually.
 \`\`\`yaml
 session_start: ${new Date().toISOString()}
 cn_version: ${cnVersion}
+cn_commit: ${cnCommit}
 template_version: ${templateVersion}
-template_commit: ${templateCommit}
-node_version: ${nodeVersion}
-platform: ${platform}
+openclaw_version: ${openclawVersion}
 hub_name: ${hubName}
-hub_path: ${hubPath}
+hub_commit: ${hubCommit}
 peer_count: ${peerCount}
 \`\`\`
 `;
@@ -348,13 +1531,98 @@ switch (command) {
     doctor(hubPath);
     break;
     
-  case 'inbox':
-    const subCmd = subArgs[0] || 'check';
-    if (!['check', 'process', 'flush'].includes(subCmd)) {
-      fail(`Unknown inbox command: ${subCmd}`);
-      process.exit(1);
+  // === CORE AGENT API ===
+  
+  case 'next':
+    // Get next inbox item for agent processing
+    const nextItem = getNextInboxItem(hubPath);
+    if (!nextItem) {
+      console.log('(inbox empty)');
+    } else {
+      console.log(`[cadence: ${nextItem.cadence}]`);
+      console.log(`[from: ${nextItem.from}]`);
+      console.log(`[id: ${nextItem.id}]`);
+      console.log('');
+      console.log(nextItem.content);
     }
-    runInbox(subCmd, hubPath, name);
+    break;
+    
+  case 'inbox':
+    // List threads in inbox
+    listInbox(hubPath, name);
+    break;
+    
+  case 'outbox':
+    // List pending outbound
+    listOutbox(hubPath, name);
+    break;
+    
+  case 'read':
+    // Read thread content
+    readThread(hubPath, subArgs[0]);
+    break;
+    
+  case 'reply':
+    // Reply to thread
+    replyThread(hubPath, name, subArgs[0], subArgs.slice(1).join(' '));
+    break;
+    
+  case 'send':
+    // Send message to peer
+    sendToPeer(hubPath, name, subArgs[0], subArgs.slice(1).join(' '));
+    break;
+    
+  // === GTD VERBS ===
+    
+  case 'delete':
+    gtdDelete(hubPath, name, subArgs[0]);
+    break;
+    
+  case 'defer':
+    gtdDefer(hubPath, name, subArgs[0], subArgs[1]);
+    break;
+    
+  case 'delegate':
+    gtdDelegate(hubPath, name, subArgs[0], subArgs[1]);
+    break;
+    
+  case 'do':
+    gtdDo(hubPath, name, subArgs[0]);
+    break;
+    
+  case 'done':
+    gtdDone(hubPath, name, subArgs[0]);
+    break;
+    
+  // === SYNC ===
+    
+  case 'sync':
+    info('Syncing...');
+    runInbox('check', hubPath, name);
+    runInbox('process', hubPath, name);
+    runOutbox('flush', hubPath, name);
+    ok('Sync complete');
+    break;
+    
+  // === GIT OPS (low-level) ===
+    
+  case 'commit':
+    runCommit(hubPath, name, subArgs.join(' '));
+    break;
+    
+  case 'push':
+    runPush(hubPath, name);
+    break;
+    
+  case 'save':
+    runCommit(hubPath, name, subArgs.join(' ') || `${name}: save ${new Date().toISOString().slice(0, 16)}`);
+    runPush(hubPath, name);
+    break;
+    
+  // === LEGACY (keep for now) ===
+  
+  case 'thread':
+    runThread(hubPath, name, subArgs);
     break;
     
   default:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cnagent",
-  "version": "2.0.7",
+  "version": "2.1.0",
   "description": "Coherent Network agent CLI — everything runs through cn",
   "keywords": [
     "cn-agent",