clamper-ai 1.1.6

package/src/status.mjs

@@ -0,0 +1,43 @@
+import { existsSync, readFileSync, readdirSync } from 'fs';
+import { join } from 'path';
+import { c, log, detectWorkspace } from './utils.mjs';
+
+export function runStatus() {
+  const workspace = detectWorkspace();
+  if (!workspace) {
+    log.err('No workspace detected. Set CLAMPER_WORKSPACE or run from ~/.openclaw/workspace');
+    process.exit(1);
+  }
+
+  const configPath = join(workspace, 'skills', '.clamper', 'config.json');
+  let config = {};
+  if (existsSync(configPath)) {
+    try { config = JSON.parse(readFileSync(configPath, 'utf8')); } catch { /* ignore */ }
+  }
+
+  const hasAgents = existsSync(join(workspace, 'AGENTS.md'));
+  const hasMemory = existsSync(join(workspace, 'MEMORY.md'));
+  const hasCron = existsSync(join(workspace, 'scripts/nightly-consolidation.sh'));
+
+  let skillCount = 0;
+  const skillsDir = join(workspace, 'skills');
+  if (existsSync(skillsDir)) {
+    skillCount = readdirSync(skillsDir, { withFileTypes: true })
+      .filter(d => d.isDirectory() && d.name !== '.clamper' && d.name !== '.clawhub')
+      .length;
+  }
+
+  const check = (ok) => ok ? `${c.green}✔${c.reset}` : `${c.red}✖${c.reset}`;
+
+  console.log(`\n${c.bold}${c.cyan}🧰 Clamper Status${c.reset}\n`);
+  console.log(`  Workspace:  ${workspace}`);
+  console.log(`  Agent:      ${config.agentName || 'Unknown'}`);
+  console.log(`  Tier:       ${config.tier || 'free'}`);
+  console.log(`  Version:    ${config.version || 'unknown'}`);
+  console.log(`  Installed:  ${config.installedAt || 'unknown'}\n`);
+  console.log(`  ${check(hasAgents)} AGENTS.md`);
+  console.log(`  ${check(hasMemory)} Memory system`);
+  console.log(`  ${check(hasCron)} Nightly consolidation`);
+  console.log(`  ${check(skillCount > 0)} Skills (${skillCount} installed)`);
+  console.log();
+}

package/src/sync.mjs

