@ftarganski/omni-ai 0.1.0

package/dist/cli/bin.js

@@ -0,0 +1,2723 @@
+#!/usr/bin/env node
+import "../chunk-AG6NZIJ3.js";
+import "../chunk-Y4EYGADJ.js";
+import {
+  createRuntime,
+  getRegisteredProviders,
+  registerProvider
+} from "../chunk-AWMSN7OB.js";
+
+// ../cli/src/bin.ts
+import { dirname as dirname4, resolve as resolve17 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import { Command } from "commander";
+import { config as loadDotenv } from "dotenv";
+
+// ../provider-google/src/provider.ts
+import { GoogleGenerativeAI } from "@google/generative-ai";
+
+// ../provider-google/src/mappers.ts
+function toGeminiPart(part) {
+  if (part.type === "text") return { text: part.text };
+  return { inlineData: { mimeType: part.mimeType, data: part.data } };
+}
+function contentToParts(content) {
+  if (typeof content === "string") return [{ text: content }];
+  return content.map(toGeminiPart);
+}
+function extractSystemInstruction(request) {
+  const systemMsg = request.messages.find((m) => m.role === "system");
+  const raw = request.systemPrompt ?? systemMsg?.content;
+  if (raw === void 0) return void 0;
+  return typeof raw === "string" ? raw : raw.map((p) => p.type === "text" ? p.text : "").join("");
+}
+function toGeminiContents(messages) {
+  return messages.filter((m) => m.role !== "system").map((m) => ({
+    role: m.role === "assistant" ? "model" : "user",
+    parts: contentToParts(m.content)
+  }));
+}
+function toGeminiTools(tools) {
+  const functionDeclarations = tools.map((t) => ({
+    name: t.name,
+    description: t.description,
+    parameters: t.parameters
+  }));
+  return [{ functionDeclarations }];
+}
+function fromGeminiResponse(response, modelName, providerName) {
+  const candidate = response.candidates?.[0];
+  const parts = candidate?.content?.parts ?? [];
+  let content = "";
+  const toolCalls = [];
+  for (const part of parts) {
+    if ("text" in part && typeof part.text === "string") {
+      content += part.text;
+    } else if ("functionCall" in part && part.functionCall) {
+      toolCalls.push({
+        id: part.functionCall.name,
+        name: part.functionCall.name,
+        arguments: part.functionCall.args ?? {}
+      });
+    }
+  }
+  const usage = response.usageMetadata ? {
+    inputTokens: response.usageMetadata.promptTokenCount ?? 0,
+    outputTokens: response.usageMetadata.candidatesTokenCount ?? 0
+  } : void 0;
+  return {
+    content,
+    toolCalls: toolCalls.length > 0 ? toolCalls : void 0,
+    usage,
+    model: modelName,
+    provider: providerName
+  };
+}
+
+// ../provider-google/src/provider.ts
+var GoogleProvider = class {
+  name;
+  capabilities = {
+    chat: true,
+    embedding: true,
+    streaming: true,
+    toolUse: true,
+    vision: true
+  };
+  client;
+  defaultModel;
+  constructor(options) {
+    this.name = options.name ?? "google";
+    this.defaultModel = options.defaultModel ?? "gemini-2.0-flash";
+    this.client = new GoogleGenerativeAI(options.apiKey);
+  }
+  async complete(request) {
+    const modelName = request.model ?? this.defaultModel;
+    const systemInstruction = extractSystemInstruction(request);
+    const contents = toGeminiContents(request.messages);
+    const tools = request.tools && request.tools.length > 0 ? toGeminiTools(request.tools) : void 0;
+    const model = this.client.getGenerativeModel({
+      model: modelName,
+      systemInstruction,
+      tools,
+      generationConfig: {
+        temperature: request.temperature,
+        maxOutputTokens: request.maxTokens
+      }
+    });
+    if (request.onToken) {
+      const result2 = await model.generateContentStream({ contents });
+      let fullContent = "";
+      for await (const chunk of result2.stream) {
+        const text = chunk.text();
+        if (text) {
+          fullContent += text;
+          request.onToken(text);
+        }
+      }
+      const finalResponse = await result2.response;
+      const response = fromGeminiResponse(finalResponse, modelName, this.name);
+      return { ...response, content: fullContent };
+    }
+    const result = await model.generateContent({ contents });
+    return fromGeminiResponse(result.response, modelName, this.name);
+  }
+  async embed(request) {
+    const modelName = "text-embedding-004";
+    const model = this.client.getGenerativeModel({ model: modelName });
+    const inputs = Array.isArray(request.input) ? request.input : [request.input];
+    const embeddings = await Promise.all(
+      inputs.map(async (text) => {
+        const result = await model.embedContent(text);
+        return result.embedding.values;
+      })
+    );
+    return { embeddings, model: modelName, provider: this.name };
+  }
+};
+
+// ../provider-google/src/index.ts
+registerProvider("google", (config) => {
+  if (!config.apiKey) {
+    throw new Error(`Provider "${config.name}" (google) requires GOOGLE_API_KEY to be set in the environment.`);
+  }
+  return new GoogleProvider({
+    apiKey: config.apiKey,
+    defaultModel: config.defaultModel,
+    name: config.name
+  });
+});
+
+// ../cli/src/commands/chain.ts
+import { writeFile as writeFile2 } from "fs/promises";
+
+// ../skills/src/code/search-code.ts
+import { readdir, readFile } from "fs/promises";
+import { join } from "path";
+import { z } from "zod";
+var InputSchema = z.object({
+  directory: z.string().describe("Root directory to search in"),
+  pattern: z.string().describe("Text substring or regex pattern to search for"),
+  extensions: z.array(z.string()).default([".ts", ".tsx"]).describe("File extensions to include in the search"),
+  maxResults: z.number().int().positive().default(30).describe("Maximum number of matching lines to return"),
+  useRegex: z.boolean().default(false).describe("Treat pattern as a regular expression")
+});
+async function searchInFile(filePath, matcher, results, maxResults) {
+  if (results.length >= maxResults) return;
+  const text = await readFile(filePath, "utf-8");
+  const lines = text.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    if (results.length >= maxResults) break;
+    if (matcher(lines[i])) {
+      results.push({ file: filePath, line: i + 1, content: lines[i].trim() });
+    }
+  }
+}
+async function walkAndSearch(dir, extensions, matcher, results, maxResults) {
+  if (results.length >= maxResults) return;
+  const entries = await readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (results.length >= maxResults) break;
+    if (entry.name === "node_modules" || entry.name === "dist") continue;
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      await walkAndSearch(fullPath, extensions, matcher, results, maxResults);
+    } else if (entry.isFile() && extensions.some((ext) => entry.name.endsWith(ext))) {
+      await searchInFile(fullPath, matcher, results, maxResults);
+    }
+  }
+}
+var searchCodeSkill = {
+  name: "search-code",
+  description: "Search for a text pattern across TypeScript/TSX source files. Use this to find existing components, hooks, types or patterns before generating new code \u2014 avoiding duplicates and understanding existing conventions.",
+  async execute(input5) {
+    const { directory, pattern, extensions, maxResults, useRegex } = InputSchema.parse(input5);
+    let matcher;
+    if (useRegex) {
+      const re = new RegExp(pattern);
+      matcher = (line) => re.test(line);
+    } else {
+      matcher = (line) => line.includes(pattern);
+    }
+    const results = [];
+    await walkAndSearch(directory, extensions, matcher, results, maxResults);
+    return results;
+  }
+};
+
+// ../skills/src/fs/list-directory.ts
+import { readdir as readdir2 } from "fs/promises";
+import { join as join2, resolve, sep } from "path";
+import { z as z2 } from "zod";
+var InputSchema2 = z2.object({
+  path: z2.string().describe("Directory path to list"),
+  recursive: z2.boolean().default(false).describe("Whether to list files in subdirectories recursively"),
+  extensions: z2.array(z2.string()).optional().describe('Filter results by file extension, e.g. [".ts", ".tsx"]')
+});
+function assertSafePath(inputPath) {
+  const cwd = process.cwd();
+  const resolved = resolve(cwd, inputPath);
+  const cwdWithSep = cwd.endsWith(sep) ? cwd : cwd + sep;
+  if (resolved !== cwd && !resolved.startsWith(cwdWithSep)) {
+    throw new Error(`Access denied: "${inputPath}" resolves outside the working directory`);
+  }
+  return resolved;
+}
+async function walk(dir, recursive, extensions) {
+  const entries = await readdir2(dir, { withFileTypes: true });
+  const results = [];
+  for (const entry of entries) {
+    const fullPath = join2(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (recursive) {
+        results.push(...await walk(fullPath, recursive, extensions));
+      }
+    } else if (entry.isFile()) {
+      const include = !extensions || extensions.some((ext) => entry.name.endsWith(ext));
+      if (include) results.push(fullPath);
+    }
+  }
+  return results;
+}
+var listDirectorySkill = {
+  name: "list-directory",
+  description: "List files in a directory. Use this to discover existing components, pages or hooks before creating new ones, avoiding duplicates.",
+  async execute(input5) {
+    const { path, recursive, extensions } = InputSchema2.parse(input5);
+    const safePath = assertSafePath(path);
+    return await walk(safePath, recursive, extensions);
+  }
+};
+
+// ../skills/src/fs/read-file.ts
+import { readFile as readFile2 } from "fs/promises";
+import { resolve as resolve2, sep as sep2 } from "path";
+import { z as z3 } from "zod";
+var InputSchema3 = z3.object({
+  path: z3.string().describe("Absolute or relative path to the file to read")
+});
+function assertSafePath2(inputPath) {
+  const cwd = process.cwd();
+  const resolved = resolve2(cwd, inputPath);
+  const cwdWithSep = cwd.endsWith(sep2) ? cwd : cwd + sep2;
+  if (resolved !== cwd && !resolved.startsWith(cwdWithSep)) {
+    throw new Error(`Access denied: "${inputPath}" resolves outside the working directory`);
+  }
+  return resolved;
+}
+var readFileSkill = {
+  name: "read-file",
+  description: "Read the full text content of a file. Use this to inspect existing components, hooks, pages, config files or any source file before generating new code.",
+  async execute(input5) {
+    const { path } = InputSchema3.parse(input5);
+    const safePath = assertSafePath2(path);
+    return await readFile2(safePath, "utf-8");
+  }
+};
+
+// ../skills/src/fs/write-file.ts
+import { mkdir, writeFile } from "fs/promises";
+import { dirname, resolve as resolve3, sep as sep3 } from "path";
+import { z as z4 } from "zod";
+var InputSchema4 = z4.object({
+  path: z4.string().describe("Absolute or relative path where the file will be written"),
+  content: z4.string().describe("Full text content to write"),
+  createDirs: z4.boolean().default(true).describe("Create intermediate directories if they do not exist")
+});
+function assertSafePath3(inputPath) {
+  const cwd = process.cwd();
+  const resolved = resolve3(cwd, inputPath);
+  const cwdWithSep = cwd.endsWith(sep3) ? cwd : cwd + sep3;
+  if (resolved !== cwd && !resolved.startsWith(cwdWithSep)) {
+    throw new Error(`Access denied: "${inputPath}" resolves outside the working directory`);
+  }
+  return resolved;
+}
+var writeFileSkill = {
+  name: "write-file",
+  description: "Write or overwrite a file with the given content. Use this to create new components, hooks, pages or any source file after generating the code.",
+  async execute(input5) {
+    const { path, content, createDirs } = InputSchema4.parse(input5);
+    const safePath = assertSafePath3(path);
+    if (createDirs) {
+      await mkdir(dirname(safePath), { recursive: true });
+    }
+    await writeFile(safePath, content, "utf-8");
+    return `Written: ${safePath}`;
+  }
+};
+
+// ../skills/src/git/git-commit-message.ts
+import { resolve as resolve4 } from "path";
+import { z as z5 } from "zod";
+
+// ../skills/src/git/shared.ts
+import { spawn } from "child_process";
+function runGit(args, cwd) {
+  return new Promise((resolve18, reject) => {
+    const proc = spawn("git", args, { cwd, shell: false });
+    const stdout = [];
+    const stderr = [];
+    proc.stdout.on("data", (chunk) => stdout.push(chunk));
+    proc.stderr.on("data", (chunk) => stderr.push(chunk));
+    proc.on("close", (code) => {
+      if (code !== 0) {
+        reject(new Error(Buffer.concat(stderr).toString().trim() || `git ${args[0]} exited with code ${code}`));
+      } else {
+        resolve18(Buffer.concat(stdout).toString());
+      }
+    });
+    proc.on("error", reject);
+  });
+}
+
+// ../skills/src/git/git-commit-message.ts
+var InputSchema5 = z5.object({
+  cwd: z5.string().default(".").describe("Repository root directory"),
+  staged: z5.boolean().default(true).describe("Use staged diff (true) or full working-tree diff (false)"),
+  hint: z5.string().optional().describe("Optional free-text hint passed to the LLM, e.g. 'fix', 'feat', 'refactor'")
+});
+var SYSTEM = `You are an expert software engineer who writes concise, conventional commit messages.
+Rules:
+- Follow Conventional Commits: <type>(<scope>): <subject>
+- Subject line \u2264 72 chars, imperative mood, no trailing period
+- If changes span multiple concerns, add a short bullet body after a blank line
+- Output ONLY the commit message \u2014 no explanation, no markdown fences`;
+var gitCommitMessageSkill = {
+  name: "git-commit-message",
+  description: "Generate a conventional commit message for the current staged (or working-tree) changes using the configured LLM provider. Returns a ready-to-use commit message string.",
+  async execute(input5, ctx) {
+    const { cwd, staged, hint } = InputSchema5.parse(input5);
+    const dir = resolve4(cwd);
+    const diffArgs = ["diff"];
+    if (staged) diffArgs.push("--cached");
+    const diff = await runGit(diffArgs, dir);
+    if (!diff.trim()) {
+      return { message: "chore: no changes staged" };
+    }
+    const promptParts = [hint ? `Hint from the developer: ${hint}` : null, "--- GIT DIFF ---", diff.slice(0, 12e3)].filter(Boolean).join("\n");
+    const response = await ctx.provider.complete({
+      systemPrompt: SYSTEM,
+      messages: [{ role: "user", content: promptParts }],
+      temperature: 0.2,
+      maxTokens: 256
+    });
+    return { message: response.content.trim() };
+  }
+};
+
+// ../skills/src/git/git-diff.ts
+import { resolve as resolve5 } from "path";
+import { z as z6 } from "zod";
+var InputSchema6 = z6.object({
+  cwd: z6.string().default(".").describe("Repository root directory"),
+  staged: z6.boolean().default(false).describe("Show staged (cached) diff instead of working-tree diff"),
+  file: z6.string().optional().describe("Limit diff to a specific file path"),
+  base: z6.string().optional().describe("Base ref to diff from (e.g. 'main', 'HEAD~1')")
+});
+var gitDiffSkill = {
+  name: "git-diff",
+  description: "Return the unified diff of uncommitted changes (or staged changes). Use this to understand what code changed before writing a commit message or performing a code review.",
+  async execute(input5) {
+    const { cwd, staged, file, base } = InputSchema6.parse(input5);
+    const dir = resolve5(cwd);
+    const diffArgs = ["diff"];
+    if (staged) diffArgs.push("--cached");
+    if (base) diffArgs.push(base);
+    if (file) diffArgs.push("--", file);
+    const nameArgs = ["diff", "--name-only"];
+    if (staged) nameArgs.push("--cached");
+    if (base) nameArgs.push(base);
+    if (file) nameArgs.push("--", file);
+    const [diff, names] = await Promise.all([runGit(diffArgs, dir), runGit(nameArgs, dir)]);
+    const changedFiles = names.split("\n").map((l) => l.trim()).filter(Boolean);
+    return { diff, changedFiles };
+  }
+};
+
+// ../skills/src/git/git-log.ts
+import { resolve as resolve6 } from "path";
+import { z as z7 } from "zod";
+var InputSchema7 = z7.object({
+  cwd: z7.string().default(".").describe("Repository root directory"),
+  maxEntries: z7.number().int().positive().default(10).describe("Maximum number of commits to return"),
+  branch: z7.string().optional().describe("Branch or ref to read log from (defaults to HEAD)"),
+  since: z7.string().optional().describe("Show commits more recent than this date, e.g. '2 weeks ago'")
+});
+var SEP = "";
+var FORMAT = [`%H${SEP}%h${SEP}%an${SEP}%ai${SEP}%s`].join("");
+var gitLogSkill = {
+  name: "git-log",
+  description: "Return recent commit history with hash, author, date and subject. Use this to understand recent changes, find the last stable commit, or generate release notes.",
+  async execute(input5) {
+    const { cwd, maxEntries, branch, since } = InputSchema7.parse(input5);
+    const dir = resolve6(cwd);
+    const args = ["log", `--format=${FORMAT}`, `-n`, String(maxEntries)];
+    if (since) args.push(`--since=${since}`);
+    if (branch) args.push(branch);
+    const raw = await runGit(args, dir);
+    const commits = raw.split("\n").filter(Boolean).map((line) => {
+      const [hash, shortHash, author, date, ...rest] = line.split(SEP);
+      return { hash, shortHash, author, date, message: rest.join(SEP) };
+    });
+    return { commits };
+  }
+};
+
+// ../skills/src/git/git-status.ts
+import { resolve as resolve7 } from "path";
+import { z as z8 } from "zod";
+var InputSchema8 = z8.object({
+  cwd: z8.string().default(".").describe("Repository root directory (defaults to process.cwd())")
+});
+function parsePorcelain(raw) {
+  const staged = [];
+  const unstaged = [];
+  const untracked = [];
+  for (const line of raw.split("\n")) {
+    if (!line || line.startsWith("##")) continue;
+    const x = line[0];
+    const y = line[1];
+    const path = line.slice(3);
+    if (x === "?" && y === "?") {
+      untracked.push(path);
+    } else {
+      if (x !== " " && x !== "?") staged.push({ path, status: x });
+      if (y !== " " && y !== "?") unstaged.push({ path, status: y });
+    }
+  }
+  return { staged, unstaged, untracked };
+}
+var gitStatusSkill = {
+  name: "git-status",
+  description: "Return the current git working-tree status: staged changes, unstaged modifications, untracked files and the active branch. Use this before generating a commit message or reviewing pending changes.",
+  async execute(input5) {
+    const { cwd } = InputSchema8.parse(input5);
+    const dir = resolve7(cwd);
+    const [porcelain, branchRaw] = await Promise.all([
+      runGit(["status", "--porcelain", "-b"], dir),
+      runGit(["rev-parse", "--abbrev-ref", "HEAD"], dir)
+    ]);
+    const branch = branchRaw.trim();
+    const { staged, unstaged, untracked } = parsePorcelain(porcelain);
+    return { branch, staged, unstaged, untracked };
+  }
+};
+
+// ../skills/src/http/http-request.ts
+import { z as z9 } from "zod";
+var BearerAuthSchema = z9.object({
+  type: z9.literal("bearer"),
+  token: z9.string().describe("Bearer token value")
+});
+var BasicAuthSchema = z9.object({
+  type: z9.literal("basic"),
+  username: z9.string(),
+  password: z9.string()
+});
+var OAuth2ClientSchema = z9.object({
+  type: z9.literal("oauth2-client-credentials"),
+  tokenUrl: z9.string().url().describe("Token endpoint URL"),
+  clientId: z9.string(),
+  clientSecret: z9.string(),
+  scope: z9.string().optional().describe("Space-separated OAuth2 scopes")
+});
+var AuthSchema = z9.discriminatedUnion("type", [BearerAuthSchema, BasicAuthSchema, OAuth2ClientSchema]);
+var InputSchema9 = z9.object({
+  url: z9.string().url().describe("Target URL"),
+  method: z9.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD"]).default("GET").describe("HTTP method"),
+  headers: z9.record(z9.string()).optional().describe("Additional request headers"),
+  body: z9.union([z9.string(), z9.record(z9.unknown())]).optional().describe("Request body \u2014 string or JSON object"),
+  auth: AuthSchema.optional().describe("Authentication configuration"),
+  timeoutMs: z9.number().int().positive().default(3e4).describe("Request timeout in milliseconds")
+});
+async function resolveToken(auth) {
+  if (auth.type === "bearer") return `Bearer ${auth.token}`;
+  if (auth.type === "basic") {
+    const encoded = Buffer.from(`${auth.username}:${auth.password}`).toString("base64");
+    return `Basic ${encoded}`;
+  }
+  const params = new URLSearchParams({
+    grant_type: "client_credentials",
+    client_id: auth.clientId,
+    client_secret: auth.clientSecret
+  });
+  if (auth.scope) params.set("scope", auth.scope);
+  const tokenRes = await fetch(auth.tokenUrl, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: params.toString()
+  });
+  if (!tokenRes.ok) {
+    throw new Error(`OAuth2 token request failed: ${tokenRes.status} ${tokenRes.statusText}`);
+  }
+  const json = await tokenRes.json();
+  if (!json.access_token) throw new Error("OAuth2 response did not include access_token");
+  const tokenType = json.token_type ?? "Bearer";
+  return `${tokenType} ${json.access_token}`;
+}
+var httpRequestSkill = {
+  name: "http-request",
+  description: "Make an authenticated HTTP request to any URL. Supports Bearer token, HTTP Basic, and OAuth2 client-credentials flows. Returns status, headers and body. Use this to call external REST APIs from an agent.",
+  async execute(input5) {
+    const { url, method, headers: extraHeaders, body, auth, timeoutMs } = InputSchema9.parse(input5);
+    const headers = {
+      Accept: "application/json",
+      ...extraHeaders
+    };
+    if (auth) {
+      headers.Authorization = await resolveToken(auth);
+    }
+    let bodyStr;
+    if (body !== void 0) {
+      if (typeof body === "string") {
+        bodyStr = body;
+      } else {
+        bodyStr = JSON.stringify(body);
+        headers["Content-Type"] ??= "application/json";
+      }
+    }
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    let response;
+    try {
+      response = await fetch(url, {
+        method,
+        headers,
+        body: bodyStr,
+        signal: controller.signal
+      });
+    } finally {
+      clearTimeout(timer);
+    }
+    const responseHeaders = {};
+    response.headers.forEach((value, key) => {
+      responseHeaders[key] = value;
+    });
+    const responseBody = await response.text();
+    return {
+      status: response.status,
+      statusText: response.statusText,
+      headers: responseHeaders,
+      body: responseBody,
+      ok: response.ok
+    };
+  }
+};
+
+// ../skills/src/multimodal/analyze-image.ts
+import { readFile as readFile3 } from "fs/promises";
+import { extname } from "path";
+import { z as z10 } from "zod";
+var SUPPORTED_MIME = ["image/jpeg", "image/png", "image/gif", "image/webp"];
+var InputSchema10 = z10.object({
+  prompt: z10.string().describe("Question or instruction for the vision model, e.g. 'Describe this screenshot'"),
+  imagePath: z10.string().optional().describe("Absolute or relative path to an image file on disk"),
+  imageUrl: z10.string().url().optional().describe("Public URL of an image to fetch and analyse"),
+  imageBase64: z10.string().optional().describe("Base64-encoded image data (without data-URL prefix)"),
+  mimeType: z10.enum(SUPPORTED_MIME).optional().describe("MIME type \u2014 required when using imageBase64, inferred from extension otherwise")
+}).refine((d) => d.imagePath ?? d.imageUrl ?? d.imageBase64, {
+  message: "Provide exactly one of: imagePath, imageUrl, or imageBase64"
+});
+var EXT_TO_MIME = {
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".gif": "image/gif",
+  ".webp": "image/webp"
+};
+async function loadImage(input5) {
+  if (input5.imagePath) {
+    const ext = extname(input5.imagePath).toLowerCase();
+    const mimeType2 = input5.mimeType ?? EXT_TO_MIME[ext];
+    if (!mimeType2) throw new Error(`Unsupported image extension "${ext}". Use: ${Object.keys(EXT_TO_MIME).join(", ")}`);
+    const data = (await readFile3(input5.imagePath)).toString("base64");
+    return { data, mimeType: mimeType2 };
+  }
+  if (input5.imageUrl) {
+    const res = await fetch(input5.imageUrl);
+    if (!res.ok) throw new Error(`Failed to fetch image: ${res.status} ${res.statusText}`);
+    const contentType = res.headers.get("content-type") ?? "";
+    const mimeType2 = input5.mimeType ?? SUPPORTED_MIME.find((m) => contentType.startsWith(m));
+    if (!mimeType2) throw new Error(`Unsupported content-type "${contentType}"`);
+    const buffer = await res.arrayBuffer();
+    return { data: Buffer.from(buffer).toString("base64"), mimeType: mimeType2 };
+  }
+  const mimeType = input5.mimeType;
+  if (!mimeType) throw new Error("mimeType is required when supplying imageBase64");
+  return { data: input5.imageBase64, mimeType };
+}
+var analyzeImageSkill = {
+  name: "analyze-image",
+  description: "Analyse an image (screenshot, diagram, mockup, photo) using the configured vision-capable LLM provider. Accepts a file path, public URL, or raw base64 data. Returns a natural-language description or answer to your prompt.",
+  async execute(input5, ctx) {
+    const parsed = InputSchema10.parse(input5);
+    if (!ctx.provider.capabilities.vision) {
+      throw new Error(
+        `Provider "${ctx.provider.name}" does not support vision. Configure a vision-capable provider (e.g. Anthropic claude-3, OpenAI gpt-4o).`
+      );
+    }
+    const { data, mimeType } = await loadImage(parsed);
+    const imagePart = { type: "image", mimeType, data };
+    const response = await ctx.provider.complete({
+      messages: [
+        {
+          role: "user",
+          content: [imagePart, { type: "text", text: parsed.prompt }]
+        }
+      ],
+      temperature: 0.2
+    });
+    return { analysis: response.content };
+  }
+};
+
+// ../skills/src/ux/audit-accessibility.ts
+import { readdir as readdir3, readFile as readFile4 } from "fs/promises";
+import { join as join3 } from "path";
+import { z as z11 } from "zod";
+var InputSchema11 = z11.object({
+  path: z11.string().describe("File path (.tsx/.ts) or directory to audit recursively"),
+  recursive: z11.boolean().default(false).describe("Scan all .tsx files in the directory recursively")
+});
+var RULES = [
+  {
+    id: "img-missing-alt",
+    severity: "critical",
+    description: "<img> without alt attribute \u2014 screen readers will read the file name",
+    suggestion: 'Add alt="" for decorative images or alt="descriptive text" for informative ones',
+    pattern: /<img(?![^>]*\balt=)[^>]*/
+  },
+  {
+    id: "onclick-non-interactive",
+    severity: "critical",
+    description: "onClick on a non-interactive element (div/span/p) without role or tabIndex",
+    suggestion: 'Use <button> instead, or add role="button" tabIndex={0} onKeyDown handler',
+    pattern: /<(div|span|p|section|article)\s[^>]*onClick/,
+    isIssue: (_match, line) => !/role=["']button["']/.test(line) && !/tabIndex/.test(line)
+  },
+  {
+    id: "link-blank-no-rel",
+    severity: "moderate",
+    description: 'target="_blank" without rel="noopener noreferrer" \u2014 security risk and unexpected UX',
+    suggestion: 'Add rel="noopener noreferrer" to all target="_blank" links',
+    pattern: /target=["']_blank["']/,
+    isIssue: (_match, line) => !/rel=/.test(line)
+  },
+  {
+    id: "hardcoded-color",
+    severity: "moderate",
+    description: "Hardcoded Tailwind color scale class \u2014 will break dark mode and theme consistency",
+    suggestion: "Replace with shadcn/ui semantic tokens: bg-background, text-foreground, bg-muted, text-muted-foreground, border-border",
+    pattern: /className=[^>]*["'][^"']*\b(bg|text|border|ring|outline|fill|stroke)-(white|black|gray|zinc|slate|stone|neutral|red|orange|amber|yellow|lime|green|emerald|teal|cyan|sky|blue|indigo|violet|purple|fuchsia|pink|rose)-\d+[^"']*["']/
+  },
+  {
+    id: "icon-button-no-label",
+    severity: "critical",
+    description: "Button containing only an icon without aria-label \u2014 invisible to screen readers",
+    suggestion: 'Add aria-label="Descriptive action name" to the button',
+    pattern: /<button(?![^>]*aria-label)[^>]*>\s*<[A-Z][a-zA-Z]+\s*(?:size|className|strokeWidth)[^/]*\/>\s*<\/button>/
+  },
+  {
+    id: "input-missing-label",
+    severity: "critical",
+    description: "<input> or <Input> without aria-label, aria-labelledby, or associated <label>",
+    suggestion: "Wrap with Form.Item + Form.Label, or add aria-label directly to the input",
+    pattern: /<(?:input|Input)\s(?![^>]*(?:aria-label|aria-labelledby|id=))[^>]*/,
+    isIssue: (_match, _line, allLines, lineIndex) => {
+      const context = allLines.slice(Math.max(0, lineIndex - 5), lineIndex + 5).join("\n");
+      return !/<label|Form\.Label|htmlFor/.test(context);
+    }
+  },
+  {
+    id: "autofocus",
+    severity: "low",
+    description: "autoFocus used \u2014 can disorient screen reader users and break keyboard flow",
+    suggestion: "Manage focus programmatically with useEffect + ref.focus() only when truly needed (e.g. after modal opens)",
+    pattern: /\bautoFocus\b/
+  },
+  {
+    id: "inline-style",
+    severity: "low",
+    description: "Inline style attribute \u2014 bypasses theme system and cannot adapt to dark mode",
+    suggestion: "Replace with Tailwind utility classes or shadcn/ui semantic tokens",
+    pattern: /\bstyle=\{/
+  },
+  {
+    id: "no-focus-visible",
+    severity: "moderate",
+    description: "Interactive element may be missing focus-visible styles",
+    suggestion: "Ensure focus-visible:ring-2 focus-visible:ring-ring is present on all focusable elements",
+    pattern: /<(button|a|input|select|textarea|Input|Button|Link)[^>]*(?:className|class)=["'][^"']*["'][^>]*>/,
+    isIssue: (_match, line) => !/focus-visible/.test(line) && !/focus:ring/.test(line)
+  }
+];
+async function auditFile(filePath) {
+  const content = await readFile4(filePath, "utf-8");
+  const lines = content.split("\n");
+  const issues = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    for (const rule of RULES) {
+      rule.pattern.lastIndex = 0;
+      const match = rule.pattern.exec(line);
+      if (!match) continue;
+      const isIssue = rule.isIssue ? rule.isIssue(match, line, lines, i) : true;
+      if (!isIssue) continue;
+      issues.push({
+        file: filePath,
+        line: i + 1,
+        severity: rule.severity,
+        rule: rule.id,
+        description: rule.description,
+        suggestion: rule.suggestion,
+        snippet: line.trim().slice(0, 120)
+      });
+    }
+  }
+  return issues;
+}
+var MAX_DEPTH = 10;
+var MAX_FILES = 500;
+async function collectFiles(dir, recursive, depth = 0, results = []) {
+  if (depth > MAX_DEPTH || results.length >= MAX_FILES) return results;
+  const entries = await readdir3(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (results.length >= MAX_FILES) break;
+    if (entry.name === "node_modules" || entry.name === "dist") continue;
+    const full = join3(dir, entry.name);
+    if (entry.isDirectory() && recursive) {
+      await collectFiles(full, recursive, depth + 1, results);
+    } else if (entry.isFile() && (entry.name.endsWith(".tsx") || entry.name.endsWith(".ts"))) {
+      results.push(full);
+    }
+  }
+  return results;
+}
+var auditAccessibilitySkill = {
+  name: "audit-accessibility",
+  description: "Heuristic static scan of React TSX files for accessibility and dark-mode issues. Detects: missing alt, onClick on non-interactive elements, icon-only buttons without aria-label, inputs without labels, target=_blank without rel, hardcoded colors, missing focus-visible styles, autoFocus misuse, inline styles.",
+  async execute(input5) {
+    const { path, recursive } = InputSchema11.parse(input5);
+    let files;
+    try {
+      const entries = await readdir3(path);
+      files = await collectFiles(path, recursive ?? false);
+      void entries;
+    } catch {
+      files = [path];
+    }
+    const allIssues = [];
+    for (const file of files) {
+      allIssues.push(...await auditFile(file));
+    }
+    const critical = allIssues.filter((i) => i.severity === "critical").length;
+    const moderate = allIssues.filter((i) => i.severity === "moderate").length;
+    const low = allIssues.filter((i) => i.severity === "low").length;
+    return {
+      totalFiles: files.length,
+      totalIssues: allIssues.length,
+      critical,
+      moderate,
+      low,
+      issues: allIssues
+    };
+  }
+};
+
+// ../cli/src/commands/chain.ts
+import chalk2 from "chalk";
+
+// ../cli/src/utils/config-path.ts
+import { dirname as dirname2, resolve as resolve8 } from "path";
+import { fileURLToPath } from "url";
+function resolveConfigPath() {
+  const __dirname3 = dirname2(fileURLToPath(import.meta.url));
+  const omniRoot = resolve8(__dirname3, "..", "..", "..", "..");
+  return resolve8(omniRoot, "config", "omni-ai.yaml");
+}
+
+// ../cli/src/utils/format.ts
+import chalk from "chalk";
+function agentHeader(name, providerModel) {
+  return chalk.bold.cyan(`\u25C6 ${name}`) + chalk.gray(`  [${providerModel}]`);
+}
+function tokenSummary(inputTokens, outputTokens) {
+  const cost = ((inputTokens * 3 + outputTokens * 15) / 1e6).toFixed(4);
+  return chalk.gray(
+    `Tokens: ${inputTokens.toLocaleString("en-US")} entrada \xB7 ${outputTokens.toLocaleString("en-US")} sa\xEDda \xB7 ~$${cost}`
+  );
+}
+function iterationLine(n) {
+  return chalk.gray(`  ... (${n} itera\xE7${n === 1 ? "\xE3o" : "\xF5es"})`);
+}
+function errorLine(message) {
+  return chalk.red(`\u2716 ${message}`);
+}
+function savedLine(path) {
+  return chalk.green(`Output salvo em: ${path}`);
+}
+
+// ../cli/src/commands/chain.ts
+async function chainCommand(prompt, agents, opts) {
+  if (agents.length < 2) {
+    console.error(errorLine("omni chain requires at least 2 agents"));
+    process.exit(1);
+  }
+  const configPath = opts.config ?? resolveConfigPath();
+  const skills2 = [
+    readFileSkill,
+    writeFileSkill,
+    listDirectorySkill,
+    searchCodeSkill,
+    auditAccessibilitySkill,
+    gitStatusSkill,
+    gitDiffSkill,
+    gitLogSkill,
+    gitCommitMessageSkill,
+    httpRequestSkill,
+    analyzeImageSkill
+  ];
+  const runtime = await createRuntime({ configPath, skills: skills2 }).catch((err) => {
+    console.error(errorLine(`Failed to load config: ${err instanceof Error ? err.message : String(err)}`));
+    process.exit(1);
+  });
+  const providerLabel = `${runtime.config.defaultProvider} / ${runtime.config.providers.find((p) => p.name === runtime.config.defaultProvider)?.defaultModel ?? "default"}`;
+  const onToken = opts.stream ? (chunk) => process.stdout.write(chunk) : void 0;
+  let currentInput = prompt;
+  let totalInput = 0;
+  let totalOutput = 0;
+  let lastOutput = "";
+  console.log();
+  for (let i = 0; i < agents.length; i++) {
+    const agentName = agents[i];
+    console.log(agentHeader(agentName, providerLabel));
+    if (opts.stream) process.stdout.write("\n");
+    const result = await runtime.run(agentName, currentInput, { onToken }).catch((err) => {
+      console.error(errorLine(err instanceof Error ? err.message : String(err)));
+      process.exit(1);
+    });
+    if (opts.stream) {
+      process.stdout.write("\n");
+    } else if (opts.verbose) {
+      console.log(`
+${result.output}
+`);
+    }
+    console.log(iterationLine(result.iterations));
+    if (result.usage) {
+      totalInput += result.usage.inputTokens;
+      totalOutput += result.usage.outputTokens;
+    }
+    lastOutput = result.output;
+    currentInput = result.output;
+    if (i < agents.length - 1) {
+      console.log(`${chalk2.gray(`
+  \u2193  sa\xEDda passada para: `) + chalk2.cyan(agents[i + 1])}
+`);
+    }
+  }
+  if (!opts.stream && !opts.verbose) {
+    console.log(`
+${lastOutput}
+`);
+  }
+  if (opts.output) {
+    await writeFile2(opts.output, lastOutput, "utf-8");
+    console.log(savedLine(opts.output));
+  }
+  if (totalInput > 0 || totalOutput > 0) {
+    console.log(tokenSummary(totalInput, totalOutput));
+  }
+  console.log();
+}
+
+// ../cli/src/commands/eval.ts
+import { readFile as readFile5, writeFile as writeFile3 } from "fs/promises";
+import chalk3 from "chalk";
+function normalize(s) {
+  return s.trim().toLowerCase().replace(/\s+/g, " ");
+}
+function matchCase(expected, actual) {
+  const normExpected = normalize(expected);
+  const normActual = normalize(actual);
+  if (normActual === normExpected) return "exact";
+  if (normActual.includes(normExpected)) return "contains";
+  return "miss";
+}
+function buildReport(agent, results) {
+  const passed = results.filter((r) => r.match !== "miss").length;
+  return {
+    agent,
+    total: results.length,
+    passed,
+    score: results.length > 0 ? passed / results.length : 0,
+    cases: results
+  };
+}
+async function runBatch(cases, runFn, concurrency, onResult) {
+  const results = [];
+  let index = 0;
+  while (index < cases.length) {
+    const batch = cases.slice(index, index + concurrency);
+    const batchResults = await Promise.all(batch.map(runFn));
+    for (const r of batchResults) {
+      results.push(r);
+      onResult(r, results.length, cases.length);
+    }
+    index += concurrency;
+  }
+  return results;
+}
+async function evalCommand(agent, datasetPath, opts) {
+  const configPath = opts.config ?? resolveConfigPath();
+  const concurrency = opts.concurrency ? Number.parseInt(opts.concurrency, 10) : 3;
+  let cases;
+  try {
+    const raw = await readFile5(datasetPath, "utf-8");
+    cases = JSON.parse(raw);
+  } catch (err) {
+    console.error(errorLine(`Failed to read dataset: ${err instanceof Error ? err.message : String(err)}`));
+    process.exit(1);
+  }
+  if (!Array.isArray(cases) || cases.length === 0) {
+    console.error(errorLine("Dataset must be a non-empty JSON array of { input, expected } objects."));
+    process.exit(1);
+  }
+  const skills2 = [readFileSkill, writeFileSkill, listDirectorySkill, searchCodeSkill];
+  const runtime = await createRuntime({ configPath, skills: skills2 }).catch((err) => {
+    console.error(errorLine(`Failed to load config: ${err instanceof Error ? err.message : String(err)}`));
+    process.exit(1);
+  });
+  const providerLabel = `${runtime.config.defaultProvider} / ${runtime.config.providers.find((p) => p.name === runtime.config.defaultProvider)?.defaultModel ?? "default"}`;
+  console.log(`
+${agentHeader(agent, providerLabel)}`);
+  console.log(chalk3.gray(`  Dataset: ${datasetPath} (${cases.length} cases, concurrency ${concurrency})
+`));
+  const matchSymbol = (m) => {
+    if (m === "exact") return chalk3.green("\u2713");
+    if (m === "contains") return chalk3.yellow("~");
+    return chalk3.red("\u2716");
+  };
+  const results = await runBatch(
+    cases,
+    async (c) => {
+      const result = await runtime.run(agent, c.input).catch((err) => ({
+        output: `ERROR: ${err instanceof Error ? err.message : String(err)}`,
+        iterations: 0
+      }));
+      const match = matchCase(c.expected, result.output);
+      return { input: c.input, expected: c.expected, actual: result.output, match };
+    },
+    concurrency,
+    (r, done, total) => {
+      console.log(`  ${matchSymbol(r.match)}  ${String(done).padStart(String(total).length)}/${total}  [${r.match}]`);
+    }
+  );
+  const report = buildReport(agent, results);
+  const scoreColor = report.score >= 0.8 ? chalk3.green : report.score >= 0.5 ? chalk3.yellow : chalk3.red;
+  const misses = report.total - report.passed;
+  console.log(
+    `
+${chalk3.bold("Resultado:")} ${scoreColor(`${report.passed}/${report.total} (${Math.round(report.score * 100)}%)`)}  \xB7 ${misses === 0 ? chalk3.green("0 erros") : chalk3.red(`${misses} erros`)}
+`
+  );
+  if (opts.output) {
+    await writeFile3(opts.output, JSON.stringify(report, null, 2), "utf-8");
+    console.log(chalk3.green(`Report saved to: ${opts.output}`));
+  }
+}
+
+// ../cli/src/commands/export.ts
+import { writeFile as writeFile4 } from "fs/promises";
+
+// ../memory/src/stores/sqlite.ts
+import Database from "better-sqlite3";
+var SQLiteMemoryStore = class {
+  db;
+  defaultLimit;
+  constructor(options = {}) {
+    const path = options.path ?? "./omni-ai-memory.db";
+    this.defaultLimit = options.defaultLimit ?? 100;
+    this.db = new Database(path);
+    this.db.pragma("journal_mode = WAL");
+    this.migrate();
+  }
+  migrate() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS messages (
+        id          INTEGER PRIMARY KEY AUTOINCREMENT,
+        resource_id TEXT    NOT NULL,
+        thread_id   TEXT    NOT NULL,
+        role        TEXT    NOT NULL,
+        content     TEXT    NOT NULL,
+        timestamp   INTEGER NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_messages_session
+        ON messages (resource_id, thread_id, id);
+
+      CREATE VIRTUAL TABLE IF NOT EXISTS messages_fts USING fts5(
+        content,
+        content='messages',
+        content_rowid='id'
+      );
+
+      CREATE TRIGGER IF NOT EXISTS messages_ai AFTER INSERT ON messages BEGIN
+        INSERT INTO messages_fts (rowid, content) VALUES (new.id, new.content);
+      END;
+
+      CREATE TABLE IF NOT EXISTS working_memory (
+        resource_id TEXT NOT NULL,
+        thread_id   TEXT NOT NULL,
+        content     TEXT NOT NULL,
+        updated_at  INTEGER NOT NULL,
+        PRIMARY KEY (resource_id, thread_id)
+      );
+    `);
+  }
+  async saveMessages(session, messages) {
+    const insert = this.db.prepare(
+      `INSERT INTO messages (resource_id, thread_id, role, content, timestamp)
+       VALUES (@resourceId, @threadId, @role, @content, @timestamp)`
+    );
+    const insertMany = this.db.transaction((entries) => {
+      for (const e of entries) {
+        insert.run({ ...session, role: e.role, content: e.content, timestamp: e.timestamp });
+      }
+    });
+    insertMany(messages);
+  }
+  async loadMessages(session, limit) {
+    const n = limit ?? this.defaultLimit;
+    const rows = this.db.prepare(
+      `SELECT role, content, timestamp FROM (
+         SELECT role, content, timestamp FROM messages
+         WHERE resource_id = ? AND thread_id = ?
+         ORDER BY id DESC LIMIT ?
+       ) ORDER BY timestamp ASC`
+    ).all(session.resourceId, session.threadId, n);
+    return rows;
+  }
+  async search(session, query, topK = 5) {
+    const rows = this.db.prepare(
+      `SELECT m.content, rank AS score
+       FROM messages_fts fts
+       JOIN messages m ON m.id = fts.rowid
+       WHERE fts.content MATCH ?
+         AND m.resource_id = ? AND m.thread_id = ?
+       ORDER BY rank LIMIT ?`
+    ).all(query, session.resourceId, session.threadId, topK);
+    return rows.map((r) => ({ content: r.content, score: r.score }));
+  }
+  async getWorkingMemory(session) {
+    const row = this.db.prepare(`SELECT content FROM working_memory WHERE resource_id = ? AND thread_id = ?`).get(session.resourceId, session.threadId);
+    return row?.content ?? null;
+  }
+  async setWorkingMemory(session, content) {
+    this.db.prepare(
+      `INSERT INTO working_memory (resource_id, thread_id, content, updated_at)
+       VALUES (?, ?, ?, ?)
+       ON CONFLICT (resource_id, thread_id) DO UPDATE SET content = excluded.content, updated_at = excluded.updated_at`
+    ).run(session.resourceId, session.threadId, content, Date.now());
+  }
+  async close() {
+    this.db.close();
+  }
+};
+
+// ../cli/src/commands/export.ts
+import chalk4 from "chalk";
+function getDbPath() {
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? ".";
+  return `${home}/.omni-ai/sessions.db`;
+}
+function formatAsMarkdown(session, messages) {
+  const lines = [
+    `# Session: ${session.resourceId} / ${session.threadId}`,
+    `_Exported: ${(/* @__PURE__ */ new Date()).toISOString()}_`,
+    ""
+  ];
+  for (const msg of messages) {
+    const ts = new Date(msg.timestamp).toISOString();
+    const label = msg.role === "user" ? chalk4.cyan("**user**") : chalk4.yellow("**assistant**");
+    lines.push(`### ${label} \u2014 ${ts}`);
+    lines.push("");
+    lines.push(msg.content);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function formatAsJson(session, messages) {
+  return JSON.stringify({ session, messages }, null, 2);
+}
+async function exportCommand(sessionArg, opts) {
+  const [resourceId, ...rest] = sessionArg.split(":");
+  const threadId = rest.join(":") || "default";
+  const session = { resourceId, threadId };
+  const limit = opts.limit ? Number.parseInt(opts.limit, 10) : void 0;
+  const format = opts.format ?? "markdown";
+  const store = new SQLiteMemoryStore({ path: getDbPath() });
+  let messages;
+  try {
+    messages = await store.loadMessages(session, limit);
+  } finally {
+    await store.close?.();
+  }
+  if (messages.length === 0) {
+    console.log(chalk4.gray(`No messages found for session "${sessionArg}".`));
+    return;
+  }
+  const output = format === "json" ? formatAsJson(session, messages) : formatAsMarkdown(session, messages);
+  if (opts.output) {
+    await writeFile4(opts.output, output, "utf-8");
+    console.log(chalk4.green(`Session exported to: ${opts.output}`));
+  } else {
+    console.log(output);
+  }
+  console.log(chalk4.gray(`
+${messages.length} message(s) exported.`));
+}
+
+// ../cli/src/commands/init.ts
+import { access, readFile as readFile6, writeFile as writeFile5 } from "fs/promises";
+import { dirname as dirname3, 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));
+var OMNI_ROOT = resolve9(__dirname, "..", "..", "..", "..");
+var CONFIG_PATH = resolve9(OMNI_ROOT, "config", "omni-ai.yaml");
+var ENV_PATH = resolve9(OMNI_ROOT, ".env");
+async function fileExists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readEnvFile(path) {
+  const map = /* @__PURE__ */ new Map();
+  try {
+    const content = await readFile6(path, "utf-8");
+    for (const line of content.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) continue;
+      const eq = trimmed.indexOf("=");
+      if (eq === -1) continue;
+      map.set(trimmed.slice(0, eq).trim(), trimmed.slice(eq + 1).trim());
+    }
+  } catch {
+  }
+  return map;
+}
+function buildEnvFile(entries, template) {
+  const lines = template.split("\n");
+  const written = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed && !trimmed.startsWith("#")) {
+      const eq = trimmed.indexOf("=");
+      if (eq !== -1) {
+        const key = trimmed.slice(0, eq).trim();
+        const value = entries.get(key) ?? "";
+        result.push(`${key}=${value}`);
+        written.add(key);
+        continue;
+      }
+    }
+    result.push(line);
+  }
+  for (const [key, value] of entries) {
+    if (!written.has(key)) {
+      result.push(`${key}=${value}`);
+    }
+  }
+  return result.join("\n");
+}
+function buildYaml(primary, extras) {
+  const allProviders = [primary, ...extras];
+  const providerBlocks = allProviders.map((p) => {
+    const lines = [`  - name: ${p.name}`, `    type: ${p.type}`, `    apiKey: \${${p.envKey}}`];
+    if (p.baseUrl) lines.push(`    baseUrl: ${p.baseUrl}`);
+    lines.push(`    defaultModel: ${p.defaultModel}`);
+    return lines.join("\n");
+  }).join("\n\n");
+  return `version: "1"
+
+# Provider padr\xE3o \u2014 todos os agentes herdam este, a menos que declarem o pr\xF3prio
+defaultProvider: ${primary.name}
+
+# Diret\xF3rio dos YAML de agentes (relativo \xE0 raiz do reposit\xF3rio)
+agentsDir: agents
+
+providers:
+${providerBlocks}
+
+# \u2500\u2500 Heran\xE7a de provider/modelo \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+# agent.provider ausente  \u2192  usa defaultProvider acima
+# agent.model ausente     \u2192  usa defaultModel do provider resolvido
+# agent.provider presente \u2192  sobrescreve s\xF3 para aquele agente
+# agent.model presente    \u2192  sobrescreve o modelo s\xF3 para aquele agente
+# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+
+agents:
+  # Agente inline de exemplo \u2014 n\xE3o precisa de arquivo YAML separado
+  - name: code-reviewer
+    description: Revisa c\xF3digo para qualidade, bugs e problemas de seguran\xE7a
+    systemPrompt: |
+      Voc\xEA \xE9 um revisor de c\xF3digo especialista. Analise o c\xF3digo fornecido e
+      d\xEA feedback acion\xE1vel sobre qualidade, poss\xEDveis bugs, vulnerabilidades
+      de seguran\xE7a e problemas de performance. Seja preciso e objetivo.
+    skills:
+      - read-file
+      - search-code
+    maxIterations: 5
+    temperature: 0.1
+`;
+}
+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();
+  const token = await password({
+    message: "Cole seu GitHub token (ghp_... ou github_pat_...):",
+    validate: (v) => v.trim().length > 0 || "Token n\xE3o pode ser vazio"
+  });
+  const model = await select({
+    message: "Modelo padr\xE3o:",
+    choices: [
+      { name: "gpt-4o  (recomendado)", value: "gpt-4o" },
+      { name: "gpt-4o-mini  (r\xE1pido, custo baixo)", value: "gpt-4o-mini" },
+      { name: "o1", value: "o1" }
+    ]
+  });
+  return {
+    name: "copilot",
+    type: "copilot",
+    envKey: "GITHUB_TOKEN",
+    envValue: token.trim(),
+    defaultModel: model,
+    baseUrl: "https://api.githubcopilot.com"
+  };
+}
+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();
+  const key = await password({
+    message: "Cole sua Anthropic API key:",
+    validate: (v) => v.trim().length > 0 || "API key n\xE3o pode ser vazia"
+  });
+  const model = await select({
+    message: "Modelo padr\xE3o:",
+    choices: [
+      { name: "claude-sonnet-4-6  (recomendado \u2014 qualidade/velocidade balanceados)", value: "claude-sonnet-4-6" },
+      { name: "claude-opus-4-7  (racioc\xEDnio complexo, contexto longo)", value: "claude-opus-4-7" },
+      { name: "claude-haiku-4-5-20251001  (r\xE1pido, custo baixo)", value: "claude-haiku-4-5-20251001" }
+    ]
+  });
+  return {
+    name: "anthropic",
+    type: "anthropic",
+    envKey: "ANTHROPIC_API_KEY",
+    envValue: key.trim(),
+    defaultModel: model
+  };
+}
+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();
+  const key = await password({
+    message: "Cole sua OpenAI API key:",
+    validate: (v) => v.trim().length > 0 || "API key n\xE3o pode ser vazia"
+  });
+  const model = await select({
+    message: "Modelo padr\xE3o:",
+    choices: [
+      { name: "gpt-4o  (recomendado \u2014 multimodal, racioc\xEDnio forte)", value: "gpt-4o" },
+      { name: "gpt-4o-mini  (r\xE1pido, custo eficiente)", value: "gpt-4o-mini" },
+      { name: "o1", value: "o1" },
+      { name: "o3-mini", value: "o3-mini" }
+    ]
+  });
+  return {
+    name: "openai",
+    type: "openai",
+    envKey: "OPENAI_API_KEY",
+    envValue: key.trim(),
+    defaultModel: model
+  };
+}
+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();
+  const baseUrl = await input({
+    message: "Base URL do endpoint:",
+    default: "http://localhost:11434/v1",
+    validate: (v) => v.trim().length > 0 || "URL n\xE3o pode ser vazia"
+  });
+  const key = await password({
+    message: "API key (deixe vazio se n\xE3o for necess\xE1ria):"
+  });
+  const model = await input({
+    message: "Modelo padr\xE3o:",
+    default: "llama3.2",
+    validate: (v) => v.trim().length > 0 || "Modelo n\xE3o pode ser vazio"
+  });
+  const envKey = "CUSTOM_LLM_API_KEY";
+  const envBaseUrl = "CUSTOM_LLM_BASE_URL";
+  return {
+    name: "custom",
+    type: "custom",
+    envKey,
+    envValue: key.trim(),
+    defaultModel: model.trim(),
+    baseUrl: `\${${envBaseUrl}}`,
+    // we'll handle the base URL separately via a side-effect on envKey
+    // store the real base URL in a special field
+    ...baseUrl ? { _baseUrlValue: baseUrl } : {}
+  };
+}
+async function selectProvider(label) {
+  const choice = await select({
+    message: label,
+    choices: [
+      { name: "GitHub Copilot  (recomendado \u2014 usa seu token GitHub)", value: "copilot" },
+      { name: "Anthropic (Claude)", value: "anthropic" },
+      { name: "OpenAI (GPT)", value: "openai" },
+      { name: "Custom / self-hosted  (Ollama, Groq, Azure...)", value: "custom" }
+    ]
+  });
+  switch (choice) {
+    case "copilot":
+      return setupCopilot();
+    case "anthropic":
+      return setupAnthropic();
+    case "openai":
+      return setupOpenAI();
+    default:
+      return setupCustom();
+  }
+}
+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();
+  if (await fileExists(CONFIG_PATH)) {
+    const overwrite = await confirm({
+      message: chalk5.yellow("config/omni-ai.yaml j\xE1 existe. Sobrescrever?"),
+      default: false
+    });
+    if (!overwrite) {
+      console.log(chalk5.dim("\n  Opera\xE7\xE3o cancelada.\n"));
+      return;
+    }
+  }
+  const primary = await selectProvider("Qual provider de IA usar?");
+  const addSecond = await confirm({
+    message: "Adicionar um segundo provider (para usar em agentes espec\xEDficos)?",
+    default: false
+  });
+  const extras = [];
+  if (addSecond) {
+    console.log();
+    const second = await selectProvider("Segundo provider:");
+    if (second.name !== primary.name) {
+      extras.push(second);
+    } else {
+      console.log(chalk5.dim("  Mesmo provider \u2014 ignorado."));
+    }
+  }
+  const agentSets = await checkbox({
+    message: "Quais grupos de agentes voc\xEA vai usar? (informativo \u2014 todos j\xE1 est\xE3o dispon\xEDveis)",
+    choices: [
+      { name: "Backend \u2014 NestJS, DynamoDB, GraphQL (7 agentes)", value: "backend", checked: true },
+      { name: "Frontend \u2014 React, TanStack Router, shadcn/ui (5 agentes)", value: "frontend", checked: true },
+      { name: "UX \u2014 auditoria, forms, states, motion (5 agentes)", value: "ux", checked: true },
+      { name: "QA \u2014 valida\xE7\xE3o e veredicto de merge (4 agentes)", value: "qa", checked: true }
+    ]
+  });
+  const envEntries = await readEnvFile(ENV_PATH);
+  envEntries.set(primary.envKey, primary.envValue);
+  for (const extra of extras) {
+    envEntries.set(extra.envKey, extra.envValue);
+  }
+  const allProviders = [primary, ...extras];
+  for (const p of allProviders) {
+    const custom = p;
+    if (custom._baseUrlValue) {
+      envEntries.set("CUSTOM_LLM_BASE_URL", custom._baseUrlValue);
+    }
+  }
+  const envTemplatePath = resolve9(OMNI_ROOT, ".env.example");
+  let envTemplate = "";
+  try {
+    envTemplate = await readFile6(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");
+  console.log();
+  console.log(`${chalk5.green("  \u2713")} config/omni-ai.yaml criado`);
+  console.log(`${chalk5.green("  \u2713")} .env atualizado`);
+  console.log();
+  console.log(chalk5.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();
+  if (agentSets.includes("backend")) {
+    console.log(chalk5.cyan("    omni run backend-dev") + chalk5.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"'));
+  }
+  if (agentSets.includes("ux")) {
+    console.log(chalk5.cyan("    omni run ux-lead") + chalk5.dim(' "audite o componente OrderForm"'));
+  }
+  if (agentSets.includes("qa")) {
+    console.log(chalk5.cyan("    omni run qa-lead") + chalk5.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();
+}
+
+// ../cli/src/commands/list.ts
+import chalk6 from "chalk";
+async function listCommand(target, opts) {
+  const configPath = opts.config ?? resolveConfigPath();
+  if (target === "providers") {
+    await import("../src-ZHTGR7T6.js");
+    await import("../src-6MUVU5ML.js");
+    const names = getRegisteredProviders();
+    console.log(chalk6.bold("Registered providers:"));
+    for (const name of names) {
+      console.log(`  ${chalk6.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."));
+      process.exit(1);
+    }
+    const agents = await runtime.listAgents();
+    if (agents.length === 0) {
+      console.log(chalk6.gray("No agents found."));
+      return;
+    }
+    console.log(chalk6.bold(`Agents (${agents.length}):
+`));
+    for (const agent of agents) {
+      console.log(`  ${chalk6.cyan(agent.name.padEnd(30))} ${chalk6.gray(agent.description)}`);
+    }
+    return;
+  }
+  if (target === "skills") {
+    if (!runtime) {
+      console.error(chalk6.red("Could not load config."));
+      process.exit(1);
+    }
+    const skills2 = runtime.skills.all();
+    if (skills2.length === 0) {
+      console.log(chalk6.gray("No skills registered."));
+      return;
+    }
+    console.log(chalk6.bold(`Skills (${skills2.length}):
+`));
+    for (const skill of skills2) {
+      console.log(`  ${chalk6.yellow(skill.name.padEnd(25))} ${chalk6.gray(skill.description)}`);
+    }
+    return;
+  }
+  console.error(chalk6.red(`Unknown list target: "${target}". Use: agents | skills | providers`));
+  process.exit(1);
+}
+
+// ../mcp/src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z as z12 } from "zod";
+var stubProvider = {
+  name: "mcp-stub",
+  capabilities: {},
+  complete: () => {
+    throw new Error("Provider not available in MCP server context");
+  }
+};
+function createMcpServer(skills2, options) {
+  const server = new McpServer({
+    name: options?.name ?? "omni-ai",
+    version: options?.version ?? "0.1.0"
+  });
+  const ctx = {
+    provider: options?.ctx?.provider ?? stubProvider,
+    config: options?.ctx?.config ?? {}
+  };
+  for (const skill of skills2) {
+    server.registerTool(
+      skill.name,
+      { description: skill.description, inputSchema: z12.record(z12.unknown()) },
+      async (args) => {
+        try {
+          const result = await skill.execute(args, ctx);
+          const text = typeof result === "string" ? result : JSON.stringify(result);
+          return { content: [{ type: "text", text }] };
+        } catch (err) {
+          return {
+            content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }],
+            isError: true
+          };
+        }
+      }
+    );
+  }
+  return server;
+}
+async function serveMcp(skills2, transport, options) {
+  const server = createMcpServer(skills2, options);
+  await server.connect(transport);
+  return server;
+}
+async function serveStdioMcp(skills2, options) {
+  const transport = new StdioServerTransport();
+  return serveMcp(skills2, transport, options);
+}
+
+// ../mcp/src/skill.ts
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+
+// ../skills/src/backend/analyze-dynamo-schema.ts
+import { readFile as readFile7 } from "fs/promises";
+import { resolve as resolve10 } from "path";
+import { z as z13 } from "zod";
+var InputSchema12 = z13.object({
+  path: z13.string().describe("Path to the *.model.ts file containing the OneTable schema")
+});
+function extractSchemaName(source) {
+  const match = /export\s+const\s+(\w+Schema)\s*=/.exec(source);
+  return match?.[1] ?? "UnknownSchema";
+}
+function extractEntityType(source) {
+  const match = /export\s+type\s+(\w+)\s*=\s*Entity</.exec(source);
+  return match?.[1] ?? "UnknownEntity";
+}
+function extractFields(source) {
+  const fieldsKeyIdx = source.indexOf("fields:");
+  if (fieldsKeyIdx === -1) return [];
+  const braceOpen = source.indexOf("{", fieldsKeyIdx);
+  if (braceOpen === -1) return [];
+  let depth = 0;
+  let fieldsEnd = -1;
+  for (let i = braceOpen; i < source.length; i++) {
+    if (source[i] === "{") depth++;
+    else if (source[i] === "}") {
+      depth--;
+      if (depth === 0) {
+        fieldsEnd = i;
+        break;
+      }
+    }
+  }
+  if (fieldsEnd === -1) return [];
+  const fieldsBlock = source.slice(braceOpen + 1, fieldsEnd);
+  const fields = [];
+  for (const m of fieldsBlock.matchAll(/(\w+)\s*:\s*\{([^}]*)\}/g)) {
+    const body = m[2];
+    const typeMatch = /type\s*:\s*['"]?(\w+)['"]?/.exec(body);
+    const requiredMatch = /required\s*:\s*(true|false)/.exec(body);
+    fields.push({
+      name: m[1],
+      type: typeMatch?.[1] ?? "unknown",
+      required: requiredMatch?.[1] === "true",
+      isEnum: /enum\s*:\s*\w+/.test(body)
+    });
+  }
+  return fields;
+}
+function extractEnums(source) {
+  const enums = [];
+  for (const m of source.matchAll(/export\s+(?:const\s+)?enum\s+(\w+)\s*\{([^}]*)\}/g)) {
+    const values = m[2].split(",").map((v) => v.trim().split("=")[0].trim()).filter(Boolean);
+    enums.push({ name: m[1], values });
+  }
+  return enums;
+}
+function extractTypenames(source) {
+  const matches = source.match(/Typenames\.\w+/g) ?? [];
+  return [...new Set(matches)];
+}
+var analyzeDynamoSchemaSkill = {
+  name: "analyze-dynamo-schema",
+  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");
+    return {
+      schemaName: extractSchemaName(source),
+      entityType: extractEntityType(source),
+      fields: extractFields(source),
+      enums: extractEnums(source),
+      typenames: extractTypenames(source)
+    };
+  }
+};
+
+// ../skills/src/backend/analyze-graphql-schema.ts
+import { readFile as readFile8 } from "fs/promises";
+import { resolve as resolve11 } from "path";
+import { z as z14 } from "zod";
+var InputSchema13 = z14.object({
+  path: z14.string().describe("Path to the *.schema.graphql file")
+});
+function extractOperations(source, section) {
+  const sectionRe = new RegExp(`extend\\s+type\\s+${section}\\s*\\{([^}]*)\\}`, "s");
+  const match = sectionRe.exec(source);
+  if (!match) return [];
+  const ops = [];
+  for (const m of match[1].matchAll(/(\w+)\s*(\([^)]*\))?\s*:\s*([^\n@#]+)((?:\s*@\w+[^\n]*)*)/g)) {
+    const directives = m[4].trim().split(/\s*@/).filter(Boolean).map((d) => `@${d.trim()}`);
+    ops.push({
+      name: m[1],
+      args: (m[2] ?? "").trim(),
+      returns: m[3].trim(),
+      directives
+    });
+  }
+  return ops;
+}
+function extractTypes(source) {
+  const types = [];
+  for (const m of source.matchAll(/(?:^|\n)\s*(?:extend\s+)?type\s+(\w+)\s*(?:implements[^{]*)?\{/g)) {
+    if (!["Query", "Mutation", "Subscription"].includes(m[1])) types.push(m[1]);
+  }
+  return [...new Set(types)];
+}
+function extractInputs(source) {
+  return [...source.matchAll(/input\s+(\w+)\s*\{/g)].map((m) => m[1]);
+}
+function extractEnums2(source) {
+  return [...source.matchAll(/(?:extend\s+)?enum\s+(\w+)\s*\{/g)].map((m) => m[1]);
+}
+var analyzeGraphqlSchemaSkill = {
+  name: "analyze-graphql-schema",
+  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");
+    return {
+      types: extractTypes(source),
+      queries: extractOperations(source, "Query"),
+      mutations: extractOperations(source, "Mutation"),
+      inputs: extractInputs(source),
+      enums: extractEnums2(source)
+    };
+  }
+};
+
+// ../skills/src/backend/analyze-nestjs-module.ts
+import { readFile as readFile9 } from "fs/promises";
+import { resolve as resolve12 } from "path";
+import { z as z15 } from "zod";
+var InputSchema14 = z15.object({
+  path: z15.string().describe("Path to the *.module.ts file")
+});
+function extractArrayItems(source, key) {
+  const re = new RegExp(`${key}\\s*:\\s*\\[([^\\]]*?)\\]`, "s");
+  const match = re.exec(source);
+  if (!match) return [];
+  return match[1].split(",").map(
+    (s) => s.trim().replace(/\/\/.*$/m, "").trim()
+  ).filter(Boolean);
+}
+function extractModuleName(source) {
+  const match = /export\s+class\s+(\w+Module)/.exec(source);
+  return match?.[1] ?? "UnknownModule";
+}
+var analyzeNestjsModuleSkill = {
+  name: "analyze-nestjs-module",
+  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");
+    return {
+      moduleName: extractModuleName(source),
+      imports: extractArrayItems(source, "imports"),
+      providers: extractArrayItems(source, "providers"),
+      exports: extractArrayItems(source, "exports"),
+      controllers: extractArrayItems(source, "controllers")
+    };
+  }
+};
+
+// ../skills/src/backend/find-code-pattern.ts
+import { readdir as readdir4, readFile as readFile10 } from "fs/promises";
+import { join as join4 } from "path";
+import { z as z16 } from "zod";
+var patternSuffixes = {
+  service: [".service.ts"],
+  resolver: [".resolver.ts"],
+  listener: [".listener.ts"],
+  model: [".model.ts"],
+  test: [".spec.ts"],
+  schema: [".schema.graphql"]
+};
+var InputSchema15 = z16.object({
+  patternType: z16.enum(["service", "resolver", "listener", "model", "test", "schema"]).describe("Type of NestJS pattern to find examples of"),
+  directory: z16.string().describe("Root directory to search in"),
+  maxExamples: z16.number().int().positive().default(3).describe("Maximum number of examples to return")
+});
+async function walkForPattern(dir, suffixes, results, max) {
+  if (results.length >= max) return;
+  const entries = await readdir4(dir, { withFileTypes: true }).catch(() => null);
+  if (!entries) return;
+  for (const entry of entries) {
+    if (results.length >= max) break;
+    if (entry.name === "node_modules" || entry.name === "dist" || entry.name === ".git") continue;
+    const fullPath = join4(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");
+      results.push({ file: fullPath, content });
+    }
+  }
+}
+var findCodePatternSkill = {
+  name: "find-code-pattern",
+  description: "Find real examples of NestJS patterns (service, resolver, listener, model, test, schema) from the codebase. Use this before generating new code to understand the exact conventions and patterns already in use.",
+  async execute(input5) {
+    const { patternType, directory, maxExamples } = InputSchema15.parse(input5);
+    const suffixes = patternSuffixes[patternType];
+    const results = [];
+    await walkForPattern(directory, suffixes, results, maxExamples);
+    return results;
+  }
+};
+
+// ../skills/src/frontend/analyze-component.ts
+import { readFile as readFile11 } from "fs/promises";
+import { resolve as resolve13 } from "path";
+import { z as z17 } from "zod";
+var InputSchema16 = z17.object({
+  path: z17.string().describe("Path to the React component file (.tsx or .ts)")
+});
+function extractComponentName(source, filePath) {
+  const fnMatch = /(?:export\s+(?:default\s+)?function\s+|const\s+)([A-Z]\w*)/.exec(source);
+  if (fnMatch) return fnMatch[1];
+  const parts = filePath.split(/[/\\]/);
+  return (parts[parts.length - 1] ?? "").replace(/\.(tsx?|jsx?)$/, "");
+}
+function extractPropsInterface(source) {
+  const ifaceMatch = /interface\s+(\w*Props\w*)\s*\{([^}]*)\}/.exec(source);
+  if (ifaceMatch) return `interface ${ifaceMatch[1]} {${ifaceMatch[2]}}`;
+  const typeMatch = /type\s+(\w*Props\w*)\s*=\s*\{([^}]*)\}/.exec(source);
+  if (typeMatch) return `type ${typeMatch[1]} = {${typeMatch[2]}}`;
+  return null;
+}
+function extractHooksUsed(source) {
+  const matches = source.match(/\buse[A-Z]\w*/g) ?? [];
+  return [...new Set(matches)];
+}
+function extractNamedExports(source) {
+  return [...source.matchAll(/export\s+(?:const|function|class|type|interface|enum)\s+(\w+)/g)].map((m) => m[1]);
+}
+var analyzeComponentSkill = {
+  name: "analyze-component",
+  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");
+    return {
+      componentName: extractComponentName(source, path),
+      propsInterface: extractPropsInterface(source),
+      hooksUsed: extractHooksUsed(source),
+      namedExports: extractNamedExports(source),
+      hasDefaultExport: /export\s+default\s+/.test(source)
+    };
+  }
+};
+
+// ../skills/src/frontend/analyze-module-structure.ts
+import { readdir as readdir5 } from "fs/promises";
+import { join as join5 } 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);
+  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);
+    if (entry.isDirectory()) {
+      files.push(...await collectFiles2(fullPath));
+    } else if (entry.isFile() && /\.(tsx?|jsx?)$/.test(entry.name)) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+function categorize(files) {
+  const result = { components: [], hooks: [], pages: [], stores: [], indexFiles: [] };
+  for (const f of files) {
+    const name = f.split(/[/\\]/).pop() ?? "";
+    if (name.includes(".spec.") || name.includes(".test.")) continue;
+    if (name === "index.ts" || name === "index.tsx") result.indexFiles.push(f);
+    else if (name.startsWith("use")) result.hooks.push(f);
+    else if (/page|route/i.test(name)) result.pages.push(f);
+    else if (/store|context|provider/i.test(name)) result.stores.push(f);
+    else if (/^[A-Z]/.test(name)) result.components.push(f);
+  }
+  return result;
+}
+var analyzeModuleStructureSkill = {
+  name: "analyze-module-structure",
+  description: "Map the file structure of a React module directory: lists components, hooks, pages, stores and index files. Use this before creating a new feature module to understand the existing layout and avoid duplicating files.",
+  async execute(input5) {
+    const { directory } = InputSchema17.parse(input5);
+    const files = await collectFiles2(directory);
+    return categorize(files);
+  }
+};
+
+// ../skills/src/frontend/find-component-pattern.ts
+import { readdir as readdir6, readFile as readFile12 } from "fs/promises";
+import { join as join6 } 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."),
+  hook: (name) => name.startsWith("use") && (name.endsWith(".ts") || name.endsWith(".tsx")) && !name.includes(".spec."),
+  page: (name) => /page|route/i.test(name) && (name.endsWith(".tsx") || name.endsWith(".ts")) && !name.includes(".spec."),
+  module: (name) => (name === "index.ts" || name === "index.tsx" || /module/i.test(name)) && !name.includes(".spec.")
+};
+var InputSchema18 = z19.object({
+  patternType: z19.enum(["component", "hook", "page", "module"]).describe("Type of React pattern to find examples of"),
+  directory: z19.string().describe("Root directory to search in"),
+  maxExamples: z19.number().int().positive().default(3).describe("Maximum number of examples to return")
+});
+async function walkForComponent(dir, filter, results, max) {
+  if (results.length >= max) return;
+  const entries = await readdir6(dir, { withFileTypes: true }).catch(() => null);
+  if (!entries) return;
+  for (const entry of entries) {
+    if (results.length >= max) break;
+    if (entry.name === "node_modules" || entry.name === "dist" || entry.name === ".git") continue;
+    const fullPath = join6(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");
+      results.push({ file: fullPath, content });
+    }
+  }
+}
+var findComponentPatternSkill = {
+  name: "find-component-pattern",
+  description: "Find real examples of React patterns (component, hook, page, module) from the codebase. Use this before generating new UI code to understand the exact naming conventions, file structure and import patterns already in use.",
+  async execute(input5) {
+    const { patternType, directory, maxExamples } = InputSchema18.parse(input5);
+    const filter = patternFilters[patternType];
+    const results = [];
+    await walkForComponent(directory, filter, results, maxExamples);
+    return results;
+  }
+};
+
+// ../skills/src/qa/analyze-test-coverage.ts
+import { readdir as readdir7 } from "fs/promises";
+import { join as join7 } 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"),
+  extensions: z20.array(z20.string()).default([".ts", ".tsx"]).describe("Source file extensions to check"),
+  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);
+  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);
+    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))) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+async function collectAllFiles(dir) {
+  const files = await collectFiles3(dir, [".ts", ".tsx"], []);
+  return new Set(files);
+}
+function specPathCandidates(filePath) {
+  const base = filePath.replace(/\.(tsx?)$/, "");
+  return [`${base}.spec.ts`, `${base}.spec.tsx`, `${base}.test.ts`, `${base}.test.tsx`];
+}
+var analyzeTestCoverageSkill = {
+  name: "analyze-test-coverage",
+  description: "Scan a directory and identify which source files have a corresponding .spec.ts test file and which do not. Use this before a QA pass to prioritize which files need tests written.",
+  async execute(input5) {
+    const { directory, extensions, ignorePatterns } = InputSchema19.parse(input5);
+    const sourceFiles = await collectFiles3(directory, extensions, ignorePatterns);
+    const allFiles = await collectAllFiles(directory);
+    const covered = [];
+    const uncovered = [];
+    for (const file of sourceFiles) {
+      const hasSpec = specPathCandidates(file).some((s) => allFiles.has(s));
+      if (hasSpec) covered.push(file);
+      else uncovered.push(file);
+    }
+    const total = covered.length + uncovered.length;
+    return {
+      covered,
+      uncovered,
+      coverageRate: total === 0 ? 1 : covered.length / total
+    };
+  }
+};
+
+// ../skills/src/qa/find-test-pattern.ts
+import { readdir as readdir8, readFile as readFile13 } from "fs/promises";
+import { join as join8 } from "path";
+import { z as z21 } from "zod";
+var patternFilters2 = {
+  service: (name) => name.endsWith(".service.spec.ts"),
+  component: (name) => /^[A-Z]/.test(name) && (name.endsWith(".spec.ts") || name.endsWith(".spec.tsx")),
+  hook: (name) => name.startsWith("use") && (name.endsWith(".spec.ts") || name.endsWith(".spec.tsx")),
+  resolver: (name) => name.endsWith(".resolver.spec.ts")
+};
+var InputSchema20 = z21.object({
+  patternType: z21.enum(["service", "component", "hook", "resolver"]).describe("Type of test pattern to find examples of"),
+  directory: z21.string().describe("Root directory to search in"),
+  maxExamples: z21.number().int().positive().default(2).describe("Maximum number of test examples to return")
+});
+async function walkForTests(dir, filter, results, max) {
+  if (results.length >= max) return;
+  const entries = await readdir8(dir, { withFileTypes: true }).catch(() => null);
+  if (!entries) return;
+  for (const entry of entries) {
+    if (results.length >= max) break;
+    if (entry.name === "node_modules" || entry.name === "dist" || entry.name === ".git") continue;
+    const fullPath = join8(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");
+      results.push({ file: fullPath, content });
+    }
+  }
+}
+var findTestPatternSkill = {
+  name: "find-test-pattern",
+  description: "Find real test file examples (service, component, hook, resolver) from the codebase. Use this before writing tests to understand the exact test structure, setup() pattern, mocking conventions and assertion style already in use.",
+  async execute(input5) {
+    const { patternType, directory, maxExamples } = InputSchema20.parse(input5);
+    const filter = patternFilters2[patternType];
+    const results = [];
+    await walkForTests(directory, filter, results, maxExamples);
+    return results;
+  }
+};
+
+// ../cli/src/commands/mcp-serve.ts
+import chalk7 from "chalk";
+var skills = [
+  readFileSkill,
+  writeFileSkill,
+  listDirectorySkill,
+  searchCodeSkill,
+  auditAccessibilitySkill,
+  gitStatusSkill,
+  gitDiffSkill,
+  gitLogSkill,
+  gitCommitMessageSkill,
+  httpRequestSkill,
+  analyzeImageSkill,
+  findCodePatternSkill,
+  analyzeNestjsModuleSkill,
+  analyzeDynamoSchemaSkill,
+  analyzeGraphqlSchemaSkill,
+  findComponentPatternSkill,
+  analyzeComponentSkill,
+  analyzeModuleStructureSkill,
+  findTestPatternSkill,
+  analyzeTestCoverageSkill
+];
+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(chalk7.gray(`  Skills:    ${skills.length}
+`));
+  process.stderr.write(chalk7.gray("\n  Waiting for MCP client connection\u2026\n\n"));
+  await serveStdioMcp(skills, { name: "omni-ai" });
+  await new Promise(() => {
+  });
+}
+
+// ../cli/src/commands/new.ts
+import { readFile as readFile14 } from "fs/promises";
+import { join as join12 } from "path";
+import { select as select4 } from "@inquirer/prompts";
+import chalk11 from "chalk";
+import YAML from "yaml";
+
+// ../cli/src/commands/new/scaffold-agent.ts
+import { access as access2, mkdir as mkdir2, writeFile as writeFile6 } from "fs/promises";
+import { join as join9, 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";
+
+// ../cli/src/commands/new/templates.ts
+function kebabToPascal(s) {
+  return s.replace(/(^|-)([a-z])/g, (_, __, c) => c.toUpperCase());
+}
+function kebabToCamel(s) {
+  return s.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+function generateAgentYaml(params) {
+  const skillLines = params.skills.length > 0 ? params.skills.map((s) => `  - ${s}`).join("\n") : "  [] # add skill names here";
+  const promptLines = params.systemPrompt.split("\n").map((l) => `  ${l}`).join("\n");
+  return `name: ${params.name}
+description: ${params.description}
+systemPrompt: |
+${promptLines}
+skills:
+${skillLines}
+maxIterations: ${params.maxIterations}
+temperature: ${params.temperature}
+`;
+}
+function generateSkillTs(params) {
+  const pascal = kebabToPascal(params.kebabName);
+  const camel = kebabToCamel(params.kebabName);
+  return `import type { ISkill, SkillContext } from "@omni-ai/core";
+import { z } from "zod";
+
+const InputSchema = z.object({
+  query: z.string().describe("Input for ${params.kebabName}"),
+});
+
+export type ${pascal}Input = z.infer<typeof InputSchema>;
+
+export const ${camel}Skill: ISkill<${pascal}Input, string> = {
+  name: "${params.kebabName}",
+  description: "${params.description}",
+
+  async execute(input: ${pascal}Input, _ctx: SkillContext): Promise<string> {
+    const { query } = InputSchema.parse(input);
+    // TODO: implement ${params.kebabName} logic
+    return query;
+  },
+};
+`;
+}
+function generateProviderFiles(params) {
+  const pascal = kebabToPascal(params.kebabName);
+  const indexTs = `import type {
+  CompletionRequest,
+  CompletionResponse,
+  IProvider,
+  ProviderCapabilities,
+} from "@omni-ai/core";
+import { ProviderRegistry } from "@omni-ai/core";
+
+export class ${pascal}Provider implements IProvider {
+  readonly name = "${params.kebabName}";
+  readonly capabilities: ProviderCapabilities = {
+    chat: true,
+    embedding: ${params.hasEmbedding},
+    streaming: false,
+    toolUse: true,
+    vision: ${params.hasVision},
+  };
+
+  async complete(_request: CompletionRequest): Promise<CompletionResponse> {
+    // TODO: implement ${params.displayName} API call
+    throw new Error("Not implemented");
+  }
+}
+
+ProviderRegistry.register(new ${pascal}Provider());
+`;
+  const packageJson = JSON.stringify(
+    {
+      name: `@omni-ai/provider-${params.kebabName}`,
+      version: "0.1.0",
+      type: "module",
+      exports: {
+        ".": {
+          import: "./dist/index.js",
+          types: "./dist/index.d.ts"
+        }
+      },
+      scripts: {
+        build: "tsc",
+        typecheck: "tsc --noEmit"
+      },
+      dependencies: {
+        "@omni-ai/core": "workspace:*"
+      },
+      devDependencies: {
+        typescript: "^5.7.0",
+        "@types/node": "^22.0.0"
+      }
+    },
+    null,
+    2
+  );
+  const tsconfigJson = JSON.stringify(
+    {
+      compilerOptions: {
+        target: "ES2022",
+        module: "NodeNext",
+        moduleResolution: "NodeNext",
+        lib: ["ES2022"],
+        outDir: "dist",
+        rootDir: "src",
+        declaration: true,
+        declarationDir: "dist",
+        strict: true,
+        esModuleInterop: false,
+        skipLibCheck: true
+      },
+      include: ["src"],
+      references: [{ path: "../core" }]
+    },
+    null,
+    2
+  );
+  return { indexTs, packageJson, tsconfigJson };
+}
+
+// ../cli/src/commands/new/scaffold-agent.ts
+var ALL_SKILLS = [
+  // Layer 1 — primitives
+  "read-file",
+  "write-file",
+  "list-directory",
+  "search-code",
+  "audit-accessibility",
+  "git-status",
+  "git-diff",
+  "git-log",
+  "git-commit-message",
+  "http-request",
+  "analyze-image",
+  // Layer 2 — domain readers
+  "find-code-pattern",
+  "analyze-nestjs-module",
+  "analyze-dynamo-schema",
+  "analyze-graphql-schema",
+  "find-component-pattern",
+  "analyze-component",
+  "analyze-module-structure",
+  "find-test-pattern",
+  "analyze-test-coverage"
+];
+async function writeAgentFile(params, agentsDir) {
+  const dir = resolve14(process.cwd(), agentsDir, params.domain);
+  const filePath = join9(dir, `${params.domain}-${params.role}.yaml`);
+  const content = generateAgentYaml({
+    name: `${params.domain}-${params.role}`,
+    description: params.description,
+    systemPrompt: params.systemPrompt,
+    skills: params.skills,
+    maxIterations: 10,
+    temperature: 0.3
+  });
+  await mkdir2(dir, { recursive: true });
+  await writeFile6(filePath, content, "utf-8");
+  return filePath;
+}
+async function agentWizard(agentsDir) {
+  console.log();
+  const domain = await select2({
+    message: "Dom\xEDnio do agente:",
+    choices: [
+      { value: "backend", name: "backend  \u2014 NestJS, DynamoDB, GraphQL" },
+      { value: "frontend", name: "frontend \u2014 React, hooks, componentes" },
+      { value: "ux", name: "ux       \u2014 acessibilidade, design system" },
+      { value: "qa", name: "qa       \u2014 testes, coverage, valida\xE7\xE3o" }
+    ]
+  });
+  const role = await input2({
+    message: "Role (slug, ex: service, dev, test):",
+    validate: (v) => /^[a-z][a-z0-9-]*$/.test(v.trim()) || "Use letras min\xFAsculas, n\xFAmeros e h\xEDfens"
+  });
+  const description = await input2({
+    message: "Descri\xE7\xE3o (uma linha):",
+    validate: (v) => v.trim().length > 0 || "Descri\xE7\xE3o n\xE3o pode ser vazia"
+  });
+  const systemPrompt = await input2({
+    message: "System prompt (pode editar no arquivo depois):",
+    default: `You are a ${domain} developer specialized in ${role} tasks.`
+  });
+  const skills2 = await checkbox2({
+    message: "Skills dispon\xEDveis para este agente:",
+    choices: ALL_SKILLS.map((s) => ({ value: s, name: s }))
+  });
+  const outPath = resolve14(process.cwd(), agentsDir, domain, `${domain}-${role}.yaml`);
+  console.log();
+  console.log(chalk8.dim(`  Destino: ${outPath}`));
+  let shouldWrite = true;
+  try {
+    await access2(outPath);
+    shouldWrite = await confirm2({ message: chalk8.yellow("Arquivo j\xE1 existe. Sobrescrever?"), default: false });
+  } catch {
+  }
+  if (!shouldWrite) {
+    console.log(chalk8.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();
+}
+
+// ../cli/src/commands/new/scaffold-provider.ts
+import { access as access3, mkdir as mkdir3, writeFile as writeFile7 } from "fs/promises";
+import { join as join10, resolve as resolve15 } from "path";
+import { confirm as confirm3, input as input3 } from "@inquirer/prompts";
+import chalk9 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");
+  return packageDir;
+}
+async function providerWizard(providersDir) {
+  console.log();
+  const kebabName = await input3({
+    message: "Nome do provider (kebab-case, ex: mistral, groq, bedrock):",
+    validate: (v) => /^[a-z][a-z0-9-]*$/.test(v.trim()) || "Use letras min\xFAsculas, n\xFAmeros e h\xEDfens"
+  });
+  const displayName = await input3({
+    message: "Nome de exibi\xE7\xE3o (ex: Mistral AI, Groq):",
+    default: kebabName.replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase()),
+    validate: (v) => v.trim().length > 0 || "Nome n\xE3o pode ser vazio"
+  });
+  const hasVision = await confirm3({ message: "Suporta vis\xE3o (imagens)?", default: false });
+  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}/`));
+  let shouldWrite = true;
+  try {
+    await access3(outDir);
+    shouldWrite = await confirm3({
+      message: chalk9.yellow(`packages/provider-${kebabName}/ j\xE1 existe. Sobrescrever arquivos?`),
+      default: false
+    });
+  } catch {
+  }
+  if (!shouldWrite) {
+    console.log(chalk9.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();
+}
+
+// ../cli/src/commands/new/scaffold-skill.ts
+import { access as access4, mkdir as mkdir4, writeFile as writeFile8 } from "fs/promises";
+import { join as join11, resolve as resolve16 } from "path";
+import { confirm as confirm4, input as input4, select as select3 } from "@inquirer/prompts";
+import chalk10 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 content = generateSkillTs({ kebabName: params.kebabName, description: params.description });
+  await mkdir4(dir, { recursive: true });
+  await writeFile8(filePath, content, "utf-8");
+  return filePath;
+}
+async function skillWizard(skillsDir) {
+  console.log();
+  const domain = await select3({
+    message: "Dom\xEDnio da skill:",
+    choices: DOMAINS.map((d) => ({ value: d, name: d }))
+  });
+  const kebabName = await input4({
+    message: "Nome da skill (kebab-case, ex: analyze-orders):",
+    validate: (v) => /^[a-z][a-z0-9-]*$/.test(v.trim()) || "Use letras min\xFAsculas, n\xFAmeros e h\xEDfens"
+  });
+  const description = await input4({
+    message: "Descri\xE7\xE3o (usada pelo agente para decidir quando chamar esta skill):",
+    validate: (v) => v.trim().length > 0 || "Descri\xE7\xE3o n\xE3o pode ser vazia"
+  });
+  const outPath = resolve16(process.cwd(), skillsDir, domain, `${kebabName}.ts`);
+  console.log();
+  console.log(chalk10.dim(`  Destino: ${outPath}`));
+  let shouldWrite = true;
+  try {
+    await access4(outPath);
+    shouldWrite = await confirm4({ message: chalk10.yellow("Arquivo j\xE1 existe. Sobrescrever?"), default: false });
+  } catch {
+  }
+  if (!shouldWrite) {
+    console.log(chalk10.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();
+}
+
+// ../cli/src/commands/new.ts
+var DEFAULTS = {
+  agentsDir: "agents",
+  skills: "src/skills",
+  providers: "packages"
+};
+async function loadScaffoldConfig() {
+  try {
+    const raw = await readFile14(join12(process.cwd(), "config", "omni-ai.yaml"), "utf-8");
+    const data = YAML.parse(raw);
+    if (!data) return DEFAULTS;
+    const sp = data.scaffoldPaths;
+    return {
+      agentsDir: data.agentsDir ?? DEFAULTS.agentsDir,
+      skills: sp?.skills ?? DEFAULTS.skills,
+      providers: sp?.providers ?? DEFAULTS.providers
+    };
+  } catch {
+    return DEFAULTS;
+  }
+}
+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"));
+  const config = await loadScaffoldConfig();
+  const type = await select4({
+    message: "O que deseja criar?",
+    choices: [
+      { value: "agent", name: "Agent    \u2014 arquivo YAML que define um agente de IA" },
+      { value: "skill", name: "Skill    \u2014 fun\xE7\xE3o TypeScript que o agente pode chamar" },
+      { value: "provider", name: "Provider \u2014 adapter para uma nova API de LLM" }
+    ]
+  });
+  switch (type) {
+    case "agent":
+      await agentWizard(config.agentsDir);
+      break;
+    case "skill":
+      await skillWizard(config.skills);
+      break;
+    case "provider":
+      await providerWizard(config.providers);
+      break;
+  }
+}
+
+// ../cli/src/commands/run.ts
+import { writeFile as writeFile9 } from "fs/promises";
+function parseSession(raw) {
+  const [resourceId, ...rest] = raw.split(":");
+  const threadId = rest.join(":") || "default";
+  return { resourceId, threadId };
+}
+function getDbPath2() {
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? ".";
+  return `${home}/.omni-ai/sessions.db`;
+}
+async function runCommand(agent, prompt, opts) {
+  const configPath = opts.config ?? resolveConfigPath();
+  const skills2 = [
+    // Layer 1 — primitives
+    readFileSkill,
+    writeFileSkill,
+    listDirectorySkill,
+    searchCodeSkill,
+    auditAccessibilitySkill,
+    gitStatusSkill,
+    gitDiffSkill,
+    gitLogSkill,
+    gitCommitMessageSkill,
+    httpRequestSkill,
+    analyzeImageSkill,
+    // Layer 2 — domain readers
+    findCodePatternSkill,
+    analyzeNestjsModuleSkill,
+    analyzeDynamoSchemaSkill,
+    analyzeGraphqlSchemaSkill,
+    findComponentPatternSkill,
+    analyzeComponentSkill,
+    analyzeModuleStructureSkill,
+    findTestPatternSkill,
+    analyzeTestCoverageSkill
+  ];
+  let memoryStore;
+  let sessionId;
+  if (opts.session) {
+    sessionId = parseSession(opts.session);
+    memoryStore = new SQLiteMemoryStore({ path: getDbPath2() });
+  }
+  const runtime = await createRuntime({ configPath, skills: skills2, memoryStore }).catch((err) => {
+    console.error(errorLine(`Failed to load config: ${err instanceof Error ? err.message : String(err)}`));
+    process.exit(1);
+  });
+  const providerLabel = `${runtime.config.defaultProvider} / ${runtime.config.providers.find((p) => p.name === runtime.config.defaultProvider)?.defaultModel ?? "default"}`;
+  console.log(`
+${agentHeader(agent, providerLabel)}`);
+  const onToken = opts.stream ? (chunk) => process.stdout.write(chunk) : void 0;
+  if (opts.stream) process.stdout.write("\n");
+  const result = await runtime.run(agent, prompt, { session: sessionId, onToken }).catch(async (err) => {
+    console.error(errorLine(err instanceof Error ? err.message : String(err)));
+    await memoryStore?.close?.();
+    process.exit(1);
+  });
+  if (opts.stream) {
+    process.stdout.write("\n");
+  } else {
+    console.log(`
+${result.output}
+`);
+  }
+  console.log(iterationLine(result.iterations));
+  if (opts.output) {
+    await writeFile9(opts.output, result.output, "utf-8");
+    console.log(savedLine(opts.output));
+  }
+  if (result.usage) {
+    console.log(tokenSummary(result.usage.inputTokens, result.usage.outputTokens));
+  }
+  console.log();
+  await memoryStore?.close?.();
+}
+
+// ../cli/src/commands/serve.ts
+import chalk12 from "chalk";
+import express from "express";
+function getDbPath3() {
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? ".";
+  return `${home}/.omni-ai/sessions.db`;
+}
+function parseSession2(raw) {
+  const [resourceId, ...rest] = raw.split(":");
+  return { resourceId, threadId: rest.join(":") || "default" };
+}
+async function serveCommand(opts) {
+  const port = opts.port ? Number.parseInt(opts.port, 10) : 3e3;
+  const configPath = opts.config ?? resolveConfigPath();
+  const skills2 = [
+    readFileSkill,
+    writeFileSkill,
+    listDirectorySkill,
+    searchCodeSkill,
+    auditAccessibilitySkill,
+    gitStatusSkill,
+    gitDiffSkill,
+    gitLogSkill,
+    gitCommitMessageSkill,
+    httpRequestSkill,
+    analyzeImageSkill,
+    findCodePatternSkill,
+    analyzeNestjsModuleSkill,
+    analyzeDynamoSchemaSkill,
+    analyzeGraphqlSchemaSkill,
+    findComponentPatternSkill,
+    analyzeComponentSkill,
+    analyzeModuleStructureSkill,
+    findTestPatternSkill,
+    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)}`));
+    process.exit(1);
+  });
+  const app = express();
+  app.use(express.json());
+  app.use((_req, res, next) => {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    next();
+  });
+  app.options("*", (_req, res) => {
+    res.sendStatus(204);
+  });
+  app.get("/health", (_req, res) => {
+    res.json({ status: "ok", version: "0.1.0" });
+  });
+  app.get("/agents", async (_req, res) => {
+    try {
+      const agents = await runtime.listAgents();
+      res.json({ agents });
+    } catch (err) {
+      res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+    }
+  });
+  app.post("/run", async (req, res) => {
+    const { agent, prompt, session } = req.body;
+    if (!agent || !prompt) {
+      res.status(400).json({ error: "agent and prompt are required" });
+      return;
+    }
+    try {
+      const sessionId = session ? parseSession2(session) : void 0;
+      const result = await runtime.run(agent, prompt, { session: sessionId });
+      res.json({ output: result.output, iterations: result.iterations, usage: result.usage });
+    } catch (err) {
+      res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+    }
+  });
+  app.post("/run/stream", async (req, res) => {
+    const { agent, prompt, session } = req.body;
+    if (!agent || !prompt) {
+      res.status(400).json({ error: "agent and prompt are required" });
+      return;
+    }
+    res.setHeader("Content-Type", "text/event-stream");
+    res.setHeader("Cache-Control", "no-cache");
+    res.setHeader("Connection", "keep-alive");
+    res.flushHeaders();
+    const sendEvent = (data) => res.write(`data: ${data}
+
+`);
+    try {
+      const memoryStore = session ? new SQLiteMemoryStore({ path: getDbPath3() }) : void 0;
+      const sessionId = session ? parseSession2(session) : void 0;
+      const result = await runtime.run(agent, prompt, {
+        session: sessionId,
+        onToken: (chunk) => sendEvent(JSON.stringify({ type: "token", content: chunk }))
+      });
+      await memoryStore?.close?.();
+      sendEvent(JSON.stringify({ type: "done", usage: result.usage, iterations: result.iterations }));
+    } catch (err) {
+      sendEvent(JSON.stringify({ type: "error", error: err instanceof Error ? err.message : String(err) }));
+    } finally {
+      res.end();
+    }
+  });
+  app.listen(port, () => {
+    console.log(chalk12.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"));
+  });
+  await new Promise(() => {
+  });
+}
+
+// ../cli/src/commands/watch.ts
+import chalk13 from "chalk";
+import chokidar from "chokidar";
+function buildDebounce(fn, ms) {
+  let timer = null;
+  return () => {
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(fn, ms);
+  };
+}
+async function runOnce(agent, prompt, configPath, stream) {
+  const skills2 = [
+    readFileSkill,
+    writeFileSkill,
+    listDirectorySkill,
+    searchCodeSkill,
+    gitStatusSkill,
+    gitDiffSkill,
+    gitLogSkill,
+    gitCommitMessageSkill
+  ];
+  const runtime = await createRuntime({ configPath, skills: skills2 }).catch((err) => {
+    console.error(errorLine(`Failed to load config: ${err instanceof Error ? err.message : String(err)}`));
+    return null;
+  });
+  if (!runtime) return;
+  const providerLabel = `${runtime.config.defaultProvider} / ${runtime.config.providers.find((p) => p.name === runtime.config.defaultProvider)?.defaultModel ?? "default"}`;
+  console.log(`
+${agentHeader(agent, providerLabel)}`);
+  const onToken = stream ? (chunk) => process.stdout.write(chunk) : void 0;
+  if (stream) process.stdout.write("\n");
+  const result = await runtime.run(agent, prompt, { onToken }).catch((err) => {
+    console.error(errorLine(err instanceof Error ? err.message : String(err)));
+    return null;
+  });
+  if (!result) return;
+  if (stream) {
+    process.stdout.write("\n");
+  } else {
+    console.log(`
+${result.output}
+`);
+  }
+  console.log(iterationLine(result.iterations));
+  if (result.usage) console.log(tokenSummary(result.usage.inputTokens, result.usage.outputTokens));
+}
+async function watchCommand(agent, prompt, opts) {
+  const configPath = opts.config ?? resolveConfigPath();
+  const glob = opts.glob ?? "src/**/*.{ts,js,yaml,json}";
+  const debounceMs = opts.debounce ? Number.parseInt(opts.debounce, 10) : 500;
+  console.log(chalk13.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"));
+  await runOnce(agent, prompt, configPath, opts.stream ?? false);
+  const trigger = buildDebounce(async () => {
+    console.log(chalk13.gray(`
+  \u21BB Rerunning ${agent}...`));
+    await runOnce(agent, prompt, configPath, opts.stream ?? false);
+  }, debounceMs);
+  const watcher = chokidar.watch(glob, { ignoreInitial: true, ignored: /node_modules/ });
+  watcher.on("change", (file) => {
+    console.log(chalk13.gray(`
+  \u270E Changed: ${file}`));
+    trigger();
+  });
+  watcher.on("add", (file) => {
+    console.log(chalk13.gray(`
+  + Added: ${file}`));
+    trigger();
+  });
+  watcher.on("error", (err) => {
+    console.error(errorLine(`Watcher error: ${err}`));
+  });
+  process.on("SIGINT", async () => {
+    console.log(chalk13.gray("\n\n  Stopping watcher..."));
+    await watcher.close();
+    process.exit(0);
+  });
+  await new Promise(() => {
+  });
+}
+
+// ../cli/src/bin.ts
+var __dirname2 = dirname4(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");
+program.command("run <agent> <prompt>").description("Run an agent with a prompt").option("-c, --config <path>", "Path to omni-ai.yaml").option("-s, --session <id>", "Session ID for memory (format: resourceId:threadId)").option("-o, --output <file>", "Save output to file").option("-v, --verbose", "Show iteration details").option("--stream", "Stream tokens in real time as the agent responds").action(runCommand);
+program.command("init").description("Interactive setup wizard \u2014 creates omni-ai.yaml and configures .env").action(initCommand);
+program.command("new").description("Scaffold a new agent, skill or provider from a template").action(newCommand);
+program.command("chain <prompt> <agents...>").description("Run a sequence of agents, piping each output as the next agent's input").option("-c, --config <path>", "Path to omni-ai.yaml").option("-o, --output <file>", "Save final output to file").option("-v, --verbose", "Print each agent's full output as the chain progresses").option("-s, --stream", "Stream tokens from each agent in real time").action(chainCommand);
+program.command("export <sessionId>").description("Export a session history as markdown or JSON").option("-f, --format <format>", "Output format: markdown | json (default: markdown)").option("-o, --output <file>", "Save output to file instead of stdout").option("-l, --limit <n>", "Limit to last N messages").action(exportCommand);
+program.command("watch <agent> <prompt>").description("Re-run an agent automatically when project files change").option("-c, --config <path>", "Path to omni-ai.yaml").option("-g, --glob <pattern>", "Glob of files to watch (default: src/**/*.{ts,js,yaml,json})").option("-d, --debounce <ms>", "Debounce delay in ms (default: 500)").option("--stream", "Stream tokens in real time").action(watchCommand);
+program.command("serve").description("Start a local HTTP server to run agents via REST or SSE").option("-p, --port <number>", "Port to listen on (default: 3000)").option("-c, --config <path>", "Path to omni-ai.yaml").action(serveCommand);
+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 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));
+list.command("providers").description("List registered providers").action((opts) => listCommand("providers", opts));
+program.parseAsync(process.argv).catch((err) => {
+  console.error(err instanceof Error ? err.message : String(err));
+  process.exit(1);
+});