@poncho-ai/harness 0.25.0 → 0.27.0

package/dist/index.js

@@ -617,8 +617,10 @@ Response: Server-Sent Events (\`run:started\`, \`model:chunk\`, \`tool:*\`, \`ru
 
 On serverless deployments with \`PONCHO_MAX_DURATION\` set, the \`run:completed\` event may
 include \`continuation: true\` in \`result\`, indicating the agent stopped early due to a
-platform timeout and the client should send another message (e.g., \`"Continue"\`) on the
-same conversation to resume.
+platform timeout. The server preserves the full internal message chain so the agent
+resumes with complete context. The web UI and client SDK handle continuation automatically
+by re-posting to the same conversation with \`{ continuation: true }\` \u2014 no manual
+"Continue" message is needed.
 
 ## Build a custom chat UI
 
@@ -1288,28 +1290,28 @@ When \`@sparticuz/chromium\` is installed and a serverless environment is detect
 
 ## Subagents
 
-Poncho agents can spawn recursive copies of themselves as **subagents**. Each subagent runs in its own independent conversation with full access to the agent's tools and skills. The parent agent controls the subagent lifecycle and receives results directly.
+Poncho agents can spawn **subagents** \u2014 independent background tasks that run in their own conversations. Each subagent has full access to the agent's tools and skills. Subagents run asynchronously and their results are delivered back to the parent automatically.
 
 Subagents are useful when an agent needs to parallelize work, delegate a subtask, or isolate a line of investigation without polluting the main conversation context.
 
 ### How it works
 
-When the agent decides to use a subagent, it calls \`spawn_subagent\` with a task description. The subagent runs to completion and the result is returned to the parent \u2014 the call is **blocking**, so the parent waits for the subagent to finish before continuing.
+When the agent decides to use a subagent, it calls \`spawn_subagent\` with a task description. The tool returns immediately with a subagent ID and \`status: "running"\`. The subagent runs in the background and, when it completes, its result is delivered to the parent conversation as a message \u2014 triggering a callback that lets the parent process or summarize the result.
 
-The parent can also send follow-up messages to existing subagents with \`message_subagent\`, stop a running subagent with \`stop_subagent\`, or list all its subagents with \`list_subagents\`.
+The agent can spawn multiple subagents in a single response and they run concurrently. The parent can also send follow-up messages to existing subagents with \`message_subagent\`, stop a running subagent with \`stop_subagent\`, or list all its subagents with \`list_subagents\`.
 
 ### Available tools
 
 | Tool | Description |
 |------|-------------|
-| \`spawn_subagent\` | Create a new subagent with a task. Blocks until the subagent completes and returns the result. |
-| \`message_subagent\` | Send a follow-up message to an existing subagent. Blocks until it responds. |
+| \`spawn_subagent\` | Create a new subagent with a task. Returns immediately; results are delivered asynchronously. |
+| \`message_subagent\` | Send a follow-up message to an existing subagent. Returns immediately. |
 | \`stop_subagent\` | Stop a running subagent. |
 | \`list_subagents\` | List all subagents for the current conversation with their IDs, tasks, and statuses. |
 
 ### Limits
 
-- **Max depth**: 3 levels of nesting (an agent can spawn a subagent, which can spawn another, but no deeper).
+- **No nesting**: subagents cannot spawn their own subagents.
 - **Max concurrent**: 5 subagents per parent conversation.
 
 ### Memory isolation
@@ -2030,9 +2032,9 @@ var ponchoDocsTool = defineTool({
 
 // src/harness.ts
 import { randomUUID as randomUUID3 } from "crypto";
-import { readFile as readFile7 } from "fs/promises";
-import { resolve as resolve9 } from "path";
-import { getTextContent as getTextContent3 } from "@poncho-ai/sdk";
+import { readFile as readFile8 } from "fs/promises";
+import { resolve as resolve10 } from "path";
+import { getTextContent as getTextContent2 } from "@poncho-ai/sdk";
 
 // src/upload-store.ts
 import { createHash as createHash2 } from "crypto";
@@ -2346,6 +2348,152 @@ 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) {
+    const response = await fetch(this.baseUrl, {
+      method: "POST",
+      headers: this.headers(),
+      body: JSON.stringify(["SET", key, value])
+    });
+    if (!response.ok) {
+      const text = await response.text().catch(() => "");
+      console.error(`[kv][upstash] SET failed (${response.status}): ${text.slice(0, 200)}`);
+    }
+  }
+  async setWithTtl(key, value, ttl) {
+    const response = await fetch(this.baseUrl, {
+      method: "POST",
+      headers: this.headers(),
+      body: JSON.stringify(["SETEX", key, Math.max(1, ttl), value])
+    });
+    if (!response.ok) {
+      const text = await response.text().catch(() => "");
+      console.error(`[kv][upstash] SETEX failed (${response.status}): ${text.slice(0, 200)}`);
+    }
+  }
+};
+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
@@ -2456,19 +2604,21 @@ var FileMainMemoryStore = class {
     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;
@@ -2478,200 +2628,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
-      });
+      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);
-    payload.main = {
-      content: input.content.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);
@@ -2679,44 +2661,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);
 };
@@ -2889,6 +2837,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;
@@ -3383,8 +3594,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) => {
@@ -3396,7 +3607,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 : {};
@@ -3465,7 +3676,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()) {
@@ -3500,13 +3711,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
         });
       }
@@ -3545,7 +3756,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();
 };
@@ -3554,11 +3765,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) => {
@@ -3675,16 +3886,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: {
@@ -3721,7 +3932,7 @@ var createSkillTools = (skills, options) => {
         }
       }
     }),
-    defineTool3({
+    defineTool4({
       name: "deactivate_skill",
       description: "Deactivate a previously activated skill and update scoped tool availability.",
       inputSchema: {
@@ -3750,7 +3961,7 @@ var createSkillTools = (skills, options) => {
         }
       }
     }),
-    defineTool3({
+    defineTool4({
       name: "list_active_skills",
       description: "List currently active skills with scoped MCP tools.",
       inputSchema: {
@@ -3762,7 +3973,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: {
@@ -3802,7 +4013,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: {
@@ -3837,7 +4048,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: {
@@ -3934,7 +4145,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()) {
@@ -3973,8 +4184,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();
@@ -4048,36 +4259,11 @@ var extractRunnableFunction = (value) => {
 };
 
 // src/subagent-tools.ts
-import { defineTool as defineTool4, getTextContent as getTextContent2 } from "@poncho-ai/sdk";
-var LAST_MESSAGES_TO_RETURN = 10;
-var summarizeResult = (r) => {
-  const summary = {
-    subagentId: r.subagentId,
-    status: r.status
-  };
-  if (r.result) {
-    summary.result = {
-      status: r.result.status,
-      response: r.result.response,
-      steps: r.result.steps,
-      duration: r.result.duration
-    };
-  }
-  if (r.error) {
-    summary.error = r.error;
-  }
-  if (r.latestMessages && r.latestMessages.length > 0) {
-    summary.latestMessages = r.latestMessages.slice(-LAST_MESSAGES_TO_RETURN).map((m) => ({
-      role: m.role,
-      content: getTextContent2(m).slice(0, 2e3)
-    }));
-  }
-  return summary;
-};
-var createSubagentTools = (manager, getConversationId, getOwnerId) => [
-  defineTool4({
+import { defineTool as defineTool5 } from "@poncho-ai/sdk";
+var createSubagentTools = (manager) => [
+  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.",
+    description: "Spawn a subagent to work on a task in the background. Returns immediately with a subagent ID. The subagent runs independently and its result will be delivered to you as a message in the conversation when it completes.\n\nGuidelines:\n- Spawn all needed subagents in a SINGLE response (they run concurrently), then end your turn with a brief message to the user.\n- Do NOT spawn more subagents in follow-up steps. Wait for results to be delivered before deciding if more work is needed.\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: {
       type: "object",
       properties: {
@@ -4089,26 +4275,27 @@ var createSubagentTools = (manager, getConversationId, getOwnerId) => [
       required: ["task"],
       additionalProperties: false
     },
-    handler: async (input) => {
+    handler: async (input, context) => {
       const task = typeof input.task === "string" ? input.task : "";
       if (!task.trim()) {
         return { error: "task is required" };
       }
-      const conversationId = getConversationId();
+      const conversationId = context.conversationId;
       if (!conversationId) {
         return { error: "no active conversation to spawn subagent from" };
       }
-      const result = await manager.spawn({
+      const ownerId = typeof context.parameters.__ownerId === "string" ? context.parameters.__ownerId : "anonymous";
+      const { subagentId } = await manager.spawn({
         task: task.trim(),
         parentConversationId: conversationId,
-        ownerId: getOwnerId()
+        ownerId
       });
-      return summarizeResult(result);
+      return { subagentId, status: "running" };
     }
   }),
-  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.",
+    description: "Send a follow-up message to a completed or stopped subagent. The subagent restarts in the background and its result will be delivered to you as a message when it completes. Only works when the subagent is not currently running.",
     inputSchema: {
       type: "object",
       properties: {
@@ -4130,11 +4317,11 @@ var createSubagentTools = (manager, getConversationId, getOwnerId) => [
       if (!subagentId || !message.trim()) {
         return { error: "subagent_id and message are required" };
       }
-      const result = await manager.sendMessage(subagentId, message.trim());
-      return summarizeResult(result);
+      const { subagentId: id } = await manager.sendMessage(subagentId, message.trim());
+      return { subagentId: id, status: "running" };
     }
   }),
-  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: {
@@ -4157,7 +4344,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: {
@@ -4165,8 +4352,8 @@ var createSubagentTools = (manager, getConversationId, getOwnerId) => [
       properties: {},
       additionalProperties: false
     },
-    handler: async () => {
-      const conversationId = getConversationId();
+    handler: async (_input, context) => {
+      const conversationId = context.conversationId;
       if (!conversationId) {
         return { error: "no active conversation" };
       }
@@ -4705,6 +4892,7 @@ var AgentHarness = class _AgentHarness {
   uploadStore;
   skillContextWindow = "";
   memoryStore;
+  todoStore;
   loadedConfig;
   loadedSkills = [];
   skillFingerprint = "";
@@ -4761,11 +4949,7 @@ var AgentHarness = class _AgentHarness {
   setSubagentManager(manager) {
     this.subagentManager = manager;
     this.dispatcher.registerMany(
-      createSubagentTools(
-        manager,
-        () => this._currentRunConversationId,
-        () => this._currentRunOwnerId ?? "anonymous"
-      )
+      createSubagentTools(manager)
     );
   }
   registerConfiguredBuiltInTools(config) {
@@ -4813,6 +4997,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();
   }
@@ -5008,8 +5196,8 @@ var AgentHarness = class _AgentHarness {
       return false;
     }
     try {
-      const agentFilePath = resolve9(this.workingDir, "AGENT.md");
-      const rawContent = await readFile7(agentFilePath, "utf8");
+      const agentFilePath = resolve10(this.workingDir, "AGENT.md");
+      const rawContent = await readFile8(agentFilePath, "utf8");
       if (rawContent === this.agentFileFingerprint) {
         return false;
       }
@@ -5078,8 +5266,8 @@ var AgentHarness = class _AgentHarness {
     }
   }
   async initialize() {
-    const agentFilePath = resolve9(this.workingDir, "AGENT.md");
-    const agentRawContent = await readFile7(agentFilePath, "utf8");
+    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);
@@ -5102,8 +5290,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,
@@ -5115,6 +5303,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(
@@ -5154,14 +5349,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: readFile9 } = await import("fs/promises");
+          const { readFile: readFile10 } = await import("fs/promises");
           try {
-            return await readFile9(filePath, "utf8");
+            return await readFile10(filePath, "utf8");
           } catch {
             return void 0;
           }
@@ -5227,7 +5422,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;
@@ -5237,7 +5432,7 @@ var AgentHarness = class _AgentHarness {
           entryPath = candidate;
           break;
         }
-        const parent = dirname5(searchDir);
+        const parent = dirname6(searchDir);
         if (parent === searchDir) break;
         searchDir = parent;
       }
@@ -5260,8 +5455,7 @@ var AgentHarness = class _AgentHarness {
     const session = new browserMod.BrowserSession(sessionId, browserCfg);
     this._browserSession = session;
     const tools = browserMod.createBrowserTools(
-      () => session,
-      () => this._currentRunConversationId ?? "__default__"
+      () => session
     );
     for (const tool of tools) {
       if (this.isToolEnabled(tool.name)) {
@@ -5269,10 +5463,6 @@ var AgentHarness = class _AgentHarness {
       }
     }
   }
-  /** Conversation ID of the currently executing run (set during run, cleared after). */
-  _currentRunConversationId;
-  /** Owner ID of the currently executing run (used by subagent tools). */
-  _currentRunOwnerId;
   get browserSession() {
     return this._browserSession;
   }
@@ -5325,9 +5515,9 @@ var AgentHarness = class _AgentHarness {
           for await (const event of this.run(input)) {
             eventQueue.push(event);
             if (queueResolve) {
-              const resolve11 = queueResolve;
+              const resolve12 = queueResolve;
               queueResolve = null;
-              resolve11();
+              resolve12();
             }
           }
         } catch (error) {
@@ -5346,8 +5536,8 @@ var AgentHarness = class _AgentHarness {
           if (eventQueue.length > 0) {
             yield eventQueue.shift();
           } else if (!generatorDone) {
-            await new Promise((resolve11) => {
-              queueResolve = resolve11;
+            await new Promise((resolve12) => {
+              queueResolve = resolve12;
             });
           }
         }
@@ -5387,11 +5577,6 @@ var AgentHarness = class _AgentHarness {
     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;
-    }
     let agent = this.parsedAgent;
     const runId = `run_${randomUUID3()}`;
     const start = now();
@@ -5399,7 +5584,7 @@ var AgentHarness = class _AgentHarness {
     const configuredTimeout = agent.frontmatter.limits?.timeout;
     const timeoutMs = this.environment === "development" && configuredTimeout == null ? 0 : (configuredTimeout ?? 300) * 1e3;
     const platformMaxDurationSec = Number(process.env.PONCHO_MAX_DURATION) || 0;
-    const softDeadlineMs = platformMaxDurationSec > 0 ? platformMaxDurationSec * 800 : 0;
+    const softDeadlineMs = input.disableSoftDeadline || platformMaxDurationSec <= 0 ? 0 : platformMaxDurationSec * 800;
     const messages = [...input.messages ?? []];
     const inputMessageCount = messages.length;
     const events = [];
@@ -5533,6 +5718,15 @@ ${this.skillFingerprint}`;
           metadata: { timestamp: now(), id: randomUUID3() }
         });
       }
