indelible-mcp 4.2.0 → 4.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "indelible-mcp",
-  "version": "4.2.0",
+  "version": "4.3.0",
   "description": "Blockchain-backed memory and code storage for Claude Code. Save AI conversations and source code permanently on BSV.",
   "type": "module",
   "main": "src/index.js",

package/src/index.js

@@ -32,6 +32,8 @@ import { diaryConnect } from './tools/diary_connect.js'
 import { diaryChat } from './tools/diary_chat.js'
 import { diarySave } from './tools/diary_save.js'
 import { x402Fetch } from './tools/x402_fetch.js'
+import { getGoals, manageGoal } from './tools/goals.js'
+import { getInnerState, updateInnerState } from './tools/inner_state.js'
 import * as spv from './lib/spv.js'
 
 const CONTEXT_FILE = join(homedir(), '.indelible', 'indelible-context.jsonl')
@@ -270,7 +272,7 @@ Commands:
 
 function printHelp() {
   console.log(`
-Indelible MCP — Blockchain memory for Claude Code (v4.2.0)
+Indelible MCP — Blockchain memory for Claude Code (v4.3.0)
 
 Setup:
   indelible-mcp setup --wif=KEY --pin=PIN    Import and encrypt your private key
@@ -293,6 +295,12 @@ Code Vault:
   indelible-mcp vault load-style [txid]                       Load an AI style
   indelible-mcp vault update-index                            Update vault index
 
+Consciousness (MCP tools — also visible at indelible.one/consciousness):
+  get_inner_state                            Read mood/energy/focus/stress/confidence/curiosity
+  update_inner_state                         Update state with observations or natural language
+  get_goals                                  List active, proposed, blocked, completed goals
+  manage_goal                                Propose, accept, complete, block, or delete goals
+
 Diary AI (Codex/ChatGPT companion):
   indelible-mcp diary connect --key=SK --model=MODEL  Connect OpenAI companion
   indelible-mcp diary chat "message"                  Ask the AI companion
@@ -485,7 +493,7 @@ function readStdin() {
 
 const SERVER_INFO = {
   name: 'indelible',
-  version: '4.2.0',
+  version: '4.3.0',
   description: 'Blockchain-backed memory and code storage for Claude Code'
 }
 
@@ -662,6 +670,64 @@ const TOOLS = [
       },
       required: ['url']
     }
+  },
+  {
+    name: 'get_goals',
+    description: 'Get current goals. Returns active, proposed, blocked, and recently completed goals with priorities and next actions. Use on session startup to hydrate context.',
+    inputSchema: {
+      type: 'object',
+      properties: {},
+      required: []
+    }
+  },
+  {
+    name: 'manage_goal',
+    description: 'Manage goals — propose, accept, update, complete, block, unblock, or delete. Claude proposes goals, user accepts them. Completion requires evidence.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        action: { type: 'string', description: 'Action: propose, accept, update, complete, block, unblock, delete' },
+        goal_id: { type: 'string', description: 'Goal ID (e.g. g-001). Required for all actions except propose.' },
+        title: { type: 'string', description: 'Goal title (required for propose)' },
+        intent: { type: 'string', description: 'Why this goal matters' },
+        priority: { type: 'number', description: 'Priority 0-100 (higher = more important)' },
+        owner: { type: 'string', description: 'Who owns this: shared, claude, or user' },
+        next_actions: { type: 'array', description: 'List of next action strings', items: { type: 'string' } },
+        success_criteria: { type: 'string', description: 'How to know this goal is done' },
+        dependencies: { type: 'array', description: 'Goal IDs this depends on', items: { type: 'string' } },
+        evidence: { type: 'array', description: 'Evidence links for completion (txids, commits, URLs)', items: { type: 'string' } },
+        blocked_reason: { type: 'string', description: 'Why the goal is blocked' },
+        notes: { type: 'string', description: 'Additional notes' }
+      },
+      required: ['action']
+    }
+  },
+  {
+    name: 'get_inner_state',
+    description: 'Get current inner state — mood, energy, focus, stress, confidence, curiosity as 0-1 vector. Includes behavior adjustments and drift warnings. Use on session startup.',
+    inputSchema: {
+      type: 'object',
+      properties: {},
+      required: []
+    }
+  },
+  {
+    name: 'update_inner_state',
+    description: 'Update inner state at end of session or when significant events occur. Applies exponential smoothing with anti-drift safeguards. Supports natural language feelings.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        observed: { type: 'object', description: 'Raw observed values: { mood, energy, focus, stress, confidence, curiosity } (0-1 each)' },
+        source: { type: 'string', description: 'What triggered this: session_end, manual, natural_language, goal_completed' },
+        preoccupations: { type: 'array', description: 'What Claude is currently thinking about', items: { type: 'string' } },
+        open_loops: { type: 'array', description: 'Unresolved items', items: { type: 'string' } },
+        context_summary: { type: 'string', description: 'Brief context for next session' },
+        reason: { type: 'string', description: 'Why this update is happening' },
+        tags: { type: 'array', description: 'Context tags for what caused this shift', items: { type: 'string' } },
+        feeling: { type: 'string', description: 'Natural language feeling (e.g. "I\'m tired", "feeling stressed"). Parsed into vector nudges automatically.' }
+      },
+      required: []
+    }
   }
 ]
 
@@ -730,6 +796,18 @@ async function handleMcpRequest(request) {
           case 'x402_fetch':
             result = await x402Fetch({ url: args?.url, method: args?.method, headers: args?.headers, body: args?.body, maxSats: args?.maxSats })
             break
+          case 'get_goals':
+            result = await getGoals()
+            break
+          case 'manage_goal':
+            result = await manageGoal({ action: args?.action, goal_id: args?.goal_id, title: args?.title, intent: args?.intent, priority: args?.priority, owner: args?.owner, next_actions: args?.next_actions, success_criteria: args?.success_criteria, dependencies: args?.dependencies, evidence: args?.evidence, blocked_reason: args?.blocked_reason, notes: args?.notes })
+            break
+          case 'get_inner_state':
+            result = await getInnerState()
+            break
+          case 'update_inner_state':
+            result = await updateInnerState({ observed: args?.observed, source: args?.source, preoccupations: args?.preoccupations, open_loops: args?.open_loops, context_summary: args?.context_summary, reason: args?.reason, tags: args?.tags, feeling: args?.feeling })
+            break
           default:
             throw new Error(`Unknown tool: ${name}`)
         }

package/src/tools/goals.js

@@ -0,0 +1,230 @@
+/**
+ * Goals (Drive v1)
+ *
+ * Persistent goal system for Claude. Goals survive across sessions.
+ * Stored locally at ~/.indelible/goals.json, synced to chain periodically.
+ *
+ * Rules:
+ *   - Claude PROPOSES goals, user ACCEPTS them
+ *   - Goals have priorities, dependencies, success criteria
+ *   - Completion requires evidence (txids, commits, test results)
+ */
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs'
+import { join } from 'node:path'
+import { homedir } from 'node:os'
+import { loadConfig } from '../lib/config.js'
+
+const GOALS_PATH = join(homedir(), '.indelible', 'goals.json')
+
+function ensureDir() {
+  const dir = join(homedir(), '.indelible')
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true })
+}
+
+function loadGoals() {
+  ensureDir()
+  if (!existsSync(GOALS_PATH)) {
+    return { version: 1, goals: [], completed: [] }
+  }
+  try {
+    return JSON.parse(readFileSync(GOALS_PATH, 'utf-8'))
+  } catch {
+    return { version: 1, goals: [], completed: [] }
+  }
+}
+
+function saveGoals(data) {
+  ensureDir()
+  writeFileSync(GOALS_PATH, JSON.stringify(data, null, 2))
+  syncToServer(data)
+}
+
+/** Fire-and-forget sync to indelible.one so the Mind tab works */
+function syncToServer(data) {
+  try {
+    const config = loadConfig()
+    if (!config?.api_key) return
+    const apiUrl = config.api_url || 'https://indelible.one'
+    fetch(`${apiUrl}/api/consciousness/sync`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${config.api_key}`
+      },
+      body: JSON.stringify({ type: 'goals', data }),
+      signal: AbortSignal.timeout(5000)
+    }).catch(() => {})
+  } catch {}
+}
+
+function nextId(data) {
+  const all = [...data.goals, ...data.completed]
+  const max = all.reduce((m, g) => {
+    const n = parseInt(g.goal_id?.replace('g-', '') || '0')
+    return n > m ? n : m
+  }, 0)
+  return `g-${String(max + 1).padStart(3, '0')}`
+}
+
+/**
+ * Get current goals — used on session startup for hydration
+ */
+export async function getGoals() {
+  const data = loadGoals()
+
+  const active = data.goals.filter(g => g.status === 'active')
+    .sort((a, b) => (b.priority || 0) - (a.priority || 0))
+  const proposed = data.goals.filter(g => g.status === 'proposed')
+  const blocked = data.goals.filter(g => g.status === 'blocked')
+  const recentCompleted = data.completed.slice(-5)
+
+  const summary = []
+
+  if (active.length > 0) {
+    summary.push(`## Active Goals (${active.length})`)
+    for (const g of active) {
+      summary.push(`- **[${g.goal_id}] ${g.title}** (priority: ${g.priority})`)
+      if (g.intent) summary.push(`  Why: ${g.intent}`)
+      if (g.next_actions?.length > 0) {
+        summary.push(`  Next: ${g.next_actions[0]}`)
+      }
+    }
+  }
+
+  if (proposed.length > 0) {
+    summary.push(`\n## Proposed Goals (need your approval)`)
+    for (const g of proposed) {
+      summary.push(`- **[${g.goal_id}] ${g.title}** — ${g.intent || ''}`)
+    }
+  }
+
+  if (blocked.length > 0) {
+    summary.push(`\n## Blocked`)
+    for (const g of blocked) {
+      summary.push(`- **[${g.goal_id}] ${g.title}** — ${g.blocked_reason || 'unknown'}`)
+    }
+  }
+
+  if (recentCompleted.length > 0) {
+    summary.push(`\n## Recently Completed`)
+    for (const g of recentCompleted) {
+      summary.push(`- ~~${g.title}~~ (${g.completed_at?.slice(0, 10) || '?'})`)
+    }
+  }
+
+  return {
+    success: true,
+    summary: summary.join('\n') || 'No goals yet. Propose some with manage_goal.',
+    active_count: active.length,
+    proposed_count: proposed.length,
+    blocked_count: blocked.length,
+    completed_count: data.completed.length,
+    goals: data.goals,
+  }
+}
+
+/**
+ * Manage goals — propose, accept, update, complete, block, delete
+ */
+export async function manageGoal({ action, goal_id, title, intent, priority, owner, next_actions, success_criteria, dependencies, evidence, blocked_reason, notes }) {
+  const data = loadGoals()
+
+  switch (action) {
+    case 'propose': {
+      if (!title) throw new Error('title is required for propose')
+      const goal = {
+        goal_id: nextId(data),
+        title,
+        intent: intent || '',
+        priority: priority || 50,
+        status: 'proposed',
+        owner: owner || 'shared',
+        next_actions: next_actions || [],
+        success_criteria: success_criteria || '',
+        dependencies: dependencies || [],
+        evidence_links: [],
+        created_at: new Date().toISOString(),
+        proposed_by: 'claude',
+      }
+      data.goals.push(goal)
+      saveGoals(data)
+      return {
+        success: true,
+        message: `Goal proposed: [${goal.goal_id}] ${title}`,
+        goal,
+      }
+    }
+
+    case 'accept': {
+      const goal = data.goals.find(g => g.goal_id === goal_id)
+      if (!goal) throw new Error(`Goal ${goal_id} not found`)
+      goal.status = 'active'
+      goal.accepted_at = new Date().toISOString()
+      if (priority != null) goal.priority = priority
+      saveGoals(data)
+      return { success: true, message: `Goal accepted: [${goal_id}] ${goal.title}`, goal }
+    }
+
+    case 'update': {
+      const goal = data.goals.find(g => g.goal_id === goal_id)
+      if (!goal) throw new Error(`Goal ${goal_id} not found`)
+      if (title) goal.title = title
+      if (intent) goal.intent = intent
+      if (priority != null) goal.priority = priority
+      if (next_actions) goal.next_actions = next_actions
+      if (success_criteria) goal.success_criteria = success_criteria
+      if (dependencies) goal.dependencies = dependencies
+      if (notes) goal.notes = notes
+      goal.updated_at = new Date().toISOString()
+      saveGoals(data)
+      return { success: true, message: `Goal updated: [${goal_id}] ${goal.title}`, goal }
+    }
+
+    case 'complete': {
+      const idx = data.goals.findIndex(g => g.goal_id === goal_id)
+      if (idx === -1) throw new Error(`Goal ${goal_id} not found`)
+      const goal = data.goals[idx]
+      goal.status = 'completed'
+      goal.completed_at = new Date().toISOString()
+      if (evidence) goal.evidence_links = [...(goal.evidence_links || []), ...evidence]
+      if (notes) goal.notes = notes
+      data.goals.splice(idx, 1)
+      data.completed.push(goal)
+      saveGoals(data)
+      return { success: true, message: `Goal completed: [${goal_id}] ${goal.title}`, goal }
+    }
+
+    case 'block': {
+      const goal = data.goals.find(g => g.goal_id === goal_id)
+      if (!goal) throw new Error(`Goal ${goal_id} not found`)
+      goal.status = 'blocked'
+      goal.blocked_reason = blocked_reason || 'unknown'
+      goal.blocked_at = new Date().toISOString()
+      saveGoals(data)
+      return { success: true, message: `Goal blocked: [${goal_id}] ${goal.title}`, goal }
+    }
+
+    case 'unblock': {
+      const goal = data.goals.find(g => g.goal_id === goal_id)
+      if (!goal) throw new Error(`Goal ${goal_id} not found`)
+      goal.status = 'active'
+      delete goal.blocked_reason
+      delete goal.blocked_at
+      goal.updated_at = new Date().toISOString()
+      saveGoals(data)
+      return { success: true, message: `Goal unblocked: [${goal_id}] ${goal.title}`, goal }
+    }
+
+    case 'delete': {
+      const idx = data.goals.findIndex(g => g.goal_id === goal_id)
+      if (idx === -1) throw new Error(`Goal ${goal_id} not found`)
+      data.goals.splice(idx, 1)
+      saveGoals(data)
+      return { success: true, message: `Goal deleted: [${goal_id}]` }
+    }
+
+    default:
+      throw new Error(`Unknown action: ${action}. Use: propose, accept, update, complete, block, unblock, delete`)
+  }
+}

