woozlit 2.3.0 → 2.3.2

package/test/session/classify.test.ts

@@ -1,335 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { classifyAssistantStep } from "../../src/session/classify"
-import { MessageV2 } from "../../src/session/message-v2"
-import { SessionID, MessageID, PartID } from "../../src/session/schema"
-import { ProviderID, ModelID } from "../../src/provider/schema"
-
-const sessionID = SessionID.make("session")
-
-function userInfo(id: string): MessageV2.User {
-  return {
-    id: MessageID.make(id),
-    sessionID,
-    role: "user",
-    time: { created: 0 },
-    agent: "user",
-    model: { providerID: ProviderID.make("test"), modelID: ModelID.make("test") },
-    tools: {},
-    mode: "",
-  } as unknown as MessageV2.User
-}
-
-function assistantInfo(
-  id: string,
-  extra?: Partial<Pick<MessageV2.Assistant, "finish" | "error" | "summary" | "structured">>,
-): MessageV2.Assistant {
-  return {
-    id: MessageID.make(id),
-    sessionID,
-    role: "assistant",
-    time: { created: 0 },
-    parentID: MessageID.make("m-parent"),
-    modelID: "test",
-    providerID: "test",
-    mode: "",
-    agent: "agent",
-    path: { cwd: "/", root: "/" },
-    cost: 0,
-    tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
-    ...extra,
-  } as unknown as MessageV2.Assistant
-}
-
-let partSeq = 0
-function basePart(messageID: string) {
-  return { id: PartID.make(`p-${partSeq++}`), sessionID, messageID: MessageID.make(messageID) }
-}
-function textPart(messageID: string, text: string, extra?: { synthetic?: boolean; ignored?: boolean }) {
-  return { ...basePart(messageID), type: "text", text, ...extra } as unknown as MessageV2.Part
-}
-function reasoningPart(messageID: string, text: string) {
-  return { ...basePart(messageID), type: "reasoning", text, time: { start: 0 } } as unknown as MessageV2.Part
-}
-function toolPart(messageID: string, opts?: { providerExecuted?: boolean }) {
-  return {
-    ...basePart(messageID),
-    type: "tool",
-    callID: "call-1",
-    tool: "read",
-    state: { status: "completed", input: {}, output: "ok", time: { start: 0, end: 1 }, title: "", metadata: {} },
-    metadata: opts?.providerExecuted ? { providerExecuted: true } : undefined,
-  } as unknown as MessageV2.Part
-}
-
-// User "m-1" precedes assistant "m-2" so the stale guard (lastUser.id < assistant.id) is satisfied.
-const lastUser = userInfo("m-1")
-
-describe("classifyAssistantStep", () => {
-  test("stop + non-empty text => final (not degraded)", () => {
-    expect(
-      classifyAssistantStep({
-        phase: "after-process",
-        lastUser,
-        assistant: assistantInfo("m-2", { finish: "stop" }),
-        parts: [textPart("m-2", "here is the answer")],
-      }),
-    ).toEqual({ type: "final" })
-  })
-
-  test("other + non-empty text => degraded final", () => {
-    expect(
-      classifyAssistantStep({
-        phase: "after-process",
-        lastUser,
-        assistant: assistantInfo("m-2", { finish: "other" }),
-        parts: [textPart("m-2", "usable answer despite an abnormal finish")],
-      }),
-    ).toEqual({ type: "final", degraded: true })
-  })
-
-  test("other + empty => invalid (routes to T01 nudge path)", () => {
-    expect(
-      classifyAssistantStep({
-        phase: "after-process",
-        lastUser,
-        assistant: assistantInfo("m-2", { finish: "other" }),
-        parts: [],
-      }).type,
-    ).toBe("invalid")
-  })
-
-  test("other + reasoning only => think-only (routes to T01 nudge path)", () => {
-    expect(
-      classifyAssistantStep({
-        phase: "after-process",
-        lastUser,
-        assistant: assistantInfo("m-2", { finish: "other" }),
-        parts: [reasoningPart("m-2", "let me think...")],
-      }),
-    ).toEqual({ type: "think-only" })
-  })
-
-  describe("core guarantee: any finish + client tool part => continue", () => {
-    for (const finish of ["stop", "other", "length", "content-filter"]) {
-      test(`finish=${finish} + client tool part (with non-empty final text) => continue`, () => {
-        expect(
-          classifyAssistantStep({
-            phase: "after-process",
-            lastUser,
-            assistant: assistantInfo("m-2", { finish }),
-            parts: [textPart("m-2", "looks done but a tool is still pending"), toolPart("m-2")],
-          }),
-        ).toEqual({ type: "continue" })
-      })
-    }
-  })
-
-  test("finish=tool-calls => continue", () => {
-    expect(
-      classifyAssistantStep({
-        phase: "after-process",
-        lastUser,
-        assistant: assistantInfo("m-2", { finish: "tool-calls" }),
-        parts: [],
-      }),
-    ).toEqual({ type: "continue" })
-  })
-
-  test("no finish => continue", () => {
-    expect(
-      classifyAssistantStep({
-        phase: "after-process",
-        lastUser,
-        assistant: assistantInfo("m-2"),
-        parts: [textPart("m-2", "partial")],
-      }),
-    ).toEqual({ type: "continue" })
-  })
-
-  test("provider-executed tool part only + stop + text => final (provider-executed isn't a client tool)", () => {
-    expect(
-      classifyAssistantStep({
-        phase: "after-process",
-        lastUser,
-        assistant: assistantInfo("m-2", { finish: "stop" }),
-        parts: [toolPart("m-2", { providerExecuted: true }), textPart("m-2", "answer")],
-      }),
-    ).toEqual({ type: "final" })
-  })
-
-  test("provider-executed tool part only + stop + no text => think-only/invalid (not continue)", () => {
-    const result = classifyAssistantStep({
-      phase: "after-process",
-      lastUser,
-      assistant: assistantInfo("m-2", { finish: "stop" }),
-      parts: [toolPart("m-2", { providerExecuted: true })],
-    })
-    expect(result.type).toBe("invalid")
-  })
-
-  test("content-filter => filtered", () => {
-    expect(
-      classifyAssistantStep({
-        phase: "after-process",
-        lastUser,
-        assistant: assistantInfo("m-2", { finish: "content-filter" }),
-        parts: [],
-      }),
-    ).toEqual({ type: "filtered" })
-  })
-
-  test("finish=error => failed", () => {
-    expect(
-      classifyAssistantStep({
-        phase: "after-process",
-        lastUser,
-        assistant: assistantInfo("m-2", { finish: "error" }),
-        parts: [],
-      }).type,
-    ).toBe("failed")
-  })
-
-  test("finish=error + non-empty text => failed (error finish beats final text)", () => {
-    // T03: a model "error" finish must terminate FAILED even when the step also
-    // produced text — error is checked before content (classify.ts step 5 vs 8),
-    // so it is never silently downgraded to a `final`.
-    const result = classifyAssistantStep({
-      phase: "after-process",
-      lastUser,
-      assistant: assistantInfo("m-2", { finish: "error" }),
-      parts: [textPart("m-2", "some text emitted before the error finish")],
-    })
-    expect(result.type).toBe("failed")
-  })
-
-  test("assistant.error set => failed even with non-empty text (not misjudged final)", () => {
-    const result = classifyAssistantStep({
-      phase: "after-process",
-      lastUser,
-      assistant: assistantInfo("m-2", {
-        finish: "stop",
-        error: new MessageV2.OutputLengthError({}).toObject(),
-      }),
-      parts: [textPart("m-2", "some text that should not count as final")],
-    })
-    expect(result.type).toBe("failed")
-  })
-
-  test("stop + reasoning only (no text) => think-only", () => {
-    expect(
-      classifyAssistantStep({
-        phase: "after-process",
-        lastUser,
-        assistant: assistantInfo("m-2", { finish: "stop" }),
-        parts: [reasoningPart("m-2", "let me think...")],
-      }),
-    ).toEqual({ type: "think-only" })
-  })
-
-  test("stop + empty (no text/tool/reasoning) => invalid", () => {
-    expect(
-      classifyAssistantStep({
-        phase: "after-process",
-        lastUser,
-        assistant: assistantInfo("m-2", { finish: "stop" }),
-        parts: [],
-      }).type,
-    ).toBe("invalid")
-  })
-
-  test("synthetic/ignored/whitespace text does not count as final => invalid", () => {
-    expect(
-      classifyAssistantStep({
-        phase: "after-process",
-        lastUser,
-        assistant: assistantInfo("m-2", { finish: "stop" }),
-        parts: [
-          textPart("m-2", "synthetic", { synthetic: true }),
-          textPart("m-2", "ignored", { ignored: true }),
-          textPart("m-2", "   "),
-        ],
-      }).type,
-    ).toBe("invalid")
-  })
-
-  test("existing-assistant phase + stale assistant (lastUser.id >= assistant.id) => continue", () => {
-    // user "m-2" comes after assistant "m-1": assistant predates the current turn.
-    expect(
-      classifyAssistantStep({
-        phase: "existing-assistant",
-        lastUser: userInfo("m-2"),
-        assistant: assistantInfo("m-1", { finish: "stop" }),
-        parts: [textPart("m-1", "old answer")],
-      }),
-    ).toEqual({ type: "continue" })
-  })
-
-  test("existing-assistant phase + fresh assistant + stop + text => final", () => {
-    expect(
-      classifyAssistantStep({
-        phase: "existing-assistant",
-        lastUser: userInfo("m-1"),
-        assistant: assistantInfo("m-2", { finish: "stop" }),
-        parts: [textPart("m-2", "answer")],
-      }),
-    ).toEqual({ type: "final" })
-  })
-
-  test("assistant.summary => final (terminal, never nudge-able)", () => {
-    expect(
-      classifyAssistantStep({
-        phase: "after-process",
-        lastUser,
-        assistant: assistantInfo("m-2", { finish: "stop", summary: true }),
-        parts: [],
-      }),
-    ).toEqual({ type: "final" })
-  })
-
-  test("assistant.structured set => final", () => {
-    expect(
-      classifyAssistantStep({
-        phase: "after-process",
-        lastUser,
-        assistant: assistantInfo("m-2", { finish: "stop", structured: { answer: 4 } }),
-        parts: [],
-      }),
-    ).toEqual({ type: "final" })
-  })
-
-  test("errored tool part → failed (Spec ③ P1 regression)", () => {
-    // SSE timeout cleanup marks pending tool parts as state.status === "error".
-    // Without the guard, these parts caused mis-classification as "continue" because
-    // the pending-tool check ranked above assistant.error. This led runLoop to
-    // re-enter and get stranded on permission.ask. Spec ③ P1 fixes this by adding
-    // state.status !== "error" to the pending-tool predicate, so errored parts fall
-    // through to step 5 (assistant.error) and return failed.
-    const errPart = {
-      ...basePart("m-2"),
-      type: "tool" as const,
-      callID: "call-1",
-      tool: "read",
-      state: {
-        status: "error" as const,
-        input: {},
-        error: "aborted",
-        time: { start: 1, end: 2 },
-        metadata: {},
-      },
-    } as unknown as MessageV2.Part
-
-    const result = classifyAssistantStep({
-      phase: "after-process",
-      lastUser,
-      assistant: assistantInfo("m-2", {
-        finish: "stop",
-        error: new MessageV2.APIError({
-          message: "SSE read timed out",
-          isRetryable: false,
-        }).toObject(),
-      }),
-      parts: [errPart],
-    })
-    expect(result).toEqual({ type: "failed", reason: "APIError" })
-  })
-})

