@poncho-ai/harness 0.55.0 → 0.57.0

package/dist/index.js

@@ -2789,6 +2789,8 @@ var InMemoryEngine = class {
   agentId;
   // Conversation data
   convs = /* @__PURE__ */ new Map();
+  // Append-only conversation entries (Phase 3 substrate)
+  entries = /* @__PURE__ */ new Map();
   // Memory data
   mem = /* @__PURE__ */ new Map();
   // Todos data
@@ -2918,6 +2920,30 @@ var InMemoryEngine = class {
       }
       results.sort((a, b) => b.updatedAt - a.updatedAt);
       return results;
+    },
+    appendEntries: async (conversationId, _agentId, _tenantId, entries) => {
+      const list = this.entries.get(conversationId) ?? [];
+      let nextSeq = list.reduce((max, e) => e.seq > max ? e.seq : max, 0) + 1;
+      const now2 = Date.now();
+      const stored = entries.map(
+        (e) => ({ ...e, seq: nextSeq++, createdAt: now2 })
+      );
+      this.entries.set(conversationId, [...list, ...stored]);
+      return stored;
+    },
+    readEntries: async (conversationId, opts) => {
+      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;
     }
   };
   // -----------------------------------------------------------------------
@@ -3457,6 +3483,36 @@ var migrations = [
         `ALTER TABLE reminders ALTER COLUMN scheduled_at TYPE BIGINT USING scheduled_at::bigint`
       ];
     }
+  },
+  {
+    version: 8,
+    name: "conversation_entries",
+    // Append-only conversation log (Phase 3 substrate). Additive: no
+    // existing table or behavior changes. `seq` is a per-conversation
+    // monotonic order assigned by the application (NOT an autoincrement
+    // serial), so the same seq space restarts at 1 for every conversation.
+    // The UNIQUE (conversation_id, seq) constraint backstops the
+    // app-assigned ordering against concurrent writers.
+    up: (d) => {
+      const jsonType = d === "sqlite" ? "TEXT" : "JSONB";
+      const tsDefault = d === "sqlite" ? "datetime('now')" : "NOW()";
+      const autoTs = `DEFAULT (${tsDefault})`;
+      return [
+        `CREATE TABLE IF NOT EXISTS conversation_entries (
+          seq INTEGER NOT NULL,
+          id TEXT NOT NULL UNIQUE,
+          agent_id TEXT NOT NULL,
+          tenant_id TEXT NOT NULL DEFAULT '__default__',
+          conversation_id TEXT NOT NULL,
+          type TEXT NOT NULL,
+          payload ${jsonType} NOT NULL,
+          created_at TIMESTAMP ${autoTs},
+          UNIQUE (conversation_id, seq)
+        )`,
+        `CREATE INDEX IF NOT EXISTS idx_conversation_entries_seq
+          ON conversation_entries (conversation_id, seq)`
+      ];
+    }
   }
 ];
 
@@ -3880,6 +3936,87 @@ var SqlStorageEngine = class {
         parentConversationId
       ]);
       return rows.map((r) => this.rowToSummary(r));
