@poncho-ai/harness 0.24.0 → 0.26.0

package/dist/index.js

@@ -1402,7 +1402,8 @@ if (result.compacted) {
 When \`memory.enabled\` is true in \`poncho.config.js\`, the harness enables a simple memory model:
 
 - A single persistent main memory document is loaded at run start and interpolated into the system prompt under \`## Persistent Memory\`.
-- \`memory_main_update\` can replace or append to that document. The tool description instructs the model to proactively evaluate each turn whether durable memory should be updated.
+- \`memory_main_write\` overwrites the entire memory document (for initial writes or full rewrites).
+- \`memory_main_edit\` performs targeted string-replacement edits on memory (find \`old_str\`, replace with \`new_str\`), mirroring \`edit_file\` semantics. The tool description instructs the model to proactively evaluate each turn whether durable memory should be updated.
 - \`conversation_recall\` can search recent prior conversations (keyword scoring) when historical context is relevant (\`as we discussed\`, \`last time\`, etc.).
 
 \`\`\`javascript
@@ -1420,9 +1421,10 @@ export default {
 
 Available memory tools:
 
-- \`memory_main_get\`
-- \`memory_main_update\`
-- \`conversation_recall\`
+- \`memory_main_get\` \u2014 read the current memory document
+- \`memory_main_write\` \u2014 overwrite the entire memory document
+- \`memory_main_edit\` \u2014 edit memory via exact string replacement (\`old_str\` / \`new_str\`)
+- \`conversation_recall\` \u2014 search past conversations
 `,
   "configuration": `# Configuration & Security
 
@@ -2028,6 +2030,8 @@ var ponchoDocsTool = defineTool({
 
 // src/harness.ts
 import { randomUUID as randomUUID3 } from "crypto";
+import { readFile as readFile8 } from "fs/promises";
+import { resolve as resolve10 } from "path";
 import { getTextContent as getTextContent3 } from "@poncho-ai/sdk";
 
 // src/upload-store.ts
@@ -2342,6 +2346,142 @@ var createUploadStore = async (config, workingDir) => {
 import { mkdir as mkdir3, readFile as readFile5, rename, writeFile as writeFile4 } from "fs/promises";
 import { dirname as dirname2, resolve as resolve6 } from "path";
 import { defineTool as defineTool2 } from "@poncho-ai/sdk";
+
+// src/kv-store.ts
+var UpstashKVStore = class {
+  baseUrl;
+  token;
+  constructor(baseUrl, token) {
+    this.baseUrl = baseUrl.replace(/\/+$/, "");
+    this.token = token;
+  }
+  headers() {
+    return { Authorization: `Bearer ${this.token}`, "Content-Type": "application/json" };
+  }
+  async get(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 set(key, value) {
+    await fetch(
+      `${this.baseUrl}/set/${encodeURIComponent(key)}/${encodeURIComponent(value)}`,
+      { method: "POST", headers: this.headers() }
+    );
+  }
+  async setWithTtl(key, value, ttl) {
+    await fetch(
+      `${this.baseUrl}/setex/${encodeURIComponent(key)}/${Math.max(1, ttl)}/${encodeURIComponent(value)}`,
+      { method: "POST", headers: this.headers() }
+    );
+  }
+};
+var RedisKVStore = class {
+  clientPromise;
+  constructor(url) {
+    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(key) {
+    const client = await this.clientPromise;
+    if (!client) throw new Error("Redis unavailable");
+    const value = await client.get(key);
+    return value ?? void 0;
+  }
+  async set(key, value) {
+    const client = await this.clientPromise;
+    if (!client) throw new Error("Redis unavailable");
+    await client.set(key, value);
+  }
+  async setWithTtl(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 DynamoDbKVStore = class {
+  table;
+  clientPromise;
+  constructor(table, region) {
+    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
+        };
+      } catch {
+        return void 0;
+      }
+    })();
+  }
+  async get(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 set(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 setWithTtl(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 createRawKVStore = (config) => {
+  const provider = config?.provider ?? "local";
+  if (provider === "upstash") {
+    const urlEnv = config?.urlEnv ?? (process.env.UPSTASH_REDIS_REST_URL ? "UPSTASH_REDIS_REST_URL" : "KV_REST_API_URL");
+    const tokenEnv = config?.tokenEnv ?? (process.env.UPSTASH_REDIS_REST_TOKEN ? "UPSTASH_REDIS_REST_TOKEN" : "KV_REST_API_TOKEN");
+    const url = process.env[urlEnv] ?? "";
+    const token = process.env[tokenEnv] ?? "";
+    if (url && token) return new UpstashKVStore(url, token);
+  }
+  if (provider === "redis") {
+    const urlEnv = config?.urlEnv ?? "REDIS_URL";
+    const url = process.env[urlEnv] ?? "";
+    if (url) return new RedisKVStore(url);
+  }
+  if (provider === "dynamodb") {
+    const table = config?.table ?? process.env.PONCHO_DYNAMODB_TABLE ?? "";
+    if (table) return new DynamoDbKVStore(table, config?.region);
+  }
+  return void 0;
+};
+
+// src/memory.ts
 var DEFAULT_MAIN_MEMORY = {
   content: "",
   updatedAt: 0
@@ -2384,14 +2524,9 @@ var InMemoryMemoryStore = class {
     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
+      content: input.content.trim(),
+      updatedAt: Date.now()
     };
     return this.mainMemory;
   }
@@ -2449,31 +2584,29 @@ var FileMainMemoryStore = class {
   }
   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(),
+      content: input.content.trim(),
       updatedAt: Date.now()
     };
     await this.persist();
     return this.mainMemory;
   }
 };
-var KeyValueMainMemoryStoreBase = class {
+var KVBackedMemoryStore = class {
+  kv;
+  storageKey;
   ttl;
   memoryFallback;
-  constructor(ttl) {
+  constructor(kv, storageKey, ttl) {
+    this.kv = kv;
+    this.storageKey = storageKey;
     this.ttl = ttl;
     this.memoryFallback = new InMemoryMemoryStore(ttl);
   }
-  async readPayload(key) {
+  async readPayload() {
     try {
-      const raw = await this.getRaw(key);
-      if (!raw) {
-        return { main: { ...DEFAULT_MAIN_MEMORY } };
-      }
+      const raw = await this.kv.get(this.storageKey);
+      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;
@@ -2483,204 +2616,32 @@ var KeyValueMainMemoryStoreBase = class {
       return { main };
     }
   }
-  async writePayload(key, payload) {
+  async writePayload(payload) {
     try {
       const serialized = JSON.stringify(payload);
       if (typeof this.ttl === "number") {
-        await this.setRawWithTtl(key, serialized, Math.max(1, this.ttl));
+        await this.kv.setWithTtl(this.storageKey, serialized, Math.max(1, this.ttl));
       } else {
-        await this.setRaw(key, serialized);
+        await this.kv.set(this.storageKey, serialized);
       }
     } catch {
-      await this.memoryFallback.updateMainMemory({
-        content: payload.main.content,
-        mode: "replace"
-      });
+      await this.memoryFallback.updateMainMemory({ content: payload.main.content });
     }
   }
   async getMainMemory() {
-    const payload = await this.readPayload(this.key());
+    const payload = await this.readPayload();
     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);
+    const payload = await this.readPayload();
+    payload.main = { content: input.content.trim(), updatedAt: Date.now() };
+    await this.writePayload(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:${STORAGE_SCHEMA_VERSION}:${slugifyStorageComponent(
-    agentId
-  )}:memory:main`;
   const workingDir = options?.workingDir ?? process.cwd();
   if (provider === "local") {
     return new FileMainMemoryStore(workingDir, ttl);
@@ -2688,44 +2649,10 @@ var createMemoryStore = (agentId, config, options) => {
   if (provider === "memory") {
     return new InMemoryMemoryStore(ttl);
   }
-  if (provider === "upstash") {
-    const urlEnv = config?.urlEnv ?? (process.env.UPSTASH_REDIS_REST_URL ? "UPSTASH_REDIS_REST_URL" : "KV_REST_API_URL");
-    const tokenEnv = config?.tokenEnv ?? (process.env.UPSTASH_REDIS_REST_TOKEN ? "UPSTASH_REDIS_REST_TOKEN" : "KV_REST_API_TOKEN");
-    const url = process.env[urlEnv] ?? "";
-    const token = process.env[tokenEnv] ?? "";
-    if (url && token) {
-      return new UpstashMemoryStore({
-        baseUrl: url,
-        token,
-        storageKey,
-        ttl
-      });
-    }
-    return new InMemoryMemoryStore(ttl);
-  }
-  if (provider === "redis") {
-    const urlEnv = config?.urlEnv ?? "REDIS_URL";
-    const url = process.env[urlEnv] ?? "";
-    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);
+  const kv = createRawKVStore(config);
+  if (kv) {
+    const storageKey = `poncho:${STORAGE_SCHEMA_VERSION}:${slugifyStorageComponent(agentId)}:memory:main`;
+    return new KVBackedMemoryStore(kv, storageKey, ttl);
   }
   return new InMemoryMemoryStore(ttl);
 };
@@ -2775,19 +2702,14 @@ var createMemoryTools = (store, options) => {
       }
     }),
     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.",
