meow-swarm 0.1.2 → 0.2.0

package/dist/index.js

@@ -16,6 +16,15 @@ var __export = (target, all) => {
 };
 
 // src/config/env.ts
+function parseIntOrUndefined(env) {
+  if (!env) return void 0;
+  const v = parseInt(env, 10);
+  return isNaN(v) ? void 0 : v;
+}
+function parseBool(env, fallback) {
+  if (!env) return fallback;
+  return env === "1" || env === "true" || env === "yes";
+}
 var config;
 var init_env = __esm({
   "src/config/env.ts"() {
@@ -24,7 +33,16 @@ var init_env = __esm({
       apiKey: process.env.LLM_API_KEY || process.env.ANTHROPIC_API_KEY,
       baseUrl: process.env.LLM_BASE_URL || process.env.ANTHROPIC_BASE_URL || "http://localhost:11434",
       model: process.env.ANTHROPIC_MODEL || process.env.MEOW_MODEL || "claude-3-5-sonnet-latest",
-      embeddingDimension: parseInt(process.env.EMBEDDING_DIMENSION || "1536")
+      embeddingDimension: parseInt(process.env.EMBEDDING_DIMENSION || "1536"),
+      // Reproducibility
+      seed: parseIntOrUndefined(process.env.MEOW_SEED),
+      deterministic: parseBool(process.env.MEOW_DETERMINISTIC, false),
+      // Budget (per mission, in US cents)
+      budgetCents: parseIntOrUndefined(process.env.MEOW_BUDGET_CENTS),
+      // Audit log path
+      auditDir: process.env.MEOW_AUDIT_DIR || `${process.env.HOME || "."}/.meow/audit`,
+      // Ambiguity: agent asks for clarification if uncertainty > this threshold (0.0-1.0)
+      ambiguityThreshold: parseFloat(process.env.MEOW_AMBIGUITY_THRESHOLD || "0.7")
     };
   }
 });
@@ -234,10 +252,10 @@ var init_discovery = __esm({
           join(this.home, ".agents", "skills")
         ];
         const skills = [];
-        for (const path3 of globalPaths) {
+        for (const path4 of globalPaths) {
           try {
-            await access2(path3);
-            const patterns = [join(path3, "**/SKILL.md")];
+            await access2(path4);
+            const patterns = [join(path4, "**/SKILL.md")];
             const files = await globby2(patterns, { absolute: true });
             for (const file of files) {
               try {
@@ -1113,16 +1131,16 @@ var init_tool = __esm({
       {
         name: "read",
         description: "Read file contents",
-        execute: async (path3) => {
-          return await readFile4(path3.trim(), "utf-8");
+        execute: async (path4) => {
+          return await readFile4(path4.trim(), "utf-8");
         }
       },
       {
         name: "write",
         description: "Write file contents",
         execute: async (args) => {
-          const [path3, content] = args.split("|");
-          await writeFile2(path3.trim(), content);
+          const [path4, content] = args.split("|");
+          await writeFile2(path4.trim(), content);
           return "Written successfully";
         }
       },
@@ -1686,12 +1704,92 @@ var init_reasoning = __esm({
   }
 });
 
+// src/kernel/audit.ts
+import fs from "fs";
+import path from "path";
+var AuditLogger;
+var init_audit = __esm({
+  "src/kernel/audit.ts"() {
+    "use strict";
+    init_env();
+    AuditLogger = class {
+      logStream = null;
+      logDir;
+      runId;
+      constructor(runId) {
+        this.runId = runId;
+        this.logDir = config.auditDir;
+        this.ensureLogDir();
+        const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 7);
+        const logPath = path.join(this.logDir, `${today}.jsonl`);
+        this.logStream = fs.createWriteStream(logPath, { flags: "a" });
+      }
+      ensureLogDir() {
+        if (!fs.existsSync(this.logDir)) {
+          fs.mkdirSync(this.logDir, { recursive: true });
+        }
+      }
+      log(entry) {
+        const full = {
+          ...entry,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          runId: this.runId
+        };
+        this.logStream?.write(JSON.stringify(full) + "\n");
+      }
+      // Convenience methods
+      llmCall(model, inputTokens, outputTokens, durationMs, costCents, success) {
+        this.log({
+          level: "debug",
+          actionType: "llm_call",
+          detail: `${model}: ${inputTokens} in / ${outputTokens} out / ${costCents.toFixed(4)}\xA2 / ${durationMs}ms`,
+          tokensUsed: { input: inputTokens, output: outputTokens },
+          costCents,
+          durationMs,
+          success
+        });
+      }
+      toolExec(toolName, args, exitCode, durationMs, success) {
+        this.log({
+          level: "info",
+          actionType: "tool_exec",
+          detail: `${toolName}(${args.slice(0, 100)}) \u2192 ${exitCode} (${durationMs}ms)`,
+          durationMs,
+          success: exitCode === 0
+        });
+      }
+      fileWrite(path4, lines) {
+        this.log({ level: "info", actionType: "file_write", detail: `${path4} (+${lines} lines)` });
+      }
+      shellCmd(cmd, exitCode, durationMs) {
+        this.log({
+          level: "info",
+          actionType: "shell_cmd",
+          detail: `${cmd.slice(0, 120)} \u2192 exit ${exitCode} (${durationMs}ms)`,
+          durationMs,
+          success: exitCode === 0
+        });
+      }
+      checkpoint(step, status) {
+        this.log({ level: "info", actionType: "checkpoint", detail: `step ${step}: ${status}` });
+      }
+      error(actionType, detail) {
+        this.log({ level: "error", actionType, detail });
+      }
+      close() {
+        this.logStream?.end();
+      }
+    };
+  }
+});
+
 // src/agent/agent.ts
 import { readFile as readFile5, writeFile as writeFile3 } from "fs/promises";
 import { execSync as execSync3 } from "child_process";
 import { basename } from "path";
 import DiffMatchPatch from "diff-match-patch";
 import { resolve as resolve3 } from "path";
+import { v4 as uuidv4 } from "uuid";
 import pc4 from "picocolors";
 var HEAD_PATTERN, DIVIDER_PATTERN, UPDATED_PATTERN, UDIFF_PATTERN, UDIFF_HUNK_PATTERN, REASONING_TAGS, Agent;
 var init_agent = __esm({
@@ -1705,6 +1803,7 @@ var init_agent = __esm({
     init_memory();
     init_reasoning();
     init_env();
+    init_audit();
     HEAD_PATTERN = /^<{5,9} SEARCH>?\s*$/;
     DIVIDER_PATTERN = /^={5,9}\s*$/;
     UPDATED_PATTERN = /^>{5,9} REPLACE\s*$/;
@@ -1743,6 +1842,12 @@ var init_agent = __esm({
 3. SERIALIZED EXECUTION: Favor simple synchronous/serial patterns. Avoid complex parallel async logic.
 4. ROT RESISTANCE: Prefer Vanilla JS/TS over external dependencies. Match existing surgical style.
   `.trim();
+      // Priority 1: Reproducibility + Observability
+      runId;
+      auditLogger;
+      totalCostCents = 0;
+      recentActions = [];
+      // For loop detection
       constructor(config2) {
         this._model = config2.model;
         this._baseUrl = config2.baseUrl;
@@ -1751,6 +1856,10 @@ var init_agent = __esm({
         if (config2.files) {
           config2.files.forEach((f) => this.files.add(f));
         }
+        this.runId = uuidv4();
+        const meowDb = config2.db;
+        meowDb.startRun(this.runId, "mission", config2.seed, config2.deterministic);
+        this.auditLogger = new AuditLogger(this.runId);
         this.skillManager = new SkillManager();
         this.mcpManager = new McpManager();
         this.discoveryModule = new DiscoveryModule();
@@ -1760,6 +1869,16 @@ var init_agent = __esm({
         this.reasoningEngine = new ReasoningEngine();
         this.agenticMemory = new AgenticMemory(config2.db, config2.kernel, this.reasoningEngine);
       }
+      // ── Priority 1: Budget enforcement ──────────────────────────────────────
+      checkBudget() {
+        const budget = config.budgetCents;
+        if (budget && this.totalCostCents >= budget) {
+          this.auditLogger.error("budget", `Budget exceeded: ${this.totalCostCents}\xA2 >= ${budget}\xA2`);
+          const meowDb = this.db;
+          meowDb.endRun(this.runId, "budget_exceeded");
+          throw new Error(`Budget exceeded: ${this.totalCostCents.toFixed(4)}\xA2 >= ${budget}\xA2. Checkpoint saved.`);
+        }
+      }
       async chat(userInput, runTests = false, testCmd, onStatus) {
         this.messages.push({ role: "user", content: userInput });
         this.updateTokenEstimate();
@@ -1985,11 +2104,11 @@ Check MEOW manually at ${meowDir}`;
         }
         return result.trim();
       }
-      addFile(path3) {
-        this.files.add(path3);
+      addFile(path4) {
+        this.files.add(path4);
       }
-      dropFile(path3) {
-        this.files.delete(path3);
+      dropFile(path4) {
+        this.files.delete(path4);
       }
       getFiles() {
         return Array.from(this.files);
@@ -2004,11 +2123,26 @@ Check MEOW manually at ${meowDir}`;
         return this._apiKey;
       }
       async callLLM(systemPrompt, messages) {
+        this.checkBudget();
+        const actionSig = JSON.stringify(messages.slice(-2));
+        this.recentActions.push(actionSig);
+        if (this.recentActions.length > 3) this.recentActions.shift();
+        const last3 = this.recentActions.slice(-3);
+        if (last3.length === 3 && last3.every((a) => a === last3[0])) {
+          this.auditLogger.log({ level: "warn", actionType: "loop_detected", detail: "Agent repeated same action 3\xD7 \u2014 flagging for review" });
+          console.warn(pc4.yellow("\u26A0\uFE0F [LOOP DETECTED] Repeating the same action. Consider pivoting strategy."));
+        }
+        const startTime = Date.now();
+        let inputTokens = 0;
+        let outputTokens = 0;
+        let costCents = 0;
+        let success = false;
+        let text2 = "";
         if (this._apiKey && this._baseUrl.includes("anthropic")) {
-          const url2 = this._baseUrl.endsWith("/v1/messages") ? this._baseUrl : `${this._baseUrl}/v1/messages`;
-          const controller2 = new AbortController();
-          const timeout2 = setTimeout(() => controller2.abort(), 12e4);
-          const response2 = await fetch(url2, {
+          const url = this._baseUrl.endsWith("/v1/messages") ? this._baseUrl : `${this._baseUrl}/v1/messages`;
+          const controller = new AbortController();
+          const timeout = setTimeout(() => controller.abort(), 12e4);
+          const response = await fetch(url, {
             method: "POST",
             headers: {
               "Content-Type": "application/json",
@@ -2021,45 +2155,65 @@ Check MEOW manually at ${meowDir}`;
               messages: messages.map((m) => ({ role: m.role, content: m.content })),
               max_tokens: 4096
             }),
-            signal: controller2.signal
+            signal: controller.signal
           });
-          clearTimeout(timeout2);
-          if (!response2.ok) {
-            const error = await response2.text();
-            throw new Error(`Anthropic-compatible endpoint error: ${response2.status} - ${error}`);
+          clearTimeout(timeout);
+          if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Anthropic-compatible endpoint error: ${response.status} - ${error}`);
           }
-          const data2 = await response2.json();
-          const textBlock = data2.content?.find((c) => c.type === "text" && c.text);
-          const text2 = textBlock?.text || "";
-          return text2;
-        }
-        const fullMessages = [
-          { role: "system", content: systemPrompt },
-          ...messages
-        ];
-        const url = this._baseUrl.includes("/api/chat") ? this._baseUrl : `${this._baseUrl}/api/chat`;
-        const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(), 3e4);
-        const response = await fetch(url, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            ...this._apiKey ? { "Authorization": `Bearer ${this._apiKey}` } : {}
-          },
-          body: JSON.stringify({
-            model: this._model,
-            messages: fullMessages,
-            stream: false
-          }),
-          signal: controller.signal
-        });
-        clearTimeout(timeout);
-        if (!response.ok) {
-          const error = await response.text();
-          throw new Error(`LLM error: ${response.status} - ${error}`);
+          const data = await response.json();
+          inputTokens = data.usage?.input_tokens ?? 0;
+          outputTokens = data.usage?.output_tokens ?? 0;
+          const textBlock = data.content?.find((c) => c.type === "text" && c.text);
+          text2 = textBlock?.text || "";
+          success = true;
+        } else {
+          const fullMessages = [
+            { role: "system", content: systemPrompt },
+            ...messages
+          ];
+          const url = this._baseUrl.includes("/api/chat") ? this._baseUrl : `${this._baseUrl}/api/chat`;
+          const controller = new AbortController();
+          const timeout = setTimeout(() => controller.abort(), 3e4);
+          const response = await fetch(url, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              ...this._apiKey ? { "Authorization": `Bearer ${this._apiKey}` } : {}
+            },
+            body: JSON.stringify({
+              model: this._model,
+              messages: fullMessages,
+              stream: false
+            }),
+            signal: controller.signal
+          });
+          clearTimeout(timeout);
+          if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`LLM error: ${response.status} - ${error}`);
+          }
+          const data = await response.json();
+          text2 = data.message?.content || data.choices?.[0]?.message?.content || "";
+          success = true;
+        }
+        const durationMs = Date.now() - startTime;
+        if (inputTokens > 0 || outputTokens > 0) {
+          costCents = inputTokens * 3e-3 / 1e6 + outputTokens * 0.015 / 1e6;
+          this.totalCostCents += costCents;
+          const meowDb = this.db;
+          meowDb.logCost(this.runId, this._model, inputTokens, outputTokens, costCents);
+          this.auditLogger.llmCall(this._model, inputTokens, outputTokens, durationMs, costCents, success);
+        }
+        if (costCents > 0) {
+          const totalSoFar = this.totalCostCents;
+          const budgetInfo = config.budgetCents ? ` / ${config.budgetCents}\xA2 budget` : "";
+          process.stdout.write(pc4.dim(`
+  \u{1F4B0} ${costCents.toFixed(4)}\xA2 (session total: ${totalSoFar.toFixed(4)}\xA2${budgetInfo})
+`));
         }
-        const data = await response.json();
-        return data.message?.content || data.choices?.[0]?.message?.content || "";
+        return text2;
       }
       getBasePrompt() {
         return `You are an expert software developer.
@@ -3205,8 +3359,8 @@ var init_ParallelExecutor = __esm({
           void 0,
           (status) => this.taskEvents?.onProgress?.(task.id, status)
         );
-        const artifacts = agent.getEditedFiles().map((path3) => ({
-          path: path3,
+        const artifacts = agent.getEditedFiles().map((path4) => ({
+          path: path4,
           operation: "update"
         }));
         return {
@@ -3328,24 +3482,24 @@ var init_FileCoordinator = __esm({
         }
         return locks;
       }
-      async acquire(path3, taskId) {
+      async acquire(path4, taskId) {
         if (!this.useSqlite || !this.db) {
-          const existing = this.inMemoryLocks.get(path3);
+          const existing = this.inMemoryLocks.get(path4);
           if (existing && existing.taskId !== taskId) return false;
-          this.inMemoryLocks.set(path3, { path: path3, taskId, acquiredAt: Date.now() });
+          this.inMemoryLocks.set(path4, { path: path4, taskId, acquiredAt: Date.now() });
           return true;
         }
         try {
           const stmt = this.db.prepare("BEGIN IMMEDIATE");
           stmt.run();
-          const row = this.db.prepare("SELECT task_id FROM file_locks WHERE path = ?").get(path3);
+          const row = this.db.prepare("SELECT task_id FROM file_locks WHERE path = ?").get(path4);
           if (row && row.task_id !== taskId) {
             this.db.prepare("COMMIT").run();
             return false;
           }
           this.db.prepare(
             "INSERT OR REPLACE INTO file_locks (path, task_id, acquired_at) VALUES (?, ?, ?)"
-          ).run(path3, taskId, Date.now());
+          ).run(path4, taskId, Date.now());
           this.db.prepare("COMMIT").run();
           return true;
         } catch {
@@ -3358,9 +3512,9 @@ var init_FileCoordinator = __esm({
       }
       release(taskId) {
         if (!this.useSqlite || !this.db) {
-          for (const [path3, lock] of this.inMemoryLocks) {
+          for (const [path4, lock] of this.inMemoryLocks) {
             if (lock.taskId === taskId) {
-              this.inMemoryLocks.delete(path3);
+              this.inMemoryLocks.delete(path4);
             }
           }
           return;
@@ -3368,9 +3522,9 @@ var init_FileCoordinator = __esm({
         try {
           this.db.prepare("DELETE FROM file_locks WHERE task_id = ?").run(taskId);
         } catch {
-          for (const [path3, lock] of this.getLocks()) {
+          for (const [path4, lock] of this.getLocks()) {
             if (lock.taskId === taskId) {
-              this.inMemoryLocks.delete(path3);
+              this.inMemoryLocks.delete(path4);
             }
           }
         }
@@ -3429,10 +3583,10 @@ var init_FileCoordinator = __esm({
         const now = Date.now();
         const stale = [];
         if (!this.useSqlite || !this.db) {
-          for (const [path3, lock] of this.inMemoryLocks) {
+          for (const [path4, lock] of this.inMemoryLocks) {
             if (now - lock.acquiredAt > maxAgeMs) {
-              this.inMemoryLocks.delete(path3);
-              stale.push(path3);
+              this.inMemoryLocks.delete(path4);
+              stale.push(path4);
             }
           }
           return stale;
@@ -3445,10 +3599,10 @@ var init_FileCoordinator = __esm({
           this.db.prepare("DELETE FROM file_locks WHERE ? - acquired_at > ?").run(now, maxAgeMs);
         } catch {
           const locks = this.getLocks();
-          for (const [path3, lock] of locks) {
+          for (const [path4, lock] of locks) {
             if (now - lock.acquiredAt > maxAgeMs) {
-              this.inMemoryLocks.delete(path3);
-              stale.push(path3);
+              this.inMemoryLocks.delete(path4);
+              stale.push(path4);
             }
           }
         }
@@ -3543,11 +3697,11 @@ var init_ResultAggregator = __esm({
           }
         }
         const resolution = /* @__PURE__ */ new Map();
-        for (const [path3] of fileStates) {
-          if (conflicts.has(path3)) {
-            resolution.set(path3, "conflict");
+        for (const [path4] of fileStates) {
+          if (conflicts.has(path4)) {
+            resolution.set(path4, "conflict");
           } else {
-            resolution.set(path3, "use_latest");
+            resolution.set(path4, "use_latest");
           }
         }
         return resolution;
@@ -4684,7 +4838,7 @@ var init_Orchestrator = __esm({
         if (stale.length > 0) {
           console.log(`[Orchestrator] Released ${stale.length} stale file locks: ${stale.join(", ")}`);
         }
-        for (const [path3, lock] of this.coordinator.getLockedFiles()) {
+        for (const [path4, lock] of this.coordinator.getLockedFiles()) {
           this.coordinator.release(lock.taskId);
         }
       }
@@ -4781,8 +4935,8 @@ var init_extension = __esm({
       exec(sql) {
         return this.send("exec", [sql]);
       }
-      loadExtension(path3) {
-        return this.send("loadExtension", [path3]);
+      loadExtension(path4) {
+        return this.send("loadExtension", [path4]);
       }
       batch(actions) {
         return this.send("batch", [actions]);
@@ -4920,6 +5074,65 @@ var init_database = __esm({
         last_pulse DATETIME DEFAULT CURRENT_TIMESTAMP,
         created_at DATETIME DEFAULT CURRENT_TIMESTAMP
       );
+    `);
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS mission_runs (
+        run_id       TEXT PRIMARY KEY,
+        mission_id   TEXT NOT NULL,
+        seed         INTEGER,
+        deterministic INTEGER DEFAULT 0,
+        created_at   DATETIME DEFAULT CURRENT_TIMESTAMP,
+        completed_at DATETIME,
+        status       TEXT DEFAULT 'running',
+        checkpoint_path TEXT
+      );
+    `);
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS mission_cost (
+        id           INTEGER PRIMARY KEY AUTOINCREMENT,
+        run_id       TEXT NOT NULL,
+        model        TEXT NOT NULL,
+        input_tokens INTEGER DEFAULT 0,
+        output_tokens INTEGER DEFAULT 0,
+        cost_cents   REAL DEFAULT 0,
+        logged_at    DATETIME DEFAULT CURRENT_TIMESTAMP,
+        FOREIGN KEY (run_id) REFERENCES mission_runs(run_id)
+      );
+      CREATE INDEX IF NOT EXISTS idx_cost_run_id ON mission_cost(run_id);
+    `);
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS audit_log (
+        id           INTEGER PRIMARY KEY AUTOINCREMENT,
+        run_id       TEXT,
+        timestamp    DATETIME DEFAULT CURRENT_TIMESTAMP,
+        level        TEXT DEFAULT 'info',
+        action_type  TEXT NOT NULL,
+        detail       TEXT,
+        agent        TEXT,
+        mission_goal TEXT
+      );
+      CREATE INDEX IF NOT EXISTS idx_audit_run_id ON audit_log(run_id);
+      CREATE INDEX IF NOT EXISTS idx_audit_timestamp ON audit_log(timestamp);
+    `);
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS episodic_memory (
+        id           INTEGER PRIMARY KEY AUTOINCREMENT,
+        session_id   TEXT NOT NULL,
+        summary      TEXT NOT NULL,
+        raw_content  TEXT,
+        relevance    REAL DEFAULT 0.5,
+        reinforced   INTEGER DEFAULT 0,
+        created_at   DATETIME DEFAULT CURRENT_TIMESTAMP
+      );
+      CREATE INDEX IF NOT EXISTS idx_episodic_session ON episodic_memory(session_id);
+    `);
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS agent_registry (
+        agent_name   TEXT PRIMARY KEY,
+        capabilities TEXT,
+        last_seen    DATETIME DEFAULT CURRENT_TIMESTAMP,
+        status       TEXT DEFAULT 'available'
+      );
     `);
       }
       // Implements DatabasePort
@@ -4971,8 +5184,8 @@ var init_database = __esm({
         transaction(actions);
         return { processed: actions.length, errors };
       }
-      async loadExtension(path3) {
-        this.db.loadExtension(path3);
+      async loadExtension(path4) {
+        this.db.loadExtension(path4);
       }
       async close() {
         this.db.close();
@@ -4981,6 +5194,59 @@ var init_database = __esm({
       getRawDb() {
         return this.db;
       }
+      // ── Priority 1: Run / Cost helpers ──────────────────────────────────────
+      startRun(runId, missionId, seed, deterministic) {
+        this.db.prepare(`
+      INSERT OR REPLACE INTO mission_runs (run_id, mission_id, seed, deterministic, status)
+      VALUES (?, ?, ?, ?, 'running')
+    `).run(runId, missionId, seed ?? null, deterministic ? 1 : 0);
+      }
+      endRun(runId, status = "completed") {
+        this.db.prepare(`
+      UPDATE mission_runs SET completed_at = CURRENT_TIMESTAMP, status = ? WHERE run_id = ?
+    `).run(status, runId);
+      }
+      logCost(runId, model, inputTokens, outputTokens, costCents) {
+        this.db.prepare(`
+      INSERT INTO mission_cost (run_id, model, input_tokens, output_tokens, cost_cents)
+      VALUES (?, ?, ?, ?, ?)
+    `).run(runId, model, inputTokens, outputTokens, costCents);
+      }
+      getTotalCost(runId) {
+        const row = this.db.prepare(
+          "SELECT COALESCE(SUM(cost_cents), 0) as total FROM mission_cost WHERE run_id = ?"
+        ).get(runId);
+        return row?.total ?? 0;
+      }
+      // ── Priority 2: Audit log ────────────────────────────────────────────────
+      audit(actionType, detail, level = "info", runId, agent, missionGoal) {
+        this.db.prepare(`
+      INSERT INTO audit_log (run_id, action_type, detail, level, agent, mission_goal)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `).run(runId ?? null, actionType, detail, level, agent ?? null, missionGoal ?? null);
+      }
+      // ── Priority 2: Cross-session memory ─────────────────────────────────────
+      storeEpisodic(sessionId, summary, rawContent, relevance = 0.5) {
+        this.db.prepare(`
+      INSERT INTO episodic_memory (session_id, summary, raw_content, relevance)
+      VALUES (?, ?, ?, ?)
+    `).run(sessionId, summary, rawContent ?? null, relevance);
+      }
+      getRecentEpisodic(limit = 10) {
+        return this.db.prepare(`
+      SELECT session_id, summary, relevance, created_at
+      FROM episodic_memory
+      ORDER BY created_at DESC, relevance DESC
+      LIMIT ?
+    `).all(limit);
+      }
+      // ── Priority 2: Agent registry ────────────────────────────────────────────
+      registerAgent(name, capabilities) {
+        this.db.prepare(`
+      INSERT OR REPLACE INTO agent_registry (agent_name, capabilities, last_seen, status)
+      VALUES (?, ?, CURRENT_TIMESTAMP, 'available')
+    `).run(name, JSON.stringify(capabilities));
+      }
     };
   }
 });
@@ -5036,8 +5302,8 @@ __export(tui_exports, {
   MeowTUI: () => MeowTUI
 });
 import * as blessed from "blessed";
-import * as path2 from "path";
-import * as fs2 from "fs";
+import * as path3 from "path";
+import * as fs3 from "fs";
 function stylize(open, text2) {
   return text2 ? `${open}${text2}{/}` : text2;
 }
@@ -5183,7 +5449,7 @@ var init_tui = __esm({
       // ── constructor ─────────────────────────────────────────────────────────────
       constructor(agent, screen2) {
         this.agent = agent;
-        this.historyPath = path2.join(process.env.HOME ?? "/tmp", ".meow", "history.txt");
+        this.historyPath = path3.join(process.env.HOME ?? "/tmp", ".meow", "history.txt");
         this.screen = screen2 ?? blessed.screen({
           smartCSR: true,
           title: "MEOW",
@@ -5302,9 +5568,9 @@ var init_tui = __esm({
         this.history.push(cmd);
         this.historyIdx = -1;
         try {
-          const dir = path2.dirname(this.historyPath);
-          if (!fs2.existsSync(dir)) fs2.mkdirSync(dir, { recursive: true });
-          fs2.appendFileSync(this.historyPath, cmd + "\n");
+          const dir = path3.dirname(this.historyPath);
+          if (!fs3.existsSync(dir)) fs3.mkdirSync(dir, { recursive: true });
+          fs3.appendFileSync(this.historyPath, cmd + "\n");
         } catch {
         }
       }
@@ -5670,8 +5936,8 @@ function createRepl(agent) {
 
 // src/kernel/kernel.ts
 import pc9 from "picocolors";
-import fs from "fs";
-import path from "path";
+import fs2 from "fs";
+import path2 from "path";
 var MeowKernel = class {
   db;
   queue = [];
@@ -5698,13 +5964,13 @@ var MeowKernel = class {
     this.setupExitHandlers();
   }
   setupLogDirectory() {
-    const logDir = path.join(process.cwd(), ".meow", "logs");
-    if (!fs.existsSync(logDir)) {
-      fs.mkdirSync(logDir, { recursive: true });
+    const logDir = path2.join(process.cwd(), ".meow", "logs");
+    if (!fs2.existsSync(logDir)) {
+      fs2.mkdirSync(logDir, { recursive: true });
     }
     this.logDir = logDir;
-    this.logFile = path.join(logDir, `meow-${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.log`);
-    this.logStream = fs.createWriteStream(this.logFile, { flags: "a" });
+    this.logFile = path2.join(logDir, `meow-${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.log`);
+    this.logStream = fs2.createWriteStream(this.logFile, { flags: "a" });
     this.log(pc9.cyan("\u{1F680} Meow Kernel initialized"), "KERNEL");
   }
   logDir = "";
@@ -5975,6 +6241,22 @@ async function main() {
   }
   const kernel = new MeowKernel(db);
   kernel.start();
+  const continueMode = process.argv.includes("--continue") || process.argv.includes("-c");
+  if (continueMode) {
+    const { MeowDatabase: MeowDatabase2 } = await Promise.resolve().then(() => (init_database(), database_exports));
+    const meowDb = db;
+    const recent = meowDb.getRawDb().prepare(`
+      SELECT run_id FROM mission_runs
+      WHERE status = 'running'
+      ORDER BY created_at DESC LIMIT 1
+    `).get();
+    if (recent) {
+      console.log(`\u21BB Continuing run: ${recent.run_id}`);
+      process.env.MEOW_RUN_ID = recent.run_id;
+    } else {
+      console.log("\u21BB No previous run found. Starting fresh.");
+    }
+  }
   const agent = new Agent({
     model: config.model,
     baseUrl: config.baseUrl,
@@ -5989,12 +6271,25 @@ async function main() {
       console.error('Usage: meow -p "<task description>"');
       process.exit(1);
     }
-    console.log(`\u{1F916} [MEOW] Plan mode: ${command2}`);
+    if (config.deterministic || config.seed !== void 0) {
+      const seedInfo = config.seed !== void 0 ? ` seed=${config.seed}` : " deterministic";
+      console.log(`\u{1F916} [meow] Plan mode${seedInfo}: ${command2}`);
+    } else {
+      console.log(`\u{1F916} [meow] Plan mode: ${command2}`);
+    }
     const response = await agent.chat(command2, false, void 0, (status) => {
       process.stdout.write(`\r${status}`);
     });
     console.log("\n" + response);
-    console.log("\n\u2705 Command completed.");
+    const { MeowDatabase: MeowDatabase2 } = await Promise.resolve().then(() => (init_database(), database_exports));
+    const meowDb = db;
+    const totalCost = meowDb.getTotalCost(agent.runId);
+    if (totalCost > 0) {
+      const budgetInfo = config.budgetCents ? ` (budget: ${config.budgetCents}\xA2)` : "";
+      console.log(`
+\u{1F4B0} Total cost: ${totalCost.toFixed(4)}\xA2${budgetInfo}`);
+    }
+    meowDb.endRun(agent.runId, "completed");
     await kernel.shutdown();
     process.exit(0);
     return;
@@ -6007,7 +6302,7 @@ async function main() {
   }
   const command = process.argv.filter((arg) => !arg.startsWith("--")).slice(2).join(" ");
   if (command) {
-    console.log(`\u{1F916} [MEOW] Executing command: ${command}`);
+    console.log(`\u{1F916} [meow] Executing command: ${command}`);
     const response = await agent.chat(command, false, void 0, (status) => {
       process.stdout.write(`\r${status}`);
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "meow-swarm",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "type": "module",
   "description": "meow -p: Autonomous multi-agent coding harness. Run coding agents in background, checkpoint state, TUI dashboard.",
   "main": "dist/index.js",
@@ -33,7 +33,8 @@
     "js-yaml": "4.1.1",
     "mathjs": "^15.2.0",
     "picocolors": "1.1.1",
-    "sqlite-vec": "^0.1.9"
+    "sqlite-vec": "^0.1.9",
+    "uuid": "^11.0.0"
   },
   "devDependencies": {
     "@types/better-sqlite3": "7.6.13",