metame-cli 1.5.4 → 1.5.6

package/README.md

@@ -464,7 +464,7 @@ Each team member runs on a virtual chatId (`_agent_{key}`) and appears with its
 
 ### Cross-Device Dispatch
 
-Team members with `peer` field run on a different machine. Configure `feishu.remote_dispatch` on both machines with the same relay chat and shared secret:
+Team members with `peer` field run on a different machine. Configure `feishu.remote_dispatch` on both machines with the same relay chat and shared secret, but do not share the same Feishu bot between machines. Each machine must use its own Feishu app/bot credentials.
 
 ```yaml
 feishu:
@@ -475,6 +475,11 @@ feishu:
     secret: shared-secret-key  # HMAC signing key
 ```
 
+Why separate bots are required:
+- Feishu may deliver relay-chat events to either online client for the same bot.
+- Current remote-dispatch handling drops packets addressed to a different `self` peer.
+- If Windows and Mac share one bot, the wrong machine can consume and discard the packet.
+
 Use from mobile: `/dispatch to windows:hunter research competitors` or just mention by nickname — routing is automatic. Use `/dispatch peers` to check remote config status.
 
 ## Mobile Commands

package/index.js

@@ -50,6 +50,96 @@ function spawnCodex(args, options) {
   return spawnViaNode('codex', args, { ...options, env });
 }
 
