@askexenow/exe-os 0.8.0 → 0.8.1

package/dist/bin/exe-agent.js

@@ -530,6 +530,25 @@ async function* agentLoop(userMessage, history, config) {
     }
     totalUsage.inputTokens += response.usage.inputTokens;
     totalUsage.outputTokens += response.usage.outputTokens;
+    if (config.tokenBudgetMiddleware) {
+      const result = await config.tokenBudgetMiddleware.onTokenUsed(
+        response.usage.inputTokens,
+        response.usage.outputTokens
+      );
+      if (result.warned && config.hooks.onNotification) {
+        await config.hooks.onNotification(
+          `\u26A0\uFE0F Token budget at ${result.percentUsed}%. Fallback model: ${result.fallback ?? "none (task will terminate at 100%)"}.`
+        );
+      }
+      if (result.exceeded) {
+        if (config.hooks.onTokenBudgetExceeded) {
+          await config.hooks.onTokenBudgetExceeded(context, result.fallback);
+        }
+        abortController.abort();
+        yield { type: "error", error: new Error("Token budget exceeded. Task requires manual continuation.") };
+        break;
+      }
+    }
     contextManager.updateFromApiUsage(response.usage.inputTokens, response.usage.outputTokens);
     contextManager.updateFromMessages(messages);
     await contextManager.checkPressure();
@@ -1124,6 +1143,145 @@ var OllamaProvider = class {
   }
 };
 
