@ftarganski/omni-ai 1.1.10 → 1.2.0

package/dist/cli/bin.js

@@ -8,7 +8,7 @@ import {
 } from "../chunk-AU3KUCI7.js";
 
 // ../../packages/cli/dist/bin.js
-import { dirname as dirname4, resolve as resolve17 } from "path";
+import { dirname as dirname5, resolve as resolve17 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { Command } from "commander";
 import { config as loadDotenv } from "dotenv";
@@ -1155,13 +1155,888 @@ async function exportCommand(sessionArg, opts) {
 ${messages.length} message(s) exported.`));
 }
 
+// ../../packages/cli/dist/commands/history/doctor.js
+import { existsSync } from "fs";
+import chalk5 from "chalk";
+
+// ../../packages/history/dist/parsers/claude-code.js
+import { readdir as readdir4, readFile as readFile6, stat } from "fs/promises";
+import { homedir } from "os";
+import { join as join4 } from "path";
+import { glob } from "glob";
+function extractContent(message) {
+  const raw = message?.content;
+  if (typeof raw === "string")
+    return { content: raw };
+  if (Array.isArray(raw)) {
+    const blocks = raw;
+    const text = blocks.map((b) => {
+      if (b.type === "text")
+        return b.text ?? "";
+      if (b.type === "tool_use")
+        return `[tool_use:${b.name}] ${JSON.stringify(b.input ?? {})}`;
+      if (b.type === "tool_result")
+        return typeof b.content === "string" ? b.content : JSON.stringify(b.content);
+      return "";
+    }).filter(Boolean).join("\n");
+    const toolUse = blocks.find((b) => b.type === "tool_use");
+    return { content: text, toolName: toolUse?.name };
+  }
+  return { content: "" };
+}
+function defaultClaudeCodeRoot() {
+  return join4(homedir(), ".claude", "projects");
+}
+async function parseTranscriptFile(file, provider, scope) {
+  const raw = await readFile6(file, "utf-8");
+  const lines = raw.split("\n").filter((l) => l.trim().length > 0);
+  const events = [];
+  const citations = [];
+  let ordinal = 0;
+  lines.forEach((line, lineIndex) => {
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      return;
+    }
+    const type = typeof entry.type === "string" ? entry.type : void 0;
+    const message = entry.message;
+    if (!message || type !== "user" && type !== "assistant")
+      return;
+    const { content, toolName } = extractContent(message);
+    if (!content)
+      return;
+    const timestamp = typeof entry.timestamp === "string" ? Date.parse(entry.timestamp) : Number.NaN;
+    events.push({
+      role: message.role ?? type ?? "user",
+      content,
+      toolName,
+      ordinal: ordinal++,
+      timestamp: Number.isNaN(timestamp) ? Date.now() : timestamp
+    });
+    citations.push({ sourcePath: file, sourceLine: lineIndex + 1 });
+  });
+  if (events.length === 0)
+    return null;
+  const sourceSessionId = file.replace(/\.jsonl$/, "").split(/[/\\]/).pop() ?? file;
+  return {
+    session: {
+      id: `${provider}:${scope ?? ""}:${sourceSessionId}`,
+      provider,
+      sourceSessionId,
+      importedAt: Date.now(),
+      scope
+    },
+    events,
+    citations
+  };
+}
+var ClaudeCodeHistoryParser = class {
+  provider = "claude-code";
+  root;
+  constructor(options = {}) {
+    this.root = options.root ?? defaultClaudeCodeRoot();
+  }
+  async discover() {
+    const id = `${this.provider}:${this.root}`;
+    const base = {
+      id,
+      provider: this.provider,
+      path: this.root,
+      nativeImport: true
+    };
+    let entries;
+    try {
+      const info = await stat(this.root);
+      if (!info.isDirectory()) {
+        return [{ ...base, importable: false, reason: "path is not a directory" }];
+      }
+      entries = await readdir4(this.root, { withFileTypes: true });
+    } catch {
+      return [{ ...base, importable: false, reason: "history directory not found" }];
+    }
+    const sources = [];
+    const looseFiles = await glob("*.jsonl", { cwd: this.root });
+    if (looseFiles.length > 0) {
+      sources.push({ ...base, importable: true });
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory())
+        continue;
+      const dir = join4(this.root, entry.name);
+      const files = await glob("**/*.jsonl", { cwd: dir });
+      if (files.length === 0)
+        continue;
+      sources.push({
+        id: `${this.provider}:${dir}`,
+        provider: this.provider,
+        path: dir,
+        nativeImport: true,
+        importable: true,
+        scope: entry.name
+      });
+    }
+    if (sources.length === 0) {
+      return [{ ...base, importable: false, reason: "no .jsonl transcripts found" }];
+    }
+    return sources;
+  }
+  async import(source) {
+    const files = await glob("**/*.jsonl", { cwd: source.path, absolute: true });
+    const results = [];
+    for (const file of files) {
+      const result = await parseTranscriptFile(file, source.provider, source.scope);
+      if (result)
+        results.push(result);
+    }
+    return results;
+  }
+};
+
+// ../../packages/history/dist/parsers/codex.js
+import { readFile as readFile7, stat as stat2 } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { join as join5 } from "path";
+import { glob as glob2 } from "glob";
+
+// ../../packages/history/dist/store.js
+import { mkdirSync } from "fs";
+import { dirname as dirname3 } from "path";
+import Database2 from "better-sqlite3";
+var sourceFromRow = (r) => ({
+  id: r.id,
+  provider: r.provider,
+  path: r.path,
+  nativeImport: Boolean(r.native_import),
+  importable: Boolean(r.importable),
+  reason: r.reason ?? void 0,
+  scope: r.scope || void 0
+});
+var sessionFromRow = (r) => ({
+  id: r.id,
+  provider: r.provider,
+  sourceSessionId: r.source_session_id,
+  importedAt: r.imported_at,
+  scope: r.scope || void 0
+});
+var eventFromRow = (r) => ({
+  id: r.id,
+  sessionId: r.session_id,
+  role: r.role,
+  content: r.content,
+  toolName: r.tool_name ?? void 0,
+  ordinal: r.ordinal,
+  timestamp: r.ts
+});
+var HistoryStore = class {
+  db;
+  constructor(options = {}) {
+    const path = options.path ?? "./omni-ai-history.db";
+    mkdirSync(dirname3(path), { recursive: true });
+    this.db = new Database2(path);
+    this.db.pragma("journal_mode = WAL");
+    this.migrate();
+  }
+  migrate() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS sources (
+        id            TEXT PRIMARY KEY,
+        provider      TEXT NOT NULL,
+        path          TEXT NOT NULL,
+        native_import INTEGER NOT NULL,
+        importable    INTEGER NOT NULL,
+        reason        TEXT,
+        scope         TEXT NOT NULL DEFAULT ''
+      );
+
+      CREATE TABLE IF NOT EXISTS sessions (
+        id                TEXT PRIMARY KEY,
+        provider          TEXT NOT NULL,
+        source_session_id TEXT NOT NULL,
+        imported_at       INTEGER NOT NULL,
+        scope             TEXT NOT NULL DEFAULT '',
+        UNIQUE (provider, scope, source_session_id)
+      );
+      CREATE INDEX IF NOT EXISTS idx_sessions_scope ON sessions (scope);
+
+      CREATE TABLE IF NOT EXISTS events (
+        id         INTEGER PRIMARY KEY AUTOINCREMENT,
+        session_id TEXT    NOT NULL REFERENCES sessions (id),
+        role       TEXT    NOT NULL,
+        content    TEXT    NOT NULL,
+        tool_name  TEXT,
+        ordinal    INTEGER NOT NULL,
+        ts         INTEGER NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_events_session ON events (session_id, ordinal);
+
+      CREATE VIRTUAL TABLE IF NOT EXISTS events_fts USING fts5(
+        content,
+        content='events',
+        content_rowid='id'
+      );
+
+      CREATE TRIGGER IF NOT EXISTS events_ai AFTER INSERT ON events BEGIN
+        INSERT INTO events_fts (rowid, content) VALUES (new.id, new.content);
+      END;
+
+      CREATE TABLE IF NOT EXISTS citations (
+        event_id    INTEGER NOT NULL REFERENCES events (id),
+        source_path TEXT    NOT NULL,
+        source_line INTEGER,
+        PRIMARY KEY (event_id)
+      );
+    `);
+  }
+  upsertSource(source) {
+    this.db.prepare(`INSERT INTO sources (id, provider, path, native_import, importable, reason, scope)
+         VALUES (@id, @provider, @path, @nativeImport, @importable, @reason, @scope)
+         ON CONFLICT (id) DO UPDATE SET
+           provider = excluded.provider,
+           path = excluded.path,
+           native_import = excluded.native_import,
+           importable = excluded.importable,
+           reason = excluded.reason,
+           scope = excluded.scope`).run({
+      id: source.id,
+      provider: source.provider,
+      path: source.path,
+      nativeImport: source.nativeImport ? 1 : 0,
+      importable: source.importable ? 1 : 0,
+      reason: source.reason ?? null,
+      scope: source.scope ?? ""
+    });
+  }
+  listSources(provider) {
+    const rows = provider ? this.db.prepare(`SELECT * FROM sources WHERE provider = ? ORDER BY id`).all(provider) : this.db.prepare(`SELECT * FROM sources ORDER BY provider, id`).all();
+    return rows.map(sourceFromRow);
+  }
+  /** Persists one imported session and its events/citations. Idempotent per (provider, scope, sourceSessionId). */
+  saveImportResult(provider, sessionId, result) {
+    const upsertSession = this.db.prepare(`INSERT INTO sessions (id, provider, source_session_id, imported_at, scope)
+       VALUES (@id, @provider, @sourceSessionId, @importedAt, @scope)
+       ON CONFLICT (provider, scope, source_session_id) DO UPDATE SET imported_at = excluded.imported_at`);
+    const insertEvent = this.db.prepare(`INSERT INTO events (session_id, role, content, tool_name, ordinal, ts)
+       VALUES (@sessionId, @role, @content, @toolName, @ordinal, @ts)`);
+    const insertCitation = this.db.prepare(`INSERT INTO citations (event_id, source_path, source_line)
+       VALUES (@eventId, @sourcePath, @sourceLine)
+       ON CONFLICT (event_id) DO UPDATE SET source_path = excluded.source_path, source_line = excluded.source_line`);
+    const deleteCitations = this.db.prepare(`DELETE FROM citations WHERE event_id IN (SELECT id FROM events WHERE session_id = ?)`);
+    const deleteEvents = this.db.prepare(`DELETE FROM events WHERE session_id = ?`);
+    const run = this.db.transaction(() => {
+      upsertSession.run({
+        id: sessionId,
+        provider,
+        sourceSessionId: result.session.sourceSessionId,
+        importedAt: result.session.importedAt,
+        scope: result.session.scope ?? ""
+      });
+      deleteCitations.run(sessionId);
+      deleteEvents.run(sessionId);
+      result.events.forEach((event, i) => {
+        const info = insertEvent.run({
+          sessionId,
+          role: event.role,
+          content: event.content,
+          toolName: event.toolName ?? null,
+          ordinal: event.ordinal,
+          ts: event.timestamp
+        });
+        const citation = result.citations[i];
+        if (citation) {
+          insertCitation.run({
+            eventId: info.lastInsertRowid,
+            sourcePath: citation.sourcePath,
+            sourceLine: citation.sourceLine ?? null
+          });
+        }
+      });
+    });
+    run();
+  }
+  getSession(id) {
+    const row = this.db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(id);
+    return row ? sessionFromRow(row) : null;
+  }
+  listSessions(options = {}) {
+    const clauses = [];
+    const params = [];
+    if (options.provider) {
+      clauses.push("provider = ?");
+      params.push(options.provider);
+    }
+    if (options.scope) {
+      clauses.push("scope = ?");
+      params.push(options.scope);
+    }
+    const where = clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "";
+    const rows = this.db.prepare(`SELECT * FROM sessions ${where} ORDER BY imported_at DESC`).all(...params);
+    return rows.map(sessionFromRow);
+  }
+  listEvents(sessionId) {
+    const rows = this.db.prepare(`SELECT * FROM events WHERE session_id = ? ORDER BY ordinal ASC`).all(sessionId);
+    return rows.map(eventFromRow);
+  }
+  getEvent(id) {
+    const row = this.db.prepare(`SELECT * FROM events WHERE id = ?`).get(id);
+    return row ? eventFromRow(row) : null;
+  }
+  /** Events immediately before/after `id` within the same session, `id` included. */
+  getEventWindow(id, window) {
+    const center = this.getEvent(id);
+    if (!center)
+      return [];
+    const rows = this.db.prepare(`SELECT * FROM events
+         WHERE session_id = ? AND ordinal BETWEEN ? AND ?
+         ORDER BY ordinal ASC`).all(center.sessionId, center.ordinal - window, center.ordinal + window);
+    return rows.map(eventFromRow);
+  }
+  getCitation(eventId) {
+    const row = this.db.prepare(`SELECT * FROM citations WHERE event_id = ?`).get(eventId);
+    return row ? { eventId: row.event_id, sourcePath: row.source_path, sourceLine: row.source_line ?? void 0 } : null;
+  }
+  /**
+   * Full-text search over event content. Session-diverse by default: at most `groupLimit`
+   * hits per session so one large session can't crowd out the rest of the result page.
+   *
+   * Scoped by default in spirit — callers (CLI, MCP skills) are expected to pass `scope`
+   * for project-aware providers so an agent working in one project never sees another
+   * project's imported history. Omitting `scope` searches across every scope.
+   */
+  search(query, options = {}) {
+    const limit = options.limit ?? 20;
+    const groupLimit = options.groupLimit ?? 3;
+    const clauses = ["fts.content MATCH @query"];
+    const params = { query };
+    if (options.sessionId) {
+      clauses.push("e.session_id = @sessionId");
+      params.sessionId = options.sessionId;
+    }
+    if (options.scope) {
+      clauses.push("s.scope = @scope");
+      params.scope = options.scope;
+    }
+    const rows = this.db.prepare(`SELECT e.*, rank AS score FROM events_fts fts
+         JOIN events e ON e.id = fts.rowid
+         JOIN sessions s ON s.id = e.session_id
+         WHERE ${clauses.join(" AND ")}
+         ORDER BY rank`).all(params);
+    const perSession = /* @__PURE__ */ new Map();
+    const sessionCache = /* @__PURE__ */ new Map();
+    const hits = [];
+    for (const row of rows) {
+      if (hits.length >= limit)
+        break;
+      const count = perSession.get(row.session_id) ?? 0;
+      if (count >= groupLimit)
+        continue;
+      let session = sessionCache.get(row.session_id);
+      if (session === void 0) {
+        session = this.getSession(row.session_id);
+        sessionCache.set(row.session_id, session);
+      }
+      if (!session)
+        continue;
+      perSession.set(row.session_id, count + 1);
+      hits.push({ event: eventFromRow(row), session, score: row.score });
+    }
+    return hits;
+  }
+  listCitations() {
+    const rows = this.db.prepare(`SELECT * FROM citations`).all();
+    return rows.map((r) => ({
+      eventId: r.event_id,
+      sourcePath: r.source_path,
+      sourceLine: r.source_line ?? void 0
+    }));
+  }
+  close() {
+    this.db.close();
+  }
+};
+
+// ../../packages/history/dist/skills.js
+function defaultHistoryDbPath() {
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? ".";
+  return `${home}/.omni-ai/history.db`;
+}
+function encodeProjectScope(absPath) {
+  return absPath.replace(/[^a-zA-Z0-9]/g, "-");
+}
+var searchHistorySkill = {
+  name: "search-history",
+  description: "Full-text search over already-imported third-party AI agent history (run `omni history import` first to populate it). Scoped to the caller's own project by default \u2014 pass allProjects:true to search every imported project.",
+  async execute(input5) {
+    const scope = input5.allProjects ? void 0 : input5.scope ?? encodeProjectScope(process.cwd());
+    const store = new HistoryStore({ path: defaultHistoryDbPath() });
+    try {
+      const hits = store.search(input5.query, { scope, limit: input5.limit });
+      return { scope: scope ?? null, hits };
+    } finally {
+      store.close();
+    }
+  }
+};
+var showEventSkill = {
+  name: "show-history-event",
+  description: "Show one imported history event with N events of surrounding context. Refuses events that belong to a different project scope than the caller's, unless allProjects:true is passed.",
+  async execute(input5) {
+    const store = new HistoryStore({ path: defaultHistoryDbPath() });
+    try {
+      const center = store.getEvent(input5.eventId);
+      if (!center)
+        return { events: [] };
+      if (!input5.allProjects) {
+        const session = store.getSession(center.sessionId);
+        const callerScope = encodeProjectScope(process.cwd());
+        if (session?.scope && session.scope !== callerScope) {
+          throw new Error(`Event ${input5.eventId} belongs to a different project scope ("${session.scope}"). Pass allProjects:true to override.`);
+        }
+      }
+      return { events: store.getEventWindow(input5.eventId, input5.window ?? 3) };
+    } finally {
+      store.close();
+    }
+  }
+};
+
+// ../../packages/history/dist/parsers/codex.js
+function defaultCodexRoot() {
+  return join5(homedir2(), ".codex", "sessions");
+}
+var CodexHistoryParser = class {
+  provider = "codex";
+  root;
+  constructor(options = {}) {
+    this.root = options.root ?? defaultCodexRoot();
+  }
+  async discover() {
+    const id = `${this.provider}:${this.root}`;
+    const base = {
+      id,
+      provider: this.provider,
+      path: this.root,
+      nativeImport: true
+    };
+    try {
+      const info = await stat2(this.root);
+      if (!info.isDirectory()) {
+        return [{ ...base, importable: false, reason: "path is not a directory" }];
+      }
+    } catch {
+      return [{ ...base, importable: false, reason: "history directory not found" }];
+    }
+    const files = await glob2("*.json", { cwd: this.root });
+    if (files.length === 0) {
+      return [{ ...base, importable: false, reason: "no session state files found" }];
+    }
+    return [{ ...base, importable: true }];
+  }
+  async import(source) {
+    const files = await glob2("*.json", { cwd: source.path, absolute: true });
+    const results = [];
+    for (const file of files) {
+      let parsed;
+      try {
+        parsed = JSON.parse(await readFile7(file, "utf-8"));
+      } catch {
+        continue;
+      }
+      const messages = Array.isArray(parsed.messages) ? parsed.messages : [];
+      const events = [];
+      const citations = [];
+      let ordinal = 0;
+      for (const m of messages) {
+        if (!m || typeof m.content !== "string" || !m.content)
+          continue;
+        const timestamp = typeof m.timestamp === "string" ? Date.parse(m.timestamp) : Number.NaN;
+        events.push({
+          role: m.role ?? "user",
+          content: m.content,
+          toolName: m.toolName,
+          ordinal: ordinal++,
+          timestamp: Number.isNaN(timestamp) ? Date.now() : timestamp
+        });
+        citations.push({ sourcePath: file });
+      }
+      if (events.length === 0)
+        continue;
+      const sourceSessionId = parsed.id ?? file.replace(/\.json$/, "").split(/[/\\]/).pop() ?? file;
+      const scope = parsed.cwd ? encodeProjectScope(parsed.cwd) : void 0;
+      results.push({
+        session: {
+          id: `${source.provider}:${scope ?? ""}:${sourceSessionId}`,
+          provider: source.provider,
+          sourceSessionId,
+          importedAt: Date.now(),
+          scope
+        },
+        events,
+        citations
+      });
+    }
+    return results;
+  }
+};
+
+// ../../packages/history/dist/registry.js
+var HistoryParserRegistry = class {
+  parsers = /* @__PURE__ */ new Map();
+  register(parser) {
+    this.parsers.set(parser.provider, parser);
+  }
+  get(provider) {
+    return this.parsers.get(provider);
+  }
+  list() {
+    return [...this.parsers.values()];
+  }
+};
+
+// ../../packages/cli/dist/commands/history/shared.js
+function getHistoryDbPath() {
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? ".";
+  return `${home}/.omni-ai/history.db`;
+}
+function buildHistoryRegistry() {
+  const registry = new HistoryParserRegistry();
+  registry.register(new ClaudeCodeHistoryParser());
+  registry.register(new CodexHistoryParser());
+  return registry;
+}
+function openHistoryStore() {
+  return new HistoryStore({ path: getHistoryDbPath() });
+}
+
+// ../../packages/cli/dist/commands/history/doctor.js
+async function historyDoctorCommand(opts) {
+  const store = openHistoryStore();
+  try {
+    const sources = store.listSources();
+    const sessions = store.listSessions();
+    const citations = store.listCitations();
+    const notImportable = sources.filter((s) => !s.importable);
+    const pathExists = /* @__PURE__ */ new Map();
+    let brokenCitations = 0;
+    for (const citation of citations) {
+      let exists = pathExists.get(citation.sourcePath);
+      if (exists === void 0) {
+        exists = existsSync(citation.sourcePath);
+        pathExists.set(citation.sourcePath, exists);
+      }
+      if (!exists)
+        brokenCitations++;
+    }
+    const report = {
+      sources: sources.length,
+      notImportable: notImportable.map((s) => ({ provider: s.provider, path: s.path, reason: s.reason })),
+      sessions: sessions.length,
+      events: citations.length,
+      brokenCitations
+    };
+    if (opts.json) {
+      console.log(JSON.stringify(report, null, 2));
+      return;
+    }
+    console.log(chalk5.bold("omni history doctor\n"));
+    console.log(`  sources:          ${report.sources}`);
+    console.log(`  not importable:   ${notImportable.length}`);
+    for (const s of notImportable) {
+      console.log(`    ${chalk5.yellow("-")} ${s.provider}: ${s.reason} (${s.path})`);
+    }
+    console.log(`  sessions:         ${report.sessions}`);
+    console.log(`  citations:        ${report.events}`);
+    console.log(`  broken citations: ${brokenCitations > 0 ? chalk5.yellow(String(brokenCitations)) : chalk5.green("0")}`);
+  } finally {
+    store.close();
+  }
+}
+
+// ../../packages/cli/dist/commands/history/import.js
+import { basename } from "path";
+import chalk6 from "chalk";
+async function historyImportCommand(opts) {
+  if (!opts.all && !opts.provider) {
+    console.error(chalk6.red("Specify --provider <name> or --all."));
+    process.exitCode = 1;
+    return;
+  }
+  if (opts.path && (!opts.provider || opts.all)) {
+    console.error(chalk6.red("--path requires a single --provider (not --all)."));
+    process.exitCode = 1;
+    return;
+  }
+  const registry = buildHistoryRegistry();
+  const parsers = opts.all ? registry.list() : (() => {
+    const parser = opts.provider ? registry.get(opts.provider) : void 0;
+    return parser ? [parser] : [];
+  })();
+  if (parsers.length === 0) {
+    const known = registry.list().map((p) => p.provider).join(", ");
+    console.error(chalk6.red(`Unknown provider: "${opts.provider}". Registered: ${known || "(none)"}`));
+    process.exitCode = 1;
+    return;
+  }
+  const store = openHistoryStore();
+  try {
+    for (const parser of parsers) {
+      const sources = opts.path ? [
+        {
+          id: `${parser.provider}:${opts.path}`,
+          provider: parser.provider,
+          path: opts.path,
+          nativeImport: true,
+          importable: true,
+          scope: basename(opts.path)
+        }
+      ] : await parser.discover();
+      for (const source of sources) {
+        store.upsertSource(source);
+        if (!source.importable) {
+          console.log(chalk6.yellow(`  - ${parser.provider}: skipped (${source.reason})`));
+          continue;
+        }
+        const results = await parser.import(source);
+        for (const result of results) {
+          store.saveImportResult(parser.provider, result.session.id, result);
+        }
+        const eventCount = results.reduce((n, r) => n + r.events.length, 0);
+        console.log(chalk6.green(`  \u2713 ${parser.provider}: imported ${results.length} session(s), ${eventCount} event(s)`));
+      }
+    }
+  } finally {
+    store.close();
+  }
+}
+
+// ../../packages/cli/dist/commands/history/locate.js
+import { existsSync as existsSync2 } from "fs";
+import chalk7 from "chalk";
+async function historyLocateEventCommand(id, opts) {
+  const store = openHistoryStore();
+  try {
+    const eventId = Number.parseInt(id, 10);
+    const event = store.getEvent(eventId);
+    if (!event) {
+      console.error(chalk7.red(`Event ${id} not found.`));
+      process.exitCode = 1;
+      return;
+    }
+    const citation = store.getCitation(eventId);
+    if (!citation) {
+      console.error(chalk7.yellow(`No citation recorded for event ${id}.`));
+      process.exitCode = 1;
+      return;
+    }
+    const exists = existsSync2(citation.sourcePath);
+    if (opts.json) {
+      console.log(JSON.stringify({ citation, exists }, null, 2));
+      return;
+    }
+    console.log(`${citation.sourcePath}${citation.sourceLine ? `:${citation.sourceLine}` : ""}`);
+    if (!exists)
+      console.log(chalk7.yellow("  ! source file no longer exists at this path"));
+  } finally {
+    store.close();
+  }
+}
+async function historyLocateSessionCommand(sessionId, opts) {
+  const store = openHistoryStore();
+  try {
+    const events = store.listEvents(sessionId);
+    if (events.length === 0) {
+      console.error(chalk7.red(`Session "${sessionId}" not found or has no events.`));
+      process.exitCode = 1;
+      return;
+    }
+    const citation = store.getCitation(events[0].id);
+    if (!citation) {
+      console.error(chalk7.yellow("No citation recorded for this session."));
+      process.exitCode = 1;
+      return;
+    }
+    const exists = existsSync2(citation.sourcePath);
+    if (opts.json) {
+      console.log(JSON.stringify({ citation, exists }, null, 2));
+      return;
+    }
+    console.log(citation.sourcePath);
+    if (!exists)
+      console.log(chalk7.yellow("  ! source file no longer exists at this path"));
+  } finally {
+    store.close();
+  }
+}
+
+// ../../packages/cli/dist/commands/history/search.js
+import chalk8 from "chalk";
+async function refresh(mode, store, scope) {
+  if (mode === "off")
+    return { mode, ran: false };
+  const registry = buildHistoryRegistry();
+  try {
+    for (const parser of registry.list()) {
+      const sources = await parser.discover();
+      const inScope = scope === void 0 ? sources : sources.filter((s) => s.scope === scope);
+      for (const source of inScope) {
+        store.upsertSource(source);
+        if (!source.importable)
+          continue;
+        const results = await parser.import(source);
+        for (const result of results)
+          store.saveImportResult(parser.provider, result.session.id, result);
+      }
+    }
+    return { mode, ran: true };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (mode === "strict")
+      throw new Error(message);
+    return { mode, ran: false, error: message };
+  }
+}
+function toFtsQuery(terms) {
+  return terms.map((t) => `"${t.replace(/"/g, '""')}"`).join(" ");
+}
+async function historySearchCommand(query, opts) {
+  const terms = opts.term && opts.term.length > 0 ? opts.term : query ? [query] : [];
+  if (terms.length === 0) {
+    console.error(chalk8.red('Provide a query, e.g. omni history search "retry handling", or repeatable --term.'));
+    process.exitCode = 1;
+    return;
+  }
+  const mode = opts.refresh ?? "auto";
+  const scope = opts.allProjects ? void 0 : opts.scope ?? encodeProjectScope(process.cwd());
+  const store = openHistoryStore();
+  try {
+    let freshness;
+    try {
+      freshness = await refresh(mode, store, scope);
+    } catch (err) {
+      console.error(chalk8.red(`Refresh failed (--refresh strict): ${err instanceof Error ? err.message : String(err)}`));
+      process.exitCode = 1;
+      return;
+    }
+    const hits = store.search(toFtsQuery(terms), {
+      sessionId: opts.session,
+      scope,
+      limit: opts.limit ? Number.parseInt(opts.limit, 10) : void 0
+    });
+    if (opts.json) {
+      console.log(JSON.stringify({ freshness, scope: scope ?? null, hits }, null, 2));
+      return;
+    }
+    if (freshness.error) {
+      console.log(chalk8.gray(`  (refresh skipped: ${freshness.error})
+`));
+    }
+    console.log(chalk8.gray(`  scope: ${scope ?? "(all projects)"}
+`));
+    if (hits.length === 0) {
+      console.log(chalk8.gray("No results."));
+      return;
+    }
+    for (const hit of hits) {
+      console.log(`${chalk8.cyan(`[${hit.session.provider}]`)} ${chalk8.gray(hit.session.id)} ${chalk8.gray(`#${hit.event.id}`)}`);
+      console.log(`  ${hit.event.content.slice(0, 200).replace(/\n/g, " ")}
+`);
+    }
+  } finally {
+    store.close();
+  }
+}
+
+// ../../packages/cli/dist/commands/history/show.js
+import { writeFile as writeFile5 } from "fs/promises";
+import chalk9 from "chalk";
+async function historyShowEventCommand(id, opts) {
+  const store = openHistoryStore();
+  try {
+    const eventId = Number.parseInt(id, 10);
+    const window = opts.window ? Number.parseInt(opts.window, 10) : 3;
+    const events = store.getEventWindow(eventId, window);
+    if (events.length === 0) {
+      console.error(chalk9.red(`Event ${id} not found.`));
+      process.exitCode = 1;
+      return;
+    }
+    for (const e of events) {
+      const marker = e.id === eventId ? chalk9.bold.cyan(">") : " ";
+      console.log(`${marker} ${chalk9.cyan(`#${e.id}`)} ${chalk9.gray(e.role.padEnd(10))} ${e.content.slice(0, 300)}`);
+    }
+  } finally {
+    store.close();
+  }
+}
+function formatSessionMarkdown(session, events) {
+  const lines = [
+    `# Session: ${session.provider} / ${session.sourceSessionId}`,
+    `_Imported: ${new Date(session.importedAt).toISOString()}_`,
+    ""
+  ];
+  for (const e of events) {
+    lines.push(`### ${e.role} \u2014 #${e.id}`, "", e.content, "");
+  }
+  return lines.join("\n");
+}
+function formatSessionText(session, events) {
+  const header = `Session: ${session.provider} / ${session.sourceSessionId}`;
+  return [header, "", ...events.map((e) => `[${e.role}] ${e.content}`)].join("\n\n");
+}
+async function historyShowSessionCommand(sessionId, opts) {
+  const store = openHistoryStore();
+  try {
+    const session = store.getSession(sessionId);
+    if (!session) {
+      console.error(chalk9.red(`Session "${sessionId}" not found.`));
+      process.exitCode = 1;
+      return;
+    }
+    const events = store.listEvents(sessionId);
+    const format = opts.format ?? "text";
+    const output = format === "markdown" ? formatSessionMarkdown(session, events) : formatSessionText(session, events);
+    if (opts.out) {
+      await writeFile5(opts.out, output, "utf-8");
+      console.log(chalk9.green(`Session exported to: ${opts.out}`));
+    } else {
+      console.log(output);
+    }
+  } finally {
+    store.close();
+  }
+}
+
+// ../../packages/cli/dist/commands/history/sources.js
+import chalk10 from "chalk";
+async function historySourcesCommand(opts) {
+  const registry = buildHistoryRegistry();
+  const sources = (await Promise.all(registry.list().map((p) => p.discover()))).flat();
+  if (opts.json) {
+    console.log(JSON.stringify({ sources }, null, 2));
+    return;
+  }
+  if (sources.length === 0) {
+    console.log(chalk10.gray("No known providers registered."));
+    return;
+  }
+  console.log(chalk10.bold(`Sources (${sources.length}):
+`));
+  for (const s of sources) {
+    const status = s.importable ? chalk10.green("importable") : chalk10.yellow(`not importable (${s.reason})`);
+    console.log(`  ${chalk10.cyan(s.provider.padEnd(14))} ${s.path}`);
+    console.log(`  ${" ".repeat(14)} scope=${s.scope ?? "(unscoped)"} native_import=${s.nativeImport} ${status}
+`);
+  }
+}
+
 // ../../packages/cli/dist/commands/init.js
-import { access, readFile as readFile6, writeFile as writeFile5 } from "fs/promises";
-import { dirname as dirname3, resolve as resolve9 } from "path";
+import { access, readFile as readFile8, writeFile as writeFile6 } from "fs/promises";
+import { dirname as dirname4, resolve as resolve9 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { checkbox, confirm, input, password, select } from "@inquirer/prompts";
-import chalk5 from "chalk";
-var __dirname = dirname3(fileURLToPath2(import.meta.url));
+import chalk11 from "chalk";
+var __dirname = dirname4(fileURLToPath2(import.meta.url));
 var OMNI_ROOT = resolve9(__dirname, "..", "..", "..", "..");
 var CONFIG_PATH = resolve9(OMNI_ROOT, "config", "omni-ai.yaml");
 var ENV_PATH = resolve9(OMNI_ROOT, ".env");
@@ -1176,7 +2051,7 @@ async function fileExists(path) {
 async function readEnvFile(path) {
   const map = /* @__PURE__ */ new Map();
   try {
-    const content = await readFile6(path, "utf-8");
+    const content = await readFile8(path, "utf-8");
     for (const line of content.split("\n")) {
       const trimmed = line.trim();
       if (!trimmed || trimmed.startsWith("#"))
@@ -1259,9 +2134,9 @@ agents:
 }
 async function setupCopilot() {
   console.log();
-  console.log(chalk5.dim("  Para obter seu token GitHub:"));
-  console.log(chalk5.dim("    gh auth login    # se ainda n\xE3o fez"));
-  console.log(chalk5.dim("    gh auth token    # mostra o token atual"));
+  console.log(chalk11.dim("  Para obter seu token GitHub:"));
+  console.log(chalk11.dim("    gh auth login    # se ainda n\xE3o fez"));
+  console.log(chalk11.dim("    gh auth token    # mostra o token atual"));
   console.log();
   const token = await password({
     message: "Cole seu GitHub token (ghp_... ou github_pat_...):",
@@ -1286,8 +2161,8 @@ async function setupCopilot() {
 }
 async function setupAnthropic() {
   console.log();
-  console.log(chalk5.dim("  Como obter: https://console.anthropic.com \u2192 API Keys \u2192 Create key"));
-  console.log(chalk5.dim("  Formato: sk-ant-api03-..."));
+  console.log(chalk11.dim("  Como obter: https://console.anthropic.com \u2192 API Keys \u2192 Create key"));
+  console.log(chalk11.dim("  Formato: sk-ant-api03-..."));
   console.log();
   const key = await password({
     message: "Cole sua Anthropic API key:",
@@ -1311,8 +2186,8 @@ async function setupAnthropic() {
 }
 async function setupOpenAI() {
   console.log();
-  console.log(chalk5.dim("  Como obter: https://platform.openai.com \u2192 API keys \u2192 Create new secret key"));
-  console.log(chalk5.dim("  Formato: sk-proj-... (novo) ou sk-... (legado)"));
+  console.log(chalk11.dim("  Como obter: https://platform.openai.com \u2192 API keys \u2192 Create new secret key"));
+  console.log(chalk11.dim("  Formato: sk-proj-... (novo) ou sk-... (legado)"));
   console.log();
   const key = await password({
     message: "Cole sua OpenAI API key:",
@@ -1337,10 +2212,10 @@ async function setupOpenAI() {
 }
 async function setupCustom() {
   console.log();
-  console.log(chalk5.dim("  Compat\xEDvel com qualquer endpoint OpenAI-like:"));
-  console.log(chalk5.dim("    Ollama:  http://localhost:11434/v1"));
-  console.log(chalk5.dim("    Groq:    https://api.groq.com/openai/v1"));
-  console.log(chalk5.dim("    Azure:   https://<resource>.openai.azure.com"));
+  console.log(chalk11.dim("  Compat\xEDvel com qualquer endpoint OpenAI-like:"));
+  console.log(chalk11.dim("    Ollama:  http://localhost:11434/v1"));
+  console.log(chalk11.dim("    Groq:    https://api.groq.com/openai/v1"));
+  console.log(chalk11.dim("    Azure:   https://<resource>.openai.azure.com"));
   console.log();
   const baseUrl = await input({
     message: "Base URL do endpoint:",
@@ -1392,16 +2267,16 @@ async function selectProvider(label) {
 }
 async function initCommand() {
   console.log();
-  console.log(chalk5.bold("  omni-ai \u2014 configura\xE7\xE3o inicial"));
-  console.log(chalk5.dim("  Isso vai criar config/omni-ai.yaml e atualizar o .env"));
+  console.log(chalk11.bold("  omni-ai \u2014 configura\xE7\xE3o inicial"));
+  console.log(chalk11.dim("  Isso vai criar config/omni-ai.yaml e atualizar o .env"));
   console.log();
   if (await fileExists(CONFIG_PATH)) {
     const overwrite = await confirm({
-      message: chalk5.yellow("config/omni-ai.yaml j\xE1 existe. Sobrescrever?"),
+      message: chalk11.yellow("config/omni-ai.yaml j\xE1 existe. Sobrescrever?"),
       default: false
     });
     if (!overwrite) {
-      console.log(chalk5.dim("\n  Opera\xE7\xE3o cancelada.\n"));
+      console.log(chalk11.dim("\n  Opera\xE7\xE3o cancelada.\n"));
       return;
     }
   }
@@ -1417,7 +2292,7 @@ async function initCommand() {
     if (second.name !== primary.name) {
       extras.push(second);
     } else {
-      console.log(chalk5.dim("  Mesmo provider \u2014 ignorado."));
+      console.log(chalk11.dim("  Mesmo provider \u2014 ignorado."));
     }
   }
   const agentSets = await checkbox({
@@ -1444,92 +2319,92 @@ async function initCommand() {
   const envTemplatePath = resolve9(OMNI_ROOT, ".env.example");
   let envTemplate = "";
   try {
-    envTemplate = await readFile6(envTemplatePath, "utf-8");
+    envTemplate = await readFile8(envTemplatePath, "utf-8");
   } catch {
     envTemplate = Array.from(envEntries.entries()).map(([k, v]) => `${k}=${v}`).join("\n");
   }
   const envContent = buildEnvFile(envEntries, envTemplate);
   const yamlContent = buildYaml(primary, extras);
-  await writeFile5(CONFIG_PATH, yamlContent, "utf-8");
-  await writeFile5(ENV_PATH, envContent, "utf-8");
+  await writeFile6(CONFIG_PATH, yamlContent, "utf-8");
+  await writeFile6(ENV_PATH, envContent, "utf-8");
   console.log();
-  console.log(`${chalk5.green("  \u2713")} config/omni-ai.yaml criado`);
-  console.log(`${chalk5.green("  \u2713")} .env atualizado`);
+  console.log(`${chalk11.green("  \u2713")} config/omni-ai.yaml criado`);
+  console.log(`${chalk11.green("  \u2713")} .env atualizado`);
   console.log();
-  console.log(chalk5.bold("  Pr\xF3ximos passos:"));
+  console.log(chalk11.bold("  Pr\xF3ximos passos:"));
   console.log();
-  console.log(chalk5.cyan("    omni list agents") + chalk5.dim("              # ver todos os agentes dispon\xEDveis"));
-  console.log(chalk5.cyan("    omni run code-reviewer") + chalk5.dim(' "revise src/app.ts"'));
+  console.log(chalk11.cyan("    omni list agents") + chalk11.dim("              # ver todos os agentes dispon\xEDveis"));
+  console.log(chalk11.cyan("    omni run code-reviewer") + chalk11.dim(' "revise src/app.ts"'));
   console.log();
   if (agentSets.includes("backend")) {
-    console.log(chalk5.cyan("    omni run backend-dev") + chalk5.dim(' "crie o m\xF3dulo de pedidos"'));
+    console.log(chalk11.cyan("    omni run backend-dev") + chalk11.dim(' "crie o m\xF3dulo de pedidos"'));
   }
   if (agentSets.includes("frontend")) {
-    console.log(chalk5.cyan("    omni run frontend-dev") + chalk5.dim(' "crie a p\xE1gina de listagem de pedidos"'));
+    console.log(chalk11.cyan("    omni run frontend-dev") + chalk11.dim(' "crie a p\xE1gina de listagem de pedidos"'));
   }
   if (agentSets.includes("ux")) {
-    console.log(chalk5.cyan("    omni run ux-lead") + chalk5.dim(' "audite o componente OrderForm"'));
+    console.log(chalk11.cyan("    omni run ux-lead") + chalk11.dim(' "audite o componente OrderForm"'));
   }
   if (agentSets.includes("qa")) {
-    console.log(chalk5.cyan("    omni run qa-lead") + chalk5.dim(' "valide src/orders/"'));
+    console.log(chalk11.cyan("    omni run qa-lead") + chalk11.dim(' "valide src/orders/"'));
   }
   console.log();
-  console.log(chalk5.dim("  Para usar de outro projeto:"));
-  console.log(chalk5.dim("    cd /caminho/para/meu-projeto"));
-  console.log(chalk5.cyan("    omni run backend-dev") + chalk5.dim(' "..."'));
+  console.log(chalk11.dim("  Para usar de outro projeto:"));
+  console.log(chalk11.dim("    cd /caminho/para/meu-projeto"));
+  console.log(chalk11.cyan("    omni run backend-dev") + chalk11.dim(' "..."'));
   console.log();
 }
 
 // ../../packages/cli/dist/commands/list.js
-import chalk6 from "chalk";
+import chalk12 from "chalk";
 async function listCommand(target, opts) {
   const configPath = opts.config ?? resolveConfigPath();
   if (target === "providers") {
     await import("../dist-Z76P5KV4.js");
     await import("../dist-KBUP5623.js");
     const names = getRegisteredProviders();
-    console.log(chalk6.bold("Registered providers:"));
+    console.log(chalk12.bold("Registered providers:"));
     for (const name of names) {
-      console.log(`  ${chalk6.cyan("\xB7")} ${name}`);
+      console.log(`  ${chalk12.cyan("\xB7")} ${name}`);
     }
     return;
   }
   const runtime = await createRuntime({ configPath }).catch(() => null);
   if (target === "agents") {
     if (!runtime) {
-      console.error(chalk6.red("Could not load config. Run from the omni-ai directory or pass --config."));
+      console.error(chalk12.red("Could not load config. Run from the omni-ai directory or pass --config."));
       process.exit(1);
     }
     const agents = await runtime.listAgents();
     if (agents.length === 0) {
-      console.log(chalk6.gray("No agents found."));
+      console.log(chalk12.gray("No agents found."));
       return;
     }
-    console.log(chalk6.bold(`Agents (${agents.length}):
+    console.log(chalk12.bold(`Agents (${agents.length}):
 `));
     for (const agent of agents) {
-      console.log(`  ${chalk6.cyan(agent.name.padEnd(30))} ${chalk6.gray(agent.description)}`);
+      console.log(`  ${chalk12.cyan(agent.name.padEnd(30))} ${chalk12.gray(agent.description)}`);
     }
     return;
   }
   if (target === "skills") {
     if (!runtime) {
-      console.error(chalk6.red("Could not load config."));
+      console.error(chalk12.red("Could not load config."));
       process.exit(1);
     }
     const skills2 = runtime.skills.all();
     if (skills2.length === 0) {
-      console.log(chalk6.gray("No skills registered."));
+      console.log(chalk12.gray("No skills registered."));
       return;
     }
-    console.log(chalk6.bold(`Skills (${skills2.length}):
+    console.log(chalk12.bold(`Skills (${skills2.length}):
 `));
     for (const skill of skills2) {
-      console.log(`  ${chalk6.yellow(skill.name.padEnd(25))} ${chalk6.gray(skill.description)}`);
+      console.log(`  ${chalk12.yellow(skill.name.padEnd(25))} ${chalk12.gray(skill.description)}`);
     }
     return;
   }
-  console.error(chalk6.red(`Unknown list target: "${target}". Use: agents | skills | providers`));
+  console.error(chalk12.red(`Unknown list target: "${target}". Use: agents | skills | providers`));
   process.exit(1);
 }
 
@@ -1583,7 +2458,7 @@ async function serveStdioMcp(skills2, options) {
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 
 // ../../packages/skills/dist/backend/analyze-dynamo-schema.js
-import { readFile as readFile7 } from "fs/promises";
+import { readFile as readFile9 } from "fs/promises";
 import { resolve as resolve10 } from "path";
 import { z as z13 } from "zod";
 var InputSchema12 = z13.object({
@@ -1651,7 +2526,7 @@ var analyzeDynamoSchemaSkill = {
   description: "Parse a OneTable *.model.ts file and extract the schema name, entity type, fields (with types and required flags), enums, and Typenames references. Use this before generating a service to understand the exact entity shape.",
   async execute(input5) {
     const { path } = InputSchema12.parse(input5);
-    const source = await readFile7(resolve10(path), "utf-8");
+    const source = await readFile9(resolve10(path), "utf-8");
     return {
       schemaName: extractSchemaName(source),
       entityType: extractEntityType(source),
@@ -1663,7 +2538,7 @@ var analyzeDynamoSchemaSkill = {
 };
 
 // ../../packages/skills/dist/backend/analyze-graphql-schema.js
-import { readFile as readFile8 } from "fs/promises";
+import { readFile as readFile10 } from "fs/promises";
 import { resolve as resolve11 } from "path";
 import { z as z14 } from "zod";
 var InputSchema13 = z14.object({
@@ -1705,7 +2580,7 @@ var analyzeGraphqlSchemaSkill = {
   description: "Parse a GraphQL SDL file and extract types, queries, mutations, inputs and enums. Use this before generating a resolver to understand what operations already exist and what the correct return types are.",
   async execute(input5) {
     const { path } = InputSchema13.parse(input5);
-    const source = await readFile8(resolve11(path), "utf-8");
+    const source = await readFile10(resolve11(path), "utf-8");
     return {
       types: extractTypes(source),
       queries: extractOperations(source, "Query"),
@@ -1717,7 +2592,7 @@ var analyzeGraphqlSchemaSkill = {
 };
 
 // ../../packages/skills/dist/backend/analyze-nestjs-module.js
-import { readFile as readFile9 } from "fs/promises";
+import { readFile as readFile11 } from "fs/promises";
 import { resolve as resolve12 } from "path";
 import { z as z15 } from "zod";
 var InputSchema14 = z15.object({
@@ -1739,7 +2614,7 @@ var analyzeNestjsModuleSkill = {
   description: "Parse a NestJS *.module.ts file and extract its imports, providers, exports and controllers. Use this to understand what a module exposes before adding new providers or resolving injection dependencies.",
   async execute(input5) {
     const { path } = InputSchema14.parse(input5);
-    const source = await readFile9(resolve12(path), "utf-8");
+    const source = await readFile11(resolve12(path), "utf-8");
     return {
       moduleName: extractModuleName(source),
       imports: extractArrayItems(source, "imports"),
@@ -1751,8 +2626,8 @@ var analyzeNestjsModuleSkill = {
 };
 
 // ../../packages/skills/dist/backend/find-code-pattern.js
-import { readdir as readdir4, readFile as readFile10 } from "fs/promises";
-import { join as join4 } from "path";
+import { readdir as readdir5, readFile as readFile12 } from "fs/promises";
+import { join as join6 } from "path";
 import { z as z16 } from "zod";
 var patternSuffixes = {
   service: [".service.ts"],
@@ -1770,7 +2645,7 @@ var InputSchema15 = z16.object({
 async function walkForPattern(dir, suffixes, results, max) {
   if (results.length >= max)
     return;
-  const entries = await readdir4(dir, { withFileTypes: true }).catch(() => null);
+  const entries = await readdir5(dir, { withFileTypes: true }).catch(() => null);
   if (!entries)
     return;
   for (const entry of entries) {
@@ -1778,11 +2653,11 @@ async function walkForPattern(dir, suffixes, results, max) {
       break;
     if (entry.name === "node_modules" || entry.name === "dist" || entry.name === ".git")
       continue;
-    const fullPath = join4(dir, entry.name);
+    const fullPath = join6(dir, entry.name);
     if (entry.isDirectory()) {
       await walkForPattern(fullPath, suffixes, results, max);
     } else if (entry.isFile() && suffixes.some((s) => entry.name.endsWith(s))) {
-      const content = await readFile10(fullPath, "utf-8");
+      const content = await readFile12(fullPath, "utf-8");
       results.push({ file: fullPath, content });
     }
   }
@@ -1800,7 +2675,7 @@ var findCodePatternSkill = {
 };
 
 // ../../packages/skills/dist/frontend/analyze-component.js
-import { readFile as readFile11 } from "fs/promises";
+import { readFile as readFile13 } from "fs/promises";
 import { resolve as resolve13 } from "path";
 import { z as z17 } from "zod";
 var InputSchema16 = z17.object({
@@ -1834,7 +2709,7 @@ var analyzeComponentSkill = {
   description: "Parse a React component file and extract its name, props interface, hooks used, named exports, and whether it has a default export. Use this to understand an existing component's contract before creating a related component or hook.",
   async execute(input5) {
     const { path } = InputSchema16.parse(input5);
-    const source = await readFile11(resolve13(path), "utf-8");
+    const source = await readFile13(resolve13(path), "utf-8");
     return {
       componentName: extractComponentName(source, path),
       propsInterface: extractPropsInterface(source),
@@ -1846,21 +2721,21 @@ var analyzeComponentSkill = {
 };
 
 // ../../packages/skills/dist/frontend/analyze-module-structure.js
-import { readdir as readdir5 } from "fs/promises";
-import { join as join5 } from "path";
+import { readdir as readdir6 } from "fs/promises";
+import { join as join7 } from "path";
 import { z as z18 } from "zod";
 var InputSchema17 = z18.object({
   directory: z18.string().describe("Root directory of the React module or feature folder")
 });
 async function collectFiles2(dir) {
-  const entries = await readdir5(dir, { withFileTypes: true }).catch(() => null);
+  const entries = await readdir6(dir, { withFileTypes: true }).catch(() => null);
   if (!entries)
     return [];
   const files = [];
   for (const entry of entries) {
     if (entry.name === "node_modules" || entry.name === "dist")
       continue;
-    const fullPath = join5(dir, entry.name);
+    const fullPath = join7(dir, entry.name);
     if (entry.isDirectory()) {
       files.push(...await collectFiles2(fullPath));
     } else if (entry.isFile() && /\.(tsx?|jsx?)$/.test(entry.name)) {
@@ -1899,8 +2774,8 @@ var analyzeModuleStructureSkill = {
 };
 
 // ../../packages/skills/dist/frontend/find-component-pattern.js
-import { readdir as readdir6, readFile as readFile12 } from "fs/promises";
-import { join as join6 } from "path";
+import { readdir as readdir7, readFile as readFile14 } from "fs/promises";
+import { join as join8 } from "path";
 import { z as z19 } from "zod";
 var patternFilters = {
   component: (name) => /^[A-Z]/.test(name) && (name.endsWith(".tsx") || name.endsWith(".ts")) && !name.includes(".spec."),
@@ -1916,7 +2791,7 @@ var InputSchema18 = z19.object({
 async function walkForComponent(dir, filter, results, max) {
   if (results.length >= max)
     return;
-  const entries = await readdir6(dir, { withFileTypes: true }).catch(() => null);
+  const entries = await readdir7(dir, { withFileTypes: true }).catch(() => null);
   if (!entries)
     return;
   for (const entry of entries) {
@@ -1924,11 +2799,11 @@ async function walkForComponent(dir, filter, results, max) {
       break;
     if (entry.name === "node_modules" || entry.name === "dist" || entry.name === ".git")
       continue;
-    const fullPath = join6(dir, entry.name);
+    const fullPath = join8(dir, entry.name);
     if (entry.isDirectory()) {
       await walkForComponent(fullPath, filter, results, max);
     } else if (entry.isFile() && filter(entry.name)) {
-      const content = await readFile12(fullPath, "utf-8");
+      const content = await readFile14(fullPath, "utf-8");
       results.push({ file: fullPath, content });
     }
   }
@@ -1946,8 +2821,8 @@ var findComponentPatternSkill = {
 };
 
 // ../../packages/skills/dist/qa/analyze-test-coverage.js
-import { readdir as readdir7 } from "fs/promises";
-import { join as join7 } from "path";
+import { readdir as readdir8 } from "fs/promises";
+import { join as join9 } from "path";
 import { z as z20 } from "zod";
 var InputSchema19 = z20.object({
   directory: z20.string().describe("Root directory to scan for source files and their tests"),
@@ -1955,14 +2830,14 @@ var InputSchema19 = z20.object({
   ignorePatterns: z20.array(z20.string()).default(["index.ts", "index.tsx", ".spec.", ".test.", ".d.ts", ".module.ts"]).describe("Substrings that mark files to skip (index, spec, declaration, module files)")
 });
 async function collectFiles3(dir, exts, ignore) {
-  const entries = await readdir7(dir, { withFileTypes: true }).catch(() => null);
+  const entries = await readdir8(dir, { withFileTypes: true }).catch(() => null);
   if (!entries)
     return [];
   const files = [];
   for (const entry of entries) {
     if (entry.name === "node_modules" || entry.name === "dist" || entry.name === ".git")
       continue;
-    const fullPath = join7(dir, entry.name);
+    const fullPath = join9(dir, entry.name);
     if (entry.isDirectory()) {
       files.push(...await collectFiles3(fullPath, exts, ignore));
     } else if (entry.isFile() && exts.some((e) => entry.name.endsWith(e)) && !ignore.some((p) => entry.name.includes(p) || fullPath.includes(p))) {
@@ -2005,8 +2880,8 @@ var analyzeTestCoverageSkill = {
 };
 
 // ../../packages/skills/dist/qa/find-test-pattern.js
-import { readdir as readdir8, readFile as readFile13 } from "fs/promises";
-import { join as join8 } from "path";
+import { readdir as readdir9, readFile as readFile15 } from "fs/promises";
+import { join as join10 } from "path";
 import { z as z21 } from "zod";
 var patternFilters2 = {
   service: (name) => name.endsWith(".service.spec.ts"),
@@ -2022,7 +2897,7 @@ var InputSchema20 = z21.object({
 async function walkForTests(dir, filter, results, max) {
   if (results.length >= max)
     return;
-  const entries = await readdir8(dir, { withFileTypes: true }).catch(() => null);
+  const entries = await readdir9(dir, { withFileTypes: true }).catch(() => null);
   if (!entries)
     return;
   for (const entry of entries) {
@@ -2030,11 +2905,11 @@ async function walkForTests(dir, filter, results, max) {
       break;
     if (entry.name === "node_modules" || entry.name === "dist" || entry.name === ".git")
       continue;
-    const fullPath = join8(dir, entry.name);
+    const fullPath = join10(dir, entry.name);
     if (entry.isDirectory()) {
       await walkForTests(fullPath, filter, results, max);
     } else if (entry.isFile() && filter(entry.name)) {
-      const content = await readFile13(fullPath, "utf-8");
+      const content = await readFile15(fullPath, "utf-8");
       results.push({ file: fullPath, content });
     }
   }
@@ -2052,7 +2927,7 @@ var findTestPatternSkill = {
 };
 
 // ../../packages/cli/dist/commands/mcp-serve.js
-import chalk7 from "chalk";
+import chalk13 from "chalk";
 var skills = [
   readFileSkill,
   writeFileSkill,
@@ -2073,32 +2948,34 @@ var skills = [
   analyzeComponentSkill,
   analyzeModuleStructureSkill,
   findTestPatternSkill,
-  analyzeTestCoverageSkill
+  analyzeTestCoverageSkill,
+  searchHistorySkill,
+  showEventSkill
 ];
 async function mcpServeCommand() {
-  process.stderr.write(chalk7.bold.cyan("\n\u25C6 omni mcp serve\n"));
-  process.stderr.write(chalk7.gray(`  Transport: stdio
+  process.stderr.write(chalk13.bold.cyan("\n\u25C6 omni mcp serve\n"));
+  process.stderr.write(chalk13.gray(`  Transport: stdio
 `));
-  process.stderr.write(chalk7.gray(`  Skills:    ${skills.length}
+  process.stderr.write(chalk13.gray(`  Skills:    ${skills.length}
 `));
-  process.stderr.write(chalk7.gray("\n  Waiting for MCP client connection\u2026\n\n"));
+  process.stderr.write(chalk13.gray("\n  Waiting for MCP client connection\u2026\n\n"));
   await serveStdioMcp(skills, { name: "omni-ai" });
   await new Promise(() => {
   });
 }
 
 // ../../packages/cli/dist/commands/new.js
-import { readFile as readFile14 } from "fs/promises";
-import { join as join12 } from "path";
+import { readFile as readFile16 } from "fs/promises";
+import { join as join14 } from "path";
 import { select as select4 } from "@inquirer/prompts";
-import chalk11 from "chalk";
+import chalk17 from "chalk";
 import YAML from "yaml";
 
 // ../../packages/cli/dist/commands/new/scaffold-agent.js
-import { access as access2, mkdir as mkdir2, writeFile as writeFile6 } from "fs/promises";
-import { join as join9, resolve as resolve14 } from "path";
+import { access as access2, mkdir as mkdir2, writeFile as writeFile7 } from "fs/promises";
+import { join as join11, resolve as resolve14 } from "path";
 import { checkbox as checkbox2, confirm as confirm2, input as input2, select as select2 } from "@inquirer/prompts";
-import chalk8 from "chalk";
+import chalk14 from "chalk";
 
 // ../../packages/cli/dist/commands/new/templates.js
 function kebabToPascal(s) {
@@ -2241,7 +3118,7 @@ var ALL_SKILLS = [
 ];
 async function writeAgentFile(params, agentsDir) {
   const dir = resolve14(process.cwd(), agentsDir, params.domain);
-  const filePath = join9(dir, `${params.domain}-${params.role}.yaml`);
+  const filePath = join11(dir, `${params.domain}-${params.role}.yaml`);
   const content = generateAgentYaml({
     name: `${params.domain}-${params.role}`,
     description: params.description,
@@ -2251,7 +3128,7 @@ async function writeAgentFile(params, agentsDir) {
     temperature: 0.3
   });
   await mkdir2(dir, { recursive: true });
-  await writeFile6(filePath, content, "utf-8");
+  await writeFile7(filePath, content, "utf-8");
   return filePath;
 }
 async function agentWizard(agentsDir) {
@@ -2283,38 +3160,38 @@ async function agentWizard(agentsDir) {
   });
   const outPath = resolve14(process.cwd(), agentsDir, domain, `${domain}-${role}.yaml`);
   console.log();
-  console.log(chalk8.dim(`  Destino: ${outPath}`));
+  console.log(chalk14.dim(`  Destino: ${outPath}`));
   let shouldWrite = true;
   try {
     await access2(outPath);
-    shouldWrite = await confirm2({ message: chalk8.yellow("Arquivo j\xE1 existe. Sobrescrever?"), default: false });
+    shouldWrite = await confirm2({ message: chalk14.yellow("Arquivo j\xE1 existe. Sobrescrever?"), default: false });
   } catch {
   }
   if (!shouldWrite) {
-    console.log(chalk8.dim("\n  Opera\xE7\xE3o cancelada.\n"));
+    console.log(chalk14.dim("\n  Opera\xE7\xE3o cancelada.\n"));
     return;
   }
   const filePath = await writeAgentFile({ domain, role, description, systemPrompt, skills: skills2 }, agentsDir);
   console.log();
-  console.log(`${chalk8.green("  \u2713")} Agente criado: ${chalk8.cyan(filePath)}`);
-  console.log(chalk8.dim("  Adicione ao omni-ai.yaml (se\xE7\xE3o agents:) ou coloque no agentsDir para uso autom\xE1tico."));
-  console.log(chalk8.dim(`  Testar: omni run ${domain}-${role} "sua tarefa aqui"`));
+  console.log(`${chalk14.green("  \u2713")} Agente criado: ${chalk14.cyan(filePath)}`);
+  console.log(chalk14.dim("  Adicione ao omni-ai.yaml (se\xE7\xE3o agents:) ou coloque no agentsDir para uso autom\xE1tico."));
+  console.log(chalk14.dim(`  Testar: omni run ${domain}-${role} "sua tarefa aqui"`));
   console.log();
 }
 
 // ../../packages/cli/dist/commands/new/scaffold-provider.js
-import { access as access3, mkdir as mkdir3, writeFile as writeFile7 } from "fs/promises";
-import { join as join10, resolve as resolve15 } from "path";
+import { access as access3, mkdir as mkdir3, writeFile as writeFile8 } from "fs/promises";
+import { join as join12, resolve as resolve15 } from "path";
 import { confirm as confirm3, input as input3 } from "@inquirer/prompts";
-import chalk9 from "chalk";
+import chalk15 from "chalk";
 async function writeProviderFiles(params, providersDir) {
   const dir = resolve15(process.cwd(), providersDir, `provider-${params.kebabName}`, "src");
   const packageDir = resolve15(process.cwd(), providersDir, `provider-${params.kebabName}`);
   const { indexTs, packageJson, tsconfigJson } = generateProviderFiles(params);
   await mkdir3(dir, { recursive: true });
-  await writeFile7(join10(dir, "index.ts"), indexTs, "utf-8");
-  await writeFile7(join10(packageDir, "package.json"), packageJson, "utf-8");
-  await writeFile7(join10(packageDir, "tsconfig.json"), tsconfigJson, "utf-8");
+  await writeFile8(join12(dir, "index.ts"), indexTs, "utf-8");
+  await writeFile8(join12(packageDir, "package.json"), packageJson, "utf-8");
+  await writeFile8(join12(packageDir, "tsconfig.json"), tsconfigJson, "utf-8");
   return packageDir;
 }
 async function providerWizard(providersDir) {
@@ -2332,43 +3209,43 @@ async function providerWizard(providersDir) {
   const hasEmbedding = await confirm3({ message: "Suporta embeddings?", default: false });
   const outDir = resolve15(process.cwd(), providersDir, `provider-${kebabName}`);
   console.log();
-  console.log(chalk9.dim(`  Destino: ${outDir}/`));
+  console.log(chalk15.dim(`  Destino: ${outDir}/`));
   let shouldWrite = true;
   try {
     await access3(outDir);
     shouldWrite = await confirm3({
-      message: chalk9.yellow(`packages/provider-${kebabName}/ j\xE1 existe. Sobrescrever arquivos?`),
+      message: chalk15.yellow(`packages/provider-${kebabName}/ j\xE1 existe. Sobrescrever arquivos?`),
       default: false
     });
   } catch {
   }
   if (!shouldWrite) {
-    console.log(chalk9.dim("\n  Opera\xE7\xE3o cancelada.\n"));
+    console.log(chalk15.dim("\n  Opera\xE7\xE3o cancelada.\n"));
     return;
   }
   const packageDir = await writeProviderFiles({ kebabName, displayName, hasVision, hasEmbedding }, providersDir);
   console.log();
-  console.log(`${chalk9.green("  \u2713")} Provider criado: ${chalk9.cyan(`${packageDir}/`)}`);
-  console.log(chalk9.dim("  Pr\xF3ximos passos:"));
-  console.log(chalk9.dim(`    1. Implemente complete() em src/index.ts`));
-  console.log(chalk9.dim(`    2. Adicione \xE0 raiz tsconfig.json \u2192 references: { path: "./${providersDir}/provider-${kebabName}" }`));
-  console.log(chalk9.dim(`    3. Importe em packages/cli/src/commands/run.ts: import "@omni-ai/provider-${kebabName}";`));
-  console.log(chalk9.dim(`    4. Adicione a chave de API ao .env.example`));
+  console.log(`${chalk15.green("  \u2713")} Provider criado: ${chalk15.cyan(`${packageDir}/`)}`);
+  console.log(chalk15.dim("  Pr\xF3ximos passos:"));
+  console.log(chalk15.dim(`    1. Implemente complete() em src/index.ts`));
+  console.log(chalk15.dim(`    2. Adicione \xE0 raiz tsconfig.json \u2192 references: { path: "./${providersDir}/provider-${kebabName}" }`));
+  console.log(chalk15.dim(`    3. Importe em packages/cli/src/commands/run.ts: import "@omni-ai/provider-${kebabName}";`));
+  console.log(chalk15.dim(`    4. Adicione a chave de API ao .env.example`));
   console.log();
 }
 
 // ../../packages/cli/dist/commands/new/scaffold-skill.js
-import { access as access4, mkdir as mkdir4, writeFile as writeFile8 } from "fs/promises";
-import { join as join11, resolve as resolve16 } from "path";
+import { access as access4, mkdir as mkdir4, writeFile as writeFile9 } from "fs/promises";
+import { join as join13, resolve as resolve16 } from "path";
 import { confirm as confirm4, input as input4, select as select3 } from "@inquirer/prompts";
-import chalk10 from "chalk";
+import chalk16 from "chalk";
 var DOMAINS = ["backend", "frontend", "qa", "fs", "git", "http", "multimodal", "ux"];
 async function writeSkillFile(params, skillsDir) {
   const dir = resolve16(process.cwd(), skillsDir, params.domain);
-  const filePath = join11(dir, `${params.kebabName}.ts`);
+  const filePath = join13(dir, `${params.kebabName}.ts`);
   const content = generateSkillTs({ kebabName: params.kebabName, description: params.description });
   await mkdir4(dir, { recursive: true });
-  await writeFile8(filePath, content, "utf-8");
+  await writeFile9(filePath, content, "utf-8");
   return filePath;
 }
 async function skillWizard(skillsDir) {
@@ -2387,24 +3264,24 @@ async function skillWizard(skillsDir) {
   });
   const outPath = resolve16(process.cwd(), skillsDir, domain, `${kebabName}.ts`);
   console.log();
-  console.log(chalk10.dim(`  Destino: ${outPath}`));
+  console.log(chalk16.dim(`  Destino: ${outPath}`));
   let shouldWrite = true;
   try {
     await access4(outPath);
-    shouldWrite = await confirm4({ message: chalk10.yellow("Arquivo j\xE1 existe. Sobrescrever?"), default: false });
+    shouldWrite = await confirm4({ message: chalk16.yellow("Arquivo j\xE1 existe. Sobrescrever?"), default: false });
   } catch {
   }
   if (!shouldWrite) {
-    console.log(chalk10.dim("\n  Opera\xE7\xE3o cancelada.\n"));
+    console.log(chalk16.dim("\n  Opera\xE7\xE3o cancelada.\n"));
     return;
   }
   const filePath = await writeSkillFile({ domain, kebabName, description }, skillsDir);
   console.log();
-  console.log(`${chalk10.green("  \u2713")} Skill criada: ${chalk10.cyan(filePath)}`);
-  console.log(chalk10.dim(`  Pr\xF3ximos passos:`));
-  console.log(chalk10.dim(`    1. Implemente a l\xF3gica em execute()`));
-  console.log(chalk10.dim(`    2. Exporte de ${skillsDir}/${domain}/index.ts`));
-  console.log(chalk10.dim(`    3. Registre em packages/cli/src/commands/run.ts`));
+  console.log(`${chalk16.green("  \u2713")} Skill criada: ${chalk16.cyan(filePath)}`);
+  console.log(chalk16.dim(`  Pr\xF3ximos passos:`));
+  console.log(chalk16.dim(`    1. Implemente a l\xF3gica em execute()`));
+  console.log(chalk16.dim(`    2. Exporte de ${skillsDir}/${domain}/index.ts`));
+  console.log(chalk16.dim(`    3. Registre em packages/cli/src/commands/run.ts`));
   console.log();
 }
 
@@ -2416,7 +3293,7 @@ var DEFAULTS = {
 };
 async function loadScaffoldConfig() {
   try {
-    const raw = await readFile14(join12(process.cwd(), "config", "omni-ai.yaml"), "utf-8");
+    const raw = await readFile16(join14(process.cwd(), "config", "omni-ai.yaml"), "utf-8");
     const data = YAML.parse(raw);
     if (!data)
       return DEFAULTS;
@@ -2432,8 +3309,8 @@ async function loadScaffoldConfig() {
 }
 async function newCommand() {
   console.log();
-  console.log(chalk11.bold("  omni new \u2014 scaffold interativo"));
-  console.log(chalk11.dim("  Cria um agente, skill ou provider a partir de template"));
+  console.log(chalk17.bold("  omni new \u2014 scaffold interativo"));
+  console.log(chalk17.dim("  Cria um agente, skill ou provider a partir de template"));
   const config = await loadScaffoldConfig();
   const type = await select4({
     message: "O que deseja criar?",
@@ -2457,7 +3334,7 @@ async function newCommand() {
 }
 
 // ../../packages/cli/dist/commands/run.js
-import { writeFile as writeFile9 } from "fs/promises";
+import { writeFile as writeFile10 } from "fs/promises";
 function parseSession(raw) {
   const [resourceId, ...rest] = raw.split(":");
   const threadId = rest.join(":") || "default";
@@ -2523,7 +3400,7 @@ ${result.output}
   }
   console.log(iterationLine(result.iterations));
   if (opts.output) {
-    await writeFile9(opts.output, result.output, "utf-8");
+    await writeFile10(opts.output, result.output, "utf-8");
     console.log(savedLine(opts.output));
   }
   if (result.usage) {
@@ -2534,7 +3411,7 @@ ${result.output}
 }
 
 // ../../packages/cli/dist/commands/serve.js
-import chalk12 from "chalk";
+import chalk18 from "chalk";
 import express from "express";
 function getDbPath3() {
   const home = process.env.HOME ?? process.env.USERPROFILE ?? ".";
@@ -2570,7 +3447,7 @@ async function serveCommand(opts) {
     analyzeTestCoverageSkill
   ];
   const runtime = await createRuntime({ configPath, skills: skills2 }).catch((err) => {
-    console.error(chalk12.red(`\u2716 Failed to load config: ${err instanceof Error ? err.message : String(err)}`));
+    console.error(chalk18.red(`\u2716 Failed to load config: ${err instanceof Error ? err.message : String(err)}`));
     process.exit(1);
   });
   const app = express();
@@ -2638,21 +3515,21 @@ async function serveCommand(opts) {
     }
   });
   app.listen(port, () => {
-    console.log(chalk12.bold.cyan(`
+    console.log(chalk18.bold.cyan(`
 \u25C6 omni serve`));
-    console.log(chalk12.gray(`  Listening on  http://localhost:${port}`));
-    console.log(chalk12.gray(`  GET  /health`));
-    console.log(chalk12.gray(`  GET  /agents`));
-    console.log(chalk12.gray(`  POST /run          \u2014 JSON response`));
-    console.log(chalk12.gray(`  POST /run/stream   \u2014 SSE stream`));
-    console.log(chalk12.gray("\n  Press Ctrl+C to stop.\n"));
+    console.log(chalk18.gray(`  Listening on  http://localhost:${port}`));
+    console.log(chalk18.gray(`  GET  /health`));
+    console.log(chalk18.gray(`  GET  /agents`));
+    console.log(chalk18.gray(`  POST /run          \u2014 JSON response`));
+    console.log(chalk18.gray(`  POST /run/stream   \u2014 SSE stream`));
+    console.log(chalk18.gray("\n  Press Ctrl+C to stop.\n"));
   });
   await new Promise(() => {
   });
 }
 
 // ../../packages/cli/dist/commands/watch.js
-import chalk13 from "chalk";
+import chalk19 from "chalk";
 import chokidar from "chokidar";
 function buildDebounce(fn, ms) {
   let timer = null;
@@ -2704,28 +3581,28 @@ ${result.output}
 }
 async function watchCommand(agent, prompt, opts) {
   const configPath = opts.config ?? resolveConfigPath();
-  const glob = opts.glob ?? "src/**/*.{ts,js,yaml,json}";
+  const glob3 = opts.glob ?? "src/**/*.{ts,js,yaml,json}";
   const debounceMs = opts.debounce ? Number.parseInt(opts.debounce, 10) : 500;
-  console.log(chalk13.bold.cyan(`
+  console.log(chalk19.bold.cyan(`
 \u25C6 omni watch`));
-  console.log(chalk13.gray(`  agent:    ${agent}`));
-  console.log(chalk13.gray(`  glob:     ${glob}`));
-  console.log(chalk13.gray(`  debounce: ${debounceMs}ms`));
-  console.log(chalk13.gray("  Press Ctrl+C to stop.\n"));
+  console.log(chalk19.gray(`  agent:    ${agent}`));
+  console.log(chalk19.gray(`  glob:     ${glob3}`));
+  console.log(chalk19.gray(`  debounce: ${debounceMs}ms`));
+  console.log(chalk19.gray("  Press Ctrl+C to stop.\n"));
   await runOnce(agent, prompt, configPath, opts.stream ?? false);
   const trigger = buildDebounce(async () => {
-    console.log(chalk13.gray(`
+    console.log(chalk19.gray(`
   \u21BB Rerunning ${agent}...`));
     await runOnce(agent, prompt, configPath, opts.stream ?? false);
   }, debounceMs);
-  const watcher = chokidar.watch(glob, { ignoreInitial: true, ignored: /node_modules/ });
+  const watcher = chokidar.watch(glob3, { ignoreInitial: true, ignored: /node_modules/ });
   watcher.on("change", (file) => {
-    console.log(chalk13.gray(`
+    console.log(chalk19.gray(`
   \u270E Changed: ${file}`));
     trigger();
   });
   watcher.on("add", (file) => {
-    console.log(chalk13.gray(`
+    console.log(chalk19.gray(`
   + Added: ${file}`));
     trigger();
   });
@@ -2733,7 +3610,7 @@ async function watchCommand(agent, prompt, opts) {
     console.error(errorLine(`Watcher error: ${err}`));
   });
   process.on("SIGINT", async () => {
-    console.log(chalk13.gray("\n\n  Stopping watcher..."));
+    console.log(chalk19.gray("\n\n  Stopping watcher..."));
     await watcher.close();
     process.exit(0);
   });
@@ -2742,7 +3619,7 @@ async function watchCommand(agent, prompt, opts) {
 }
 
 // ../../packages/cli/dist/bin.js
-var __dirname2 = dirname4(fileURLToPath3(import.meta.url));
+var __dirname2 = dirname5(fileURLToPath3(import.meta.url));
 loadDotenv({ path: resolve17(__dirname2, "..", "..", "..", ".env") });
 var program = new Command();
 program.name("omni").description("omni-ai \u2014 provider-agnostic AI agents for developer workflows").version("0.1.0");
@@ -2756,6 +3633,17 @@ program.command("serve").description("Start a local HTTP server to run agents vi
 program.command("eval <agent> <dataset>").description("Evaluate an agent against a dataset of (input, expected) pairs").option("-c, --config <path>", "Path to omni-ai.yaml").option("--concurrency <n>", "Number of parallel evaluations (default: 3)").option("-o, --output <file>", "Save JSON report to file").action(evalCommand);
 var mcp = program.command("mcp").description("MCP (Model Context Protocol) integration");
 mcp.command("serve").description("Expose all registered skills as MCP tools over stdio").option("-c, --config <path>", "Path to omni-ai.yaml").action(mcpServeCommand);
+var history = program.command("history").description("Import, search and inspect third-party AI agent history");
+history.command("sources").description("List known history providers and whether they're importable on this machine").option("--json", "Output as JSON").action(historySourcesCommand);
+history.command("import").description("Import history from one or all registered providers").option("--provider <name>", "Import a single provider").option("--all", "Import every registered provider").option("--path <path>", "Override the discovered path (requires --provider)").action(historyImportCommand);
+history.command("search [query]").description('Full-text search over imported history, e.g. omni history search "retry handling"').option("--term <term>", "Search term (repeatable)", (value, prev) => [...prev, value], []).option("--session <id>", "Restrict search to one session").option("--scope <name>", "Restrict search to one project scope (default: current directory's project)").option("--all-projects", "Search across every imported project, not just the current one").option("--limit <n>", "Max results (default: 20)").option("--refresh <mode>", "auto | off | strict (default: auto)").option("--json", "Output as JSON").action(historySearchCommand);
+var historyShow = history.command("show").description("Show one event (with context) or a full session");
+historyShow.command("event <id>").description("Show one event with surrounding context").option("--window <n>", "Events of context before/after (default: 3)").action(historyShowEventCommand);
+historyShow.command("session <sessionId>").description("Show a full session").option("-f, --format <format>", "text | markdown (default: text)").option("-o, --out <path>", "Write to a file instead of stdout").action(historyShowSessionCommand);
+var historyLocate = history.command("locate").description("Report the original source location for an event/session");
+historyLocate.command("event <id>").description("Locate the source file/line an event was imported from").option("--json", "Output as JSON").action(historyLocateEventCommand);
+historyLocate.command("session <sessionId>").description("Locate the source file a session was imported from").option("--json", "Output as JSON").action(historyLocateSessionCommand);
+history.command("doctor").description("Diagnose non-importable sources and broken citations").option("--json", "Output as JSON").action(historyDoctorCommand);
 var list = program.command("list").description("List available resources");
 list.command("agents").description("List all available agents").option("-c, --config <path>", "Path to omni-ai.yaml").action((opts) => listCommand("agents", opts));
 list.command("skills").description("List registered skills").option("-c, --config <path>", "Path to omni-ai.yaml").action((opts) => listCommand("skills", opts));