@poncho-ai/harness 0.37.2 → 0.39.0

package/src/storage/sql-dialect.ts

@@ -8,14 +8,19 @@
 // ---------------------------------------------------------------------------
 
 import { randomUUID } from "node:crypto";
+import { createLogger } from "@poncho-ai/sdk";
 import type {
   Conversation,
+  ConversationCreateInit,
+  ConversationStatusSnapshot,
   ConversationSummary,
   PendingSubagentResult,
 } from "../state.js";
+
+const egressLog = createLogger("egress");
 import type { MainMemory } from "../memory.js";
 import type { TodoItem } from "../todo-tools.js";
-import type { Reminder } from "../reminder-store.js";
+import type { Reminder, ReminderCreateInput, ReminderStatus } from "../reminder-store.js";
 import type { StorageEngine, VfsDirEntry, VfsStat } from "./engine.js";
 import { type DialectTag, migrations } from "./schema.js";
 
@@ -104,10 +109,91 @@ const rewrite = (sql: string, dialect: Dialect): string => {
 // SqlStorageEngine base class
 // ---------------------------------------------------------------------------
 
+// ---------------------------------------------------------------------------
+// Conversation egress meter — tracks estimated bytes read from / written to
+// the conversations table per method. Enable periodic logging by setting
+// PONCHO_LOG_EGRESS=1 in the environment.
+// ---------------------------------------------------------------------------
+
+interface EgressBucket {
+  calls: number;
+  bytes: number;
+}
+
+class ConversationEgressMeter {
+  readonly read: Record<string, EgressBucket> = {};
+  readonly write: Record<string, EgressBucket> = {};
+  private lastLogAt = Date.now();
+  private readonly logIntervalMs: number;
+  private readonly enabled: boolean;
+
+  constructor(logIntervalMs = 60_000) {
+    this.logIntervalMs = logIntervalMs;
+    this.enabled = process.env.PONCHO_LOG_EGRESS === "1";
+  }
+
+  trackRead(method: string, bytes: number): void {
+    const b = (this.read[method] ??= { calls: 0, bytes: 0 });
+    b.calls += 1;
+    b.bytes += bytes;
+    this.maybeLog();
+  }
+
+  trackWrite(method: string, bytes: number): void {
+    const b = (this.write[method] ??= { calls: 0, bytes: 0 });
+    b.calls += 1;
+    b.bytes += bytes;
+    this.maybeLog();
+  }
+
+  private maybeLog(): void {
+    if (!this.enabled) return;
+    const now = Date.now();
+    if (now - this.lastLogAt < this.logIntervalMs) return;
+    this.lastLogAt = now;
+    this.flush();
+  }
+
+  flush(): void {
+    if (!this.enabled) return;
+    const fmt = (buckets: Record<string, EgressBucket>) =>
+      Object.entries(buckets)
+        .filter(([, b]) => b.calls > 0)
+        .map(([m, b]) => `${m}=${b.calls}calls/${fmtBytes(b.bytes)}`)
+        .join(", ");
+    const r = fmt(this.read);
+    const w = fmt(this.write);
+    if (r || w) {
+      egressLog.debug(`read: ${r || "(none)"} | write: ${w || "(none)"}`);
+    }
+    // Reset after logging.
+    for (const b of Object.values(this.read)) { b.calls = 0; b.bytes = 0; }
+    for (const b of Object.values(this.write)) { b.calls = 0; b.bytes = 0; }
+  }
+}
+
+const fmtBytes = (n: number): string => {
+  if (n < 1024) return `${n}B`;
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)}KB`;
+  return `${(n / (1024 * 1024)).toFixed(2)}MB`;
+};
+
+/** Estimate the byte size of a string-ish value (JSON column from the DB). */
+const colBytes = (v: unknown): number => {
+  if (v == null) return 0;
+  if (typeof v === "string") return v.length;
+  if (Buffer.isBuffer(v)) return v.byteLength;
+  // JSONB columns in node-postgres come back as parsed objects — estimate
+  // by re-stringifying. This is only called on the measured hot paths, so
+  // the overhead is acceptable.
+  return JSON.stringify(v).length;
+};
+
 export abstract class SqlStorageEngine implements StorageEngine {
   protected readonly dialect: Dialect;
   protected readonly agentId: string;
   protected abstract readonly executor: QueryExecutor;
+  protected readonly egressMeter = new ConversationEgressMeter();
 
   constructor(dialect: Dialect, agentId: string) {
     this.dialect = dialect;
@@ -125,6 +211,11 @@ export abstract class SqlStorageEngine implements StorageEngine {
 
   abstract close(): Promise<void>;
 
+  /** Flush egress stats before shutdown. Subclasses should call super. */
+  protected flushEgressStats(): void {
+    this.egressMeter.flush();
+  }
+
   /** Hook for subclass-specific setup (e.g. WAL mode). */
   protected async onBeforeInit(): Promise<void> {}
 
@@ -189,7 +280,7 @@ export abstract class SqlStorageEngine implements StorageEngine {
       const filterTenant = tenantId !== undefined;
       const params: unknown[] = [this.agentId];
       let sql = `SELECT id, title, updated_at, created_at, owner_id, tenant_id,