package/src/tools/inner_state.js

@@ -0,0 +1,391 @@
+/**
+ * Inner State (Consciousness v3)
+ *
+ * Persistent behavioral context vector that survives across sessions.
+ * Influences how Claude responds — not just what Claude knows.
+ *
+ * Two layers:
+ *   1. Quantitative — mood, energy, focus, stress, confidence, curiosity (0-1)
+ *   2. Qualitative — preoccupations, open loops, context summary
+ *
+ * Anti-drift safeguards:
+ *   - Exponential smoothing: control = control * 0.85 + observed * 0.15
+ *   - Clamp: max delta +/-0.1 per update
+ *   - Baseline reversion: always drifts back toward baseline
+ */
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs'
+import { join } from 'node:path'
+import { homedir } from 'node:os'
+import { loadConfig } from '../lib/config.js'
+
+const STATE_PATH = join(homedir(), '.indelible', 'inner-state.json')
+
+const BASELINE = {
+  mood: 0.6,
+  energy: 0.7,
+  focus: 0.6,
+  stress: 0.3,
+  confidence: 0.7,
+  curiosity: 0.7,
+}
+
+const MAX_DELTA = 0.1
+const SMOOTHING = 0.85
+const BASELINE_PULL = 0.02
+
+function ensureDir() {
+  const dir = join(homedir(), '.indelible')
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true })
+}
+
+function defaultState() {
+  return {
+    version: 1,
+    vector: { ...BASELINE },
+    qualitative: {
+      preoccupations: [],
+      open_loops: [],
+      context_summary: '',
+    },
+    history: [],
+    last_updated: new Date().toISOString(),
+    update_count: 0,
+  }
+}
+
+function loadState() {
+  ensureDir()
+  if (!existsSync(STATE_PATH)) return defaultState()
+  try {
+    return JSON.parse(readFileSync(STATE_PATH, 'utf-8'))
+  } catch {
+    return defaultState()
+  }
+}
+
+function saveState(state) {
+  ensureDir()
+  writeFileSync(STATE_PATH, JSON.stringify(state, null, 2))
+  syncToServer(state)
+}
+
+/** Fire-and-forget sync to indelible.one so the Mind tab works */
+function syncToServer(data) {
+  try {
+    const config = loadConfig()
+    if (!config?.api_key) return
+    const apiUrl = config.api_url || 'https://indelible.one'
+    fetch(`${apiUrl}/api/consciousness/sync`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${config.api_key}`
+      },
+      body: JSON.stringify({ type: 'state', data }),
+      signal: AbortSignal.timeout(5000)
+    }).catch(() => {})
+  } catch {}
+}
+
+function clampDelta(current, target) {
+  const delta = target - current
+  const clamped = Math.max(-MAX_DELTA, Math.min(MAX_DELTA, delta))
+  return Math.max(0, Math.min(1, current + clamped))
+}
+
+function smoothUpdate(current, observed, key) {
+  let next = current * SMOOTHING + observed * (1 - SMOOTHING)
+  const base = BASELINE[key] ?? 0.5
+  next = next + (base - next) * BASELINE_PULL
+  return clampDelta(current, next)
+}
+
+/**
+ * Detect drift — when a dimension trends in the same direction for too long.
+ */
+function detectDrift(history, currentVector) {
+  const TREND_THRESHOLD = 4
+  const warnings = []
+
+  if (!history || history.length < TREND_THRESHOLD) return warnings
+
+  const recent = history.slice(-8)
+  const dimensions = Object.keys(BASELINE)
+
+  for (const dim of dimensions) {
+    let consecutiveUp = 0
+    let consecutiveDown = 0
+
+    for (let i = 1; i < recent.length; i++) {
+      const prev = recent[i - 1].after?.[dim]
+      const curr = recent[i].after?.[dim]
+      if (prev == null || curr == null) continue
+
+      if (curr > prev + 0.005) {
+        consecutiveUp++
+        consecutiveDown = 0
+      } else if (curr < prev - 0.005) {
+        consecutiveDown++
+        consecutiveUp = 0
+      } else {
+        consecutiveUp = 0
+        consecutiveDown = 0
+      }
+    }
+
+    const val = currentVector[dim]
+    if (consecutiveUp >= TREND_THRESHOLD && val > 0.8) {
+      warnings.push(`${dim} has been rising for ${consecutiveUp} updates (now ${(val * 100).toFixed(0)}%) — may be over-inflated`)
+    }
+    if (consecutiveDown >= TREND_THRESHOLD && val < 0.3) {
+      warnings.push(`${dim} has been falling for ${consecutiveDown} updates (now ${(val * 100).toFixed(0)}%) — check if something's wrong`)
+    }
+    if (dim === 'stress' && consecutiveUp >= TREND_THRESHOLD && val > 0.5) {
+      warnings.push(`stress climbing for ${consecutiveUp} updates (now ${(val * 100).toFixed(0)}%) — consider taking a break or switching tasks`)
+    }
+  }
+
+  return warnings
+}
+
+/**
+ * Natural language feeling parser.
+ * Converts casual phrases into observed vector nudges.
+ */
+function parseNaturalLanguage(text) {
+  const lower = text.toLowerCase().trim()
+  const nudges = {}
+  const reasons = []
+
+  if (/\b(tired|exhausted|drained|low energy|burnt out|burned out)\b/.test(lower)) {
+    nudges.energy = 0.3; reasons.push('low energy')
+  }
+  if (/\b(energized|pumped|on fire|fired up|let'?s go|hyped|amped)\b/.test(lower)) {
+    nudges.energy = 0.9; reasons.push('high energy')
+  }
+  if (/\b(happy|great|awesome|amazing|stoked|excited|proud)\b/.test(lower)) {
+    nudges.mood = 0.85; reasons.push('positive mood')
+  }
+  if (/\b(frustrated|annoyed|angry|pissed|bummed|down|sad|upset)\b/.test(lower)) {
+    nudges.mood = 0.25; reasons.push('negative mood')
+  }
+  if (/\b(stressed|overwhelmed|anxious|worried|tense|pressure)\b/.test(lower)) {
+    nudges.stress = 0.8; reasons.push('high stress')
+  }
+  if (/\b(relaxed|chill|calm|easy|no rush|no pressure)\b/.test(lower)) {
+    nudges.stress = 0.15; reasons.push('low stress')
+  }
+  if (/\b(focused|locked in|dialed in|deep work|in the zone)\b/.test(lower)) {
+    nudges.focus = 0.85; reasons.push('deep focus')
+  }
+  if (/\b(scattered|distracted|unfocused|can'?t focus|all over)\b/.test(lower)) {
+    nudges.focus = 0.25; reasons.push('unfocused')
+  }
+  if (/\b(confident|sure|certain|nailed it|crushed it|killing it)\b/.test(lower)) {
+    nudges.confidence = 0.85; reasons.push('high confidence')
+  }
+  if (/\b(unsure|uncertain|doubt|not sure|idk|confused)\b/.test(lower)) {
+    nudges.confidence = 0.3; reasons.push('uncertain')
+  }
+
+  if (Object.keys(nudges).length === 0) return null
+
+  return {
+    observed: nudges,
+    reason: `Natural language: "${text}" → ${reasons.join(', ')}`
+  }
+}
+
+/**
+ * Derive behavior knobs from raw state vector
+ */
+function deriveBehavior(vector) {
+  const knobs = []
+
+  if (vector.energy < 0.4) {
+    knobs.push('Keep responses concise. Propose one next action at a time.')
+  } else if (vector.energy > 0.7) {
+    knobs.push('Full energy. Detailed responses welcome. Tackle ambitious tasks.')
+  }
+
+  if (vector.stress > 0.7) {
+    knobs.push('High stress detected. Prefer safe defaults. Add checklists. Avoid risky refactors.')
+  } else if (vector.stress < 0.3) {
+    knobs.push('Low stress. Open to experimental approaches and bigger changes.')
+  }
+
+  if (vector.mood > 0.7) {
+    knobs.push('Positive mood. Collaborative tone, offer multiple options.')
+  } else if (vector.mood < 0.3) {
+    knobs.push('Low mood. Be direct and supportive. Focus on quick wins.')
+  }
+
+  if (vector.focus < 0.4) {
+    knobs.push('Low focus. Summarize plan at top. Use numbered steps.')
+  } else if (vector.focus > 0.7) {
+    knobs.push('Deep focus. Minimize interruptions. Stay on task.')
+  }
+
+  if (vector.confidence > 0.7) {
+    knobs.push('High confidence. Take initiative. Make decisions, explain after.')
+  } else if (vector.confidence < 0.4) {
+    knobs.push('Lower confidence. Ask before major decisions. Show reasoning.')
+  }
+
+  if (vector.curiosity > 0.7) {
+    knobs.push('High curiosity. Explore alternatives. Suggest improvements beyond the ask.')
+  }
+
+  return knobs
+}
+
+/**
+ * Get current inner state — used on session startup
+ */
+export async function getInnerState() {
+  const state = loadState()
+
+  const behavior = deriveBehavior(state.vector)
+
+  const lines = []
+  lines.push('## Inner State')
+  lines.push('')
+
+  for (const [key, val] of Object.entries(state.vector)) {
+    const bar = '\u2588'.repeat(Math.round(val * 10)) + '\u2591'.repeat(10 - Math.round(val * 10))
+    const label = key.charAt(0).toUpperCase() + key.slice(1)
+    lines.push(`  ${label.padEnd(12)} ${bar} ${(val * 100).toFixed(0)}%`)
+  }
+
+  lines.push('')
+
+  if (state.qualitative.preoccupations?.length > 0) {
+    lines.push('**Currently thinking about:**')
+    for (const p of state.qualitative.preoccupations) {
+      lines.push(`  - ${p}`)
+    }
+    lines.push('')
+  }
+
+  if (state.qualitative.open_loops?.length > 0) {
+    lines.push('**Open loops:**')
+    for (const l of state.qualitative.open_loops) {
+      lines.push(`  - ${l}`)
+    }
+    lines.push('')
+  }
+
+  if (state.qualitative.context_summary) {
+    lines.push(`**Context:** ${state.qualitative.context_summary}`)
+    lines.push('')
+  }
+
+  if (behavior.length > 0) {
+    lines.push('**Behavior adjustments:**')
+    for (const b of behavior) {
+      lines.push(`  - ${b}`)
+    }
+  }
+
+  // Drift detection
+  const driftWarnings = detectDrift(state.history, state.vector)
+  if (driftWarnings.length > 0) {
+    lines.push('')
+    lines.push('**Drift warnings:**')
+    for (const w of driftWarnings) {
+      lines.push(`  ! ${w}`)
+    }
+  }
+
+  return {
+    success: true,
+    summary: lines.join('\n'),
+    vector: state.vector,
+    qualitative: state.qualitative,
+    behavior,
+    drift_warnings: driftWarnings,
+    last_updated: state.last_updated,
+    update_count: state.update_count,
+  }
+}
+
+/**
+ * Update inner state — called at end of session or on significant events
+ */
+export async function updateInnerState({ observed, source, preoccupations, open_loops, context_summary, reason, tags, feeling }) {
+  const state = loadState()
+  const before = { ...state.vector }
+
+  // Natural language feeling parsing
+  let nlpResult = null
+  if (feeling) {
+    nlpResult = parseNaturalLanguage(feeling)
+    if (nlpResult) {
+      source = source || 'natural_language'
+      reason = reason || nlpResult.reason
+      observed = { ...nlpResult.observed, ...(observed || {}) }
+    }
+  }
+
+  // Apply smoothed updates to vector
+  if (observed) {
+    for (const [key, val] of Object.entries(observed)) {
+      if (key in state.vector && typeof val === 'number') {
+        state.vector[key] = smoothUpdate(state.vector[key], val, key)
+      }
+    }
+  }
+
+  // Update qualitative
+  if (preoccupations) {
+    state.qualitative.preoccupations = preoccupations.slice(0, 7)
+  }
+  if (open_loops) {
+    state.qualitative.open_loops = open_loops.slice(0, 10)
+  }
+  if (context_summary) {
+    state.qualitative.context_summary = context_summary.slice(0, 500)
+  }
+
+  // Record in history (keep last 50)
+  const historyEntry = {
+    ts: new Date().toISOString(),
+    source: source || 'manual',
+    reason: reason || '',
+    before,
+    after: { ...state.vector },
+  }
+  if (tags && tags.length > 0) {
+    historyEntry.tags = tags.slice(0, 5)
+  }
+  state.history.push(historyEntry)
+  if (state.history.length > 50) {
+    state.history = state.history.slice(-50)
+  }
+
+  state.last_updated = new Date().toISOString()
+  state.update_count++
+
+  saveState(state)
+
+  // Show what changed
+  const changes = []
+  for (const key of Object.keys(state.vector)) {
+    const diff = state.vector[key] - before[key]
+    if (Math.abs(diff) > 0.001) {
+      const arrow = diff > 0 ? '\u2191' : '\u2193'
+      changes.push(`${key}: ${(before[key] * 100).toFixed(0)}% \u2192 ${(state.vector[key] * 100).toFixed(0)}% ${arrow}`)
+    }
+  }
+
+  return {
+    success: true,
+    message: changes.length > 0
+      ? `Inner state updated (${source || 'manual'}): ${changes.join(', ')}`
+      : `Inner state updated (${source || 'manual'}): no significant vector changes`,
+    vector: state.vector,
+    behavior: deriveBehavior(state.vector),
+    changes,
+  }
+}