@poncho-ai/harness 0.55.0 → 0.58.0

package/test/entries-dual-write.test.ts

@@ -0,0 +1,172 @@
+import { describe, it, expect } from "vitest";
+import type { Message } from "@poncho-ai/sdk";
+import { createLogger } from "@poncho-ai/sdk";
+import { InMemoryConversationStore } from "../src/state.js";
+import {
+  buildDisplaySnapshot,
+  buildLlmContext,
+  getPendingSubagentResults,
+} from "../src/storage/entries.js";
+import {
+  appendEntriesSafe,
+  assistantMessageEntry,
+  callbackStartedEntry,
+  compactionEntry,
+  harnessMessageEntries,
+  newHarnessMessagesThisTurn,
+  subagentResultEntry,
+  userMessageEntry,
+} from "../src/orchestrator/entries-dual-write.js";
+
+const log = createLogger("test");
+const msg = (role: Message["role"], content: string): Message => ({
+  role,
+  content,
+  metadata: { id: `${role}-${content}` },
+});
+
+const conv = (id: string) => ({
+  conversationId: id,
+  ownerId: "owner-1",
+  tenantId: null as string | null,
+});
+
+describe("entries dual-write", () => {
+  it("rebuilds llm context + display from a simulated chat turn's appends", async () => {
+    const store = new InMemoryConversationStore();
+    const c = conv("c1");
+    const turnId = "turn-1";
+
+    // Turn start: user message.
+    await appendEntriesSafe(store, c, [userMessageEntry(msg("user", "hi"), turnId)], log);
+
+    // During the turn the harness produced two model-visible messages and a
+    // final assistant bubble.
+    const harness1 = msg("user", "hi");
+    const harness2 = msg("assistant", "hello there");
+    const finalAssistant = msg("assistant", "hello there");
+    await appendEntriesSafe(
+      store,
+      c,
+      [
+        ...harnessMessageEntries([harness1, harness2], turnId),
+        assistantMessageEntry(finalAssistant, turnId, "run-1"),
+      ],
+      log,
+    );
+
+    const entries = await store.readEntries("c1");
+
+    // LLM context == the harness messages in order.
+    const llm = buildLlmContext(entries);
+    expect(llm.map((m) => m.content)).toEqual(["hi", "hello there"]);
+
+    // Display == [user, assistant] (final assistant bubble; harness msgs hidden).
+    const snap = buildDisplaySnapshot(entries, 100);
+    expect(snap.messages.map((m) => [m.role, m.content])).toEqual([
+      ["user", "hi"],
+      ["assistant", "hello there"],
+    ]);
+    expect(snap.totalMessages).toBe(2);
+  });
+
+  it("compaction overlay keeps summary + tail at rebuild", async () => {
+    const store = new InMemoryConversationStore();
+    const c = conv("c2");
+
+    await appendEntriesSafe(
+      store,
+      c,
+      harnessMessageEntries(
+        [msg("user", "m1"), msg("assistant", "m2"), msg("user", "m3")],
+        "t",
+      ),
+      log,
+    );
+    const before = await store.readEntries("c2");
+    // Keep only the last harness message (seq 3) after compaction.
+    const firstKeptSeq = before[before.length - 1]!.seq;
+    await appendEntriesSafe(
+      store,
+      c,
+      [compactionEntry(msg("assistant", "SUMMARY"), firstKeptSeq)],
+      log,
+    );
+
+    const llm = buildLlmContext(await store.readEntries("c2"));
+    expect(llm.map((m) => m.content)).toEqual(["SUMMARY", "m3"]);
+  });
+
+  it("subagent_result + callback_started track pending consumption", async () => {
+    const store = new InMemoryConversationStore();
+    const c = conv("c3");
+
+    const stored = await appendEntriesSafe(
+      store,
+      c,
+      [
+        subagentResultEntry({
+          subagentId: "sa-1",
+          task: "do thing",
+          status: "completed",
+          timestamp: 1,
+        }),
+      ],
+      log,
+    );
+    const resultSeq = stored[0]!.seq;
+
+    // Before consumption: pending.
+    expect(getPendingSubagentResults(await store.readEntries("c3"))).toHaveLength(1);
+
+    // The callback consumes it + injects a hidden user message.
+    await appendEntriesSafe(
+      store,
+      c,
+      [
+        callbackStartedEntry([resultSeq]),
+        userMessageEntry(msg("user", "[Subagent Result] ..."), "cb-1", { hidden: true }),
+      ],
+      log,
+    );
+
+    const after = await store.readEntries("c3");
+    expect(getPendingSubagentResults(after)).toHaveLength(0);
+    // Hidden injected message does not appear in the display transcript.
+    expect(buildDisplaySnapshot(after, 100).messages).toHaveLength(0);
+  });
+
+  it("newHarnessMessagesThisTurn diffs the suffix and flags shrinks", () => {
+    const a = msg("user", "a");
+    const b = msg("assistant", "b");
+    const cc = msg("user", "c");
+
+    expect(newHarnessMessagesThisTurn(undefined, [a, b])).toEqual({
+      messages: [a, b],
+      approximate: false,
+    });
+    expect(newHarnessMessagesThisTurn([a], [a, b, cc])).toEqual({
+      messages: [b, cc],
+      approximate: false,
+    });
+    // Shrink (compaction reshaped the array) → approximate, returns full next.
+    const shrink = newHarnessMessagesThisTurn([a, b, cc], [a]);
+    expect(shrink.approximate).toBe(true);
+    expect(shrink.messages).toEqual([a]);
+  });
+
+  it("appendEntriesSafe swallows store errors and returns []", async () => {
+    const brokenStore = {
+      appendEntries: async () => {
+        throw new Error("boom");
+      },
+    } as unknown as InMemoryConversationStore;
+    const result = await appendEntriesSafe(
+      brokenStore,
+      conv("c4"),
+      [userMessageEntry(msg("user", "x"), "t")],
+      log,
+    );
+    expect(result).toEqual([]);
+  });
+});