+function mergeReflectionDisplayEntries(entries) {
+  const merged = new Map();
+  for (const entry of entries) {
+    const normalized = typeof entry === 'string'
+      ? { summary: entry, detected: null }
+      : (entry && typeof entry.summary === 'string' ? { summary: entry.summary, detected: entry.detected || null } : null);
+    if (!normalized) continue;
+
+    const existing = merged.get(normalized.summary);
+    if (!existing) {
+      merged.set(normalized.summary, normalized);
+      continue;
+    }
+
+    const existingDetected = existing.detected ? new Date(existing.detected).getTime() : 0;
+    const normalizedDetected = normalized.detected ? new Date(normalized.detected).getTime() : 0;
+    const shouldReplace =
+      normalizedDetected > 0 && (
+        existingDetected === 0
+        || normalizedDetected < existingDetected
+      );
+    if (shouldReplace) merged.set(normalized.summary, { ...existing, ...normalized });
+  }
+  return [...merged.values()];
+}
+
+function readLatestClaudeSession(projectsRoot, cwd) {
+  let bestSession = null;
+  const findLatest = (dir) => {
+    try {
+      return fs.readdirSync(dir)
+        .filter(f => f.endsWith('.jsonl'))
+        .map(f => ({ id: f.replace('.jsonl', ''), mtime: fs.statSync(path.join(dir, f)).mtimeMs }))
+        .sort((a, b) => b.mtime - a.mtime)[0] || null;
+    } catch { return null; }
+  };
+
+  try {
+    const projDir = path.join(projectsRoot, cwd.replace(/\//g, '-'));
+    const localBest = findLatest(projDir);
+    let globalBest = null;
+    try {
+      for (const d of fs.readdirSync(projectsRoot)) {
+        const s = findLatest(path.join(projectsRoot, d));
+        if (s && (!globalBest || s.mtime > globalBest.mtime)) globalBest = s;
+      }
+    } catch { /* ignore */ }
+    if (localBest && globalBest && globalBest.mtime > localBest.mtime) {
+      bestSession = { ...globalBest, scope: 'global' };
+    } else {
+      bestSession = localBest ? { ...localBest, scope: 'local' } : (globalBest ? { ...globalBest, scope: 'global' } : null);
+    }
+  } catch { /* ignore */ }
+
+  return bestSession ? { ...bestSession, engine: 'claude' } : null;
+}
+
+function readLatestCodexSession(cwd) {
+  let db;
+  try {
+    const codeDb = path.join(HOME_DIR, '.codex', 'state_5.sqlite');
+    if (!fs.existsSync(codeDb)) return null;
+    const { DatabaseSync } = require('node:sqlite');
+    db = new DatabaseSync(codeDb, { readonly: true });
+    const row = db.prepare(`
+      SELECT id, cwd, updated_at, created_at
+      FROM threads
+      WHERE COALESCE(has_user_event, 1) = 1
+        AND archived = 0
+      ORDER BY
+        CASE WHEN cwd = ? THEN 0 ELSE 1 END ASC,
+        COALESCE(updated_at, created_at, 0) DESC
+      LIMIT 1
+    `).get(cwd);
+    db.close();
+    db = null;
+    if (!row || !row.id) return null;
+    const ts = Number(row.updated_at || row.created_at || 0) * 1000;
+    return {
+      id: String(row.id),
+      mtime: ts || 0,
+      engine: 'codex',
+      scope: String(row.cwd || '') === String(cwd) ? 'local' : 'global',
+    };
+  } catch {
+    if (db) { try { db.close(); } catch { /* ignore */ } }
+    return null;
+  }
+}
+
 // Quick flags (before heavy init)
 const pkgVersion = require('./package.json').version;
 if (process.argv.includes('-V') || process.argv.includes('--version')) {
@@ -144,10 +234,76 @@ function syncDirFiles(srcDir, destDir, { fileList, chmod } = {}) {
   return updated;
 }
 
+function readRunningDaemonPid({ pidFile, lockFile }) {
+  if (fs.existsSync(pidFile)) {
+    try {
+      const pid = parseInt(fs.readFileSync(pidFile, 'utf8').trim(), 10);
+      if (pid && pid !== process.pid) {
+        process.kill(pid, 0);
+        return pid;
+      }
+    } catch { /* stale pid file */ }
+  }
+  if (fs.existsSync(lockFile)) {
+    try {
+      const lock = JSON.parse(fs.readFileSync(lockFile, 'utf8'));
+      const pid = parseInt(lock && lock.pid, 10);
+      if (pid && pid !== process.pid) {
+        process.kill(pid, 0);
+        return pid;
+      }
+    } catch { /* stale or invalid lock */ }
+  }
+  return null;
+}
+
+function requestDaemonRestart({
+  reason = 'manual-restart',
+  daemonPidFile = path.join(METAME_DIR, 'daemon.pid'),
+  daemonLockFile = path.join(METAME_DIR, 'daemon.lock'),
+  daemonScript = path.join(METAME_DIR, 'daemon.js'),
+} = {}) {
+  const pid = readRunningDaemonPid({ pidFile: daemonPidFile, lockFile: daemonLockFile });
+  if (!pid) return { ok: false, status: 'not_running' };
+
+  if (process.platform !== 'win32') {
+    try {
+      process.kill(pid, 'SIGUSR2');
+      return { ok: true, status: 'signaled', pid };
+    } catch (e) {
+      return { ok: false, status: 'signal_failed', pid, error: e.message };
+    }
+  }
+
+  try {
+    process.kill(pid, 'SIGTERM');
+  } catch (e) {
+    return { ok: false, status: 'stop_failed', pid, error: e.message };
+  }
+
+  let stopped = false;
+  for (let i = 0; i < 12; i++) {
+    sleepSync(500);
+    try { process.kill(pid, 0); } catch { stopped = true; break; }
+  }
+  if (!stopped) {
+    try { process.kill(pid, 'SIGKILL'); } catch { /* already gone */ }
+  }
+
+  const bg = spawn(process.execPath, [daemonScript], {
+    detached: true,
+    stdio: 'ignore',
+    windowsHide: true,
+    env: { ...process.env, HOME: HOME_DIR, METAME_ROOT: __dirname, METAME_DEPLOY_RESTART_REASON: reason },
+  });
+  bg.unref();
+  return { ok: true, status: 'restarted', pid, nextPid: bg.pid };
+}
+
 // Auto-deploy bundled scripts to ~/.metame/
 // IMPORTANT: daemon.yaml is USER CONFIG — never overwrite it. Only daemon-default.yaml (template) is synced.
 const scriptsDir = path.join(__dirname, 'scripts');
-const BUNDLED_BASE_SCRIPTS = ['platform.js', 'signal-capture.js', 'distill.js', 'schema.js', 'pending-traits.js', 'daemon.js', 'telegram-adapter.js', 'feishu-adapter.js', 'daemon-default.yaml', 'providers.js', 'session-analytics.js', 'resolve-yaml.js', 'utils.js', 'skill-evolution.js', 'memory.js', 'memory-extract.js', 'memory-search.js', 'memory-write.js', 'memory-gc.js', 'qmd-client.js', 'session-summarize.js', 'mentor-engine.js', 'check-macos-control-capabilities.sh', 'usage-classifier.js', 'task-board.js', 'memory-nightly-reflect.js', 'memory-index.js', 'skill-changelog.js', 'agent-layer.js'];
+const BUNDLED_BASE_SCRIPTS = ['platform.js', 'signal-capture.js', 'distill.js', 'schema.js', 'pending-traits.js', 'daemon.js', 'daemon-notify.js', 'telegram-adapter.js', 'feishu-adapter.js', 'daemon-default.yaml', 'providers.js', 'session-analytics.js', 'resolve-yaml.js', 'utils.js', 'skill-evolution.js', 'memory.js', 'memory-extract.js', 'memory-search.js', 'memory-write.js', 'memory-gc.js', 'qmd-client.js', 'session-summarize.js', 'mentor-engine.js', 'check-macos-control-capabilities.sh', 'usage-classifier.js', 'task-board.js', 'memory-nightly-reflect.js', 'memory-index.js', 'skill-changelog.js', 'agent-layer.js'];
 const DAEMON_MODULE_SCRIPTS = (() => {
   try {
     return fs.readdirSync(scriptsDir).filter((f) => /^daemon-[\w-]+\.js$/.test(f));
@@ -192,22 +348,36 @@ if (syntaxErrors.length > 0) {
   console.error('Fix the errors before deploying. Daemon continues running with old code.');
 } else {
   scriptsUpdated = syncDirFiles(scriptsDir, METAME_DIR, { fileList: BUNDLED_SCRIPTS });
-
-  // Daemon restart on script update:
-  // Don't kill daemon here — daemon's own file watcher detects ~/.metame/daemon.js changes
-  // and has defer logic (waits for active Claude tasks to finish before restarting).
-  // Killing here bypasses that and interrupts ongoing conversations.
   if (scriptsUpdated) {
-    console.log(`${icon("pkg")} Scripts ${IS_DEV_MODE ? 'symlinked' : 'synced'} to ~/.metame/ — daemon will auto-restart when idle.`);
+    console.log(`${icon("pkg")} Scripts ${IS_DEV_MODE ? 'symlinked' : 'synced'} to ~/.metame/.`);
   }
 }
 
 // Docs: lazy-load references for CLAUDE.md pointer instructions
 syncDirFiles(path.join(__dirname, 'scripts', 'docs'), path.join(METAME_DIR, 'docs'));
 // Bin: CLI tools (dispatch_to etc.)
-syncDirFiles(path.join(__dirname, 'scripts', 'bin'), path.join(METAME_DIR, 'bin'), { chmod: 0o755 });
+const binUpdated = syncDirFiles(path.join(__dirname, 'scripts', 'bin'), path.join(METAME_DIR, 'bin'), { chmod: 0o755 });
 // Hooks: Claude Code event hooks (Stop, PostToolUse, etc.)
-syncDirFiles(path.join(__dirname, 'scripts', 'hooks'), path.join(METAME_DIR, 'hooks'));
+const hooksUpdated = syncDirFiles(path.join(__dirname, 'scripts', 'hooks'), path.join(METAME_DIR, 'hooks'));
+
+const daemonCodeUpdated = scriptsUpdated || binUpdated || hooksUpdated;
+const shouldAutoRestartAfterDeploy = (() => {
+  const [cmd] = process.argv.slice(2);
+  if (!cmd) return true;
+  if (cmd === 'daemon') return false;
+  if (['start', 'stop', 'restart', 'status', 'logs'].includes(cmd)) return false;
+  return ['codex', 'continue', 'sync'].includes(cmd);
+})();
+if (daemonCodeUpdated && shouldAutoRestartAfterDeploy) {
+  const restartResult = requestDaemonRestart({ reason: 'deploy-sync' });
+  if (restartResult.ok) {
+    console.log(`${icon("reload")} Daemon restart requested after deploy${restartResult.pid ? ` (PID: ${restartResult.pid})` : ''}.`);
+  } else if (restartResult.status === 'not_running') {
+    console.log(`${icon("info")}  Deploy finished. Daemon not running, so restart was skipped.`);
+  } else {
+    console.log(`${icon("warn")}  Deploy finished, but daemon restart failed: ${restartResult.error || restartResult.status}`);
+  }
+}
 
 // ---------------------------------------------------------
 // Deploy bundled skills to ~/.claude/skills/
@@ -834,6 +1004,7 @@ try {
 
       // Find a pattern that hasn't been surfaced in 14 days
       const candidate = brainDoc.growth.patterns.find(p => {
+        if (!p || typeof p.summary !== 'string') return false;
         if (!p.surfaced) return true;
         return (now - new Date(p.surfaced).getTime()) > COOLDOWN_MS;
       });
@@ -1307,17 +1478,34 @@ if (isInsights) {
   try {
     const doc = yaml.load(fs.readFileSync(BRAIN_FILE, 'utf8')) || {};
     const patterns = (doc.growth && doc.growth.patterns) || [];
+    const reflectionPatterns = (doc.growth && doc.growth.self_reflection_patterns) || [];
     const zoneHistory = (doc.growth && doc.growth.zone_history) || [];
+    const userPatterns = patterns.filter(p => p && typeof p.summary === 'string');
+    const legacyReflectionPatterns = patterns
+      .filter(p => typeof p === 'string')
+      .map(p => ({ summary: p, detected: null }));
+    const aiReflections = mergeReflectionDisplayEntries([...reflectionPatterns, ...legacyReflectionPatterns]);
 
-    if (patterns.length === 0) {
+    if (userPatterns.length === 0 && aiReflections.length === 0) {
       console.log(`${icon("search")} MetaMe: No patterns detected yet. Keep using MetaMe and patterns will emerge after ~5 sessions.`);
     } else {
       console.log(`${icon("mirror")} MetaMe Insights:\n`);
-      patterns.forEach((p, i) => {
+      if (userPatterns.length > 0) {
+        console.log('User observation:');
+      }
+      userPatterns.forEach((p, i) => {
         const sym = p.type === 'avoidance' ? icon("warn") : p.type === 'growth' ? '+' : p.type === 'energy' ? '*' : icon("reload");
         console.log(`   ${sym} [${p.type}] ${p.summary} (confidence: ${(p.confidence * 100).toFixed(0)}%)`);
         console.log(`      Detected: ${p.detected}${p.surfaced ? `, Last shown: ${p.surfaced}` : ''}`);
       });
+      if (aiReflections.length > 0) {
+        if (userPatterns.length > 0) console.log('');
+        console.log('AI self-reflection:');
+        aiReflections.forEach((p) => {
+          console.log(`   ${icon("thought")} ${p.summary}`);
+          if (p.detected) console.log(`      Detected: ${p.detected}`);
+        });
+      }
       if (zoneHistory.length > 0) {
         console.log(`\n   ${icon("chart")} Recent zone history: ${zoneHistory.join(' → ')}`);
         console.log(`      (C=Comfort, S=Stretch, P=Panic)`);
@@ -1525,7 +1713,7 @@ if (isProvider) {
 // 5.7 DAEMON SUBCOMMANDS
 // ---------------------------------------------------------
 // Shorthand aliases: `metame start` → `metame daemon start`, etc.
-const DAEMON_SHORTCUTS = ['start', 'stop', 'status', 'logs'];
+const DAEMON_SHORTCUTS = ['start', 'stop', 'restart', 'status', 'logs'];
 if (DAEMON_SHORTCUTS.includes(process.argv[2])) {
   process.argv.splice(2, 0, 'daemon');
 }
@@ -1907,6 +2095,48 @@ WantedBy=default.target
     process.exit(0);
   }
 
+  if (subCmd === 'restart') {
+    if (!fs.existsSync(DAEMON_CONFIG)) {
+      console.error(`${icon("fail")} No config found. Run: metame daemon init`);
+      process.exit(1);
+    }
+    if (!fs.existsSync(DAEMON_SCRIPT)) {
+      console.error(`${icon("fail")} daemon.js not found. Reinstall MetaMe.`);
+      process.exit(1);
+    }
+    const result = requestDaemonRestart({
+      reason: 'cli-restart',
+      daemonPidFile: DAEMON_PID,
+      daemonLockFile: DAEMON_LOCK,
+      daemonScript: DAEMON_SCRIPT,
+    });
+    if (result.ok) {
+      if (result.status === 'restarted') {
+        console.log(`${icon("ok")} Daemon restarted (old PID: ${result.pid}, new PID: ${result.nextPid})`);
+      } else {
+        console.log(`${icon("ok")} Daemon graceful restart requested (PID: ${result.pid})`);
+      }
+      process.exit(0);
+    }
+    if (result.status === 'not_running') {
+      console.log(`${icon("info")}  No daemon running. Starting a fresh daemon instead.`);
+      const isMac = process.platform === 'darwin';
+      const cmd = isMac ? 'caffeinate' : process.execPath;
+      const args = isMac ? ['-i', process.execPath, DAEMON_SCRIPT] : [DAEMON_SCRIPT];
+      const bg = spawn(cmd, args, {
+        detached: true,
+        stdio: 'ignore',
+        windowsHide: true,
+        env: { ...process.env, HOME: HOME_DIR, METAME_ROOT: __dirname, METAME_DEPLOY_RESTART_REASON: 'cli-restart' },
+      });
+      bg.unref();
+      console.log(`${icon("ok")} MetaMe daemon started (PID: ${bg.pid})`);
+      process.exit(0);
+    }
+    console.error(`${icon("fail")} Daemon restart failed: ${result.error || result.status}`);
+    process.exit(1);
+  }
+
   if (subCmd === 'status') {
     let state = {};
     try { state = JSON.parse(fs.readFileSync(DAEMON_STATE, 'utf8')); } catch { /* empty */ }
@@ -2010,6 +2240,7 @@ WantedBy=default.target
   console.log(`${icon("book")} Daemon Commands:`);
   console.log("   metame start                  — start background daemon");
   console.log("   metame stop                   — stop daemon");
+  console.log("   metame restart                — graceful restart daemon");
   console.log("   metame status                 — show status & budget");
   console.log("   metame logs                   — tail log file");
   console.log("   metame daemon init            — initialize config");
@@ -2073,58 +2304,48 @@ if (isCodex) {
 // ---------------------------------------------------------
 // 5.9 CONTINUE/SYNC — resume latest session from terminal
 // ---------------------------------------------------------
-// Usage: exit Claude first, then run `metame continue` from terminal.
-// Finds the most recent session and launches Claude with --resume.
+// Usage: exit current CLI first, then run `metame continue` from terminal.
+// Finds the most recent session across Claude/Codex and resumes with the matching engine.
 const isSync = process.argv.includes('sync') || process.argv.includes('continue');
 if (isSync) {
   const projectsRoot = path.join(HOME_DIR, '.claude', 'projects');
-  let bestSession = null;
-  try {
-    const cwd = process.cwd();
-    const projDir = path.join(projectsRoot, cwd.replace(/\//g, '-'));
-    const findLatest = (dir) => {
-      try {
-        return fs.readdirSync(dir)
-          .filter(f => f.endsWith('.jsonl'))
-          .map(f => ({ id: f.replace('.jsonl', ''), mtime: fs.statSync(path.join(dir, f)).mtimeMs }))
-          .sort((a, b) => b.mtime - a.mtime)[0] || null;
-      } catch { return null; }
-    };
-    const localBest = findLatest(projDir);
-    // Always scan globally to find the absolute most recent session
-    // (phone /continue may have worked in a different project's session)
-    let globalBest = null;
-    try {
-      for (const d of fs.readdirSync(projectsRoot)) {
-        const s = findLatest(path.join(projectsRoot, d));
-        if (s && (!globalBest || s.mtime > globalBest.mtime)) globalBest = s;
-      }
-    } catch { /* ignore */ }
-    // Use global best if it's more recent than local; prefer local otherwise
-    if (localBest && globalBest && globalBest.mtime > localBest.mtime) {
-      bestSession = globalBest;
-      console.log(`  (global session is newer than local — using global)`);
-    } else {
-      bestSession = localBest || globalBest;
-    }
-  } catch { }
+  const cwd = process.cwd();
+  const candidates = [
+    readLatestClaudeSession(projectsRoot, cwd),
+    readLatestCodexSession(cwd),
+  ].filter(Boolean);
+  const bestSession = candidates.sort((a, b) => (b.mtime || 0) - (a.mtime || 0))[0] || null;
 
   if (!bestSession) {
     console.error('No session found.');
     process.exit(1);
   }
 
+  if (bestSession.scope === 'global') {
+    console.log('  (global session is newer than local — using global)');
+  }
   console.log(`\n${icon("reload")} Resuming session ${bestSession.id.slice(0, 8)}...\n`);
-  const providerEnv = (() => { try { return require(path.join(__dirname, 'scripts', 'providers.js')).buildActiveEnv(); } catch { return {}; } })();
-  const resumeArgs = ['--resume', bestSession.id];
-  if (daemonCfg.dangerously_skip_permissions) resumeArgs.push('--dangerously-skip-permissions');
-  const syncChild = spawnClaude(resumeArgs, {
-    stdio: 'inherit',
-    env: { ...process.env, ...providerEnv, METAME_ACTIVE_SESSION: 'true' }
-  });
-  syncChild.on('error', () => {
-    console.error("Could not launch 'claude'. Is Claude Code installed?");
-  });
+  let syncChild;
+  if (bestSession.engine === 'codex') {
+    syncChild = spawnCodex(['exec', 'resume', bestSession.id], {
+      stdio: 'inherit',
+      env: { ...process.env, METAME_ACTIVE_SESSION: 'true' }
+    });
+    syncChild.on('error', () => {
+      console.error("Could not launch 'codex'. Is Codex CLI installed?");
+    });
+  } else {
+    const providerEnv = (() => { try { return require(path.join(__dirname, 'scripts', 'providers.js')).buildActiveEnv(); } catch { return {}; } })();
+    const resumeArgs = ['--resume', bestSession.id];
+    if (daemonCfg.dangerously_skip_permissions) resumeArgs.push('--dangerously-skip-permissions');
+    syncChild = spawnClaude(resumeArgs, {
+      stdio: 'inherit',
+      env: { ...process.env, ...providerEnv, METAME_ACTIVE_SESSION: 'true' }
+    });
+    syncChild.on('error', () => {
+      console.error("Could not launch 'claude'. Is Claude Code installed?");
+    });
+  }
   syncChild.on('close', (c) => process.exit(c || 0));
   return;
 }
@@ -2137,7 +2358,8 @@ if (isSync) {
 if (process.env.METAME_ACTIVE_SESSION === 'true') {
   console.error(`\n${icon("stop")} ACTION BLOCKED: Nested Session Detected`);
   console.error("   You are actively running inside a MetaMe session.");
-  console.error("   To reload configuration, use: \x1b[36m!metame refresh\x1b[0m\n");
+  console.error("   To hot-reload daemon code from this session, run: \x1b[36mtouch ~/.metame/daemon.js\x1b[0m");
+  console.error("   In this dev workspace, \x1b[36mtouch scripts/daemon.js\x1b[0m works too because ~/.metame/daemon.js is symlinked.\n");
   process.exit(1);
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "metame-cli",
-    "version": "1.5.4",
+    "version": "1.5.6",
     "description": "The Cognitive Profile Layer for Claude Code. Knows how you think, not just what you said.",
     "main": "index.js",
     "bin": {
@@ -17,7 +17,8 @@
         "test": "node --test scripts/*.test.js",
         "test:daemon-status": "node --test scripts/daemon-restart-status.test.js",
         "start": "node index.js",
-        "sync:plugin": "cp scripts/platform.js scripts/schema.js scripts/pending-traits.js scripts/signal-capture.js scripts/distill.js scripts/daemon.js scripts/daemon-agent-commands.js scripts/daemon-session-commands.js scripts/daemon-admin-commands.js scripts/daemon-exec-commands.js scripts/daemon-ops-commands.js scripts/daemon-session-store.js scripts/daemon-checkpoints.js scripts/daemon-bridges.js scripts/daemon-file-browser.js scripts/daemon-runtime-lifecycle.js scripts/daemon-notify.js scripts/daemon-claude-engine.js scripts/daemon-engine-runtime.js scripts/daemon-command-router.js scripts/daemon-user-acl.js scripts/daemon-agent-tools.js scripts/daemon-task-scheduler.js scripts/daemon-task-envelope.js scripts/task-board.js scripts/telegram-adapter.js scripts/feishu-adapter.js scripts/daemon-default.yaml scripts/providers.js scripts/utils.js scripts/usage-classifier.js scripts/resolve-yaml.js scripts/memory.js scripts/memory-write.js scripts/memory-extract.js scripts/memory-search.js scripts/memory-gc.js scripts/memory-nightly-reflect.js scripts/memory-index.js scripts/qmd-client.js scripts/session-summarize.js scripts/session-analytics.js scripts/mentor-engine.js scripts/skill-evolution.js scripts/skill-changelog.js scripts/agent-layer.js scripts/self-reflect.js scripts/check-macos-control-capabilities.sh plugin/scripts/ && echo 'Plugin scripts synced'",
+        "push": "bash scripts/bin/push-clean.sh",
+        "sync:plugin": "cp scripts/platform.js scripts/schema.js scripts/pending-traits.js scripts/signal-capture.js scripts/distill.js scripts/daemon.js scripts/daemon-agent-commands.js scripts/daemon-session-commands.js scripts/daemon-admin-commands.js scripts/daemon-exec-commands.js scripts/daemon-ops-commands.js scripts/daemon-command-session-route.js scripts/daemon-session-store.js scripts/daemon-checkpoints.js scripts/daemon-bridges.js scripts/daemon-file-browser.js scripts/daemon-runtime-lifecycle.js scripts/daemon-notify.js scripts/daemon-claude-engine.js scripts/daemon-engine-runtime.js scripts/daemon-command-router.js scripts/daemon-user-acl.js scripts/daemon-agent-tools.js scripts/daemon-task-scheduler.js scripts/daemon-task-envelope.js scripts/daemon-team-dispatch.js scripts/daemon-dispatch-cards.js scripts/daemon-remote-dispatch.js scripts/daemon-siri-bridge.js scripts/daemon-siri-imessage.js scripts/task-board.js scripts/telegram-adapter.js scripts/feishu-adapter.js scripts/daemon-default.yaml scripts/providers.js scripts/utils.js scripts/usage-classifier.js scripts/resolve-yaml.js scripts/memory.js scripts/memory-write.js scripts/memory-extract.js scripts/memory-search.js scripts/memory-gc.js scripts/memory-nightly-reflect.js scripts/memory-index.js scripts/qmd-client.js scripts/session-summarize.js scripts/session-analytics.js scripts/mentor-engine.js scripts/skill-evolution.js scripts/skill-changelog.js scripts/agent-layer.js scripts/self-reflect.js scripts/check-macos-control-capabilities.sh plugin/scripts/ && echo 'Plugin scripts synced'",
         "sync:readme": "node scripts/sync-readme.js",
         "restart:daemon": "node index.js stop 2>/dev/null; sleep 1; node index.js start 2>/dev/null || echo '鈿狅笍  Daemon not running or restart failed'",
         "precommit": "npm run sync:plugin && npm run restart:daemon"

package/scripts/agent-layer.js

@@ -127,11 +127,13 @@ function tryRemoveExisting(filePath) {
  *   3. plain file copy (last resort; note: will not track future changes to target)
  */
 function createLinkOrMirror(targetPath, linkPath) {
-  const relativeTarget = path.relative(path.dirname(linkPath), targetPath) || path.basename(targetPath);
   tryRemoveExisting(linkPath);
 
   try {
-    fs.symlinkSync(relativeTarget, linkPath, 'file');
+    // Use absolute symlinks here: agent layer lives under ~/.metame while workspaces can
+    // sit on a different top-level tree (/var, /Volumes, etc). Relative links are brittle
+    // across those roots and have produced broken SOUL.md/MEMORY.md views.
+    fs.symlinkSync(targetPath, linkPath, 'file');
     return { mode: 'symlink', path: linkPath };
   } catch (symlinkErr) {
     const sameRoot = path.parse(targetPath).root.toLowerCase() === path.parse(linkPath).root.toLowerCase();

package/scripts/bin/dispatch_to

@@ -16,8 +16,12 @@ const crypto = require('crypto');
 const os = require('os');
 const { socketPath } = require('../platform');
 const yaml = require('../resolve-yaml');
-const { buildEnrichedPrompt, buildTeamRosterHint } = require('../team-dispatch');
-const { parseRemoteTargetRef, normalizeRemoteDispatchConfig, encodePacket } = require('../daemon-remote-dispatch');
+const { buildEnrichedPrompt, buildTeamRosterHint } = require('../daemon-team-dispatch');
+const {
+  parseRemoteTargetRef,
+  normalizeRemoteDispatchConfig,
+  encodePacket,
+} = require('../daemon-remote-dispatch');
 
 const METAME_DIR = path.join(os.homedir(), '.metame');
 const DISPATCH_DIR = path.join(METAME_DIR, 'dispatch');
@@ -30,6 +34,7 @@ const args = process.argv.slice(2);
 const newSession = args[0] === '--new' ? (args.shift(), true) : false;
 
 let fromKey = process.env.METAME_PROJECT || '_claude_session';
+const sourceSenderId = String(process.env.METAME_SENDER_ID || '').trim();
 const fromIdx = args.indexOf('--from');
 if (fromIdx !== -1 && args[fromIdx + 1]) {
   fromKey = args.splice(fromIdx, 2)[1];
@@ -64,7 +69,9 @@ function sendOne(memberTarget, memberPrompt, opts = {}) {
   return new Promise((resolve) => {
     const ts = new Date().toISOString();
     const secret = getDispatchSecret();
-    const enriched = opts.skipEnrich ? memberPrompt : buildEnrichedPrompt(memberTarget, memberPrompt, METAME_DIR);
+    const enriched = opts.skipEnrich
+      ? memberPrompt
+      : buildEnrichedPrompt(memberTarget, memberPrompt, METAME_DIR, { includeShared: !!opts.includeShared });
     const sigPayload = JSON.stringify({ target: memberTarget, prompt: enriched, ts });
     const sig = crypto.createHmac('sha256', secret).update(sigPayload).digest('hex');
 
@@ -73,6 +80,7 @@ function sendOne(memberTarget, memberPrompt, opts = {}) {
       target: memberTarget,
       prompt: enriched,
       from: fromKey,
+      source_sender_id: sourceSenderId,
       new_session: newSession,
       created_at: ts,
       ts,
@@ -141,6 +149,10 @@ function sendRemoteViaRelay(peer, project, memberPrompt) {
     console.error('dispatch_to: feishu.remote_dispatch not configured or disabled');
     process.exit(1);
   }
+  if (!rd.secret) {
+    console.error('dispatch_to: remote dispatch secret missing; run /dispatch code then /dispatch pair <code>');
+    process.exit(1);
+  }
   const ts = new Date().toISOString();
   const id = `${rd.selfPeer}_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
   const body = encodePacket({
@@ -151,11 +163,11 @@ function sendRemoteViaRelay(peer, project, memberPrompt) {
     target_project: project,
     prompt: memberPrompt,
     source_sender_key: fromKey,
+    source_sender_id: sourceSenderId,
   }, rd.secret);
 
   // Write to dispatch/remote-pending.jsonl for daemon to pick up and send via bot
   const remotePending = path.join(DISPATCH_DIR, 'remote-pending.jsonl');
-  fs.mkdirSync(DISPATCH_DIR, { recursive: true });
   fs.appendFileSync(remotePending, JSON.stringify({ relay_chat_id: rd.chatId, body }) + '\n');
   console.log(`DISPATCH_OK(remote): ${peer}:${project} → ${memberPrompt.slice(0, 60)}`);
 }
@@ -187,7 +199,7 @@ if (teamMode) {
   // Await all dispatches before exiting so async socket/file ops complete
   Promise.all(team.map((member) => {
     const roster = buildTeamRosterHint(target, member.key, config.projects);
-    const enriched = buildEnrichedPrompt(member.key, prompt, METAME_DIR);
+    const enriched = buildEnrichedPrompt(member.key, prompt, METAME_DIR, { includeShared: true });
     const memberPrompt = roster ? `${roster}\n\n---\n${enriched}` : enriched;
     // Remote member → relay dispatch
     if (member.peer) {
@@ -201,7 +213,7 @@ if (teamMode) {
 // ── Normal single-target dispatch ─────────────────────────────────────────────
 const remoteTarget = parseRemoteTargetRef(target);
 if (remoteTarget) {
-  const enriched = buildEnrichedPrompt(remoteTarget.project, prompt, METAME_DIR);
+  const enriched = buildEnrichedPrompt(remoteTarget.project, prompt, METAME_DIR, { includeShared: false });
   sendRemoteViaRelay(remoteTarget.peer, remoteTarget.project, enriched);
   process.exit(0);
 } else {

package/scripts/bin/push-clean.sh

@@ -0,0 +1,72 @@
+#!/usr/bin/env bash
+# push-clean.sh — Push to remote, stripping local-only checkpoint/safety commits.
+#
+# Usage:  npm run push
+#
+# What it does:
+#   1. Collects non-checkpoint commits between origin/main and HEAD (in order).
+#   2. If none exist → plain `git push` (nothing to strip).
+#   3. Otherwise → cherry-picks them onto a temp branch based at origin/main,
+#      pushes that branch as origin/main, then resets local main to match remote.
+
+set -euo pipefail
+
+REMOTE="${METAME_PUSH_REMOTE:-origin}"
+BRANCH="${METAME_PUSH_BRANCH:-main}"
+TEMP_BRANCH="_push-clean-$(date +%s)"
+
+upstream="$REMOTE/$BRANCH"
+
+# ── 1. Fetch so we have an up-to-date upstream ref ────────────────────────────
+echo "[push] Fetching $upstream …"
+git fetch "$REMOTE" "$BRANCH" --quiet
+
+# ── 2. Collect ALL commits ahead of upstream (oldest first) ──────────────────
+all_commits=()
+while IFS= read -r sha; do
+  [ -n "$sha" ] && all_commits+=("$sha")
+done < <(git log --reverse --format="%H" "$upstream"..HEAD 2>/dev/null)
+
+if [ ${#all_commits[@]} -eq 0 ]; then
+  echo "[push] Nothing ahead of $upstream — already up to date."
+  exit 0
+fi
+
+# ── 3. Filter out checkpoint/safety commits ───────────────────────────────────
+clean_commits=()
+cp_count=0
+for sha in "${all_commits[@]}"; do
+  subject=$(git log -1 --format="%s" "$sha")
+  if echo "$subject" | grep -qE '^\[metame-checkpoint\]|^\[metame-safety\]'; then
+    cp_count=$((cp_count + 1))
+    echo "[push] Skipping checkpoint: $sha  ${subject:0:60}"
+  else
+    clean_commits+=("$sha")
+  fi
+done
+
+if [ ${#clean_commits[@]} -eq 0 ]; then
+  echo "[push] Only checkpoint commits ahead — nothing to push."
+  exit 0
+fi
+
+echo "[push] Pushing ${#clean_commits[@]} commit(s) (skipping $cp_count checkpoint(s)) …"
+
+# ── 4. Cherry-pick onto a temp branch at upstream ────────────────────────────
+git checkout -q -b "$TEMP_BRANCH" "$upstream"
+
+for sha in "${clean_commits[@]}"; do
+  subject=$(git log -1 --format="%s" "$sha")
+  echo "[push]   cherry-pick $sha  ${subject:0:60}"
+  git cherry-pick --allow-empty --keep-redundant-commits "$sha" --quiet
+done
+
+# ── 5. Push temp branch → remote main ────────────────────────────────────────
+git push "$REMOTE" "$TEMP_BRANCH:$BRANCH"
+
+# ── 6. Reset local main to match remote (fast-forward) ───────────────────────
+git checkout -q "$BRANCH"
+git reset --hard "$REMOTE/$BRANCH"
+git branch -D "$TEMP_BRANCH"
+
+echo "[push] Done. Local $BRANCH is now aligned with $REMOTE/$BRANCH."