package/test/session/compaction-agent-scope.test.ts

@@ -1,164 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { Effect } from "effect"
-import path from "path"
-import { Instance } from "../../src/project/instance"
-import { Session as SessionNs } from "../../src/session"
-import { MessageV2 } from "../../src/session/message-v2"
-import * as Compaction from "../../src/session/compaction"
-import { MessageID, PartID, type SessionID } from "../../src/session/schema"
-import { ModelID, ProviderID } from "../../src/provider/schema"
-import { Log } from "../../src/util"
-
-const root = path.join(__dirname, "../..")
-void Log.init({ print: false })
-
-function run<A, E>(fx: Effect.Effect<A, E, SessionNs.Service>) {
-  return Effect.runPromise(fx.pipe(Effect.provide(SessionNs.defaultLayer)))
-}
-
-const svc = {
-  create(input?: SessionNs.CreateInput) {
-    return run(SessionNs.Service.use((s) => s.create(input)))
-  },
-  remove(id: SessionID) {
-    return run(SessionNs.Service.use((s) => s.remove(id)))
-  },
-  updateMessage<T extends MessageV2.Info>(msg: T) {
-    return run(SessionNs.Service.use((s) => s.updateMessage(msg)))
-  },
-  updatePart<T extends MessageV2.Part>(part: T) {
-    return run(SessionNs.Service.use((s) => s.updatePart(part)))
-  },
-}
-
-async function addUser(sessionID: SessionID, text: string, agentID?: string) {
-  const id = MessageID.ascending()
-  await svc.updateMessage({
-    id,
-    sessionID,
-    role: "user",
-    time: { created: Date.now() },
-    agent: "test",
-    agentID,
-    model: { providerID: ProviderID.make("test"), modelID: ModelID.make("test") },
-    tools: {},
-    mode: "",
-  } as unknown as MessageV2.Info)
-  await svc.updatePart({
-    id: PartID.ascending(),
-    sessionID,
-    messageID: id,
-    type: "text",
-    text,
-  })
-  return id
-}
-
-describe("compaction scope is (session_id, agent_id)", () => {
-  test("create({sessionID, agentID}) inserts a compaction-boundary part tagged with that agent_id", async () => {
-    await Instance.provide({
-      directory: root,
-      fn: async () => {
-        const session = await svc.create({})
-
-        // Main thread: 3 messages (agent_id IS NULL)
-        await addUser(session.id, "main-1")
-        await addUser(session.id, "main-2")
-        await addUser(session.id, "main-3")
-
-        // Subagent "writer-1": 3 messages
-        await addUser(session.id, "writer-msg-1", "writer-1")
-        await addUser(session.id, "writer-msg-2", "writer-1")
-        await addUser(session.id, "writer-msg-3", "writer-1")
-
-        // Insert a compaction boundary scoped to writer-1.
-        await Compaction.create({
-          sessionID: session.id,
-          agent: "compaction",
-          model: { providerID: ProviderID.make("test"), modelID: ModelID.make("test") },
-          auto: true,
-          agentID: "writer-1",
-        })
-
-        // After compaction: writer-1's filterCompacted slice begins at the
-        // synthetic boundary (which is also tagged with agent_id = "writer-1"),
-        // skipping prior writer-1 history.
-        const writerMsgs = await Effect.runPromise(
-          MessageV2.filterCompactedEffect(session.id, { agentID: "writer-1" }),
-        )
-        // Expect: only the boundary message remains in writer-1's view
-        // (filterCompacted stops at the first compaction part walking back
-        // newest → oldest).
-        expect(writerMsgs).toHaveLength(1)
-        expect(writerMsgs[0].info.role).toBe("user")
-        expect(writerMsgs[0].info.agentID).toBe("writer-1")
-        const boundaryPart = writerMsgs[0].parts.find((p) => p.type === "compaction")
-        expect(boundaryPart).toBeDefined()
-        expect((boundaryPart as MessageV2.CompactionPart).auto).toBe(true)
-
-        // Main agent's view (agent_id IS NULL) is untouched: still 3 messages,
-        // no compaction boundary.
-        const mainMsgs = await Effect.runPromise(
-          MessageV2.filterCompactedEffect(session.id, { agentID: "main" }),
-        )
-        expect(mainMsgs).toHaveLength(3)
-        expect(mainMsgs.map((m) => (m.parts[0] as MessageV2.TextPart).text)).toEqual([
-          "main-1",
-          "main-2",
-          "main-3",
-        ])
-        for (const m of mainMsgs) {
-          expect(m.info.agentID).toBe("main")
-          expect(m.parts.some((p) => p.type === "compaction")).toBe(false)
-        }
-
-        await svc.remove(session.id)
-      },
-    })
-  })
-
-  test("compacting writer-1 leaves writer-2's history untouched", async () => {
-    await Instance.provide({
-      directory: root,
-      fn: async () => {
-        const session = await svc.create({})
-
-        await addUser(session.id, "writer-1-a", "writer-1")
-        await addUser(session.id, "writer-1-b", "writer-1")
-        await addUser(session.id, "writer-2-a", "writer-2")
-        await addUser(session.id, "writer-2-b", "writer-2")
-
-        await Compaction.create({
-          sessionID: session.id,
-          agent: "compaction",
-          model: { providerID: ProviderID.make("test"), modelID: ModelID.make("test") },
-          auto: true,
-          agentID: "writer-1",
-        })
-
-        // writer-2 unchanged: 2 messages, no boundary.
-        const w2Msgs = await Effect.runPromise(
-          MessageV2.filterCompactedEffect(session.id, { agentID: "writer-2" }),
-        )
-        expect(w2Msgs).toHaveLength(2)
-        expect(w2Msgs.map((m) => (m.parts[0] as MessageV2.TextPart).text)).toEqual([
-          "writer-2-a",
-          "writer-2-b",
-        ])
-        for (const m of w2Msgs) {
-          expect(m.parts.some((p) => p.type === "compaction")).toBe(false)
-        }
-
-        // writer-1 is compacted: its slice now starts at the boundary.
-        const w1Msgs = await Effect.runPromise(
-          MessageV2.filterCompactedEffect(session.id, { agentID: "writer-1" }),
-        )
-        expect(w1Msgs).toHaveLength(1)
-        expect(w1Msgs[0].parts.some((p) => p.type === "compaction")).toBe(true)
-        expect(w1Msgs[0].info.agentID).toBe("writer-1")
-
-        await svc.remove(session.id)
-      },
-    })
-  })
-})

