@kl-c/matrixos 0.2.1 → 0.2.6

package/dist/cli-node/index.js

@@ -2163,7 +2163,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@kl-c/matrixos",
-    version: "0.2.1",
+    version: "0.2.6",
     description: "MaTrixOS \u2014 Agentic OS for OpenCode. Personalizable, communicating, self-improving, resilient.",
     main: "./dist/index.js",
     types: "dist/index.d.ts",
@@ -90408,11 +90408,22 @@ class TelegramAdapter {
       }
       const text = envelope.content.text ?? "";
       const result = await this.bot.api.sendMessage(chatId, text);
-      return String(result.message_id);
+      const messageId = String(result.message_id);
+      if (envelope.metadata?.onMessageId && typeof envelope.metadata.onMessageId === "function") {
+        envelope.metadata.onMessageId(messageId);
+      }
+      return messageId;
     } catch (err) {
       throw new TelegramSendError(`Failed to send Telegram message: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
     }
   }
+  async editMessage(recipientId, messageId, text) {
+    try {
+      await this.bot.api.editMessageText(recipientId, Number(messageId), text);
+    } catch (err) {
+      console.warn(`[telegram] editMessage failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
   onMessage(handler) {
     this.messageHandler = handler;
   }
@@ -164473,6 +164484,351 @@ var require_picomatch2 = __commonJS((exports2, module2) => {
   module2.exports = picomatch;
 });
 
+// packages/omo-opencode/src/features/cron/store.ts
+function createCronStore() {
+  const jobs = new Map;
+  let counter = 0;
+  return {
+    add(input) {
+      counter += 1;
+      const now = new Date().toISOString();
+      const job = {
+        id: `cron-${counter}`,
+        name: input.name,
+        schedule: input.schedule,
+        command: input.command,
+        channel: input.channel,
+        recipient: input.recipient,
+        enabled: input.enabled ?? true,
+        createdAt: now,
+        updatedAt: now
+      };
+      CronJobSchema.parse(job);
+      jobs.set(job.id, job);
+      return job;
+    },
+    get(id) {
+      return jobs.get(id);
+    },
+    list(filter) {
+      const all = Array.from(jobs.values());
+      return all.filter((j) => {
+        if (filter?.enabled !== undefined && j.enabled !== filter.enabled)
+          return false;
+        if (filter?.channel && j.channel !== filter.channel)
+          return false;
+        return true;
+      });
+    },
+    remove(id) {
+      return jobs.delete(id);
+    },
+    size() {
+      return jobs.size;
+    }
+  };
+}
+var CronJobSchema;
+var init_store = __esm(() => {
+  init_zod();
+  CronJobSchema = object({
+    id: string2().min(1),
+    name: string2().min(1).max(100),
+    schedule: string2().min(1).max(100),
+    command: string2().min(1),
+    channel: _enum2(["telegram", "discord", "whatsapp"]).optional(),
+    recipient: string2().optional(),
+    enabled: boolean2().default(true),
+    createdAt: string2(),
+    updatedAt: string2()
+  }).strict();
+});
+
+// packages/task-ledger-core/src/schema.ts
+var TaskSourceSchema, TaskStatusSchema, TaskPrioritySchema, TaskSchema, TaskInsertSchema, TaskPatchSchema, TaskFilterSchema;
+var init_schema2 = __esm(() => {
+  init_zod();
+  TaskSourceSchema = _enum2(["webhook", "cron", "user", "kanban"]);
+  TaskStatusSchema = _enum2([
+    "pending",
+    "running",
+    "done",
+    "failed",
+    "cancelled"
+  ]);
+  TaskPrioritySchema = _enum2(["high", "medium", "low"]);
+  TaskSchema = object({
+    id: string2().min(1),
+    source: TaskSourceSchema,
+    context: string2().nullable(),
+    status: TaskStatusSchema,
+    priority: TaskPrioritySchema.nullable(),
+    payload: string2(),
+    agent_assigned: string2().nullable(),
+    session_id: string2().nullable(),
+    result: string2().nullable(),
+    cost_tokens: number2().int().nonnegative().default(0),
+    cost_usd: number2().nonnegative().default(0),
+    created_at: number2().int(),
+    started_at: number2().int().nullable(),
+    completed_at: number2().int().nullable()
+  }).strict();
+  TaskInsertSchema = object({
+    id: string2().min(1).optional(),
+    source: TaskSourceSchema,
+    context: string2().nullable().optional(),
+    status: TaskStatusSchema.optional(),
+    priority: TaskPrioritySchema.nullable().optional(),
+    payload: string2(),
+    agent_assigned: string2().nullable().optional(),
+    session_id: string2().nullable().optional(),
+    cost_tokens: number2().int().nonnegative().optional(),
+    cost_usd: number2().nonnegative().optional()
+  }).strict();
+  TaskPatchSchema = object({
+    status: TaskStatusSchema.optional(),
+    priority: TaskPrioritySchema.nullable().optional(),
+    agent_assigned: string2().nullable().optional(),
+    session_id: string2().nullable().optional(),
+    result: string2().nullable().optional(),
+    cost_tokens: number2().int().nonnegative().optional(),
+    cost_usd: number2().nonnegative().optional(),
+    started_at: number2().int().nullable().optional(),
+    completed_at: number2().int().nullable().optional()
+  }).strict();
+  TaskFilterSchema = object({
+    source: TaskSourceSchema.optional(),
+    context: string2().optional(),
+    status: TaskStatusSchema.optional(),
+    agent_assigned: string2().optional(),
+    session_id: string2().optional(),
+    priority: TaskPrioritySchema.optional()
+  }).strict();
+});
+
+// packages/task-ledger-core/src/ledger.ts
+import { randomUUID as randomUUID2 } from "crypto";
+function rowToTask(row) {
+  return {
+    id: row.id,
+    source: row.source,
+    context: row.context,
+    status: row.status,
+    priority: row.priority,
+    payload: row.payload,
+    agent_assigned: row.agent_assigned,
+    session_id: row.session_id,
+    result: row.result,
+    cost_tokens: row.cost_tokens,
+    cost_usd: row.cost_usd,
+    created_at: row.created_at,
+    started_at: row.started_at,
+    completed_at: row.completed_at
+  };
+}
+function createTaskLedger(db) {
+  db.exec(CREATE_TABLE_SQL);
+  db.exec(CREATE_INDEX_STATUS);
+  db.exec(CREATE_INDEX_CONTEXT);
+  db.exec(CREATE_INDEX_SOURCE);
+  return {
+    insert(input) {
+      const now = Date.now();
+      const task2 = TaskSchema.parse({
+        id: input.id ?? randomUUID2(),
+        source: input.source,
+        context: input.context ?? null,
+        status: input.status ?? "pending",
+        priority: input.priority ?? null,
+        payload: input.payload,
+        agent_assigned: input.agent_assigned ?? null,
+        session_id: input.session_id ?? null,
+        result: null,
+        cost_tokens: input.cost_tokens ?? 0,
+        cost_usd: input.cost_usd ?? 0,
+        created_at: now,
+        started_at: null,
+        completed_at: null
+      });
+      db.exec(INSERT_SQL, {
+        $id: task2.id,
+        $source: task2.source,
+        $context: task2.context,
+        $status: task2.status,
+        $priority: task2.priority,
+        $payload: task2.payload,
+        $agent_assigned: task2.agent_assigned,
+        $session_id: task2.session_id,
+        $result: task2.result,
+        $cost_tokens: task2.cost_tokens,
+        $cost_usd: task2.cost_usd,
+        $created_at: task2.created_at,
+        $started_at: task2.started_at,
+        $completed_at: task2.completed_at
+      });
+      return task2;
+    },
+    get(id) {
+      const rows = db.query(SELECT_BY_ID_SQL, { $id: id });
+      if (rows.length === 0)
+        return null;
+      return rowToTask(rows[0]);
+    },
+    list(filter) {
+      const conditions = [];
+      const params = {};
+      if (filter?.source) {
+        conditions.push("source = $source");
+        params.$source = filter.source;
+      }
+      if (filter?.context) {
+        conditions.push("context = $context");
+        params.$context = filter.context;
+      }
+      if (filter?.status) {
+        conditions.push("status = $status");
+        params.$status = filter.status;
+      }
+      if (filter?.agent_assigned) {
+        conditions.push("agent_assigned = $agent_assigned");
+        params.$agent_assigned = filter.agent_assigned;
+      }
+      if (filter?.session_id) {
+        conditions.push("session_id = $session_id");
+        params.$session_id = filter.session_id;
+      }
+      if (filter?.priority) {
+        conditions.push("priority = $priority");
+        params.$priority = filter.priority;
+      }
+      const where = conditions.length > 0 ? ` WHERE ${conditions.join(" AND ")}` : "";
+      const sql = `SELECT * FROM tasks${where} ORDER BY created_at DESC`;
+      const rows = db.query(sql, params);
+      return rows.map(rowToTask);
+    },
+    update(id, patch) {
+      const existing = db.query(SELECT_BY_ID_SQL, { $id: id });
+      if (existing.length === 0)
+        return null;
+      const params = { $id: id };
+      if (patch.status !== undefined)
+        params.$status = patch.status;
+      if (patch.priority !== undefined)
+        params.$priority = patch.priority;
+      if (patch.agent_assigned !== undefined)
+        params.$agent_assigned = patch.agent_assigned;
+      if (patch.session_id !== undefined)
+        params.$session_id = patch.session_id;
+      if (patch.result !== undefined)
+        params.$result = patch.result;
+      if (patch.cost_tokens !== undefined)
+        params.$cost_tokens = patch.cost_tokens;
+      if (patch.cost_usd !== undefined)
+        params.$cost_usd = patch.cost_usd;
+      if (patch.started_at !== undefined)
+        params.$started_at = patch.started_at;
+      if (patch.completed_at !== undefined)
+        params.$completed_at = patch.completed_at;
+      db.exec(UPDATE_SQL, params);
+      return this.get(id);
+    },
+    remove(id) {
+      const before = db.query(SELECT_BY_ID_SQL, { $id: id });
+      if (before.length === 0)
+        return false;
+      db.exec(DELETE_BY_ID_SQL, { $id: id });
+      return true;
+    },
+    listPending() {
+      const rows = db.query(`SELECT * FROM tasks WHERE status = 'pending' ORDER BY created_at ASC`);
+      return rows.map(rowToTask);
+    },
+    listFailed() {
+      const rows = db.query(`SELECT * FROM tasks WHERE status = 'failed' ORDER BY created_at ASC`);
+      return rows.map(rowToTask);
+    },
+    listByContext(context) {
+      const rows = db.query(`SELECT * FROM tasks WHERE context = $context ORDER BY created_at DESC`, { $context: context });
+      return rows.map(rowToTask);
+    },
+    close() {
+      db.close();
+    }
+  };
+}
+var CREATE_TABLE_SQL = `
+  CREATE TABLE IF NOT EXISTS tasks (
+    id TEXT PRIMARY KEY,
+    source TEXT NOT NULL,
+    context TEXT,
+    status TEXT NOT NULL,
+    priority TEXT,
+    payload TEXT NOT NULL,
+    agent_assigned TEXT,
+    session_id TEXT,
+    result TEXT,
+    cost_tokens INTEGER DEFAULT 0,
+    cost_usd REAL DEFAULT 0,
+    created_at INTEGER NOT NULL,
+    started_at INTEGER,
+    completed_at INTEGER
+  )
+`, CREATE_INDEX_STATUS = `CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status)`, CREATE_INDEX_CONTEXT = `CREATE INDEX IF NOT EXISTS idx_tasks_context ON tasks(context)`, CREATE_INDEX_SOURCE = `CREATE INDEX IF NOT EXISTS idx_tasks_source ON tasks(source)`, INSERT_SQL = `
+  INSERT INTO tasks (id, source, context, status, priority, payload, agent_assigned, session_id, result, cost_tokens, cost_usd, created_at, started_at, completed_at)
+  VALUES ($id, $source, $context, $status, $priority, $payload, $agent_assigned, $session_id, $result, $cost_tokens, $cost_usd, $created_at, $started_at, $completed_at)
+`, SELECT_BY_ID_SQL = `SELECT * FROM tasks WHERE id = $id`, DELETE_BY_ID_SQL = `DELETE FROM tasks WHERE id = $id`, UPDATE_SQL = `
+  UPDATE tasks SET
+    status = COALESCE($status, status),
+    priority = COALESCE($priority, priority),
+    agent_assigned = COALESCE($agent_assigned, agent_assigned),
+    session_id = COALESCE($session_id, session_id),
+    result = COALESCE($result, result),
+    cost_tokens = COALESCE($cost_tokens, cost_tokens),
+    cost_usd = COALESCE($cost_usd, cost_usd),
+    started_at = COALESCE($started_at, started_at),
+    completed_at = COALESCE($completed_at, completed_at)
+  WHERE id = $id
+`;
+var init_ledger = __esm(() => {
+  init_schema2();
+});
+
+// packages/task-ledger-core/src/sqlite.ts
+import { Database as Database2 } from "bun:sqlite";
+function createSqliteDatabase(dbPath) {
+  const db = new Database2(dbPath);
+  db.exec("PRAGMA journal_mode = WAL");
+  db.exec("PRAGMA foreign_keys = ON");
+  return {
+    exec(sql, ...params) {
+      if (params.length === 0) {
+        db.run(sql);
+      } else {
+        const named = params[0];
+        db.run(sql, named);
+      }
+    },
+    query(sql, ...params) {
+      if (params.length === 0) {
+        return db.prepare(sql).all();
+      }
+      const named = params[0];
+      return db.prepare(sql).all(named);
+    },
+    close() {
+      db.close();
+    }
+  };
+}
+var init_sqlite = () => {};
+
+// packages/task-ledger-core/src/index.ts
+var init_src6 = __esm(() => {
+  init_schema2();
+  init_ledger();
+  init_sqlite();
+});
+
 // packages/omo-opencode/src/cli/generate.ts
 var exports_generate = {};
 __export(exports_generate, {
@@ -165075,6 +165431,264 @@ var init_export = __esm(() => {
   };
 });
 
+// packages/omo-opencode/src/project/project-context.ts
+var exports_project_context = {};
+__export(exports_project_context, {
+  unarchiveProject: () => unarchiveProject,
+  switchProject: () => switchProject,
+  saveState: () => saveState,
+  saveProjectMeta: () => saveProjectMeta,
+  loadState: () => loadState,
+  loadProjectMeta: () => loadProjectMeta,
+  listProjects: () => listProjects,
+  initProjectFiles: () => initProjectFiles,
+  getStatePath: () => getStatePath,
+  getProjectsDir: () => getProjectsDir,
+  getProjectDir: () => getProjectDir,
+  getMatrixOsDir: () => getMatrixOsDir,
+  getActiveProject: () => getActiveProject,
+  deleteProject: () => deleteProject,
+  createProject: () => createProject,
+  archiveProject: () => archiveProject
+});
+import { existsSync as existsSync75, mkdirSync as mkdirSync27, readFileSync as readFileSync60, writeFileSync as writeFileSync27, rmSync as rmSync8 } from "fs";
+import { join as join81 } from "path";
+function getMatrixOsDir(cwd = process.cwd()) {
+  return join81(cwd, ".matrixos");
+}
+function getProjectsDir(cwd) {
+  return join81(getMatrixOsDir(cwd), "projects");
+}
+function getProjectDir(slug, cwd) {
+  return join81(getProjectsDir(cwd), slug);
+}
+function getStatePath(cwd) {
+  return join81(getMatrixOsDir(cwd), "state.json");
+}
+function loadState(cwd) {
+  const path29 = getStatePath(cwd);
+  if (!existsSync75(path29))
+    return {};
+  try {
+    return JSON.parse(readFileSync60(path29, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function saveState(state2, cwd) {
+  const path29 = getStatePath(cwd);
+  mkdirSync27(getMatrixOsDir(cwd), { recursive: true });
+  writeFileSync27(path29, JSON.stringify(state2, null, 2) + `
+`);
+}
+function loadProjectMeta(slug, cwd) {
+  const path29 = join81(getProjectDir(slug, cwd), "meta.json");
+  if (!existsSync75(path29))
+    return null;
+  try {
+    return JSON.parse(readFileSync60(path29, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function saveProjectMeta(slug, meta3, cwd) {
+  const dir = getProjectDir(slug, cwd);
+  mkdirSync27(dir, { recursive: true });
+  const path29 = join81(dir, "meta.json");
+  writeFileSync27(path29, JSON.stringify(meta3, null, 2) + `
+`);
+}
+function initProjectFiles(slug, cwd) {
+  const dir = getProjectDir(slug, cwd);
+  mkdirSync27(join81(dir, "kb"), { recursive: true });
+  const kanbanPath = join81(dir, "kanban.json");
+  if (!existsSync75(kanbanPath)) {
+    writeFileSync27(kanbanPath, JSON.stringify({ columns: ["todo", "in-progress", "review", "done"], tasks: [] }, null, 2) + `
+`);
+  }
+}
+function createProject(slug, options = {}) {
+  if (!/^[a-z0-9_-]+$/.test(slug)) {
+    throw new Error(`Invalid project slug "${slug}": only lowercase letters, numbers, - and _ are allowed.`);
+  }
+  const dir = getProjectDir(slug, options.cwd);
+  if (existsSync75(dir)) {
+    throw new Error(`Project "${slug}" already exists.`);
+  }
+  const now = new Date().toISOString();
+  const meta3 = {
+    slug,
+    name: options.name || slug,
+    description: options.description,
+    createdAt: now
+  };
+  saveProjectMeta(slug, meta3, options.cwd);
+  initProjectFiles(slug, options.cwd);
+  const state2 = loadState(options.cwd);
+  if (!state2.activeProject) {
+    saveState({ ...state2, activeProject: slug }, options.cwd);
+  }
+  return { slug, meta: meta3, active: state2.activeProject === slug || !state2.activeProject };
+}
+function listProjects(cwd) {
+  const state2 = loadState(cwd);
+  const root = getProjectsDir(cwd);
+  if (!existsSync75(root))
+    return [];
+  const fs24 = __require("fs");
+  const items = [];
+  for (const slug of fs24.readdirSync(root, { withFileTypes: true })) {
+    if (!slug.isDirectory())
+      continue;
+    const meta3 = loadProjectMeta(slug.name, cwd);
+    if (!meta3)
+      continue;
+    items.push({ slug: slug.name, meta: meta3, active: state2.activeProject === slug.name });
+  }
+  return items.sort((a2, b2) => a2.slug.localeCompare(b2.slug));
+}
+function switchProject(slug, cwd) {
+  const meta3 = loadProjectMeta(slug, cwd);
+  if (!meta3)
+    throw new Error(`Project "${slug}" does not exist.`);
+  if (meta3.archived)
+    throw new Error(`Project "${slug}" is archived. Unarchive it before switching.`);
+  const state2 = loadState(cwd);
+  saveState({ ...state2, activeProject: slug }, cwd);
+  return { slug, meta: meta3, active: true };
+}
+function archiveProject(slug, cwd) {
+  const meta3 = loadProjectMeta(slug, cwd);
+  if (!meta3)
+    throw new Error(`Project "${slug}" does not exist.`);
+  const now = new Date().toISOString();
+  const next = { ...meta3, archived: true, archivedAt: now };
+  saveProjectMeta(slug, next, cwd);
+  const state2 = loadState(cwd);
+  if (state2.activeProject === slug) {
+    saveState({ ...state2, activeProject: undefined }, cwd);
+  }
+  return { slug, meta: next, active: false };
+}
+function unarchiveProject(slug, cwd) {
+  const meta3 = loadProjectMeta(slug, cwd);
+  if (!meta3)
+    throw new Error(`Project "${slug}" does not exist.`);
+  const { archived: _a3, archivedAt: _b, ...rest } = meta3;
+  const next = rest;
+  saveProjectMeta(slug, next, cwd);
+  return { slug, meta: next, active: loadState(cwd).activeProject === slug };
+}
+function deleteProject(slug, cwd) {
+  const dir = getProjectDir(slug, cwd);
+  if (!existsSync75(dir))
+    throw new Error(`Project "${slug}" does not exist.`);
+  rmSync8(dir, { recursive: true, force: true });
+  const state2 = loadState(cwd);
+  if (state2.activeProject === slug) {
+    saveState({ ...state2, activeProject: undefined }, cwd);
+  }
+}
+function getActiveProject(cwd) {
+  const state2 = loadState(cwd);
+  if (!state2.activeProject)
+    return null;
+  const meta3 = loadProjectMeta(state2.activeProject, cwd);
+  if (!meta3) {
+    saveState({ ...state2, activeProject: undefined }, cwd);
+    return null;
+  }
+  return { slug: state2.activeProject, meta: meta3, active: true };
+}
+var init_project_context = () => {};
+
+// packages/omo-opencode/src/project/project-memory.ts
+var exports_project_memory = {};
+__export(exports_project_memory, {
+  tagWithProject: () => tagWithProject,
+  searchProject: () => searchProject,
+  searchKb: () => searchKb,
+  listKbDocuments: () => listKbDocuments,
+  isProjectEpisode: () => isProjectEpisode,
+  addKbDocument: () => addKbDocument
+});
+import { existsSync as existsSync76, mkdirSync as mkdirSync28, readFileSync as readFileSync61, readdirSync as readdirSync16, writeFileSync as writeFileSync28 } from "fs";
+import { join as join82 } from "path";
+function tagWithProject(metadata = {}, projectSlug, cwd) {
+  const active = projectSlug ?? getActiveProject(cwd)?.slug;
+  if (!active)
+    return metadata;
+  return { ...metadata, project: active };
+}
+function isProjectEpisode(ep, projectSlug, cwd) {
+  const target = projectSlug ?? getActiveProject(cwd)?.slug;
+  if (!target)
+    return true;
+  return ep.metadata?.project === target;
+}
+function listKbDocuments(projectSlug, cwd) {
+  const kbDir = join82(getProjectDir(projectSlug, cwd), "kb");
+  if (!existsSync76(kbDir))
+    return [];
+  const docs = [];
+  for (const entry of readdirSync16(kbDir, { withFileTypes: true })) {
+    if (!entry.isFile())
+      continue;
+    const path29 = join82(kbDir, entry.name);
+    try {
+      docs.push({ path: path29, content: readFileSync61(path29, "utf-8") });
+    } catch {}
+  }
+  return docs;
+}
+function searchKb(projectSlug, query, cwd) {
+  const needle = query.toLowerCase();
+  const docs = listKbDocuments(projectSlug, cwd);
+  const results = [];
+  for (const doc2 of docs) {
+    const content = doc2.content.toLowerCase();
+    const matches = content.split(needle).length - 1;
+    if (matches > 0) {
+      results.push({
+        project: projectSlug,
+        source: "kb",
+        path: doc2.path,
+        content: doc2.content.slice(0, 240),
+        score: matches
+      });
+    }
+  }
+  return results.sort((a2, b2) => b2.score - a2.score);
+}
+async function searchProject(query, options = {}) {
+  const projectSlug = options.projectSlug ?? getActiveProject(options.cwd)?.slug;
+  if (!projectSlug)
+    return [];
+  const kbHits = searchKb(projectSlug, query, options.cwd);
+  let memoryHits = [];
+  if (options.memoryStore) {
+    const episodes = options.memoryStore.searchEpisodes?.({ textContains: query, limit: 20 }) ?? [];
+    memoryHits = episodes.filter((ep) => ep.metadata?.project === projectSlug).map((ep) => ({
+      project: projectSlug,
+      source: "episode",
+      summary: ep.summary,
+      score: 1
+    }));
+  }
+  return [...kbHits, ...memoryHits].sort((a2, b2) => b2.score - a2.score);
+}
+function addKbDocument(projectSlug, filename, content, cwd) {
+  const kbDir = join82(getProjectDir(projectSlug, cwd), "kb");
+  mkdirSync28(kbDir, { recursive: true });
+  const safeName = filename.replace(/[^a-zA-Z0-9._-]/g, "_");
+  const path29 = join82(kbDir, safeName);
+  writeFileSync28(path29, content, "utf-8");
+  return path29;
+}
+var init_project_memory = __esm(() => {
+  init_project_context();
+});
+
 // packages/omo-opencode/src/cli/adopt.ts
 var exports_adopt = {};
 __export(exports_adopt, {
@@ -165196,6 +165810,13 @@ async function runAdopt(options = {}) {
       message: "Global adoption requires an interactive terminal. Run: matrixos adopt (no arguments)."
     };
   }
+  if (!process.stdin.isTTY) {
+    return {
+      ok: false,
+      message: `Cannot run interactive adoption: stdin is not a TTY.
+` + "Run in a terminal, or use: matrixos gateway adopt telegram --token <token>"
+    };
+  }
   console.log(`
 === MaTrixOS Re-Adoption ===`);
   console.log(`You can reconfigure providers, channels, and profile.
@@ -165402,12 +166023,12 @@ __export(exports_gateway_start, {
   buildTelegramConfig: () => buildTelegramConfig,
   buildGatewayConfig: () => buildGatewayConfig
 });
-import { readFileSync as readFileSync60, existsSync as existsSync75 } from "fs";
+import { readFileSync as readFileSync62, existsSync as existsSync77 } from "fs";
 import { resolve as resolve19 } from "path";
 function loadGatewayEnv(path29 = ENV_PATH) {
-  if (!existsSync75(path29))
+  if (!existsSync77(path29))
     return {};
-  const text = readFileSync60(path29, "utf8");
+  const text = readFileSync62(path29, "utf8");
   const out = {};
   for (const raw of text.split(/\r?\n/)) {
     const line = raw.trim();
@@ -165527,6 +166148,537 @@ var init_gateway_start = __esm(() => {
   ENV_PATH = resolve19(process.cwd(), ".klc-gateway.env");
 });
 
+// packages/omo-opencode/src/deployment/deployment-core.ts
+function registerTarget(target) {
+  targets.set(target.name, target);
+}
+function getTarget(name2) {
+  return targets.get(name2);
+}
+function listTargets() {
+  return Array.from(targets.keys());
+}
+var targets;
+var init_deployment_core = __esm(() => {
+  targets = new Map;
+});
+
+// packages/omo-opencode/src/deployment/deploy-static.ts
+import { spawn as spawn6 } from "child_process";
+import { existsSync as existsSync78 } from "fs";
+import { resolve as resolve20 } from "path";
+function pushStage(stage, message, ok = true) {
+  return { stage, message, ok };
+}
+function run2(cmd, args, cwd) {
+  return new Promise((resolve21) => {
+    let output = "";
+    let error51 = "";
+    const child = spawn6(cmd, args, { cwd, shell: false });
+    child.stdout.on("data", (d) => output += d.toString());
+    child.stderr.on("data", (d) => error51 += d.toString());
+    child.on("close", (code) => resolve21({ ok: code === 0, output, error: error51 }));
+  });
+}
+var deployStatic;
+var init_deploy_static = __esm(() => {
+  deployStatic = {
+    name: "static",
+    async deploy(ctx, params) {
+      const stages = [];
+      const buildDir = resolve20(ctx.projectRoot, params.buildDir ?? "dist");
+      const destination = params.destination;
+      const prebuild = params.prebuild ?? "bun run build";
+      try {
+        if (!destination) {
+          return { target: "static", ok: false, stages: [pushStage("build", "missing destination parameter", false)], error: "missing destination" };
+        }
+        if (ctx.environment === "production" && ctx.requireValidation && !params.force) {
+          return {
+            target: "static",
+            ok: false,
+            stages: [pushStage("build", "production deploy requires explicit validation (force=true or use staging)", false)],
+            error: "validation required"
+          };
+        }
+        if (!ctx.execute) {
+          return {
+            target: "static",
+            ok: true,
+            url: destination,
+            stages: [
+              pushStage("build", `dry-run: would run '${prebuild}' in ${ctx.projectRoot}`),
+              pushStage("push", `dry-run: would rsync ${buildDir} to ${destination}`),
+              pushStage("verify", "dry-run: would verify 200 from deployed URL")
+            ]
+          };
+        }
+        if (prebuild) {
+          stages.push(pushStage("build", `running '${prebuild}'...`));
+          const build = await run2(prebuild, [], ctx.projectRoot);
+          if (!build.ok) {
+            stages.push(pushStage("build", `build failed: ${build.error}`, false));
+            return { target: "static", ok: false, stages, error: build.error };
+          }
+          stages.push(pushStage("build", "build succeeded"));
+        }
+        if (!existsSync78(buildDir)) {
+          stages.push(pushStage("push", `build directory not found: ${buildDir}`, false));
+          return { target: "static", ok: false, stages, error: "build directory missing" };
+        }
+        stages.push(pushStage("push", `syncing ${buildDir} to ${destination}...`));
+        const rsync = await run2("rsync", ["-avz", "--delete", buildDir + "/", destination], ctx.projectRoot);
+        if (!rsync.ok) {
+          stages.push(pushStage("push", `rsync failed: ${rsync.error}`, false));
+          return { target: "static", ok: false, stages, error: rsync.error };
+        }
+        stages.push(pushStage("push", "sync complete"));
+        const url3 = params.verifyUrl;
+        if (url3) {
+          stages.push(pushStage("verify", `checking ${url3}...`));
+          const check2 = await run2("curl", ["-sf", url3], ctx.projectRoot);
+          if (!check2.ok) {
+            stages.push(pushStage("verify", `verify failed: ${check2.error}`, false));
+            return { target: "static", ok: false, stages, error: check2.error };
+          }
+          stages.push(pushStage("verify", "verify ok"));
+        }
+        return { target: "static", ok: true, url: url3, stages };
+      } catch (err) {
+        const error51 = err instanceof Error ? err.message : String(err);
+        stages.push(pushStage("done", `unexpected error: ${error51}`, false));
+        return { target: "static", ok: false, stages, error: error51 };
+      }
+    }
+  };
+});
+
+// packages/omo-opencode/src/deployment/deploy-vercel.ts
+import { spawn as spawn7 } from "child_process";
+function pushStage2(stage, message, ok = true) {
+  return { stage, message, ok };
+}
+function run3(cmd, args, cwd, env5) {
+  return new Promise((resolve21) => {
+    let output = "";
+    let error51 = "";
+    const child = spawn7(cmd, args, { cwd, env: { ...process.env, ...env5 }, shell: false });
+    child.stdout.on("data", (d) => output += d.toString());
+    child.stderr.on("data", (d) => error51 += d.toString());
+    child.on("close", (code) => resolve21({ ok: code === 0, output, error: error51 }));
+  });
+}
+var deployVercel;
+var init_deploy_vercel = __esm(() => {
+  deployVercel = {
+    name: "vercel",
+    async deploy(ctx, params) {
+      const stages = [];
+      const prod = ctx.environment === "production";
+      const token = process.env.VERCEL_TOKEN || params.token;
+      try {
+        if (prod && ctx.requireValidation && !params.force) {
+          return {
+            target: "vercel",
+            ok: false,
+            stages: [pushStage2("build", "production deploy to Vercel requires explicit validation", false)],
+            error: "validation required"
+          };
+        }
+        if (!ctx.execute) {
+          return {
+            target: "vercel",
+            ok: true,
+            stages: [
+              pushStage2("build", `dry-run: would run vercel deploy${prod ? " --prod" : ""}`),
+              pushStage2("verify", "dry-run: would verify deployment URL")
+            ]
+          };
+        }
+        if (!token && prod) {
+          stages.push(pushStage2("build", "VERCEL_TOKEN missing", false));
+          return { target: "vercel", ok: false, stages, error: "missing VERCEL_TOKEN" };
+        }
+        const args = ["deploy"];
+        if (prod)
+          args.push("--prod");
+        if (token)
+          args.push("--token", token);
+        if (params.scope)
+          args.push("--scope", params.scope);
+        stages.push(pushStage2("push", `vercel ${args.join(" ")}...`));
+        const result = await run3("vercel", args, ctx.projectRoot, token ? { VERCEL_TOKEN: token } : undefined);
+        if (!result.ok) {
+          stages.push(pushStage2("push", `vercel deploy failed: ${result.error}`, false));
+          return { target: "vercel", ok: false, stages, error: result.error };
+        }
+        const urlMatch = result.output.match(/https:\/\/[^\s]+\.vercel\.app/);
+        const url3 = urlMatch?.[0];
+        stages.push(pushStage2("verify", url3 ? `deployed to ${url3}` : "deployed (URL not parsed)"));
+        return { target: "vercel", ok: true, url: url3, stages };
+      } catch (err) {
+        const error51 = err instanceof Error ? err.message : String(err);
+        stages.push(pushStage2("done", `unexpected error: ${error51}`, false));
+        return { target: "vercel", ok: false, stages, error: error51 };
+      }
+    }
+  };
+});
+
+// packages/omo-opencode/src/deployment/deploy-vps.ts
+import { spawn as spawn8 } from "child_process";
+function pushStage3(stage, message, ok = true) {
+  return { stage, message, ok };
+}
+function run4(cmd, args, cwd, env5) {
+  return new Promise((resolve21) => {
+    let output = "";
+    let error51 = "";
+    const child = spawn8(cmd, args, { cwd, env: { ...process.env, ...env5 }, shell: false });
+    child.stdout.on("data", (d) => output += d.toString());
+    child.stderr.on("data", (d) => error51 += d.toString());
+    child.on("close", (code) => resolve21({ ok: code === 0, output, error: error51 }));
+  });
+}
+var deployVps;
+var init_deploy_vps = __esm(() => {
+  deployVps = {
+    name: "vps",
+    async deploy(ctx, params) {
+      const stages = [];
+      const host = params.host;
+      const user = params.user ?? "deploy";
+      const remoteDir = params.remoteDir;
+      const buildDir = params.buildDir ?? "dist";
+      const service = params.service;
+      const healthUrl = params.healthUrl;
+      try {
+        if (!host || !remoteDir) {
+          return { target: "vps", ok: false, stages: [pushStage3("build", "missing host or remoteDir", false)], error: "missing parameters" };
+        }
+        if (ctx.environment === "production" && ctx.requireValidation && !params.force) {
+          return {
+            target: "vps",
+            ok: false,
+            stages: [pushStage3("build", "production deploy to VPS requires explicit validation", false)],
+            error: "validation required"
+          };
+        }
+        if (!ctx.execute) {
+          return {
+            target: "vps",
+            ok: true,
+            stages: [
+              pushStage3("build", `dry-run: would build in ${ctx.projectRoot}`),
+              pushStage3("push", `dry-run: would rsync ${buildDir} to ${user}@${host}:${remoteDir}`),
+              pushStage3("verify", `dry-run: would restart ${service ?? "service"} + health check ${healthUrl ?? ""}`)
+            ]
+          };
+        }
+        stages.push(pushStage3("build", "building..."));
+        const build = await run4("bun", ["run", "build"], ctx.projectRoot);
+        if (!build.ok) {
+          stages.push(pushStage3("build", `build failed: ${build.error}`, false));
+          return { target: "vps", ok: false, stages, error: build.error };
+        }
+        stages.push(pushStage3("build", "build ok"));
+        stages.push(pushStage3("push", `rsync to ${host}...`));
+        const rsync = await run4("rsync", ["-avz", "--delete", `${buildDir}/`, `${user}@${host}:${remoteDir}/`], ctx.projectRoot);
+        if (!rsync.ok) {
+          stages.push(pushStage3("push", `rsync failed: ${rsync.error}`, false));
+          return { target: "vps", ok: false, stages, error: rsync.error };
+        }
+        stages.push(pushStage3("push", "rsync ok"));
+        if (service) {
+          stages.push(pushStage3("verify", `restarting ${service}...`));
+          const restart = await run4("ssh", [`${user}@${host}`, `sudo systemctl restart ${service}`], ctx.projectRoot);
+          if (!restart.ok) {
+            stages.push(pushStage3("verify", `restart failed: ${restart.error}`, false));
+            return { target: "vps", ok: false, stages, error: restart.error };
+          }
+          stages.push(pushStage3("verify", "restart ok"));
+        }
+        if (healthUrl) {
+          stages.push(pushStage3("verify", `health check ${healthUrl}...`));
+          await new Promise((r2) => setTimeout(r2, 2000));
+          const health = await run4("curl", ["-sf", healthUrl], ctx.projectRoot);
+          if (!health.ok) {
+            stages.push(pushStage3("verify", `health check failed: ${health.error}`, false));
+            return { target: "vps", ok: false, stages, error: health.error };
+          }
+          stages.push(pushStage3("verify", "health ok"));
+        }
+        return { target: "vps", ok: true, url: healthUrl, stages };
+      } catch (err) {
+        const error51 = err instanceof Error ? err.message : String(err);
+        stages.push(pushStage3("done", `unexpected error: ${error51}`, false));
+        return { target: "vps", ok: false, stages, error: error51 };
+      }
+    }
+  };
+});
+
+// packages/omo-opencode/src/deployment/deploy-cli.ts
+import { resolve as resolve21 } from "path";
+async function runDeploy(options) {
+  const target = getTarget(options.target);
+  if (!target) {
+    console.error(`Unknown deployment target: ${options.target}`);
+    console.error(`Available: ${["static", "vercel", "vps", "docker", "wordpress"].join(", ")}`);
+    return 1;
+  }
+  const project = options.projectRoot ? undefined : await getActiveProject();
+  if (!options.projectRoot && !project) {
+    console.error("No active project. Run `matrixos project switch <slug>` or pass --project-root.");
+    return 1;
+  }
+  const projectRoot = resolve21(options.projectRoot ?? getProjectDir(project.slug));
+  const ctx = {
+    projectRoot,
+    projectSlug: project?.slug,
+    environment: options.environment ?? (options.dryRun ? "staging" : "production"),
+    execute: !options.dryRun,
+    requireValidation: true
+  };
+  const params = {};
+  for (const p2 of options.params ?? []) {
+    const [key, ...rest] = p2.split("=");
+    if (key)
+      params[key] = rest.join("=");
+  }
+  if (ctx.environment === "production" && ctx.requireValidation && !options.force) {
+    console.warn("Production deployment. This action requires explicit validation.");
+    console.warn("Re-run with --force to confirm, or use --env staging.");
+    return 1;
+  }
+  const result = await target.deploy(ctx, params);
+  if (result.ok) {
+    console.log(`\u2713 Deployed to ${result.target}${result.url ? ` \u2192 ${result.url}` : ""}`);
+    for (const s of result.stages) {
+      console.log(`  [${s.stage}] ${s.ok ? "\u2713" : "\u2717"} ${s.message}`);
+    }
+    return 0;
+  }
+  console.error(`\u2717 Deploy to ${result.target} failed: ${result.error ?? "unknown error"}`);
+  for (const s of result.stages) {
+    console.log(`  [${s.stage}] ${s.ok ? "\u2713" : "\u2717"} ${s.message}`);
+  }
+  return 1;
+}
+var init_deploy_cli = __esm(() => {
+  init_project_context();
+  init_deployment_core();
+});
+
+// packages/omo-opencode/src/deployment/index.ts
+var exports_deployment = {};
+__export(exports_deployment, {
+  targets: () => targets,
+  runDeploy: () => runDeploy,
+  registerTarget: () => registerTarget,
+  listTargets: () => listTargets,
+  getTarget: () => getTarget,
+  deployVps: () => deployVps,
+  deployVercel: () => deployVercel,
+  deployStatic: () => deployStatic
+});
+var init_deployment = __esm(() => {
+  init_deployment_core();
+  init_deploy_static();
+  init_deploy_vercel();
+  init_deploy_vps();
+  init_deploy_static();
+  init_deploy_vercel();
+  init_deploy_vps();
+  init_deploy_cli();
+  init_deployment_core();
+  registerTarget(deployStatic);
+  registerTarget(deployVercel);
+  registerTarget(deployVps);
+});
+
+// packages/omo-opencode/src/audit/self-audit.ts
+import { existsSync as existsSync79, mkdirSync as mkdirSync29, readdirSync as readdirSync17, readFileSync as readFileSync63, writeFileSync as writeFileSync29 } from "fs";
+import { join as join83 } from "path";
+function getAuditDir(cwd = process.cwd()) {
+  return join83(cwd, ".matrixos", "audits");
+}
+function getWeekString(date5 = new Date) {
+  const d = new Date(Date.UTC(date5.getFullYear(), date5.getMonth(), date5.getDate()));
+  const dayNum = d.getUTCDay() || 7;
+  d.setUTCDate(d.getUTCDate() + 4 - dayNum);
+  const yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
+  const weekNo = Math.ceil(((+d - +yearStart) / 86400000 + 1) / 7);
+  return `${d.getUTCFullYear()}-W${String(weekNo).padStart(2, "0")}`;
+}
+function parseWeekDateRange(weekStr) {
+  const [year, week] = weekStr.split("-W").map(Number);
+  const jan4 = new Date(Date.UTC(year, 0, 4));
+  const monday = new Date(Date.UTC(year, 0, 4 - ((jan4.getUTCDay() || 7) - 1) + (week - 1) * 7));
+  const sunday = new Date(+monday + 6 * 86400000);
+  return { from: monday.toISOString().slice(0, 10), to: sunday.toISOString().slice(0, 10) };
+}
+function generateAuditReport(tasks, signals, weekStr) {
+  const week = weekStr ?? getWeekString();
+  const period = parseWeekDateRange(week);
+  const summary = {
+    total: tasks.length,
+    done: tasks.filter((t2) => t2.status === "done").length,
+    failed: tasks.filter((t2) => t2.status === "failed").length,
+    inProgress: tasks.filter((t2) => t2.status === "in-progress").length,
+    blocked: tasks.filter((t2) => t2.status === "blocked").length
+  };
+  const byProject = {};
+  for (const t2 of tasks) {
+    const p2 = t2.project || "default";
+    byProject[p2] = byProject[p2] || { done: 0, failed: 0, blocked: 0 };
+    if (t2.status === "done")
+      byProject[p2].done += 1;
+    if (t2.status === "failed")
+      byProject[p2].failed += 1;
+    if (t2.status === "blocked")
+      byProject[p2].blocked += 1;
+  }
+  const errorCounts = new Map;
+  for (const s of signals) {
+    if (s.type !== "error")
+      continue;
+    const key = `${s.project || "global"}: ${s.message}`;
+    errorCounts.set(key, (errorCounts.get(key) || 0) + (s.count || 1));
+  }
+  const topErrors = [...errorCounts.entries()].sort((a2, b2) => b2[1] - a2[1]).slice(0, 5).map(([message, count]) => ({ type: "error", message, count }));
+  const recommendations = [];
+  if (summary.failed > 0) {
+    recommendations.push(`Analyser ${summary.failed} t\xE2che(s) en \xE9chec et cr\xE9er une skill/r\xE8gle par pattern r\xE9current.`);
+  }
+  if (summary.blocked > 0) {
+    recommendations.push(`D\xE9bloquer ${summary.blocked} t\xE2che(s) bloqu\xE9es avant le prochain sprint.`);
+  }
+  if (topErrors.length > 0) {
+    recommendations.push(`Top erreur : "${topErrors[0].message}" \u2014 prioriser un guard/automated fix.`);
+  }
+  if (recommendations.length === 0) {
+    recommendations.push("Semaine propre. Poursuivre la veille et la documentation des d\xE9cisions.");
+  }
+  return { week, period, summary, byProject, topErrors, recommendations };
+}
+function formatAuditReport(report) {
+  const lines = [
+    `# Auto-audit hebdomadaire \u2014 ${report.week}`,
+    "",
+    `**P\xE9riode** : ${report.period.from} \u2192 ${report.period.to}`,
+    "",
+    "## R\xE9sum\xE9",
+    "",
+    `| M\xE9trique | Valeur |`,
+    `|----------|--------|`,
+    `| Total | ${report.summary.total} |`,
+    `| Termin\xE9es | ${report.summary.done} |`,
+    `| \xC9chou\xE9es | ${report.summary.failed} |`,
+    `| En cours | ${report.summary.inProgress} |`,
+    `| Bloqu\xE9es | ${report.summary.blocked} |`,
+    "",
+    "## Par projet",
+    "",
+    `| Projet | Termin\xE9es | \xC9chou\xE9es | Bloqu\xE9es |`,
+    `|--------|-----------|----------|----------|`
+  ];
+  for (const [project, stats] of Object.entries(report.byProject).sort()) {
+    lines.push(`| ${project} | ${stats.done} | ${stats.failed} | ${stats.blocked} |`);
+  }
+  lines.push("");
+  lines.push("## Top erreurs");
+  lines.push("");
+  if (report.topErrors.length === 0) {
+    lines.push("Aucune erreur significative cette semaine.");
+  } else {
+    for (const err of report.topErrors) {
+      lines.push(`- **${err.count}\xD7** ${err.message}`);
+    }
+  }
+  lines.push("");
+  lines.push("## Recommandations");
+  lines.push("");
+  for (const rec of report.recommendations) {
+    lines.push(`- ${rec}`);
+  }
+  lines.push("");
+  return lines.join(`
+`);
+}
+function writeAuditReport(report, cwd) {
+  const dir = getAuditDir(cwd);
+  mkdirSync29(dir, { recursive: true });
+  const path29 = join83(dir, `${report.week}.md`);
+  writeFileSync29(path29, formatAuditReport(report), "utf-8");
+  return path29;
+}
+var init_self_audit = () => {};
+
+// packages/omo-opencode/src/cli/self-audit-command.ts
+var exports_self_audit_command = {};
+__export(exports_self_audit_command, {
+  normalizeStatus: () => normalizeStatus,
+  executeSelfAuditCommand: () => executeSelfAuditCommand
+});
+async function executeSelfAuditCommand(options = {}) {
+  if (options.installCron) {
+    const store4 = createCronStore();
+    const job = store4.add({
+      name: "Weekly self-audit",
+      schedule: "0 22 * * 0",
+      command: "matrixos self-audit",
+      channel: undefined,
+      recipient: undefined,
+      enabled: true
+    });
+    return { ok: true, message: `Weekly self-audit cron job installed: ${job.id}` };
+  }
+  const dbPath = options.tasksDb ?? process.env.TASK_LEDGER_DB ?? "/root/.matrixos/tasks.db";
+  let tasks = [];
+  let signals = [];
+  try {
+    const rawLedger = createTaskLedger(createSqliteDatabase(dbPath));
+    const since = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString();
+    const allTasks = rawLedger.list?.() ?? [];
+    tasks = allTasks.filter((t2) => !t2.created_at || String(t2.created_at) >= since);
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    return {
+      ok: false,
+      message: `Could not read task ledger at ${dbPath}: ${detail}`
+    };
+  }
+  const report = generateAuditReport(tasks.map((t2) => ({
+    id: String(t2.id ?? t2.task_id ?? "unknown"),
+    title: String(t2.title ?? t2.summary ?? "untitled"),
+    status: normalizeStatus(t2.status),
+    project: t2.project || t2.context?.project || undefined,
+    errorCount: t2.error_count || t2.errorCount || 0
+  })), signals, options.week);
+  const path29 = writeAuditReport(report);
+  return { ok: true, path: path29, message: `Self-audit written to ${path29}`, report };
+}
+function normalizeStatus(status2) {
+  if (!status2)
+    return "in-progress";
+  const s = String(status2).toLowerCase();
+  if (["done", "completed", "finished", "closed"].includes(s))
+    return "done";
+  if (["fail", "failed", "error"].includes(s))
+    return "failed";
+  if (["blocked", "stuck"].includes(s))
+    return "blocked";
+  if (["in-progress", "in_progress", "wip", "active"].includes(s))
+    return "in-progress";
+  return s;
+}
+var init_self_audit_command = __esm(() => {
+  init_src6();
+  init_store();
+  init_self_audit();
+});
+
 // packages/omo-opencode/src/cli/rgpd-command.ts
 var exports_rgpd_command = {};
 __export(exports_rgpd_command, {
@@ -180251,64 +181403,8 @@ async function boulder(options) {
 `);
   return 0;
 }
-// packages/omo-opencode/src/features/cron/store.ts
-init_zod();
-var CronJobSchema = object({
-  id: string2().min(1),
-  name: string2().min(1).max(100),
-  schedule: string2().min(1).max(100),
-  command: string2().min(1),
-  channel: _enum2(["telegram", "discord", "whatsapp"]).optional(),
-  recipient: string2().optional(),
-  enabled: boolean2().default(true),
-  createdAt: string2(),
-  updatedAt: string2()
-}).strict();
-function createCronStore() {
-  const jobs = new Map;
-  let counter = 0;
-  return {
-    add(input) {
-      counter += 1;
-      const now = new Date().toISOString();
-      const job = {
-        id: `cron-${counter}`,
-        name: input.name,
-        schedule: input.schedule,
-        command: input.command,
-        channel: input.channel,
-        recipient: input.recipient,
-        enabled: input.enabled ?? true,
-        createdAt: now,
-        updatedAt: now
-      };
-      CronJobSchema.parse(job);
-      jobs.set(job.id, job);
-      return job;
-    },
-    get(id) {
-      return jobs.get(id);
-    },
-    list(filter) {
-      const all = Array.from(jobs.values());
-      return all.filter((j) => {
-        if (filter?.enabled !== undefined && j.enabled !== filter.enabled)
-          return false;
-        if (filter?.channel && j.channel !== filter.channel)
-          return false;
-        return true;
-      });
-    },
-    remove(id) {
-      return jobs.delete(id);
-    },
-    size() {
-      return jobs.size;
-    }
-  };
-}
-
 // packages/omo-opencode/src/cli/cron.ts
+init_store();
 var store2 = createCronStore();
 function cronAdd(options) {
   const job = store2.add({
@@ -180461,289 +181557,12 @@ function createDailyBrief(opts) {
   };
 }
 
-// packages/task-ledger-core/src/schema.ts
-init_zod();
-var TaskSourceSchema = _enum2(["webhook", "cron", "user", "kanban"]);
-var TaskStatusSchema = _enum2([
-  "pending",
-  "running",
-  "done",
-  "failed",
-  "cancelled"
-]);
-var TaskPrioritySchema = _enum2(["high", "medium", "low"]);
-var TaskSchema = object({
-  id: string2().min(1),
-  source: TaskSourceSchema,
-  context: string2().nullable(),
-  status: TaskStatusSchema,
-  priority: TaskPrioritySchema.nullable(),
-  payload: string2(),
-  agent_assigned: string2().nullable(),
-  session_id: string2().nullable(),
-  result: string2().nullable(),
-  cost_tokens: number2().int().nonnegative().default(0),
-  cost_usd: number2().nonnegative().default(0),
-  created_at: number2().int(),
-  started_at: number2().int().nullable(),
-  completed_at: number2().int().nullable()
-}).strict();
-var TaskInsertSchema = object({
-  id: string2().min(1).optional(),
-  source: TaskSourceSchema,
-  context: string2().nullable().optional(),
-  status: TaskStatusSchema.optional(),
-  priority: TaskPrioritySchema.nullable().optional(),
-  payload: string2(),
-  agent_assigned: string2().nullable().optional(),
-  session_id: string2().nullable().optional(),
-  cost_tokens: number2().int().nonnegative().optional(),
-  cost_usd: number2().nonnegative().optional()
-}).strict();
-var TaskPatchSchema = object({
-  status: TaskStatusSchema.optional(),
-  priority: TaskPrioritySchema.nullable().optional(),
-  agent_assigned: string2().nullable().optional(),
-  session_id: string2().nullable().optional(),
-  result: string2().nullable().optional(),
-  cost_tokens: number2().int().nonnegative().optional(),
-  cost_usd: number2().nonnegative().optional(),
-  started_at: number2().int().nullable().optional(),
-  completed_at: number2().int().nullable().optional()
-}).strict();
-var TaskFilterSchema = object({
-  source: TaskSourceSchema.optional(),
-  context: string2().optional(),
-  status: TaskStatusSchema.optional(),
-  agent_assigned: string2().optional(),
-  session_id: string2().optional(),
-  priority: TaskPrioritySchema.optional()
-}).strict();
-
-// packages/task-ledger-core/src/ledger.ts
-import { randomUUID as randomUUID2 } from "crypto";
-var CREATE_TABLE_SQL = `
-  CREATE TABLE IF NOT EXISTS tasks (
-    id TEXT PRIMARY KEY,
-    source TEXT NOT NULL,
-    context TEXT,
-    status TEXT NOT NULL,
-    priority TEXT,
-    payload TEXT NOT NULL,
-    agent_assigned TEXT,
-    session_id TEXT,
-    result TEXT,
-    cost_tokens INTEGER DEFAULT 0,
-    cost_usd REAL DEFAULT 0,
-    created_at INTEGER NOT NULL,
-    started_at INTEGER,
-    completed_at INTEGER
-  )
-`;
-var CREATE_INDEX_STATUS = `CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status)`;
-var CREATE_INDEX_CONTEXT = `CREATE INDEX IF NOT EXISTS idx_tasks_context ON tasks(context)`;
-var CREATE_INDEX_SOURCE = `CREATE INDEX IF NOT EXISTS idx_tasks_source ON tasks(source)`;
-var INSERT_SQL = `
-  INSERT INTO tasks (id, source, context, status, priority, payload, agent_assigned, session_id, result, cost_tokens, cost_usd, created_at, started_at, completed_at)
-  VALUES ($id, $source, $context, $status, $priority, $payload, $agent_assigned, $session_id, $result, $cost_tokens, $cost_usd, $created_at, $started_at, $completed_at)
-`;
-var SELECT_BY_ID_SQL = `SELECT * FROM tasks WHERE id = $id`;
-var DELETE_BY_ID_SQL = `DELETE FROM tasks WHERE id = $id`;
-var UPDATE_SQL = `
-  UPDATE tasks SET
-    status = COALESCE($status, status),
-    priority = COALESCE($priority, priority),
-    agent_assigned = COALESCE($agent_assigned, agent_assigned),
-    session_id = COALESCE($session_id, session_id),
-    result = COALESCE($result, result),
-    cost_tokens = COALESCE($cost_tokens, cost_tokens),
-    cost_usd = COALESCE($cost_usd, cost_usd),
-    started_at = COALESCE($started_at, started_at),
-    completed_at = COALESCE($completed_at, completed_at)
-  WHERE id = $id
-`;
-function rowToTask(row) {
-  return {
-    id: row.id,
-    source: row.source,
-    context: row.context,
-    status: row.status,
-    priority: row.priority,
-    payload: row.payload,
-    agent_assigned: row.agent_assigned,
-    session_id: row.session_id,
-    result: row.result,
-    cost_tokens: row.cost_tokens,
-    cost_usd: row.cost_usd,
-    created_at: row.created_at,
-    started_at: row.started_at,
-    completed_at: row.completed_at
-  };
-}
-function createTaskLedger(db) {
-  db.exec(CREATE_TABLE_SQL);
-  db.exec(CREATE_INDEX_STATUS);
-  db.exec(CREATE_INDEX_CONTEXT);
-  db.exec(CREATE_INDEX_SOURCE);
-  return {
-    insert(input) {
-      const now = Date.now();
-      const task2 = TaskSchema.parse({
-        id: input.id ?? randomUUID2(),
-        source: input.source,
-        context: input.context ?? null,
-        status: input.status ?? "pending",
-        priority: input.priority ?? null,
-        payload: input.payload,
-        agent_assigned: input.agent_assigned ?? null,
-        session_id: input.session_id ?? null,
-        result: null,
-        cost_tokens: input.cost_tokens ?? 0,
-        cost_usd: input.cost_usd ?? 0,
-        created_at: now,
-        started_at: null,
-        completed_at: null
-      });
-      db.exec(INSERT_SQL, {
-        $id: task2.id,
-        $source: task2.source,
-        $context: task2.context,
-        $status: task2.status,
-        $priority: task2.priority,
-        $payload: task2.payload,
-        $agent_assigned: task2.agent_assigned,
-        $session_id: task2.session_id,
-        $result: task2.result,
-        $cost_tokens: task2.cost_tokens,
-        $cost_usd: task2.cost_usd,
-        $created_at: task2.created_at,
-        $started_at: task2.started_at,
-        $completed_at: task2.completed_at
-      });
-      return task2;
-    },
-    get(id) {
-      const rows = db.query(SELECT_BY_ID_SQL, { $id: id });
-      if (rows.length === 0)
-        return null;
-      return rowToTask(rows[0]);
-    },
-    list(filter) {
-      const conditions = [];
-      const params = {};
-      if (filter?.source) {
-        conditions.push("source = $source");
-        params.$source = filter.source;
-      }
-      if (filter?.context) {
-        conditions.push("context = $context");
-        params.$context = filter.context;
-      }
-      if (filter?.status) {
-        conditions.push("status = $status");
-        params.$status = filter.status;
-      }
-      if (filter?.agent_assigned) {
-        conditions.push("agent_assigned = $agent_assigned");
-        params.$agent_assigned = filter.agent_assigned;
-      }
-      if (filter?.session_id) {
-        conditions.push("session_id = $session_id");
-        params.$session_id = filter.session_id;
-      }
-      if (filter?.priority) {
-        conditions.push("priority = $priority");
-        params.$priority = filter.priority;
-      }
-      const where = conditions.length > 0 ? ` WHERE ${conditions.join(" AND ")}` : "";
-      const sql = `SELECT * FROM tasks${where} ORDER BY created_at DESC`;
-      const rows = db.query(sql, params);
-      return rows.map(rowToTask);
-    },
-    update(id, patch) {
-      const existing = db.query(SELECT_BY_ID_SQL, { $id: id });
-      if (existing.length === 0)
-        return null;
-      const params = { $id: id };
-      if (patch.status !== undefined)
-        params.$status = patch.status;
-      if (patch.priority !== undefined)
-        params.$priority = patch.priority;
-      if (patch.agent_assigned !== undefined)
-        params.$agent_assigned = patch.agent_assigned;
-      if (patch.session_id !== undefined)
-        params.$session_id = patch.session_id;
-      if (patch.result !== undefined)
-        params.$result = patch.result;
-      if (patch.cost_tokens !== undefined)
-        params.$cost_tokens = patch.cost_tokens;
-      if (patch.cost_usd !== undefined)
-        params.$cost_usd = patch.cost_usd;
-      if (patch.started_at !== undefined)
-        params.$started_at = patch.started_at;
-      if (patch.completed_at !== undefined)
-        params.$completed_at = patch.completed_at;
-      db.exec(UPDATE_SQL, params);
-      return this.get(id);
-    },
-    remove(id) {
-      const before = db.query(SELECT_BY_ID_SQL, { $id: id });
-      if (before.length === 0)
-        return false;
-      db.exec(DELETE_BY_ID_SQL, { $id: id });
-      return true;
-    },
-    listPending() {
-      const rows = db.query(`SELECT * FROM tasks WHERE status = 'pending' ORDER BY created_at ASC`);
-      return rows.map(rowToTask);
-    },
-    listFailed() {
-      const rows = db.query(`SELECT * FROM tasks WHERE status = 'failed' ORDER BY created_at ASC`);
-      return rows.map(rowToTask);
-    },
-    listByContext(context) {
-      const rows = db.query(`SELECT * FROM tasks WHERE context = $context ORDER BY created_at DESC`, { $context: context });
-      return rows.map(rowToTask);
-    },
-    close() {
-      db.close();
-    }
-  };
-}
-
-// packages/task-ledger-core/src/sqlite.ts
-import { Database as Database2 } from "bun:sqlite";
-function createSqliteDatabase(dbPath) {
-  const db = new Database2(dbPath);
-  db.exec("PRAGMA journal_mode = WAL");
-  db.exec("PRAGMA foreign_keys = ON");
-  return {
-    exec(sql, ...params) {
-      if (params.length === 0) {
-        db.run(sql);
-      } else {
-        const named = params[0];
-        db.run(sql, named);
-      }
-    },
-    query(sql, ...params) {
-      if (params.length === 0) {
-        return db.prepare(sql).all();
-      }
-      const named = params[0];
-      return db.prepare(sql).all(named);
-    },
-    close() {
-      db.close();
-    }
-  };
-}
-
 // packages/omo-opencode/src/cli/daily-brief.ts
+init_src6();
 async function dailyBriefSend(options) {
   try {
     const rawLedger = createTaskLedger(createSqliteDatabase(process.env.TASK_LEDGER_DB ?? "/root/.matrixos/tasks.db"));
-    const ledger = {
+    const ledger2 = {
       listPending: () => rawLedger.listPending(),
       listFailed: () => rawLedger.list({ status: "failed" })
     };
@@ -180768,7 +181587,7 @@ async function dailyBriefSend(options) {
         recipient_id: recipient,
         channel
       }),
-      ledger,
+      ledger: ledger2,
       sender,
       now: () => Date.now()
     });
@@ -186062,7 +186881,7 @@ function createDataProvider(config5) {
       } catch {}
       if (entries.length > 0)
         return entries;
-      const types15 = ["episodic", "semantic", "procedural", "reflection"];
+      const types16 = ["episodic", "semantic", "procedural", "reflection"];
       const mockContent = [
         "User prefers concise responses with bullet points",
         "Project MaTrixOS uses Bun runtime and TypeScript strict mode",
@@ -186076,7 +186895,7 @@ function createDataProvider(config5) {
         entries.push({
           id: `mem_${randomBetween(1000, 9999)}`,
           content: randomChoice(mockContent),
-          type: randomChoice(types15),
+          type: randomChoice(types16),
           confidence: Math.round(randomBetween(60, 99)),
           created_at: new Date(Date.now() - randomBetween(0, 604800000)).toISOString()
         });
@@ -186652,6 +187471,9 @@ function configureRuntimeCommands(program2) {
 init_package();
 var VERSION4 = package_default.version;
 var program2 = new Command;
+function collectParams(value, previous) {
+  return previous.concat([value]);
+}
 function resolveInstallArgs(options, invocationName = process.env.OMO_INVOCATION_NAME) {
   const defaultPlatform = invocationName === "lazycodex" || invocationName === "lazycodex-ai" ? "codex" : undefined;
   const platform2 = options.platform ?? defaultPlatform;
@@ -186846,6 +187668,63 @@ program2.command("export [name]").description("Export a mini-OS profile as a sta
   process.exit(result.exitCode);
 });
 program2.addCommand(createMcpOAuthCommand());
+var project = program2.command("project").description("Manage MaTrixOS projects (active context, kanban, knowledge base)");
+project.command("create <slug>").description("Create a new project").option("-n, --name <name>", "Display name").option("-d, --description <text>", "Short description").action(async (slug, options) => {
+  const { createProject: createProject2 } = await Promise.resolve().then(() => (init_project_context(), exports_project_context));
+  const info = createProject2(slug, { name: options.name, description: options.description });
+  process.stdout.write(JSON.stringify(info, null, 2) + `
+`);
+});
+project.command("list").alias("ls").description("List all projects").action(async () => {
+  const { listProjects: listProjects2 } = await Promise.resolve().then(() => (init_project_context(), exports_project_context));
+  const list = listProjects2();
+  process.stdout.write(JSON.stringify(list, null, 2) + `
+`);
+});
+project.command("switch <slug>").description("Switch the active project").action(async (slug) => {
+  const { switchProject: switchProject2 } = await Promise.resolve().then(() => (init_project_context(), exports_project_context));
+  const info = switchProject2(slug);
+  process.stdout.write(JSON.stringify(info, null, 2) + `
+`);
+});
+project.command("active").description("Show the active project").action(async () => {
+  const { getActiveProject: getActiveProject2 } = await Promise.resolve().then(() => (init_project_context(), exports_project_context));
+  const info = getActiveProject2();
+  process.stdout.write(JSON.stringify(info ?? null, null, 2) + `
+`);
+});
+project.command("archive <slug>").description("Archive a project (removes it from the active list)").action(async (slug) => {
+  const { archiveProject: archiveProject2 } = await Promise.resolve().then(() => (init_project_context(), exports_project_context));
+  const info = archiveProject2(slug);
+  process.stdout.write(JSON.stringify(info, null, 2) + `
+`);
+});
+project.command("unarchive <slug>").description("Unarchive a project").action(async (slug) => {
+  const { unarchiveProject: unarchiveProject2 } = await Promise.resolve().then(() => (init_project_context(), exports_project_context));
+  const info = unarchiveProject2(slug);
+  process.stdout.write(JSON.stringify(info, null, 2) + `
+`);
+});
+project.command("delete <slug>").description("Permanently delete a project").action(async (slug) => {
+  const { deleteProject: deleteProject2 } = await Promise.resolve().then(() => (init_project_context(), exports_project_context));
+  deleteProject2(slug);
+  process.stdout.write(JSON.stringify({ ok: true, deleted: slug }, null, 2) + `
+`);
+});
+project.command("search <query>").description("Search the active project KB and memory").option("-p, --project <slug>", "Search a specific project instead of the active one").action(async (query, options) => {
+  const { searchProject: searchProject2 } = await Promise.resolve().then(() => (init_project_memory(), exports_project_memory));
+  const hits = await searchProject2(query, { projectSlug: options.project });
+  process.stdout.write(JSON.stringify(hits, null, 2) + `
+`);
+});
+project.command("add-doc <slug> <file>").description("Copy a document into the project KB").action(async (slug, filePath) => {
+  const { addKbDocument: addKbDocument2 } = await Promise.resolve().then(() => (init_project_memory(), exports_project_memory));
+  const { readFileSync: readFileSync64 } = await import("fs");
+  const content = readFileSync64(filePath, "utf-8");
+  const dest = addKbDocument2(slug, filePath, content);
+  process.stdout.write(JSON.stringify({ ok: true, dest }, null, 2) + `
+`);
+});
 var gateway2 = program2.command("gateway").description("Gateway configuration \u2014 bot token management");
 var gatewayAdopt = gateway2.command("adopt").description("Adopt a gateway channel (Telegram, Discord, WhatsApp)");
 var gatewayAdoptTelegram = gatewayAdopt.command("telegram").description("Set up the Telegram gateway: prompt for bot token, validate, write .klc-gateway.env").option("-t, --token <value>", "Bot token (non-interactive)").option("-c, --chat <id>", "Restrict to a single chat id").addHelpText("after", `
@@ -186909,13 +187788,48 @@ gateway2.command("status").description("Check gateway status (best-effort, inspe
   }, null, 2) + `
 `);
 });
-program2.command("adopt").description("Re-run the MaTrixOS adoption wizard (providers, channels, profile)").addHelpText("after", `
+program2.command("deploy <target>").description("Deploy the active project (static, vercel, vps)").option("-e, --env <env>", "Environment (staging, production, preview)", "production").option("-n, --dry-run", "Show what would happen without executing").option("-f, --force", "Skip production validation prompt").option("-r, --project-root <path>", "Override project root directory").option("-p, --param <param>", "Target-specific parameter (key=value)", collectParams, []).action(async (target, options) => {
+  const { runDeploy: runDeploy2 } = await Promise.resolve().then(() => (init_deployment(), exports_deployment));
+  const env5 = options.env;
+  const code = await runDeploy2({
+    target,
+    environment: env5,
+    dryRun: options.dryRun,
+    force: options.force,
+    projectRoot: options.projectRoot,
+    params: options.param
+  });
+  process.exit(code);
+});
+program2.command("self-audit").description("Generate the weekly self-audit report from task ledger and scanner signals").option("-w, --week <week>", "ISO week string, e.g. 2026-W30").option("-j, --json", "Output JSON instead of markdown").option("--tasks-db <path>", "Path to the task ledger SQLite DB").option("--install-cron", "Install the weekly cron job (Sunday 22:00)").action(async (options) => {
+  const { executeSelfAuditCommand: executeSelfAuditCommand2 } = await Promise.resolve().then(() => (init_self_audit_command(), exports_self_audit_command));
+  const result = await executeSelfAuditCommand2(options);
+  if (options.json) {
+    process.stdout.write(JSON.stringify(result, null, 2) + `
+`);
+  } else if (result.path) {
+    console.log(`Self-audit written to ${result.path}`);
+  } else {
+    console.log(result.message);
+  }
+  process.exit(result.ok ? 0 : 1);
+});
+program2.command("adopt").description("Re-run the MaTrixOS adoption wizard (providers, channels, profile)").argument("[channel]", "optional channel to adopt (telegram). Redirects to: matrixos gateway adopt <channel>").addHelpText("after", `
 Examples:
   $ matrixos adopt                    # interactive re-adoption (TUI)
+  $ matrixos adopt telegram           # alias for: matrixos gateway adopt telegram
 
 For channel-specific setup, use:
   $ matrixos gateway adopt telegram
-`).action(async () => {
+`).action(async (channel) => {
+  if (channel) {
+    const { runAdopt: runAdopt3 } = await Promise.resolve().then(() => (init_adopt(), exports_adopt));
+    const result2 = await runAdopt3({ channel, nonInteractive: true });
+    console.log(result2.message);
+    if (!result2.ok)
+      process.exit(1);
+    return;
+  }
   const { runAdopt: runAdopt2 } = await Promise.resolve().then(() => (init_adopt(), exports_adopt));
   const result = await runAdopt2({});
   if (!result.ok)