+      name: "memory_main_write",
+      description: "Overwrite the entire persistent main memory document. Use for initial writes or full rewrites. Prefer memory_main_edit for targeted changes to existing memory.",
       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"
+            description: "The full memory content to write"
           }
         },
         required: ["content"],
@@ -2798,8 +2720,50 @@ var createMemoryTools = (store, options) => {
         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 });
+        const memory = await store.updateMainMemory({ content });
+        return { ok: true, memory };
+      }
+    }),
+    defineTool2({
+      name: "memory_main_edit",
+      description: "Edit persistent main memory by replacing an exact string match with new content. The old_str must match exactly one location in memory. Use an empty new_str to delete matched content. Proactively evaluate every turn whether memory should be updated.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          old_str: {
+            type: "string",
+            description: "The exact text to find and replace (must be unique in memory). Include surrounding context if needed to ensure uniqueness."
+          },
+          new_str: {
+            type: "string",
+            description: "The replacement text (use empty string to delete the matched content)"
+          }
+        },
+        required: ["old_str", "new_str"],
+        additionalProperties: false
+      },
+      handler: async (input) => {
+        const oldStr = typeof input.old_str === "string" ? input.old_str : "";
+        const newStr = typeof input.new_str === "string" ? input.new_str : "";
+        if (!oldStr) {
+          throw new Error("old_str must not be empty.");
+        }
+        const current = await store.getMainMemory();
+        const content = current.content;
+        const first = content.indexOf(oldStr);
+        if (first === -1) {
+          throw new Error(
+            "old_str not found in memory. Make sure it matches exactly, including whitespace and line breaks."
+          );
+        }
+        const last = content.lastIndexOf(oldStr);
+        if (first !== last) {
+          throw new Error(
+            "old_str appears multiple times in memory. Please provide more context to ensure a unique match."
+          );
+        }
+        const newContent = content.slice(0, first) + newStr + content.slice(first + oldStr.length);
+        const memory = await store.updateMainMemory({ content: newContent });
         return { ok: true, memory };
       }
     }),
