metame-cli 1.4.19 → 1.4.21

package/scripts/memory.js

@@ -25,8 +25,17 @@ const fs = require('fs');
 
 const DB_PATH = path.join(os.homedir(), '.metame', 'memory.db');
 
+/** Minimal structured logger. level: 'INFO' | 'WARN' | 'ERROR' */
+function log(level, msg) {
+  const ts = new Date().toISOString();
+  process.stderr.write(`${ts} [${level}] ${msg}\n`);
+}
+
 // Lazy-init: only open DB when first called
 let _db = null;
+// Counts external callers that have called acquire() but not yet release().
+// Internal helpers (getDb, _trackSearch, etc.) do NOT affect this counter.
+let _refCount = 0;
 
 function getDb() {
   if (_db) return _db;
@@ -164,6 +173,9 @@ function getDb() {
   // One-time migration: copy recall_count → search_count for existing rows
   try { _db.exec('UPDATE facts SET search_count = recall_count WHERE recall_count > 0 AND search_count = 0'); } catch {}
 
+  // conflict_status: 'OK' (default) | 'CONFLICT' — set by _detectConflict for non-stateful relations
+  try { _db.exec("ALTER TABLE facts ADD COLUMN conflict_status TEXT NOT NULL DEFAULT 'OK'"); } catch {}
+
   return _db;
 }
 
@@ -260,13 +272,14 @@ function saveFacts(sessionId, project, facts, { scope = null } = {}) {
 
   const insert = db.prepare(`
     INSERT INTO facts (id, entity, relation, value, confidence, source_type, source_id, project, scope, tags, created_at, updated_at)
-    VALUES (?, ?, ?, ?, ?, 'session', ?, ?, ?, ?, datetime('now'), datetime('now'))
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'), datetime('now'))
     ON CONFLICT(id) DO NOTHING
   `);
 
   let saved = 0;
   let skipped = 0;
   let superseded = 0;
+  let conflicts = 0;
   const savedFacts = [];
   const batchDedup = new Set();
 
@@ -287,8 +300,9 @@ function saveFacts(sessionId, project, facts, { scope = null } = {}) {
     const id = `f-${sessionId.slice(0, 8)}-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
     const tags = JSON.stringify(Array.isArray(f.tags) ? f.tags.slice(0, 3) : []);
     try {
+      const sourceType = f.source_type || 'session';
       insert.run(id, f.entity, f.relation, f.value.slice(0, 300),
-        f.confidence || 'medium', sessionId, normalizedProject, normalizedScope, tags);
+        f.confidence || 'medium', sourceType, sessionId, normalizedProject, normalizedScope, tags);
       batchDedup.add(dedupKey);
       savedFacts.push({ id, entity: f.entity, relation: f.relation, value: f.value,
         project: normalizedProject, scope: normalizedScope, tags: f.tags || [], created_at: new Date().toISOString() });
@@ -328,6 +342,20 @@ function saveFacts(sessionId, project, facts, { scope = null } = {}) {
         if (changes > 0) {
           _logSupersede(toSupersede, id, f.entity, f.relation, f.value, sessionId);
         }
+      } else {
+        // Conflict detection for non-stateful relations
+        let whereSql = '';
+        let filterParams = [];
+        if (normalizedScope === '*') {
+          whereSql = `((scope = '*') OR (scope IS NULL AND project = '*'))`;
+        } else if (normalizedScope) {
+          whereSql = `((scope = ?) OR (scope IS NULL AND project = ?))`;
+          filterParams = [normalizedScope, normalizedProject];
+        } else {
+          whereSql = `(project IN (?, '*'))`;
+          filterParams = [normalizedProject];
+        }
+        conflicts += _detectConflict(db, f, id, whereSql, filterParams, sessionId);
       }
     } catch { skipped++; }
   }
@@ -339,7 +367,9 @@ function saveFacts(sessionId, project, facts, { scope = null } = {}) {
     if (qmdClient) qmdClient.upsertFacts(savedFacts);
   }
 
-  return { saved, skipped, superseded };
+  if (conflicts > 0) log('WARN', `[MEMORY] ${conflicts} conflict(s) detected`);
+
+  return { saved, skipped, superseded, conflicts };
 }
 
 /**
@@ -361,6 +391,7 @@ function _trackSearch(ids) {
 }
 
 const SUPERSEDE_LOG = path.join(os.homedir(), '.metame', 'memory_supersede_log.jsonl');
+const CONFLICT_LOG  = path.join(os.homedir(), '.metame', 'memory_conflict_log.jsonl');
 
 /**
  * Append supersede operations to audit log (append-only, never mutated).
@@ -383,6 +414,77 @@ function _logSupersede(oldFacts, newId, entity, relation, newValue, sessionId) {
   } catch { /* non-fatal */ }
 }
 
+/**
+ * Detect value conflicts for non-stateful facts.
+ *
+ * When a new fact (entity, relation) already has an active record whose value
+ * differs significantly from the incoming value, both are flagged CONFLICT.
+ * "Significant difference" = trimmed values are not equal AND neither contains
+ * the other as a substring (handles minor rewording and prefix matches).
+ *
+ * @param {object} db            - DatabaseSync instance
+ * @param {object} fact          - The newly-inserted fact { entity, relation, value }
+ * @param {string} newId         - Row ID of the newly-inserted fact
+ * @param {string} whereSql      - Scope WHERE clause (reused from saveFacts)
+ * @param {Array}  filterParams  - Bind params for whereSql
+ * @param {string} sessionId     - Source session ID (for audit log)
+ * @returns {number} Number of conflicts detected (0 or more)
+ */
+function _detectConflict(db, fact, newId, whereSql, filterParams, sessionId) {
+  try {
+    const existing = db.prepare(
+      `SELECT id, value FROM facts
+       WHERE entity = ? AND relation = ? AND id != ? AND superseded_by IS NULL
+         AND (conflict_status IS NULL OR conflict_status NOT IN ('ARCHIVED', 'CONFLICT'))
+         AND ${whereSql}`
+    ).all(fact.entity, fact.relation, newId, ...filterParams);
+
+    if (existing.length === 0) return 0;
+
+    const newVal = fact.value.trim();
+    let conflictCount = 0;
+
+    const conflicting = [];
+    for (const row of existing) {
+      const oldVal = row.value.trim();
+      // Skip if values are equivalent or one contains the other
+      if (oldVal === newVal) continue;
+      if (oldVal.includes(newVal) || newVal.includes(oldVal)) continue;
+
+      // Mark existing record as CONFLICT
+      db.prepare(
+        `UPDATE facts SET conflict_status = 'CONFLICT', updated_at = datetime('now') WHERE id = ?`
+      ).run(row.id);
+
+      conflicting.push({ id: row.id, value: row.value.slice(0, 80) });
+      conflictCount++;
+    }
+
+    if (conflictCount > 0) {
+      // Mark the new fact as CONFLICT too
+      db.prepare(
+        `UPDATE facts SET conflict_status = 'CONFLICT', updated_at = datetime('now') WHERE id = ?`
+      ).run(newId);
+
+      // Audit log (append-only, never mutated)
+      try {
+        const entry = {
+          ts: new Date().toISOString(),
+          entity: fact.entity,
+          relation: fact.relation,
+          new_id: newId,
+          new_value: fact.value.slice(0, 80),
+          session_id: sessionId,
+          conflicting,
+        };
+        fs.appendFileSync(CONFLICT_LOG, JSON.stringify(entry) + '\n', 'utf8');
+      } catch { /* non-fatal */ }
+    }
+
+    return conflictCount;
+  } catch { return 0; }
+}
+
 /**
  * Scope filter semantics (new + legacy):
  * - New rows: prefer `scope` exact match or global scope '*'
@@ -426,7 +528,8 @@ async function searchFactsAsync(query, { limit = 5, project = null, scope = null
         const placeholders = ids.map(() => '?').join(',');
         let rows = db.prepare(
           `SELECT id, entity, relation, value, confidence, project, scope, tags, created_at
-           FROM facts WHERE id IN (${placeholders}) AND superseded_by IS NULL`
+           FROM facts WHERE id IN (${placeholders}) AND superseded_by IS NULL
+           AND (conflict_status IS NULL OR conflict_status NOT IN ('ARCHIVED', 'CONFLICT'))`
         ).all(...ids);
 
         // Apply project/scope filter
@@ -476,6 +579,7 @@ function searchFacts(query, { limit = 5, project = null, scope = null } = {}) {
         WHERE facts_fts MATCH ?
           AND ((f.scope = ? OR f.scope = '*') OR (f.scope IS NULL AND (f.project = ? OR f.project = '*')))
           AND f.superseded_by IS NULL
+          AND (f.conflict_status IS NULL OR f.conflict_status NOT IN ('ARCHIVED', 'CONFLICT'))
         ORDER BY rank LIMIT ?
       `;
       params = [sanitized, scope, project, limit];
@@ -484,6 +588,7 @@ function searchFacts(query, { limit = 5, project = null, scope = null } = {}) {
         SELECT f.id, f.entity, f.relation, f.value, f.confidence, f.project, f.scope, f.tags, f.created_at, rank
         FROM facts_fts fts JOIN facts f ON f.rowid = fts.rowid
         WHERE facts_fts MATCH ? AND (f.scope = ? OR f.scope = '*') AND f.superseded_by IS NULL
+          AND (f.conflict_status IS NULL OR f.conflict_status NOT IN ('ARCHIVED', 'CONFLICT'))
         ORDER BY rank LIMIT ?
       `;
       params = [sanitized, scope, limit];
@@ -492,6 +597,7 @@ function searchFacts(query, { limit = 5, project = null, scope = null } = {}) {
         SELECT f.id, f.entity, f.relation, f.value, f.confidence, f.project, f.scope, f.tags, f.created_at, rank
         FROM facts_fts fts JOIN facts f ON f.rowid = fts.rowid
         WHERE facts_fts MATCH ? AND (f.project = ? OR f.project = '*') AND f.superseded_by IS NULL
+          AND (f.conflict_status IS NULL OR f.conflict_status NOT IN ('ARCHIVED', 'CONFLICT'))
         ORDER BY rank LIMIT ?
       `;
       params = [sanitized, project, limit];
@@ -500,6 +606,7 @@ function searchFacts(query, { limit = 5, project = null, scope = null } = {}) {
         SELECT f.id, f.entity, f.relation, f.value, f.confidence, f.project, f.scope, f.tags, f.created_at, rank
         FROM facts_fts fts JOIN facts f ON f.rowid = fts.rowid
         WHERE facts_fts MATCH ? AND f.superseded_by IS NULL
+          AND (f.conflict_status IS NULL OR f.conflict_status NOT IN ('ARCHIVED', 'CONFLICT'))
         ORDER BY rank LIMIT ?
       `;
       params = [sanitized, limit];
@@ -518,20 +625,24 @@ function searchFacts(query, { limit = 5, project = null, scope = null } = {}) {
        FROM facts WHERE (entity LIKE ? OR value LIKE ? OR tags LIKE ?)
        AND ((scope = ? OR scope = '*') OR (scope IS NULL AND (project = ? OR project = '*')))
        AND superseded_by IS NULL
+       AND (conflict_status IS NULL OR conflict_status NOT IN ('ARCHIVED', 'CONFLICT'))
        ORDER BY created_at DESC LIMIT ?`
     : scope
       ? `SELECT id, entity, relation, value, confidence, project, scope, tags, created_at
        FROM facts WHERE (entity LIKE ? OR value LIKE ? OR tags LIKE ?)
        AND (scope = ? OR scope = '*') AND superseded_by IS NULL
+       AND (conflict_status IS NULL OR conflict_status NOT IN ('ARCHIVED', 'CONFLICT'))
        ORDER BY created_at DESC LIMIT ?`
       : project
         ? `SELECT id, entity, relation, value, confidence, project, scope, tags, created_at
        FROM facts WHERE (entity LIKE ? OR value LIKE ? OR tags LIKE ?)
        AND (project = ? OR project = '*') AND superseded_by IS NULL
+       AND (conflict_status IS NULL OR conflict_status NOT IN ('ARCHIVED', 'CONFLICT'))
        ORDER BY created_at DESC LIMIT ?`
         : `SELECT id, entity, relation, value, confidence, project, scope, tags, created_at
        FROM facts WHERE (entity LIKE ? OR value LIKE ? OR tags LIKE ?)
        AND superseded_by IS NULL
+       AND (conflict_status IS NULL OR conflict_status NOT IN ('ARCHIVED', 'CONFLICT'))
        ORDER BY created_at DESC LIMIT ?`;
   const likeResults = scope && project
     ? db.prepare(likeSql).all(like, like, like, scope, project, limit)
@@ -697,8 +808,35 @@ function stats() {
 /**
  * Close the database connection (for clean shutdown).
  */
-function close() {
+/**
+ * Acquire a reference. Call once per logical "session" (e.g. per task run).
+ * Ensures DB is open and increments the ref count.
+ * Must be paired with a matching release() call.
+ */
+function acquire() {
+  _refCount++;
+  getDb(); // ensure DB is initialised
+}
+
+/**
+ * Release a reference. When the last caller releases, the DB is closed.
+ * Safe to call even if acquire() was never called (no-op when _refCount <= 0).
+ */
+function release() {
+  if (_refCount > 0) _refCount--;
+  if (_refCount === 0 && _db) { _db.close(); _db = null; }
+}
+
+/**
+ * Backwards-compatible alias. Equivalent to release().
+ * External callers that previously called close() continue to work correctly.
+ */
+function close() { release(); }
+
+/** Force-close regardless of ref count. Only call on process exit. */
+function forceClose() {
+  _refCount = 0;
   if (_db) { _db.close(); _db = null; }
 }
 
-module.exports = { saveSession, saveFacts, searchFacts, searchFactsAsync, searchSessions, recentSessions, getSession, stats, close, DB_PATH };
+module.exports = { saveSession, saveFacts, searchFacts, searchFactsAsync, searchSessions, recentSessions, getSession, stats, acquire, release, close, forceClose, DB_PATH };

package/scripts/schema.js

@@ -11,8 +11,11 @@
  *   T1 — Identity (LOCKED, never auto-modify)
  *   T2 — Core Values (LOCKED, deep personality)
  *   T3 — Preferences (auto-writable, needs confidence)
- *   T4 — Context (free overwrite, current state)
  *   T5 — Evolution (system-managed, strict limits)
+ *
+ * NOTE: T4 (Context/Status) was intentionally removed. Work state (focus,
+ * active_projects, blockers) belongs in ~/.metame/memory/NOW.md (task
+ * whiteboard), not in the cognitive profile. This prevents role pollution.
  */
 
 const SCHEMA = {
@@ -49,14 +52,15 @@ const SCHEMA = {
   'cognition.metacognition.receptive_to_challenge': { tier: 'T3', type: 'enum', values: ['yes', 'sometimes', 'no'] },
   'cognition.metacognition.error_response': { tier: 'T3', type: 'enum', values: ['quick_pivot', 'root_cause_first', 'seek_help', 'retry_same'] },
 
-  // === T4: Context ===
-  'context.focus': { tier: 'T4', type: 'string', maxChars: 80 },
-  'context.focus_since': { tier: 'T4', type: 'string' },
-  'context.active_projects': { tier: 'T4', type: 'array', maxItems: 5 },
-  'context.blockers': { tier: 'T4', type: 'array', maxItems: 3 },
-  'context.energy': { tier: 'T4', type: 'enum', values: ['high', 'medium', 'low', null] },
-  'status.focus': { tier: 'T4', type: 'string', maxChars: 80 },
-  'status.language': { tier: 'T4', type: 'string' },
+  // === T3c: User Competence Map (ZPD scaffolding) ===
+  'user_competence_map': {
+    tier: 'T3',
+    type: 'map',         // dynamic key-value, keys are domain names
+    valueType: 'enum',
+    values: ['beginner', 'intermediate', 'expert'],
+    maxKeys: 20,
+    description: 'Per-domain skill level for ZPD-based explanation depth'
+  },
 
   // === T5: Evolution (system-managed) ===
   'evolution.last_distill': { tier: 'T5', type: 'string' },
@@ -144,6 +148,23 @@ function validate(key, value) {
     }
   }
 
+  if (def.type === 'map') {
+    if (typeof value !== 'object' || Array.isArray(value)) {
+      return { valid: false, reason: `${key} must be an object (map)` };
+    }
+    if (def.maxKeys && Object.keys(value).length > def.maxKeys) {
+      return { valid: false, reason: `${key} exceeds maxKeys (${def.maxKeys})` };
+    }
+    if (def.values) {
+      for (const [k, v] of Object.entries(value)) {
+        if (!def.values.includes(v)) {
+          return { valid: false, reason: `${key}.${k} must be one of: ${def.values.join(', ')}` };
+        }
+      }
+    }
+    return { valid: true };
+  }
+
   return { valid: true };
 }
 

package/scripts/self-reflect.js

@@ -1,13 +1,15 @@
 #!/usr/bin/env node
 
 /**
- * self-reflect.js — Weekly Self-Reflection Task
+ * self-reflect.js — Daily Self-Reflection Task
  *
  * Scans correction/metacognitive signals from the past 7 days,
  * aggregates "where did the AI get it wrong", and writes a brief
  * self-critique pattern into growth.patterns in ~/.claude_profile.yaml.
  *
- * Heartbeat: weekly, require_idle, non-blocking.
+ * Also distills correction signals into lessons/ SOP markdown files.
+ *
+ * Heartbeat: nightly at 23:00, require_idle, non-blocking.
  */
 
 'use strict';
@@ -16,13 +18,111 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const { callHaiku, buildDistillEnv } = require('./providers');
+const { writeBrainFileSafe } = require('./utils');
 
 const HOME = os.homedir();
 const SIGNAL_FILE = path.join(HOME, '.metame', 'raw_signals.jsonl');
 const BRAIN_FILE = path.join(HOME, '.claude_profile.yaml');
 const LOCK_FILE = path.join(HOME, '.metame', 'self-reflect.lock');
+const LESSONS_DIR = path.join(HOME, '.metame', 'memory', 'lessons');
 const WINDOW_DAYS = 7;
 
+/**
+ * Distill correction signals into reusable SOP markdown files.
+ * Each run produces at most one lesson file per unique slug.
+ * Returns the number of lesson files actually written.
+ *
+ * @param {Array} signals - all recent signals (will filter to 'correction' type internally)
+ * @param {string} lessonsDir - absolute path where lesson .md files are written
+ */
+async function generateLessons(signals, lessonsDir) {
+  // Only process correction signals that carry explicit feedback
+  const corrections = signals.filter(s => s.type === 'correction' && s.feedback);
+  if (corrections.length < 2) {
+    console.log(`[self-reflect] Only ${corrections.length} correction signal(s) with feedback, skipping lessons.`);
+    return 0;
+  }
+
+  fs.mkdirSync(lessonsDir, { recursive: true });
+
+  const correctionText = corrections
+    .slice(-15) // cap to avoid prompt bloat
+    .map(c => `- Prompt: ${(c.prompt || '').slice(0, 100)}\n  Feedback: ${(c.feedback || '').slice(0, 150)}`)
+    .join('\n');
+
+  const prompt = `You are distilling correction signals into a reusable SOP for an AI assistant.
+
+Corrections (JSON):
+${correctionText}
+
+Generate ONE actionable lesson in this JSON format:
+{
+  "title": "简短标题（中文，10字以内）",
+  "slug": "kebab-case-english-slug",
+  "content": "## 问题\\n...\\n## 根因\\n...\\n## 操作手册\\n1. ...\\n2. ...\\n3. ..."
+}
+
+Rules: content must be in 中文, concrete and actionable, 100-300 chars total.
+Only output the JSON object, no explanation.`;
+
+  let distillEnv = {};
+  try { distillEnv = buildDistillEnv(); } catch {}
+
+  let result;
+  try {
+    result = await Promise.race([
+      callHaiku(prompt, distillEnv, 60000),
+      new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), 90000)),
+    ]);
+  } catch (e) {
+    console.log(`[self-reflect] generateLessons Haiku call failed: ${e.message}`);
+    return 0;
+  }
+
+  let lesson;
+  try {
+    const cleaned = result.replace(/```json\n?/g, '').replace(/```\n?/g, '').trim();
+    lesson = JSON.parse(cleaned);
+    if (!lesson.title || !lesson.slug || !lesson.content) throw new Error('missing fields');
+  } catch (e) {
+    console.log(`[self-reflect] Failed to parse lesson JSON: ${e.message}`);
+    return 0;
+  }
+
+  // Sanitize slug: only lowercase alphanumeric and hyphens
+  const slug = (lesson.slug || '').toLowerCase().replace(/[^a-z0-9-]/g, '-').replace(/-+/g, '-').replace(/^-|-$/g, '');
+  if (!slug) {
+    console.log('[self-reflect] generateLessons: empty slug, skipping');
+    return 0;
+  }
+
+  // Prevent duplicates: skip if any existing file already uses this slug
+  const existing = fs.readdirSync(lessonsDir).filter(f => f.endsWith(`-${slug}.md`));
+  if (existing.length > 0) {
+    console.log(`[self-reflect] Lesson '${slug}' already exists (${existing[0]}), skipping.`);
+    return 0;
+  }
+
+  const today = new Date().toISOString().slice(0, 10);
+  const filename = `${today}-${slug}.md`;
+  const filepath = path.join(lessonsDir, filename);
+
+  const fileContent = `---
+date: ${today}
+source: self-reflect
+corrections: ${corrections.length}
+---
+
+# ${lesson.title}
+
+${lesson.content}
+`;
+
+  fs.writeFileSync(filepath, fileContent, 'utf8');
+  console.log(`[self-reflect] Lesson written: ${filepath}`);
+  return 1;
+}
+
 async function run() {
   // Atomic lock
   let lockFd;
@@ -35,7 +135,12 @@ async function run() {
       const age = Date.now() - fs.statSync(LOCK_FILE).mtimeMs;
       if (age < 300000) { console.log('[self-reflect] Already running.'); return; }
       fs.unlinkSync(LOCK_FILE);
-      lockFd = fs.openSync(LOCK_FILE, 'wx');
+      try {
+        lockFd = fs.openSync(LOCK_FILE, 'wx');
+      } catch {
+        // Another process acquired the lock
+        return;
+      }
       fs.writeSync(lockFd, process.pid.toString());
       fs.closeSync(lockFd);
     } else throw e;
@@ -105,7 +210,8 @@ ${signalText}
     try {
       result = await Promise.race([
         callHaiku(prompt, distillEnv, 60000),
-        new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), 65000)),
+        // outer safety net in case callHaiku's internal timeout doesn't propagate
+        new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), 90000)),
       ]);
     } catch (e) {
       console.log(`[self-reflect] Haiku call failed: ${e.message}`);
@@ -125,6 +231,16 @@ ${signalText}
       return;
     }
 
+    // === Generate lessons/ from correction signals (independent of patterns result) ===
+    try {
+      const lessonsCount = await generateLessons(recentSignals, LESSONS_DIR);
+      if (lessonsCount > 0) {
+        console.log(`[self-reflect] Generated ${lessonsCount} lesson(s) in ${LESSONS_DIR}`);
+      }
+    } catch (e) {
+      console.log(`[self-reflect] generateLessons failed (non-fatal): ${e.message}`);
+    }
+
     if (patterns.length === 0) {
       console.log('[self-reflect] No patterns found this week.');
       return;
@@ -146,7 +262,7 @@ ${signalText}
 
       // Preserve locked lines (simple approach: only update growth section)
       const dumped = yaml.dump(profile, { lineWidth: -1 });
-      fs.writeFileSync(BRAIN_FILE, dumped, 'utf8');
+      await writeBrainFileSafe(dumped);
       console.log(`[self-reflect] ${patterns.length} pattern(s) written to growth.patterns: ${patterns.join(' | ')}`);
     } catch (e) {
       console.log(`[self-reflect] Failed to write profile: ${e.message}`);

package/scripts/session-analytics.js

@@ -576,17 +576,16 @@ function findSessionById(sessionId) {
  * Read declared goals from the user's profile.
  * Returns a compact string like "DECLARED_GOALS: focus1 | focus2" (~11 tokens).
  */
-function formatGoalContext(profilePath) {
+function formatGoalContext(_profilePath) {
+  // Work state now lives in NOW.md (task whiteboard), not in the profile.
   try {
-    const yaml = require('js-yaml');
-    const profile = yaml.load(fs.readFileSync(profilePath, 'utf8')) || {};
-    const goals = [];
-    if (profile.status && profile.status.focus) goals.push(profile.status.focus);
-    if (profile.context && profile.context.focus && profile.context.focus !== (profile.status && profile.status.focus)) {
-      goals.push(profile.context.focus);
-    }
-    if (goals.length === 0) return '';
-    return `DECLARED_GOALS: ${goals.join(' | ')}`;
+    const nowPath = path.join(HOME, '.metame', 'memory', 'NOW.md');
+    if (!fs.existsSync(nowPath)) return '';
+    const content = fs.readFileSync(nowPath, 'utf8').trim();
+    if (!content) return '';
+    // Truncate to avoid bloating prompts
+    const truncated = content.length > 300 ? content.slice(0, 300) + '…' : content;
+    return `CURRENT_TASK:\n${truncated}`;
   } catch { return ''; }
 }
 

package/scripts/task-board.js

@@ -73,9 +73,15 @@ function createTaskBoard(opts = {}) {
         updated_at          TEXT NOT NULL
       )
     `);
-    try { db.exec("ALTER TABLE tasks ADD COLUMN scope_id TEXT NOT NULL DEFAULT ''"); } catch {}
-    try { db.exec("ALTER TABLE tasks ADD COLUMN task_kind TEXT NOT NULL DEFAULT 'team'"); } catch {}
-    try { db.exec("ALTER TABLE tasks ADD COLUMN participants TEXT NOT NULL DEFAULT '[]'"); } catch {}
+    for (const col of [
+      "ALTER TABLE tasks ADD COLUMN scope_id TEXT NOT NULL DEFAULT ''",
+      "ALTER TABLE tasks ADD COLUMN task_kind TEXT NOT NULL DEFAULT 'team'",
+      "ALTER TABLE tasks ADD COLUMN participants TEXT NOT NULL DEFAULT '[]'",
+    ]) {
+      try { db.exec(col); } catch (e) {
+        if (!e.message.includes('duplicate column name')) throw e;
+      }
+    }
 
     db.exec(`
       CREATE TABLE IF NOT EXISTS handoffs (

package/scripts/telegram-adapter.js

@@ -122,19 +122,21 @@ function createBot(token) {
      * @param {string} markdown - Markdown text
      */
     async sendMarkdown(chatId, markdown) {
-      const chunks = splitMessage(markdown, 4096);
+      // Convert first, then split — avoids mid-token cuts and length underestimation
+      const converted = toTelegramMarkdownV2(markdown);
+      const chunks = splitMessage(converted, 4096);
       for (const chunk of chunks) {
         try {
           await apiRequest(token, 'sendMessage', {
             chat_id: chatId,
             text: chunk,
-            parse_mode: 'Markdown',
+            parse_mode: 'MarkdownV2',
           });
         } catch {
-          // Fallback to plain text if markdown parsing fails
+          // Fallback: send stripped plain text
           await apiRequest(token, 'sendMessage', {
             chat_id: chatId,
-            text: chunk,
+            text: stripMarkdown(markdown).slice(0, 4096),
           });
         }
       }
@@ -179,11 +181,21 @@ function createBot(token) {
      * @param {string} text
      */
     async editMessage(chatId, messageId, text) {
-      await apiRequest(token, 'editMessageText', {
-        chat_id: chatId,
-        message_id: messageId,
-        text: text.slice(0, 4096),
-      });
+      const converted = toTelegramMarkdownV2(text).slice(0, 4096);
+      try {
+        await apiRequest(token, 'editMessageText', {
+          chat_id: chatId,
+          message_id: messageId,
+          text: converted,
+          parse_mode: 'MarkdownV2',
+        });
+      } catch {
+        await apiRequest(token, 'editMessageText', {
+          chat_id: chatId,
+          message_id: messageId,
+          text: stripMarkdown(text).slice(0, 4096),
+        });
+      }
     },
 
     /**
@@ -336,4 +348,60 @@ function splitMessage(text, maxLen) {
   return chunks;
 }
 
+/**
+ * Convert standard Markdown to Telegram MarkdownV2 format.
+ *
+ * Mapping:  **bold** → *bold*,  *italic* → _italic_,  # Heading → *Heading*
+ * All MarkdownV2 special chars in plain text are escaped with backslash.
+ */
+function toTelegramMarkdownV2(md) {
+  const escapePlain = s => s.replace(/([_*[\]()~`>#+\-=|{}.!\\])/g, '\\$1');
+
+  // Order matters: code blocks → inline code → bold (before italic) → links → headings → blockquotes
+  // Note: bold uses [\s\S]+? to allow * inside; _italic_ only matches boundary underscores
+  //   (_[^_\n]+_ would match snake_case — use word-boundary aware pattern instead)
+  const pattern = /```(?:\w*\n?)?([\s\S]*?)```|`([^`\n]+)`|\*\*([\s\S]+?)\*\*|\*([^*\n]+)\*|(?<!\w)_([^_\n]+)_(?!\w)|\[([^\]]+)\]\(([^)\s]+)\)|^(#{1,6}) (.+)$|^(>.+(?:\n>.*)*)$/mg;
+
+  let out = '';
+  let last = 0;
+  let m;
+
+  while ((m = pattern.exec(md)) !== null) {
+    if (m.index > last) out += escapePlain(md.slice(last, m.index));
+
+    if      (m[1] !== undefined) out += '```' + m[1].replace(/[`\\]/g, '\\$&') + '```';
+    else if (m[2] !== undefined) out += '`'   + m[2].replace(/[`\\]/g, '\\$&') + '`';
+    else if (m[3] !== undefined) out += '*'   + toTelegramMarkdownV2(m[3]) + '*';
+    else if (m[4] !== undefined) out += '_'   + toTelegramMarkdownV2(m[4]) + '_';
+    else if (m[5] !== undefined) out += '_'   + toTelegramMarkdownV2(m[5]) + '_';
+    else if (m[6] !== undefined) out += '[' + toTelegramMarkdownV2(m[6]) + '](' + m[7].replace(/[()\\]/g, '\\$&') + ')';
+    else if (m[9] !== undefined) out += '*' + escapePlain(m[9]) + '*';
+    else if (m[10] !== undefined) {
+      // > blockquote — prefix each line with TG quote syntax
+      const lines = m[10].split('\n').map(l => '>' + escapePlain(l.replace(/^>\s?/, '')));
+      out += lines.join('\n');
+    }
+
+    last = m.index + m[0].length;
+  }
+
+  if (last < md.length) out += escapePlain(md.slice(last));
+  return out;
+}
+
+/**
+ * Strip all Markdown formatting, returning plain text.
+ * Used as fallback when MarkdownV2 rendering fails.
+ */
+function stripMarkdown(md) {
+  return md
+    .replace(/```[\s\S]*?```/g, m => m.replace(/^```\w*\n?/, '').replace(/```$/, ''))
+    .replace(/`([^`]+)`/g, '$1')
+    .replace(/\*\*([^*]+)\*\*/g, '$1')
+    .replace(/\*([^*\n]+)\*/g, '$1')
+    .replace(/_([^_\n]+)_/g, '$1')
+    .replace(/^#{1,6} (.+)$/mg, '$1')
+    .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1');
+}
+
 module.exports = { createBot };