metame-cli 1.4.19 → 1.4.21

package/scripts/daemon-task-scheduler.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const crypto = require('crypto');
 const { classifyTaskUsage } = require('./usage-classifier');
 
 const WEEKDAY_INDEX = Object.freeze({
@@ -229,25 +230,29 @@ function createTaskScheduler(deps) {
     if (!task || !task.memory_log) return;
     try {
       const memory = require('./memory');
-      const nowIso = new Date().toISOString();
-      const projectKey = (task._project && task._project.key) || 'heartbeat';
+      memory.acquire();
       const memoryId = `${task.name}-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
-      const summaryText = String(output || '(no output)').trim() || '(no output)';
-      const summary = [
-        `[heartbeat task] ${task.name}`,
-        sessionId ? `session: ${sessionId}` : '',
-        summaryText,
-      ].filter(Boolean).join('\n').slice(0, 8000);
-      const keywords = [task.name, 'heartbeat', 'evolution', nowIso.slice(0, 10)].join(',');
-      memory.saveSession({
-        sessionId: memoryId,
-        project: projectKey,
-        summary,
-        keywords,
-        mood: '',
-        tokenCost: Number(tokenCost) || 0,
-      });
-      memory.close();
+      try {
+        const nowIso = new Date().toISOString();
+        const projectKey = (task._project && task._project.key) || 'heartbeat';
+        const summaryText = String(output || '(no output)').trim() || '(no output)';
+        const summary = [
+          `[heartbeat task] ${task.name}`,
+          sessionId ? `session: ${sessionId}` : '',
+          summaryText,
+        ].filter(Boolean).join('\n').slice(0, 8000);
+        const keywords = [task.name, 'heartbeat', 'evolution', nowIso.slice(0, 10)].join(',');
+        memory.saveSession({
+          sessionId: memoryId,
+          project: projectKey,
+          summary,
+          keywords,
+          mood: '',
+          tokenCost: Number(tokenCost) || 0,
+        });
+      } finally {
+        memory.release();
+      }
       log('INFO', `Task ${task.name}: memory_log saved (${memoryId})`);
     } catch (e) {
       log('WARN', `Task ${task.name}: memory_log failed: ${e.message}`);
@@ -281,7 +286,7 @@ function createTaskScheduler(deps) {
 
     // Workflow tasks: multi-step skill chain via --resume session
     if (task.type === 'workflow') {
-      return executeWorkflow(task, config);
+      return executeWorkflow(task, config, precheck);
     }
 
     // Script tasks: run a local script directly (e.g. distill.js), no claude -p
@@ -488,18 +493,13 @@ function createTaskScheduler(deps) {
 
   // parseInterval — imported from ./utils
 
-  function executeWorkflow(task, config) {
+  function executeWorkflow(task, config, precheck) {
     const state = loadState();
     if (!checkBudget(config, state)) {
       log('WARN', `Budget exceeded, skipping workflow: ${task.name}`);
       return { success: false, error: 'budget_exceeded', output: '' };
     }
-    const precheck = checkPrecondition(task);
-    if (!precheck.pass) {
-      state.tasks[task.name] = { last_run: new Date().toISOString(), status: 'skipped', output_preview: 'Precondition not met' };
-      saveState(state);
-      return { success: true, output: '(skipped)', skipped: true };
-    }
+    // precheck.pass is guaranteed true here — executeTask() already returns early when false
     const steps = task.steps || [];
     if (steps.length === 0) return { success: false, error: 'No steps defined', output: '' };
 
@@ -518,6 +518,7 @@ function createTaskScheduler(deps) {
 
     log('INFO', `Workflow ${task.name}: ${steps.length} steps, session ${sessionId.slice(0, 8)}${mcpConfig ? ', mcp: ' + path.basename(mcpConfig) : ''}`);
 
+    let loopState = loadState();
     for (let i = 0; i < steps.length; i++) {
       const step = steps[i];
       let prompt = (step.skill ? `/${step.skill} ` : '') + (step.prompt || '');
@@ -546,19 +547,19 @@ function createTaskScheduler(deps) {
         totalTokens += tk;
         outputs.push({ step: i + 1, skill: step.skill || null, output: output.slice(0, 500), tokens: tk });
         log('INFO', `Workflow ${task.name} step ${i + 1} done (${tk} tokens)`);
-        if (!checkBudget(config, loadState())) { log('WARN', 'Budget exceeded mid-workflow'); break; }
+        if (!checkBudget(config, loopState)) { log('WARN', 'Budget exceeded mid-workflow'); break; }
       } catch (e) {
         log('ERROR', `Workflow ${task.name} step ${i + 1} failed: ${e.message.slice(0, 200)}`);
         outputs.push({ step: i + 1, skill: step.skill || null, error: e.message.slice(0, 200) });
         if (!step.optional) {
-          recordTokens(loadState(), totalTokens, { category: classifyTaskUsage(task) });
+          recordTokens(loopState, totalTokens, { category: classifyTaskUsage(task) });
           state.tasks[task.name] = { last_run: new Date().toISOString(), status: 'error', error: `Step ${i + 1} failed`, steps_completed: i, steps_total: steps.length };
           saveState(state);
           return { success: false, error: `Step ${i + 1} failed`, output: outputs.map(o => `Step ${o.step}: ${o.error ? 'FAILED' : 'OK'}`).join('\n'), tokens: totalTokens };
         }
       }
     }
-    recordTokens(loadState(), totalTokens, { category: classifyTaskUsage(task) });
+    recordTokens(loopState, totalTokens, { category: classifyTaskUsage(task) });
     const lastOk = [...outputs].reverse().find(o => !o.error);
     state.tasks[task.name] = { last_run: new Date().toISOString(), status: 'success', output_preview: (lastOk ? lastOk.output : '').slice(0, 200), steps_completed: outputs.filter(o => !o.error).length, steps_total: steps.length };
     saveState(state);

package/scripts/daemon.js

@@ -248,11 +248,11 @@ function restoreConfig() {
       }
     }
     writeConfigSafe(bakCfg);
-    config = loadConfig();
+    config = loadConfig(); // eslint-disable-line no-undef -- config is declared in main() closure
     return true;
   } catch {
     fs.copyFileSync(bak, CONFIG_FILE);
-    config = loadConfig();
+    config = loadConfig(); // eslint-disable-line no-undef
     return true;
   }
 }
@@ -1352,6 +1352,11 @@ const pendingBinds = new Map(); // chatId -> agentName
 // chatId -> { step: 'dir'|'name'|'desc', dir: string, name: string }
 const pendingAgentFlows = new Map();
 
+// Pending activation: after creating an agent with skipChatBinding=true,
+// store here so any new unbound group can activate it with /activate
+// { agentKey, agentName, cwd, createdAt }
+const pendingActivations = new Map(); // key: agentKey -> activation record
+
 const { handleAdminCommand } = createAdminCommandHandler({
   fs,
   yaml,
@@ -1371,6 +1376,10 @@ const { handleAdminCommand } = createAdminCommandHandler({
   skillEvolution,
   taskBoard,
   taskEnvelope,
+  getActiveProcesses: () => activeProcesses,
+  getMessageQueue: () => messageQueue,
+  loadState,
+  saveState,
 });
 
 const { handleSessionCommand } = createSessionCommandHandler({
@@ -1492,6 +1501,7 @@ const { handleAgentCommand } = createAgentCommandHandler({
   getSessionRecentContext,
   pendingBinds,
   pendingAgentFlows,
+  pendingActivations,
   doBindAgent,
   mergeAgentRole,
   agentTools,
@@ -1569,6 +1579,7 @@ const { handleCommand } = createCommandRouter({
   log,
   agentTools,
   pendingAgentFlows,
+  pendingActivations,
   agentFlowTtlMs: getAgentFlowTtlMs,
 });
 
@@ -1589,6 +1600,7 @@ const { startTelegramBridge, startFeishuBridge } = createBridgeStarter({
   saveState,
   getSession,
   handleCommand,
+  pendingActivations,
 });
 
 const { killExistingDaemon, writePid, cleanPid } = createPidManager({
@@ -1740,7 +1752,10 @@ async function main() {
     setConfig: (next) => { config = next; },
     getHeartbeatTimer: () => heartbeatTimer,
     setHeartbeatTimer: (next) => { heartbeatTimer = next; },
-    onRestartRequested: () => process.exit(0),
+    onRestartRequested: () => {
+      // Reuse full shutdown logic (kill child processes, clean PID, stop bridges)
+      shutdown().catch(() => process.exit(0));
+    },
   });
   // Expose reloadConfig to handleCommand via closure
   global._metameReload = runtimeWatchers.reloadConfig;
@@ -1754,9 +1769,26 @@ async function main() {
   await sleep(1500); // Let polling settle
   await adminNotifyFn('✅ Daemon ready.').catch(() => { });
 
+  // Notify active users before restart/shutdown
+  async function notifyActiveUsers(reason) {
+    if (activeProcesses.size === 0) return;
+    const bots = [];
+    if (feishuBridge && feishuBridge.bot) bots.push(feishuBridge.bot);
+    if (telegramBridge && telegramBridge.bot) bots.push(telegramBridge.bot);
+    if (bots.length === 0) return;
+    const notifs = [];
+    for (const [cid] of activeProcesses) {
+      for (const bot of bots) {
+        notifs.push(bot.sendMessage(cid, `⚠️ 系统正在重启（${reason}），任务已中断，请重新发送指令。`).catch(() => {}));
+      }
+    }
+    await Promise.race([Promise.all(notifs), new Promise(r => setTimeout(r, 3000))]);
+  }
+
   // Graceful shutdown
-  const shutdown = () => {
+  const shutdown = async () => {
     log('INFO', 'Daemon shutting down...');
+    await notifyActiveUsers('关闭').catch(() => {});
     runtimeWatchers.stop();
     if (heartbeatTimer) clearInterval(heartbeatTimer);
     if (dispatchSocket) try { dispatchSocket.close(); } catch { }
@@ -1779,8 +1811,8 @@ async function main() {
     process.exit(0);
   };
 
-  process.on('SIGTERM', shutdown);
-  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', () => { shutdown().catch(() => process.exit(0)); });
+  process.on('SIGINT', () => { shutdown().catch(() => process.exit(0)); });
 
   // Keep alive
   log('INFO', 'Daemon running. Send SIGTERM to stop.');

package/scripts/distill.js

@@ -636,15 +636,6 @@ function strategicMerge(profile, updates, lockedKeys, pendingTraits, confidenceM
         break;
       }
 
-      case 'T4':
-        setNested(result, key, value);
-
-        // Auto-set focus_since when focus changes
-        if (key === 'context.focus') {
-          setNested(result, 'context.focus_since', new Date().toISOString().slice(0, 10));
-        }
-        break;
-
       case 'T5':
         setNested(result, key, value);
         break;
@@ -717,9 +708,17 @@ function filterBySchema(obj, parentKey = '') {
     const value = obj[key];
 
     if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
-      const nested = filterBySchema(value, fullKey);
-      if (Object.keys(nested).length > 0) {
-        result[key] = nested;
+      // map type: accept entire object as-is, do not recurse into sub-keys
+      const def = getDefinition(fullKey);
+      if (def && def.type === 'map') {
+        if (hasKey(fullKey) && !isLocked(fullKey)) {
+          result[key] = value;
+        }
+      } else {
+        const nested = filterBySchema(value, fullKey);
+        if (Object.keys(nested).length > 0) {
+          result[key] = nested;
+        }
       }
     } else {
       // Check schema whitelist — allow if key exists and is not locked

package/scripts/memory-gc.js

@@ -0,0 +1,239 @@
+#!/usr/bin/env node
+
+/**
+ * memory-gc.js — Nightly Fact Garbage Collection
+ *
+ * Archives stale, low-frequency facts from memory.db by marking them
+ * with conflict_status = 'ARCHIVED' (soft delete, fully auditable).
+ *
+ * GC criteria (ALL must be true):
+ *   1. last_searched_at older than 30 days (i.e. datetime < now-30d), OR NULL and created_at also older than 30 days
+ *   2. search_count < 3
+ *   3. superseded_by IS NULL          (already-superseded facts excluded)
+ *   4. conflict_status IS NULL OR conflict_status = 'OK'  (skip CONFLICT/ARCHIVED)
+ *   5. relation NOT IN protected set  (user_pref, workflow_rule, arch_convention never archived)
+ *
+ * Protected relations are permanently excluded — they are high-value guardrails
+ * that must survive regardless of search frequency.
+ *
+ * Designed to run nightly at 02:00 via daemon.yaml scheduler.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const HOME = os.homedir();
+const METAME_DIR = path.join(HOME, '.metame');
+const DB_PATH = path.join(METAME_DIR, 'memory.db');
+const LOCK_FILE = path.join(METAME_DIR, 'memory-gc.lock');
+const GC_LOG_FILE = path.join(METAME_DIR, 'memory_gc_log.jsonl');
+
+// Relations that are permanently protected from archival
+const PROTECTED_RELATIONS = ['user_pref', 'workflow_rule', 'arch_convention', 'config_fact'];
+
+// GC threshold: facts older than this many days are candidates
+const STALE_DAYS = 30;
+// GC threshold: facts with fewer searches than this are candidates
+const MIN_SEARCH_COUNT = 3;
+// Lock timeout: if a lock is older than this, it's stale and safe to break
+const LOCK_TIMEOUT_MS = 10 * 60 * 1000; // 10 minutes
+
+/**
+ * Acquire atomic lock using O_EXCL — prevents concurrent GC runs.
+ * Returns the lock fd, or throws if lock is held by a live process.
+ */
+function acquireLock() {
+  try {
+    const fd = fs.openSync(LOCK_FILE, 'wx');
+    fs.writeSync(fd, process.pid.toString());
+    fs.closeSync(fd);
+    return true;
+  } catch (e) {
+    if (e.code === 'EEXIST') {
+      // Check if the lock is stale (crashed process left it behind)
+      try {
+        const lockAge = Date.now() - fs.statSync(LOCK_FILE).mtimeMs;
+        if (lockAge < LOCK_TIMEOUT_MS) {
+          console.log('[MEMORY-GC] Already running (lock held), skipping.');
+          return false;
+        }
+        // Stale lock — remove and re-acquire
+        fs.unlinkSync(LOCK_FILE);
+        const fd = fs.openSync(LOCK_FILE, 'wx');
+        fs.writeSync(fd, process.pid.toString());
+        fs.closeSync(fd);
+        return true;
+      } catch {
+        console.log('[MEMORY-GC] Could not acquire lock, skipping.');
+        return false;
+      }
+    }
+    throw e;
+  }
+}
+
+/**
+ * Release the atomic lock.
+ */
+function releaseLock() {
+  try { fs.unlinkSync(LOCK_FILE); } catch { /* non-fatal */ }
+}
+
+/**
+ * Append a GC run record to the audit log.
+ */
+function writeGcLog(record) {
+  const line = JSON.stringify({ ts: new Date().toISOString(), ...record }) + '\n';
+  try {
+    fs.mkdirSync(path.dirname(GC_LOG_FILE), { recursive: true });
+    fs.appendFileSync(GC_LOG_FILE, line, 'utf8');
+  } catch (e) {
+    console.log(`[MEMORY-GC] Warning: could not write GC log: ${e.message}`);
+  }
+}
+
+/**
+ * Get the on-disk size of the database file in bytes.
+ */
+function getDbSizeBytes() {
+  try { return fs.statSync(DB_PATH).size; } catch { return 0; }
+}
+
+/**
+ * Main GC run.
+ */
+function run() {
+  console.log('[MEMORY-GC] Starting GC run...');
+
+  if (!fs.existsSync(DB_PATH)) {
+    console.log('[MEMORY-GC] memory.db not found, nothing to GC.');
+    return;
+  }
+
+  if (!acquireLock()) {
+    return;
+  }
+
+  let db;
+  try {
+    const { DatabaseSync } = require('node:sqlite');
+    db = new DatabaseSync(DB_PATH);
+
+    db.exec('PRAGMA journal_mode = WAL');
+    db.exec('PRAGMA busy_timeout = 5000');
+
+    const dbSizeBefore = getDbSizeBytes();
+
+    // ── Ensure ARCHIVED status column accepts the new value ──
+    // conflict_status was created with NOT NULL DEFAULT 'OK'; ARCHIVED is a new valid state.
+    // No schema change needed — we just write the string value directly.
+
+    const protectedPlaceholders = PROTECTED_RELATIONS.map(() => '?').join(', ');
+
+    // ── DRY RUN: count candidates and protected exclusions ──
+    console.log(`[MEMORY-GC] Scanning facts older than ${STALE_DAYS} days with search_count < ${MIN_SEARCH_COUNT}...`);
+
+    const countCandidatesStmt = db.prepare(`
+      SELECT COUNT(*) AS cnt
+      FROM facts
+      WHERE (
+        (last_searched_at IS NOT NULL AND last_searched_at < datetime('now', '-${STALE_DAYS} days'))
+        OR
+        (last_searched_at IS NULL AND created_at < datetime('now', '-${STALE_DAYS} days'))
+      )
+      AND search_count < ${MIN_SEARCH_COUNT}
+      AND superseded_by IS NULL
+      AND (conflict_status IS NULL OR conflict_status = 'OK')
+      AND relation NOT IN (${protectedPlaceholders})
+      AND source_type != 'manual'
+    `);
+    const candidateCount = countCandidatesStmt.get(...PROTECTED_RELATIONS).cnt;
+
+    // Count how many facts would be skipped due to the protected-relation guard
+    const countProtectedStmt = db.prepare(`
+      SELECT COUNT(*) AS cnt
+      FROM facts
+      WHERE (
+        (last_searched_at IS NOT NULL AND last_searched_at < datetime('now', '-${STALE_DAYS} days'))
+        OR
+        (last_searched_at IS NULL AND created_at < datetime('now', '-${STALE_DAYS} days'))
+      )
+      AND search_count < ${MIN_SEARCH_COUNT}
+      AND superseded_by IS NULL
+      AND (conflict_status IS NULL OR conflict_status = 'OK')
+      AND (relation IN (${protectedPlaceholders}) OR source_type = 'manual')
+    `);
+    const protectedCount = countProtectedStmt.get(...PROTECTED_RELATIONS).cnt;
+
+    console.log(`[MEMORY-GC] Found ${candidateCount} candidates (excluded ${protectedCount} protected facts)`);
+
+    let archivedCount = 0;
+
+    db.exec('BEGIN IMMEDIATE');
+    try {
+      if (candidateCount > 0) {
+        // ── EXECUTE: archive the candidates ──
+        const updateStmt = db.prepare(`
+          UPDATE facts
+          SET conflict_status = 'ARCHIVED',
+              updated_at = datetime('now')
+          WHERE (
+            (last_searched_at IS NOT NULL AND last_searched_at < datetime('now', '-${STALE_DAYS} days'))
+            OR
+            (last_searched_at IS NULL AND created_at < datetime('now', '-${STALE_DAYS} days'))
+          )
+          AND search_count < ${MIN_SEARCH_COUNT}
+          AND superseded_by IS NULL
+          AND (conflict_status IS NULL OR conflict_status = 'OK')
+          AND relation NOT IN (${protectedPlaceholders})
+          AND source_type != 'manual'
+        `);
+
+        const result = updateStmt.run(...PROTECTED_RELATIONS);
+        archivedCount = result.changes;
+
+        console.log(`[MEMORY-GC] Archived ${archivedCount} facts → conflict_status = 'ARCHIVED'`);
+      } else {
+        console.log('[MEMORY-GC] No candidates to archive.');
+      }
+      db.exec('COMMIT');
+    } catch (e) {
+      try { db.exec('ROLLBACK'); } catch {}
+      throw e;
+    }
+
+    // Run VACUUM to reclaim space (only if we archived something) — outside transaction
+    if (archivedCount > 0) {
+      try {
+        db.exec('VACUUM');
+      } catch { /* non-fatal — WAL mode makes VACUUM occasionally slow */ }
+    }
+
+    const dbSizeAfter = getDbSizeBytes();
+
+    // ── Write audit log ──
+    writeGcLog({
+      archived: archivedCount,
+      skipped_protected: protectedCount,
+      candidates_found: candidateCount,
+      stale_days_threshold: STALE_DAYS,
+      min_search_count_threshold: MIN_SEARCH_COUNT,
+      db_size_before: dbSizeBefore,
+      db_size_after: dbSizeAfter,
+    });
+
+    console.log(`[MEMORY-GC] GC complete. Log: ${GC_LOG_FILE}`);
+
+  } catch (e) {
+    console.error(`[MEMORY-GC] Fatal error: ${e.message}`);
+    process.exitCode = 1;
+  } finally {
+    try { if (db) db.close(); } catch { /* non-fatal */ }
+    releaseLock();
+  }
+}
+
+run();

package/scripts/memory-index.js

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+
+/**
+ * memory-index.js — Auto-generate INDEX.md for ~/.metame/memory/
+ *
+ * Lists all .md files under ~/.metame/memory/ recursively and writes
+ * a structured INDEX.md at the root of that directory.
+ * Serves as an L1 pointer document for context injection.
+ *
+ * Designed to run nightly at 01:30 via daemon.yaml scheduler.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const MEMORY_DIR = path.join(os.homedir(), '.metame', 'memory');
+const INDEX_FILE = path.join(MEMORY_DIR, 'INDEX.md');
+
+/**
+ * Recursively list all .md files under dir, excluding INDEX.md itself.
+ * Returns relative paths (relative to MEMORY_DIR), sorted alphabetically.
+ *
+ * @param {string} dir - absolute directory to scan
+ * @param {string} base - relative prefix to prepend (used in recursion)
+ * @returns {string[]} sorted relative paths
+ */
+function listFiles(dir, base = '') {
+  let results = [];
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return results;
+  }
+
+  for (const entry of entries) {
+    const relPath = base ? `${base}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) {
+      results = results.concat(listFiles(path.join(dir, entry.name), relPath));
+    } else if (entry.isFile() && entry.name.endsWith('.md') && entry.name !== 'INDEX.md') {
+      results.push(relPath);
+    }
+  }
+
+  return results.sort();
+}
+
+/**
+ * Group files by their top-level subdirectory (or root).
+ * @param {string[]} files - relative paths
+ * @returns {Map<string, string[]>}
+ */
+function groupByDir(files) {
+  const groups = new Map();
+  for (const f of files) {
+    const parts = f.split('/');
+    const dir = parts.length > 1 ? parts[0] : '(root)';
+    if (!groups.has(dir)) groups.set(dir, []);
+    groups.get(dir).push(f);
+  }
+  return groups;
+}
+
+/**
+ * Main: scan memory dir and write INDEX.md.
+ */
+function run() {
+  fs.mkdirSync(MEMORY_DIR, { recursive: true });
+
+  const files = listFiles(MEMORY_DIR);
+  const groups = groupByDir(files);
+
+  const lines = [
+    '# Memory Index',
+    '',
+    `_Updated: ${new Date().toISOString()}_`,
+    `_Total files: ${files.length}_`,
+    '',
+  ];
+
+  if (files.length === 0) {
+    lines.push('_(no memory files yet)_');
+  } else {
+    for (const [dir, dirFiles] of groups) {
+      lines.push(`## ${dir}`);
+      lines.push('');
+      for (const f of dirFiles) {
+        lines.push(`- [${path.basename(f, '.md')}](./${f})`);
+      }
+      lines.push('');
+    }
+  }
+
+  fs.writeFileSync(INDEX_FILE, lines.join('\n') + '\n', 'utf8');
+  console.log(`[MEMORY-INDEX] Updated INDEX.md (${files.length} file(s)) → ${INDEX_FILE}`);
+}
+
+if (require.main === module) {
+  run();
+}