@@ -2861,6 +2825,269 @@ ${item.content}`, query)
   ];
 };
 
+// src/todo-tools.ts
+import { mkdir as mkdir4, readFile as readFile6, rename as rename2, writeFile as writeFile5 } from "fs/promises";
+import { dirname as dirname3, resolve as resolve7 } from "path";
+import { defineTool as defineTool3 } from "@poncho-ai/sdk";
+var VALID_STATUSES = ["pending", "in_progress", "completed"];
+var VALID_PRIORITIES = ["high", "medium", "low"];
+var TODOS_DIRECTORY = "todos";
+var writeJsonAtomic2 = async (filePath, payload) => {
+  await mkdir4(dirname3(filePath), { recursive: true });
+  const tmpPath = `${filePath}.tmp`;
+  await writeFile5(tmpPath, JSON.stringify(payload, null, 2), "utf8");
+  await rename2(tmpPath, filePath);
+};
+var parseTodoList = (raw) => {
+  if (!Array.isArray(raw)) return [];
+  return raw.filter(
+    (item) => typeof item === "object" && item !== null && typeof item.id === "string" && typeof item.content === "string"
+  );
+};
+var generateId = () => (globalThis.crypto?.randomUUID?.() ?? `${Date.now()}-${Math.random()}`).slice(0, 8);
+var InMemoryTodoStore = class {
+  store = /* @__PURE__ */ new Map();
+  async get(conversationId) {
+    return this.store.get(conversationId) ?? [];
+  }
+  async set(conversationId, todos) {
+    this.store.set(conversationId, todos);
+  }
+};
+var FileTodoStore = class {
+  workingDir;
+  todosDir = "";
+  constructor(workingDir) {
+    this.workingDir = workingDir;
+  }
+  async ensureTodosDir() {
+    if (this.todosDir) return this.todosDir;
+    const identity = await ensureAgentIdentity(this.workingDir);
+    this.todosDir = resolve7(getAgentStoreDirectory(identity), TODOS_DIRECTORY);
+    await mkdir4(this.todosDir, { recursive: true });
+    return this.todosDir;
+  }
+  async filePath(conversationId) {
+    const dir = await this.ensureTodosDir();
+    return resolve7(dir, `${slugifyStorageComponent(conversationId)}.json`);
+  }
+  async get(conversationId) {
+    try {
+      const fp = await this.filePath(conversationId);
+      const raw = await readFile6(fp, "utf8");
+      return parseTodoList(JSON.parse(raw));
+    } catch {
+      return [];
+    }
+  }
+  async set(conversationId, todos) {
+    const fp = await this.filePath(conversationId);
+    await writeJsonAtomic2(fp, todos);
+  }
+};
+var KVBackedTodoStore = class {
+  kv;
+  baseKey;
+  ttl;
+  memoryFallback = new InMemoryTodoStore();
+  constructor(kv, baseKey, ttl) {
+    this.kv = kv;
+    this.baseKey = baseKey;
+    this.ttl = ttl;
+  }
+  keyFor(conversationId) {
+    return `${this.baseKey}:${slugifyStorageComponent(conversationId)}`;
+  }
+  async get(conversationId) {
+    try {
+      const raw = await this.kv.get(this.keyFor(conversationId));
+      if (!raw) return [];
+      return parseTodoList(JSON.parse(raw));
+    } catch {
+      return this.memoryFallback.get(conversationId);
+    }
+  }
+  async set(conversationId, todos) {
+    try {
+      const serialized = JSON.stringify(todos);
+      const key = this.keyFor(conversationId);
+      if (typeof this.ttl === "number") {
+        await this.kv.setWithTtl(key, serialized, Math.max(1, this.ttl));
+      } else {
+        await this.kv.set(key, serialized);
+      }
+    } catch {
+      await this.memoryFallback.set(conversationId, todos);
+    }
+  }
+};
+var createTodoStore = (agentId, config, options) => {
+  const provider = config?.provider ?? "local";
+  const ttl = config?.ttl;
+  const workingDir = options?.workingDir ?? process.cwd();
+  if (provider === "local") {
+    return new FileTodoStore(workingDir);
+  }
+  if (provider === "memory") {
+    return new InMemoryTodoStore();
+  }
+  const kv = createRawKVStore(config);
+  if (kv) {
+    const baseKey = `poncho:${STORAGE_SCHEMA_VERSION}:${slugifyStorageComponent(agentId)}:todos`;
+    return new KVBackedTodoStore(kv, baseKey, ttl);
+  }
+  return new InMemoryTodoStore();
+};
+var createTodoTools = (store) => {
+  const resolveKey = (context) => context.conversationId || context.runId;
+  return [
+    defineTool3({
+      name: "todo_list",
+      description: "List all todo items for the current conversation. Use this to check progress and plan next steps.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          status: {
+            type: "string",
+            enum: VALID_STATUSES,
+            description: "Filter by status (omit to list all)"
+          }
+        },
+        additionalProperties: false
+      },
+      handler: async (input, context) => {
+        const key = resolveKey(context);
+        let todos = await store.get(key);
+        const status = typeof input.status === "string" ? input.status : void 0;
+        if (status && VALID_STATUSES.includes(status)) {
+          todos = todos.filter((t) => t.status === status);
+        }
+        return { todos, count: todos.length };
+      }
+    }),
+    defineTool3({
+      name: "todo_add",
+      description: "Add a new todo item for the current conversation. Use proactively for complex multi-step tasks (3+ steps).",
+      inputSchema: {
+        type: "object",
+        properties: {
+          content: {
+            type: "string",
+            description: "Description of the task"
+          },
+          status: {
+            type: "string",
+            enum: VALID_STATUSES,
+            description: "Initial status (default: pending)"
+          },
+          priority: {
+            type: "string",
+            enum: VALID_PRIORITIES,
+            description: "Priority level (default: medium)"
+          }
+        },
+        required: ["content"],
+        additionalProperties: false
+      },
+      handler: async (input, context) => {
+        const content = typeof input.content === "string" ? input.content.trim() : "";
+        if (!content) throw new Error("content is required");
+        const status = typeof input.status === "string" && VALID_STATUSES.includes(input.status) ? input.status : "pending";
+        const priority = typeof input.priority === "string" && VALID_PRIORITIES.includes(input.priority) ? input.priority : "medium";
+        const now2 = Date.now();
+        const todo = {
+          id: generateId(),
+          content,
+          status,
+          priority,
+          createdAt: now2,
+          updatedAt: now2
+        };
+        const key = resolveKey(context);
+        const todos = await store.get(key);
+        todos.push(todo);
+        await store.set(key, todos);
+        return { todo, todos };
+      }
+    }),
+    defineTool3({
+      name: "todo_update",
+      description: "Update an existing todo item's status, content, or priority. Mark tasks in_progress when starting and completed when done.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          id: {
+            type: "string",
+            description: "ID of the todo to update"
+          },
+          status: {
+            type: "string",
+            enum: VALID_STATUSES,
+            description: "New status"
+          },
+          content: {
+            type: "string",
+            description: "New content/description"
+          },
+          priority: {
+            type: "string",
+            enum: VALID_PRIORITIES,
+            description: "New priority level"
+          }
+        },
+        required: ["id"],
+        additionalProperties: false
+      },
+      handler: async (input, context) => {
+        const id = typeof input.id === "string" ? input.id : "";
+        if (!id) throw new Error("id is required");
+        const key = resolveKey(context);
+        const todos = await store.get(key);
+        const todo = todos.find((t) => t.id === id);
+        if (!todo) throw new Error(`Todo with id "${id}" not found`);
+        if (typeof input.status === "string" && VALID_STATUSES.includes(input.status)) {
+          todo.status = input.status;
+        }
+        if (typeof input.content === "string" && input.content.trim()) {
+          todo.content = input.content.trim();
+        }
+        if (typeof input.priority === "string" && VALID_PRIORITIES.includes(input.priority)) {
+          todo.priority = input.priority;
+        }
+        todo.updatedAt = Date.now();
+        await store.set(key, todos);
+        return { todo, todos };
+      }
+    }),
+    defineTool3({
+      name: "todo_remove",
+      description: "Remove a todo item by ID.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          id: {
+            type: "string",
+            description: "ID of the todo to remove"
+          }
+        },
+        required: ["id"],
+        additionalProperties: false
+      },
+      handler: async (input, context) => {
+        const id = typeof input.id === "string" ? input.id : "";
+        if (!id) throw new Error("id is required");
+        const key = resolveKey(context);
+        const todos = await store.get(key);
+        const index = todos.findIndex((t) => t.id === id);
+        if (index === -1) throw new Error(`Todo with id "${id}" not found`);
+        const [removed] = todos.splice(index, 1);
+        await store.set(key, todos);
+        return { removed, todos };
+      }
+    })
+  ];
+};
+
 // src/mcp.ts
 var McpHttpError = class extends Error {
   status;
@@ -3355,8 +3582,8 @@ var createModelProvider = (provider, config) => {
 };
 
 // src/skill-context.ts
-import { readFile as readFile6, readdir as readdir2, stat } from "fs/promises";
-import { dirname as dirname3, resolve as resolve7, normalize } from "path";
+import { readFile as readFile7, readdir as readdir2, stat } from "fs/promises";
+import { dirname as dirname4, resolve as resolve8, normalize } from "path";
 import YAML3 from "yaml";
 var DEFAULT_SKILL_DIRS = ["skills"];
 var resolveSkillDirs = (workingDir, extraPaths) => {
@@ -3368,7 +3595,7 @@ var resolveSkillDirs = (workingDir, extraPaths) => {
       }
     }
   }
-  return dirs.map((d) => resolve7(workingDir, d));
+  return dirs.map((d) => resolve8(workingDir, d));
 };
 var FRONTMATTER_PATTERN3 = /^---\s*\n([\s\S]*?)\n---\s*\n?([\s\S]*)$/;
 var asRecord2 = (value) => typeof value === "object" && value !== null ? value : {};
@@ -3437,7 +3664,7 @@ var collectSkillManifests = async (directory) => {
   const entries = await readdir2(directory, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
-    const fullPath = resolve7(directory, entry.name);
+    const fullPath = resolve8(directory, entry.name);
     let isDir = entry.isDirectory();
     let isFile = entry.isFile();
     if (entry.isSymbolicLink()) {
@@ -3472,13 +3699,13 @@ var loadSkillMetadata = async (workingDir, extraSkillPaths) => {
   const seen = /* @__PURE__ */ new Set();
   for (const manifest of allManifests) {
     try {
-      const content = await readFile6(manifest, "utf8");
+      const content = await readFile7(manifest, "utf8");
       const parsed = parseSkillFrontmatter(content);
       if (parsed && !seen.has(parsed.name)) {
         seen.add(parsed.name);
         skills.push({
           ...parsed,
-          skillDir: dirname3(manifest),
+          skillDir: dirname4(manifest),
           skillPath: manifest
         });
       }
@@ -3517,7 +3744,7 @@ ${xmlSkills}
 };
 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 readFile6(skill.skillPath, "utf8");
+  const content = await readFile7(skill.skillPath, "utf8");
   const match = content.match(FRONTMATTER_PATTERN3);
   return match ? match[2].trim() : content.trim();
 };
@@ -3526,11 +3753,11 @@ var readSkillResource = async (skill, relativePath) => {
   if (normalized.startsWith("..") || normalized.startsWith("/")) {
     throw new Error("Path must be relative and within the skill directory");
   }
-  const fullPath = resolve7(skill.skillDir, normalized);
+  const fullPath = resolve8(skill.skillDir, normalized);
   if (!fullPath.startsWith(skill.skillDir)) {
     throw new Error("Path escapes the skill directory");
   }
-  return await readFile6(fullPath, "utf8");
+  return await readFile7(fullPath, "utf8");
 };
 var MAX_INSTRUCTIONS_PER_SKILL = 1200;
 var loadSkillContext = async (workingDir) => {
@@ -3647,16 +3874,16 @@ function convertSchema(schema) {
 }
 
 // src/skill-tools.ts
-import { defineTool as defineTool3 } from "@poncho-ai/sdk";
+import { defineTool as defineTool4 } from "@poncho-ai/sdk";
 import { access as access2, readdir as readdir3, stat as stat2 } from "fs/promises";
-import { extname, normalize as normalize2, resolve as resolve8, sep as sep2 } from "path";
+import { extname, normalize as normalize2, resolve as resolve9, sep as sep2 } from "path";
 import { pathToFileURL } from "url";
 import { createJiti as createJiti2 } from "jiti";
 var createSkillTools = (skills, options) => {
   const skillsByName = new Map(skills.map((skill) => [skill.name, skill]));
   const knownNames = skills.length > 0 ? skills.map((skill) => skill.name).join(", ") : "(none)";
   return [
-    defineTool3({
+    defineTool4({
       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: {
@@ -3693,7 +3920,7 @@ var createSkillTools = (skills, options) => {
         }
       }
     }),
-    defineTool3({
+    defineTool4({
       name: "deactivate_skill",
       description: "Deactivate a previously activated skill and update scoped tool availability.",
       inputSchema: {
@@ -3722,7 +3949,7 @@ var createSkillTools = (skills, options) => {
         }
       }
     }),
-    defineTool3({
+    defineTool4({
       name: "list_active_skills",
       description: "List currently active skills with scoped MCP tools.",
       inputSchema: {
@@ -3734,7 +3961,7 @@ var createSkillTools = (skills, options) => {
         activeSkills: options?.onListActiveSkills ? options.onListActiveSkills() : []
       })
     }),
-    defineTool3({
+    defineTool4({
       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: {
@@ -3774,7 +4001,7 @@ var createSkillTools = (skills, options) => {
         }
       }
     }),
-    defineTool3({
+    defineTool4({
       name: "list_skill_scripts",
       description: `List JavaScript/TypeScript script files available under a skill directory (recursive). Available skills: ${knownNames}`,
       inputSchema: {
@@ -3809,7 +4036,7 @@ var createSkillTools = (skills, options) => {
         }
       }
     }),
-    defineTool3({
+    defineTool4({
       name: "run_skill_script",
       description: `Run a JavaScript/TypeScript module in a skill or project directory. Uses default export function or named run/main/handler function. Available skills: ${knownNames}`,
       inputSchema: {
@@ -3906,7 +4133,7 @@ var collectScriptFiles = async (directory) => {
     if (entry.name === "node_modules") {
       continue;
     }
-    const fullPath = resolve8(directory, entry.name);
+    const fullPath = resolve9(directory, entry.name);
     let isDir = entry.isDirectory();
     let isFile = entry.isFile();
     if (entry.isSymbolicLink()) {
@@ -3945,8 +4172,8 @@ var normalizeScriptPolicyPath = (relativePath) => {
 };
 var resolveScriptPath = (baseDir, relativePath) => {
   const normalized = normalizeScriptPolicyPath(relativePath);
-  const fullPath = resolve8(baseDir, normalized);
-  if (!fullPath.startsWith(`${resolve8(baseDir)}${sep2}`) && fullPath !== resolve8(baseDir)) {
+  const fullPath = resolve9(baseDir, normalized);
+  if (!fullPath.startsWith(`${resolve9(baseDir)}${sep2}`) && fullPath !== resolve9(baseDir)) {
     throw new Error("Script path must stay inside the allowed directory");
   }
   const extension = extname(fullPath).toLowerCase();
@@ -4020,7 +4247,7 @@ var extractRunnableFunction = (value) => {
 };
 
 // src/subagent-tools.ts
-import { defineTool as defineTool4, getTextContent as getTextContent2 } from "@poncho-ai/sdk";
+import { defineTool as defineTool5, getTextContent as getTextContent2 } from "@poncho-ai/sdk";
 var LAST_MESSAGES_TO_RETURN = 10;
 var summarizeResult = (r) => {
   const summary = {
@@ -4047,7 +4274,7 @@ var summarizeResult = (r) => {
   return summary;
 };
 var createSubagentTools = (manager, getConversationId, getOwnerId) => [
-  defineTool4({
+  defineTool5({
     name: "spawn_subagent",
     description: "Spawn a subagent to work on a task and wait for it to finish. The subagent is a full copy of yourself running in its own conversation context with access to the same tools (except memory writes). This call blocks until the subagent completes and returns its result.\n\nGuidelines:\n- Use subagents to parallelize work: call spawn_subagent multiple times in one response for independent sub-tasks -- they run concurrently.\n- Prefer doing work yourself for simple or quick tasks. Spawn subagents for substantial, self-contained work.\n- The subagent has no memory of your conversation -- write thorough, self-contained instructions in the task.",
     inputSchema: {
@@ -4078,7 +4305,7 @@ var createSubagentTools = (manager, getConversationId, getOwnerId) => [
       return summarizeResult(result);
     }
   }),
-  defineTool4({
+  defineTool5({
     name: "message_subagent",
     description: "Send a follow-up message to a completed or stopped subagent and wait for it to finish. This restarts the subagent with the new message and blocks until it completes. Only works when the subagent is not currently running.",
     inputSchema: {
@@ -4106,7 +4333,7 @@ var createSubagentTools = (manager, getConversationId, getOwnerId) => [
       return summarizeResult(result);
     }
   }),
-  defineTool4({
+  defineTool5({
     name: "stop_subagent",
     description: "Stop a running subagent. The subagent's conversation is preserved but it will stop processing. Use this to cancel work that is no longer needed.",
     inputSchema: {
@@ -4129,7 +4356,7 @@ var createSubagentTools = (manager, getConversationId, getOwnerId) => [
       return { message: `Subagent "${subagentId}" has been stopped.` };
     }
   }),
-  defineTool4({
+  defineTool5({
     name: "list_subagents",
     description: "List all subagents that have been spawned in this conversation. Returns each subagent's ID, original task, current status, and message count. Use this to look up subagent IDs before calling message_subagent or stop_subagent.",
     inputSchema: {
@@ -4677,6 +4904,7 @@ var AgentHarness = class _AgentHarness {
   uploadStore;
   skillContextWindow = "";
   memoryStore;
+  todoStore;
   loadedConfig;
   loadedSkills = [];
   skillFingerprint = "";
@@ -4688,6 +4916,7 @@ var AgentHarness = class _AgentHarness {
   _browserSession;
   _browserMod;
   parsedAgent;
+  agentFileFingerprint = "";
   mcpBridge;
   subagentManager;
   resolveToolAccess(toolName) {
@@ -4784,6 +5013,10 @@ var AgentHarness = class _AgentHarness {
   get frontmatter() {
     return this.parsedAgent?.frontmatter;
   }
+  async getTodos(conversationId) {
+    if (!this.todoStore) return [];
+    return this.todoStore.get(conversationId);
+  }
   listActiveSkills() {
     return [...this.activeSkillNames].sort();
   }
@@ -4800,20 +5033,17 @@ var AgentHarness = class _AgentHarness {
     return this.parsedAgent?.frontmatter.approvalRequired?.scripts ?? [];
   }
   getRequestedMcpPatterns() {
-    const skillPatterns = /* @__PURE__ */ new Set();
+    const patterns = new Set(this.getAgentMcpIntent());
     for (const skillName of this.activeSkillNames) {
       const skill = this.loadedSkills.find((entry) => entry.name === skillName);
       if (!skill) {
         continue;
       }
       for (const pattern of skill.allowedTools.mcp) {
-        skillPatterns.add(pattern);
+        patterns.add(pattern);
       }
     }
-    if (skillPatterns.size > 0) {
-      return [...skillPatterns];
-    }
-    return this.getAgentMcpIntent();
+    return [...patterns];
   }
   getRequestedScriptPatterns() {
     const patterns = new Set(this.getAgentScriptIntent());
@@ -4829,20 +5059,17 @@ var AgentHarness = class _AgentHarness {
     return [...patterns];
   }
   getRequestedMcpApprovalPatterns() {
-    const skillPatterns = /* @__PURE__ */ new Set();
+    const patterns = new Set(this.getAgentMcpApprovalPatterns());
     for (const skillName of this.activeSkillNames) {
       const skill = this.loadedSkills.find((entry) => entry.name === skillName);
       if (!skill) {
         continue;
       }
       for (const pattern of skill.approvalRequired.mcp) {
-        skillPatterns.add(pattern);
+        patterns.add(pattern);
       }
     }
-    if (skillPatterns.size > 0) {
-      return [...skillPatterns];
-    }
-    return this.getAgentMcpApprovalPatterns();
+    return [...patterns];
   }
   getRequestedScriptApprovalPatterns() {
     const patterns = new Set(this.getAgentScriptApprovalPatterns());
@@ -4973,13 +5200,54 @@ var AgentHarness = class _AgentHarness {
     );
   }
   static SKILL_REFRESH_DEBOUNCE_MS = 3e3;
-  async refreshSkillsIfChanged() {
+  /**
+   * Re-read AGENT.md and update the parsed agent when the file has changed
+   * on disk.  Returns `true` when the agent was actually re-parsed.
+   *
+   * Preserves the agent identity (id) across reloads so conversation
+   * continuity isn't broken.
+   */
+  async refreshAgentIfChanged() {
     if (this.environment !== "development") {
-      return;
+      return false;
     }
-    const elapsed = Date.now() - this.lastSkillRefreshAt;
-    if (this.lastSkillRefreshAt > 0 && elapsed < _AgentHarness.SKILL_REFRESH_DEBOUNCE_MS) {
-      return;
+    try {
+      const agentFilePath = resolve10(this.workingDir, "AGENT.md");
+      const rawContent = await readFile8(agentFilePath, "utf8");
+      if (rawContent === this.agentFileFingerprint) {
+        return false;
+      }
+      const parsed = parseAgentMarkdown(rawContent);
+      if (!parsed.frontmatter.id && this.parsedAgent?.frontmatter.id) {
+        parsed.frontmatter.id = this.parsedAgent.frontmatter.id;
+      }
+      this.parsedAgent = parsed;
+      this.agentFileFingerprint = rawContent;
+      return true;
+    } catch (error) {
+      console.warn(
+        `[poncho][agent] Failed to refresh AGENT.md in development mode: ${error instanceof Error ? error.message : String(error)}`
+      );
+      return false;
+    }
+  }
+  /**
+   * Re-scan skill directories and update metadata, tools, and context window
+   * when skills have changed on disk. Returns `true` when the skill set was
+   * actually updated.
+   *
+   * @param force - bypass the time-based debounce (used for mid-run refreshes
+   *   after the agent may have written new skill files).
+   */
+  async refreshSkillsIfChanged(force = false) {
+    if (this.environment !== "development") {
+      return false;
+    }
+    if (!force) {
+      const elapsed = Date.now() - this.lastSkillRefreshAt;
+      if (this.lastSkillRefreshAt > 0 && elapsed < _AgentHarness.SKILL_REFRESH_DEBOUNCE_MS) {
+        return false;
+      }
     }
     this.lastSkillRefreshAt = Date.now();
     try {
@@ -4989,22 +5257,35 @@ var AgentHarness = class _AgentHarness {
       );
       const nextFingerprint = this.buildSkillFingerprint(latestSkills);
       if (nextFingerprint === this.skillFingerprint) {
-        return;
+        return false;
       }
       this.loadedSkills = latestSkills;
       this.skillContextWindow = buildSkillContextWindow(latestSkills);
       this.skillFingerprint = nextFingerprint;
       this.registerSkillTools(latestSkills);
-      this.activeSkillNames.clear();
+      const latestSkillNames = new Set(latestSkills.map((s) => s.name));
+      for (const name of this.activeSkillNames) {
+        if (!latestSkillNames.has(name)) {
+          this.activeSkillNames.delete(name);
+        }
+      }
+      if (this.mcpBridge) {
+        await this.mcpBridge.discoverTools();
+      }
       await this.refreshMcpTools("skills:changed");
+      return true;
     } catch (error) {
       console.warn(
         `[poncho][skills] Failed to refresh skills in development mode: ${error instanceof Error ? error.message : String(error)}`
       );
+      return false;
     }
   }
   async initialize() {
-    this.parsedAgent = await parseAgentFile(this.workingDir);
+    const agentFilePath = resolve10(this.workingDir, "AGENT.md");
+    const agentRawContent = await readFile8(agentFilePath, "utf8");
+    this.parsedAgent = parseAgentMarkdown(agentRawContent);
+    this.agentFileFingerprint = agentRawContent;
     const identity = await ensureAgentIdentity(this.workingDir);
     if (!this.parsedAgent.frontmatter.id) {
       this.parsedAgent.frontmatter.id = identity.id;
@@ -5025,8 +5306,8 @@ var AgentHarness = class _AgentHarness {
     this.skillContextWindow = buildSkillContextWindow(skillMetadata);
     this.skillFingerprint = this.buildSkillFingerprint(skillMetadata);
     this.registerSkillTools(skillMetadata);
+    const agentId = this.parsedAgent.frontmatter.id ?? this.parsedAgent.frontmatter.name;
     if (memoryConfig?.enabled) {
-      const agentId = this.parsedAgent.frontmatter.id ?? this.parsedAgent.frontmatter.name;
       this.memoryStore = createMemoryStore(
         agentId,
         memoryConfig,
@@ -5038,6 +5319,13 @@ var AgentHarness = class _AgentHarness {
         })
       );
     }
+    const stateConfig = resolveStateConfig(config);
+    this.todoStore = createTodoStore(agentId, stateConfig, { workingDir: this.workingDir });
+    for (const tool of createTodoTools(this.todoStore)) {
+      if (this.isToolEnabled(tool.name)) {
+        this.registerIfMissing(tool);
+      }
+    }
     if (config?.browser) {
       await this.initBrowserTools(config).catch((e) => {
         console.warn(
@@ -5077,14 +5365,14 @@ var AgentHarness = class _AgentHarness {
       const filePath = pathResolve(stateDir, `${sessionId}.json`);
       return {
         async save(json) {
-          const { mkdir: mkdir5, writeFile: writeFile6 } = await import("fs/promises");
-          await mkdir5(stateDir, { recursive: true });
-          await writeFile6(filePath, json, "utf8");
+          const { mkdir: mkdir6, writeFile: writeFile7 } = await import("fs/promises");
+          await mkdir6(stateDir, { recursive: true });
+          await writeFile7(filePath, json, "utf8");
         },
         async load() {
-          const { readFile: readFile8 } = await import("fs/promises");
+          const { readFile: readFile10 } = await import("fs/promises");
           try {
-            return await readFile8(filePath, "utf8");
+            return await readFile10(filePath, "utf8");
           } catch {
             return void 0;
           }
@@ -5150,7 +5438,7 @@ var AgentHarness = class _AgentHarness {
     let browserMod;
     try {
       const { existsSync } = await import("fs");
-      const { join, dirname: dirname5 } = await import("path");
+      const { join, dirname: dirname6 } = await import("path");
       const { pathToFileURL: pathToFileURL2 } = await import("url");
       let searchDir = this.workingDir;
       let entryPath;
@@ -5160,7 +5448,7 @@ var AgentHarness = class _AgentHarness {
           entryPath = candidate;
           break;
         }
-        const parent = dirname5(searchDir);
+        const parent = dirname6(searchDir);
         if (parent === searchDir) break;
         searchDir = parent;
       }
@@ -5248,9 +5536,9 @@ var AgentHarness = class _AgentHarness {
           for await (const event of this.run(input)) {
             eventQueue.push(event);
             if (queueResolve) {
-              const resolve10 = queueResolve;
+              const resolve12 = queueResolve;
               queueResolve = null;
-              resolve10();
+              resolve12();
             }
           }
         } catch (error) {
@@ -5269,8 +5557,8 @@ var AgentHarness = class _AgentHarness {
           if (eventQueue.length > 0) {
             yield eventQueue.shift();
           } else if (!generatorDone) {
-            await new Promise((resolve10) => {
-              queueResolve = resolve10;
+            await new Promise((resolve12) => {
+              queueResolve = resolve12;
             });
           }
         }
@@ -5308,13 +5596,14 @@ var AgentHarness = class _AgentHarness {
       await this.initialize();
     }
     const memoryPromise = this.memoryStore ? this.memoryStore.getMainMemory() : void 0;
+    await this.refreshAgentIfChanged();
     await this.refreshSkillsIfChanged();
     this._currentRunConversationId = input.conversationId;
     const ownerParam = input.parameters?.__ownerId;
     if (typeof ownerParam === "string") {
       this._currentRunOwnerId = ownerParam;
     }
-    const agent = this.parsedAgent;
+    let agent = this.parsedAgent;
     const runId = `run_${randomUUID3()}`;
     const start = now();
     const maxSteps = agent.frontmatter.limits?.maxSteps ?? 50;
@@ -5325,11 +5614,11 @@ var AgentHarness = class _AgentHarness {
     const messages = [...input.messages ?? []];
     const inputMessageCount = messages.length;
     const events = [];
-    const systemPrompt = renderAgentPrompt(agent, {
+    const renderCurrentAgentPrompt = () => renderAgentPrompt(this.parsedAgent, {
       parameters: input.parameters,
       runtime: {
         runId,
-        agentId: agent.frontmatter.id ?? agent.frontmatter.name,
+        agentId: this.parsedAgent.frontmatter.id ?? this.parsedAgent.frontmatter.name,
         environment: this.environment,
         workingDir: this.workingDir
       }
@@ -5357,9 +5646,6 @@ Browser sessions (cookies, localStorage, login state) are automatically saved an
 
 ### Tabs and resources
 Each conversation gets its own browser tab sharing a single browser instance. Call \`browser_close\` when done to free the tab. If you don't close it, the tab stays open and the user can continue interacting with it.` : "";
