@kuralle-syrinx/kuralle 3.0.0 → 4.0.0

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@kuralle-syrinx/kuralle",
-  "version": "3.0.0",
+  "version": "4.0.0",
   "private": false,
   "type": "module",
   "license": "MIT",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
   "dependencies": {
-    "@kuralle-syrinx/core": "3.0.0"
+    "@kuralle-syrinx/core": "4.0.0"
   },
   "peerDependencies": {
     "@kuralle-agents/core": ">=0.8.0"

package/src/from-kuralle.test.ts

@@ -8,6 +8,7 @@ import {
   reconcileSpokenPrefix,
   rewriteLastAssistant,
   type KuralleMessageLike,
+  type KuralleRunOptions,
   type KuralleRuntimeLike,
   type KuralleSessionStoreLike,
   type KuralleStoredSession,
@@ -74,6 +75,58 @@ async function collectParts(reasoner: Reasoner, turn: ReasonerTurn): Promise<Rea
   return collected;
 }
 
+describe("fromKuralleRuntime G4 resume-by-seed (historyDelta)", () => {
+  const turnWithContext = (): ReasonerTurn => ({
+    userText: "Second question",
+    messages: [
+      { role: "system", content: "sys" },
+      { role: "user", content: "First question" },
+      { role: "assistant", content: "First answer" },
+    ],
+    signal: new AbortController().signal,
+  });
+
+  it("seeds prior turn.messages into an EMPTY kuralle session (fresh isolate resume)", async () => {
+    const spy: { runOpts?: KuralleRunOptions } = {};
+    const runtime: KuralleRuntimeLike = {
+      run(opts) {
+        spy.runOpts = opts;
+        return { events: partsToEvents([textDelta("ok"), done()]) };
+      },
+      getSession: async () => null,
+    };
+    const reasoner = fromKuralleRuntime(runtime, { sessionId: "sess-1" });
+
+    await collectParts(reasoner, turnWithContext());
+
+    expect(spy.runOpts?.input).toBe("Second question");
+    expect(spy.runOpts?.historyDelta).toEqual([
+      { role: "user", content: "First question" },
+      { role: "assistant", content: "First answer" },
+    ]);
+  });
+
+  it("does NOT seed into a non-empty session (no double-applied history, R6)", async () => {
+    const spy: { runOpts?: KuralleRunOptions } = {};
+    const runtime: KuralleRuntimeLike = {
+      run(opts) {
+        spy.runOpts = opts;
+        return { events: partsToEvents([textDelta("ok"), done()]) };
+      },
+      getSession: async () => ({
+        id: "sess-1",
+        messages: [{ role: "user", content: "already there" }],
+      }),
+    };
+    const reasoner = fromKuralleRuntime(runtime, { sessionId: "sess-1" });
+
+    await collectParts(reasoner, turnWithContext());
+
+    expect(spy.runOpts?.input).toBe("Second question");
+    expect(spy.runOpts?.historyDelta).toBeUndefined();
+  });
+});
+
 describe("fromKuralleRuntime", () => {
   it("maps happy path: text deltas and done to finish:stop", async () => {
     const reasoner = fromKuralleRuntime(

package/src/from-kuralle.ts

@@ -87,7 +87,23 @@ async function buildKuralleRunOptions(
     const appended = await appendFlowResumeUserMessage(runtime, opts.sessionId, turn.userText);
     if (appended) return base;
   }
-  return { ...base, input: turn.userText };
+  // G4 resume-by-seed: the BRIDGE owns history (reasoner seam §4.5). When the kuralle
+  // session is empty (fresh isolate / post-eviction) and the turn carries prior context,
+  // seed it once via historyDelta — kuralle appends it to the (empty) session, so the
+  // runtime resumes with the same context instead of restarting amnesiac. Never seeded
+  // into a non-empty session (that would double-apply history).
+  return { ...base, input: turn.userText, ...seedHistoryDelta(session, turn.messages) };
+}
+
+function seedHistoryDelta(
+  session: KuralleStoredSession | null,
+  messages: ReasonerTurn["messages"],
+): Pick<KuralleRunOptions, "historyDelta"> | Record<string, never> {
+  if (session && session.messages.length > 0) return {};
+  const delta = messages
+    .filter((message) => message.role === "user" || message.role === "assistant")
+    .map((message) => ({ role: message.role, content: message.content }));
+  return delta.length > 0 ? { historyDelta: delta } : {};
 }
 
 export async function buildKuralleTurnRunOptions(