-                        message_count, parent_conversation_id,
+                        message_count, parent_conversation_id, parent_message_id,
                         has_pending_approvals, channel_meta
                  FROM conversations WHERE agent_id = $1`;
       if (filterTenant) {
@@ -207,6 +298,83 @@ export abstract class SqlStorageEngine implements StorageEngine {
     },
 
     get: async (conversationId: string): Promise<Conversation | undefined> => {
+      // Skip tool_result_archive — unbounded blob, only needed on run-entry
+      // paths which must use getWithArchive() instead.
+      const row = await this.executor.get<{
+        data: unknown;
+        harness_messages: unknown;
+        continuation_messages: unknown;
+      }>(
+        rewrite("SELECT data, harness_messages, continuation_messages FROM conversations WHERE id = $1 AND agent_id = $2", this.dialect),
+        [conversationId, this.agentId],
+      );
+      if (!row) return undefined;
+      this.egressMeter.trackRead("get",
+        colBytes(row.data) + colBytes(row.harness_messages) + colBytes(row.continuation_messages));
+      const conv = this.parseConversation(row.data);
+      if (row.harness_messages) {
+        conv._harnessMessages =
+          typeof row.harness_messages === "string"
+            ? JSON.parse(row.harness_messages)
+            : row.harness_messages;
+      }
+      if (row.continuation_messages) {
+        conv._continuationMessages =
+          typeof row.continuation_messages === "string"
+            ? JSON.parse(row.continuation_messages)
+            : row.continuation_messages;
+      }
+      return conv;
+    },
+
+    getStatusSnapshot: async (
+      conversationId: string,
+    ): Promise<ConversationStatusSnapshot | undefined> => {
+      // Column-only read. runStatus lives inside the `data` JSON; extract it
+      // with a dialect-specific JSON path expression rather than pulling the
+      // whole blob.
+      const runStatusExpr = this.dialect.tag === "sqlite"
+        ? "json_extract(data, '$.runStatus')"
+        : "data->>'runStatus'";
+      const row = await this.executor.get<{
+        updated_at: string;
+        message_count: number;
+        has_pending_approvals: number | boolean;
+        parent_conversation_id: string | null;
+        owner_id: string;
+        tenant_id: string | null;
+        has_continuation_messages: number | boolean;
+        run_status: string | null;
+      }>(
+        rewrite(
+          `SELECT updated_at, message_count, has_pending_approvals,
+                  parent_conversation_id, owner_id, tenant_id,
+                  (continuation_messages IS NOT NULL) AS has_continuation_messages,
+                  ${runStatusExpr} AS run_status
+           FROM conversations WHERE id = $1 AND agent_id = $2`,
+          this.dialect,
+        ),
+        [conversationId, this.agentId],
+      );
+      if (!row) return undefined;
+      this.egressMeter.trackRead("getStatusSnapshot", 200); // fixed-size column read
+      const runStatus = row.run_status === "running" || row.run_status === "idle"
+        ? row.run_status
+        : null;
+      return {
+        conversationId,
+        updatedAt: new Date(row.updated_at).getTime(),
+        messageCount: row.message_count ?? 0,
+        hasPendingApprovals: !!row.has_pending_approvals,
+        hasContinuationMessages: !!row.has_continuation_messages,
+        parentConversationId: row.parent_conversation_id,
+        ownerId: row.owner_id,
+        tenantId: row.tenant_id === "__default__" ? null : row.tenant_id,
+        runStatus,
+      };
+    },
+
+    getWithArchive: async (conversationId: string): Promise<Conversation | undefined> => {
       const row = await this.executor.get<{
         data: unknown;
         tool_result_archive: unknown;
@@ -217,8 +385,10 @@ export abstract class SqlStorageEngine implements StorageEngine {
         [conversationId, this.agentId],
       );
       if (!row) return undefined;
+      this.egressMeter.trackRead("getWithArchive",
+        colBytes(row.data) + colBytes(row.tool_result_archive) +
+        colBytes(row.harness_messages) + colBytes(row.continuation_messages));
       const conv = this.parseConversation(row.data);
-      // Rehydrate heavy fields from separate columns
       if (row.tool_result_archive) {
         conv._toolResultArchive =
           typeof row.tool_result_archive === "string"
@@ -244,24 +414,41 @@ export abstract class SqlStorageEngine implements StorageEngine {
       ownerId?: string,
       title?: string,
       tenantId?: string | null,
+      init?: ConversationCreateInit,
     ): Promise<Conversation> => {
       const id = randomUUID();
       const now = Date.now();
       const conv: Conversation = {
         conversationId: id,
         title: normalizeTitle(title),
-        messages: [],
+        messages: init?.messages ?? [],
         ownerId: ownerId ?? DEFAULT_OWNER,
         tenantId: tenantId === undefined ? null : tenantId,
         createdAt: now,
         updatedAt: now,
+        ...(init?.parentConversationId !== undefined
+          ? { parentConversationId: init.parentConversationId }
+          : {}),
+        ...(init?.parentMessageId !== undefined
+          ? { parentMessageId: init.parentMessageId }
+          : {}),
+        ...(init?.subagentMeta !== undefined
+          ? { subagentMeta: init.subagentMeta }
+          : {}),
+        ...(init?.threadMeta !== undefined
+          ? { threadMeta: init.threadMeta }
+          : {}),
+        ...(init?.channelMeta !== undefined
+          ? { channelMeta: init.channelMeta }
+          : {}),
       };
       const data = JSON.stringify(conv);
+      const channelMetaJson = conv.channelMeta ? JSON.stringify(conv.channelMeta) : null;
       await this.executor.run(
         rewrite(
           `INSERT INTO conversations (id, agent_id, tenant_id, owner_id, title, data, message_count, created_at, updated_at,
-               parent_conversation_id, has_pending_approvals, channel_meta)
-           VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)`,
+               parent_conversation_id, parent_message_id, has_pending_approvals, channel_meta)
+           VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)`,
           this.dialect,
         ),
         [
@@ -271,12 +458,13 @@ export abstract class SqlStorageEngine implements StorageEngine {
           conv.ownerId,
           conv.title,
           data,
-          0,
+          conv.messages.length,
           new Date(now).toISOString(),
           new Date(now).toISOString(),
-          null,
+          conv.parentConversationId ?? null,
+          conv.parentMessageId ?? null,
           0,
-          null,
+          channelMetaJson,
         ],
       );
       return conv;
