@poncho-ai/harness 0.2.0

package/dist/index.js

@@ -0,0 +1,3015 @@
+// src/agent-parser.ts
+import { randomUUID } from "crypto";
+import { readFile } from "fs/promises";
+import { resolve } from "path";
+import Mustache from "mustache";
+import YAML from "yaml";
+var FRONTMATTER_PATTERN = /^---\s*\n([\s\S]*?)\n---\s*\n?([\s\S]*)$/;
+var asRecord = (value) => typeof value === "object" && value !== null ? value : {};
+var asNumberOrUndefined = (value) => typeof value === "number" ? value : void 0;
+var parseAgentMarkdown = (content) => {
+  const match = content.match(FRONTMATTER_PATTERN);
+  if (!match) {
+    throw new Error(
+      "Invalid AGENT.md: expected YAML frontmatter wrapped in --- markers."
+    );
+  }
+  const parsedYaml = YAML.parse(match[1]) ?? {};
+  const parsed = asRecord(parsedYaml);
+  if (typeof parsed.name !== "string" || parsed.name.trim() === "") {
+    throw new Error("Invalid AGENT.md: frontmatter requires a non-empty `name`.");
+  }
+  const modelValue = asRecord(parsed.model);
+  const limitsValue = asRecord(parsed.limits);
+  const frontmatter = {
+    name: parsed.name,
+    description: typeof parsed.description === "string" ? parsed.description : void 0,
+    model: Object.keys(modelValue).length > 0 ? {
+      provider: typeof modelValue.provider === "string" ? modelValue.provider : "anthropic",
+      name: typeof modelValue.name === "string" ? modelValue.name : "claude-opus-4-5",
+      temperature: asNumberOrUndefined(modelValue.temperature),
+      maxTokens: asNumberOrUndefined(modelValue.maxTokens)
+    } : void 0,
+    limits: Object.keys(limitsValue).length > 0 ? {
+      maxSteps: asNumberOrUndefined(limitsValue.maxSteps),
+      timeout: asNumberOrUndefined(limitsValue.timeout)
+    } : void 0
+  };
+  return {
+    frontmatter,
+    body: match[2].trim()
+  };
+};
+var parseAgentFile = async (workingDir) => {
+  const filePath = resolve(workingDir, "AGENT.md");
+  const content = await readFile(filePath, "utf8");
+  return parseAgentMarkdown(content);
+};
+var renderAgentPrompt = (agent, context = {}) => {
+  const renderContext = {
+    name: agent.frontmatter.name,
+    description: agent.frontmatter.description ?? "",
+    runtime: {
+      workingDir: context.runtime?.workingDir ?? process.cwd(),
+      agentId: context.runtime?.agentId ?? agent.frontmatter.name,
+      runId: context.runtime?.runId ?? `run_${randomUUID()}`,
+      environment: context.runtime?.environment ?? "development"
+    },
+    parameters: context.parameters ?? {}
+  };
+  return Mustache.render(agent.body, renderContext).trim();
+};
+
+// src/config.ts
+import { access } from "fs/promises";
+import { resolve as resolve2 } from "path";
+var resolveTtl = (ttl, key) => {
+  if (typeof ttl === "number") {
+    return ttl;
+  }
+  if (ttl && typeof ttl === "object" && typeof ttl[key] === "number") {
+    return ttl[key];
+  }
+  return void 0;
+};
+var resolveStateConfig = (config) => {
+  if (config?.storage) {
+    return {
+      provider: config.storage.provider,
+      url: config.storage.url,
+      token: config.storage.token,
+      table: config.storage.table,
+      region: config.storage.region,
+      ttl: resolveTtl(config.storage.ttl, "conversations")
+    };
+  }
+  return config?.state;
+};
+var resolveMemoryConfig = (config) => {
+  if (config?.storage) {
+    return {
+      enabled: config.storage.memory?.enabled ?? config.memory?.enabled,
+      provider: config.storage.provider,
+      url: config.storage.url,
+      token: config.storage.token,
+      table: config.storage.table,
+      region: config.storage.region,
+      ttl: resolveTtl(config.storage.ttl, "memory"),
+      maxRecallConversations: config.storage.memory?.maxRecallConversations ?? config.memory?.maxRecallConversations
+    };
+  }
+  return config?.memory;
+};
+var loadPonchoConfig = async (workingDir) => {
+  const filePath = resolve2(workingDir, "poncho.config.js");
+  try {
+    await access(filePath);
+  } catch {
+    return void 0;
+  }
+  const imported = await import(`${filePath}?t=${Date.now()}`);
+  return imported.default;
+};
+
+// src/default-tools.ts
+import { mkdir, readdir, readFile as readFile2, writeFile } from "fs/promises";
+import { dirname, resolve as resolve3, sep } from "path";
+import { defineTool } from "@poncho-ai/sdk";
+var resolveSafePath = (workingDir, inputPath) => {
+  const base = resolve3(workingDir);
+  const target = resolve3(base, inputPath);
+  if (target === base || target.startsWith(`${base}${sep}`)) {
+    return target;
+  }
+  throw new Error("Access denied: path must stay inside the working directory.");
+};
+var createDefaultTools = (workingDir) => [
+  defineTool({
+    name: "list_directory",
+    description: "List files and folders at a path",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Directory path relative to working directory"
+        }
+      },
+      required: ["path"],
+      additionalProperties: false
+    },
+    handler: async (input) => {
+      const path = typeof input.path === "string" ? input.path : ".";
+      const resolved = resolveSafePath(workingDir, path);
+      const entries = await readdir(resolved, { withFileTypes: true });
+      return entries.map((entry) => ({
+        name: entry.name,
+        type: entry.isDirectory() ? "directory" : "file"
+      }));
+    }
+  }),
+  defineTool({
+    name: "read_file",
+    description: "Read UTF-8 text file contents",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "File path relative to working directory"
+        }
+      },
+      required: ["path"],
+      additionalProperties: false
+    },
+    handler: async (input) => {
+      const path = typeof input.path === "string" ? input.path : "";
+      const resolved = resolveSafePath(workingDir, path);
+      const content = await readFile2(resolved, "utf8");
+      return { path, content };
+    }
+  })
+];
+var createWriteTool = (workingDir) => defineTool({
+  name: "write_file",
+  description: "Write UTF-8 text file contents (create or overwrite)",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: {
+        type: "string",
+        description: "File path relative to working directory"
+      },
+      content: {
+        type: "string",
+        description: "Text content to write"
+      }
+    },
+    required: ["path", "content"],
+    additionalProperties: false
+  },
+  handler: async (input) => {
+    const path = typeof input.path === "string" ? input.path : "";
+    const content = typeof input.content === "string" ? input.content : "";
+    const resolved = resolveSafePath(workingDir, path);
+    await mkdir(dirname(resolved), { recursive: true });
+    await writeFile(resolved, content, "utf8");
+    return { path, written: true };
+  }
+});
+
+// src/harness.ts
+import { randomUUID as randomUUID2 } from "crypto";
+
+// src/latitude-capture.ts
+var sanitizePath = (value) => value.trim().replace(/[^a-zA-Z0-9\-_/\.]/g, "-").replace(/-+/g, "-");
+var LatitudeCapture = class {
+  apiKey;
+  telemetryPromise;
+  projectId;
+  path;
+  constructor(config) {
+    this.apiKey = config?.apiKey ?? process.env.LATITUDE_API_KEY;
+    if (!this.apiKey) {
+      return;
+    }
+    const rawProjectId = config?.projectId ?? process.env.LATITUDE_PROJECT_ID;
+    const projectIdNumber = typeof rawProjectId === "number" ? rawProjectId : rawProjectId ? Number.parseInt(rawProjectId, 10) : Number.NaN;
+    this.projectId = Number.isFinite(projectIdNumber) ? projectIdNumber : void 0;
+    const rawPath = config?.path ?? process.env.LATITUDE_PATH ?? process.env.LATITUDE_DOCUMENT_PATH ?? config?.defaultPath;
+    this.path = rawPath ? sanitizePath(rawPath) : void 0;
+  }
+  async initializeTelemetry() {
+    if (!this.apiKey) {
+      return void 0;
+    }
+    try {
+      const [{ LatitudeTelemetry }, AnthropicSdk, { default: OpenAI2 }] = await Promise.all([
+        import("@latitude-data/telemetry"),
+        import("@anthropic-ai/sdk"),
+        import("openai")
+      ]);
+      const disableAnthropicInstrumentation = process.env.LATITUDE_DISABLE_ANTHROPIC_INSTRUMENTATION === "true";
+      return new LatitudeTelemetry(this.apiKey, {
+        instrumentations: {
+          ...disableAnthropicInstrumentation ? {} : { anthropic: AnthropicSdk },
+          openai: OpenAI2
+        }
+      });
+    } catch {
+      return void 0;
+    }
+  }
+  async capture(fn) {
+    if (!this.apiKey || !this.projectId || !this.path) {
+      return await fn();
+    }
+    if (!this.telemetryPromise) {
+      this.telemetryPromise = this.initializeTelemetry();
+    }
+    const telemetry = await this.telemetryPromise;
+    if (!telemetry) {
+      return await fn();
+    }
+    try {
+      return await telemetry.capture(
+        {
+          projectId: this.projectId,
+          path: this.path
+        },
+        fn
+      );
+    } catch {
+      return await fn();
+    }
+  }
+};
+
+// src/memory.ts
+import { createHash } from "crypto";
+import { mkdir as mkdir2, readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
+import { basename, dirname as dirname2, resolve as resolve4 } from "path";
+import { homedir } from "os";
+import { defineTool as defineTool2 } from "@poncho-ai/sdk";
+var DEFAULT_MAIN_MEMORY = {
+  content: "",
+  updatedAt: 0
+};
+var LOCAL_MEMORY_FILE = "local-memory.json";
+var getStateDirectory = () => {
+  const cwd = process.cwd();
+  const home = homedir();
+  const isServerless = process.env.VERCEL === "1" || process.env.VERCEL_ENV !== void 0 || process.env.VERCEL_URL !== void 0 || process.env.AWS_LAMBDA_FUNCTION_NAME !== void 0 || process.env.AWS_EXECUTION_ENV?.includes("AWS_Lambda") === true || process.env.LAMBDA_TASK_ROOT !== void 0 || process.env.NOW_REGION !== void 0 || cwd.startsWith("/var/task") || home.startsWith("/var/task") || process.env.SERVERLESS === "1";
+  if (isServerless) {
+    return "/tmp/.poncho/state";
+  }
+  return resolve4(homedir(), ".poncho", "state");
+};
+var projectScopedMemoryPath = (workingDir) => {
+  const projectName = basename(workingDir).replace(/[^a-zA-Z0-9_-]+/g, "-") || "project";
+  const projectHash = createHash("sha256").update(workingDir).digest("hex").slice(0, 12);
+  return resolve4(getStateDirectory(), `${projectName}-${projectHash}-${LOCAL_MEMORY_FILE}`);
+};
+var scoreText = (text, query) => {
+  const normalized = query.trim().toLowerCase();
+  const tokens = normalized.split(/\s+/).filter(Boolean);
+  if (tokens.length === 0) {
+    return 0;
+  }
+  const haystack = text.toLowerCase();
+  let score = haystack.includes(normalized) ? 5 : 0;
+  for (const token of tokens) {
+    if (haystack.includes(token)) {
+      score += 1;
+    }
+  }
+  return score;
+};
+var InMemoryMemoryStore = class {
+  mainMemory = { ...DEFAULT_MAIN_MEMORY };
+  ttlMs;
+  constructor(ttlSeconds) {
+    this.ttlMs = typeof ttlSeconds === "number" ? ttlSeconds * 1e3 : void 0;
+  }
+  isExpired(updatedAt) {
+    return typeof this.ttlMs === "number" && Date.now() - updatedAt > this.ttlMs;
+  }
+  async getMainMemory() {
+    if (this.mainMemory.updatedAt > 0 && this.isExpired(this.mainMemory.updatedAt)) {
+      this.mainMemory = { ...DEFAULT_MAIN_MEMORY };
+    }
+    return this.mainMemory;
+  }
+  async updateMainMemory(input) {
+    const now2 = Date.now();
+    const existing = await this.getMainMemory();
+    const nextContent = input.mode === "append" && existing.content ? `${existing.content}
+
+${input.content}`.trim() : input.content;
+    this.mainMemory = {
+      content: nextContent.trim(),
+      updatedAt: now2
+    };
+    return this.mainMemory;
+  }
+};
+var FileMainMemoryStore = class {
+  filePath;
+  ttlMs;
+  loaded = false;
+  writing = Promise.resolve();
+  mainMemory = { ...DEFAULT_MAIN_MEMORY };
+  constructor(workingDir, ttlSeconds) {
+    this.filePath = projectScopedMemoryPath(workingDir);
+    this.ttlMs = typeof ttlSeconds === "number" ? ttlSeconds * 1e3 : void 0;
+  }
+  isExpired(updatedAt) {
+    return typeof this.ttlMs === "number" && Date.now() - updatedAt > this.ttlMs;
+  }
+  async ensureLoaded() {
+    if (this.loaded) {
+      return;
+    }
+    this.loaded = true;
+    try {
+      const raw = await readFile3(this.filePath, "utf8");
+      const parsed = JSON.parse(raw);
+      const content = typeof parsed.main?.content === "string" ? parsed.main.content : "";
+      const updatedAt = typeof parsed.main?.updatedAt === "number" ? parsed.main.updatedAt : 0;
+      this.mainMemory = { content, updatedAt };
+    } catch {
+    }
+  }
+  async persist() {
+    const payload = { main: this.mainMemory };
+    this.writing = this.writing.then(async () => {
+      await mkdir2(dirname2(this.filePath), { recursive: true });
+      await writeFile2(this.filePath, JSON.stringify(payload, null, 2), "utf8");
+    });
+    await this.writing;
+  }
+  async getMainMemory() {
+    await this.ensureLoaded();
+    if (this.mainMemory.updatedAt > 0 && this.isExpired(this.mainMemory.updatedAt)) {
+      this.mainMemory = { ...DEFAULT_MAIN_MEMORY };
+      await this.persist();
+    }
+    return this.mainMemory;
+  }
+  async updateMainMemory(input) {
+    await this.ensureLoaded();
+    const existing = await this.getMainMemory();
+    const nextContent = input.mode === "append" && existing.content ? `${existing.content}
+
+${input.content}`.trim() : input.content;
+    this.mainMemory = {
+      content: nextContent.trim(),
+      updatedAt: Date.now()
+    };
+    await this.persist();
+    return this.mainMemory;
+  }
+};
+var KeyValueMainMemoryStoreBase = class {
+  ttl;
+  memoryFallback;
+  constructor(ttl) {
+    this.ttl = ttl;
+    this.memoryFallback = new InMemoryMemoryStore(ttl);
+  }
+  async readPayload(key) {
+    try {
+      const raw = await this.getRaw(key);
+      if (!raw) {
+        return { main: { ...DEFAULT_MAIN_MEMORY } };
+      }
+      const parsed = JSON.parse(raw);
+      const content = typeof parsed.main?.content === "string" ? parsed.main.content : "";
+      const updatedAt = typeof parsed.main?.updatedAt === "number" ? parsed.main.updatedAt : 0;
+      return { main: { content, updatedAt } };
+    } catch {
+      const main = await this.memoryFallback.getMainMemory();
+      return { main };
+    }
+  }
+  async writePayload(key, payload) {
+    try {
+      const serialized = JSON.stringify(payload);
+      if (typeof this.ttl === "number") {
+        await this.setRawWithTtl(key, serialized, Math.max(1, this.ttl));
+      } else {
+        await this.setRaw(key, serialized);
+      }
+    } catch {
+      await this.memoryFallback.updateMainMemory({
+        content: payload.main.content,
+        mode: "replace"
+      });
+    }
+  }
+  async getMainMemory() {
+    const payload = await this.readPayload(this.key());
+    return payload.main;
+  }
+  async updateMainMemory(input) {
+    const key = this.key();
+    const payload = await this.readPayload(key);
+    const nextContent = input.mode === "append" && payload.main.content ? `${payload.main.content}
+
+${input.content}`.trim() : input.content;
+    payload.main = {
+      content: nextContent.trim(),
+      updatedAt: Date.now()
+    };
+    await this.writePayload(key, payload);
+    return payload.main;
+  }
+};
+var UpstashMemoryStore = class extends KeyValueMainMemoryStoreBase {
+  baseUrl;
+  token;
+  storageKey;
+  constructor(options) {
+    super(options.ttl);
+    this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+    this.token = options.token;
+    this.storageKey = options.storageKey;
+  }
+  key() {
+    return this.storageKey;
+  }
+  headers() {
+    return {
+      Authorization: `Bearer ${this.token}`,
+      "Content-Type": "application/json"
+    };
+  }
+  async getRaw(key) {
+    const response = await fetch(`${this.baseUrl}/get/${encodeURIComponent(key)}`, {
+      method: "POST",
+      headers: this.headers()
+    });
+    if (!response.ok) {
+      return void 0;
+    }
+    const payload = await response.json();
+    return payload.result ?? void 0;
+  }
+  async setRaw(key, value) {
+    await fetch(
+      `${this.baseUrl}/set/${encodeURIComponent(key)}/${encodeURIComponent(value)}`,
+      { method: "POST", headers: this.headers() }
+    );
+  }
+  async setRawWithTtl(key, value, ttl) {
+    await fetch(
+      `${this.baseUrl}/setex/${encodeURIComponent(key)}/${Math.max(1, ttl)}/${encodeURIComponent(
+        value
+      )}`,
+      { method: "POST", headers: this.headers() }
+    );
+  }
+};
+var RedisMemoryStore = class extends KeyValueMainMemoryStoreBase {
+  storageKey;
+  clientPromise;
+  constructor(options) {
+    super(options.ttl);
+    this.storageKey = options.storageKey;
+    this.clientPromise = (async () => {
+      try {
+        const redisModule = await import("redis");
+        const client = redisModule.createClient({ url: options.url });
+        await client.connect();
+        return client;
+      } catch {
+        return void 0;
+      }
+    })();
+  }
+  key() {
+    return this.storageKey;
+  }
+  async getRaw(key) {
+    const client = await this.clientPromise;
+    if (!client) {
+      throw new Error("Redis unavailable");
+    }
+    const value = await client.get(key);
+    return value ?? void 0;
+  }
+  async setRaw(key, value) {
+    const client = await this.clientPromise;
+    if (!client) {
+      throw new Error("Redis unavailable");
+    }
+    await client.set(key, value);
+  }
+  async setRawWithTtl(key, value, ttl) {
+    const client = await this.clientPromise;
+    if (!client) {
+      throw new Error("Redis unavailable");
+    }
+    await client.set(key, value, { EX: Math.max(1, ttl) });
+  }
+};
+var DynamoDbMemoryStore = class extends KeyValueMainMemoryStoreBase {
+  storageKey;
+  table;
+  clientPromise;
+  constructor(options) {
+    super(options.ttl);
+    this.storageKey = options.storageKey;
+    this.table = options.table;
+    this.clientPromise = (async () => {
+      try {
+        const module = await import("@aws-sdk/client-dynamodb");
+        const client = new module.DynamoDBClient({ region: options.region });
+        return {
+          send: client.send.bind(client),
+          GetItemCommand: module.GetItemCommand,
+          PutItemCommand: module.PutItemCommand
+        };
+      } catch {
+        return void 0;
+      }
+    })();
+  }
+  key() {
+    return this.storageKey;
+  }
+  async getRaw(key) {
+    const client = await this.clientPromise;
+    if (!client) {
+      throw new Error("DynamoDB unavailable");
+    }
+    const result = await client.send(
+      new client.GetItemCommand({
+        TableName: this.table,
+        Key: { runId: { S: key } }
+      })
+    );
+    return result.Item?.value?.S;
+  }
+  async setRaw(key, value) {
+    const client = await this.clientPromise;
+    if (!client) {
+      throw new Error("DynamoDB unavailable");
+    }
+    await client.send(
+      new client.PutItemCommand({
+        TableName: this.table,
+        Item: {
+          runId: { S: key },
+          value: { S: value }
+        }
+      })
+    );
+  }
+  async setRawWithTtl(key, value, ttl) {
+    const client = await this.clientPromise;
+    if (!client) {
+      throw new Error("DynamoDB unavailable");
+    }
+    const ttlEpoch = Math.floor(Date.now() / 1e3) + Math.max(1, ttl);
+    await client.send(
+      new client.PutItemCommand({
+        TableName: this.table,
+        Item: {
+          runId: { S: key },
+          value: { S: value },
+          ttl: { N: String(ttlEpoch) }
+        }
+      })
+    );
+  }
+};
+var createMemoryStore = (agentId, config, options) => {
+  const provider = config?.provider ?? "local";
+  const ttl = config?.ttl;
+  const storageKey = `poncho:memory:${agentId}:main`;
+  const workingDir = options?.workingDir ?? process.cwd();
+  if (provider === "local") {
+    return new FileMainMemoryStore(workingDir, ttl);
+  }
+  if (provider === "memory") {
+    return new InMemoryMemoryStore(ttl);
+  }
+  if (provider === "upstash") {
+    const url = config?.url ?? process.env.UPSTASH_REDIS_REST_URL ?? process.env.KV_REST_API_URL ?? "";
+    const token = config?.token ?? process.env.UPSTASH_REDIS_REST_TOKEN ?? process.env.KV_REST_API_TOKEN ?? "";
+    if (url && token) {
+      return new UpstashMemoryStore({
+        baseUrl: url,
+        token,
+        storageKey,
+        ttl
+      });
+    }
+    return new InMemoryMemoryStore(ttl);
+  }
+  if (provider === "redis") {
+    const url = config?.url ?? process.env.REDIS_URL ?? "";
+    if (url) {
+      return new RedisMemoryStore({
+        url,
+        storageKey,
+        ttl
+      });
+    }
+    return new InMemoryMemoryStore(ttl);
+  }
+  if (provider === "dynamodb") {
+    const table = config?.table ?? process.env.PONCHO_DYNAMODB_TABLE ?? "";
+    if (table) {
+      return new DynamoDbMemoryStore({
+        table,
+        storageKey,
+        region: config?.region,
+        ttl
+      });
+    }
+    return new InMemoryMemoryStore(ttl);
+  }
+  return new InMemoryMemoryStore(ttl);
+};
+var asRecallCorpus = (raw) => {
+  if (!Array.isArray(raw)) {
+    return [];
+  }
+  return raw.map((item) => {
+    if (!item || typeof item !== "object") {
+      return void 0;
+    }
+    const record = item;
+    const conversationId = typeof record.conversationId === "string" ? record.conversationId : "";
+    const title = typeof record.title === "string" ? record.title : "Conversation";
+    const updatedAt = typeof record.updatedAt === "number" ? record.updatedAt : 0;
+    const content = typeof record.content === "string" ? record.content : "";
+    if (!conversationId || !content) {
+      return void 0;
+    }
+    return { conversationId, title, updatedAt, content };
+  }).filter((item) => Boolean(item));
+};
+var buildRecallSnippet = (content, query, maxChars = 360) => {
+  const normalized = query.trim().toLowerCase();
+  const index = content.toLowerCase().indexOf(normalized);
+  if (index === -1) {
+    return content.slice(0, maxChars);
+  }
+  const start = Math.max(0, index - 120);
+  const end = Math.min(content.length, index + normalized.length + 180);
+  return content.slice(start, end);
+};
+var createMemoryTools = (store, options) => {
+  const maxRecallConversations = Math.max(1, options?.maxRecallConversations ?? 20);
+  return [
+    defineTool2({
+      name: "memory_main_get",
+      description: "Get the current persistent main memory document.",
+      inputSchema: {
+        type: "object",
+        properties: {},
+        additionalProperties: false
+      },
+      handler: async () => {
+        const memory = await store.getMainMemory();
+        return { memory };
+      }
+    }),
+    defineTool2({
+      name: "memory_main_update",
+      description: "Update persistent main memory when new stable preferences, long-term goals, or durable facts appear. Proactively evaluate every turn whether memory should be updated, and avoid storing ephemeral details.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          mode: {
+            type: "string",
+            enum: ["replace", "append"],
+            description: "replace overwrites memory; append adds content to the end"
+          },
+          content: {
+            type: "string",
+            description: "The memory content to write"
+          }
+        },
+        required: ["content"],
+        additionalProperties: false
+      },
+      handler: async (input) => {
+        const content = typeof input.content === "string" ? input.content.trim() : "";
+        if (!content) {
+          throw new Error("content is required");
+        }
+        const mode = input.mode === "append" || input.mode === "replace" ? input.mode : "replace";
+        const memory = await store.updateMainMemory({ content, mode });
+        return { ok: true, memory };
+      }
+    }),
+    defineTool2({
+      name: "conversation_recall",
+      description: "Recall relevant snippets from previous conversations when prior context is likely important (for example: 'as we discussed', 'last time', or ambiguous references).",
+      inputSchema: {
+        type: "object",
+        properties: {
+          query: {
+            type: "string",
+            description: "Search query for past conversation recall"
+          },
+          limit: {
+            type: "number",
+            description: "Maximum snippets to return"
+          },
+          excludeConversationId: {
+            type: "string",
+            description: "Optional conversation id to exclude from recall"
+          }
+        },
+        required: ["query"],
+        additionalProperties: false
+      },
+      handler: async (input, context) => {
+        const query = typeof input.query === "string" ? input.query.trim() : "";
+        if (!query) {
+          throw new Error("query is required");
+        }
+        const limit = Math.max(
+          1,
+          Math.min(5, typeof input.limit === "number" ? input.limit : 3)
+        );
+        const excludeConversationId = typeof input.excludeConversationId === "string" ? input.excludeConversationId : "";
+        const corpus = asRecallCorpus(context.parameters.__conversationRecallCorpus).slice(
+          0,
+          maxRecallConversations
+        );
+        const results = corpus.filter(
+          (item) => excludeConversationId ? item.conversationId !== excludeConversationId : true
+        ).map((item) => ({
+          ...item,
+          score: scoreText(`${item.title}
+${item.content}`, query)
+        })).filter((item) => item.score > 0).sort((a, b) => {
+          if (b.score === a.score) {
+            return b.updatedAt - a.updatedAt;
+          }
+          return b.score - a.score;
+        }).slice(0, limit).map((item) => ({
+          conversationId: item.conversationId,
+          title: item.title,
+          updatedAt: item.updatedAt,
+          snippet: buildRecallSnippet(item.content, query)
+        }));
+        return { results };
+      }
+    })
+  ];
+};
+
+// src/mcp.ts
+import { WebSocket } from "ws";
+var WebSocketMcpRpcClient = class {
+  ws;
+  url;
+  timeoutMs;
+  reconnectAttempts;
+  reconnectDelayMs;
+  idCounter = 1;
+  pending = /* @__PURE__ */ new Map();
+  opened = false;
+  constructor(url, timeoutMs = 1e4, reconnectAttempts = 3, reconnectDelayMs = 500) {
+    this.url = url;
+    this.timeoutMs = timeoutMs;
+    this.reconnectAttempts = reconnectAttempts;
+    this.reconnectDelayMs = reconnectDelayMs;
+  }
+  attachHandlers(ws) {
+    ws.on("open", () => {
+      this.opened = true;
+    });
+    ws.on("message", (data) => {
+      try {
+        const message = JSON.parse(String(data));
+        if (typeof message.id !== "number") {
+          return;
+        }
+        const pending = this.pending.get(message.id);
+        if (!pending) {
+          return;
+        }
+        clearTimeout(pending.timer);
+        this.pending.delete(message.id);
+        if (message.error) {
+          pending.reject(new Error(message.error.message ?? "MCP RPC error"));
+        } else {
+          pending.resolve(message.result);
+        }
+      } catch {
+      }
+    });
+    ws.on("close", () => {
+      this.opened = false;
+      for (const [, pending] of this.pending) {
+        clearTimeout(pending.timer);
+        pending.reject(new Error("MCP websocket closed"));
+      }
+      this.pending.clear();
+    });
+  }
+  async openSocket() {
+    const ws = new WebSocket(this.url);
+    this.ws = ws;
+    this.attachHandlers(ws);
+    await new Promise((resolvePromise, rejectPromise) => {
+      const timeout = setTimeout(() => {
+        rejectPromise(new Error("MCP websocket open timeout"));
+      }, this.timeoutMs);
+      ws.once("open", () => {
+        clearTimeout(timeout);
+        resolvePromise();
+      });
+      ws.once("error", (error) => {
+        clearTimeout(timeout);
+        rejectPromise(error);
+      });
+    });
+  }
+  async waitUntilOpen() {
+    if (this.opened && this.ws && this.ws.readyState === WebSocket.OPEN) {
+      return;
+    }
+    let lastError;
+    for (let attempt = 1; attempt <= this.reconnectAttempts; attempt += 1) {
+      try {
+        await this.openSocket();
+        return;
+      } catch (error) {
+        lastError = error;
+        await new Promise(
+          (resolvePromise) => setTimeout(resolvePromise, this.reconnectDelayMs * attempt)
+        );
+      }
+    }
+    throw lastError instanceof Error ? lastError : new Error("Unable to connect to remote MCP websocket");
+  }
+  async request(method, params) {
+    await this.waitUntilOpen();
+    const id = this.idCounter++;
+    const payload = JSON.stringify({
+      jsonrpc: "2.0",
+      id,
+      method,
+      params: params ?? {}
+    });
+    const resultPromise = new Promise((resolvePromise, rejectPromise) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        rejectPromise(new Error(`MCP websocket timeout for method ${method}`));
+      }, this.timeoutMs);
+      this.pending.set(id, { resolve: resolvePromise, reject: rejectPromise, timer });
+    });
+    const socket = this.ws;
+    if (!socket || socket.readyState !== WebSocket.OPEN) {
+      throw new Error("MCP websocket is not connected");
+    }
+    socket.send(payload);
+    return await resultPromise;
+  }
+  async listTools() {
+    const result = await this.request("tools/list");
+    const value = result?.tools;
+    return Array.isArray(value) ? value : [];
+  }
+  async callTool(name, input) {
+    const result = await this.request("tools/call", { name, arguments: input });
+    return result?.result ?? result?.content ?? result;
+  }
+  async close() {
+    this.ws?.close();
+    this.ws = void 0;
+    this.opened = false;
+  }
+};
+var LocalMcpBridge = class {
+  remoteServers;
+  rpcClients = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.remoteServers = (config?.mcp ?? []).filter(
+      (entry) => typeof entry.url === "string"
+    );
+  }
+  async loadTools() {
+    const tools = [];
+    for (const remoteServer of this.remoteServers) {
+      const name = remoteServer.name ?? remoteServer.url;
+      const client = this.rpcClients.get(name);
+      if (!client) {
+        continue;
+      }
+      try {
+        const discovered = await client.listTools();
+        tools.push(...this.toToolDefinitions(name, discovered, client));
+      } catch {
+      }
+    }
+    return tools;
+  }
+  async startLocalServers() {
+    for (const server of this.remoteServers) {
+      const name = server.name ?? server.url;
+      this.rpcClients.set(
+        name,
+        new WebSocketMcpRpcClient(
+          server.url,
+          server.timeoutMs ?? 1e4,
+          server.reconnectAttempts ?? 3,
+          server.reconnectDelayMs ?? 500
+        )
+      );
+    }
+  }
+  async stopLocalServers() {
+    for (const [, client] of this.rpcClients) {
+      await client.close();
+    }
+    this.rpcClients.clear();
+  }
+  listServers() {
+    return [...this.remoteServers];
+  }
+  listRemoteServers() {
+    return this.remoteServers;
+  }
+  async checkRemoteConnectivity() {
+    const checks = [];
+    for (const remote of this.remoteServers) {
+      try {
+        if (remote.url.startsWith("http://") || remote.url.startsWith("https://")) {
+          const response = await fetch(remote.url, { method: "HEAD" });
+          checks.push({ url: remote.url, ok: response.ok });
+        } else {
+          checks.push({ url: remote.url, ok: true });
+        }
+      } catch (error) {
+        checks.push({
+          url: remote.url,
+          ok: false,
+          error: error instanceof Error ? error.message : "Unknown connectivity error"
+        });
+      }
+    }
+    return checks;
+  }
+  toSerializableConfig() {
+    return { mcp: [...this.remoteServers] };
+  }
+  getLocalServers() {
+    return [];
+  }
+  toToolDefinitions(serverName, tools, client) {
+    return tools.map((tool) => ({
+      name: `${serverName}:${tool.name}`,
+      description: tool.description ?? `MCP tool ${tool.name} from ${serverName}`,
+      inputSchema: tool.inputSchema ?? {
+        type: "object",
+        properties: {}
+      },
+      handler: async (input) => await client.callTool(tool.name, input)
+    }));
+  }
+};
+
+// src/anthropic-client.ts
+import Anthropic from "@anthropic-ai/sdk";
+var toAnthropicMessages = (messages) => messages.flatMap((message) => {
+  if (message.role === "system") {
+    return [];
+  }
+  if (message.role === "tool") {
+    return [{ role: "user", content: message.content }];
+  }
+  return [{ role: message.role, content: message.content }];
+});
+var AnthropicModelClient = class {
+  client;
+  latitudeCapture;
+  constructor(apiKey, options) {
+    this.client = new Anthropic({
+      apiKey: apiKey ?? process.env.ANTHROPIC_API_KEY
+    });
+    this.latitudeCapture = options?.latitudeCapture;
+  }
+  async *generateStream(input) {
+    let stream;
+    try {
+      stream = await (this.latitudeCapture?.capture(
+        async () => this.client.messages.stream({
+          model: input.modelName,
+          max_tokens: input.maxTokens ?? 1024,
+          temperature: input.temperature ?? 0.2,
+          system: input.systemPrompt,
+          messages: toAnthropicMessages(input.messages),
+          tools: input.tools.map((tool) => ({
+            name: tool.name,
+            description: tool.description,
+            input_schema: tool.inputSchema
+          }))
+        })
+      ) ?? this.client.messages.stream({
+        model: input.modelName,
+        max_tokens: input.maxTokens ?? 1024,
+        temperature: input.temperature ?? 0.2,
+        system: input.systemPrompt,
+        messages: toAnthropicMessages(input.messages),
+        tools: input.tools.map((tool) => ({
+          name: tool.name,
+          description: tool.description,
+          input_schema: tool.inputSchema
+        }))
+      }));
+    } catch (error) {
+      const maybeStatus = error.status;
+      if (maybeStatus === 404) {
+        throw new Error(
+          `Anthropic model not found: ${input.modelName}. Update AGENT.md frontmatter model.name to a valid model (for example: claude-opus-4-5).`
+        );
+      }
+      throw error;
+    }
+    let text = "";
+    for await (const event of stream) {
+      if (event.type === "content_block_delta" && event.delta?.type === "text_delta" && typeof event.delta.text === "string" && event.delta.text.length > 0) {
+        text += event.delta.text;
+        yield { type: "chunk", content: event.delta.text };
+      }
+    }
+    const response = await stream.finalMessage();
+    const toolCalls = [];
+    for (const block of response.content) {
+      if (block.type === "text") {
+        if (text.length === 0 && block.text) {
+          text = block.text;
+        }
+      }
+      if (block.type === "tool_use") {
+        toolCalls.push({
+          id: block.id,
+          name: block.name,
+          input: block.input ?? {}
+        });
+      }
+    }
+    yield {
+      type: "final",
+      response: {
+        text,
+        toolCalls,
+        usage: {
+          input: response.usage.input_tokens,
+          output: response.usage.output_tokens
+        },
+        rawContent: response.content
+      }
+    };
+  }
+  async generate(input) {
+    let finalResponse;
+    for await (const event of this.generateStream(input)) {
+      if (event.type === "final") {
+        finalResponse = event.response;
+      }
+    }
+    if (!finalResponse) {
+      throw new Error("Anthropic response ended without final payload");
+    }
+    return finalResponse;
+  }
+};
+
+// src/openai-client.ts
+import OpenAI from "openai";
+var toOpenAiMessages = (systemPrompt, messages) => {
+  const mapped = [{ role: "system", content: systemPrompt }];
+  for (const message of messages) {
+    if (message.role === "system") {
+      continue;
+    }
+    if (message.role === "tool") {
+      mapped.push({
+        role: "user",
+        content: `Tool result context: ${message.content}`
+      });
+      continue;
+    }
+    mapped.push({ role: message.role, content: message.content });
+  }
+  return mapped;
+};
+var OpenAiModelClient = class {
+  client;
+  latitudeCapture;
+  constructor(apiKey, options) {
+    this.client = new OpenAI({
+      apiKey: apiKey ?? process.env.OPENAI_API_KEY ?? "missing-openai-key"
+    });
+    this.latitudeCapture = options?.latitudeCapture;
+  }
+  async *generateStream(input) {
+    const stream = await (this.latitudeCapture?.capture(
+      async () => this.client.chat.completions.create({
+        model: input.modelName,
+        temperature: input.temperature ?? 0.2,
+        max_tokens: input.maxTokens ?? 1024,
+        messages: toOpenAiMessages(input.systemPrompt, input.messages),
+        tools: input.tools.map((tool) => ({
+          type: "function",
+          function: {
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.inputSchema
+          }
+        })),
+        tool_choice: "auto",
+        stream: true,
+        stream_options: { include_usage: true }
+      })
+    ) ?? this.client.chat.completions.create({
+      model: input.modelName,
+      temperature: input.temperature ?? 0.2,
+      max_tokens: input.maxTokens ?? 1024,
+      messages: toOpenAiMessages(input.systemPrompt, input.messages),
+      tools: input.tools.map((tool) => ({
+        type: "function",
+        function: {
+          name: tool.name,
+          description: tool.description,
+          parameters: tool.inputSchema
+        }
+      })),
+      tool_choice: "auto",
+      stream: true,
+      stream_options: { include_usage: true }
+    }));
+    let text = "";
+    let inputTokens = 0;
+    let outputTokens = 0;
+    const toolCallsByIndex = /* @__PURE__ */ new Map();
+    for await (const chunk of stream) {
+      if (chunk.usage) {
+        inputTokens = chunk.usage.prompt_tokens ?? inputTokens;
+        outputTokens = chunk.usage.completion_tokens ?? outputTokens;
+      }
+      const delta = chunk.choices[0]?.delta;
+      if (delta?.content) {
+        text += delta.content;
+        yield { type: "chunk", content: delta.content };
+      }
+      for (const toolCall of delta?.tool_calls ?? []) {
+        const index = toolCall.index ?? 0;
+        const current = toolCallsByIndex.get(index) ?? {
+          id: toolCall.id ?? `tool_call_${index}`,
+          name: "",
+          argumentsJson: ""
+        };
+        if (toolCall.id) {
+          current.id = toolCall.id;
+        }
+        if (toolCall.function?.name) {
+          current.name = toolCall.function.name;
+        }
+        if (toolCall.function?.arguments) {
+          current.argumentsJson += toolCall.function.arguments;
+        }
+        toolCallsByIndex.set(index, current);
+      }
+    }
+    const toolCalls = Array.from(toolCallsByIndex.values()).filter((call) => call.name.length > 0).map((call) => {
+      let parsedInput = {};
+      if (call.argumentsJson.trim().length > 0) {
+        try {
+          parsedInput = JSON.parse(call.argumentsJson);
+        } catch {
+          parsedInput = { raw: call.argumentsJson };
+        }
+      }
+      return {
+        id: call.id,
+        name: call.name,
+        input: parsedInput
+      };
+    });
+    yield {
+      type: "final",
+      response: {
+        text,
+        toolCalls,
+        usage: {
+          input: inputTokens,
+          output: outputTokens
+        },
+        rawContent: []
+      }
+    };
+  }
+  async generate(input) {
+    let finalResponse;
+    for await (const event of this.generateStream(input)) {
+      if (event.type === "final") {
+        finalResponse = event.response;
+      }
+    }
+    if (!finalResponse) {
+      throw new Error("OpenAI response ended without final payload");
+    }
+    return finalResponse;
+  }
+};
+
+// src/model-factory.ts
+var createModelClient = (provider, options) => {
+  const normalized = (provider ?? "anthropic").toLowerCase();
+  if (normalized === "openai") {
+    return new OpenAiModelClient(void 0, options);
+  }
+  return new AnthropicModelClient(void 0, options);
+};
+
+// src/skill-context.ts
+import { readFile as readFile4, readdir as readdir2 } from "fs/promises";
+import { dirname as dirname3, resolve as resolve5, normalize } from "path";
+import YAML2 from "yaml";
+var DEFAULT_SKILL_DIRS = ["skills"];
+var resolveSkillDirs = (workingDir, extraPaths) => {
+  const dirs = [...DEFAULT_SKILL_DIRS];
+  if (extraPaths) {
+    for (const p of extraPaths) {
+      if (!dirs.includes(p)) {
+        dirs.push(p);
+      }
+    }
+  }
+  return dirs.map((d) => resolve5(workingDir, d));
+};
+var FRONTMATTER_PATTERN2 = /^---\s*\n([\s\S]*?)\n---\s*\n?([\s\S]*)$/;
+var asRecord2 = (value) => typeof value === "object" && value !== null ? value : {};
+var parseSkillFrontmatter = (content) => {
+  const match = content.match(FRONTMATTER_PATTERN2);
+  if (!match) {
+    return void 0;
+  }
+  const parsedYaml = YAML2.parse(match[1]) ?? {};
+  const parsed = asRecord2(parsedYaml);
+  const name = typeof parsed.name === "string" ? parsed.name.trim() : "";
+  if (!name) {
+    return void 0;
+  }
+  const description = typeof parsed.description === "string" ? parsed.description.trim() : "";
+  const allowedToolsValue = parsed["allowed-tools"];
+  const allowedTools = typeof allowedToolsValue === "string" ? allowedToolsValue.split(/\s+/).map((tool) => tool.trim()).filter((tool) => tool.length > 0) : [];
+  const legacyToolsValue = parsed.tools;
+  const legacyTools = Array.isArray(legacyToolsValue) ? legacyToolsValue.filter((tool) => typeof tool === "string") : [];
+  const tools = allowedTools.length > 0 ? allowedTools : legacyTools;
+  return { name, description, tools };
+};
+var collectSkillManifests = async (directory) => {
+  const entries = await readdir2(directory, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const fullPath = resolve5(directory, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await collectSkillManifests(fullPath));
+      continue;
+    }
+    if (entry.isFile() && entry.name.toLowerCase() === "skill.md") {
+      files.push(fullPath);
+    }
+  }
+  return files;
+};
+var loadSkillMetadata = async (workingDir, extraSkillPaths) => {
+  const skillDirs = resolveSkillDirs(workingDir, extraSkillPaths);
+  const allManifests = [];
+  for (const dir of skillDirs) {
+    try {
+      allManifests.push(...await collectSkillManifests(dir));
+    } catch {
+    }
+  }
+  const skills = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const manifest of allManifests) {
+    try {
+      const content = await readFile4(manifest, "utf8");
+      const parsed = parseSkillFrontmatter(content);
+      if (parsed && !seen.has(parsed.name)) {
+        seen.add(parsed.name);
+        skills.push({
+          ...parsed,
+          skillDir: dirname3(manifest),
+          skillPath: manifest
+        });
+      }
+    } catch {
+    }
+  }
+  return skills;
+};
+var buildSkillContextWindow = (skills) => {
+  if (skills.length === 0) {
+    return "";
+  }
+  const xmlSkills = skills.map((skill) => {
+    const lines = [
+      "  <skill>",
+      `    <name>${escapeXml(skill.name)}</name>`
+    ];
+    if (skill.description) {
+      lines.push(
+        `    <description>${escapeXml(skill.description)}</description>`
+      );
+    }
+    lines.push("  </skill>");
+    return lines.join("\n");
+  }).join("\n");
+  return `<available_skills description="Skills the agent can use. Use the activate_skill tool to load full instructions for a skill when a user's request matches its description.">
+${xmlSkills}
+</available_skills>`;
+};
+var escapeXml = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+var loadSkillInstructions = async (skill) => {
+  const content = await readFile4(skill.skillPath, "utf8");
+  const match = content.match(FRONTMATTER_PATTERN2);
+  return match ? match[2].trim() : content.trim();
+};
+var readSkillResource = async (skill, relativePath) => {
+  const normalized = normalize(relativePath);
+  if (normalized.startsWith("..") || normalized.startsWith("/")) {
+    throw new Error("Path must be relative and within the skill directory");
+  }
+  const fullPath = resolve5(skill.skillDir, normalized);
+  if (!fullPath.startsWith(skill.skillDir)) {
+    throw new Error("Path escapes the skill directory");
+  }
+  return await readFile4(fullPath, "utf8");
+};
+var MAX_INSTRUCTIONS_PER_SKILL = 1200;
+var loadSkillContext = async (workingDir) => {
+  const metadata = await loadSkillMetadata(workingDir);
+  const entries = [];
+  for (const skill of metadata) {
+    try {
+      const instructions = await loadSkillInstructions(skill);
+      const trimmed = instructions.length > MAX_INSTRUCTIONS_PER_SKILL ? `${instructions.slice(0, MAX_INSTRUCTIONS_PER_SKILL)}...` : instructions;
+      entries.push({ ...skill, instructions: trimmed });
+    } catch {
+      entries.push({ ...skill, instructions: "" });
+    }
+  }
+  return entries;
+};
+
+// src/skill-tools.ts
+import { defineTool as defineTool3 } from "@poncho-ai/sdk";
+import { access as access2, readdir as readdir3 } from "fs/promises";
+import { extname, normalize as normalize2, resolve as resolve6, sep as sep2 } from "path";
+import { pathToFileURL } from "url";
+import { createJiti } from "jiti";
+var createSkillTools = (skills) => {
+  if (skills.length === 0) {
+    return [];
+  }
+  const skillsByName = new Map(skills.map((skill) => [skill.name, skill]));
+  const knownNames = skills.map((skill) => skill.name).join(", ");
+  return [
+    defineTool3({
+      name: "activate_skill",
+      description: `Load the full instructions for an available skill. Use this when a user's request matches a skill's description. Available skills: ${knownNames}`,
+      inputSchema: {
+        type: "object",
+        properties: {
+          name: {
+            type: "string",
+            description: "Name of the skill to activate"
+          }
+        },
+        required: ["name"],
+        additionalProperties: false
+      },
+      handler: async (input) => {
+        const name = typeof input.name === "string" ? input.name.trim() : "";
+        const skill = skillsByName.get(name);
+        if (!skill) {
+          return {
+            error: `Unknown skill: "${name}". Available skills: ${knownNames}`
+          };
+        }
+        try {
+          const instructions = await loadSkillInstructions(skill);
+          return {
+            skill: name,
+            instructions: instructions || "(no instructions provided)"
+          };
+        } catch (err) {
+          return {
+            error: `Failed to load skill "${name}": ${err instanceof Error ? err.message : String(err)}`
+          };
+        }
+      }
+    }),
+    defineTool3({
+      name: "read_skill_resource",
+      description: `Read a file from a skill's directory (references, scripts, assets). Use relative paths from the skill root. Available skills: ${knownNames}`,
+      inputSchema: {
+        type: "object",
+        properties: {
+          skill: {
+            type: "string",
+            description: "Name of the skill"
+          },
+          path: {
+            type: "string",
+            description: "Relative path to the file within the skill directory (e.g. references/REFERENCE.md)"
+          }
+        },
+        required: ["skill", "path"],
+        additionalProperties: false
+      },
+      handler: async (input) => {
+        const name = typeof input.skill === "string" ? input.skill.trim() : "";
+        const path = typeof input.path === "string" ? input.path.trim() : "";
+        const skill = skillsByName.get(name);
+        if (!skill) {
+          return {
+            error: `Unknown skill: "${name}". Available skills: ${knownNames}`
+          };
+        }
+        if (!path) {
+          return { error: "Path is required" };
+        }
+        try {
+          const content = await readSkillResource(skill, path);
+          return { skill: name, path, content };
+        } catch (err) {
+          return {
+            error: `Failed to read "${path}" from skill "${name}": ${err instanceof Error ? err.message : String(err)}`
+          };
+        }
+      }
+    }),
+    defineTool3({
+      name: "list_skill_scripts",
+      description: `List JavaScript/TypeScript script files available under a skill's scripts directory. Available skills: ${knownNames}`,
+      inputSchema: {
+        type: "object",
+        properties: {
+          skill: {
+            type: "string",
+            description: "Name of the skill"
+          }
+        },
+        required: ["skill"],
+        additionalProperties: false
+      },
+      handler: async (input) => {
+        const name = typeof input.skill === "string" ? input.skill.trim() : "";
+        const skill = skillsByName.get(name);
+        if (!skill) {
+          return {
+            error: `Unknown skill: "${name}". Available skills: ${knownNames}`
+          };
+        }
+        try {
+          const scripts = await listSkillScripts(skill);
+          return {
+            skill: name,
+            scripts
+          };
+        } catch (err) {
+          return {
+            error: `Failed to list scripts for skill "${name}": ${err instanceof Error ? err.message : String(err)}`
+          };
+        }
+      }
+    }),
+    defineTool3({
+      name: "run_skill_script",
+      description: `Run a JavaScript/TypeScript module in a skill's scripts directory. Uses default export function or named run/main/handler function. Available skills: ${knownNames}`,
+      inputSchema: {
+        type: "object",
+        properties: {
+          skill: {
+            type: "string",
+            description: "Name of the skill"
+          },
+          script: {
+            type: "string",
+            description: "Relative path under scripts/ (e.g. scripts/summarize.ts or summarize.ts)"
+          },
+          input: {
+            type: "object",
+            description: "Optional JSON input payload passed to the script function"
+          }
+        },
+        required: ["skill", "script"],
+        additionalProperties: false
+      },
+      handler: async (input) => {
+        const name = typeof input.skill === "string" ? input.skill.trim() : "";
+        const script = typeof input.script === "string" ? input.script.trim() : "";
+        const payload = typeof input.input === "object" && input.input !== null ? input.input : {};
+        const skill = skillsByName.get(name);
+        if (!skill) {
+          return {
+            error: `Unknown skill: "${name}". Available skills: ${knownNames}`
+          };
+        }
+        if (!script) {
+          return { error: "Script path is required" };
+        }
+        try {
+          const scriptPath = resolveSkillScriptPath(skill, script);
+          await access2(scriptPath);
+          const fn = await loadRunnableScriptFunction(scriptPath);
+          const output = await fn(payload, {
+            skill: name,
+            skillDir: skill.skillDir,
+            scriptPath
+          });
+          return {
+            skill: name,
+            script,
+            output
+          };
+        } catch (err) {
+          return {
+            error: `Failed to run script "${script}" in skill "${name}": ${err instanceof Error ? err.message : String(err)}`
+          };
+        }
+      }
+    })
+  ];
+};
+var SCRIPT_EXTENSIONS = /* @__PURE__ */ new Set([".js", ".mjs", ".cjs", ".ts", ".mts", ".cts"]);
+var listSkillScripts = async (skill) => {
+  const scriptsRoot = resolve6(skill.skillDir, "scripts");
+  try {
+    await access2(scriptsRoot);
+  } catch {
+    return [];
+  }
+  const scripts = await collectScriptFiles(scriptsRoot);
+  return scripts.map((fullPath) => `scripts/${fullPath.slice(scriptsRoot.length + 1).split(sep2).join("/")}`).sort();
+};
+var collectScriptFiles = async (directory) => {
+  const entries = await readdir3(directory, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const fullPath = resolve6(directory, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await collectScriptFiles(fullPath));
+      continue;
+    }
+    if (entry.isFile()) {
+      const extension = extname(fullPath).toLowerCase();
+      if (SCRIPT_EXTENSIONS.has(extension)) {
+        files.push(fullPath);
+      }
+    }
+  }
+  return files;
+};
+var resolveSkillScriptPath = (skill, relativePath) => {
+  const normalized = normalize2(relativePath);
+  if (normalized.startsWith("..") || normalized.startsWith("/")) {
+    throw new Error("Script path must be relative and within the skill directory");
+  }
+  const normalizedWithPrefix = normalized.startsWith("scripts/") ? normalized : `scripts/${normalized}`;
+  const fullPath = resolve6(skill.skillDir, normalizedWithPrefix);
+  const scriptsRoot = resolve6(skill.skillDir, "scripts");
+  if (!fullPath.startsWith(`${scriptsRoot}${sep2}`) && fullPath !== scriptsRoot) {
+    throw new Error("Script path must stay inside the scripts directory");
+  }
+  const extension = extname(fullPath).toLowerCase();
+  if (!SCRIPT_EXTENSIONS.has(extension)) {
+    throw new Error(
+      `Unsupported script extension "${extension || "(none)"}". Allowed: ${[...SCRIPT_EXTENSIONS].join(", ")}`
+    );
+  }
+  return fullPath;
+};
+var loadRunnableScriptFunction = async (scriptPath) => {
+  const loaded = await loadScriptModule(scriptPath);
+  const fn = extractRunnableFunction(loaded);
+  if (!fn) {
+    throw new Error(
+      "Script module must export a function (default export or named run/main/handler)"
+    );
+  }
+  return fn;
+};
+var loadScriptModule = async (scriptPath) => {
+  try {
+    return await import(pathToFileURL(scriptPath).href);
+  } catch {
+    const jiti = createJiti(import.meta.url, { interopDefault: true });
+    return await jiti.import(scriptPath);
+  }
+};
+var extractRunnableFunction = (value) => {
+  if (typeof value === "function") {
+    return value;
+  }
+  if (Array.isArray(value) || typeof value !== "object" || value === null) {
+    return void 0;
+  }
+  const module = value;
+  const defaultValue = module.default;
+  if (typeof defaultValue === "function") {
+    return defaultValue;
+  }
+  if (typeof module.run === "function") {
+    return module.run;
+  }
+  if (typeof module.main === "function") {
+    return module.main;
+  }
+  if (typeof module.handler === "function") {
+    return module.handler;
+  }
+  if (defaultValue && typeof defaultValue === "object" && !Array.isArray(defaultValue)) {
+    const inner = defaultValue;
+    if (typeof inner.run === "function") {
+      return inner.run;
+    }
+    if (typeof inner.main === "function") {
+      return inner.main;
+    }
+    if (typeof inner.handler === "function") {
+      return inner.handler;
+    }
+  }
+  return void 0;
+};
+
+// src/tool-dispatcher.ts
+var ToolDispatcher = class {
+  tools = /* @__PURE__ */ new Map();
+  register(tool) {
+    this.tools.set(tool.name, tool);
+  }
+  registerMany(tools) {
+    for (const tool of tools) {
+      this.register(tool);
+    }
+  }
+  list() {
+    return [...this.tools.values()];
+  }
+  get(name) {
+    return this.tools.get(name);
+  }
+  async execute(call, context) {
+    const definition = this.tools.get(call.name);
+    if (!definition) {
+      return {
+        callId: call.id,
+        tool: call.name,
+        error: `Tool not found: ${call.name}`
+      };
+    }
+    try {
+      const output = await definition.handler(call.input, context);
+      return {
+        callId: call.id,
+        tool: call.name,
+        output
+      };
+    } catch (error) {
+      return {
+        callId: call.id,
+        tool: call.name,
+        error: error instanceof Error ? error.message : "Unknown tool error"
+      };
+    }
+  }
+  async executeBatch(calls, context) {
+    return Promise.all(calls.map(async (call) => this.execute(call, context)));
+  }
+};
+
+// src/harness.ts
+var now = () => Date.now();
+var MAX_CONTEXT_MESSAGES = 40;
+var trimMessageWindow = (messages) => messages.length <= MAX_CONTEXT_MESSAGES ? messages : messages.slice(messages.length - MAX_CONTEXT_MESSAGES);
+var DEVELOPMENT_MODE_CONTEXT = `## Development Mode Context
+
+You are running locally in development mode. Treat this as an editable agent workspace.
+
+When users ask about customization:
+- Explain and edit \`poncho.config.js\` for model/provider, storage+memory, auth, telemetry, and MCP settings.
+- Help create or update local skills under \`skills/<skill-name>/SKILL.md\`.
+- For executable skills, add JavaScript/TypeScript scripts under \`skills/<skill-name>/scripts/\` and run them via \`run_skill_script\`.
+- For setup, skills, MCP, auth, storage, telemetry, or "how do I..." questions, proactively read \`README.md\` with \`read_file\` before answering.
+- Prefer quoting concrete commands and examples from \`README.md\` over guessing.
+- Keep edits minimal, preserve unrelated settings/code, and summarize what changed.`;
+var AgentHarness = class {
+  workingDir;
+  environment;
+  modelClient;
+  dispatcher = new ToolDispatcher();
+  approvalHandler;
+  skillContextWindow = "";
+  memoryStore;
+  parsedAgent;
+  mcpBridge;
+  getConfiguredToolFlag(config, name) {
+    const defaults = config?.tools?.defaults;
+    const environment = this.environment ?? "development";
+    const envOverrides = config?.tools?.byEnvironment?.[environment];
+    return envOverrides?.[name] ?? defaults?.[name];
+  }
+  isBuiltInToolEnabled(config, name) {
+    if (name === "write_file") {
+      const allowedByEnvironment = this.shouldEnableWriteTool();
+      const configured = this.getConfiguredToolFlag(config, "write_file");
+      return allowedByEnvironment && configured !== false;
+    }
+    if (name === "list_directory") {
+      const configured = this.getConfiguredToolFlag(config, "list_directory");
+      return configured !== false;
+    }
+    if (name === "read_file") {
+      const configured = this.getConfiguredToolFlag(config, "read_file");
+      return configured !== false;
+    }
+    return true;
+  }
+  registerIfMissing(tool) {
+    if (!this.dispatcher.get(tool.name)) {
+      this.dispatcher.register(tool);
+    }
+  }
+  registerConfiguredBuiltInTools(config) {
+    for (const tool of createDefaultTools(this.workingDir)) {
+      if (this.isBuiltInToolEnabled(config, tool.name)) {
+        this.registerIfMissing(tool);
+      }
+    }
+    if (this.isBuiltInToolEnabled(config, "write_file")) {
+      this.registerIfMissing(createWriteTool(this.workingDir));
+    }
+  }
+  shouldEnableWriteTool() {
+    const override = process.env.PONCHO_FS_WRITE?.toLowerCase();
+    if (override === "1" || override === "true" || override === "yes") {
+      return true;
+    }
+    if (override === "0" || override === "false" || override === "no") {
+      return false;
+    }
+    return this.environment !== "production";
+  }
+  constructor(options = {}) {
+    this.workingDir = options.workingDir ?? process.cwd();
+    this.environment = options.environment ?? "development";
+    this.modelClient = createModelClient("anthropic");
+    this.approvalHandler = options.approvalHandler;
+    if (options.toolDefinitions?.length) {
+      this.dispatcher.registerMany(options.toolDefinitions);
+    }
+  }
+  async initialize() {
+    this.parsedAgent = await parseAgentFile(this.workingDir);
+    const config = await loadPonchoConfig(this.workingDir);
+    this.registerConfiguredBuiltInTools(config);
+    const provider = this.parsedAgent.frontmatter.model?.provider ?? "anthropic";
+    const memoryConfig = resolveMemoryConfig(config);
+    const latitudeCapture = new LatitudeCapture({
+      apiKey: config?.telemetry?.latitude?.apiKey ?? process.env.LATITUDE_API_KEY,
+      projectId: config?.telemetry?.latitude?.projectId ?? process.env.LATITUDE_PROJECT_ID,
+      path: config?.telemetry?.latitude?.path ?? config?.telemetry?.latitude?.documentPath ?? process.env.LATITUDE_PATH ?? process.env.LATITUDE_DOCUMENT_PATH,
+      defaultPath: `agents/${this.parsedAgent.frontmatter.name}/model-call`
+    });
+    this.modelClient = createModelClient(provider, { latitudeCapture });
+    const bridge = new LocalMcpBridge(config);
+    this.mcpBridge = bridge;
+    const extraSkillPaths = config?.skillPaths;
+    const skillMetadata = await loadSkillMetadata(this.workingDir, extraSkillPaths);
+    this.skillContextWindow = buildSkillContextWindow(skillMetadata);
+    this.dispatcher.registerMany(createSkillTools(skillMetadata));
+    if (memoryConfig?.enabled) {
+      this.memoryStore = createMemoryStore(
+        this.parsedAgent.frontmatter.name,
+        memoryConfig,
+        { workingDir: this.workingDir }
+      );
+      this.dispatcher.registerMany(
+        createMemoryTools(this.memoryStore, {
+          maxRecallConversations: memoryConfig.maxRecallConversations
+        })
+      );
+    }
+    await bridge.startLocalServers();
+    this.dispatcher.registerMany(await bridge.loadTools());
+  }
+  async shutdown() {
+    await this.mcpBridge?.stopLocalServers();
+  }
+  listTools() {
+    return this.dispatcher.list();
+  }
+  async *run(input) {
+    if (!this.parsedAgent) {
+      await this.initialize();
+    }
+    const agent = this.parsedAgent;
+    const runId = `run_${randomUUID2()}`;
+    const start = now();
+    const maxSteps = agent.frontmatter.limits?.maxSteps ?? 50;
+    const timeoutMs = (agent.frontmatter.limits?.timeout ?? 300) * 1e3;
+    const messages = [...input.messages ?? []];
+    const events = [];
+    const systemPrompt = renderAgentPrompt(agent, {
+      parameters: input.parameters,
+      runtime: {
+        runId,
+        agentId: agent.frontmatter.name,
+        environment: this.environment,
+        workingDir: this.workingDir
+      }
+    });
+    const developmentContext = this.environment === "development" ? `
+
+${DEVELOPMENT_MODE_CONTEXT}` : "";
+    const promptWithSkills = this.skillContextWindow ? `${systemPrompt}${developmentContext}
+
+${this.skillContextWindow}` : `${systemPrompt}${developmentContext}`;
+    const mainMemory = this.memoryStore ? await this.memoryStore.getMainMemory() : void 0;
+    const boundedMainMemory = mainMemory && mainMemory.content.length > 4e3 ? `${mainMemory.content.slice(0, 4e3)}
+...[truncated]` : mainMemory?.content;
+    const memoryContext = boundedMainMemory && boundedMainMemory.trim().length > 0 ? `
+## Persistent Memory
+
+${boundedMainMemory.trim()}` : "";
+    const integrityPrompt = `${promptWithSkills}${memoryContext}
+
+## Execution Integrity
+
+- Do not claim that you executed a tool unless you actually emitted a tool call in this run.
+- Do not fabricate "Tool Used" or "Tool Result" logs as plain text.
+- Never output faux execution transcripts, markdown tool logs, or "Tool Used/Result" sections.
+- If no suitable tool is available, explicitly say that and ask for guidance.`;
+    const pushEvent = (event) => {
+      events.push(event);
+      return event;
+    };
+    yield pushEvent({
+      type: "run:started",
+      runId,
+      agentId: agent.frontmatter.name
+    });
+    messages.push({
+      role: "user",
+      content: input.task,
+      metadata: { timestamp: now(), id: randomUUID2() }
+    });
+    let responseText = "";
+    let totalInputTokens = 0;
+    let totalOutputTokens = 0;
+    for (let step = 1; step <= maxSteps; step += 1) {
+      if (now() - start > timeoutMs) {
+        yield pushEvent({
+          type: "run:error",
+          runId,
+          error: {
+            code: "TIMEOUT",
+            message: `Run exceeded timeout of ${Math.floor(timeoutMs / 1e3)}s`
+          }
+        });
+        return;
+      }
+      const stepStart = now();
+      yield pushEvent({ type: "step:started", step });
+      yield pushEvent({ type: "model:request", tokens: 0 });
+      const modelCallInput = {
+        modelName: agent.frontmatter.model?.name ?? "claude-opus-4-5",
+        temperature: agent.frontmatter.model?.temperature,
+        maxTokens: agent.frontmatter.model?.maxTokens,
+        systemPrompt: integrityPrompt,
+        messages: trimMessageWindow(messages),
+        tools: this.dispatcher.list()
+      };
+      let modelResponse;
+      let streamedAnyChunk = false;
+      if (this.modelClient.generateStream) {
+        for await (const streamEvent of this.modelClient.generateStream(modelCallInput)) {
+          if (streamEvent.type === "chunk" && streamEvent.content.length > 0) {
+            streamedAnyChunk = true;
+            yield pushEvent({ type: "model:chunk", content: streamEvent.content });
+          }
+          if (streamEvent.type === "final") {
+            modelResponse = streamEvent.response;
+          }
+        }
+      } else {
+        modelResponse = await this.modelClient.generate(modelCallInput);
+      }
+      if (!modelResponse) {
+        throw new Error("Model response ended without final payload");
+      }
+      totalInputTokens += modelResponse.usage.input;
+      totalOutputTokens += modelResponse.usage.output;
+      if (!streamedAnyChunk && modelResponse.text) {
+        yield pushEvent({ type: "model:chunk", content: modelResponse.text });
+      }
+      yield pushEvent({
+        type: "model:response",
+        usage: {
+          input: modelResponse.usage.input,
+          output: modelResponse.usage.output,
+          cached: 0
+        }
+      });
+      if (modelResponse.toolCalls.length === 0) {
+        responseText = modelResponse.text;
+        yield pushEvent({
+          type: "step:completed",
+          step,
+          duration: now() - stepStart
+        });
+        const result = {
+          status: "completed",
+          response: responseText,
+          steps: step,
+          tokens: {
+            input: totalInputTokens,
+            output: totalOutputTokens,
+            cached: 0
+          },
+          duration: now() - start
+        };
+        yield pushEvent({ type: "run:completed", runId, result });
+        return;
+      }
+      const toolContext = {
+        runId,
+        agentId: agent.frontmatter.name,
+        step,
+        workingDir: this.workingDir,
+        parameters: input.parameters ?? {}
+      };
+      const toolResultsForModel = [];
+      const approvedCalls = [];
+      for (const call of modelResponse.toolCalls) {
+        yield pushEvent({ type: "tool:started", tool: call.name, input: call.input });
+        const definition = this.dispatcher.get(call.name);
+        if (definition?.requiresApproval) {
+          const approvalId = `approval_${randomUUID2()}`;
+          yield pushEvent({
+            type: "tool:approval:required",
+            tool: call.name,
+            input: call.input,
+            approvalId
+          });
+          const approved = this.approvalHandler ? await this.approvalHandler({
+            tool: call.name,
+            input: call.input,
+            runId,
+            step,
+            approvalId
+          }) : false;
+          if (!approved) {
+            yield pushEvent({
+              type: "tool:approval:denied",
+              approvalId,
+              reason: "No approval handler granted execution"
+            });
+            yield pushEvent({
+              type: "tool:error",
+              tool: call.name,
+              error: "Tool execution denied by approval policy",
+              recoverable: true
+            });
+            toolResultsForModel.push({
+              type: "tool_result",
+              tool_use_id: call.id,
+              content: "Tool error: Tool execution denied by approval policy"
+            });
+            continue;
+          }
+          yield pushEvent({ type: "tool:approval:granted", approvalId });
+        }
+        approvedCalls.push({
+          id: call.id,
+          name: call.name,
+          input: call.input
+        });
+      }
+      const batchStart = now();
+      const batchResults = approvedCalls.length > 0 ? await this.dispatcher.executeBatch(approvedCalls, toolContext) : [];
+      for (const result of batchResults) {
+        if (result.error) {
+          yield pushEvent({
+            type: "tool:error",
+            tool: result.tool,
+            error: result.error,
+            recoverable: true
+          });
+          toolResultsForModel.push({
+            type: "tool_result",
+            tool_use_id: result.callId,
+            content: `Tool error: ${result.error}`
+          });
+        } else {
+          yield pushEvent({
+            type: "tool:completed",
+            tool: result.tool,
+            output: result.output,
+            duration: now() - batchStart
+          });
+          toolResultsForModel.push({
+            type: "tool_result",
+            tool_use_id: result.callId,
+            content: JSON.stringify(result.output ?? null)
+          });
+        }
+      }
+      messages.push({
+        role: "assistant",
+        content: modelResponse.text || `[tool calls: ${modelResponse.toolCalls.length}]`,
+        metadata: { timestamp: now(), id: randomUUID2(), step }
+      });
+      messages.push({
+        role: "tool",
+        content: JSON.stringify(toolResultsForModel),
+        metadata: { timestamp: now(), id: randomUUID2(), step }
+      });
+      yield pushEvent({
+        type: "step:completed",
+        step,
+        duration: now() - stepStart
+      });
+    }
+    yield {
+      type: "run:error",
+      runId,
+      error: {
+        code: "MAX_STEPS_EXCEEDED",
+        message: `Run reached maximum of ${maxSteps} steps`
+      }
+    };
+  }
+  async runToCompletion(input) {
+    const events = [];
+    let runId = "";
+    let finalResult;
+    const messages = [...input.messages ?? []];
+    messages.push({ role: "user", content: input.task });
+    for await (const event of this.run(input)) {
+      events.push(event);
+      if (event.type === "run:started") {
+        runId = event.runId;
+      }
+      if (event.type === "run:completed") {
+        finalResult = event.result;
+        messages.push({
+          role: "assistant",
+          content: event.result.response ?? ""
+        });
+      }
+      if (event.type === "run:error") {
+        finalResult = {
+          status: "error",
+          response: event.error.message,
+          steps: 0,
+          tokens: { input: 0, output: 0, cached: 0 },
+          duration: 0
+        };
+      }
+    }
+    return {
+      runId,
+      events,
+      messages,
+      result: finalResult ?? {
+        status: "error",
+        response: "Run ended unexpectedly",
+        steps: 0,
+        tokens: { input: 0, output: 0, cached: 0 },
+        duration: 0
+      }
+    };
+  }
+};
+
+// src/state.ts
+import { createHash as createHash2, randomUUID as randomUUID3 } from "crypto";
+import { mkdir as mkdir3, readFile as readFile5, writeFile as writeFile3 } from "fs/promises";
+import { basename as basename2, dirname as dirname4, resolve as resolve7 } from "path";
+import { homedir as homedir2 } from "os";
+var DEFAULT_OWNER = "local-owner";
+var CONVERSATIONS_STATE_KEY = "__poncho_conversations__";
+var LOCAL_CONVERSATIONS_FILE = "local-conversations.json";
+var LOCAL_STATE_FILE = "local-state.json";
+var getStateDirectory2 = () => {
+  const cwd = process.cwd();
+  const home = homedir2();
+  const isServerless = process.env.VERCEL === "1" || process.env.VERCEL_ENV !== void 0 || process.env.VERCEL_URL !== void 0 || process.env.AWS_LAMBDA_FUNCTION_NAME !== void 0 || process.env.AWS_EXECUTION_ENV?.includes("AWS_Lambda") === true || process.env.LAMBDA_TASK_ROOT !== void 0 || process.env.NOW_REGION !== void 0 || cwd.startsWith("/var/task") || home.startsWith("/var/task") || process.env.SERVERLESS === "1";
+  if (isServerless) {
+    return "/tmp/.poncho/state";
+  }
+  return resolve7(homedir2(), ".poncho", "state");
+};
+var projectScopedFilePath = (workingDir, suffix) => {
+  const projectName = basename2(workingDir).replace(/[^a-zA-Z0-9_-]+/g, "-") || "project";
+  const projectHash = createHash2("sha256").update(workingDir).digest("hex").slice(0, 12);
+  return resolve7(getStateDirectory2(), `${projectName}-${projectHash}-${suffix}`);
+};
+var normalizeTitle = (title) => {
+  return title && title.trim().length > 0 ? title.trim() : "New conversation";
+};
+var InMemoryStateStore = class {
+  store = /* @__PURE__ */ new Map();
+  ttlMs;
+  constructor(ttlSeconds) {
+    this.ttlMs = typeof ttlSeconds === "number" ? ttlSeconds * 1e3 : void 0;
+  }
+  isExpired(state) {
+    return typeof this.ttlMs === "number" && Date.now() - state.updatedAt > this.ttlMs;
+  }
+  async get(runId) {
+    const state = this.store.get(runId);
+    if (!state) {
+      return void 0;
+    }
+    if (this.isExpired(state)) {
+      this.store.delete(runId);
+      return void 0;
+    }
+    return state;
+  }
+  async set(state) {
+    this.store.set(state.runId, { ...state, updatedAt: Date.now() });
+  }
+  async delete(runId) {
+    this.store.delete(runId);
+  }
+};
+var UpstashStateStore = class {
+  baseUrl;
+  token;
+  ttl;
+  constructor(baseUrl, token, ttl) {
+    this.baseUrl = baseUrl.replace(/\/+$/, "");
+    this.token = token;
+    this.ttl = ttl;
+  }
+  headers() {
+    return {
+      Authorization: `Bearer ${this.token}`,
+      "Content-Type": "application/json"
+    };
+  }
+  async get(runId) {
+    const response = await fetch(`${this.baseUrl}/get/${encodeURIComponent(runId)}`, {
+      method: "POST",
+      headers: this.headers()
+    });
+    if (!response.ok) {
+      return void 0;
+    }
+    const payload = await response.json();
+    if (!payload.result) {
+      return void 0;
+    }
+    return JSON.parse(payload.result);
+  }
+  async set(state) {
+    const serialized = JSON.stringify({ ...state, updatedAt: Date.now() });
+    const path = typeof this.ttl === "number" ? `${this.baseUrl}/setex/${encodeURIComponent(state.runId)}/${Math.max(
+      1,
+      this.ttl
+    )}/${encodeURIComponent(serialized)}` : `${this.baseUrl}/set/${encodeURIComponent(state.runId)}/${encodeURIComponent(
+      serialized
+    )}`;
+    await fetch(path, { method: "POST", headers: this.headers() });
+  }
+  async delete(runId) {
+    await fetch(`${this.baseUrl}/del/${encodeURIComponent(runId)}`, {
+      method: "POST",
+      headers: this.headers()
+    });
+  }
+};
+var InMemoryConversationStore = class {
+  conversations = /* @__PURE__ */ new Map();
+  ttlMs;
+  constructor(ttlSeconds) {
+    this.ttlMs = typeof ttlSeconds === "number" ? ttlSeconds * 1e3 : void 0;
+  }
+  isExpired(updatedAt) {
+    return typeof this.ttlMs === "number" && Date.now() - updatedAt > this.ttlMs;
+  }
+  purgeExpired() {
+    for (const [conversationId, conversation] of this.conversations.entries()) {
+      if (this.isExpired(conversation.updatedAt)) {
+        this.conversations.delete(conversationId);
+      }
+    }
+  }
+  async list(ownerId = DEFAULT_OWNER) {
+    this.purgeExpired();
+    return Array.from(this.conversations.values()).filter((conversation) => conversation.ownerId === ownerId).sort((a, b) => b.updatedAt - a.updatedAt);
+  }
+  async get(conversationId) {
+    this.purgeExpired();
+    return this.conversations.get(conversationId);
+  }
+  async create(ownerId = DEFAULT_OWNER, title) {
+    const now2 = Date.now();
+    const conversation = {
+      conversationId: globalThis.crypto?.randomUUID?.() ?? `${now2}-${Math.random()}`,
+      title: normalizeTitle(title),
+      messages: [],
+      ownerId,
+      tenantId: null,
+      createdAt: now2,
+      updatedAt: now2
+    };
+    this.conversations.set(conversation.conversationId, conversation);
+    return conversation;
+  }
+  async update(conversation) {
+    this.conversations.set(conversation.conversationId, {
+      ...conversation,
+      updatedAt: Date.now()
+    });
+  }
+  async rename(conversationId, title) {
+    const existing = await this.get(conversationId);
+    if (!existing) {
+      return void 0;
+    }
+    const updated = {
+      ...existing,
+      title: normalizeTitle(title || existing.title),
+      updatedAt: Date.now()
+    };
+    this.conversations.set(conversationId, updated);
+    return updated;
+  }
+  async delete(conversationId) {
+    return this.conversations.delete(conversationId);
+  }
+};
+var FileConversationStore = class {
+  filePath;
+  conversations = /* @__PURE__ */ new Map();
+  loaded = false;
+  writing = Promise.resolve();
+  constructor(workingDir) {
+    this.filePath = projectScopedFilePath(workingDir, LOCAL_CONVERSATIONS_FILE);
+  }
+  async ensureLoaded() {
+    if (this.loaded) {
+      return;
+    }
+    this.loaded = true;
+    try {
+      const raw = await readFile5(this.filePath, "utf8");
+      const parsed = JSON.parse(raw);
+      for (const conversation of parsed.conversations ?? []) {
+        this.conversations.set(conversation.conversationId, conversation);
+      }
+    } catch {
+    }
+  }
+  async persist() {
+    const payload = {
+      conversations: Array.from(this.conversations.values())
+    };
+    this.writing = this.writing.then(async () => {
+      await mkdir3(dirname4(this.filePath), { recursive: true });
+      await writeFile3(this.filePath, JSON.stringify(payload, null, 2), "utf8");
+    });
+    await this.writing;
+  }
+  async list(ownerId = DEFAULT_OWNER) {
+    await this.ensureLoaded();
+    return Array.from(this.conversations.values()).filter((conversation) => conversation.ownerId === ownerId).sort((a, b) => b.updatedAt - a.updatedAt);
+  }
+  async get(conversationId) {
+    await this.ensureLoaded();
+    return this.conversations.get(conversationId);
+  }
+  async create(ownerId = DEFAULT_OWNER, title) {
+    await this.ensureLoaded();
+    const now2 = Date.now();
+    const conversation = {
+      conversationId: randomUUID3(),
+      title: normalizeTitle(title),
+      messages: [],
+      ownerId,
+      tenantId: null,
+      createdAt: now2,
+      updatedAt: now2
+    };
+    this.conversations.set(conversation.conversationId, conversation);
+    await this.persist();
+    return conversation;
+  }
+  async update(conversation) {
+    await this.ensureLoaded();
+    this.conversations.set(conversation.conversationId, {
+      ...conversation,
+      updatedAt: Date.now()
+    });
+    await this.persist();
+  }
+  async rename(conversationId, title) {
+    await this.ensureLoaded();
+    const existing = this.conversations.get(conversationId);
+    if (!existing) {
+      return void 0;
+    }
+    const updated = {
+      ...existing,
+      title: normalizeTitle(title || existing.title),
+      updatedAt: Date.now()
+    };
+    this.conversations.set(conversationId, updated);
+    await this.persist();
+    return updated;
+  }
+  async delete(conversationId) {
+    await this.ensureLoaded();
+    const removed = this.conversations.delete(conversationId);
+    if (removed) {
+      await this.persist();
+    }
+    return removed;
+  }
+};
+var FileStateStore = class {
+  filePath;
+  states = /* @__PURE__ */ new Map();
+  ttlMs;
+  loaded = false;
+  writing = Promise.resolve();
+  constructor(workingDir, ttlSeconds) {
+    this.filePath = projectScopedFilePath(workingDir, LOCAL_STATE_FILE);
+    this.ttlMs = typeof ttlSeconds === "number" ? ttlSeconds * 1e3 : void 0;
+  }
+  isExpired(state) {
+    return typeof this.ttlMs === "number" && Date.now() - state.updatedAt > this.ttlMs;
+  }
+  async ensureLoaded() {
+    if (this.loaded) {
+      return;
+    }
+    this.loaded = true;
+    try {
+      const raw = await readFile5(this.filePath, "utf8");
+      const parsed = JSON.parse(raw);
+      for (const state of parsed.states ?? []) {
+        this.states.set(state.runId, state);
+      }
+    } catch {
+    }
+  }
+  async persist() {
+    const payload = {
+      states: Array.from(this.states.values())
+    };
+    this.writing = this.writing.then(async () => {
+      await mkdir3(dirname4(this.filePath), { recursive: true });
+      await writeFile3(this.filePath, JSON.stringify(payload, null, 2), "utf8");
+    });
+    await this.writing;
+  }
+  async get(runId) {
+    await this.ensureLoaded();
+    const state = this.states.get(runId);
+    if (!state) {
+      return void 0;
+    }
+    if (this.isExpired(state)) {
+      this.states.delete(runId);
+      await this.persist();
+      return void 0;
+    }
+    return state;
+  }
+  async set(state) {
+    await this.ensureLoaded();
+    this.states.set(state.runId, { ...state, updatedAt: Date.now() });
+    await this.persist();
+  }
+  async delete(runId) {
+    await this.ensureLoaded();
+    this.states.delete(runId);
+    await this.persist();
+  }
+};
+var KeyValueConversationStoreBase = class {
+  memoryFallback;
+  ttl;
+  constructor(ttl) {
+    this.ttl = ttl;
+    this.memoryFallback = new InMemoryConversationStore(ttl);
+  }
+  async readAllConversations() {
+    try {
+      const raw = await this.getRaw(CONVERSATIONS_STATE_KEY);
+      if (!raw) {
+        return [];
+      }
+      const parsed = JSON.parse(raw);
+      return Array.isArray(parsed.conversations) ? parsed.conversations : [];
+    } catch {
+      return await this.memoryFallback.list(DEFAULT_OWNER);
+    }
+  }
+  async writeAllConversations(conversations) {
+    const payload = JSON.stringify({ conversations });
+    try {
+      if (typeof this.ttl === "number") {
+        await this.setRawWithTtl(CONVERSATIONS_STATE_KEY, payload, Math.max(1, this.ttl));
+      } else {
+        await this.setRaw(CONVERSATIONS_STATE_KEY, payload);
+      }
+    } catch {
+      for (const conversation of conversations) {
+        await this.memoryFallback.update(conversation);
+      }
+    }
+  }
+  async list(ownerId = DEFAULT_OWNER) {
+    const conversations = await this.readAllConversations();
+    return conversations.filter((conversation) => conversation.ownerId === ownerId).sort((a, b) => b.updatedAt - a.updatedAt);
+  }
+  async get(conversationId) {
+    const conversations = await this.readAllConversations();
+    return conversations.find((conversation) => conversation.conversationId === conversationId);
+  }
+  async create(ownerId = DEFAULT_OWNER, title) {
+    const now2 = Date.now();
+    const conversation = {
+      conversationId: globalThis.crypto?.randomUUID?.() ?? `${now2}-${Math.random()}`,
+      title: normalizeTitle(title),
+      messages: [],
+      ownerId,
+      tenantId: null,
+      createdAt: now2,
+      updatedAt: now2
+    };
+    const conversations = await this.readAllConversations();
+    conversations.push(conversation);
+    await this.writeAllConversations(conversations);
+    return conversation;
+  }
+  async update(conversation) {
+    const conversations = await this.readAllConversations();
+    const next = conversations.map(
+      (item) => item.conversationId === conversation.conversationId ? { ...conversation, updatedAt: Date.now() } : item
+    );
+    await this.writeAllConversations(next);
+  }
+  async rename(conversationId, title) {
+    const conversations = await this.readAllConversations();
+    let updated;
+    const next = conversations.map((item) => {
+      if (item.conversationId !== conversationId) {
+        return item;
+      }
+      updated = {
+        ...item,
+        title: normalizeTitle(title || item.title),
+        updatedAt: Date.now()
+      };
+      return updated;
+    });
+    if (!updated) {
+      return void 0;
+    }
+    await this.writeAllConversations(next);
+    return updated;
+  }
+  async delete(conversationId) {
+    const conversations = await this.readAllConversations();
+    const next = conversations.filter((item) => item.conversationId !== conversationId);
+    if (next.length === conversations.length) {
+      return false;
+    }
+    if (next.length === 0) {
+      try {
+        await this.delRaw(CONVERSATIONS_STATE_KEY);
+      } catch {
+        await this.writeAllConversations(next);
+      }
+      return true;
+    }
+    await this.writeAllConversations(next);
+    return true;
+  }
+};
+var UpstashConversationStore = class extends KeyValueConversationStoreBase {
+  baseUrl;
+  token;
+  constructor(baseUrl, token, ttl) {
+    super(ttl);
+    this.baseUrl = baseUrl.replace(/\/+$/, "");
+    this.token = token;
+  }
+  headers() {
+    return {
+      Authorization: `Bearer ${this.token}`,
+      "Content-Type": "application/json"
+    };
+  }
+  async getRaw(key) {
+    const response = await fetch(`${this.baseUrl}/get/${encodeURIComponent(key)}`, {
+      method: "POST",
+      headers: this.headers()
+    });
+    if (!response.ok) {
+      return void 0;
+    }
+    const payload = await response.json();
+    return payload.result ?? void 0;
+  }
+  async setRaw(key, value) {
+    await fetch(
+      `${this.baseUrl}/set/${encodeURIComponent(key)}/${encodeURIComponent(value)}`,
+      { method: "POST", headers: this.headers() }
+    );
+  }
+  async setRawWithTtl(key, value, ttl) {
+    await fetch(
+      `${this.baseUrl}/setex/${encodeURIComponent(key)}/${Math.max(1, ttl)}/${encodeURIComponent(
+        value
+      )}`,
+      { method: "POST", headers: this.headers() }
+    );
+  }
+  async delRaw(key) {
+    await fetch(`${this.baseUrl}/del/${encodeURIComponent(key)}`, {
+      method: "POST",
+      headers: this.headers()
+    });
+  }
+};
+var RedisLikeStateStore = class {
+  memoryFallback;
+  ttl;
+  clientPromise;
+  constructor(url, ttl) {
+    this.ttl = ttl;
+    this.memoryFallback = new InMemoryStateStore(ttl);
+    this.clientPromise = (async () => {
+      try {
+        const redisModule = await import("redis");
+        const client = redisModule.createClient({ url });
+        await client.connect();
+        return client;
+      } catch {
+        return void 0;
+      }
+    })();
+  }
+  async get(runId) {
+    const client = await this.clientPromise;
+    if (!client) {
+      return await this.memoryFallback.get(runId);
+    }
+    const raw = await client.get(runId);
+    return raw ? JSON.parse(raw) : void 0;
+  }
+  async set(state) {
+    const client = await this.clientPromise;
+    if (!client) {
+      await this.memoryFallback.set(state);
+      return;
+    }
+    const serialized = JSON.stringify({ ...state, updatedAt: Date.now() });
+    if (typeof this.ttl === "number") {
+      await client.set(state.runId, serialized, { EX: Math.max(1, this.ttl) });
+      return;
+    }
+    await client.set(state.runId, serialized);
+  }
+  async delete(runId) {
+    const client = await this.clientPromise;
+    if (!client) {
+      await this.memoryFallback.delete(runId);
+      return;
+    }
+    await client.del(runId);
+  }
+};
+var RedisLikeConversationStore = class extends KeyValueConversationStoreBase {
+  clientPromise;
+  constructor(url, ttl) {
+    super(ttl);
+    this.clientPromise = (async () => {
+      try {
+        const redisModule = await import("redis");
+        const client = redisModule.createClient({ url });
+        await client.connect();
+        return client;
+      } catch {
+        return void 0;
+      }
+    })();
+  }
+  async getRaw(key) {
+    const client = await this.clientPromise;
+    if (!client) {
+      throw new Error("Redis unavailable");
+    }
+    const value = await client.get(key);
+    return value ?? void 0;
+  }
+  async setRaw(key, value) {
+    const client = await this.clientPromise;
+    if (!client) {
+      throw new Error("Redis unavailable");
+    }
+    await client.set(key, value);
+  }
+  async setRawWithTtl(key, value, ttl) {
+    const client = await this.clientPromise;
+    if (!client) {
+      throw new Error("Redis unavailable");
+    }
+    await client.set(key, value, { EX: Math.max(1, ttl) });
+  }
+  async delRaw(key) {
+    const client = await this.clientPromise;
+    if (!client) {
+      throw new Error("Redis unavailable");
+    }
+    await client.del(key);
+  }
+};
+var DynamoDbStateStore = class {
+  memoryFallback;
+  table;
+  ttl;
+  clientPromise;
+  constructor(table, region, ttl) {
+    this.table = table;
+    this.ttl = ttl;
+    this.memoryFallback = new InMemoryStateStore(ttl);
+    this.clientPromise = (async () => {
+      try {
+        const module = await import("@aws-sdk/client-dynamodb");
+        return {
+          send: module.DynamoDBClient ? new module.DynamoDBClient({ region }).send.bind(
+            new module.DynamoDBClient({ region })
+          ) : async () => ({}),
+          GetItemCommand: module.GetItemCommand,
+          PutItemCommand: module.PutItemCommand,
+          DeleteItemCommand: module.DeleteItemCommand
+        };
+      } catch {
+        return void 0;
+      }
+    })();
+  }
+  async get(runId) {
+    const client = await this.clientPromise;
+    if (!client) {
+      return await this.memoryFallback.get(runId);
+    }
+    const result = await client.send(
+      new client.GetItemCommand({
+        TableName: this.table,
+        Key: { runId: { S: runId } }
+      })
+    );
+    const raw = result.Item?.value?.S;
+    return raw ? JSON.parse(raw) : void 0;
+  }
+  async set(state) {
+    const client = await this.clientPromise;
+    if (!client) {
+      await this.memoryFallback.set(state);
+      return;
+    }
+    const updatedState = { ...state, updatedAt: Date.now() };
+    const ttlEpoch = typeof this.ttl === "number" ? Math.floor(Date.now() / 1e3) + Math.max(1, this.ttl) : void 0;
+    await client.send(
+      new client.PutItemCommand({
+        TableName: this.table,
+        Item: {
+          runId: { S: state.runId },
+          value: { S: JSON.stringify(updatedState) },
+          ...typeof ttlEpoch === "number" ? { ttl: { N: String(ttlEpoch) } } : {}
+        }
+      })
+    );
+  }
+  async delete(runId) {
+    const client = await this.clientPromise;
+    if (!client) {
+      await this.memoryFallback.delete(runId);
+      return;
+    }
+    await client.send(
+      new client.DeleteItemCommand({
+        TableName: this.table,
+        Key: { runId: { S: runId } }
+      })
+    );
+  }
+};
+var DynamoDbConversationStore = class extends KeyValueConversationStoreBase {
+  table;
+  clientPromise;
+  constructor(table, region, ttl) {
+    super(ttl);
+    this.table = table;
+    this.clientPromise = (async () => {
+      try {
+        const module = await import("@aws-sdk/client-dynamodb");
+        const client = new module.DynamoDBClient({ region });
+        return {
+          send: client.send.bind(client),
+          GetItemCommand: module.GetItemCommand,
+          PutItemCommand: module.PutItemCommand,
+          DeleteItemCommand: module.DeleteItemCommand
+        };
+      } catch {
+        return void 0;
+      }
+    })();
+  }
+  async getRaw(key) {
+    const client = await this.clientPromise;
+    if (!client) {
+      throw new Error("DynamoDB unavailable");
+    }
+    const result = await client.send(
+      new client.GetItemCommand({
+        TableName: this.table,
+        Key: { runId: { S: key } }
+      })
+    );
+    return result.Item?.value?.S;
+  }
+  async setRaw(key, value) {
+    const client = await this.clientPromise;
+    if (!client) {
+      throw new Error("DynamoDB unavailable");
+    }
+    await client.send(
+      new client.PutItemCommand({
+        TableName: this.table,
+        Item: {
+          runId: { S: key },
+          value: { S: value }
+        }
+      })
+    );
+  }
+  async setRawWithTtl(key, value, ttl) {
+    const client = await this.clientPromise;
+    if (!client) {
+      throw new Error("DynamoDB unavailable");
+    }
+    const ttlEpoch = Math.floor(Date.now() / 1e3) + Math.max(1, ttl);
+    await client.send(
+      new client.PutItemCommand({
+        TableName: this.table,
+        Item: {
+          runId: { S: key },
+          value: { S: value },
+          ttl: { N: String(ttlEpoch) }
+        }
+      })
+    );
+  }
+  async delRaw(key) {
+    const client = await this.clientPromise;
+    if (!client) {
+      throw new Error("DynamoDB unavailable");
+    }
+    await client.send(
+      new client.DeleteItemCommand({
+        TableName: this.table,
+        Key: { runId: { S: key } }
+      })
+    );
+  }
+};
+var createStateStore = (config, options) => {
+  const provider = config?.provider ?? "local";
+  const ttl = config?.ttl;
+  const workingDir = options?.workingDir ?? process.cwd();
+  if (provider === "local") {
+    return new FileStateStore(workingDir, ttl);
+  }
+  if (provider === "memory") {
+    return new InMemoryStateStore(ttl);
+  }
+  if (provider === "upstash") {
+    const url = config?.url ?? process.env.UPSTASH_REDIS_REST_URL ?? "";
+    const token = config?.token ?? process.env.UPSTASH_REDIS_REST_TOKEN ?? "";
+    if (url && token) {
+      return new UpstashStateStore(url, token, ttl);
+    }
+    return new InMemoryStateStore(ttl);
+  }
+  if (provider === "redis") {
+    const url = config?.url ?? process.env.REDIS_URL ?? "";
+    if (url) {
+      return new RedisLikeStateStore(url, ttl);
+    }
+    return new InMemoryStateStore(ttl);
+  }
+  if (provider === "dynamodb") {
+    const table = config?.table ?? process.env.PONCHO_DYNAMODB_TABLE ?? "";
+    if (table) {
+      return new DynamoDbStateStore(table, config?.region, ttl);
+    }
+    return new InMemoryStateStore(ttl);
+  }
+  return new InMemoryStateStore(ttl);
+};
+var createConversationStore = (config, options) => {
+  const provider = config?.provider ?? "local";
+  const ttl = config?.ttl;
+  const workingDir = options?.workingDir ?? process.cwd();
+  if (provider === "local") {
+    return new FileConversationStore(workingDir);
+  }
+  if (provider === "memory") {
+    return new InMemoryConversationStore(ttl);
+  }
+  if (provider === "upstash") {
+    const url = config?.url ?? (process.env.UPSTASH_REDIS_REST_URL || process.env.KV_REST_API_URL || "");
+    const token = config?.token ?? (process.env.UPSTASH_REDIS_REST_TOKEN || process.env.KV_REST_API_TOKEN || "");
+    if (url && token) {
+      return new UpstashConversationStore(url, token, ttl);
+    }
+    return new InMemoryConversationStore(ttl);
+  }
+  if (provider === "redis") {
+    const url = config?.url ?? process.env.REDIS_URL ?? "";
+    if (url) {
+      return new RedisLikeConversationStore(url, ttl);
+    }
+    return new InMemoryConversationStore(ttl);
+  }
+  if (provider === "dynamodb") {
+    const table = config?.table ?? process.env.PONCHO_DYNAMODB_TABLE ?? "";
+    if (table) {
+      return new DynamoDbConversationStore(table, config?.region, ttl);
+    }
+    return new InMemoryConversationStore(ttl);
+  }
+  return new InMemoryConversationStore(ttl);
+};
+
+// src/telemetry.ts
+var TelemetryEmitter = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  async emit(event) {
+    if (this.config?.enabled === false) {
+      return;
+    }
+    if (this.config?.handler) {
+      await this.config.handler(event);
+      return;
+    }
+    if (this.config?.otlp) {
+      await this.sendOtlp(event);
+    }
+    if (this.config?.latitude?.apiKey) {
+      await this.sendLatitude(event);
+    }
+    process.stdout.write(`[event] ${event.type} ${JSON.stringify(event)}
+`);
+  }
+  async sendOtlp(event) {
+    const endpoint = this.config?.otlp;
+    if (!endpoint) {
+      return;
+    }
+    try {
+      await fetch(endpoint, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          resourceLogs: [
+            {
+              scopeLogs: [
+                {
+                  logRecords: [
+                    {
+                      timeUnixNano: String(Date.now() * 1e6),
+                      severityText: "INFO",
+                      body: { stringValue: event.type },
+                      attributes: [
+                        {
+                          key: "event.payload",
+                          value: { stringValue: JSON.stringify(event) }
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        })
+      });
+    } catch {
+    }
+  }
+  async sendLatitude(event) {
+    const apiKey = this.config?.latitude?.apiKey;
+    if (!apiKey) {
+      return;
+    }
+    const projectId = this.config?.latitude?.projectId ?? process.env.LATITUDE_PROJECT_ID;
+    const path = this.config?.latitude?.path ?? process.env.LATITUDE_PATH;
+    const documentPath = this.config?.latitude?.documentPath ?? process.env.LATITUDE_DOCUMENT_PATH;
+    try {
+      await fetch("https://api.latitude.so/v1/telemetry/events", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${apiKey}`
+        },
+        body: JSON.stringify({
+          type: event.type,
+          payload: event,
+          timestamp: Date.now(),
+          projectId,
+          path,
+          documentPath
+        })
+      });
+    } catch {
+    }
+  }
+};
+
+// src/index.ts
+import { defineTool as defineTool4 } from "@poncho-ai/sdk";
+export {
+  AgentHarness,
+  InMemoryConversationStore,
+  InMemoryStateStore,
+  LatitudeCapture,
+  LocalMcpBridge,
+  OpenAiModelClient,
+  TelemetryEmitter,
+  ToolDispatcher,
+  buildSkillContextWindow,
+  createConversationStore,
+  createDefaultTools,
+  createMemoryStore,
+  createMemoryTools,
+  createModelClient,
+  createSkillTools,
+  createStateStore,
+  createWriteTool,
+  defineTool4 as defineTool,
+  loadPonchoConfig,
+  loadSkillContext,
+  loadSkillInstructions,
+  loadSkillMetadata,
+  parseAgentFile,
+  parseAgentMarkdown,
+  readSkillResource,
+  renderAgentPrompt,
+  resolveMemoryConfig,
+  resolveSkillDirs,
+  resolveStateConfig
+};