@poncho-ai/harness 0.59.1 → 0.59.3

package/test/entries-store.test.ts

@@ -4,33 +4,24 @@ 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 type { 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",
+// The queue carries exactly two entry types; the engine-level append/read
+// semantics tested here (seq assignment, ordering, filters, isolation) are
+// type-agnostic.
+const resultEntry = (id: string, subagentId: string): NewConversationEntry => ({
+  type: "subagent_result",
   id,
-  message: msg("assistant", content),
-  turnId: "t1",
+  result: { subagentId, task: "t", status: "completed", timestamp: 1 },
 });
 
-const compactionEntry = (id: string): NewConversationEntry => ({
-  type: "compaction",
+const consumedEntry = (id: string, seqs: number[]): NewConversationEntry => ({
+  type: "callback_started",
   id,
-  summaryMessage: msg("user", "summary so far"),
-  firstKeptSeq: 2,
+  consumedSeqs: seqs,
 });
 
 // Shared suite run against both InMemory and SQLite-backed stores.
@@ -51,55 +42,55 @@ function runSuite(name: string, factory: () => Promise<{ store: ConversationStor
 
     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?"),
+        resultEntry("r1", "s1"),
+        resultEntry("r2", "s2"),
+        consumedEntry("cb1", [1]),
       ]);
       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")]);
+      await store.appendEntries("c1", "agent", null, [resultEntry("r1", "s1")]);
       const second = await store.appendEntries("c1", "agent", null, [
-        harnessEntry("h1", "b"),
-        harnessEntry("h2", "c"),
+        resultEntry("r2", "s2"),
+        consumedEntry("cb1", [1]),
       ]);
       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")]);
+      await store.appendEntries("c1", "agent", null, [resultEntry("r1", "s1")]);
+      const other = await store.appendEntries("c2", "agent", null, [resultEntry("r2", "s2")]);
       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"),
+        resultEntry("r1", "s1"),
+        resultEntry("r2", "s2"),
+        consumedEntry("cb1", [1]),
       ]);
       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"]);
+      expect(all.map((e) => e.id)).toEqual(["r1", "r2", "cb1"]);
     });
 
     it("filters by type", async () => {
       await store.appendEntries("c1", "agent", null, [
-        userEntry("u1", "one"),
-        harnessEntry("h1", "two"),
-        harnessEntry("h2", "three"),
+        resultEntry("r1", "s1"),
+        consumedEntry("cb1", [1]),
+        resultEntry("r2", "s2"),
       ]);
-      const harnessOnly = await store.readEntries("c1", { types: ["harness_message"] });
-      expect(harnessOnly.map((e) => e.id)).toEqual(["h1", "h2"]);
+      const resultsOnly = await store.readEntries("c1", { types: ["subagent_result"] });
+      expect(resultsOnly.map((e) => e.id)).toEqual(["r1", "r2"]);
     });
 
     it("filters by afterSeq", async () => {
       await store.appendEntries("c1", "agent", null, [
-        userEntry("u1", "one"),
-        harnessEntry("h1", "two"),
-        harnessEntry("h2", "three"),
+        resultEntry("r1", "s1"),
+        resultEntry("r2", "s2"),
+        resultEntry("r3", "s3"),
       ]);
       const after1 = await store.readEntries("c1", { afterSeq: 1 });
       expect(after1.map((e) => e.seq)).toEqual([2, 3]);
@@ -107,30 +98,29 @@ function runSuite(name: string, factory: () => Promise<{ store: ConversationStor
 
     it("respects limit", async () => {
       await store.appendEntries("c1", "agent", null, [
-        userEntry("u1", "one"),
-        harnessEntry("h1", "two"),
-        harnessEntry("h2", "three"),
+        resultEntry("r1", "s1"),
+        resultEntry("r2", "s2"),
+        resultEntry("r3", "s3"),
       ]);
       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 () => {
+    it("round-trips both entry types with their payloads intact", async () => {
       await store.appendEntries("c1", "agent", null, [
-        userEntry("u1", "question"),
-        compactionEntry("cmp1"),
+        resultEntry("r1", "sub-42"),
+        consumedEntry("cb1", [1, 7]),
       ]);
       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 result = all.find((e) => e.id === "r1");
+      expect(result?.type).toBe("subagent_result");
+      expect(result?.type === "subagent_result" && result.result.subagentId).toBe("sub-42");
+      expect(result?.type === "subagent_result" && result.result.status).toBe("completed");
 
-      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");
+      const consumed = all.find((e) => e.id === "cb1");
+      expect(consumed?.type).toBe("callback_started");
+      expect(consumed?.type === "callback_started" && consumed.consumedSeqs).toEqual([1, 7]);
     });
 
     it("returns an empty array for an unknown conversation", async () => {

package/test/entries.test.ts

@@ -1,125 +1,57 @@
 import { describe, it, expect } from "vitest";
 import {
-  buildLlmContext,
-  buildDisplaySnapshot,
   getPendingSubagentResults,
   type ConversationEntry,
 } from "../src/storage/entries.js";
-import type { Message } from "@poncho-ai/sdk";
 
-const msg = (role: Message["role"], content: string): Message => ({ role, content });
-
-let seq = 0;
-const reset = () => { seq = 0; };
-const next = () => ++seq;
-
-const harness = (content: string, turnId = "t1"): ConversationEntry => ({
-  type: "harness_message", id: `h${seq + 1}`, seq: next(), createdAt: 0,
-  message: msg("assistant", content), turnId,
-});
-const user = (content: string, opts: { hidden?: boolean } = {}): ConversationEntry => ({
-  type: "user_message", id: `u${seq + 1}`, seq: next(), createdAt: 0,
-  message: msg("user", content), turnId: "t1", hidden: opts.hidden,
-});
-const assistant = (id: string, content: string): ConversationEntry => ({
-  type: "assistant_message", id, seq: next(), createdAt: 0,
-  message: msg("assistant", content), turnId: "t1", runId: "r1",
+const result = (seq: number, subagentId: string): ConversationEntry => ({
+  type: "subagent_result",
+  id: `r${seq}`,
+  seq,
+  createdAt: seq,
+  result: { subagentId, task: "t", status: "completed", timestamp: seq },
 });
 
-describe("buildLlmContext", () => {
-  it("returns all harness messages in order with no compaction", () => {
-    reset();
-    const entries = [harness("a"), harness("b"), harness("c")];
-    expect(buildLlmContext(entries).map((m) => m.content)).toEqual(["a", "b", "c"]);
-  });
-
-  it("applies a compaction overlay: summary + messages from firstKeptSeq", () => {
-    reset();
-    const h1 = harness("old1"); // seq 1
-    const h2 = harness("old2"); // seq 2
-    const h3 = harness("kept3"); // seq 3
-    const h4 = harness("kept4"); // seq 4
-    const compaction: ConversationEntry = {
-      type: "compaction", id: "c1", seq: next(), createdAt: 0,
-      summaryMessage: msg("user", "[summary]"), firstKeptSeq: 3,
-    };
-    const ctx = buildLlmContext([h1, h2, h3, h4, compaction]);
-    expect(ctx.map((m) => m.content)).toEqual(["[summary]", "kept3", "kept4"]);
-  });
-
-  it("uses the LATEST compaction when several exist (layered)", () => {
-    reset();
-    const h1 = harness("a");
-    const c1: ConversationEntry = { type: "compaction", id: "c1", seq: next(), createdAt: 0, summaryMessage: msg("user", "[sum1]"), firstKeptSeq: 1 };
-    const h2 = harness("b"); // seq 3
-    const c2: ConversationEntry = { type: "compaction", id: "c2", seq: next(), createdAt: 0, summaryMessage: msg("user", "[sum2]"), firstKeptSeq: 3 };
-    const ctx = buildLlmContext([h1, c1, h2, c2]);
-    expect(ctx.map((m) => m.content)).toEqual(["[sum2]", "b"]);
-  });
+const consumed = (seq: number, consumedSeqs: number[]): ConversationEntry => ({
+  type: "callback_started",
+  id: `cb${seq}`,
+  seq,
+  createdAt: seq,
+  consumedSeqs,
 });
 
-describe("buildDisplaySnapshot", () => {
-  it("drops hidden user messages and returns the tail", () => {
-    reset();
-    const entries = [
-      user("hidden-framed", { hidden: true }),
-      user("hello"),
-      assistant("a1", "hi"),
-      user("again"),
-      assistant("a2", "yo"),
-    ];
-    const snap = buildDisplaySnapshot(entries, 10);
-    expect(snap.messages.map((m) => m.content)).toEqual(["hello", "hi", "again", "yo"]);
-    expect(snap.totalMessages).toBe(4);
-  });
-
-  it("folds amendments into their target assistant message", () => {
-    reset();
-    const a = assistant("a1", "part1");
-    const amend: ConversationEntry = {
-      type: "assistant_amendment", id: "am1", seq: next(), createdAt: 0,
-      targetEntryId: "a1", appendText: " + part2",
-    };
-    const snap = buildDisplaySnapshot([user("q"), a, amend], 10);
-    expect(snap.messages.map((m) => m.content)).toEqual(["q", "part1 + part2"]);
+describe("getPendingSubagentResults", () => {
+  it("returns every result when nothing is consumed", () => {
+    const pending = getPendingSubagentResults([result(1, "a"), result(2, "b")]);
+    expect(pending.map((r) => r.subagentId)).toEqual(["a", "b"]);
   });
 
-  it("returns only the trailing tailN messages", () => {
-    reset();
-    const entries = [user("1"), assistant("a", "2"), user("3"), assistant("b", "4")];
-    const snap = buildDisplaySnapshot(entries, 2);
-    expect(snap.messages.map((m) => m.content)).toEqual(["3", "4"]);
-    expect(snap.totalMessages).toBe(4);
+  it("excludes results consumed by a callback_started entry", () => {
+    const pending = getPendingSubagentResults([
+      result(1, "a"),
+      result(2, "b"),
+      consumed(3, [1]),
+    ]);
+    expect(pending.map((r) => r.subagentId)).toEqual(["b"]);
   });
-});
 
-describe("getPendingSubagentResults", () => {
-  const result = (subagentId: string): ConversationEntry => ({
-    type: "subagent_result", id: `sr-${subagentId}`, seq: next(), createdAt: 0,
-    result: { subagentId, task: "t", status: "completed", timestamp: 0 },
+  it("supports multiple consumption entries", () => {
+    const pending = getPendingSubagentResults([
+      result(1, "a"),
+      consumed(2, [1]),
+      result(3, "b"),
+      result(4, "c"),
+      consumed(5, [3, 4]),
+    ]);
+    expect(pending).toEqual([]);
   });
 
-  it("returns results not yet consumed by a callback", () => {
-    reset();
-    const r1 = result("s1"); // seq 1
-    const r2 = result("s2"); // seq 2
-    const callback: ConversationEntry = {
-      type: "callback_started", id: "cb1", seq: next(), createdAt: 0,
-      consumedSeqs: [1],
-    };
-    const r3 = result("s3"); // seq 4
-    const pending = getPendingSubagentResults([r1, r2, callback, r3]);
-    // s1 consumed; s2 + s3 still pending
-    expect(pending.map((p) => p.subagentId)).toEqual(["s2", "s3"]);
+  it("ignores consumption of unknown seqs", () => {
+    const pending = getPendingSubagentResults([result(1, "a"), consumed(2, [99])]);
+    expect(pending.map((r) => r.subagentId)).toEqual(["a"]);
   });
 
-  it("returns empty when all consumed", () => {
-    reset();
-    const r1 = result("s1");
-    const callback: ConversationEntry = {
-      type: "callback_started", id: "cb1", seq: next(), createdAt: 0,
-      consumedSeqs: [1],
-    };
-    expect(getPendingSubagentResults([r1, callback])).toEqual([]);
+  it("returns [] for an empty log", () => {
+    expect(getPendingSubagentResults([])).toEqual([]);
   });
 });