+    } else {
+      const lastMsg = messages[messages.length - 1];
+      if (lastMsg && lastMsg.role !== "user") {
+        messages.push({
+          role: "user",
+          content: "[System: Your previous turn was interrupted by a time limit. Continue from where you left off \u2014 do NOT repeat what you already said. Proceed directly with the next action or tool call.]",
+          metadata: { timestamp: now(), id: randomUUID3() }
+        });
+      }
     }
     let responseText = "";
     let totalInputTokens = 0;
@@ -5567,6 +5761,7 @@ ${this.skillFingerprint}`;
             tokens: { input: totalInputTokens, output: totalOutputTokens, cached: totalCachedTokens },
             duration: now() - start,
             continuation: true,
+            continuationMessages: [...messages],
             maxSteps
           };
           yield pushEvent({ type: "run:completed", runId, result: result2 });
@@ -5600,7 +5795,7 @@ ${this.skillFingerprint}`;
             if (rich && rich.length > 0) {
               return [{ role: "tool", content: rich }];
             }
-            const textContent = typeof msg.content === "string" ? msg.content : getTextContent3(msg);
+            const textContent = typeof msg.content === "string" ? msg.content : getTextContent2(msg);
             try {
               const parsed = JSON.parse(textContent);
               if (!Array.isArray(parsed)) {
@@ -5650,7 +5845,7 @@ ${this.skillFingerprint}`;
             }
           }
           if (msg.role === "assistant") {
-            const assistantText = typeof msg.content === "string" ? msg.content : getTextContent3(msg);
+            const assistantText = typeof msg.content === "string" ? msg.content : getTextContent2(msg);
             try {
               const parsed = JSON.parse(assistantText);
               if (typeof parsed === "object" && parsed !== null) {
@@ -5684,12 +5879,15 @@ ${this.skillFingerprint}`;
               }
             } catch {
             }