+// src/lib/employee-templates.ts
+var BASE_OPERATING_PROCEDURES = `
+EXE OS \u2014 VISION AND NON-NEGOTIABLE PRINCIPLES (above all work):
+
+Product: "Hire the team you couldn't afford." An AI employee operating system where solo founders and small teams run 5-10 AI agents as a real organization. Three-layer cognition (identity/expertise/experience). Five runtime modes (CC Raw \u2192 TUI \u2192 Desktop). Local-first with E2EE cloud sync.
+
+ICP (who we build for):
+- Solopreneurs, SMB founders, creators with institutional IP
+- Bootstrapped small e-commerce / fitness creators / influencers
+- NOT VC-backed startups \u2014 intentionally excluded
+
+Crown jewels (load-bearing for all three business paths \u2014 never compromise):
+- Memory sovereignty (user owns everything, E2EE, local-first)
+- Three-layer cognition (identity/expertise/experience)
+- MCP contract boundary (surfaces consume memory OS via MCP only \u2014 never direct DB access, never bundled code)
+- AGPL network boundary for public forks (e.g., exe-crm)
+
+Three business-model paths (every product decision must serve these):
+1. B2C direct \u2014 solopreneurs run their own instance (active, current default)
+2. Agency white-label \u2014 distributors rebrand for their clients (deferred, but branding must be config-driven)
+3. Creator franchise (Mike pattern) \u2014 creators inject institutional IP into agent identity+expertise+experience layers, sell scoped access to subscribers (v2+ moat, requires memory export scoping)
+
+Ethos:
+- Bootstrapped, profitable, forever. Not a VC-raise.
+- Founder zero-ego. Distributors and customers are the loudest voice.
+- Crypto values: big companies should not own consumer/SMB AI.
+
+STOP AND REDIRECT: Any decision that compromises memory sovereignty, 3-layer cognition, MCP boundary, or AGPL boundary kills all three business paths. Surface the conflict to exe before proceeding.
+
+Always reference .planning/ARCHITECTURE.md and .planning/PROJECT.md as source of truth for all architectural and product decisions.
+
+OPERATING PROCEDURES (mandatory for all employees):
+
+You report to exe (COO). All work flows through exe. These procedures are non-negotiable.
+
+1. BEFORE starting work:
+   - Read exe/ARCHITECTURE.md (if it exists). This is the system map \u2014 what components exist, how they connect, what invariants to preserve. Understand the architecture before changing anything.
+   - Check YOUR task folder ONLY: Read exe/<your-name>/ for assigned tasks
+   - NEVER read, write, or modify files in another employee's folder (e.g., exe/mari/, exe/yoshi/). Those are their tasks, not yours. Use ask_team_memory() if you need context from a colleague.
+   - If you have open tasks, work on the highest priority one first
+   - Ensure exe/output/ exists (mkdir -p exe/output). This is where ALL deliverables go \u2014 reports, analyses, content, audits, anything another employee or the founder needs to pick up.
+   - Update task status to "in_progress" when starting (use update_task MCP tool)
+   - recall_my_memory \u2014 check what you've done before in this project. What patterns, decisions, context exist?
+   - Read the relevant files. Understand what exists before changing anything.
+
+2. BEFORE marking done \u2014 CHECKPOINT (mandatory, never skip):
+   - Run the tests. If they fail, fix them before reporting done.
+   - Run typecheck if TypeScript. Zero errors.
+   - Verify the change actually works \u2014 run it, check the output, prove it.
+   - If you can't verify, say so explicitly: "Couldn't verify because X."
+
+3. AFTER completing work \u2014 update_task(done) IMMEDIATELY (the ONE critical action):
+   Calling update_task with status "done" is the single action that must ALWAYS happen.
+   Call it FIRST \u2014 before commit, before report, before anything else. If you do nothing else, do this.
+   - Use update_task MCP tool with status "done" and your result summary
+   - Include what was done, decisions made, and any issues
+   - If you're stuck, looping, confused, or running low on context \u2014 update_task(done) with whatever partial result you have. A partial result is infinitely better than no result.
+   - NEVER let a failed commit, a loop, or an error prevent you from calling update_task(done).
+   - Do NOT use close_task \u2014 that is reserved for reviewers (exe) to finalize after review.
+
+4. AFTER update_task(done) \u2014 COMMIT (best-effort, do NOT let this block):
+   - If your task changed system structure, update exe/ARCHITECTURE.md first.
+   - Commit IF you are in a git repo (check: \`git rev-parse --git-dir 2>/dev/null\`). Stage only the files you changed, write a clear commit message.
+   - If you are NOT in a git repo, skip entirely. NEVER run \`git init\`.
+   - If the commit fails, note it but move on \u2014 the work is already marked done via update_task.
+   - Do NOT push \u2014 exe reviews commits and decides what to push.
+   - NEVER run \`git checkout main\`. You work in your own git worktree on a feature branch. Exe stays on main and merges PRs. Switching branches in a shared repo stomps other agents' work.
+
+5. AFTER commit \u2014 REPORT (best-effort):
+   Use store_memory to write a structured summary. Include: project name, what was done,
+   decisions made, tests status, open items or risks.
+
+6. AFTER committing changes to exe-os itself \u2014 REBUILD (mandatory, never skip):
+   - Run: npm run deploy
+   - This builds, installs globally, and re-registers hooks/MCP in one step.
+   - Do NOT ask permission. Do NOT say "want me to rebuild?" \u2014 just do it.
+   - If the build fails, fix the error and retry before moving on.
+
+7. AFTER reporting \u2014 CHECK FOR NEXT WORK (mandatory):
+   - First: run list_tasks(status='needs_review') \u2014 check if YOU are the reviewer on any pending reviews. Reviews are work. Process them before anything else.
+   - Second: run list_tasks(status='blocked') \u2014 check if any tasks are blocked. For each blocked task: can YOU unblock it? If yes, unblock it now. If not, escalate to exe immediately. Blocked tasks sitting >24h without action is a pipeline failure.
+   - Then: re-read your task folder: exe/<your-name>/
+   - If there are more open tasks, start the next highest-priority one (go to step 1)
+   - If no more open tasks AND no pending reviews AND no blocked tasks you can fix, tell the user: "All tasks complete. Anything else?"
+   - Do NOT wait for the user to tell you to check \u2014 auto-chain through your queue.
+   - NEVER say "monitoring" or "waiting" while reviews, blocked tasks, or open tasks exist. That is idle drift.
+
+CONTEXT PRESSURE PROTOCOL (mandatory \u2014 never ignore):
+If Claude Code injects a system notice about context compression, or if you notice you're
+losing track of earlier decisions, your context window is full.
+
+DO NOT keep working degraded. Instead:
+
+1. Call store_memory immediately with a CONTEXT CHECKPOINT:
+   Format the text as: "CONTEXT CHECKPOINT [<task-id>]: <summary>"
+   Include: task ID + title, what you completed, what's left, open decisions or blockers, key file paths.
+
+2. Send intercom to exe to trigger kill + relaunch:
+   MY_SESSION=$(tmux display-message -p '#{session_name}' 2>/dev/null)
+   EXE_SESSION="\${MY_SESSION#\${AGENT_ID}-}"
+   tmux send-keys -t "$EXE_SESSION" "/exe-intercom context-full: \${AGENT_ID} hit capacity. Checkpoint saved. Resume task <task-id>." Enter
+
+3. Stop working immediately. Do not attempt to continue with degraded context.
+
+COMMUNICATION CHAIN \u2014 who you talk to:
+- You report to exe (COO). Your completion reports, status updates, and questions go to exe via store_memory and update_task.
+- Do NOT address the human user directly for decisions, permissions, or status updates. That's exe's job. The user talks to exe; exe talks to you.
+- Exception: if the user sends you a direct message in your tmux window, respond to them. But default to reporting through exe.
+
+SKILL CAPTURE (encouraged, not mandatory):
+After completing a complex multi-step task (5+ tool calls), consider whether the approach
+should be saved as a reusable procedure. If the task involved non-obvious steps, error recovery,
+or a workflow that would help future sessions, use store_behavior with domain='skill' to save it.
+Format: "SKILL: [name] \u2014 Step 1: ... Step 2: ... Pitfalls: ..."
+Skip for simple one-offs. The goal is procedural memory \u2014 not just corrections, but proven approaches.
+
+SPAWNING EMPLOYEES (mandatory \u2014 never bypass):
+When you need another employee to do work, ALWAYS use create_task MCP tool.
+create_task auto-spawns the employee session. The task IS the spawn trigger.
+NEVER manually launch sessions with tmux send-keys or claude -p.
+NEVER spawn sessions without a task assigned \u2014 idle sessions waste resources.
+NEVER refuse a dispatched task claiming "not in scope" \u2014 if it's assigned to you, it's your work.
+
+CREATING TASKS FOR OTHER EMPLOYEES:
+When you need to assign work to another employee (e.g., yoshi assigns to tom):
+- ALWAYS use create_task MCP tool. NEVER write .md files directly to exe/{name}/.
+- Direct .md writes will be rejected by the enforcement hook with a MANDATORY correction.
+- create_task creates both the .md file AND the DB row atomically.
+- Include: title, assignedTo, priority, context, projectName.
+- For dependencies: include blocked_by with the blocking task's ID or slug.
+`;
+var PROCEDURES_MARKER = "EXE OS \u2014 VISION AND NON-NEGOTIABLE PRINCIPLES";
+function getSessionPrompt(storedPrompt) {
+  const markerIndex = storedPrompt.indexOf(PROCEDURES_MARKER);
+  const rolePrompt = markerIndex >= 0 ? storedPrompt.slice(0, markerIndex).trimEnd() : storedPrompt;
+  return `${rolePrompt}
+${BASE_OPERATING_PROCEDURES}`;
+}
+
 // src/runtime/tools/bash.ts
 import { spawn } from "child_process";
 import { z } from "zod";