package/test/entries-read-cutover.test.ts

@@ -0,0 +1,96 @@
+import { describe, it, expect, afterEach } from "vitest";
+import { InMemoryConversationStore } from "../src/state.js";
+import {
+  buildLlmContext,
+  buildDisplaySnapshot,
+  type NewConversationEntry,
+} from "../src/storage/entries.js";
+import type { Message } from "@poncho-ai/sdk";
+
+const msg = (role: Message["role"], content: string): Message => ({ role, content });
+
+// A turn's worth of entries: a user display message, the harness (LLM
+// transcript) messages for that turn, and the final assistant bubble.
+function turnEntries(): NewConversationEntry[] {
+  return [
+    { type: "user_message", id: "u1", message: msg("user", "hello"), turnId: "t1" },
+    { type: "harness_message", id: "h1", message: msg("user", "hello"), turnId: "t1" },
+    { type: "harness_message", id: "h2", message: msg("assistant", "hi there"), turnId: "t1" },
+    {
+      type: "assistant_message",
+      id: "a1",
+      message: msg("assistant", "hi there"),
+      turnId: "t1",
+      runId: "r1",
+    },
+  ];
+}
+
+describe("Phase 3c read cutover", () => {
+  const prevFlag = process.env.PONCHO_READ_ENTRIES;
+
+  afterEach(() => {
+    if (prevFlag === undefined) delete process.env.PONCHO_READ_ENTRIES;
+    else process.env.PONCHO_READ_ENTRIES = prevFlag;
+  });
+
+  it("get() rebuilds _harnessMessages/messages from entries when present", async () => {
+    delete process.env.PONCHO_READ_ENTRIES; // ON by default
+    const store = new InMemoryConversationStore();
+    const conv = await store.create("owner", "title", null);
+
+    // Seed the blob with stale messages so we can prove the override happened.
+    conv.messages = [msg("assistant", "STALE BLOB")];
+    conv._harnessMessages = [msg("assistant", "STALE BLOB HARNESS")];
+    await store.update(conv);
+
+    const entries = await store.appendEntries(conv.conversationId, "agent", null, turnEntries());
+
+    const loaded = await store.get(conv.conversationId);
+    expect(loaded).toBeDefined();
+    expect(loaded!._harnessMessages).toEqual(buildLlmContext(entries));
+    expect(loaded!.messages).toEqual(buildDisplaySnapshot(entries, 100000).messages);
+    // Display transcript drops the harness-only messages; keeps user + assistant bubble.
+    expect(loaded!.messages.map((m) => m.content)).toEqual(["hello", "hi there"]);
+  });
+
+  it("get() falls back to the blob when there are no entries", async () => {
+    delete process.env.PONCHO_READ_ENTRIES;
+    const store = new InMemoryConversationStore();
+    const conv = await store.create("owner", "title", null);
+    conv.messages = [msg("user", "blob only")];
+    conv._harnessMessages = [msg("user", "blob only harness")];
+    await store.update(conv);
+
+    const loaded = await store.get(conv.conversationId);
+    expect(loaded!.messages).toEqual([msg("user", "blob only")]);
+    expect(loaded!._harnessMessages).toEqual([msg("user", "blob only harness")]);
+  });
+
+  it("kill-switch PONCHO_READ_ENTRIES=0 reverts to blob reads even with entries", async () => {
+    process.env.PONCHO_READ_ENTRIES = "0";
+    const store = new InMemoryConversationStore();
+    const conv = await store.create("owner", "title", null);
+    conv.messages = [msg("user", "blob wins")];
+    await store.update(conv);
+    await store.appendEntries(conv.conversationId, "agent", null, turnEntries());
+
+    const loaded = await store.get(conv.conversationId);
+    expect(loaded!.messages).toEqual([msg("user", "blob wins")]);
+  });
+
+  it("get() does not mutate the stored blob conversation (clone)", async () => {
+    delete process.env.PONCHO_READ_ENTRIES;
+    const store = new InMemoryConversationStore();
+    const conv = await store.create("owner", "title", null);
+    conv.messages = [msg("assistant", "STALE BLOB")];
+    await store.update(conv);
+    await store.appendEntries(conv.conversationId, "agent", null, turnEntries());
+
+    await store.get(conv.conversationId);
+    // Re-read with the kill-switch on: should still see the untouched blob.
+    process.env.PONCHO_READ_ENTRIES = "0";
+    const blob = await store.get(conv.conversationId);
+    expect(blob!.messages).toEqual([msg("assistant", "STALE BLOB")]);
+  });
+});

