@kl-c/matrixos 0.2.1 → 0.2.5

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.5",
     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, {
@@ -165402,12 +166016,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 +166141,188 @@ var init_gateway_start = __esm(() => {
   ENV_PATH = resolve19(process.cwd(), ".klc-gateway.env");
 });
 
+// packages/omo-opencode/src/audit/self-audit.ts
+import { existsSync as existsSync78, 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 +181047,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 +181201,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 +181231,7 @@ async function dailyBriefSend(options) {
         recipient_id: recipient,
         channel
       }),
-      ledger,
+      ledger: ledger2,
       sender,
       now: () => Date.now()
     });
@@ -186062,7 +186525,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 +186539,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()
         });
@@ -186846,6 +187309,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,6 +187429,19 @@ gateway2.command("status").description("Check gateway status (best-effort, inspe
   }, null, 2) + `
 `);
 });
+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)").addHelpText("after", `
 Examples:
   $ matrixos adopt                    # interactive re-adoption (TUI)