+    },
+    appendEntries: async (conversationId, agentId, tenantId, entries) => {
+      if (entries.length === 0) return [];
+      const tid = normalizeTenant2(tenantId);
+      const maxAttempts = 3;
+      let lastErr;
+      for (let attempt = 0; attempt < maxAttempts; attempt++) {
+        const stored = [];
+        try {
+          await this.executor.transaction(async () => {
+            stored.length = 0;
+            const row = await this.executor.get(
+              rewrite(
+                "SELECT MAX(seq) AS max_seq FROM conversation_entries WHERE conversation_id = $1",
+                this.dialect
+              ),
+              [conversationId]
+            );
+            let nextSeq = Number(row?.max_seq ?? 0) + 1;
+            const now2 = Date.now();
+            for (const entry of entries) {
+              const seq = nextSeq++;
+              const createdAt = now2;
+              const payload = JSON.stringify(entry);
+              await this.executor.run(
+                rewrite(
+                  `INSERT INTO conversation_entries
+                     (seq, id, agent_id, tenant_id, conversation_id, type, payload, created_at)
+                   VALUES ($1, $2, $3, $4, $5, $6, $7, $8)`,
+                  this.dialect
+                ),
+                [
+                  seq,
+                  entry.id,
+                  agentId,
+                  tid,
+                  conversationId,
+                  entry.type,
+                  payload,
+                  new Date(createdAt).toISOString()
+                ]
+              );
+              stored.push({ ...entry, seq, createdAt });
+            }
+          });
+          return stored;
+        } catch (err) {
+          lastErr = err;
+        }
+      }
+      throw lastErr;
+    },
+    readEntries: async (conversationId, opts) => {
+      const params = [conversationId];
+      let sql = "SELECT seq, id, payload, created_at FROM conversation_entries WHERE conversation_id = $1";
+      if (opts?.types && opts.types.length > 0) {
+        const placeholders = opts.types.map(
+          (_t, i) => `$${params.length + 1 + i}`
+        );
+        sql += ` AND type IN (${placeholders.join(", ")})`;
+        params.push(...opts.types);
+      }
+      if (typeof opts?.afterSeq === "number") {
+        sql += ` AND seq > $${params.length + 1}`;
+        params.push(opts.afterSeq);
+      }
+      sql += " ORDER BY seq ASC";
+      if (typeof opts?.limit === "number") {
+        sql += ` LIMIT $${params.length + 1}`;
+        params.push(opts.limit);
+      }
+      const rows = await this.executor.all(rewrite(sql, this.dialect), params);
+      return rows.map((r) => {
+        const parsed = typeof r.payload === "string" ? JSON.parse(r.payload) : r.payload;
+        return {
+          ...parsed,
+          id: r.id,
+          seq: Number(r.seq),
+          createdAt: new Date(r.created_at).getTime()
+        };
+      });
     }
   };
   // -----------------------------------------------------------------------
@@ -4712,7 +4849,9 @@ function createConversationStoreFromEngine(engine) {
     delete: (conversationId) => engine.conversations.delete(conversationId),
     appendSubagentResult: (conversationId, result) => engine.conversations.appendSubagentResult(conversationId, result),
     clearCallbackLock: (conversationId) => engine.conversations.clearCallbackLock(conversationId),
-    listThreads: (parentConversationId) => engine.conversations.listThreads(parentConversationId)
+    listThreads: (parentConversationId) => engine.conversations.listThreads(parentConversationId),
+    appendEntries: (conversationId, agentId, tenantId, entries) => engine.conversations.appendEntries(conversationId, agentId, tenantId, entries),
+    readEntries: (conversationId, opts) => engine.conversations.readEntries(conversationId, opts)
   };
 }
 function createMemoryStoreFromEngine(engine, tenantId) {
@@ -11973,6 +12112,7 @@ var InMemoryStateStore = class {
 };
 var InMemoryConversationStore = class {
   conversations = /* @__PURE__ */ new Map();
+  entries = /* @__PURE__ */ new Map();
   ttlMs;
   constructor(ttlSeconds) {
     this.ttlMs = typeof ttlSeconds === "number" ? ttlSeconds * 1e3 : void 0;
@@ -12102,6 +12242,30 @@ var InMemoryConversationStore = class {
       channelMeta: c.channelMeta
     }));
   }