package/test/session/context-inheritance.test.ts

@@ -1,46 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { Info } from "../../src/session/session"
-import { Identifier } from "../../src/id/id"
-import { SessionID, MessageID } from "../../src/session/schema"
-
-describe("Session context inheritance", () => {
-  test("Session.Info accepts contextFrom and contextWatermark fields", () => {
-    const sessionId = Identifier.descending("session")
-    const parentSessionId = SessionID.make(Identifier.descending("session"))
-    const parentMessageId = MessageID.make(Identifier.ascending("message"))
-    const result = Info.safeParse({
-      id: sessionId,
-      slug: "test",
-      projectID: "proj",
-      directory: "/tmp",
-      title: "test",
-      version: "1.0.0",
-      time: { created: 1, updated: 1 },
-      contextFrom: parentSessionId,
-      contextWatermark: parentMessageId,
-    })
-    expect(result.success).toBe(true)
-    if (result.success) {
-      expect(result.data.contextFrom).toBe(parentSessionId)
-      expect(result.data.contextWatermark).toBe(parentMessageId)
-    }
-  })
-
-  test("Session.Info contextFrom and contextWatermark are optional", () => {
-    const sessionId = Identifier.descending("session")
-    const result = Info.safeParse({
-      id: sessionId,
-      slug: "test",
-      projectID: "proj",
-      directory: "/tmp",
-      title: "test",
-      version: "1.0.0",
-      time: { created: 1, updated: 1 },
-    })
-    expect(result.success).toBe(true)
-    if (result.success) {
-      expect(result.data.contextFrom).toBeUndefined()
-      expect(result.data.contextWatermark).toBeUndefined()
-    }
-  })
-})