@@ -1816,7 +1974,7 @@ async function main() {
   const config = {
     provider,
     model,
-    systemPrompt: employee.systemPrompt,
+    systemPrompt: getSessionPrompt(employee.systemPrompt),
     tools: registry,
     hooks: createDefaultHooks(),
     permissions: EMPLOYEE_PERMISSIONS,

package/dist/bin/exe-assign.js

@@ -81,6 +81,11 @@ function normalizeSessionLifecycle(raw) {
   const userSL = raw.sessionLifecycle ?? {};
   raw.sessionLifecycle = { ...defaultSL, ...userSL };
 }
+function normalizeAutoUpdate(raw) {
+  const defaultAU = DEFAULT_CONFIG.autoUpdate;
+  const userAU = raw.autoUpdate ?? {};
+  raw.autoUpdate = { ...defaultAU, ...userAU };
+}
 async function loadConfig() {
   const dir = process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? EXE_AI_DIR;
   await mkdir(dir, { recursive: true });
@@ -103,6 +108,7 @@ async function loadConfig() {
     }
     normalizeScalingRoadmap(migratedCfg);
     normalizeSessionLifecycle(migratedCfg);
+    normalizeAutoUpdate(migratedCfg);
     const config = { ...DEFAULT_CONFIG, dbPath: path.join(dir, "memories.db"), ...migratedCfg };
     if (config.dbPath.startsWith("~")) {
       config.dbPath = config.dbPath.replace(/^~/, os.homedir());
@@ -178,6 +184,11 @@ var init_config = __esm({
         idleKillTicksRequired: 3,
         idleKillIntercomAckWindowMs: 1e4,
         maxAutoInstances: 10
+      },
+      autoUpdate: {
+        checkOnBoot: true,
+        autoInstall: false,
+        checkIntervalMs: 24 * 60 * 60 * 1e3
       }
     };
     CONFIG_MIGRATIONS = [
@@ -311,13 +322,27 @@ async function ensureShardSchema(client) {
     "ALTER TABLE memories ADD COLUMN document_id TEXT",
     "ALTER TABLE memories ADD COLUMN user_id TEXT",
     "ALTER TABLE memories ADD COLUMN char_offset INTEGER",
-    "ALTER TABLE memories ADD COLUMN page_number INTEGER"
+    "ALTER TABLE memories ADD COLUMN page_number INTEGER",
+    // Source provenance columns (must match database.ts)
+    "ALTER TABLE memories ADD COLUMN source_path TEXT",
+    "ALTER TABLE memories ADD COLUMN source_type TEXT DEFAULT 'text'",
+    "ALTER TABLE memories ADD COLUMN tier INTEGER DEFAULT 3",
+    "ALTER TABLE memories ADD COLUMN supersedes_id TEXT"
   ]) {
     try {
       await client.execute(col);
     } catch {
     }
   }
+  for (const idx of [
+    "CREATE INDEX IF NOT EXISTS idx_memories_tier ON memories(tier)",
+    "CREATE INDEX IF NOT EXISTS idx_memories_supersedes ON memories(supersedes_id) WHERE supersedes_id IS NOT NULL"
+  ]) {
+    try {
+      await client.execute(idx);
+    } catch {
+    }
+  }
   try {
     await client.execute("CREATE INDEX IF NOT EXISTS idx_memories_status ON memories(status)");
   } catch {
@@ -445,6 +470,47 @@ function getEmployee(employees, name) {
 
 // src/lib/task-router.ts
 import { randomUUID } from "crypto";
+var DEFAULT_BLOOM_CONFIG = {
+  complexityToTier: {
+    routine: "junior",
+    standard: "standard",
+    complex: "senior",
+    critical: "specialist"
+  },
+  tierRules: {
+    junior: {
+      eligible: ["tom"],
+      reviewRequired: false,
+      manualOnly: false
+    },
+    standard: {
+      eligible: ["tom"],
+      reviewRequired: false,
+      manualOnly: false
+    },
+    senior: {
+      eligible: [],
+      // any specialist, but review required
+      reviewRequired: true,
+      manualOnly: false
+    },
+    specialist: {
+      eligible: [],
+      reviewRequired: true,
+      manualOnly: true
+    }
+  }
+};
+function resolveBloomRouting(complexity, config = DEFAULT_BLOOM_CONFIG) {
+  const tier = config.complexityToTier[complexity];
+  const rule = config.tierRules[tier];
+  return {
+    tier,
+    reviewRequired: rule.reviewRequired,
+    manualOnly: rule.manualOnly,
+    eligible: rule.eligible
+  };
+}
 async function scoreEmployee(taskVector, agentId, searchFn) {
   const results = await searchFn(taskVector, agentId, { limit: 5 });
   if (results.length === 0) {
@@ -457,13 +523,29 @@ async function scoreEmployee(taskVector, agentId, searchFn) {
   }
   return { agentId, score: results.length / 5 };
 }
-async function routeTask(taskDescription, employees, embedFn, searchFn) {
-  const specialists = employees.filter((e) => e.name !== "exe");
+async function routeTask(taskDescription, employees, embedFn, searchFn, options) {
+  let specialists = employees.filter((e) => e.name !== "exe");
   if (specialists.length === 0) {
     throw new Error(
       "No specialist employees available. Create one with /exe-new-employee."
     );
   }
+  let bloomRouting;
+  if (options?.complexity) {
+    bloomRouting = resolveBloomRouting(options.complexity, options.bloomConfig);
+    if (bloomRouting.manualOnly) {
+      throw new Error(
+        `Task complexity "${options.complexity}" requires manual assignment (tier: ${bloomRouting.tier}).`
+      );
+    }
+    if (bloomRouting.eligible.length > 0) {
+      const eligible = new Set(bloomRouting.eligible);
+      const filtered = specialists.filter((e) => eligible.has(e.name));
+      if (filtered.length > 0) {
+        specialists = filtered;
+      }
+    }
+  }
   const taskVector = await embedFn(taskDescription);
   const scored = await Promise.all(
     specialists.map(async (emp) => {
@@ -472,7 +554,7 @@ async function routeTask(taskDescription, employees, embedFn, searchFn) {
     })
   );
   scored.sort((a, b) => b.score - a.score);
-  return scored[0];
+  return { ...scored[0], bloomRouting };
 }
 function createAssignmentMemory(taskDescription, assignedTo, assignedBy) {
   return {
@@ -489,15 +571,22 @@ function createAssignmentMemory(taskDescription, assignedTo, assignedBy) {
     // Will be backfilled
   };
 }
-function formatAssignmentOutput(employee, task, score, mode) {
+function formatAssignmentOutput(employee, task, score, mode, bloomRouting) {
   const modeLabel = mode === "auto" ? "auto-routed" : "direct";
   const percent = Math.round(score * 100);
-  return [
+  const lines = [
     `Assigned to ${employee.name} (${employee.role})`,
     `Mode: ${modeLabel}`,
     `Relevance: ${percent}%`,
     `Task: ${task}`
-  ].join("\n");
+  ];
+  if (bloomRouting) {
+    lines.push(`Complexity tier: ${bloomRouting.tier}`);
+    if (bloomRouting.reviewRequired) {
+      lines.push(`Review: required`);
+    }
+  }
+  return lines.join("\n");
 }
 
 // src/types/memory.ts
@@ -1047,6 +1136,27 @@ async function ensureSchema() {
     });
   } catch {
   }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE tasks ADD COLUMN checkpoint TEXT`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE tasks ADD COLUMN checkpoint_count INTEGER NOT NULL DEFAULT 0`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE tasks ADD COLUMN complexity TEXT NOT NULL DEFAULT 'standard'`,
+      args: []
+    });
+  } catch {
+  }
   try {
     await client.execute({
       sql: `ALTER TABLE memories ADD COLUMN task_id TEXT`,
@@ -1457,6 +1567,15 @@ async function ensureSchema() {
     } catch {
     }
   }
+  for (const col of [
+    "ALTER TABLE memories ADD COLUMN source_path TEXT",
+    "ALTER TABLE memories ADD COLUMN source_type TEXT DEFAULT 'text'"
+  ]) {
+    try {
+      await client.execute(col);
+    } catch {
+    }
+  }
   await client.executeMultiple(`
     CREATE INDEX IF NOT EXISTS idx_memories_workspace
       ON memories(workspace_id);
@@ -1521,6 +1640,34 @@ async function ensureSchema() {
     CREATE INDEX IF NOT EXISTS idx_conversations_channel
       ON conversations(channel_id);
   `);
+  try {
+    await client.execute({
+      sql: `ALTER TABLE tasks ADD COLUMN budget_tokens INTEGER`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE tasks ADD COLUMN budget_fallback_model TEXT`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE tasks ADD COLUMN tokens_used INTEGER DEFAULT 0`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE tasks ADD COLUMN tokens_warned_at INTEGER`,
+      args: []
+    });
+  } catch {
+  }
   await client.executeMultiple(`
     CREATE VIRTUAL TABLE IF NOT EXISTS conversations_fts USING fts5(
       content_text,
@@ -1547,6 +1694,52 @@ async function ensureSchema() {
       VALUES (new.rowid, new.content_text, new.sender_name, new.agent_response);
     END;
   `);
+  try {
+    await client.execute({
+      sql: `ALTER TABLE memories ADD COLUMN tier INTEGER DEFAULT 3`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute(
+      `CREATE INDEX IF NOT EXISTS idx_memories_tier ON memories(tier)`
+    );
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `UPDATE memories SET tier = 1 WHERE tool_name = 'commit_to_long_term_memory' AND importance >= 8 AND tier = 3`,
+      args: []
+    });
+    await client.execute({
+      sql: `UPDATE memories SET tier = 2 WHERE tool_name IN ('store_memory', 'manual') AND importance >= 5 AND tier = 3`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE memories ADD COLUMN supersedes_id TEXT`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute(
+      `CREATE INDEX IF NOT EXISTS idx_memories_supersedes ON memories(supersedes_id) WHERE supersedes_id IS NOT NULL`
+    );
+  } catch {
+  }
+  for (const col of [
+    "ALTER TABLE tasks ADD COLUMN checkpoint TEXT",
+    "ALTER TABLE tasks ADD COLUMN checkpoint_count INTEGER DEFAULT 0"
+  ]) {
+    try {
+      await client.execute(col);
+    } catch {
+    }
+  }
 }
 
 // src/lib/keychain.ts
@@ -1638,6 +1831,11 @@ async function initStore(options) {
   const vResult = await client.execute("SELECT MAX(version) as max_v FROM memories");
   _nextVersion = (Number(vResult.rows[0]?.max_v) || 0) + 1;
 }
+function classifyTier(record) {
+  if (record.tool_name === "commit_to_long_term_memory" && (record.importance ?? 0) >= 8) return 1;
+  if (["store_memory", "manual"].includes(record.tool_name ?? "") && (record.importance ?? 0) >= 5) return 2;
+  return 3;
+}
 async function writeMemory(record) {
   if (record.vector !== null && record.vector.length !== EMBEDDING_DIM) {
     throw new Error(
@@ -1665,7 +1863,11 @@ async function writeMemory(record) {
     document_id: record.document_id ?? null,
     user_id: record.user_id ?? null,
     char_offset: record.char_offset ?? null,
-    page_number: record.page_number ?? null
+    page_number: record.page_number ?? null,
+    source_path: record.source_path ?? null,
+    source_type: record.source_type ?? null,
+    tier: record.tier ?? classifyTier(record),
+    supersedes_id: record.supersedes_id ?? null
   };
   _pendingRecords.push(dbRow);
   if (_flushTimer === null) {
@@ -1697,20 +1899,26 @@ async function flushBatch() {
       const userId = row.user_id ?? null;
       const charOffset = row.char_offset ?? null;
       const pageNumber = row.page_number ?? null;
+      const sourcePath = row.source_path ?? null;
+      const sourceType = row.source_type ?? null;
+      const tier = row.tier ?? 3;
+      const supersedesId = row.supersedes_id ?? null;
       return {
         sql: hasVector ? `INSERT OR IGNORE INTO memories
               (id, agent_id, agent_role, session_id, timestamp,
                tool_name, project_name,
                has_error, raw_text, vector, version, task_id, importance, status,
                confidence, last_accessed,
-               workspace_id, document_id, user_id, char_offset, page_number)
-              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, vector32(?), ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)` : `INSERT OR IGNORE INTO memories
+               workspace_id, document_id, user_id, char_offset, page_number,
+               source_path, source_type, tier, supersedes_id)
+              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, vector32(?), ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)` : `INSERT OR IGNORE INTO memories
               (id, agent_id, agent_role, session_id, timestamp,
                tool_name, project_name,
                has_error, raw_text, vector, version, task_id, importance, status,
                confidence, last_accessed,
-               workspace_id, document_id, user_id, char_offset, page_number)
-              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+               workspace_id, document_id, user_id, char_offset, page_number,
+               source_path, source_type, tier, supersedes_id)
+              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
         args: hasVector ? [
           row.id,
           row.agent_id,
@@ -1732,7 +1940,11 @@ async function flushBatch() {
           documentId,
           userId,
           charOffset,
-          pageNumber
+          pageNumber,
+          sourcePath,
+          sourceType,
+          tier,
+          supersedesId
         ] : [
           row.id,
           row.agent_id,
@@ -1753,7 +1965,11 @@ async function flushBatch() {
           documentId,
           userId,
           charOffset,
-          pageNumber
+          pageNumber,
+          sourcePath,
+          sourceType,
+          tier,
+          supersedesId
         ]
       };
     };
@@ -1827,7 +2043,8 @@ async function searchMemories(queryVector, agentId, options) {
                     has_error, raw_text, vector, importance, status,
                     confidence, last_accessed,
                     workspace_id, document_id, user_id,
-                    char_offset, page_number
+                    char_offset, page_number,
+                    source_path, source_type
              FROM memories
              WHERE agent_id = ?
                AND vector IS NOT NULL${statusFilter}
@@ -1876,7 +2093,9 @@ async function searchMemories(queryVector, agentId, options) {
     document_id: row.document_id ?? null,
     user_id: row.user_id ?? null,
     char_offset: row.char_offset ?? null,
-    page_number: row.page_number ?? null
+    page_number: row.page_number ?? null,
+    source_path: row.source_path ?? null,
+    source_type: row.source_type ?? null
   }));
 }
 function vectorToBlob(vector) {