-    const promptWithSkills = this.skillContextWindow ? `${systemPrompt}${developmentContext}
-
-${this.skillContextWindow}${browserContext}` : `${systemPrompt}${developmentContext}${browserContext}`;
     const mainMemory = await memoryPromise;
     const boundedMainMemory = mainMemory && mainMemory.content.length > 4e3 ? `${mainMemory.content.slice(0, 4e3)}
 ...[truncated]` : mainMemory?.content;
@@ -5367,7 +5653,12 @@ ${this.skillContextWindow}${browserContext}` : `${systemPrompt}${developmentCont
 ## Persistent Memory
 
 ${boundedMainMemory.trim()}` : "";
-    const integrityPrompt = `${promptWithSkills}${memoryContext}
+    const buildSystemPrompt = () => {
+      const agentPrompt = renderCurrentAgentPrompt();
+      const promptWithSkills = this.skillContextWindow ? `${agentPrompt}${developmentContext}
+
+${this.skillContextWindow}${browserContext}` : `${agentPrompt}${developmentContext}${browserContext}`;
+      return `${promptWithSkills}${memoryContext}
 
 ## Execution Integrity
 
@@ -5375,6 +5666,10 @@ ${boundedMainMemory.trim()}` : "";
 - 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.`;
+    };
+    let integrityPrompt = buildSystemPrompt();
+    let lastPromptFingerprint = `${this.agentFileFingerprint}
+${this.skillFingerprint}`;
     const pushEvent = (event) => {
       events.push(event);
       return event;
@@ -5797,8 +6092,8 @@ ${textContent}` };
               let timer;
               nextPart = await Promise.race([
                 fullStreamIterator.next(),
-                new Promise((resolve10) => {
-                  timer = setTimeout(() => resolve10(null), timeout);
+                new Promise((resolve12) => {
+                  timer = setTimeout(() => resolve12(null), timeout);
                 })
               ]);
               clearTimeout(timer);
@@ -6106,6 +6401,19 @@ ${textContent}` };
           content: JSON.stringify(toolResultsForModel),
           metadata: toolMsgMeta
         });
+        if (this.environment === "development") {
+          const agentChanged = await this.refreshAgentIfChanged();
+          const skillsChanged = await this.refreshSkillsIfChanged(true);
+          if (agentChanged || skillsChanged) {
+            agent = this.parsedAgent;
+            const currentFingerprint = `${this.agentFileFingerprint}
+${this.skillFingerprint}`;
+            if (currentFingerprint !== lastPromptFingerprint) {
+              integrityPrompt = buildSystemPrompt();
+              lastPromptFingerprint = currentFingerprint;
+            }
+          }
+        }
         yield pushEvent({
           type: "step:completed",
           step,
@@ -6294,8 +6602,8 @@ var LatitudeCapture = class {
 
 // src/state.ts
 import { randomUUID as randomUUID4 } from "crypto";
-import { mkdir as mkdir4, readFile as readFile7, readdir as readdir4, rename as rename2, rm as rm3, writeFile as writeFile5 } from "fs/promises";
-import { dirname as dirname4, resolve as resolve9 } from "path";
+import { mkdir as mkdir5, readFile as readFile9, readdir as readdir4, rename as rename3, rm as rm3, writeFile as writeFile6 } from "fs/promises";
+import { dirname as dirname5, resolve as resolve11 } from "path";
 var DEFAULT_OWNER = "local-owner";
 var LOCAL_STATE_FILE = "state.json";
 var CONVERSATIONS_DIRECTORY = "conversations";
@@ -6310,11 +6618,11 @@ var toStoreIdentity = async ({
   }
   return { name: ensured.name, id: agentId };
 };
-var writeJsonAtomic2 = async (filePath, payload) => {
-  await mkdir4(dirname4(filePath), { recursive: true });
+var writeJsonAtomic3 = async (filePath, payload) => {
+  await mkdir5(dirname5(filePath), { recursive: true });
   const tmpPath = `${filePath}.tmp`;
-  await writeFile5(tmpPath, JSON.stringify(payload, null, 2), "utf8");
-  await rename2(tmpPath, filePath);
+  await writeFile6(tmpPath, JSON.stringify(payload, null, 2), "utf8");
+  await rename3(tmpPath, filePath);
 };
 var formatUtcTimestamp = (value) => new Date(value).toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
 var normalizeTitle = (title) => {
@@ -6488,8 +6796,8 @@ var FileConversationStore = class {
       agentId: this.agentId
     });
     const agentDir = getAgentStoreDirectory(identity);
-    const conversationsDir = resolve9(agentDir, CONVERSATIONS_DIRECTORY);
-    const indexPath = resolve9(conversationsDir, LOCAL_CONVERSATION_INDEX_FILE);
+    const conversationsDir = resolve11(agentDir, CONVERSATIONS_DIRECTORY);
+    const indexPath = resolve11(conversationsDir, LOCAL_CONVERSATION_INDEX_FILE);
     this.paths = { conversationsDir, indexPath };
     return this.paths;
   }
@@ -6499,13 +6807,13 @@ var FileConversationStore = class {
       schemaVersion: STORAGE_SCHEMA_VERSION,
       conversations: Array.from(this.conversations.values()).sort((a, b) => b.updatedAt - a.updatedAt)
     };
-    await writeJsonAtomic2(indexPath, payload);
+    await writeJsonAtomic3(indexPath, payload);
   }
   async readConversationFile(fileName) {
     const { conversationsDir } = await this.resolvePaths();
-    const filePath = resolve9(conversationsDir, fileName);
+    const filePath = resolve11(conversationsDir, fileName);
     try {
-      const raw = await readFile7(filePath, "utf8");
+      const raw = await readFile9(filePath, "utf8");
       return JSON.parse(raw);
     } catch {
       return void 0;
@@ -6551,7 +6859,7 @@ var FileConversationStore = class {
     this.loaded = true;
     const { indexPath } = await this.resolvePaths();
     try {
-      const raw = await readFile7(indexPath, "utf8");
+      const raw = await readFile9(indexPath, "utf8");
       const parsed = JSON.parse(raw);
       for (const conversation of parsed.conversations ?? []) {
         this.conversations.set(conversation.conversationId, conversation);
@@ -6574,9 +6882,9 @@ var FileConversationStore = class {
     const { conversationsDir } = await this.resolvePaths();
     const existing = this.conversations.get(conversation.conversationId);
     const fileName = existing?.fileName ?? this.resolveConversationFileName(conversation);
-    const filePath = resolve9(conversationsDir, fileName);
+    const filePath = resolve11(conversationsDir, fileName);
     this.writing = this.writing.then(async () => {
-      await writeJsonAtomic2(filePath, conversation);
+      await writeJsonAtomic3(filePath, conversation);
       this.conversations.set(conversation.conversationId, {
         conversationId: conversation.conversationId,
         title: conversation.title,
@@ -6672,7 +6980,7 @@ var FileConversationStore = class {
     if (removed) {
       this.writing = this.writing.then(async () => {
         if (existing) {
-          await rm3(resolve9(conversationsDir, existing.fileName), { force: true });
+          await rm3(resolve11(conversationsDir, existing.fileName), { force: true });
         }
         await this.writeIndex();
       });
@@ -6702,7 +7010,7 @@ var FileStateStore = class {
       workingDir: this.workingDir,
       agentId: this.agentId
     });
-    this.filePath = resolve9(getAgentStoreDirectory(identity), LOCAL_STATE_FILE);
+    this.filePath = resolve11(getAgentStoreDirectory(identity), LOCAL_STATE_FILE);
   }
   isExpired(state) {
     return typeof this.ttlMs === "number" && Date.now() - state.updatedAt > this.ttlMs;
@@ -6714,7 +7022,7 @@ var FileStateStore = class {
     }
     this.loaded = true;
     try {
-      const raw = await readFile7(this.filePath, "utf8");
+      const raw = await readFile9(this.filePath, "utf8");
       const parsed = JSON.parse(raw);
       for (const state of parsed.states ?? []) {
         this.states.set(state.runId, state);
@@ -6727,7 +7035,7 @@ var FileStateStore = class {
       states: Array.from(this.states.values())
     };
     this.writing = this.writing.then(async () => {
-      await writeJsonAtomic2(this.filePath, payload);
+      await writeJsonAtomic3(this.filePath, payload);
     });
     await this.writing;
   }
@@ -7441,7 +7749,7 @@ var TelemetryEmitter = class {
 };
 
 // src/index.ts
-import { defineTool as defineTool5 } from "@poncho-ai/sdk";
+import { defineTool as defineTool6 } from "@poncho-ai/sdk";
 export {
   AgentHarness,
   InMemoryConversationStore,
@@ -7471,7 +7779,7 @@ export {
   createSubagentTools,
   createUploadStore,
   createWriteTool,
-  defineTool5 as defineTool,
+  defineTool6 as defineTool,
   deriveUploadKey,
   ensureAgentIdentity,
   estimateTokens,