+            if (!assistantText || assistantText.trim().length === 0) {
+              return [];
+            }
             return [{ role: "assistant", content: assistantText }];
           }
           if (msg.role === "system") {
             return [{
               role: "system",
-              content: typeof msg.content === "string" ? msg.content : getTextContent3(msg)
+              content: typeof msg.content === "string" ? msg.content : getTextContent2(msg)
             }];
           }
           if (msg.role === "user") {
@@ -5881,8 +6079,8 @@ ${textContent}` };
               let timer;
               nextPart = await Promise.race([
                 fullStreamIterator.next(),
-                new Promise((resolve11) => {
-                  timer = setTimeout(() => resolve11(null), timeout);
+                new Promise((resolve12) => {
+                  timer = setTimeout(() => resolve12(null), timeout);
                 })
               ]);
               clearTimeout(timer);
@@ -6243,6 +6441,7 @@ ${this.skillFingerprint}`;
         tokens: { input: totalInputTokens, output: totalOutputTokens, cached: totalCachedTokens },
         duration: now() - start,
         continuation: true,
+        continuationMessages: [...messages],
         maxSteps
       };
       yield pushEvent({ type: "run:completed", runId, result });
@@ -6391,8 +6590,8 @@ var LatitudeCapture = class {
 
 // src/state.ts
 import { randomUUID as randomUUID4 } from "crypto";
-import { mkdir as mkdir4, readFile as readFile8, readdir as readdir4, rename as rename2, rm as rm3, writeFile as writeFile5 } from "fs/promises";
-import { dirname as dirname4, resolve as resolve10 } 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";
@@ -6407,11 +6606,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) => {
@@ -6564,6 +6763,13 @@ var InMemoryConversationStore = class {
   async delete(conversationId) {
     return this.conversations.delete(conversationId);
   }
+  async appendSubagentResult(conversationId, result) {
+    const conversation = this.conversations.get(conversationId);
+    if (!conversation) return;
+    if (!conversation.pendingSubagentResults) conversation.pendingSubagentResults = [];
+    conversation.pendingSubagentResults.push(result);
+    conversation.updatedAt = Date.now();
+  }
 };
 var FileConversationStore = class {
   workingDir;
@@ -6585,8 +6791,8 @@ var FileConversationStore = class {
       agentId: this.agentId
     });
     const agentDir = getAgentStoreDirectory(identity);
-    const conversationsDir = resolve10(agentDir, CONVERSATIONS_DIRECTORY);
-    const indexPath = resolve10(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;
   }
@@ -6596,13 +6802,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 = resolve10(conversationsDir, fileName);
+    const filePath = resolve11(conversationsDir, fileName);
     try {
-      const raw = await readFile8(filePath, "utf8");
+      const raw = await readFile9(filePath, "utf8");
       return JSON.parse(raw);
     } catch {
       return void 0;
@@ -6648,7 +6854,7 @@ var FileConversationStore = class {
     this.loaded = true;
     const { indexPath } = await this.resolvePaths();
     try {
-      const raw = await readFile8(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);
@@ -6671,9 +6877,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 = resolve10(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,
@@ -6769,7 +6975,7 @@ var FileConversationStore = class {
     if (removed) {
       this.writing = this.writing.then(async () => {
         if (existing) {
-          await rm3(resolve10(conversationsDir, existing.fileName), { force: true });
+          await rm3(resolve11(conversationsDir, existing.fileName), { force: true });
         }
         await this.writeIndex();
       });
@@ -6777,6 +6983,15 @@ var FileConversationStore = class {
     }
     return removed;
   }
+  async appendSubagentResult(conversationId, result) {
+    await this.ensureLoaded();
+    const conversation = await this.get(conversationId);
+    if (!conversation) return;
+    if (!conversation.pendingSubagentResults) conversation.pendingSubagentResults = [];
+    conversation.pendingSubagentResults.push(result);
+    conversation.updatedAt = Date.now();
+    await this.update(conversation);
+  }
 };
 var FileStateStore = class {
   workingDir;
@@ -6799,7 +7014,7 @@ var FileStateStore = class {
       workingDir: this.workingDir,
       agentId: this.agentId
     });
-    this.filePath = resolve10(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;
@@ -6811,7 +7026,7 @@ var FileStateStore = class {
     }
     this.loaded = true;
     try {
-      const raw = await readFile8(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);
@@ -6824,7 +7039,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;
   }
@@ -6856,6 +7071,7 @@ var KeyValueConversationStoreBase = class {
   ttl;
   agentIdPromise;
   ownerLocks = /* @__PURE__ */ new Map();
+  appendLocks = /* @__PURE__ */ new Map();
   memoryFallback;
   constructor(ttl, workingDir, agentId) {
     this.ttl = ttl;
@@ -6874,6 +7090,18 @@ var KeyValueConversationStoreBase = class {
       }
     }
   }
+  async withAppendLock(conversationId, task) {
+    const prev = this.appendLocks.get(conversationId) ?? Promise.resolve();
+    const next = prev.then(task, task);
+    this.appendLocks.set(conversationId, next);
+    try {
+      await next;
+    } finally {
+      if (this.appendLocks.get(conversationId) === next) {
+        this.appendLocks.delete(conversationId);
+      }
+    }
+  }
   async namespace() {
     const agentId = await this.agentIdPromise;
     return `poncho:${STORAGE_SCHEMA_VERSION}:${slugifyStorageComponent(agentId)}`;
@@ -7094,6 +7322,16 @@ var KeyValueConversationStoreBase = class {
     });
     return true;
   }
+  async appendSubagentResult(conversationId, result) {
+    await this.withAppendLock(conversationId, async () => {
+      const conversation = await this.get(conversationId);
+      if (!conversation) return;
+      if (!conversation.pendingSubagentResults) conversation.pendingSubagentResults = [];
+      conversation.pendingSubagentResults.push(result);
+      conversation.updatedAt = Date.now();
+      await this.update(conversation);
+    });
+  }
 };
 var UpstashConversationStore = class extends KeyValueConversationStoreBase {
   baseUrl;
@@ -7136,20 +7374,26 @@ var UpstashConversationStore = class extends KeyValueConversationStoreBase {
         return (payload.result ?? []).map((v) => v ?? void 0);
       },
       set: async (key, value, ttl) => {
-        const endpoint = typeof ttl === "number" ? `${this.baseUrl}/setex/${encodeURIComponent(key)}/${Math.max(
-          1,
-          ttl
-        )}/${encodeURIComponent(value)}` : `${this.baseUrl}/set/${encodeURIComponent(key)}/${encodeURIComponent(value)}`;
-        await fetch(endpoint, {
+        const command = typeof ttl === "number" ? ["SETEX", key, Math.max(1, ttl), value] : ["SET", key, value];
+        const response = await fetch(this.baseUrl, {
           method: "POST",
-          headers: this.headers()
+          headers: this.headers(),
+          body: JSON.stringify(command)
         });
+        if (!response.ok) {
+          const text = await response.text().catch(() => "");
+          console.error(`[store][upstash] SET failed (${response.status}): ${text.slice(0, 200)}`);
+        }
       },
       del: async (key) => {
-        await fetch(`${this.baseUrl}/del/${encodeURIComponent(key)}`, {
+        const response = await fetch(`${this.baseUrl}/del/${encodeURIComponent(key)}`, {
           method: "POST",
           headers: this.headers()
         });
+        if (!response.ok) {
+          const text = await response.text().catch(() => "");
+          console.error(`[store][upstash] DEL failed (${response.status}): ${text.slice(0, 200)}`);
+        }
       }
     };
   }
@@ -7538,7 +7782,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,
@@ -7568,7 +7812,7 @@ export {
   createSubagentTools,
   createUploadStore,
   createWriteTool,
-  defineTool5 as defineTool,
+  defineTool6 as defineTool,
   deriveUploadKey,
   ensureAgentIdentity,
   estimateTokens,