package/test/session/fork-prefix-invariant.test.ts

@@ -1,116 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test"
-import { Instance } from "../../src/project/instance"
-import { Session as SessionNs } from "../../src/session"
-import { MessageV2 } from "../../src/session/message-v2"
-import { MessageID, PartID } from "../../src/session/schema"
-import { ProviderID, ModelID } from "../../src/provider/schema"
-import { buildLLMRequestPrefix } from "../../src/session/llm-request-prefix"
-import { AppRuntime } from "../../src/effect/app-runtime"
-import { Log } from "../../src/util"
-import { tmpdir } from "../fixture/fixture"
-import { ProviderTest } from "../fake/provider"
-import type { Agent } from "../../src/agent/agent"
-
-void Log.init({ print: false })
-
-afterEach(async () => {
-  await Instance.disposeAll()
-})
-
-function makeAgent(): Agent.Info {
-  return {
-    name: "build",
-    mode: "primary",
-    options: {},
-    permission: [{ permission: "*", pattern: "*", action: "allow" }],
-  } satisfies Agent.Info
-}
-
-describe("fork prefix invariant", () => {
-  test("two callers of buildLLMRequestPrefix produce deep-equal output for identical inputs", async () => {
-    // The invariant: any future change to system/tools/messages construction
-    // that introduces an agent-conditional branch breaks this assertion.
-    // parent's runLoop and fork's spawn capture both call buildLLMRequestPrefix
-    // with the same inputs and must produce byte-equal output.
-
-    await using tmp = await tmpdir({ git: true })
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const session = await AppRuntime.runPromise(
-          SessionNs.Service.use((svc) => svc.create({})),
-        )
-
-        // Build a session with three messages: user → assistant → user.
-        for (let i = 0; i < 3; i++) {
-          const id = MessageID.ascending()
-          const role = i % 2 === 0 ? "user" : "assistant"
-          await AppRuntime.runPromise(
-            SessionNs.Service.use((svc) =>
-              svc.updateMessage({
-                id,
-                sessionID: session.id,
-                role,
-                time: { created: Date.now() + i },
-                agent: "build",
-                model: { providerID: ProviderID.make("test"), modelID: ModelID.make("test") },
-                tools: {},
-                mode: "",
-              } as unknown as MessageV2.Info),
-            ),
-          )
-          await AppRuntime.runPromise(
-            SessionNs.Service.use((svc) =>
-              svc.updatePart({
-                id: PartID.ascending(),
-                sessionID: session.id,
-                messageID: id,
-                type: "text",
-                text: `msg-${i}`,
-              }),
-            ),
-          )
-        }
-
-        const msgs = await AppRuntime.runPromise(
-          SessionNs.Service.use((svc) => svc.messages({ sessionID: session.id })),
-        )
-
-        const agent = makeAgent()
-        const model = ProviderTest.model({
-          id: ModelID.make("gpt-5.2"),
-          providerID: ProviderID.make("openai"),
-        })
-
-        // Call A: parent's runLoop view
-        const a = await AppRuntime.runPromise(
-          buildLLMRequestPrefix({
-            sessionID: session.id,
-            agent,
-            model,
-            msgs,
-            additions: [],
-          }),
-        )
-
-        // Call B: fork's spawn-capture view.
-        // Both paths call this same function with the same inputs;
-        // any divergence (e.g. agent-conditional branch) breaks this assertion.
-        const b = await AppRuntime.runPromise(
-          buildLLMRequestPrefix({
-            sessionID: session.id,
-            agent,
-            model,
-            msgs,
-            additions: [],
-          }),
-        )
-
-        // Fork-prefix-cache parity contract
-        expect(a.system).toEqual(b.system)
-        expect(JSON.stringify(a.tools)).toEqual(JSON.stringify(b.tools))
-        expect(a.inheritedMessages).toEqual(b.inheritedMessages)
-      },
-    })
-  })
-})