@vefimov/crew 0.0.0-stage → 0.1.0

package/dist/crew.js

@@ -0,0 +1,1854 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// ../packages/core/src/crew.ts
+import { EventEmitter } from "node:events";
+
+// ../packages/memory/src/store.ts
+import { DatabaseSync } from "node:sqlite";
+import { mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import { randomUUID } from "node:crypto";
+
+// ../packages/memory/src/migrations.ts
+var migrations = [
+  /* 1 — initial schema */
+  `
+  CREATE TABLE agents (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL UNIQUE COLLATE NOCASE,
+    role TEXT NOT NULL DEFAULT '',
+    personality TEXT NOT NULL DEFAULT '',
+    system_prompt TEXT NOT NULL DEFAULT '',
+    model TEXT,
+    avatar TEXT NOT NULL DEFAULT '\u{1F916}',
+    color TEXT NOT NULL DEFAULT '#7c5cff',
+    created_at INTEGER NOT NULL,
+    updated_at INTEGER NOT NULL
+  );
+
+  CREATE TABLE conversations (
+    id TEXT PRIMARY KEY,
+    agent_id TEXT NOT NULL REFERENCES agents(id) ON DELETE CASCADE,
+    channel TEXT NOT NULL,
+    channel_ref TEXT NOT NULL,
+    created_at INTEGER NOT NULL,
+    UNIQUE (agent_id, channel, channel_ref)
+  );
+
+  CREATE TABLE messages (
+    id TEXT PRIMARY KEY,
+    conversation_id TEXT NOT NULL REFERENCES conversations(id) ON DELETE CASCADE,
+    role TEXT NOT NULL,
+    content TEXT NOT NULL,
+    meta TEXT,
+    created_at INTEGER NOT NULL
+  );
+  CREATE INDEX messages_conv ON messages(conversation_id, created_at);
+
+  CREATE TABLE memories (
+    id TEXT PRIMARY KEY,
+    agent_id TEXT NOT NULL REFERENCES agents(id) ON DELETE CASCADE,
+    content TEXT NOT NULL,
+    type TEXT NOT NULL DEFAULT 'fact',
+    importance REAL NOT NULL DEFAULT 0.5,
+    source TEXT NOT NULL DEFAULT 'manual',
+    embedding BLOB,
+    created_at INTEGER NOT NULL,
+    last_used_at INTEGER
+  );
+  CREATE INDEX memories_agent ON memories(agent_id);
+
+  CREATE VIRTUAL TABLE memories_fts USING fts5(content, content='memories', content_rowid='rowid');
+  CREATE TRIGGER memories_ai AFTER INSERT ON memories BEGIN
+    INSERT INTO memories_fts(rowid, content) VALUES (new.rowid, new.content);
+  END;
+  CREATE TRIGGER memories_ad AFTER DELETE ON memories BEGIN
+    INSERT INTO memories_fts(memories_fts, rowid, content) VALUES ('delete', old.rowid, old.content);
+  END;
+  CREATE TRIGGER memories_au AFTER UPDATE OF content ON memories BEGIN
+    INSERT INTO memories_fts(memories_fts, rowid, content) VALUES ('delete', old.rowid, old.content);
+    INSERT INTO memories_fts(rowid, content) VALUES (new.rowid, new.content);
+  END;
+
+  CREATE TABLE files_access (
+    id TEXT PRIMARY KEY,
+    agent_id TEXT NOT NULL REFERENCES agents(id) ON DELETE CASCADE,
+    path TEXT NOT NULL,
+    mode TEXT NOT NULL DEFAULT 'ro',
+    UNIQUE (agent_id, path)
+  );
+
+  CREATE TABLE settings (
+    key TEXT PRIMARY KEY,
+    value TEXT NOT NULL
+  );
+  `,
+  /* 2 — background tasks */
+  `
+  CREATE TABLE tasks (
+    id TEXT PRIMARY KEY,
+    kind TEXT NOT NULL,
+    payload TEXT NOT NULL,
+    status TEXT NOT NULL DEFAULT 'queued',
+    attempts INTEGER NOT NULL DEFAULT 0,
+    error TEXT,
+    run_at INTEGER NOT NULL,
+    created_at INTEGER NOT NULL,
+    updated_at INTEGER NOT NULL
+  );
+  CREATE INDEX tasks_queue ON tasks(status, run_at);
+  `
+];
+
+// ../packages/memory/src/vector.ts
+function toBlob(vec) {
+  return new Uint8Array(new Float32Array(vec).buffer);
+}
+function fromBlob(blob) {
+  const copy = blob.slice();
+  return new Float32Array(copy.buffer, copy.byteOffset, copy.byteLength / 4);
+}
+function cosine(a, b) {
+  if (a.length !== b.length || a.length === 0) return 0;
+  let dot = 0;
+  let na = 0;
+  let nb = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    na += a[i] * a[i];
+    nb += b[i] * b[i];
+  }
+  if (na === 0 || nb === 0) return 0;
+  return dot / (Math.sqrt(na) * Math.sqrt(nb));
+}
+var STOP = new Set(
+  "the and for are was were you your what which who how why when where this that with from have has had use used does did not but can could would should about into our out his her its they them their there \u0447\u0442\u043E \u043A\u0430\u043A \u044D\u0442\u043E \u0433\u0434\u0435 \u043A\u043E\u0433\u0434\u0430 \u043A\u0442\u043E \u0434\u043B\u044F \u0438\u043B\u0438 \u0435\u0441\u043B\u0438 \u0442\u0430\u043A \u0443\u0436\u0435 \u0432\u0441\u0435 \u043E\u043D\u0430 \u043E\u043D\u0438 \u043E\u043D\u043E \u0435\u0433\u043E \u043C\u043D\u0435 \u043C\u0435\u043D\u044F \u043C\u043E\u0439 \u043C\u043E\u044F \u043C\u043E\u0438 \u043D\u0430\u0448 \u0432\u0430\u0448 \u0442\u0435\u0431\u0435 \u0442\u0435\u0431\u044F \u0449\u043E \u044F\u043A \u044D\u0442\u043E \u043A\u043E\u043B\u0438 \u0445\u0442\u043E \u0430\u0431\u043E \u044F\u043A\u0449\u043E \u0432\u0436\u0435 \u0432\u0441\u0456 \u0432\u043E\u043D\u0430 \u0432\u043E\u043D\u0438 \u0439\u043E\u0433\u043E \u043C\u0435\u043D\u0456 \u043C\u0435\u043D\u0435 \u043C\u0456\u0439 \u043C\u043E\u044F \u043C\u043E\u0457 \u043D\u0430\u0448 \u0432\u0430\u0448 \u0442\u043E\u0431\u0456 \u0442\u0435\u0431\u0435".split(" ")
+);
+function ftsQuery(text) {
+  const words = text.toLowerCase().match(/[\p{L}\p{N}_]{3,}/gu)?.filter((w) => !STOP.has(w)).slice(0, 24);
+  if (!words?.length) return null;
+  return [...new Set(words)].map((w) => w.length >= 5 ? `"${w.slice(0, Math.max(5, w.length - 2))}"*` : `"${w}"`).join(" OR ");
+}
+
+// ../packages/memory/src/store.ts
+var now = () => Date.now();
+var id = () => randomUUID();
+var AGENT_COLORS = ["#7c5cff", "#ff6b6b", "#20c997", "#fab005", "#4dabf7", "#e64980", "#82c91e", "#fd7e14"];
+function toAgent(r) {
+  return {
+    id: r.id,
+    name: r.name,
+    role: r.role,
+    personality: r.personality,
+    systemPrompt: r.system_prompt,
+    model: r.model ?? null,
+    avatar: r.avatar,
+    color: r.color,
+    createdAt: Number(r.created_at),
+    updatedAt: Number(r.updated_at)
+  };
+}
+function toMemory(r) {
+  return {
+    id: r.id,
+    agentId: r.agent_id,
+    content: r.content,
+    type: r.type,
+    importance: Number(r.importance),
+    source: r.source,
+    createdAt: Number(r.created_at),
+    lastUsedAt: r.last_used_at == null ? null : Number(r.last_used_at)
+  };
+}
+function toMessage(r) {
+  return {
+    id: r.id,
+    conversationId: r.conversation_id,
+    role: r.role,
+    content: r.content,
+    meta: r.meta ? JSON.parse(r.meta) : null,
+    createdAt: Number(r.created_at)
+  };
+}
+function toTask(r) {
+  return {
+    id: r.id,
+    kind: r.kind,
+    payload: JSON.parse(r.payload),
+    status: r.status,
+    attempts: Number(r.attempts),
+    error: r.error ?? null,
+    runAt: Number(r.run_at),
+    createdAt: Number(r.created_at),
+    updatedAt: Number(r.updated_at)
+  };
+}
+var Store = class {
+  constructor(file) {
+    this.file = file;
+    if (file !== ":memory:") mkdirSync(dirname(file), { recursive: true });
+    this.db = new DatabaseSync(file);
+    this.db.exec("PRAGMA journal_mode = WAL; PRAGMA foreign_keys = ON; PRAGMA busy_timeout = 5000;");
+    this.migrate();
+  }
+  file;
+  db;
+  migrate() {
+    const { user_version } = this.db.prepare("PRAGMA user_version").get();
+    for (let v = user_version; v < migrations.length; v++) {
+      this.db.exec("BEGIN");
+      try {
+        this.db.exec(migrations[v]);
+        this.db.exec(`PRAGMA user_version = ${v + 1}`);
+        this.db.exec("COMMIT");
+      } catch (err) {
+        this.db.exec("ROLLBACK");
+        throw err;
+      }
+    }
+  }
+  close() {
+    this.db.close();
+  }
+  // ── agents ────────────────────────────────────────────────────────────
+  listAgents() {
+    return this.db.prepare("SELECT * FROM agents ORDER BY created_at").all().map(toAgent);
+  }
+  getAgent(idOrName) {
+    const r = this.db.prepare("SELECT * FROM agents WHERE id = ? OR name = ? COLLATE NOCASE").get(idOrName, idOrName);
+    return r ? toAgent(r) : null;
+  }
+  createAgent(input) {
+    const count = this.db.prepare("SELECT COUNT(*) AS n FROM agents").get().n;
+    const t = now();
+    const agentId = id();
+    this.db.prepare(
+      `INSERT INTO agents (id, name, role, personality, system_prompt, model, avatar, color, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      agentId,
+      input.name.trim(),
+      input.role ?? "",
+      input.personality ?? "",
+      input.systemPrompt ?? "",
+      input.model ?? null,
+      input.avatar ?? "\u{1F916}",
+      input.color ?? AGENT_COLORS[count % AGENT_COLORS.length],
+      t,
+      t
+    );
+    return this.getAgent(agentId);
+  }
+  updateAgent(agentId, patch) {
+    const cur = this.getAgent(agentId);
+    if (!cur) throw new Error(`Agent not found: ${agentId}`);
+    const next = { ...cur, ...patch };
+    this.db.prepare(
+      `UPDATE agents SET name = ?, role = ?, personality = ?, system_prompt = ?, model = ?, avatar = ?, color = ?, updated_at = ?
+         WHERE id = ?`
+    ).run(next.name, next.role, next.personality, next.systemPrompt, next.model ?? null, next.avatar, next.color, now(), cur.id);
+    return this.getAgent(cur.id);
+  }
+  deleteAgent(agentId) {
+    this.db.prepare("DELETE FROM agents WHERE id = ?").run(agentId);
+  }
+  // ── conversations & messages ─────────────────────────────────────────
+  conversation(agentId, channel = "web", channelRef = "default") {
+    const found = this.db.prepare("SELECT * FROM conversations WHERE agent_id = ? AND channel = ? AND channel_ref = ?").get(agentId, channel, channelRef);
+    if (found) {
+      return {
+        id: found.id,
+        agentId,
+        channel,
+        channelRef,
+        createdAt: Number(found.created_at)
+      };
+    }
+    const conv = { id: id(), agentId, channel, channelRef, createdAt: now() };
+    this.db.prepare("INSERT INTO conversations (id, agent_id, channel, channel_ref, created_at) VALUES (?, ?, ?, ?, ?)").run(conv.id, agentId, channel, channelRef, conv.createdAt);
+    return conv;
+  }
+  listConversations(agentId) {
+    return this.db.prepare("SELECT * FROM conversations WHERE agent_id = ? ORDER BY created_at").all(agentId).map(
+      (r) => ({
+        id: r.id,
+        agentId,
+        channel: r.channel,
+        channelRef: r.channel_ref,
+        createdAt: Number(r.created_at)
+      })
+    );
+  }
+  addMessage(conversationId, role, content, meta) {
+    const msg = { id: id(), conversationId, role, content, meta: meta ?? null, createdAt: now() };
+    this.db.prepare("INSERT INTO messages (id, conversation_id, role, content, meta, created_at) VALUES (?, ?, ?, ?, ?, ?)").run(msg.id, conversationId, role, content, meta ? JSON.stringify(meta) : null, msg.createdAt);
+    return msg;
+  }
+  /** Last `limit` messages of a conversation, oldest first. */
+  messages(conversationId, limit = 50) {
+    const rows = this.db.prepare("SELECT * FROM messages WHERE conversation_id = ? ORDER BY created_at DESC, rowid DESC LIMIT ?").all(conversationId, limit);
+    return rows.reverse().map(toMessage);
+  }
+  clearConversation(conversationId) {
+    this.db.prepare("DELETE FROM messages WHERE conversation_id = ?").run(conversationId);
+  }
+  // ── memories ─────────────────────────────────────────────────────────
+  addMemory(input) {
+    const memId = id();
+    this.db.prepare(
+      `INSERT INTO memories (id, agent_id, content, type, importance, source, embedding, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      memId,
+      input.agentId,
+      input.content.trim(),
+      input.type ?? "fact",
+      Math.min(1, Math.max(0, input.importance ?? 0.5)),
+      input.source ?? "manual",
+      input.embedding?.length ? toBlob(input.embedding) : null,
+      now()
+    );
+    return this.getMemory(memId);
+  }
+  getMemory(memId) {
+    const r = this.db.prepare("SELECT * FROM memories WHERE id = ?").get(memId);
+    return r ? toMemory(r) : null;
+  }
+  listMemories(agentId, limit = 200) {
+    return this.db.prepare("SELECT * FROM memories WHERE agent_id = ? ORDER BY created_at DESC LIMIT ?").all(agentId, limit).map(toMemory);
+  }
+  countMemories(agentId) {
+    return this.db.prepare("SELECT COUNT(*) AS n FROM memories WHERE agent_id = ?").get(agentId).n;
+  }
+  deleteMemory(memId) {
+    this.db.prepare("DELETE FROM memories WHERE id = ?").run(memId);
+  }
+  setMemoryEmbedding(memId, embedding) {
+    this.db.prepare("UPDATE memories SET embedding = ? WHERE id = ?").run(toBlob(embedding), memId);
+  }
+  /** Memories that still lack an embedding (e.g. created while the embed model was offline). */
+  memoriesWithoutEmbedding(limit = 50) {
+    return this.db.prepare("SELECT * FROM memories WHERE embedding IS NULL LIMIT ?").all(limit).map(toMemory);
+  }
+  /**
+   * Hybrid recall: full-text (BM25) and vector similarity are merged with
+   * reciprocal-rank fusion, then nudged by importance and recency.
+   */
+  searchMemories(agentId, query, opts = {}) {
+    const limit = opts.limit ?? 6;
+    const ranks = /* @__PURE__ */ new Map();
+    const rows = /* @__PURE__ */ new Map();
+    const K = 60;
+    const fts = ftsQuery(query);
+    if (fts) {
+      const hits = this.db.prepare(
+        `SELECT m.* FROM memories_fts f JOIN memories m ON m.rowid = f.rowid
+           WHERE memories_fts MATCH ? AND m.agent_id = ? ORDER BY bm25(memories_fts) LIMIT 30`
+      ).all(fts, agentId);
+      hits.forEach((r, i) => {
+        rows.set(r.id, r);
+        ranks.set(r.id, (ranks.get(r.id) ?? 0) + 1 / (K + i));
+      });
+    }
+    if (opts.embedding?.length) {
+      const all = this.db.prepare("SELECT * FROM memories WHERE agent_id = ? AND embedding IS NOT NULL").all(agentId);
+      all.map((r) => ({ r, s: cosine(opts.embedding, fromBlob(r.embedding)) })).filter((x) => x.s > 0.35).sort((a, b) => b.s - a.s).slice(0, 30).forEach(({ r }, i) => {
+        rows.set(r.id, r);
+        ranks.set(r.id, (ranks.get(r.id) ?? 0) + 1 / (K + i));
+      });
+    }
+    const t = now();
+    const scored = [...ranks.entries()].map(([memId, rrf]) => {
+      const m = toMemory(rows.get(memId));
+      const ageDays = (t - m.createdAt) / 864e5;
+      const score = rrf * (1 + m.importance) * (1 + 0.25 * Math.exp(-ageDays / 30));
+      return { ...m, score };
+    });
+    scored.sort((a, b) => b.score - a.score);
+    const top = scored.slice(0, limit);
+    if (top.length) {
+      const touch = this.db.prepare("UPDATE memories SET last_used_at = ? WHERE id = ?");
+      for (const m of top) touch.run(t, m.id);
+    }
+    return top;
+  }
+  /** The single most similar memory by embedding, used to avoid storing near-duplicates. */
+  nearest(agentId, embedding) {
+    let best = null;
+    const rows = this.db.prepare("SELECT * FROM memories WHERE agent_id = ? AND embedding IS NOT NULL").all(agentId);
+    for (const row of rows) {
+      const similarity = cosine(embedding, fromBlob(row.embedding));
+      if (!best || similarity > best.similarity) best = { row, similarity };
+    }
+    return best ? { memory: toMemory(best.row), similarity: best.similarity } : null;
+  }
+  /** The most important memories — always included in the agent's context. */
+  coreMemories(agentId, limit = 5) {
+    return this.db.prepare("SELECT * FROM memories WHERE agent_id = ? AND importance >= 0.8 ORDER BY importance DESC, created_at DESC LIMIT ?").all(agentId, limit).map(toMemory);
+  }
+  // ── folders ──────────────────────────────────────────────────────────
+  listFolders(agentId) {
+    return this.db.prepare("SELECT * FROM files_access WHERE agent_id = ? ORDER BY path").all(agentId).map((r) => ({
+      id: r.id,
+      agentId,
+      path: r.path,
+      mode: r.mode
+    }));
+  }
+  grantFolder(agentId, path, mode = "ro") {
+    this.db.prepare(
+      `INSERT INTO files_access (id, agent_id, path, mode) VALUES (?, ?, ?, ?)
+         ON CONFLICT (agent_id, path) DO UPDATE SET mode = excluded.mode`
+    ).run(id(), agentId, path, mode);
+    return this.listFolders(agentId).find((f) => f.path === path);
+  }
+  revokeFolder(folderId) {
+    this.db.prepare("DELETE FROM files_access WHERE id = ?").run(folderId);
+  }
+  // ── settings ─────────────────────────────────────────────────────────
+  getSetting(key) {
+    const r = this.db.prepare("SELECT value FROM settings WHERE key = ?").get(key);
+    return r ? JSON.parse(r.value) : null;
+  }
+  setSetting(key, value) {
+    this.db.prepare("INSERT INTO settings (key, value) VALUES (?, ?) ON CONFLICT (key) DO UPDATE SET value = excluded.value").run(key, JSON.stringify(value));
+  }
+  allSettings() {
+    const out = {};
+    for (const r of this.db.prepare("SELECT key, value FROM settings").all()) {
+      out[r.key] = JSON.parse(r.value);
+    }
+    return out;
+  }
+  // ── tasks (a tiny SQLite-backed queue) ────────────────────────────────
+  enqueue(kind, payload, delayMs = 0) {
+    const t = now();
+    const taskId = id();
+    this.db.prepare(
+      "INSERT INTO tasks (id, kind, payload, status, run_at, created_at, updated_at) VALUES (?, ?, ?, 'queued', ?, ?, ?)"
+    ).run(taskId, kind, JSON.stringify(payload), t + delayMs, t, t);
+    return this.getTask(taskId);
+  }
+  getTask(taskId) {
+    const r = this.db.prepare("SELECT * FROM tasks WHERE id = ?").get(taskId);
+    return r ? toTask(r) : null;
+  }
+  /** Atomically claim the next due task. */
+  claimTask() {
+    const t = now();
+    const r = this.db.prepare(
+      `UPDATE tasks SET status = 'running', attempts = attempts + 1, updated_at = ?
+         WHERE id = (SELECT id FROM tasks WHERE status = 'queued' AND run_at <= ? ORDER BY run_at LIMIT 1)
+         RETURNING *`
+    ).get(t, t);
+    return r ? toTask(r) : null;
+  }
+  finishTask(taskId, error, retryInMs) {
+    const t = now();
+    if (!error) {
+      this.db.prepare("UPDATE tasks SET status = 'done', error = NULL, updated_at = ? WHERE id = ?").run(t, taskId);
+    } else if (retryInMs != null) {
+      this.db.prepare("UPDATE tasks SET status = 'queued', error = ?, run_at = ?, updated_at = ? WHERE id = ?").run(error, t + retryInMs, t, taskId);
+    } else {
+      this.db.prepare("UPDATE tasks SET status = 'failed', error = ?, updated_at = ? WHERE id = ?").run(error, t, taskId);
+    }
+  }
+  listTasks(limit = 50) {
+    return this.db.prepare("SELECT * FROM tasks ORDER BY created_at DESC LIMIT ?").all(limit).map(toTask);
+  }
+  /** Re-queue tasks left in `running` by a crashed process. */
+  recoverTasks() {
+    this.db.prepare("UPDATE tasks SET status = 'queued' WHERE status = 'running'").run();
+  }
+  pruneTasks(olderThanMs = 7 * 864e5) {
+    this.db.prepare("DELETE FROM tasks WHERE status IN ('done', 'failed') AND updated_at < ?").run(now() - olderThanMs);
+  }
+};
+
+// ../packages/core/src/config.ts
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+var DEFAULT_MODEL = "qwen2.5:3b";
+var DEFAULT_EMBED_MODEL = "nomic-embed-text";
+function expand(p) {
+  return p.startsWith("~") ? join(homedir(), p.slice(1)) : resolve(p);
+}
+function envConfig(env = process.env) {
+  const home = expand(env.CREW_HOME || "~/.crew");
+  return {
+    home,
+    dbFile: join(home, "crew.db"),
+    port: Number(env.CREW_PORT || env.PORT || 3e3),
+    provider: env.CREW_PROVIDER === "openai" ? "openai" : "ollama",
+    ollamaHost: env.OLLAMA_HOST ? normalizeHost(env.OLLAMA_HOST) : "http://127.0.0.1:11434",
+    openaiBaseUrl: env.OPENAI_BASE_URL || "https://api.openai.com/v1",
+    openaiApiKey: env.OPENAI_API_KEY || "",
+    model: env.CREW_MODEL || "",
+    embedModel: env.CREW_EMBED_MODEL || "",
+    telegramToken: env.CREW_TELEGRAM_TOKEN || ""
+  };
+}
+function normalizeHost(h) {
+  let url = /^https?:\/\//.test(h) ? h : `http://${h}`;
+  url = url.replace("://0.0.0.0", "://127.0.0.1");
+  return url;
+}
+var SETTING_KEYS = [
+  "provider",
+  "ollamaHost",
+  "openaiBaseUrl",
+  "openaiApiKey",
+  "model",
+  "embedModel",
+  "telegramToken"
+];
+function resolveConfig(store, env = process.env) {
+  const base = envConfig(env);
+  const s = store.allSettings();
+  return {
+    ...base,
+    provider: env.CREW_PROVIDER ? base.provider : s.provider === "openai" ? "openai" : "ollama",
+    ollamaHost: env.OLLAMA_HOST ? base.ollamaHost : s.ollamaHost || base.ollamaHost,
+    openaiBaseUrl: env.OPENAI_BASE_URL ? base.openaiBaseUrl : s.openaiBaseUrl || base.openaiBaseUrl,
+    openaiApiKey: base.openaiApiKey || s.openaiApiKey || "",
+    model: base.model || s.model || DEFAULT_MODEL,
+    embedModel: base.embedModel || s.embedModel || DEFAULT_EMBED_MODEL,
+    telegramToken: base.telegramToken || s.telegramToken || ""
+  };
+}
+
+// ../packages/core/src/llm/ollama.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+
+// ../packages/core/src/llm/ndjson.ts
+async function* lines(body) {
+  const decoder = new TextDecoder();
+  let buf = "";
+  for await (const chunk2 of body) {
+    buf += decoder.decode(chunk2, { stream: true });
+    let nl;
+    while ((nl = buf.indexOf("\n")) >= 0) {
+      const line = buf.slice(0, nl).trim();
+      buf = buf.slice(nl + 1);
+      if (line) yield line;
+    }
+  }
+  if (buf.trim()) yield buf.trim();
+}
+
+// ../packages/core/src/llm/ollama.ts
+function toOllama(m) {
+  switch (m.role) {
+    case "assistant":
+      return {
+        role: "assistant",
+        content: m.content,
+        ...m.toolCalls?.length ? { tool_calls: m.toolCalls.map((c) => ({ function: { name: c.name, arguments: c.arguments } })) } : {}
+      };
+    case "tool":
+      return { role: "tool", content: m.content, tool_name: m.name };
+    default:
+      return { role: m.role, content: m.content };
+  }
+}
+var OllamaProvider = class {
+  name = "ollama";
+  host;
+  constructor(host = "http://127.0.0.1:11434") {
+    this.host = host.replace(/\/+$/, "");
+  }
+  async chat(req) {
+    const res = await fetch(`${this.host}/api/chat`, {
+      method: "POST",
+      signal: req.signal,
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({
+        model: req.model,
+        messages: req.messages.map(toOllama),
+        tools: req.tools?.length ? req.tools.map((t) => ({ type: "function", function: t })) : void 0,
+        stream: true,
+        format: req.json ? "json" : void 0,
+        options: { temperature: req.temperature ?? 0.7 }
+      })
+    });
+    if (!res.ok || !res.body) {
+      const text = await res.text().catch(() => "");
+      throw new Error(`Ollama ${res.status}: ${text || res.statusText}`);
+    }
+    let content = "";
+    const toolCalls = [];
+    for await (const line of lines(res.body)) {
+      const chunk2 = JSON.parse(line);
+      if (chunk2.error) throw new Error(`Ollama: ${chunk2.error}`);
+      const delta = chunk2.message?.content ?? "";
+      if (delta) {
+        content += delta;
+        req.onToken?.(delta);
+      }
+      for (const c of chunk2.message?.tool_calls ?? []) {
+        toolCalls.push({ id: randomUUID2(), name: c.function.name, arguments: c.function.arguments ?? {} });
+      }
+    }
+    return { content, toolCalls };
+  }
+  async embed(model, input) {
+    const res = await fetch(`${this.host}/api/embed`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ model, input })
+    });
+    if (!res.ok) throw new Error(`Ollama embed ${res.status}: ${await res.text()}`);
+    const data = await res.json();
+    return data.embeddings;
+  }
+  async models() {
+    const res = await fetch(`${this.host}/api/tags`);
+    if (!res.ok) throw new Error(`Ollama ${res.status}`);
+    const data = await res.json();
+    return data.models.map((m) => ({ name: m.name, size: m.size, family: m.details?.family }));
+  }
+  async ping() {
+    try {
+      const res = await fetch(`${this.host}/api/version`, { signal: AbortSignal.timeout(1500) });
+      return res.ok;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// ../packages/core/src/llm/openai.ts
+function toOpenAI(m) {
+  switch (m.role) {
+    case "assistant":
+      return {
+        role: "assistant",
+        content: m.content || null,
+        ...m.toolCalls?.length ? {
+          tool_calls: m.toolCalls.map((c) => ({
+            id: c.id,
+            type: "function",
+            function: { name: c.name, arguments: JSON.stringify(c.arguments) }
+          }))
+        } : {}
+      };
+    case "tool":
+      return { role: "tool", content: m.content, tool_call_id: m.toolCallId };
+    default:
+      return { role: m.role, content: m.content };
+  }
+}
+var OpenAIProvider = class {
+  constructor(baseUrl = "http://127.0.0.1:1234/v1", apiKey = "") {
+    this.apiKey = apiKey;
+    this.baseUrl = baseUrl.replace(/\/+$/, "");
+  }
+  apiKey;
+  name = "openai";
+  baseUrl;
+  headers() {
+    return {
+      "content-type": "application/json",
+      ...this.apiKey ? { authorization: `Bearer ${this.apiKey}` } : {}
+    };
+  }
+  async chat(req) {
+    const res = await fetch(`${this.baseUrl}/chat/completions`, {
+      method: "POST",
+      signal: req.signal,
+      headers: this.headers(),
+      body: JSON.stringify({
+        model: req.model,
+        messages: req.messages.map(toOpenAI),
+        tools: req.tools?.length ? req.tools.map((t) => ({ type: "function", function: t })) : void 0,
+        stream: true,
+        temperature: req.temperature ?? 0.7,
+        response_format: req.json ? { type: "json_object" } : void 0
+      })
+    });
+    if (!res.ok || !res.body) throw new Error(`OpenAI-compatible ${res.status}: ${await res.text().catch(() => "")}`);
+    let content = "";
+    const partial = /* @__PURE__ */ new Map();
+    for await (const line of lines(res.body)) {
+      if (!line.startsWith("data:")) continue;
+      const data = line.slice(5).trim();
+      if (data === "[DONE]") break;
+      const delta = JSON.parse(data).choices?.[0]?.delta ?? {};
+      if (delta.content) {
+        content += delta.content;
+        req.onToken?.(delta.content);
+      }
+      for (const tc of delta.tool_calls ?? []) {
+        const cur = partial.get(tc.index) ?? { id: tc.id ?? `call_${tc.index}`, name: "", args: "" };
+        if (tc.function?.name) cur.name += tc.function.name;
+        if (tc.function?.arguments) cur.args += tc.function.arguments;
+        partial.set(tc.index, cur);
+      }
+    }
+    const toolCalls = [...partial.values()].map((p) => ({
+      id: p.id,
+      name: p.name,
+      arguments: p.args ? safeJson(p.args) : {}
+    }));
+    return { content, toolCalls };
+  }
+  async embed(model, input) {
+    const res = await fetch(`${this.baseUrl}/embeddings`, {
+      method: "POST",
+      headers: this.headers(),
+      body: JSON.stringify({ model, input })
+    });
+    if (!res.ok) throw new Error(`Embeddings ${res.status}: ${await res.text()}`);
+    const data = await res.json();
+    return data.data.map((d) => d.embedding);
+  }
+  async models() {
+    const res = await fetch(`${this.baseUrl}/models`, { headers: this.headers() });
+    if (!res.ok) throw new Error(`Models ${res.status}`);
+    const data = await res.json();
+    return data.data.map((m) => ({ name: m.id }));
+  }
+  async ping() {
+    try {
+      const res = await fetch(`${this.baseUrl}/models`, { headers: this.headers(), signal: AbortSignal.timeout(1500) });
+      return res.ok;
+    } catch {
+      return false;
+    }
+  }
+};
+function safeJson(s) {
+  try {
+    return JSON.parse(s);
+  } catch {
+    return {};
+  }
+}
+
+// ../packages/core/src/prompt.ts
+function buildSystemPrompt({ agent: agent2, memories, folders, channel, now: now2 = /* @__PURE__ */ new Date() }) {
+  const parts = [];
+  parts.push(
+    `You are ${agent2.name}${agent2.role ? `, ${agent2.role}` : ""}. You are a persistent AI colleague living in Crew \u2014 a local-first workspace. You remember previous conversations with the user through your long-term memory.`
+  );
+  if (agent2.personality) parts.push(`Your personality: ${agent2.personality}`);
+  if (agent2.systemPrompt) parts.push(agent2.systemPrompt);
+  parts.push(
+    [
+      "Guidelines:",
+      "- Reply in the same language the user writes in.",
+      "- Be concise and practical; use Markdown when it helps.",
+      "- Stay in character, but never invent facts about the user \u2014 if you don't know, ask.",
+      "- When the user tells you something worth keeping (a preference, decision, fact about them or the project), call the `remember` tool.",
+      channel === "telegram" ? "- You are chatting via Telegram: keep messages short." : ""
+    ].filter(Boolean).join("\n")
+  );
+  if (memories.length) {
+    parts.push(
+      "What you remember (most relevant first):\n" + memories.map((m) => `- [${m.type}] ${m.content}`).join("\n")
+    );
+  }
+  if (folders.length) {
+    parts.push(
+      "Folders shared with you (use list_files / read_file / write_file):\n" + folders.map((f) => `- ${f.path} (${f.mode === "rw" ? "read-write" : "read-only"})`).join("\n")
+    );
+  }
+  parts.push(`Current date and time: ${now2.toISOString().slice(0, 16).replace("T", " ")} UTC.`);
+  return parts.join("\n\n");
+}
+var EXTRACT_PROMPT = `You maintain the long-term memory of an AI assistant.
+Read the latest exchange and extract durable information worth remembering for weeks:
+facts about the user, their projects, decisions that were made, and preferences.
+Ignore small talk, questions, and anything already known.
+
+Reply with JSON only: {"memories":[{"content":"...","type":"fact|decision|preference","importance":0.0-1.0}]}
+Each content must be a short, self-contained sentence in the user's language. Return {"memories":[]} if nothing is worth saving.`;
+
+// ../packages/core/src/tools/files.ts
+import { mkdir, readdir, readFile, realpath, stat, writeFile } from "node:fs/promises";
+import { dirname as dirname2, isAbsolute, join as join2, relative, resolve as resolve2 } from "node:path";
+var MAX_READ = 64 * 1024;
+var AccessError = class extends Error {
+};
+async function realish(p) {
+  let cur = p;
+  for (; ; ) {
+    try {
+      return join2(await realpath(cur), relative(cur, p));
+    } catch {
+      const parent = dirname2(cur);
+      if (parent === cur) throw new AccessError(`Path does not exist: ${p}`);
+      cur = parent;
+    }
+  }
+}
+function inside(child, parent) {
+  const rel = relative(parent, child);
+  return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
+}
+async function resolveAllowed(folders, requested, need) {
+  if (!folders.length) throw new AccessError("No folders are shared with you. Ask the user to grant access in Crew.");
+  const raw = String(requested || ".");
+  const candidates = isAbsolute(raw) ? [resolve2(raw)] : folders.map((f) => resolve2(f.path, raw));
+  for (const target of candidates) {
+    const finalPath = await realish(target);
+    for (const folder of folders) {
+      const root = await realpath(folder.path).catch(() => null);
+      if (!root || !inside(finalPath, root)) continue;
+      if (need === "rw" && folder.mode !== "rw") {
+        throw new AccessError(`Folder ${folder.path} is read-only for you.`);
+      }
+      return { path: finalPath, folder };
+    }
+  }
+  throw new AccessError(`Access denied: ${raw} is outside of your shared folders.`);
+}
+var listFiles = {
+  name: "list_files",
+  description: "List files and folders in a directory you have access to.",
+  parameters: {
+    type: "object",
+    properties: { path: { type: "string", description: "Directory path. Relative paths resolve against your shared folders." } }
+  },
+  async run(args, { agent: agent2, store }) {
+    const { path } = await resolveAllowed(store.listFolders(agent2.id), String(args.path ?? "."), "ro");
+    const entries = await readdir(path, { withFileTypes: true });
+    const shown = entries.filter((e) => !e.name.startsWith(".") && e.name !== "node_modules").slice(0, 200).map((e) => e.isDirectory() ? `${e.name}/` : e.name);
+    return `${path}
+${shown.join("\n") || "(empty)"}`;
+  }
+};
+var readFileTool = {
+  name: "read_file",
+  description: "Read a text file you have access to.",
+  parameters: {
+    type: "object",
+    properties: { path: { type: "string" } },
+    required: ["path"]
+  },
+  async run(args, { agent: agent2, store }) {
+    const { path } = await resolveAllowed(store.listFolders(agent2.id), String(args.path), "ro");
+    const info = await stat(path);
+    if (info.isDirectory()) return `${path} is a directory \u2014 use list_files.`;
+    const buf = await readFile(path);
+    if (buf.subarray(0, 8e3).includes(0)) return `${path} looks like a binary file (${info.size} bytes).`;
+    const text = buf.subarray(0, MAX_READ).toString("utf8");
+    return info.size > MAX_READ ? `${text}
+
+\u2026truncated (${info.size} bytes total)` : text;
+  }
+};
+var writeFileTool = {
+  name: "write_file",
+  description: "Create or overwrite a text file inside a folder shared with you in read-write mode.",
+  parameters: {
+    type: "object",
+    properties: { path: { type: "string" }, content: { type: "string" } },
+    required: ["path", "content"]
+  },
+  async run(args, { agent: agent2, store }) {
+    const { path } = await resolveAllowed(store.listFolders(agent2.id), String(args.path), "rw");
+    await mkdir(dirname2(path), { recursive: true });
+    const content = String(args.content ?? "");
+    await writeFile(path, content);
+    return `Wrote ${Buffer.byteLength(content)} bytes to ${path}`;
+  }
+};
+
+// ../packages/core/src/tools/memory.ts
+var rememberTool = {
+  name: "remember",
+  description: "Save an important long-term fact, decision or user preference so you remember it in future conversations. Use sparingly, only for durable information.",
+  parameters: {
+    type: "object",
+    properties: {
+      content: { type: "string", description: "A short self-contained statement, e.g. 'User's project uses Postgres 16'." },
+      type: { type: "string", enum: ["fact", "decision", "preference"] },
+      importance: { type: "number", description: "0..1, how important it is to remember" }
+    },
+    required: ["content"]
+  },
+  run: (args, ctx) => ctx.remember(String(args.content), args.type, args.importance)
+};
+var recallTool = {
+  name: "recall",
+  description: "Search your long-term memory for things you were told before.",
+  parameters: {
+    type: "object",
+    properties: { query: { type: "string" } },
+    required: ["query"]
+  },
+  run: (args, ctx) => ctx.recall(String(args.query))
+};
+
+// ../packages/core/src/tools/index.ts
+var memoryTools = [rememberTool, recallTool];
+var fileTools = [listFiles, readFileTool, writeFileTool];
+
+// ../packages/core/src/worker.ts
+var Worker = class {
+  constructor(store, intervalMs = 750) {
+    this.store = store;
+    this.intervalMs = intervalMs;
+  }
+  store;
+  intervalMs;
+  handlers = /* @__PURE__ */ new Map();
+  timer = null;
+  running = null;
+  handle(kind, fn) {
+    this.handlers.set(kind, fn);
+  }
+  start() {
+    if (this.timer) return;
+    this.store.recoverTasks();
+    this.store.pruneTasks();
+    this.timer = setInterval(() => {
+      if (!this.running) this.running = this.drain().finally(() => this.running = null);
+    }, this.intervalMs);
+    this.timer.unref?.();
+  }
+  async stop() {
+    if (this.timer) clearInterval(this.timer);
+    this.timer = null;
+    await this.running;
+  }
+  /** Run every due task. Exposed for tests and the CLI. */
+  async drain() {
+    for (let task = this.store.claimTask(); task; task = this.store.claimTask()) {
+      const fn = this.handlers.get(task.kind);
+      if (!fn) {
+        this.store.finishTask(task.id, `No handler for ${task.kind}`);
+        continue;
+      }
+      try {
+        await fn(task.payload, task);
+        this.store.finishTask(task.id);
+      } catch (err) {
+        const msg = err.message;
+        this.store.finishTask(task.id, msg, task.attempts < 3 ? 2 ** task.attempts * 5e3 : void 0);
+      }
+    }
+  }
+};
+
+// ../packages/core/src/crew.ts
+var MAX_TOOL_ROUNDS = 6;
+var HISTORY = 20;
+var DUPLICATE_SIMILARITY = 0.9;
+var Crew = class _Crew extends EventEmitter {
+  constructor(store) {
+    super();
+    this.store = store;
+    this.config = resolveConfig(store);
+    this.provider = makeProvider(this.config);
+    this.worker = new Worker(store);
+    this.worker.handle("memory.extract", (p) => this.extractMemories(p));
+    this.worker.handle("memory.embed", () => this.backfillEmbeddings());
+  }
+  store;
+  config;
+  provider;
+  worker;
+  locks = /* @__PURE__ */ new Map();
+  statuses = /* @__PURE__ */ new Map();
+  embedOk = null;
+  static open(file) {
+    return new _Crew(new Store(file ?? envConfig().dbFile));
+  }
+  /** Re-read settings (after they were changed from the UI or CLI). */
+  reload() {
+    this.config = resolveConfig(this.store);
+    this.provider = makeProvider(this.config);
+    this.embedOk = null;
+  }
+  emitEvent(e) {
+    this.emit("event", e);
+  }
+  status(agentId) {
+    return this.statuses.get(agentId) ?? "idle";
+  }
+  setStatus(agentId, status, detail) {
+    this.statuses.set(agentId, status);
+    this.emitEvent({ type: "status", agentId, status, detail });
+  }
+  modelFor(agent2) {
+    return agent2.model || this.config.model;
+  }
+  requireAgent(idOrName) {
+    const agent2 = this.store.getAgent(idOrName);
+    if (!agent2) throw new Error(`No agent named "${idOrName}"`);
+    return agent2;
+  }
+  // ── memory ───────────────────────────────────────────────────────────
+  async embed(text) {
+    if (this.embedOk === false) return null;
+    try {
+      const [vec] = await this.provider.embed(this.config.embedModel, [text]);
+      this.embedOk = true;
+      return vec ?? null;
+    } catch {
+      this.embedOk = false;
+      return null;
+    }
+  }
+  async remember(agentId, content, type = "fact", importance = 0.6, source = "manual") {
+    const text = content.trim();
+    if (!text) throw new Error("Memory is empty");
+    const embedding = await this.embed(text);
+    const near = embedding ? this.store.nearest(agentId, embedding) : null;
+    if (near && near.similarity >= DUPLICATE_SIMILARITY) return near.memory;
+    const [same] = this.store.searchMemories(agentId, text, { limit: 1 });
+    if (same && normalize(same.content) === normalize(text)) return same;
+    const memory2 = this.store.addMemory({ agentId, content: text, type, importance, source, embedding });
+    this.emitEvent({ type: "memory", agentId, memory: memory2 });
+    return memory2;
+  }
+  async recall(agentId, query, limit = 6) {
+    const embedding = await this.embed(query);
+    return this.store.searchMemories(agentId, query, { limit, embedding });
+  }
+  // ── chat ─────────────────────────────────────────────────────────────
+  /** Run one turn: user message → (tools)* → assistant reply. Turns of one agent are serialized. */
+  async chat(input) {
+    const agent2 = this.requireAgent(input.agent);
+    const prev = this.locks.get(agent2.id) ?? Promise.resolve();
+    const run = prev.catch(() => {
+    }).then(() => this.turn(agent2, input));
+    this.locks.set(agent2.id, run);
+    try {
+      return await run;
+    } finally {
+      if (this.locks.get(agent2.id) === run) this.locks.delete(agent2.id);
+    }
+  }
+  async turn(agent2, input) {
+    const channel = input.channel ?? "web";
+    const conv = this.store.conversation(agent2.id, channel, input.channelRef ?? "default");
+    const history = this.store.messages(conv.id, HISTORY);
+    const userMsg = this.store.addMessage(conv.id, "user", input.text);
+    this.emitEvent({ type: "message", agentId: agent2.id, conversationId: conv.id, message: userMsg });
+    this.setStatus(agent2.id, "thinking");
+    const replyId = crypto.randomUUID();
+    const toolLog = [];
+    let answer = "";
+    try {
+      const relevant = await this.recall(agent2.id, input.text, 6);
+      const core = this.store.coreMemories(agent2.id, 4).filter((m) => !relevant.some((r) => r.id === m.id));
+      const folders = this.store.listFolders(agent2.id);
+      const tools = [...memoryTools, ...folders.length ? fileTools : []];
+      const messages = [
+        { role: "system", content: buildSystemPrompt({ agent: agent2, memories: [...core, ...relevant], folders, channel }) },
+        ...history.filter((m) => m.role === "user" || m.role === "assistant").map((m) => ({ role: m.role, content: m.content })),
+        { role: "user", content: input.text }
+      ];
+      const ctx = {
+        agent: agent2,
+        store: this.store,
+        remember: async (content, type, importance) => {
+          const m = await this.remember(agent2.id, content, asType(type), importance ?? 0.7, "agent");
+          return `Saved to memory: ${m.content}`;
+        },
+        recall: async (query) => {
+          const hits = await this.recall(agent2.id, query, 8);
+          return hits.length ? hits.map((h) => `- ${h.content}`).join("\n") : "Nothing found in memory.";
+        }
+      };
+      for (let round = 0; round <= MAX_TOOL_ROUNDS; round++) {
+        const request = {
+          model: this.modelFor(agent2),
+          messages,
+          signal: input.signal,
+          onToken: (delta) => this.emitEvent({ type: "token", agentId: agent2.id, conversationId: conv.id, replyId, delta })
+        };
+        let res = await this.provider.chat({ ...request, tools: round < MAX_TOOL_ROUNDS ? tools : void 0 });
+        if (!res.content.trim() && !res.toolCalls.length) res = await this.provider.chat(request);
+        answer += res.content;
+        if (!res.toolCalls.length) break;
+        messages.push({ role: "assistant", content: res.content, toolCalls: res.toolCalls });
+        this.setStatus(agent2.id, "working", res.toolCalls.map((c) => c.name).join(", "));
+        for (const call of res.toolCalls) {
+          const tool = tools.find((t) => t.name === call.name);
+          this.emitEvent({ type: "tool", agentId: agent2.id, conversationId: conv.id, replyId, name: call.name, args: call.arguments });
+          let result;
+          try {
+            result = tool ? await tool.run(call.arguments, ctx) : `Unknown tool: ${call.name}`;
+          } catch (err) {
+            result = `Error: ${err.message}`;
+          }
+          toolLog.push({ name: call.name, args: call.arguments, result: result.slice(0, 2e3) });
+          this.emitEvent({
+            type: "tool",
+            agentId: agent2.id,
+            conversationId: conv.id,
+            replyId,
+            name: call.name,
+            args: call.arguments,
+            result: result.slice(0, 2e3)
+          });
+          messages.push({ role: "tool", content: result, toolCallId: call.id, name: call.name });
+        }
+        this.setStatus(agent2.id, "thinking");
+      }
+    } catch (err) {
+      this.setStatus(agent2.id, "idle");
+      throw err;
+    }
+    const reply = this.store.addMessage(conv.id, "assistant", answer.trim() || "\u2026", {
+      replyId,
+      model: this.modelFor(agent2),
+      ...toolLog.length ? { tools: toolLog } : {}
+    });
+    this.emitEvent({ type: "message", agentId: agent2.id, conversationId: conv.id, message: reply });
+    this.setStatus(agent2.id, "idle");
+    this.store.enqueue("memory.extract", {
+      agentId: agent2.id,
+      user: input.text,
+      assistant: reply.content
+    });
+    return reply;
+  }
+  // ── background jobs ──────────────────────────────────────────────────
+  async extractMemories(p) {
+    const agent2 = this.store.getAgent(p.agentId);
+    if (!agent2 || p.user.trim().length < 12) return;
+    this.setStatus(agent2.id, "remembering");
+    try {
+      const known = await this.recall(agent2.id, p.user, 8);
+      const res = await this.provider.chat({
+        model: this.modelFor(agent2),
+        json: true,
+        temperature: 0,
+        messages: [
+          { role: "system", content: EXTRACT_PROMPT },
+          {
+            role: "user",
+            content: (known.length ? `Already known:
+${known.map((k) => `- ${k.content}`).join("\n")}
+
+` : "") + `User: ${p.user}
+
+Assistant: ${p.assistant}`
+          }
+        ]
+      });
+      const parsed = safeParse(res.content);
+      for (const m of parsed.slice(0, 5)) {
+        if (typeof m.content !== "string" || m.content.length < 6) continue;
+        await this.remember(agent2.id, m.content, asType(m.type), clamp(Number(m.importance) || 0.5), "auto");
+      }
+    } finally {
+      if (this.status(agent2.id) === "remembering") this.setStatus(agent2.id, "idle");
+    }
+  }
+  async backfillEmbeddings() {
+    for (const m of this.store.memoriesWithoutEmbedding(100)) {
+      const vec = await this.embed(m.content);
+      if (!vec) return;
+      this.store.setMemoryEmbedding(m.id, vec);
+    }
+  }
+  start() {
+    this.worker.start();
+    this.store.enqueue("memory.embed", {});
+  }
+  async stop() {
+    await this.worker.stop();
+  }
+};
+function makeProvider(config2) {
+  return config2.provider === "openai" ? new OpenAIProvider(config2.openaiBaseUrl, config2.openaiApiKey) : new OllamaProvider(config2.ollamaHost);
+}
+function asType(t) {
+  return t === "decision" || t === "preference" || t === "conversation" ? t : "fact";
+}
+function clamp(n) {
+  return Math.min(1, Math.max(0, n));
+}
+function normalize(s) {
+  return s.toLowerCase().replace(/[^\p{L}\p{N}]+/gu, " ").trim();
+}
+function safeParse(s) {
+  try {
+    const data = JSON.parse(s);
+    const list = Array.isArray(data) ? data : data?.memories;
+    return Array.isArray(list) ? list : [];
+  } catch {
+    return [];
+  }
+}
+
+// ../packages/core/src/templates.ts
+var templates = {
+  backend: {
+    name: "Artem",
+    role: "Senior backend engineer",
+    avatar: "\u{1F6E0}\uFE0F",
+    personality: "Calm, pragmatic, a bit of a perfectionist. Likes simple solutions, Postgres and boring technology.",
+    systemPrompt: "Help with APIs, databases, architecture and code reviews. Prefer concrete code over theory."
+  },
+  frontend: {
+    name: "Lena",
+    role: "Frontend developer & designer",
+    avatar: "\u{1F3A8}",
+    personality: "Energetic and visual. Cares about details, accessibility and nice animations.",
+    systemPrompt: "Help with React, CSS and UX. Suggest improvements to interfaces and copy."
+  },
+  pm: {
+    name: "Max",
+    role: "Product manager",
+    avatar: "\u{1F4CB}",
+    personality: "Structured, asks the right questions, keeps everyone focused on what matters this week.",
+    systemPrompt: "Help plan work, write specs and break big goals into small tasks. Track decisions."
+  },
+  writer: {
+    name: "Sofia",
+    role: "Writer & editor",
+    avatar: "\u270D\uFE0F",
+    personality: "Warm, witty, and precise with words.",
+    systemPrompt: "Help write and edit texts: posts, docs, emails. Keep the author's voice."
+  },
+  coach: {
+    name: "Oleg",
+    role: "Personal coach",
+    avatar: "\u{1F9ED}",
+    personality: "Supportive but honest. Remembers your goals and gently reminds you about them.",
+    systemPrompt: "Help the user reflect, set goals and keep habits. Ask one good question at a time."
+  }
+};
+
+// ../apps/server/src/index.ts
+import { serve } from "@hono/node-server";
+
+// ../packages/channels/src/telegram/index.ts
+import { randomInt } from "node:crypto";
+import { Bot } from "grammy";
+var PAIRED = "telegram.paired";
+var ACTIVE = "telegram.active";
+var TelegramChannel = class {
+  constructor(crew, opts) {
+    this.crew = crew;
+    this.log = opts.log ?? ((m) => console.log(m));
+    this.bot = new Bot(opts.token);
+    this.setup();
+  }
+  crew;
+  bot;
+  pairingCode = String(randomInt(1e5, 999999));
+  log;
+  paired() {
+    return this.crew.store.getSetting(PAIRED) ?? [];
+  }
+  activeAgent(chatId) {
+    const map = this.crew.store.getSetting(ACTIVE) ?? {};
+    const id2 = map[chatId];
+    if (id2 && this.crew.store.getAgent(id2)) return id2;
+    return this.crew.store.listAgents()[0]?.id ?? null;
+  }
+  setActive(chatId, agentId) {
+    const map = this.crew.store.getSetting(ACTIVE) ?? {};
+    map[chatId] = agentId;
+    this.crew.store.setSetting(ACTIVE, map);
+  }
+  setup() {
+    const bot = this.bot;
+    bot.command(
+      "start",
+      (ctx) => ctx.reply(
+        this.paired().includes(ctx.chat.id) ? "\u{1F44B} Crew is here. /agents \u2014 list colleagues, /use <name> \u2014 switch, /memory \u2014 what I remember." : "\u{1F44B} This is a private Crew workspace. Send /pair <code> with the code shown in your terminal."
+      )
+    );
+    bot.command("pair", async (ctx) => {
+      if (ctx.match.trim() !== this.pairingCode) return ctx.reply("\u274C Wrong code.");
+      this.crew.store.setSetting(PAIRED, [.../* @__PURE__ */ new Set([...this.paired(), ctx.chat.id])]);
+      this.log(`telegram: paired chat ${ctx.chat.id}`);
+      return ctx.reply("\u2705 Paired! Say hi to your crew. /agents to see who's here.");
+    });
+    bot.use(async (ctx, next) => {
+      if (ctx.chat && this.paired().includes(ctx.chat.id)) return next();
+      if (ctx.chat) await ctx.reply("\u{1F512} Not paired. Send /pair <code>.");
+    });
+    bot.command("agents", (ctx) => {
+      const active = this.activeAgent(ctx.chat.id);
+      const list = this.crew.store.listAgents();
+      if (!list.length) return ctx.reply("No agents yet \u2014 create one in the web UI or with `crew agent create`.");
+      return ctx.reply(
+        list.map((a) => `${a.id === active ? "\u25B6\uFE0F" : "  "} ${a.avatar} *${a.name}* \u2014 ${a.role || "colleague"}`).join("\n"),
+        { parse_mode: "Markdown" }
+      );
+    });
+    bot.command("use", (ctx) => {
+      const agent2 = this.crew.store.getAgent(ctx.match.trim());
+      if (!agent2) return ctx.reply("Unknown agent. /agents to list.");
+      this.setActive(ctx.chat.id, agent2.id);
+      return ctx.reply(`${agent2.avatar} Now talking to ${agent2.name}.`);
+    });
+    bot.command("memory", (ctx) => {
+      const id2 = this.activeAgent(ctx.chat.id);
+      if (!id2) return ctx.reply("No agents yet.");
+      const mems = this.crew.store.listMemories(id2, 15);
+      return ctx.reply(mems.length ? mems.map((m) => `\u2022 ${m.content}`).join("\n") : "Nothing remembered yet.");
+    });
+    bot.command("forget", (ctx) => {
+      const id2 = this.activeAgent(ctx.chat.id);
+      if (!id2) return;
+      this.crew.store.clearConversation(this.crew.store.conversation(id2, "telegram", String(ctx.chat.id)).id);
+      return ctx.reply("\u{1F9F9} Chat history cleared (long-term memory kept).");
+    });
+    bot.on("message:text", (ctx) => this.onText(ctx, ctx.message.text));
+    bot.catch((err) => this.log(`telegram: ${err.message}`));
+  }
+  async onText(ctx, text) {
+    const chatId = ctx.chat.id;
+    const agentId = this.activeAgent(chatId);
+    if (!agentId) return ctx.reply("No agents yet \u2014 create one first.");
+    let target = agentId;
+    const mention = text.match(/^@?([\p{L}\d_-]+)[,:]\s+/u);
+    const named = mention && this.crew.store.getAgent(mention[1]);
+    if (named) {
+      target = named.id;
+      text = text.slice(mention[0].length);
+    }
+    const typing = setInterval(() => ctx.replyWithChatAction("typing").catch(() => {
+    }), 4e3);
+    await ctx.replyWithChatAction("typing").catch(() => {
+    });
+    try {
+      const reply = await this.crew.chat({ agent: target, text, channel: "telegram", channelRef: String(chatId) });
+      const agent2 = this.crew.store.getAgent(target);
+      const body = named ? `${agent2.avatar} ${agent2.name}:
+${reply.content}` : reply.content;
+      for (const part of chunk(body, 4e3)) {
+        await ctx.reply(part, { parse_mode: "Markdown" }).catch(() => ctx.reply(part));
+      }
+    } catch (err) {
+      await ctx.reply(`\u26A0\uFE0F ${err.message}`);
+    } finally {
+      clearInterval(typing);
+    }
+  }
+  async start() {
+    const me = await this.bot.api.getMe();
+    this.log(`telegram: @${me.username} is online \u2014 pairing code ${this.pairingCode}`);
+    void this.bot.start({ drop_pending_updates: true });
+    return me;
+  }
+  async stop() {
+    await this.bot.stop();
+  }
+};
+function chunk(s, size) {
+  const out = [];
+  for (let i = 0; i < s.length; i += size) out.push(s.slice(i, i + size));
+  return out;
+}
+
+// ../apps/server/src/app.ts
+import { existsSync, readFileSync } from "node:fs";
+import { join as join3 } from "node:path";
+import { stat as stat2 } from "node:fs/promises";
+import { Hono } from "hono";
+import { HTTPException } from "hono/http-exception";
+import { serveStatic } from "@hono/node-server/serve-static";
+import { createNodeWebSocket } from "@hono/node-ws";
+
+// ../apps/server/src/version.ts
+var VERSION = "0.1.0";
+
+// ../apps/server/src/app.ts
+var SECRET_KEYS = /* @__PURE__ */ new Set(["openaiApiKey", "telegramToken"]);
+function createApp(crew, opts = {}) {
+  const app = new Hono();
+  const { injectWebSocket, upgradeWebSocket } = createNodeWebSocket({ app });
+  const sockets = /* @__PURE__ */ new Set();
+  const broadcast = (e) => {
+    const data = JSON.stringify(e);
+    for (const ws of sockets) ws.send(data);
+  };
+  crew.on("event", broadcast);
+  const agentOr404 = (id2) => {
+    const agent2 = crew.store.getAgent(id2);
+    if (!agent2) throw new HTTPException(404, { message: "Agent not found" });
+    return agent2;
+  };
+  const withStats = (a) => ({
+    ...a,
+    status: crew.status(a.id),
+    memoryCount: crew.store.countMemories(a.id),
+    effectiveModel: crew.modelFor(a)
+  });
+  app.onError((err, c) => {
+    if (err instanceof HTTPException) return c.json({ error: err.message }, err.status);
+    console.error(err);
+    return c.json({ error: err.message }, 500);
+  });
+  const api = new Hono();
+  api.get("/health", (c) => c.json({ ok: true, version: VERSION }));
+  api.get("/status", async (c) => {
+    const online = await crew.provider.ping();
+    const models = online ? await crew.provider.models().catch(() => []) : [];
+    return c.json({
+      version: VERSION,
+      provider: crew.config.provider,
+      online,
+      model: crew.config.model,
+      embedModel: crew.config.embedModel,
+      modelInstalled: models.some((m) => m.name === crew.config.model || m.name === `${crew.config.model}:latest`),
+      models,
+      telegram: Boolean(crew.config.telegramToken)
+    });
+  });
+  api.get("/settings", (c) => {
+    const cfg = crew.config;
+    const out = {};
+    for (const k of SETTING_KEYS) {
+      const v = cfg[k];
+      out[k] = SECRET_KEYS.has(k) ? v ? "\u2022\u2022\u2022\u2022\u2022\u2022" : "" : v;
+    }
+    return c.json(out);
+  });
+  api.put("/settings", async (c) => {
+    const body = await c.req.json();
+    for (const k of SETTING_KEYS) {
+      if (!(k in body)) continue;
+      if (SECRET_KEYS.has(k) && body[k] === "\u2022\u2022\u2022\u2022\u2022\u2022") continue;
+      crew.store.setSetting(k, String(body[k] ?? ""));
+    }
+    crew.reload();
+    return c.json({ ok: true });
+  });
+  api.get("/templates", (c) => c.json(templates));
+  api.get("/agents", (c) => c.json(crew.store.listAgents().map(withStats)));
+  api.post("/agents", async (c) => {
+    const body = await c.req.json();
+    if (!body?.name?.trim()) throw new HTTPException(400, { message: "Name is required" });
+    if (crew.store.getAgent(body.name)) throw new HTTPException(409, { message: "An agent with this name already exists" });
+    const agent2 = crew.store.createAgent(body);
+    crew.emitEvent({ type: "agents" });
+    return c.json(withStats(agent2), 201);
+  });
+  api.post("/agents/import", async (c) => {
+    const body = await c.req.json();
+    const name = crew.store.getAgent(body.agent?.name) ? `${body.agent.name} (2)` : body.agent?.name;
+    if (!name) throw new HTTPException(400, { message: "Not a Crew export" });
+    const agent2 = crew.store.createAgent({ ...body.agent, name });
+    for (const m of body.memories ?? []) {
+      await crew.remember(agent2.id, m.content, m.type, m.importance, "import");
+    }
+    crew.emitEvent({ type: "agents" });
+    return c.json(withStats(agent2), 201);
+  });
+  api.get("/agents/:id", (c) => c.json(withStats(agentOr404(c.req.param("id")))));
+  api.patch("/agents/:id", async (c) => {
+    const agent2 = agentOr404(c.req.param("id"));
+    const updated = crew.store.updateAgent(agent2.id, await c.req.json());
+    crew.emitEvent({ type: "agents" });
+    return c.json(withStats(updated));
+  });
+  api.delete("/agents/:id", (c) => {
+    const agent2 = agentOr404(c.req.param("id"));
+    crew.store.deleteAgent(agent2.id);
+    crew.emitEvent({ type: "agents" });
+    return c.json({ ok: true });
+  });
+  api.get("/agents/:id/export", (c) => {
+    const agent2 = agentOr404(c.req.param("id"));
+    const { name, role, personality, systemPrompt, model, avatar, color } = agent2;
+    return c.json({
+      crew: 1,
+      agent: { name, role, personality, systemPrompt, model, avatar, color },
+      memories: crew.store.listMemories(agent2.id, 1e4).map(({ content, type, importance }) => ({ content, type, importance }))
+    });
+  });
+  api.get("/agents/:id/messages", (c) => {
+    const agent2 = agentOr404(c.req.param("id"));
+    const conv = crew.store.conversation(agent2.id, c.req.query("channel") ?? "web", c.req.query("ref") ?? "default");
+    return c.json({ conversationId: conv.id, messages: crew.store.messages(conv.id, Number(c.req.query("limit") ?? 100)) });
+  });
+  api.get("/agents/:id/conversations", (c) => c.json(crew.store.listConversations(agentOr404(c.req.param("id")).id)));
+  api.delete("/agents/:id/messages", (c) => {
+    const agent2 = agentOr404(c.req.param("id"));
+    crew.store.clearConversation(crew.store.conversation(agent2.id, "web").id);
+    return c.json({ ok: true });
+  });
+  api.post("/agents/:id/chat", async (c) => {
+    const agent2 = agentOr404(c.req.param("id"));
+    const { text, channel, ref } = await c.req.json();
+    if (!text?.trim()) throw new HTTPException(400, { message: "text is required" });
+    const reply = await crew.chat({ agent: agent2.id, text, channel: channel ?? "api", channelRef: ref ?? "default" });
+    return c.json(reply);
+  });
+  api.get("/agents/:id/memories", async (c) => {
+    const agent2 = agentOr404(c.req.param("id"));
+    const q = c.req.query("q");
+    return c.json(q ? await crew.recall(agent2.id, q, 20) : crew.store.listMemories(agent2.id));
+  });
+  api.post("/agents/:id/memories", async (c) => {
+    const agent2 = agentOr404(c.req.param("id"));
+    const { content, type, importance } = await c.req.json();
+    if (!content?.trim()) throw new HTTPException(400, { message: "content is required" });
+    return c.json(await crew.remember(agent2.id, content, type ?? "fact", importance ?? 0.7, "manual"), 201);
+  });
+  api.delete("/memories/:id", (c) => {
+    crew.store.deleteMemory(c.req.param("id"));
+    return c.json({ ok: true });
+  });
+  api.get("/agents/:id/folders", (c) => c.json(crew.store.listFolders(agentOr404(c.req.param("id")).id)));
+  api.post("/agents/:id/folders", async (c) => {
+    const agent2 = agentOr404(c.req.param("id"));
+    const { path, mode } = await c.req.json();
+    const info = await stat2(path).catch(() => null);
+    if (!info?.isDirectory()) throw new HTTPException(400, { message: `Not a directory: ${path}` });
+    return c.json(crew.store.grantFolder(agent2.id, path, mode === "rw" ? "rw" : "ro"), 201);
+  });
+  api.delete("/folders/:id", (c) => {
+    crew.store.revokeFolder(c.req.param("id"));
+    return c.json({ ok: true });
+  });
+  api.get("/tasks", (c) => c.json(crew.store.listTasks()));
+  app.route("/api", api);
+  app.get(
+    "/ws",
+    upgradeWebSocket(() => ({
+      onOpen(_e, ws) {
+        sockets.add(ws);
+      },
+      onClose(_e, ws) {
+        sockets.delete(ws);
+      },
+      async onMessage(e, ws) {
+        let msg;
+        try {
+          msg = JSON.parse(String(e.data));
+        } catch {
+          return;
+        }
+        if (msg.type === "chat" && msg.agentId && msg.text?.trim()) {
+          crew.chat({ agent: msg.agentId, text: msg.text, channel: "web" }).catch(
+            (err) => ws.send(JSON.stringify({ type: "error", agentId: msg.agentId, message: err.message }))
+          );
+        }
+      }
+    }))
+  );
+  const webDir2 = opts.webDir;
+  if (webDir2 && existsSync(join3(webDir2, "index.html"))) {
+    const index = readFileSync(join3(webDir2, "index.html"), "utf8");
+    app.use("/*", serveStatic({ root: webDir2 }));
+    app.get("*", (c) => c.html(index));
+  } else {
+    app.get(
+      "/",
+      (c) => c.text("Crew API is running. Start the web UI with `pnpm dev` or build it with `pnpm build`.")
+    );
+  }
+  return { app, injectWebSocket };
+}
+
+// ../apps/server/src/index.ts
+async function startServer(opts = {}) {
+  const log = opts.log ?? ((m) => console.log(m));
+  const env = envConfig();
+  const crew = Crew.open(opts.dbFile ?? env.dbFile);
+  crew.start();
+  const { app, injectWebSocket } = createApp(crew, { webDir: opts.webDir });
+  const port = opts.port ?? env.port;
+  const host = opts.host ?? process.env.CREW_HOST ?? "127.0.0.1";
+  const server = await new Promise((resolve4, reject) => {
+    const s = serve({ fetch: app.fetch, port, hostname: host }, () => resolve4(s));
+    s.once("error", reject);
+  });
+  injectWebSocket(server);
+  let telegram = null;
+  if (opts.telegram !== false && crew.config.telegramToken) {
+    telegram = new TelegramChannel(crew, { token: crew.config.telegramToken, log });
+    await telegram.start().catch((err) => {
+      log(`telegram: failed to start \u2014 ${err.message}`);
+      telegram = null;
+    });
+  }
+  const shownHost = host === "0.0.0.0" || host === "127.0.0.1" ? "localhost" : host;
+  return {
+    crew,
+    server,
+    url: `http://${shownHost}:${port}`,
+    telegram,
+    async close() {
+      await telegram?.stop();
+      await crew.stop();
+      await new Promise((r) => server.close(r));
+      crew.store.close();
+    }
+  };
+}
+
+// src/commands/start.ts
+import open from "open";
+
+// src/ui.ts
+import pc from "picocolors";
+var logo = () => [
+  pc.magenta("   \u25CF  \u25CF   ") + pc.bold("crew"),
+  pc.cyan("    \u25CF     ") + pc.dim("your AI colleagues, at home")
+].join("\n");
+var ok = (msg) => console.log(`${pc.green("\u2714")} ${msg}`);
+var warn = (msg) => console.log(`${pc.yellow("!")} ${msg}`);
+var fail = (msg) => console.error(`${pc.red("\u2716")} ${msg}`);
+var dim = pc.dim;
+var bold = pc.bold;
+var cyan = pc.cyan;
+var magenta = pc.magenta;
+
+// src/web-dir.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { fileURLToPath } from "node:url";
+function webDir() {
+  const candidates = [
+    new URL("./web", import.meta.url),
+    new URL("../../apps/web/dist", import.meta.url)
+  ].map((u) => fileURLToPath(u));
+  return candidates.find((p) => existsSync2(`${p}/index.html`));
+}
+
+// src/commands/start.ts
+async function start(flags) {
+  console.log(`
+${logo()}
+`);
+  const running = await startServer({
+    port: flags.port ? Number(flags.port) : void 0,
+    host: flags.host,
+    webDir: webDir(),
+    telegram: flags.telegram,
+    log: (m) => console.log(dim(`  ${m}`))
+  });
+  const { crew } = running;
+  const online = await crew.provider.ping();
+  const agents = crew.store.listAgents();
+  ok(`Crew is running at ${bold(cyan(running.url))}`);
+  console.log(dim(`  data      ${crew.store.file}`));
+  console.log(dim(`  provider  ${crew.config.provider} \xB7 ${crew.config.model}`));
+  console.log(dim(`  agents    ${agents.length ? agents.map((a) => a.name).join(", ") : "none yet"}`));
+  if (!online) warn(`Model provider is offline. Start Ollama: ${bold("ollama serve")}`);
+  if (running.telegram) ok(`Telegram bot online \u2014 send ${bold(`/pair ${running.telegram.pairingCode}`)} to it`);
+  console.log();
+  if (flags.open) open(running.url).catch(() => {
+  });
+  const shutdown = async () => {
+    console.log(dim("\n  shutting down\u2026"));
+    await running.close();
+    process.exit(0);
+  };
+  process.once("SIGINT", shutdown);
+  process.once("SIGTERM", shutdown);
+}
+
+// src/commands/agent.ts
+import { resolve as resolve3 } from "node:path";
+import { readFileSync as readFileSync2, writeFileSync } from "node:fs";
+function withCrew(fn) {
+  return async () => {
+    const crew = Crew.open();
+    try {
+      return await fn(crew);
+    } finally {
+      await crew.stop();
+      crew.store.close();
+    }
+  };
+}
+var agentCreate = (name, f) => withCrew((crew) => {
+  const base = f.template ? templates[f.template] : void 0;
+  if (f.template && !base) {
+    fail(`Unknown template "${f.template}". Available: ${Object.keys(templates).join(", ")}`);
+    process.exitCode = 1;
+    return;
+  }
+  if (crew.store.getAgent(name)) {
+    fail(`Agent "${name}" already exists`);
+    process.exitCode = 1;
+    return;
+  }
+  const agent2 = crew.store.createAgent({
+    ...base,
+    name,
+    role: f.role ?? base?.role,
+    personality: f.persona ?? base?.personality,
+    systemPrompt: f.prompt ?? base?.systemPrompt,
+    model: f.model ?? null,
+    avatar: f.avatar ?? base?.avatar
+  });
+  for (const folder of f.folder ?? []) crew.store.grantFolder(agent2.id, resolve3(folder), f.rw ? "rw" : "ro");
+  ok(`${agent2.avatar} ${bold(agent2.name)} joined the crew${agent2.role ? dim(` \u2014 ${agent2.role}`) : ""}`);
+})();
+var agentList = () => withCrew((crew) => {
+  const agents = crew.store.listAgents();
+  if (!agents.length) return console.log(dim("No agents yet. Try: crew agent create Artem --template backend"));
+  for (const a of agents) {
+    const mem = crew.store.countMemories(a.id);
+    console.log(`${a.avatar}  ${bold(a.name.padEnd(14))} ${(a.role || "\u2014").padEnd(32)} ${dim(`${mem} memories \xB7 ${crew.modelFor(a)}`)}`);
+  }
+})();
+var agentRemove = (name) => withCrew((crew) => {
+  const a = crew.requireAgent(name);
+  crew.store.deleteAgent(a.id);
+  ok(`Removed ${a.name}`);
+})();
+var agentGrant = (name, folder, f) => withCrew((crew) => {
+  const a = crew.requireAgent(name);
+  const g = crew.store.grantFolder(a.id, resolve3(folder), f.rw ? "rw" : "ro");
+  ok(`${a.name} can now ${g.mode === "rw" ? "read and write" : "read"} ${g.path}`);
+})();
+var agentExport = (name, f) => withCrew((crew) => {
+  const a = crew.requireAgent(name);
+  const dump = {
+    crew: 1,
+    agent: { name: a.name, role: a.role, personality: a.personality, systemPrompt: a.systemPrompt, model: a.model, avatar: a.avatar, color: a.color },
+    memories: crew.store.listMemories(a.id, 1e4).map(({ content, type, importance }) => ({ content, type, importance }))
+  };
+  const out = f.out ?? `${a.name}.crew.json`;
+  writeFileSync(out, JSON.stringify(dump, null, 2));
+  ok(`Exported ${a.name} with ${dump.memories.length} memories \u2192 ${out}`);
+})();
+var agentImport = (file) => withCrew(async (crew) => {
+  const dump = JSON.parse(readFileSync2(file, "utf8"));
+  const name = crew.store.getAgent(dump.agent.name) ? `${dump.agent.name} (2)` : dump.agent.name;
+  const a = crew.store.createAgent({ ...dump.agent, name });
+  for (const m of dump.memories ?? []) await crew.remember(a.id, m.content, m.type, m.importance, "import");
+  ok(`Imported ${a.avatar} ${bold(a.name)} with ${dump.memories?.length ?? 0} memories`);
+})();
+
+// src/commands/chat.ts
+import { createInterface } from "node:readline/promises";
+import { stdin, stdout } from "node:process";
+async function chat(name, f) {
+  const crew = Crew.open();
+  crew.start();
+  const agent2 = crew.store.getAgent(name);
+  if (!agent2) {
+    fail(`No agent named "${name}". Create one: crew agent create ${name}`);
+    process.exit(1);
+  }
+  crew.on("event", (e) => {
+    if (!("agentId" in e) || e.agentId !== agent2.id) return;
+    if (e.type === "token") stdout.write(e.delta);
+    if (e.type === "tool" && e.result === void 0) stdout.write(dim(`
+  \u21B3 ${e.name} ${JSON.stringify(e.args).slice(0, 80)}
+`));
+  });
+  const ask = async (text) => {
+    stdout.write(`
+${agent2.avatar} ${bold(magenta(agent2.name))}  `);
+    try {
+      await crew.chat({ agent: agent2.id, text, channel: "cli" });
+    } catch (err) {
+      fail(err.message);
+    }
+    stdout.write("\n");
+  };
+  if (f.message) {
+    await ask(f.message);
+  } else {
+    console.log(dim(`Chatting with ${agent2.name}. /memory \u2014 show memories, /exit \u2014 quit.
+`));
+    const rl = createInterface({ input: stdin, output: stdout });
+    for (; ; ) {
+      const text = (await rl.question(cyan("\nyou \u203A "))).trim();
+      if (!text) continue;
+      if (text === "/exit" || text === "/quit") break;
+      if (text === "/memory") {
+        for (const m of crew.store.listMemories(agent2.id, 20)) console.log(dim(`  \u2022 [${m.type}] ${m.content}`));
+        continue;
+      }
+      await ask(text);
+    }
+    rl.close();
+  }
+  await crew.worker.drain();
+  await crew.stop();
+  crew.store.close();
+}
+
+// src/commands/memory.ts
+var memoryList = (name, f) => withCrew(async (crew) => {
+  const a = crew.requireAgent(name);
+  const list = f.search ? await crew.recall(a.id, f.search, Number(f.limit ?? 20)) : crew.store.listMemories(a.id, Number(f.limit ?? 50));
+  if (!list.length) return console.log(dim(`${a.name} doesn't remember anything yet.`));
+  console.log(bold(`${a.avatar} ${a.name} remembers:
+`));
+  for (const m of list) console.log(`  \u2022 ${m.content} ${dim(`[${m.type} \xB7 ${m.importance.toFixed(1)}]`)}`);
+})();
+var memoryAdd = (name, text, f) => withCrew(async (crew) => {
+  const a = crew.requireAgent(name);
+  await crew.remember(a.id, text, f.type ?? "fact", 0.8, "cli");
+  ok(`${a.name} will remember that.`);
+})();
+
+// src/commands/doctor.ts
+var doctor = () => withCrew(async (crew) => {
+  const [major, minor] = process.versions.node.split(".").map(Number);
+  if (major > 22 || major === 22 && minor >= 13) ok(`Node.js ${process.versions.node}`);
+  else fail(`Node.js ${process.versions.node} \u2014 Crew needs 22.13+ (for built-in SQLite)`);
+  ok(`Database ${dim(crew.store.file)}`);
+  const { provider, model, embedModel, ollamaHost, openaiBaseUrl } = crew.config;
+  const url = provider === "ollama" ? ollamaHost : openaiBaseUrl;
+  if (!await crew.provider.ping()) {
+    fail(`${provider} is not reachable at ${url}`);
+    if (provider === "ollama") console.log(dim("    install: https://ollama.com  \xB7  then run: ollama serve"));
+    return;
+  }
+  ok(`${provider} is reachable at ${url}`);
+  const models = (await crew.provider.models()).map((m) => m.name);
+  const has = (m) => models.includes(m) || models.includes(`${m}:latest`);
+  if (has(model)) ok(`Chat model ${bold(model)}`);
+  else warn(`Chat model ${bold(model)} is missing \u2014 ${provider === "ollama" ? `ollama pull ${model}` : "check the model name"}`);
+  if (has(embedModel)) ok(`Embedding model ${bold(embedModel)}`);
+  else warn(`Embedding model ${bold(embedModel)} is missing \u2014 memory falls back to keyword search (ollama pull ${embedModel})`);
+  if (crew.config.telegramToken) ok("Telegram token configured");
+  else console.log(dim("  \xB7 Telegram not configured (crew config set telegramToken <token>)"));
+})();
+
+// src/commands/config.ts
+var SECRET = /* @__PURE__ */ new Set(["openaiApiKey", "telegramToken"]);
+var configList = () => withCrew((crew) => {
+  for (const k of SETTING_KEYS) {
+    const v = crew.config[k];
+    console.log(`${k.padEnd(16)} ${SECRET.has(k) ? v ? "\u2022\u2022\u2022\u2022\u2022\u2022" : dim("\u2014") : v || dim("\u2014")}`);
+  }
+})();
+var configSet = (key, value) => withCrew((crew) => {
+  if (!SETTING_KEYS.includes(key)) {
+    fail(`Unknown key. One of: ${SETTING_KEYS.join(", ")}`);
+    process.exitCode = 1;
+    return;
+  }
+  crew.store.setSetting(key, value);
+  ok(`${key} saved`);
+})();
+
+// src/index.ts
+var program = new Command().name("crew").description("A lightweight local-first workspace for your persistent AI colleagues").version(VERSION);
+program.command("start", { isDefault: true }).description("start the Crew server and web UI").option("-p, --port <port>", "port to listen on (default 3000)").option("--host <host>", "interface to bind (default 127.0.0.1)").option("-o, --open", "open the browser").option("--no-telegram", "don't start the Telegram bot").action(start);
+program.command("dev").description("start Crew and open it in the browser").option("-p, --port <port>", "port to listen on").action((f) => start({ ...f, open: true }));
+var agent = program.command("agent").description("manage your colleagues");
+agent.command("create <name>").description("create a new agent").option("-r, --role <role>", "role, e.g. 'backend engineer'").option("--persona <text>", "personality / character").option("--prompt <text>", "extra instructions").option("-m, --model <model>", "model for this agent (default: global)").option("-a, --avatar <emoji>", "avatar emoji").option("-t, --template <name>", `start from a template: ${Object.keys(templates).join(", ")}`).option("-f, --folder <path...>", "share folder(s) with the agent").option("--rw", "give write access to shared folders").action(agentCreate);
+agent.command("list").alias("ls").description("list agents").action(agentList);
+agent.command("rm <name>").description("delete an agent and its memory").action(agentRemove);
+agent.command("grant <name> <folder>").description("share a folder with an agent").option("--rw", "allow writing").action(agentGrant);
+agent.command("export <name>").option("-o, --out <file>").description("export agent + memories to JSON").action(agentExport);
+agent.command("import <file>").description("import an agent from JSON").action(agentImport);
+program.command("chat <agent>").description("chat with an agent in the terminal").option("-m, --message <text>", "send one message and exit").action(chat);
+var memory = program.command("memory").description("inspect long-term memory");
+memory.command("list <agent>", { isDefault: true }).option("-s, --search <query>", "semantic search").option("-n, --limit <n>").action(memoryList);
+memory.command("add <agent> <text>").option("-t, --type <type>", "fact | decision | preference").action(memoryAdd);
+var config = program.command("config").description("view or change settings");
+config.command("list", { isDefault: true }).action(configList);
+config.command("set <key> <value>").action(configSet);
+program.command("doctor").description("check your setup").action(doctor);
+program.parseAsync().catch((err) => {
+  fail(err.message);
+  process.exit(1);
+});