@poncho-ai/harness 0.53.0 → 0.57.0

package/src/orchestrator/orchestrator.ts

@@ -1,4 +1,4 @@
-import { getTextContent, type AgentEvent, type Message } from "@poncho-ai/sdk";
+import { createLogger, getTextContent, type AgentEvent, type Message } from "@poncho-ai/sdk";
 import type { Conversation, ConversationStore, PendingSubagentResult } from "../state.js";
 import type { AgentHarness } from "../harness.js";
 import type { TelemetryEmitter } from "../telemetry.js";
@@ -27,6 +27,17 @@ import {
   CALLBACK_LOCK_STALE_MS,
   STALE_SUBAGENT_THRESHOLD_MS,
 } from "./subagents.js";
+import {
+  appendEntriesSafe,
+  assistantAmendmentEntry,
+  assistantMessageEntry,
+  callbackStartedEntry,
+  subagentResultEntry,
+  userMessageEntry,
+  verifyEntriesParity,
+} from "./entries-dual-write.js";
+
+const dualWriteLog = createLogger("orchestrator:entries");
 
 // ── Subagent result extraction ──
 
@@ -491,6 +502,11 @@ export class AgentOrchestrator {
     if (!checkpointedRun) {
       const conv = await this.conversationStore.get(conversationId);
       if (conv) {
+        // Track which dual-write branch the blob took: an in-place merge onto
+        // the previous assistant bubble (→ assistant_amendment) or a fresh
+        // bubble (→ assistant_message).
+        let amendmentText: string | undefined;
+        let pushedAssistant: Message | undefined;
         const hasAssistantContent =
           draft.assistantResponse.length > 0 || draft.toolTimeline.length > 0 || draft.sections.length > 0;
         if (hasAssistantContent) {
@@ -519,15 +535,14 @@ export class AgentOrchestrator {
                 } as Message["metadata"],
               },
             ];
+            amendmentText = draft.assistantResponse;
           } else {
-            conv.messages = [
-              ...prevMessages,
-              {
-                role: "assistant" as const,
-                content: draft.assistantResponse,
-                metadata: buildAssistantMetadata(draft),
-              },
-            ];
+            pushedAssistant = {
+              role: "assistant" as const,
+              content: draft.assistantResponse,
+              metadata: buildAssistantMetadata(draft),
+            };
+            conv.messages = [...prevMessages, pushedAssistant];
           }
         }
         applyTurnMetadata(conv, {
@@ -537,6 +552,62 @@ export class AgentOrchestrator {
           harnessMessages: execution?.runHarnessMessages,
         }, { shouldRebuildCanonical: true });
         await this.conversationStore.update(conv);
+
+        // DUAL-WRITE (mirrors the resume merge/push above). In-place merge →
+        // assistant_amendment targeting the latest assistant_message entry
+        // (BEST-EFFORT: the blob carries no entry id, so we resolve the target
+        // by reading the log's last assistant_message). Fresh bubble →
+        // assistant_message. Then parity-check. Fire-and-forget.
+        if (amendmentText !== undefined || pushedAssistant) {
+          const finalConv = conv;
+          const amendText = amendmentText;
+          const pushed = pushedAssistant;
+          void (async () => {
+            try {
+              if (pushed) {
+                await appendEntriesSafe(
+                  this.conversationStore,
+                  finalConv,
+                  [assistantMessageEntry(pushed, `resume-${conversationId}`, latestRunId)],
+                  dualWriteLog,
+                );
+              } else if (amendText !== undefined) {
+                const existing = await this.conversationStore.readEntries(
+                  conversationId,
+                  { types: ["assistant_message"] },
+                );
+                const target = existing[existing.length - 1];
+                if (target) {
+                  await appendEntriesSafe(
+                    this.conversationStore,
+                    finalConv,
+                    [assistantAmendmentEntry(target.id, amendText)],
+                    dualWriteLog,
+                  );
+                } else {
+                  dualWriteLog.warn(
+                    `[entries-dual-write] resume amendment for ${conversationId}: no assistant_message entry to target; skipped`,
+                  );
+                }
+              }
+              await verifyEntriesParity(
+                this.conversationStore,
+                conversationId,
+                {
+                  harnessMessages: finalConv._harnessMessages,
+                  displayMessages: finalConv.messages,
+                },
+                dualWriteLog,
+              );
+            } catch (err) {
+              dualWriteLog.error(
+                `[entries-dual-write] resume finalize append failed for ${conversationId}: ${
+                  err instanceof Error ? err.message : String(err)
+                }`,
+              );
+            }
+          })();
+        }
       }
     } else {
       const conv = await this.conversationStore.get(conversationId);
@@ -1158,6 +1229,9 @@ export class AgentOrchestrator {
     const callbackCount = (conversation.subagentCallbackCount ?? 0) + 1;
     conversation.subagentCallbackCount = callbackCount;
 
+    // Collect the injected callback messages so the dual-write can append them
+    // as hidden user_message entries (mirroring the blob pushes below).
+    const injectedCallbackMessages: Message[] = [];
     for (const pr of pendingResults) {
       // An empty response is recoverable, not a dead end: the subagent's work
       // lives in its transcript even when it produced no closing summary (e.g.
@@ -1172,11 +1246,13 @@ export class AgentOrchestrator {
         : pr.error
           ? `Error: ${pr.error.message}`
           : "(no result)";
-      conversation.messages.push({
+      const injected: Message = {
         role: "user",
         content: `[Subagent Result] Subagent "${pr.task}" (${pr.subagentId}) ${pr.status}:\n\n${resultBody}`,
         metadata: { _subagentCallback: true, subagentId: pr.subagentId, task: pr.task, timestamp: pr.timestamp } as Message["metadata"],
-      });
+      };
+      injectedCallbackMessages.push(injected);
+      conversation.messages.push(injected);
     }
     const processedIds = new Set(pendingResults.map(pr => pr.subagentId));
     const freshForPending = await this.conversationStore.get(conversationId);
@@ -1187,6 +1263,48 @@ export class AgentOrchestrator {
     conversation.updatedAt = Date.now();
     await this.conversationStore.update(conversation);
 
+    // DUAL-WRITE (mirrors the consume-pending + message-push blob writes
+    // above): append a callback_started entry listing the consumed
+    // subagent_result seqs (resolved by matching subagentId against the entry
+    // log — BEST-EFFORT, since the blob's pending array carries no seq), plus
+    // a hidden user_message entry per injected callback message.
+    if (pendingResults.length > 0) {
+      const turnId = `callback-${callbackCount}-${conversation.conversationId}`;
+      void (async () => {
+        try {
+          const resultEntries = await this.conversationStore.readEntries(
+            conversation.conversationId,
+            { types: ["subagent_result"] },
+          );
+          const consumedIds = new Set(pendingResults.map((pr) => pr.subagentId));
+          const consumedSeqs = resultEntries
+            .filter(
+              (e) =>
+                e.type === "subagent_result" &&
+                consumedIds.has(e.result.subagentId),
+            )
+            .map((e) => e.seq);
+          await appendEntriesSafe(
+            this.conversationStore,
+            conversation,
+            [
+              callbackStartedEntry(consumedSeqs),
+              ...injectedCallbackMessages.map((m) =>
+                userMessageEntry(m, turnId, { hidden: true }),
+              ),
+            ],
+            dualWriteLog,
+          );
+        } catch (err) {
+          dualWriteLog.error(
+            `[entries-dual-write] callback_started append failed for ${conversation.conversationId}: ${
+              err instanceof Error ? err.message : String(err)
+            }`,
+          );
+        }
+      })();
+    }
+
     if (callbackCount > MAX_SUBAGENT_CALLBACK_COUNT) {
       console.warn(`[poncho][subagent-callback] Circuit breaker: ${callbackCount} callbacks for ${conversationId}, skipping re-run`);
       conversation.runningCallbackSince = undefined;
@@ -1256,12 +1374,14 @@ export class AgentOrchestrator {
       if (callbackNeedsContinuation || execution.draft.assistantResponse.length > 0 || execution.draft.toolTimeline.length > 0) {
         const freshConv = await this.conversationStore.get(conversationId);
         if (freshConv) {
+          let callbackAssistantMsg: Message | undefined;
           if (!callbackNeedsContinuation) {
-            freshConv.messages.push({
+            callbackAssistantMsg = {
               role: "assistant",
               content: execution.draft.assistantResponse,
               metadata: buildAssistantMetadata(execution.draft),
-            });
+            };
+            freshConv.messages.push(callbackAssistantMsg);
           }
           applyTurnMetadata(freshConv, {
             latestRunId: execution.latestRunId,
@@ -1275,6 +1395,30 @@ export class AgentOrchestrator {
           freshConv.runningCallbackSince = undefined;
           await this.conversationStore.update(freshConv);
 
+          // DUAL-WRITE (mirrors the assistant push above): the callback re-run's
+          // final assistant bubble. Only when not continuing (a continuation has
+          // no final bubble yet). Then run the parity check on the rebuilt
+          // transcript. Fire-and-forget; never blocks.
+          if (callbackAssistantMsg) {
+            const finalMsg = callbackAssistantMsg;
+            void appendEntriesSafe(
+              this.conversationStore,
+              freshConv,
+              [assistantMessageEntry(finalMsg, `callback-${conversationId}`, execution.latestRunId)],
+              dualWriteLog,
+            ).then(() =>
+              verifyEntriesParity(
+                this.conversationStore,
+                conversationId,
+                {
+                  harnessMessages: freshConv._harnessMessages,
+                  displayMessages: freshConv.messages,
+                },
+                dualWriteLog,
+              ),
+            );
+          }
+
           // Proactive messaging notification
           if (freshConv.channelMeta && execution.draft.assistantResponse.length > 0) {
             this.hooks?.onMessagingNotify?.(conversationId, execution.draft.assistantResponse);
@@ -1732,6 +1876,28 @@ export class AgentOrchestrator {
     parentConversationId: string,
     result: PendingSubagentResult,
   ): Promise<boolean> {
+    // DUAL-WRITE (mirrors the appendSubagentResult blob write below): append a
+    // subagent_result entry. Fire-and-forget; needs the parent's owner/tenant,
+    // fetched cheaply. Never blocks or fails the reliable append.
+    void (async () => {
+      try {
+        const parent = await this.conversationStore.get(parentConversationId);
+        if (!parent) return;
+        await appendEntriesSafe(
+          this.conversationStore,
+          parent,
+          [subagentResultEntry(result)],
+          dualWriteLog,
+        );
+      } catch (err) {
+        dualWriteLog.error(
+          `[entries-dual-write] subagent_result append failed for ${parentConversationId}: ${
+            err instanceof Error ? err.message : String(err)
+          }`,
+        );
+      }
+    })();
+
     try {
       await this.conversationStore.appendSubagentResult(parentConversationId, result);
       return true;

package/src/orchestrator/run-conversation-turn.ts

@@ -36,6 +36,15 @@ import {
   executeConversationTurn,
   flushTurnDraft,
 } from "./turn.js";
+import {
+  appendEntriesSafe,
+  assistantMessageEntry,
+  compactionEntry,
+  harnessMessageEntries,
+  newHarnessMessagesThisTurn,
+  userMessageEntry,
+  verifyEntriesParity,
+} from "./entries-dual-write.js";
 
 const log = createLogger("orchestrator");
 
@@ -185,6 +194,14 @@ export const runConversationTurn = async (
     await opts.conversationStore.update(conversation);
   };
 
+  // Snapshot the harness-message array as it stood BEFORE this turn so the
+  // finalize path can diff out the messages this turn appended (dual-write).
+  const preTurnHarnessMessages = conversation._harnessMessages
+    ? [...conversation._harnessMessages]
+    : undefined;
+  // The stable per-turn id used to group dual-write entries.
+  const turnId = assistantId;
+
   // Persist the user turn immediately so a crash mid-run still records what
   // the user said. Fire-and-forget — don't block the run.
   conversation.messages = [...historyMessages, userMessage];
@@ -197,6 +214,15 @@ export const runConversationTurn = async (
     );
   });
 
+  // DUAL-WRITE (additive, mirrors the user-turn blob write above): append a
+  // user_message entry. Fire-and-forget — never blocks or breaks the turn.
+  void appendEntriesSafe(
+    opts.conversationStore,
+    conversation,
+    [userMessageEntry(userMessage, turnId)],
+    log,
+  );
+
   try {
     const execution = await executeConversationTurn({
       harness: opts.harness,
@@ -247,6 +273,48 @@ export const runConversationTurn = async (
               ...existingHistory,
               ...preRunMessages.slice(0, removedCount),
             ];
+
+            // DUAL-WRITE (mirrors the compactedHistory blob write above): the
+            // compacted array is [summaryMessage, ...keptMessages]. BEST-EFFORT
+            // firstKeptSeq: the entry-log seqs of the kept harness messages
+            // aren't known here, so we derive a sentinel from the kept-count by
+            // reading the current max harness_message seq and pointing at the
+            // tail. We read the existing entries to compute it.
+            const summaryMessage = event.compactedMessages[0];
+            const keptCount = Math.max(0, event.compactedMessages.length - 1);
+            if (summaryMessage) {
+              void (async () => {
+                try {
+                  const existing = await opts.conversationStore.readEntries(
+                    opts.conversationId,
+                    { types: ["harness_message"] },
+                  );
+                  // firstKeptSeq = seq of the (keptCount)-th-from-last existing
+                  // harness message, so rebuild keeps exactly that many.
+                  const harnessSeqs = existing.map((e) => e.seq);
+                  const firstKeptSeq =
+                    harnessSeqs.length >= keptCount && keptCount > 0
+                      ? harnessSeqs[harnessSeqs.length - keptCount]!
+                      : (harnessSeqs[harnessSeqs.length - 1] ?? 0) + 1;
+                  await appendEntriesSafe(
+                    opts.conversationStore,
+                    conversation,
+                    [
+                      compactionEntry(summaryMessage, firstKeptSeq, {
+                        tokensBefore: conversation.contextTokens,
+                      }),
+                    ],
+                    log,
+                  );
+                } catch (err) {
+                  log.error(
+                    `[entries-dual-write] compaction append failed: ${
+                      err instanceof Error ? err.message : String(err)
+                    }`,
+                  );
+                }
+              })();
+            }
           }
         }
         if (event.type === "step:completed") {
@@ -387,6 +455,46 @@ export const runConversationTurn = async (
         { shouldRebuildCanonical },
       );
       await opts.conversationStore.update(conversation);
+
+      // DUAL-WRITE at finalize (mirrors applyTurnMetadata's _harnessMessages
+      // write + the final assistant bubble in conversation.messages):
+      //   1. harness_message entries for the messages this turn appended,
+      //   2. the final assistant_message entry.
+      // Best-effort + fire-and-forget; never blocks the return.
+      const finalAssistant =
+        conversation.messages[conversation.messages.length - 1];
+      const { messages: newHarness, approximate } = newHarnessMessagesThisTurn(
+        preTurnHarnessMessages,
+        conversation._harnessMessages,
+      );
+      if (approximate) {
+        log.warn(
+          `[entries-dual-write] ${opts.conversationId} harness-message diff approximate ` +
+            `(blob array shrank this turn — likely compaction); appended full context`,
+        );
+      }
+      const finalizeEntries = [
+        ...harnessMessageEntries(newHarness, turnId),
+        ...(finalAssistant && finalAssistant.role === "assistant"
+          ? [assistantMessageEntry(finalAssistant, turnId, latestRunId)]
+          : []),
+      ];
+      void appendEntriesSafe(
+        opts.conversationStore,
+        conversation,
+        finalizeEntries,
+        log,
+      ).then(() =>
+        verifyEntriesParity(
+          opts.conversationStore,
+          opts.conversationId,
+          {
+            harnessMessages: conversation._harnessMessages,
+            displayMessages: conversation.messages,
+          },
+          log,
+        ),
+      );
     }
 
     return {

package/src/state.ts

@@ -1,4 +1,5 @@
 import type { Message } from "@poncho-ai/sdk";
+import type { ConversationEntry, NewConversationEntry } from "./storage/entries.js";
 
 export interface ConversationState {
   runId: string;
@@ -142,6 +143,23 @@ export interface ConversationStore {
   clearCallbackLock(conversationId: string): Promise<Conversation | undefined>;
   /** List thread conversations anchored under `parentConversationId`. */
   listThreads(parentConversationId: string): Promise<ConversationSummary[]>;
+  /**
+   * Append entries to a conversation's append-only log (Phase 3 substrate).
+   * Assigns a per-conversation monotonic `seq` and a `createdAt` to each
+   * entry, persists them in order, and returns the stored entries with those
+   * fields filled in. Additive — no existing read path consumes these yet.
+   */
+  appendEntries(
+    conversationId: string,
+    agentId: string,
+    tenantId: string | null,
+    entries: NewConversationEntry[],
+  ): Promise<ConversationEntry[]>;
+  /** Read a conversation's entries ordered by `seq` ascending. */
+  readEntries(
+    conversationId: string,
+    opts?: { types?: string[]; afterSeq?: number; limit?: number },
+  ): Promise<ConversationEntry[]>;
 }
 
 export type StateProviderName =
@@ -201,6 +219,7 @@ export class InMemoryStateStore implements StateStore {
 
 export class InMemoryConversationStore implements ConversationStore {
   private readonly conversations = new Map<string, Conversation>();
+  private readonly entries = new Map<string, ConversationEntry[]>();
   private readonly ttlMs?: number;
 
   constructor(ttlSeconds?: number) {
@@ -372,6 +391,43 @@ export class InMemoryConversationStore implements ConversationStore {
         channelMeta: c.channelMeta,
       }));
   }
+
+  async appendEntries(
+    conversationId: string,
+    _agentId: string,
+    _tenantId: string | null,
+    entries: NewConversationEntry[],
+  ): Promise<ConversationEntry[]> {
+    const list = this.entries.get(conversationId) ?? [];
+    // seq is per-conversation: max existing seq + 1, then consecutive.
+    let nextSeq = list.reduce((max, e) => (e.seq > max ? e.seq : max), 0) + 1;
+    const now = Date.now();
+    const stored: ConversationEntry[] = entries.map(
+      (e) => ({ ...e, seq: nextSeq++, createdAt: now }) as ConversationEntry,
+    );
+    this.entries.set(conversationId, [...list, ...stored]);
+    return stored;
+  }
+
+  async readEntries(
+    conversationId: string,
+    opts?: { types?: string[]; afterSeq?: number; limit?: number },
+  ): Promise<ConversationEntry[]> {
+    let list = (this.entries.get(conversationId) ?? [])
+      .slice()
+      .sort((a, b) => a.seq - b.seq);
+    if (opts?.types && opts.types.length > 0) {
+      const allowed = new Set(opts.types);
+      list = list.filter((e) => allowed.has(e.type));
+    }
+    if (typeof opts?.afterSeq === "number") {
+      list = list.filter((e) => e.seq > opts.afterSeq!);
+    }
+    if (typeof opts?.limit === "number") {
+      list = list.slice(0, opts.limit);
+    }
+    return list;
+  }
 }
 
 export type ConversationSummary = {

package/src/storage/engine.ts

@@ -5,6 +5,7 @@ import type {
   ConversationSummary,
   PendingSubagentResult,
 } from "../state.js";
+import type { ConversationEntry, NewConversationEntry } from "./entries.js";
 import type { MainMemory } from "../memory.js";
 import type { TodoItem } from "../todo-tools.js";
 import type { Reminder, ReminderCreateInput, ReminderStatus } from "../reminder-store.js";
@@ -77,6 +78,23 @@ export interface StorageEngine {
     clearCallbackLock(conversationId: string): Promise<Conversation | undefined>;
     /** List thread conversations anchored under `parentConversationId`. */
     listThreads(parentConversationId: string): Promise<ConversationSummary[]>;
+    /**
+     * Append entries to a conversation's append-only log (Phase 3 substrate).
+     * Assigns a per-conversation monotonic `seq` and `createdAt` to each entry,
+     * persists them in order, and returns the stored entries. Additive — no
+     * read path consumes these yet.
+     */
+    appendEntries(
+      conversationId: string,
+      agentId: string,
+      tenantId: string | null,
+      entries: NewConversationEntry[],
+    ): Promise<ConversationEntry[]>;
+    /** Read a conversation's entries ordered by `seq` ascending. */
+    readEntries(
+      conversationId: string,
+      opts?: { types?: string[]; afterSeq?: number; limit?: number },
+    ): Promise<ConversationEntry[]>;
   };
 
   // --- Memory (replaces MemoryStore) ---