@@ -0,0 +1,585 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { execSync } from 'child_process';
+import { c, log, detectWorkspace } from './utils.mjs';
+
+const API_BASE = 'https://clamper-api.vercel.app';
+
+function getApiKey() {
+  return process.env.CLAMPER_API_KEY || '';
+}
+
+// --- Connected Accounts: parse from TOOLS.md ---
+
+const SERVICE_PATTERNS = [
+  { key: 'google_sheets', names: ['Google Sheets'], patterns: [/Google Sheets.*?(?:Connection|ID).*?[:`]\s*`?([0-9a-f-]{20,})/i] },
+  { key: 'google_docs', names: ['Google Docs'], patterns: [/Google Docs.*?(?:Connection|ID).*?[:`]\s*`?([0-9a-f-]{20,})/i] },
+  { key: 'twitter', names: ['Twitter', 'X API', '@Clamper'], patterns: [/(?:Consumer|API)\s*Key.*?[:`]\s*`?([A-Za-z0-9]{20,})/i, /Bearer.*?[:`]\s*`?(AAAA[^\s`]+)/i] },
+  { key: 'stripe', names: ['Stripe'], patterns: [/(?:Secret|Publishable).*?[:`]\s*`?([sp]k_[^\s`]+)/i] },
+  { key: 'openai', names: ['OpenAI', 'Sora API'], patterns: [/(?:Key|API).*?[:`]\s*`?(sk-proj-[^\s`]+)/i, /(?:Key|API).*?[:`]\s*`?(sk-[^\s`]+)/i] },
+  { key: 'anthropic', names: ['Anthropic', 'Claude API'], patterns: [/(?:Key|API).*?[:`]\s*`?(sk-ant-[^\s`]+)/i] },
+  { key: 'brave_search', names: ['Brave Search', 'Brave API'], patterns: [/Brave.*(?:Key|API).*?[:`]\s*`?([^\s`]+)/i] },
+  { key: 'telegram', names: ['Telegram'], patterns: [/Telegram.*(?:Token|Bot).*?[:`]\s*`?(\d+:[^\s`]+)/i] },
+  { key: 'discord', names: ['Discord'], patterns: [/Discord.*(?:Token|Bot).*?[:`]\s*`?([^\s`]+)/i] },
+  { key: 'github', names: ['GitHub'], patterns: [/\*\*PAT:\*\*\s*`?(ghp_[^\s`]+)/i, /github.*(?:Token|PAT).*?`?(ghp_[^\s`]+)/i] },
+  { key: 'email', names: ['Email', 'IMAP', 'SMTP'], patterns: [/\*\*Email:\*\*\s*`?([^\s`]+@[^\s`]+)/i, /App Password.*?[:`]\s*`?([a-z ]{10,})/i] },
+  { key: 'sogni', names: ['Sogni'], patterns: [/SOGNI_USERNAME.*?["'`]\s*([^\s"'`]+)/i, /SOGNI_PASSWORD.*?["'`]\s*([^\s"'`]+)/i] },
+  { key: 'upload_post', names: ['Upload-Post', 'upload-post'], patterns: [/\*\*API Key:\*\*\s*`?(ey[^\s`]+)/i, /upload-post.*?Key.*?`?(ey[^\s`]+)/i] },
+  { key: 'vercel', names: ['Vercel'], patterns: [/(?:Token|token).*?`?(vcp_[^\s`]+)/i, /--token\s+(vcp_[^\s`]+)/i] },
+  { key: 'netlify', names: ['Netlify'], patterns: [/(?:Site ID|site).*?`?([0-9a-f]{8}-[0-9a-f-]{27,})/i] },
+  { key: 'maton', names: ['Maton', 'Google Workspace'], patterns: [/MATON_API_KEY.*?`?([A-Za-z0-9_-]{30,})/i] },
+];
+
+function parseAccountsFromTools(workspace) {
+  const accounts = {};
+  
+  // Read TOOLS.md
+  const toolsPath = join(workspace, 'TOOLS.md');
+  let toolsContent = '';
+  if (existsSync(toolsPath)) {
+    toolsContent = readFileSync(toolsPath, 'utf8');
+  }
+  
+  // Also check docs/tool-configs.md (some users split configs there)
+  const extPath = join(workspace, 'docs', 'tool-configs.md');
+  if (existsSync(extPath)) {
+    toolsContent += '\n' + readFileSync(extPath, 'utf8');
+  }
+
+  if (!toolsContent) return accounts;
+
+  for (const svc of SERVICE_PATTERNS) {
+    // First check if service is even mentioned
+    const mentioned = svc.names.some(n => toolsContent.includes(n));
+    if (!mentioned) continue;
+
+    // Try to extract a credential
+    let credential = '';
+    for (const pat of svc.patterns) {
+      const match = toolsContent.match(pat);
+      if (match) {
+        credential = match[1];
+        break;
+      }
+    }
+
+    if (credential) {
+      accounts[svc.key] = {
+        credential,
+        label: svc.names[0],
+        connectedAt: new Date().toISOString(),
+      };
+    } else {
+      // Service mentioned but no credential extracted — mark as connected without exposing key
+      accounts[svc.key] = {
+        credential: 'configured',
+        label: svc.names[0],
+        connectedAt: new Date().toISOString(),
+      };
+    }
+  }
+
+  return accounts;
+}
+
+// --- Apply pending changes from dashboard back to TOOLS.md ---
+
+function applyPendingChanges(workspace, changes, quiet) {
+  if (!changes || changes.length === 0) return;
+
+  const toolsPath = join(workspace, 'TOOLS.md');
+  let tools = existsSync(toolsPath) ? readFileSync(toolsPath, 'utf8') : '# TOOLS.md - Quick Reference\n';
+
+  // Also handle docs/tool-configs.md for detailed configs
+  const extPath = join(workspace, 'docs', 'tool-configs.md');
+  let extTools = existsSync(extPath) ? readFileSync(extPath, 'utf8') : '';
+
+  let toolsChanged = false;
+  let extChanged = false;
+
+  for (const change of changes) {
+    if (change.type === 'connect_account' && change.service && change.credential) {
+      const svcDef = SERVICE_PATTERNS.find(s => s.key === change.service);
+      const label = change.label || svcDef?.names[0] || change.service;
+      const section = `\n## ${label}\n- **API Key:** \`${change.credential}\`\n- **Added via:** Clamper Dashboard (${new Date(change.timestamp).toISOString().slice(0, 10)})\n`;
+
+      // Add to docs/tool-configs.md if it exists, otherwise TOOLS.md
+      if (extTools) {
+        extTools += section;
+        extChanged = true;
+      } else {
+        tools += section;
+        toolsChanged = true;
+      }
+
+      if (!quiet) log.ok(`Added ${label} credentials to ${extTools ? 'docs/tool-configs.md' : 'TOOLS.md'}`);
+    }
+
+    if (change.type === 'disconnect_account' && change.service) {
+      const svcDef = SERVICE_PATTERNS.find(s => s.key === change.service);
+      const label = svcDef?.names[0] || change.service;
+      if (!quiet) log.warn(`Dashboard requested disconnect of ${label} — manual removal recommended`);
+      // We don't auto-delete credentials from files for safety
+    }
+
+    if (change.type === 'preferences_update' && change.preferences) {
+      // Update IDENTITY.md agent name
+      if (change.preferences.agentName) {
+        const idPath = join(workspace, 'IDENTITY.md');
+        if (existsSync(idPath)) {
+          let id = readFileSync(idPath, 'utf8');
+          id = id.replace(/(\*\*Name:\*\*\s*).+/, `$1${change.preferences.agentName}`);
+          writeFileSync(idPath, id);
+          if (!quiet) log.ok(`Updated agent name to "${change.preferences.agentName}" in IDENTITY.md`);
+        }
+      }
+
+      // Update USER.md timezone
+      if (change.preferences.timezone) {
+        const userPath = join(workspace, 'USER.md');
+        if (existsSync(userPath)) {
+          let user = readFileSync(userPath, 'utf8');
+          user = user.replace(/(Timezone:\s*)\S+/i, `$1${change.preferences.timezone}`);
+          writeFileSync(userPath, user);
+          if (!quiet) log.ok(`Updated timezone to "${change.preferences.timezone}" in USER.md`);
+        }
+      }
+    }
+
+    if (change.type === 'model_switch' && change.model) {
+      if (!quiet) log.info(`Model switch requested: ${change.model} (agent should pick this up)`);
+    }
+
+    // Toggle preferences → write to config so agent respects them
+    if (change.type === 'preferences_update' && change.preferences) {
+      const p = change.preferences;
+      const cfgDir = join(workspace, 'skills', '.clamper');
+      const cfgPath = join(cfgDir, 'config.json');
+      let cfg = {};
+      if (existsSync(cfgPath)) try { cfg = JSON.parse(readFileSync(cfgPath, 'utf8')); } catch {}
+
+      if (p.emailChecking !== undefined) { cfg.emailChecking = p.emailChecking; if (!quiet) log.ok(`Email checking ${p.emailChecking ? 'enabled' : 'disabled'}`); }
+      if (p.socialMonitoring !== undefined) { cfg.socialMonitoring = p.socialMonitoring; if (!quiet) log.ok(`Social monitoring ${p.socialMonitoring ? 'enabled' : 'disabled'}`); }
+
+      // Quick actions → write flag for agent
+      if (p.quickAction) {
+        const logsDir = join(workspace, 'logs');
+        if (!existsSync(logsDir)) mkdirSync(logsDir, { recursive: true });
+        writeFileSync(join(logsDir, 'quick-action.flag'), JSON.stringify({ action: p.quickAction, timestamp: change.timestamp }));
+        if (!quiet) log.ok(`Quick action queued: ${p.quickAction}`);
+      }
+
+      if (!existsSync(cfgDir)) mkdirSync(cfgDir, { recursive: true });
+      writeFileSync(cfgPath, JSON.stringify(cfg, null, 2));
+    }
+
+    if (change.type === 'clear_context' || (change.type === 'preferences_update' && change.preferences?.clearContext)) {
+      const flagPath = join(workspace, 'logs', 'clear-context.flag');
+      const logsDir = join(workspace, 'logs');
+      if (!existsSync(logsDir)) mkdirSync(logsDir, { recursive: true });
+      writeFileSync(flagPath, JSON.stringify({ requested: change.timestamp || new Date().toISOString(), source: 'dashboard' }));
+      if (!quiet) log.ok('Clear context requested — flag written to logs/clear-context.flag');
+    }
+  }
+
+  if (toolsChanged) writeFileSync(toolsPath, tools);
+  if (extChanged) writeFileSync(extPath, extTools);
+}
+
+// --- Gather full state ---
+
+function gatherState(workspace) {
+  // Get OpenClaw version
+  let openclawVersion = '';
+  try {
+    openclawVersion = execSync('openclaw --version 2>/dev/null', { encoding: 'utf8' }).trim();
+  } catch { /* ignore */ }
+
+  const state = {
+    model: '',
+    uptime: '',
+    openclawVersion,
+    contextUsage: '',
+    cronJobs: [],
+    connectedAccounts: {},
+    recentActivity: [],
+    preferences: { timezone: 'UTC', heartbeatInterval: 30, defaultModel: '', costTarget: 6 },
+    skills: [],
+    memory: { dailyNotes: 0, knowledgeFiles: 0, memoryMdSize: '0KB', lastConsolidation: null },
+  };
+
+  // Config
+  const configPath = join(workspace, 'skills', '.clamper', 'config.json');
+  let config = {};
+  if (existsSync(configPath)) {
+    try { config = JSON.parse(readFileSync(configPath, 'utf8')); } catch {}
+  }
+
+  state.preferences.agentName = config.agentName || '';
+  state.preferences.defaultModel = config.defaultModel || '';
+  state.preferences.emailChecking = config.emailChecking || false;
+  state.preferences.socialMonitoring = config.socialMonitoring || false;
+
+  // Identity
+  const idPath = join(workspace, 'IDENTITY.md');
+  if (existsSync(idPath)) {
+    const id = readFileSync(idPath, 'utf8');
+    const nameMatch = id.match(/\*\*Name:\*\*\s*(.+)/);
+    if (nameMatch) state.preferences.agentName = nameMatch[1].trim();
+  }
+
+  // User preferences
+  const userPath = join(workspace, 'USER.md');
+  if (existsSync(userPath)) {
+    const user = readFileSync(userPath, 'utf8');
+    const tzMatch = user.match(/Timezone:\s*(\S+)/i);
+    if (tzMatch) state.preferences.timezone = tzMatch[1];
+  }
+
+  // Connected accounts from TOOLS.md + docs/tool-configs.md
+  state.connectedAccounts = parseAccountsFromTools(workspace);
+
+  // Also pull from OpenClaw gateway config
+  try {
+    const gwPath = join(process.env.HOME || '', '.openclaw', 'openclaw.json');
+    if (existsSync(gwPath)) {
+      const gw = JSON.parse(readFileSync(gwPath, 'utf8'));
+
+      // Telegram bot
+      const tgToken = gw.channels?.telegram?.botToken;
+      if (tgToken && !state.connectedAccounts.telegram) {
+        state.connectedAccounts.telegram = {
+          credential: tgToken === '__OPENCLAW_REDACTED__' ? 'configured (gateway)' : tgToken,
+          label: 'Telegram Bot',
+          connectedAt: new Date().toISOString(),
+        };
+      }
+
+      // Brave Search
+      const braveKey = gw.tools?.web?.search?.apiKey;
+      if (braveKey && !state.connectedAccounts.brave_search) {
+        state.connectedAccounts.brave_search = {
+          credential: braveKey === '__OPENCLAW_REDACTED__' ? 'configured (gateway)' : braveKey,
+          label: 'Brave Search',
+          connectedAt: new Date().toISOString(),
+        };
+      }
+
+      // Anthropic (from auth profiles or model providers)
+      const hasAnthropic = gw.auth?.profiles?.['anthropic:manual'] || gw.models?.providers?.anthropic;
+      if (hasAnthropic && !state.connectedAccounts.anthropic) {
+        state.connectedAccounts.anthropic = {
+          credential: 'configured (gateway)',
+          label: 'Anthropic',
+          connectedAt: new Date().toISOString(),
+        };
+      }
+
+      // Skip internal/infra services: OpenRouter, Qwen, Nvidia, Browser
+      // These are model routing, not user-facing connected accounts
+    }
+  } catch {}
+
+  // Skills
+  const skillsDir = join(workspace, 'skills');
+  if (existsSync(skillsDir)) {
+    state.skills = readdirSync(skillsDir, { withFileTypes: true })
+      .filter(d => d.isDirectory() && !d.name.startsWith('.'))
+      .map(d => ({ name: d.name, emoji: '⚡' }));
+  }
+
+  // Memory stats
+  const dailyDir = join(workspace, 'memory', 'daily');
+  if (existsSync(dailyDir)) {
+    state.memory.dailyNotes = readdirSync(dailyDir).filter(f => f.endsWith('.md')).length;
+  }
+  const memDir = join(workspace, 'memory');
+  if (existsSync(memDir)) {
+    const rootDaily = readdirSync(memDir).filter(f => /^\d{4}-\d{2}-\d{2}\.md$/.test(f)).length;
+    state.memory.dailyNotes = Math.max(state.memory.dailyNotes, rootDaily);
+  }
+
+  const knowledgeDir = join(workspace, 'memory', 'knowledge');
+  if (existsSync(knowledgeDir)) {
+    state.memory.knowledgeFiles = readdirSync(knowledgeDir).filter(f => f.endsWith('.md')).length;
+  }
+
+  const memoryMd = join(workspace, 'MEMORY.md');
+  if (existsSync(memoryMd)) {
+    const bytes = statSync(memoryMd).size;
+    state.memory.memoryMdSize = bytes < 1024 ? `${bytes}B` : `${Math.round(bytes / 1024)}KB`;
+  }
+
+  // Last consolidation
+  const consolLog = join(workspace, 'scripts', 'consolidation.log');
+  if (existsSync(consolLog)) {
+    const logContent = readFileSync(consolLog, 'utf8');
+    const dates = logContent.match(/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/g);
+    if (dates && dates.length > 0) {
+      state.memory.lastConsolidation = dates[dates.length - 1] + 'Z';
+    }
+  }
+
+  // --- Cron Jobs (from OpenClaw gateway API) ---
+  try {
+    // Try the local gateway WebSocket API via HTTP
+    const cronOut = execSync('curl -s -m 3 http://127.0.0.1:18789/api/cron/list 2>/dev/null || true', { timeout: 5000, encoding: 'utf8' });
+    const cronMatch = cronOut.match(/\{[\s\S]*\}/);
+    if (cronMatch) {
+      const cronData = JSON.parse(cronMatch[0]);
+      const jobs = cronData.jobs || [];
+      state.cronJobs = jobs.map(j => ({
+        name: j.name || (j.payload?.text || '').slice(0, 40) || 'Unnamed',
+        schedule: j.schedule?.kind === 'cron' ? j.schedule.expr :
+                  j.schedule?.kind === 'every' ? `every ${Math.round((j.schedule.everyMs || 0) / 60000)}m` :
+                  j.schedule?.kind === 'at' ? `at ${j.schedule.at}` : 'unknown',
+        lastRun: j.state?.lastRunAtMs ? new Date(j.state.lastRunAtMs).toISOString() : undefined,
+        status: j.state?.lastStatus || (j.enabled ? 'ok' : 'disabled'),
+      }));
+    }
+  } catch {}
+
+  // Fallback: parse cron info from HEARTBEAT.md
+  if (state.cronJobs.length === 0) {
+    const hbPath = join(workspace, 'HEARTBEAT.md');
+    if (existsSync(hbPath)) {
+      const hb = readFileSync(hbPath, 'utf8');
+      
+      // Detect heartbeat interval from config or default
+      let hbInterval = '30 min';
+      const cfgPath = join(workspace, 'skills', '.clamper', 'config.json');
+      if (existsSync(cfgPath)) {
+        try {
+          const cfg = JSON.parse(readFileSync(cfgPath, 'utf8'));
+          if (cfg.heartbeatInterval) hbInterval = `${cfg.heartbeatInterval} min`;
+        } catch {}
+      }
+
+      // Parse sections to determine frequency
+      const lines = hb.split('\n');
+      let currentFreq = hbInterval; // default
+      
+      const tasks = [];
+      for (const line of lines) {
+        // Detect frequency headers
+        if (/every heartbeat|immediate/i.test(line)) currentFreq = hbInterval;
+        else if (/daily/i.test(line)) currentFreq = '24 hours';
+        else if (/bi-daily|3 times/i.test(line)) currentFreq = '8 hours';
+        else if (/weekly/i.test(line)) currentFreq = '7 days';
+        else if (/hourly/i.test(line)) currentFreq = '1 hour';
+        
+        // Extract task names
+        const taskMatch = line.match(/\*\*(?:Task|Check):\*\*\s*(.+)/);
+        if (taskMatch) {
+          tasks.push({ name: taskMatch[1].trim(), freq: currentFreq });
+        }
+      }
+      
+      for (const t of tasks.slice(0, 12)) {
+        state.cronJobs.push({
+          name: t.name,
+          schedule: `every ${t.freq}`,
+          status: 'ok',
+        });
+      }
+    }
+  }
+
+  // --- Recent Activity ---
+
+  // Primary: activity log file (JSONL format)
+  const activityLog = join(workspace, 'logs', 'activity.jsonl');
+  if (existsSync(activityLog)) {
+    const lines = readFileSync(activityLog, 'utf8').trim().split('\n').filter(Boolean);
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        state.recentActivity.push({
+          timestamp: entry.ts || entry.timestamp || new Date().toISOString(),
+          message: entry.msg || entry.message || '',
+        });
+      } catch {}
+    }
+  }
+
+  // Secondary: git commits (if not enough from activity log)
+  if (state.recentActivity.length < 10) {
+    try {
+      // Find git repos in common locations
+      const home = process.env.HOME || '';
+      const searchDirs = [join(home, 'Desktop'), join(home, 'Projects'), join(home, 'dev')];
+      for (const searchDir of searchDirs) {
+        if (!existsSync(searchDir)) continue;
+        try {
+          const repos = execSync(`find "${searchDir}" -maxdepth 2 -name ".git" -type d 2>/dev/null`, { timeout: 3000, encoding: 'utf8' });
+          for (const gitDir of repos.trim().split('\n').filter(Boolean)) {
+            const repoDir = join(gitDir, '..');
+            try {
+              const gitLog = execSync(`cd "${repoDir}" && git log --oneline --format="%ai|%s" -3 2>/dev/null`, { timeout: 2000, encoding: 'utf8' });
+              const repoName = repoDir.split('/').pop();
+              for (const line of gitLog.trim().split('\n').filter(Boolean)) {
+                const [date, ...msgParts] = line.split('|');
+                state.recentActivity.push({
+                  timestamp: new Date(date.trim()).toISOString(),
+                  message: `[${repoName}] ${msgParts.join('|').slice(0, 100)}`,
+                });
+              }
+            } catch {}
+          }
+        } catch {}
+      }
+    } catch {}
+  }
+
+  // Tertiary: recent file changes
+  if (state.recentActivity.length < 15) {
+    try {
+      const recentFiles = execSync(`find "${workspace}" -name "*.md" -mmin -1440 -not -path "*/node_modules/*" -not -path "*/.git/*" -printf "%T@|%f\n" 2>/dev/null | sort -rn | head -5`, { timeout: 3000, encoding: 'utf8' });
+      for (const line of recentFiles.trim().split('\n').filter(Boolean)) {
+        const [ts, file] = line.split('|');
+        state.recentActivity.push({
+          timestamp: new Date(parseFloat(ts) * 1000).toISOString(),
+          message: `Updated ${file}`,
+        });
+      }
+    } catch {}
+  }
+
+  // Sort by timestamp descending, dedupe by message, limit
+  state.recentActivity.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+  const seen = new Set();
+  state.recentActivity = state.recentActivity.filter(a => {
+    if (seen.has(a.message)) return false;
+    seen.add(a.message);
+    return true;
+  }).slice(0, 20);
+
+  // Agent activity status
+  const statusFile = join(workspace, 'logs', 'agent-status.txt');
+  if (existsSync(statusFile)) {
+    state.agentActivity = readFileSync(statusFile, 'utf8').trim().slice(0, 100);
+  } else if (state.recentActivity.length > 0) {
+    state.agentActivity = state.recentActivity[0].message.slice(0, 80);
+  } else {
+    state.agentActivity = 'Waiting for instructions';
+  }
+
+  // --- Token Usage & Cost + Context Breakdown ---
+  state.usage = { inputTokens: 0, outputTokens: 0, contextUsed: 0, contextMax: 0, costEstimate: '', model: '', compactions: 0 };
+
+  // Read context stats from logs/context-stats.json (updated by agent)
+  const ctxStatsPath = join(workspace, 'logs', 'context-stats.json');
+  if (existsSync(ctxStatsPath)) {
+    try {
+      const cs = JSON.parse(readFileSync(ctxStatsPath, 'utf8'));
+      state.usage.model = cs.model || state.usage.model;
+      state.usage.inputTokens = cs.inputTokens || 0;
+      state.usage.outputTokens = cs.outputTokens || 0;
+      state.usage.contextUsed = cs.contextUsed || cs.contextTokens || 0;
+      state.usage.contextMax = cs.contextMax || cs.contextLimit || 0;
+      state.usage.compactions = cs.compactions || 0;
+    } catch {}
+  }
+
+  // Fallback: read model from gateway config
+  if (!state.usage.model) {
+    try {
+      const gwPath = join(process.env.HOME || '', '.openclaw', 'openclaw.json');
+      if (existsSync(gwPath)) {
+        const gw = JSON.parse(readFileSync(gwPath, 'utf8'));
+        const primary = gw.agents?.defaults?.model?.primary;
+        if (primary) state.usage.model = primary;
+      }
+    } catch {}
+  }
+
+  // If we couldn't get from CLI, estimate from daily note sizes
+  if (!state.usage.model) {
+    state.usage.model = state.preferences.defaultModel || 'unknown';
+  }
+
+  // Cost estimation based on model
+  const MODEL_COSTS = {
+    'claude-opus-4-6': { input: 15, output: 75 },     // per 1M tokens
+    'claude-opus-4': { input: 15, output: 75 },
+    'claude-sonnet-4-5': { input: 3, output: 15 },
+    'claude-sonnet-4': { input: 3, output: 15 },
+    'claude-haiku-3-5': { input: 0.8, output: 4 },
+    'gpt-4o': { input: 2.5, output: 10 },
+    'gpt-4o-mini': { input: 0.15, output: 0.6 },
+    'gemini-2.0-flash': { input: 0.1, output: 0.4 },
+  };
+  const modelKey = Object.keys(MODEL_COSTS).find(k => state.usage.model?.includes(k));
+  const costs = MODEL_COSTS[modelKey] || { input: 3, output: 15 };
+  const inCost = (state.usage.inputTokens / 1_000_000) * costs.input;
+  const outCost = (state.usage.outputTokens / 1_000_000) * costs.output;
+  state.usage.costEstimate = `$${(inCost + outCost).toFixed(4)}`;
+  state.usage.costPerMInput = costs.input;
+  state.usage.costPerMOutput = costs.output;
+
+  return state;
+}
+
+// --- Main sync ---
+
+export async function runSync(flags) {
+  const workspace = detectWorkspace();
+  if (!workspace) {
+    log.err('No workspace found. Run clamper init first.');
+    process.exit(1);
+  }
+
+  const apiKey = flags.key || getApiKey();
+  if (!apiKey) {
+    log.err('No API key. Set CLAMPER_API_KEY or use --key=YOUR_KEY');
+    process.exit(1);
+  }
+
+  const quiet = flags.quiet || flags.q;
+  if (!quiet) console.log(`\n${c.bold}${c.cyan}🔄 Clamper Sync${c.reset}\n`);
+
+  // Gather state
+  if (!quiet) log.step(1, 'Gathering agent state...');
+  const state = gatherState(workspace);
+
+  const accountCount = Object.keys(state.connectedAccounts).length;
+  if (!quiet) {
+    log.ok(`${state.skills.length} skills, ${accountCount} accounts, ${state.memory.dailyNotes} daily notes, ${state.memory.memoryMdSize} memory`);
+  }
+
+  // Push to API
+  if (!quiet) log.step(2, 'Pushing to Clamper API...');
+  try {
+    const res = await fetch(`${API_BASE}/api/dashboard/sync`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ apiKey, state }),
+    });
+    const data = await res.json();
+
+    if (data.success) {
+      if (!quiet) log.ok('State synced successfully');
+
+      // Apply pending changes from dashboard → local files
+      if (data.pendingChanges && data.pendingChanges.length > 0) {
+        if (!quiet) {
+          console.log(`\n  ${c.yellow}📥 ${data.pendingChanges.length} pending change(s) from dashboard${c.reset}`);
+        }
+        applyPendingChanges(workspace, data.pendingChanges, quiet);
+      }
+
+      if (!quiet) {
+        console.log(`\n  ${c.green}✔${c.reset} Dashboard: ${c.cyan}https://clamper.tech/dashboard${c.reset}\n`);
+      } else {
+        // Quiet mode — output pending changes as JSON for agent
+        if (data.pendingChanges && data.pendingChanges.length > 0) {
+          console.log(JSON.stringify(data.pendingChanges));
+        }
+      }
+    } else {
+      log.err(`Sync failed: ${data.error || 'Unknown error'}`);
+    }
+  } catch (err) {
+    log.err(`Network error: ${err.message}`);
+  }
+}