+  async appendEntries(conversationId, _agentId, _tenantId, entries) {
+    const list = this.entries.get(conversationId) ?? [];
+    let nextSeq = list.reduce((max, e) => e.seq > max ? e.seq : max, 0) + 1;
+    const now2 = Date.now();
+    const stored = entries.map(
+      (e) => ({ ...e, seq: nextSeq++, createdAt: now2 })
+    );
+    this.entries.set(conversationId, [...list, ...stored]);
+    return stored;
+  }
+  async readEntries(conversationId, opts) {
+    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;
+  }
 };
 var createStateStore = (config, _options) => {
   const ttl = config?.ttl;
@@ -12112,6 +12276,66 @@ var createConversationStore = (config, _options) => {
   return new InMemoryConversationStore(ttl);
 };
 
+// src/storage/entries.ts
+function buildLlmContext(entries) {
+  let latestCompaction;
+  for (const e of entries) {
+    if (e.type === "compaction" && (!latestCompaction || e.seq > latestCompaction.seq)) {
+      latestCompaction = e;
+    }
+  }
+  const harnessMsgs = entries.filter(
+    (e) => e.type === "harness_message"
+  );
+  if (latestCompaction) {
+    const kept = harnessMsgs.filter((e) => e.seq >= latestCompaction.firstKeptSeq).map((e) => e.message);
+    return [latestCompaction.summaryMessage, ...kept];
+  }
+  return harnessMsgs.map((e) => e.message);
+}
+function buildDisplaySnapshot(entries, tailN) {
+  const amendmentsByTarget = /* @__PURE__ */ new Map();
+  for (const e of entries) {
+    if (e.type === "assistant_amendment") {
+      const list = amendmentsByTarget.get(e.targetEntryId) ?? [];
+      list.push(e);
+      amendmentsByTarget.set(e.targetEntryId, list);
+    }
+  }
+  const built = [];
+  for (const e of entries) {
+    if (e.type === "user_message") {
+      if (e.hidden) continue;
+      built.push({ seq: e.seq, message: e.message });
+    } else if (e.type === "assistant_message") {
+      let content = typeof e.message.content === "string" ? e.message.content : "";
+      const amendments = amendmentsByTarget.get(e.id);
+      if (amendments) {
+        for (const a of amendments.sort((x, y) => x.seq - y.seq)) {
+          if (a.appendText) content += a.appendText;
+        }
+      }
+      built.push({ seq: e.seq, message: { ...e.message, content } });
+    }
+  }
+  const total = built.length;
+  const tail = tailN >= total ? built : built.slice(total - tailN);
+  return {
+    messages: tail.map((b) => b.message),
+    totalMessages: total,
+    headSeq: tail.length > 0 ? tail[0].seq : null
+  };
+}
+function getPendingSubagentResults(entries) {
+  const consumed = /* @__PURE__ */ new Set();
+  for (const e of entries) {
+    if (e.type === "callback_started") {
+      for (const s of e.consumedSeqs) consumed.add(s);
+    }
+  }
+  return entries.filter((e) => e.type === "subagent_result").filter((e) => !consumed.has(e.seq)).map((e) => e.result);
+}
+
 // src/tenant-token.ts
 import { jwtVerify } from "jose";
 async function verifyTenantToken(signingKey, token) {
@@ -12444,9 +12668,143 @@ var CALLBACK_LOCK_STALE_MS = 5 * 60 * 1e3;
 var STALE_SUBAGENT_THRESHOLD_MS = 5 * 60 * 1e3;
 
 // src/orchestrator/orchestrator.ts
+import { createLogger as createLogger7, getTextContent as getTextContent4 } from "@poncho-ai/sdk";
+
+// src/orchestrator/entries-dual-write.ts
+import { randomUUID as randomUUID6 } from "crypto";
 import { getTextContent as getTextContent3 } from "@poncho-ai/sdk";
+var entriesParityEnabled = () => process.env.PONCHO_VERIFY_ENTRIES === "1";
+var appendEntriesSafe = async (store, conversation, entries, log2) => {
+  if (entries.length === 0) return [];
+  try {
+    const withIds = entries.map(
+      (e) => ({ id: randomUUID6(), ...e })
+    );
+    return await store.appendEntries(
+      conversation.conversationId,
+      conversation.ownerId,
+      conversation.tenantId ?? null,
+      withIds
+    );
+  } catch (err) {
+    log2.error(
+      `[entries-dual-write] append failed for ${conversation.conversationId}: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return [];
+  }
+};
+var userMessageEntry = (message, turnId, opts) => ({
+  type: "user_message",
+  message,
+  turnId,
+  ...opts?.hidden ? { hidden: true } : {}
+});
+var assistantMessageEntry = (message, turnId, runId) => ({
+  type: "assistant_message",
+  message,
+  turnId,
+  runId
+});
+var harnessMessageEntries = (messages, turnId) => messages.map((message) => ({ type: "harness_message", message, turnId }));
+var compactionEntry = (summaryMessage, firstKeptSeq, opts) => ({
+  type: "compaction",
+  summaryMessage,
+  firstKeptSeq,
+  ...opts?.tokensBefore !== void 0 ? { tokensBefore: opts.tokensBefore } : {},
+  ...opts?.tokensAfter !== void 0 ? { tokensAfter: opts.tokensAfter } : {}
+});
+var subagentResultEntry = (result) => ({ type: "subagent_result", result });
+var callbackStartedEntry = (consumedSeqs) => ({
+  type: "callback_started",
+  consumedSeqs
+});
+var assistantAmendmentEntry = (targetEntryId, appendText) => ({
+  type: "assistant_amendment",
+  targetEntryId,
+  ...appendText ? { appendText } : {}
+});
+var newHarnessMessagesThisTurn = (prev, next) => {
+  const prevArr = prev ?? [];
+  const nextArr = next ?? [];
+  if (nextArr.length === 0) return { messages: [], approximate: false };
+  if (prevArr.length === 0) return { messages: nextArr, approximate: false };
+  if (nextArr.length >= prevArr.length) {
+    return { messages: nextArr.slice(prevArr.length), approximate: false };
+  }
+  return { messages: nextArr, approximate: true };
+};
+var projectText = (m) => {
+  const role = m.role;
+  const text = getTextContent3(m).replace(/\s+/g, " ").trim();
+  return `${role}:${text}`;
+};
+var projectAll = (msgs) => msgs.map(projectText);
+var countMismatch = (label, a, b) => a === b ? null : `${label} length ${a} (entries) vs ${b} (blob)`;
+var verifyEntriesParity = async (store, conversationId, blob, log2) => {
+  if (!entriesParityEnabled()) return;
+  try {
+    const entries = await store.readEntries(conversationId);
+    const mismatches = [];
+    if (blob.harnessMessages) {
+      const llm = buildLlmContext(entries);
+      const lenMismatch = countMismatch(
+        "llmContext",
+        llm.length,
+        blob.harnessMessages.length
+      );
+      if (lenMismatch) mismatches.push(lenMismatch);
+      const entriesProj = projectAll(llm);
+      const blobProj = projectAll(blob.harnessMessages);
+      const tail = Math.min(entriesProj.length, blobProj.length, 5);
+      for (let i = 1; i <= tail; i++) {
+        const ep = entriesProj[entriesProj.length - i];
+        const bp = blobProj[blobProj.length - i];
+        if (ep !== bp) {
+          mismatches.push(
+            `llmContext tail[-${i}] differs: entries=${JSON.stringify(ep).slice(0, 120)} blob=${JSON.stringify(bp).slice(0, 120)}`
+          );
+        }
+      }
+    }
+    if (blob.displayMessages) {
+      const snap = buildDisplaySnapshot(entries, Number.MAX_SAFE_INTEGER);
+      const lenMismatch = countMismatch(
+        "display",
+        snap.totalMessages,
+        blob.displayMessages.length
+      );
+      if (lenMismatch) mismatches.push(lenMismatch);
+      const entriesProj = projectAll(snap.messages);
+      const blobProj = projectAll(blob.displayMessages);
+      const tail = Math.min(entriesProj.length, blobProj.length, 5);
+      for (let i = 1; i <= tail; i++) {
+        const ep = entriesProj[entriesProj.length - i];
+        const bp = blobProj[blobProj.length - i];
+        if (ep !== bp) {
+          mismatches.push(
+            `display tail[-${i}] differs: entries=${JSON.stringify(ep).slice(0, 120)} blob=${JSON.stringify(bp).slice(0, 120)}`
+          );
+        }
+      }
+    }
+    if (mismatches.length > 0) {
+      log2.warn(
+        `[entries-parity] ${conversationId} MISMATCH (${mismatches.length}): ${mismatches.join(" | ")}`
+      );
+    } else {
+      log2.info(`[entries-parity] ${conversationId} OK`);
+    }
+  } catch (err) {
+    log2.error(
+      `[entries-parity] ${conversationId} checker threw (ignored): ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+};
+
+// src/orchestrator/orchestrator.ts
+var dualWriteLog = createLogger7("orchestrator:entries");
 var assistantMessageText = (message) => {
-  const raw = getTextContent3(message).trim();
+  const raw = getTextContent4(message).trim();
   if (raw.startsWith("{") && raw.includes('"tool_calls"')) {
     try {
       const parsed = JSON.parse(raw);
@@ -12755,6 +13113,8 @@ var AgentOrchestrator = class {
     if (!checkpointedRun) {
       const conv = await this.conversationStore.get(conversationId);
       if (conv) {
+        let amendmentText;
+        let pushedAssistant;
         const hasAssistantContent = draft.assistantResponse.length > 0 || draft.toolTimeline.length > 0 || draft.sections.length > 0;
         if (hasAssistantContent) {
           const prevMessages = conv.messages;
@@ -12782,15 +13142,14 @@ var AgentOrchestrator = class {
                 }
               }
             ];
+            amendmentText = draft.assistantResponse;
           } else {
-            conv.messages = [
-              ...prevMessages,
-              {
-                role: "assistant",
-                content: draft.assistantResponse,
-                metadata: buildAssistantMetadata(draft)
-              }
-            ];
+            pushedAssistant = {
+              role: "assistant",
+              content: draft.assistantResponse,
+              metadata: buildAssistantMetadata(draft)
+            };
+            conv.messages = [...prevMessages, pushedAssistant];
           }
         }
         applyTurnMetadata(conv, {
@@ -12800,6 +13159,54 @@ var AgentOrchestrator = class {
           harnessMessages: execution?.runHarnessMessages
         }, { shouldRebuildCanonical: true });
         await this.conversationStore.update(conv);
+        if (amendmentText !== void 0 || 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 !== void 0) {
+                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);
@@ -13310,19 +13717,22 @@ var AgentOrchestrator = class {
     conversation.runStatus = "running";
     const callbackCount = (conversation.subagentCallbackCount ?? 0) + 1;
     conversation.subagentCallbackCount = callbackCount;
+    const injectedCallbackMessages = [];
     for (const pr of pendingResults) {
       const responseText = (pr.result?.response ?? "").trim();
       const responseLine = responseText || `(subagent produced no final summary after ${pr.result?.steps ?? 0} step(s); its work may be incomplete. Call read_subagent with subagent_id "${pr.subagentId}" and mode "assistant" to retrieve what it did.)`;
       const resultBody = pr.result ? `Status: ${pr.result.status}
 Response: ${responseLine}
 Steps: ${pr.result.steps}, Duration: ${pr.result.duration}ms` : pr.error ? `Error: ${pr.error.message}` : "(no result)";
-      conversation.messages.push({
+      const injected = {
         role: "user",
         content: `[Subagent Result] Subagent "${pr.task}" (${pr.subagentId}) ${pr.status}:
 
 ${resultBody}`,
         metadata: { _subagentCallback: true, subagentId: pr.subagentId, task: pr.task, timestamp: pr.timestamp }
-      });
+      };
+      injectedCallbackMessages.push(injected);
+      conversation.messages.push(injected);
     }
     const processedIds = new Set(pendingResults.map((pr) => pr.subagentId));
     const freshForPending = await this.conversationStore.get(conversationId);
@@ -13331,6 +13741,36 @@ ${resultBody}`,
     conversation._harnessMessages = [...conversation.messages];
     conversation.updatedAt = Date.now();
     await this.conversationStore.update(conversation);
+    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 = void 0;
@@ -13392,12 +13832,14 @@ ${resultBody}`,
       if (callbackNeedsContinuation || execution.draft.assistantResponse.length > 0 || execution.draft.toolTimeline.length > 0) {
         const freshConv = await this.conversationStore.get(conversationId);
         if (freshConv) {
+          let callbackAssistantMsg;
           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,
@@ -13410,6 +13852,25 @@ ${resultBody}`,
           }, { shouldRebuildCanonical: true, clearApprovals: false });
           freshConv.runningCallbackSince = void 0;
           await this.conversationStore.update(freshConv);
+          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
+              )
+            );
+          }
           if (freshConv.channelMeta && execution.draft.assistantResponse.length > 0) {
             this.hooks?.onMessagingNotify?.(conversationId, execution.draft.assistantResponse);
           }
@@ -13814,6 +14275,22 @@ ${resultBody}`,
    * old `.catch(() => {})` call sites did. Returns whether the result landed.
    */
   async appendSubagentResultReliable(parentConversationId, result) {
+    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;
@@ -13915,9 +14392,9 @@ ${resultBody}`,
 };
 
 // src/orchestrator/run-conversation-turn.ts
-import { randomUUID as randomUUID6 } from "crypto";
-import { createLogger as createLogger7 } from "@poncho-ai/sdk";
-var log = createLogger7("orchestrator");
+import { randomUUID as randomUUID7 } from "crypto";
+import { createLogger as createLogger8 } from "@poncho-ai/sdk";
+var log = createLogger8("orchestrator");
 var runConversationTurn = async (opts) => {
   const conversation = await opts.conversationStore.getWithArchive(opts.conversationId);
   if (!conversation) {
@@ -13955,9 +14432,9 @@ var runConversationTurn = async (opts) => {
   const userMessage = {
     role: "user",
     content: userContent,
-    metadata: { id: randomUUID6(), timestamp: turnTimestamp }
+    metadata: { id: randomUUID7(), timestamp: turnTimestamp }
   };
-  const assistantId = randomUUID6();
+  const assistantId = randomUUID7();
   const draft = createTurnDraftState();
   let latestRunId = conversation.runtimeRunId ?? "";
   let runCancelled = false;
@@ -13996,6 +14473,8 @@ var runConversationTurn = async (opts) => {
     conversation.updatedAt = Date.now();
     await opts.conversationStore.update(conversation);
   };
+  const preTurnHarnessMessages = conversation._harnessMessages ? [...conversation._harnessMessages] : void 0;
+  const turnId = assistantId;
   conversation.messages = [...historyMessages, userMessage];
   conversation.subagentCallbackCount = 0;
   conversation._continuationCount = void 0;
@@ -14005,6 +14484,12 @@ var runConversationTurn = async (opts) => {
       `failed to persist user turn: ${err instanceof Error ? err.message : String(err)}`
     );
   });
+  void appendEntriesSafe(
+    opts.conversationStore,
+    conversation,
+    [userMessageEntry(userMessage, turnId)],
+    log
+  );
   try {
     const execution = await executeConversationTurn({
       harness: opts.harness,
@@ -14052,6 +14537,34 @@ var runConversationTurn = async (opts) => {
               ...existingHistory,
               ...preRunMessages.slice(0, removedCount)
             ];
+            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"] }
+                  );
+                  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") {
@@ -14185,6 +14698,36 @@ var runConversationTurn = async (opts) => {
         { shouldRebuildCanonical }
       );
       await opts.conversationStore.update(conversation);
+      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 \u2014 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 {
       latestRunId,
@@ -14302,10 +14845,13 @@ export {
   VFS_SCHEME,
   VercelBlobUploadStore,
   abnormalEndResponse,
+  appendEntriesSafe,
   applyTurnMetadata,
   buildAgentDirectoryName,
   buildApprovalCheckpoints,
   buildAssistantMetadata,
+  buildDisplaySnapshot,
+  buildLlmContext,
   buildSkillContextWindow,
   buildToolCompletedText,
   cloneSections,
@@ -14342,6 +14888,7 @@ export {
   deleteOpenAICodexSession,
   deriveUploadKey,
   ensureAgentIdentity,
+  entriesParityEnabled,
   estimateTokens,
   estimateTotalTokens,
   executeConversationTurn,
@@ -14353,6 +14900,7 @@ export {
   getOpenAICodexAccessToken,
   getOpenAICodexAuthFilePath,
   getOpenAICodexRequiredScopes,
+  getPendingSubagentResults,
   getPonchoStoreRoot,
   isMessageArray,
   jsonSchemaToZod,
@@ -14366,6 +14914,7 @@ export {
   loadSkillMetadataFromDirs,
   loadVfsSkillMetadata,
   mergeSkills,
+  newHarnessMessagesThisTurn,
   normalizeApprovalCheckpoint,
   normalizeOtlp,
   normalizeScriptPolicyPath,
@@ -14389,6 +14938,7 @@ export {
   runConversationTurn,
   slugifyStorageComponent,
   startOpenAICodexDeviceAuth,
+  verifyEntriesParity,
   verifyTenantToken,
   withToolResultArchiveParam,
   writeOpenAICodexSession