@@ -297,25 +485,35 @@ export abstract class SqlStorageEngine implements StorageEngine {
       const archiveJson = archive ? JSON.stringify(archive) : null;
       const harnessJson = harnessMessages ? JSON.stringify(harnessMessages) : null;
       const continuationJson = continuationMessages ? JSON.stringify(continuationMessages) : null;
+      this.egressMeter.trackWrite("update",
+        data.length + (archiveJson?.length ?? 0) +
+        (harnessJson?.length ?? 0) + (continuationJson?.length ?? 0));
       const msgCount = conversation.messages?.length ?? 0;
       const tid = normalizeTenant(conversation.tenantId);
       const now = new Date(conversation.updatedAt).toISOString();
       const created = new Date(conversation.createdAt).toISOString();
       const parentConvId = conversation.parentConversationId ?? null;
+      const parentMsgId = conversation.parentMessageId ?? null;
       const hasPendingApprovals = (conversation.pendingApprovals?.length ?? 0) > 0 ? 1 : 0;
       const channelMetaJson = conversation.channelMeta ? JSON.stringify(conversation.channelMeta) : null;
       await this.executor.run(
         rewrite(
           `INSERT INTO conversations (id, agent_id, tenant_id, owner_id, title, data, message_count, created_at, updated_at,
                tool_result_archive, harness_messages, continuation_messages,
-               parent_conversation_id, has_pending_approvals, channel_meta)
-           VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15)
+               parent_conversation_id, parent_message_id, has_pending_approvals, channel_meta)
+           VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16)
            ${this.dialect.upsert(["id"])}
            data = excluded.data, title = excluded.title, message_count = excluded.message_count,
            updated_at = excluded.updated_at, tenant_id = excluded.tenant_id, owner_id = excluded.owner_id,
-           tool_result_archive = excluded.tool_result_archive, harness_messages = excluded.harness_messages,
+           -- tool_result_archive is append-only from the caller's side; if the
+           -- in-memory conversation was loaded via the light get() variant it
+           -- won't have _toolResultArchive attached, so we must preserve the
+           -- existing column instead of clobbering it with NULL.
+           tool_result_archive = COALESCE(excluded.tool_result_archive, conversations.tool_result_archive),
+           harness_messages = excluded.harness_messages,
            continuation_messages = excluded.continuation_messages,
            parent_conversation_id = excluded.parent_conversation_id,
+           parent_message_id = excluded.parent_message_id,
            has_pending_approvals = excluded.has_pending_approvals,
            channel_meta = excluded.channel_meta`,
           this.dialect,
@@ -334,6 +532,7 @@ export abstract class SqlStorageEngine implements StorageEngine {
           harnessJson,
           continuationJson,
           parentConvId,
+          parentMsgId,
           hasPendingApprovals,
           channelMetaJson,
         ],
@@ -374,7 +573,7 @@ export abstract class SqlStorageEngine implements StorageEngine {
       // SQLite uses positional ? so we can't reuse $2, need separate params
       const params: unknown[] = [this.agentId, pattern, pattern];
       let sql = `SELECT id, title, updated_at, created_at, owner_id, tenant_id,
-                        message_count, parent_conversation_id,
+                        message_count, parent_conversation_id, parent_message_id,
                         has_pending_approvals, channel_meta
                  FROM conversations
                  WHERE agent_id = $1 AND (title LIKE $2 OR data LIKE $3)`;
@@ -406,6 +605,24 @@ export abstract class SqlStorageEngine implements StorageEngine {
       await this.conversations.update(conv);
       return conv;
     },
+
+    listThreads: async (
+      parentConversationId: string,
+    ): Promise<ConversationSummary[]> => {
+      const sql = `SELECT id, title, updated_at, created_at, owner_id, tenant_id,
+                          message_count, parent_conversation_id, parent_message_id,
+                          has_pending_approvals, channel_meta
+                   FROM conversations
+                   WHERE agent_id = $1
+                     AND parent_conversation_id = $2
+                     AND parent_message_id IS NOT NULL
+                   ORDER BY updated_at DESC`;
+      const rows = await this.executor.all(rewrite(sql, this.dialect), [
+        this.agentId,
+        parentConversationId,
+      ]);
+      return rows.map((r) => this.rowToSummary(r));
+    },
   };
 
   // -----------------------------------------------------------------------
@@ -497,21 +714,15 @@ export abstract class SqlStorageEngine implements StorageEngine {
       return rows.map((r) => this.rowToReminder(r));
     },
 
-    create: async (input: {
-      task: string;
-      scheduledAt: number;
-      timezone?: string;
-      conversationId: string;
-      ownerId?: string;
-      tenantId?: string | null;
-    }): Promise<Reminder> => {
+    create: async (input: ReminderCreateInput): Promise<Reminder> => {
       const id = randomUUID();
       const now = Date.now();
       const tid = normalizeTenant(input.tenantId);
+      const recurrenceJson = input.recurrence ? JSON.stringify(input.recurrence) : null;
       await this.executor.run(
         rewrite(
-          `INSERT INTO reminders (id, agent_id, tenant_id, owner_id, conversation_id, task, status, scheduled_at, timezone, created_at)
-           VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)`,
+          `INSERT INTO reminders (id, agent_id, tenant_id, owner_id, conversation_id, task, status, scheduled_at, timezone, created_at, recurrence, occurrence_count)
+           VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)`,
           this.dialect,
         ),
         [
@@ -525,6 +736,8 @@ export abstract class SqlStorageEngine implements StorageEngine {
           input.scheduledAt,
           input.timezone ?? null,
           new Date(now).toISOString(),
+          recurrenceJson,
+          0,
         ],
       );
       return {
@@ -537,9 +750,54 @@ export abstract class SqlStorageEngine implements StorageEngine {
         conversationId: input.conversationId,
         ownerId: input.ownerId,
         tenantId: input.tenantId,
+        recurrence: input.recurrence ?? null,
+        occurrenceCount: 0,
       };
     },
 
+    update: async (id: string, fields: { scheduledAt?: number; occurrenceCount?: number; status?: ReminderStatus }): Promise<Reminder> => {
+      const setClauses: string[] = [];
+      const params: unknown[] = [];
+      let idx = 1;
+      if (fields.scheduledAt !== undefined) {
+        setClauses.push(`scheduled_at = $${idx++}`);
+        params.push(fields.scheduledAt);
+      }
+      if (fields.occurrenceCount !== undefined) {
+        setClauses.push(`occurrence_count = $${idx++}`);
+        params.push(fields.occurrenceCount);
+      }
+      if (fields.status !== undefined) {
+        setClauses.push(`status = $${idx++}`);
+        params.push(fields.status);
+      }
+      if (setClauses.length === 0) {
+        // Nothing to update — just fetch
+        const row = await this.executor.get(
+          rewrite("SELECT * FROM reminders WHERE id = $1 AND agent_id = $2", this.dialect),
+          [id, this.agentId],
+        );
+        if (!row) throw new Error(`Reminder ${id} not found`);
+        return this.rowToReminder(row);
+      }
+      params.push(id, this.agentId);
+      const idIdx = idx++;
+      const agentIdx = idx++;
+      await this.executor.run(
+        rewrite(
+          `UPDATE reminders SET ${setClauses.join(", ")} WHERE id = $${idIdx} AND agent_id = $${agentIdx}`,
+          this.dialect,
+        ),
+        params,
+      );
+      const row = await this.executor.get(
+        rewrite("SELECT * FROM reminders WHERE id = $1 AND agent_id = $2", this.dialect),
+        [id, this.agentId],
+      );
+      if (!row) throw new Error(`Reminder ${id} not found`);
+      return this.rowToReminder(row);
+    },
+
     cancel: async (id: string): Promise<Reminder> => {
       await this.executor.run(
         rewrite(
@@ -910,6 +1168,7 @@ export abstract class SqlStorageEngine implements StorageEngine {
       messageCount: row.message_count as number,
       hasPendingApprovals: !!(row.has_pending_approvals),
       parentConversationId: (row.parent_conversation_id as string) || undefined,
+      parentMessageId: (row.parent_message_id as string) || undefined,
       channelMeta: rawChannelMeta
         ? (typeof rawChannelMeta === "string" ? JSON.parse(rawChannelMeta) : rawChannelMeta)
         : undefined,
@@ -918,6 +1177,16 @@ export abstract class SqlStorageEngine implements StorageEngine {
 
   private rowToReminder(row: QueryRow): Reminder {
     const tid = row.tenant_id as string;
+    let recurrence: Reminder["recurrence"] = null;
+    if (row.recurrence) {
+      try {
+        recurrence = typeof row.recurrence === "string"
+          ? JSON.parse(row.recurrence)
+          : row.recurrence;
+      } catch {
+        recurrence = null;
+      }
+    }
     return {
       id: row.id as string,
       task: row.task as string,
@@ -928,6 +1197,8 @@ export abstract class SqlStorageEngine implements StorageEngine {
       conversationId: row.conversation_id as string,
       ownerId: (row.owner_id as string) ?? undefined,
       tenantId: tid === DEFAULT_TENANT ? null : tid,
+      recurrence,
+      occurrenceCount: (row.occurrence_count as number) ?? 0,
     };
   }
 

package/src/storage/sqlite-engine.ts

@@ -94,6 +94,7 @@ export class SqliteEngine extends SqlStorageEngine {
   }
 
   async close(): Promise<void> {
+    this.flushEgressStats();
     this.db?.close();
   }
 }

package/src/storage/store-adapters.ts

@@ -6,13 +6,14 @@
 
 import type {
   Conversation,
+  ConversationCreateInit,
   ConversationStore,
   ConversationSummary,
   PendingSubagentResult,
 } from "../state.js";
 import type { MainMemory, MemoryStore } from "../memory.js";
 import type { TodoItem, TodoStore } from "../todo-tools.js";
-import type { Reminder, ReminderStore } from "../reminder-store.js";
+import type { Reminder, ReminderCreateInput, ReminderStatus, ReminderStore } from "../reminder-store.js";
 import type { StorageEngine } from "./engine.js";
 
 // ---------------------------------------------------------------------------
@@ -35,8 +36,16 @@ export function createConversationStoreFromEngine(
       engine.conversations.list(ownerId, tenantId),
     get: (conversationId: string) =>
       engine.conversations.get(conversationId),
-    create: (ownerId?: string, title?: string, tenantId?: string | null) =>
-      engine.conversations.create(ownerId, title, tenantId),
+    getWithArchive: (conversationId: string) =>
+      engine.conversations.getWithArchive(conversationId),
+    getStatusSnapshot: (conversationId: string) =>
+      engine.conversations.getStatusSnapshot(conversationId),
+    create: (
+      ownerId?: string,
+      title?: string,
+      tenantId?: string | null,
+      init?: ConversationCreateInit,
+    ) => engine.conversations.create(ownerId, title, tenantId, init),
     update: (conversation: Conversation) =>
       engine.conversations.update(conversation),
     rename: (conversationId: string, title: string) =>
@@ -47,6 +56,8 @@ export function createConversationStoreFromEngine(
       engine.conversations.appendSubagentResult(conversationId, result),
     clearCallbackLock: (conversationId: string) =>
       engine.conversations.clearCallbackLock(conversationId),
+    listThreads: (parentConversationId: string) =>
+      engine.conversations.listThreads(parentConversationId),
   };
 }
 
@@ -86,14 +97,9 @@ export function createReminderStoreFromEngine(
 ): ReminderStore {
   return {
     list: () => engine.reminders.list(),
-    create: (input: {
-      task: string;
-      scheduledAt: number;
-      timezone?: string;
-      conversationId: string;
-      ownerId?: string;
-      tenantId?: string | null;
-    }) => engine.reminders.create(input),
+    create: (input: ReminderCreateInput) => engine.reminders.create(input),
+    update: (id: string, fields: { scheduledAt?: number; occurrenceCount?: number; status?: ReminderStatus }) =>
+      engine.reminders.update(id, fields),
     cancel: (id: string) => engine.reminders.cancel(id),
     delete: (id: string) => engine.reminders.delete(id),
   };

package/src/telemetry.ts

@@ -1,4 +1,8 @@
 import type { AgentEvent } from "@poncho-ai/sdk";
+import { createLogger } from "@poncho-ai/sdk";
+
+const eventLog = createLogger("event");
+const telemetryLog = createLogger("telemetry");
 
 const MAX_FIELD_LENGTH = 200;
 const OMIT_FROM_LOG = new Set(["continuationMessages", "_harnessMessages", "messages", "compactedHistory"]);
@@ -70,12 +74,13 @@ export class TelemetryEmitter {
       await this.sendOtlp(event, otlp);
     }
     // Default behavior in local dev: print concise structured logs.
-    // Skip per-token stream logs to keep console output readable.
-    if (event.type === "model:chunk") {
+    // Skip per-token stream logs and browser screencast frames — both are
+    // high-volume and would drown the log.
+    if (event.type === "model:chunk" || event.type === "browser:frame") {
       return;
     }
     // Strip large binary payloads (e.g. base64 images) to keep logs readable.
-    process.stdout.write(`[event] ${event.type} ${sanitizeEventForLog(event)}\n`);
+    eventLog.debug(`${event.type} ${sanitizeEventForLog(event)}`);
   }
 
   private async sendOtlp(event: AgentEvent, otlp: OtlpConfig): Promise<void> {
@@ -108,10 +113,8 @@ export class TelemetryEmitter {
         }),
       });
     } catch (err) {
-      console.warn(
-        `[poncho][telemetry] OTLP log delivery failed: ${
-          err instanceof Error ? err.message : String(err)
-        }`,
+      telemetryLog.warn(
+        `OTLP log delivery failed: ${err instanceof Error ? err.message : String(err)}`,
       );
     }
   }

package/src/upload-store.ts

@@ -3,8 +3,11 @@ import { mkdir, readFile, writeFile, rm } from "node:fs/promises";
 import { createRequire } from "node:module";
 import { homedir } from "node:os";
 import { resolve } from "node:path";
+import { createLogger } from "@poncho-ai/sdk";
 import type { UploadsConfig } from "./config.js";
 
+const uploadLog = createLogger("upload");
+
 /**
  * Try to dynamically import a module, first from the harness's own
  * node_modules, then from the user's project directory. This handles
@@ -62,7 +65,7 @@ class CachedUploadStore implements UploadStore {
 
     // Fire off the real upload in the background — don't block the caller.
     this.inner.put(key, data, mediaType).catch((err) => {
-      console.error("[poncho] background upload failed:", err instanceof Error ? err.message : err);
+      uploadLog.error(`background upload failed: ${err instanceof Error ? err.message : err}`);
     });
 
     return ref;
@@ -343,7 +346,7 @@ export class S3UploadStore implements UploadStore {
 // ---------------------------------------------------------------------------
 
 const warn = (msg: string) => {
-  console.warn(`[poncho] ⚠ ${msg}`);
+  uploadLog.warn(msg);
 };
 
 export const createUploadStore = async (
@@ -363,7 +366,7 @@ export const createUploadStore = async (
     const store = new VercelBlobUploadStore(workingDir, config?.access ?? "public");
     try {
       await store.loadSdk();
-      console.log("[poncho] uploads: using vercel-blob store");
+      uploadLog.item("using vercel-blob store");
       return new CachedUploadStore(store);
     } catch {
       warn(
@@ -393,7 +396,7 @@ export const createUploadStore = async (
     );
     try {
       await store.ensureClient();
-      console.log(`[poncho] uploads: using s3 store (bucket: ${bucket})`);
+      uploadLog.item(`using s3 store (bucket: ${bucket})`);
       return new CachedUploadStore(store);
     } catch {
       warn(