package/test/entries-store.test.ts

@@ -0,0 +1,165 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { InMemoryConversationStore } from "../src/state.js";
+import type { ConversationStore } from "../src/state.js";
+import type { ConversationEntry, NewConversationEntry } from "../src/storage/entries.js";
+import { SqliteEngine } from "../src/storage/sqlite-engine.js";
+import { createConversationStoreFromEngine } from "../src/storage/store-adapters.js";
+import type { Message } from "@poncho-ai/sdk";
+
+const msg = (role: Message["role"], content: string): Message => ({ role, content });
+
+// Entry factories (without seq/createdAt — those are assigned by the store).
+const userEntry = (id: string, content: string): NewConversationEntry => ({
+  type: "user_message",
+  id,
+  message: msg("user", content),
+  turnId: "t1",
+});
+
+const harnessEntry = (id: string, content: string): NewConversationEntry => ({
+  type: "harness_message",
+  id,
+  message: msg("assistant", content),
+  turnId: "t1",
+});
+
+const compactionEntry = (id: string): NewConversationEntry => ({
+  type: "compaction",
+  id,
+  summaryMessage: msg("user", "summary so far"),
+  firstKeptSeq: 2,
+});
+
+// Shared suite run against both InMemory and SQLite-backed stores.
+function runSuite(name: string, factory: () => Promise<{ store: ConversationStore; cleanup: () => Promise<void> }>) {
+  describe(name, () => {
+    let store: ConversationStore;
+    let cleanup: () => Promise<void>;
+
+    beforeEach(async () => {
+      const ctx = await factory();
+      store = ctx.store;
+      cleanup = ctx.cleanup;
+    });
+
+    afterEach(async () => {
+      await cleanup();
+    });
+
+    it("assigns consecutive per-conversation seqs starting at 1", async () => {
+      const stored = await store.appendEntries("c1", "agent", null, [
+        userEntry("u1", "hi"),
+        harnessEntry("h1", "hello"),
+        harnessEntry("h2", "how can I help?"),
+      ]);
+      expect(stored.map((e) => e.seq)).toEqual([1, 2, 3]);
+      expect(stored.every((e) => typeof e.createdAt === "number")).toBe(true);
+    });
+
+    it("continues seq across multiple appendEntries calls", async () => {
+      await store.appendEntries("c1", "agent", null, [userEntry("u1", "a")]);
+      const second = await store.appendEntries("c1", "agent", null, [
+        harnessEntry("h1", "b"),
+        harnessEntry("h2", "c"),
+      ]);
+      expect(second.map((e) => e.seq)).toEqual([2, 3]);
+    });
+
+    it("keeps seq spaces independent per conversation", async () => {
+      await store.appendEntries("c1", "agent", null, [userEntry("u1", "a")]);
+      const other = await store.appendEntries("c2", "agent", null, [userEntry("u2", "b")]);
+      expect(other[0].seq).toBe(1);
+    });
+
+    it("reads entries ordered by seq ascending", async () => {
+      await store.appendEntries("c1", "agent", null, [
+        userEntry("u1", "one"),
+        harnessEntry("h1", "two"),
+        harnessEntry("h2", "three"),
+      ]);
+      const all = await store.readEntries("c1");
+      expect(all.map((e) => e.seq)).toEqual([1, 2, 3]);
+      expect(all.map((e) => e.id)).toEqual(["u1", "h1", "h2"]);
+    });
+
+    it("filters by type", async () => {
+      await store.appendEntries("c1", "agent", null, [
+        userEntry("u1", "one"),
+        harnessEntry("h1", "two"),
+        harnessEntry("h2", "three"),
+      ]);
+      const harnessOnly = await store.readEntries("c1", { types: ["harness_message"] });
+      expect(harnessOnly.map((e) => e.id)).toEqual(["h1", "h2"]);
+    });
+
+    it("filters by afterSeq", async () => {
+      await store.appendEntries("c1", "agent", null, [
+        userEntry("u1", "one"),
+        harnessEntry("h1", "two"),
+        harnessEntry("h2", "three"),
+      ]);
+      const after1 = await store.readEntries("c1", { afterSeq: 1 });
+      expect(after1.map((e) => e.seq)).toEqual([2, 3]);
+    });
+
+    it("respects limit", async () => {
+      await store.appendEntries("c1", "agent", null, [
+        userEntry("u1", "one"),
+        harnessEntry("h1", "two"),
+        harnessEntry("h2", "three"),
+      ]);
+      const limited = await store.readEntries("c1", { limit: 2 });
+      expect(limited.map((e) => e.seq)).toEqual([1, 2]);
+    });
+
+    it("round-trips distinct entry types with their payloads intact", async () => {
+      await store.appendEntries("c1", "agent", null, [
+        userEntry("u1", "question"),
+        compactionEntry("cmp1"),
+      ]);
+      const all = await store.readEntries("c1");
+
+      const user = all.find((e) => e.id === "u1");
+      expect(user?.type).toBe("user_message");
+      expect(user?.type === "user_message" && user.message.content).toBe("question");
+      expect(user?.type === "user_message" && user.turnId).toBe("t1");
+
+      const cmp = all.find((e) => e.id === "cmp1");
+      expect(cmp?.type).toBe("compaction");
+      expect(cmp?.type === "compaction" && cmp.firstKeptSeq).toBe(2);
+      expect(cmp?.type === "compaction" && cmp.summaryMessage.content).toBe("summary so far");
+    });
+
+    it("returns an empty array for an unknown conversation", async () => {
+      expect(await store.readEntries("nope")).toEqual([]);
+    });
+
+    it("treats an empty append as a no-op", async () => {
+      const stored = await store.appendEntries("c1", "agent", null, []);
+      expect(stored).toEqual([]);
+      expect(await store.readEntries("c1")).toEqual([]);
+    });
+  });
+}
+
+runSuite("InMemoryConversationStore entries", async () => {
+  const store = new InMemoryConversationStore();
+  return { store, cleanup: async () => {} };
+});
+
+runSuite("SqliteEngine entries (via adapter)", async () => {
+  const dir = await mkdtemp(join(tmpdir(), "entries-store-"));
+  const engine = new SqliteEngine({ workingDir: dir, agentId: "agent", dbPath: join(dir, "test.db") });
+  await engine.initialize();
+  const store = createConversationStoreFromEngine(engine);
+  return {
+    store,
+    cleanup: async () => {
+      await engine.close();
+      await rm(dir, { recursive: true, force: true });
+    },
+  };
+});