@monotykamary/pi-vcc 0.4.0 → 0.5.0

package/tests/load-messages.test.ts

@@ -1,49 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import { mkdtempSync, writeFileSync, rmSync } from "fs";
-import { tmpdir } from "os";
-import { join } from "path";
-import { loadAllMessages } from "../src/core/load-messages";
-
-describe("loadAllMessages", () => {
-  it("loads all message entries when no lineage filter is provided", () => {
-    const dir = mkdtempSync(join(tmpdir(), "pi-vcc-load-all-"));
-    const file = join(dir, "session.jsonl");
-    try {
-      const lines = [
-        JSON.stringify({ type: "session", id: "s1" }),
-        JSON.stringify({ type: "message", id: "m1", message: { role: "user", content: "u1" } }),
-        JSON.stringify({ type: "custom", id: "c1", customType: "x", data: {} }),
-        JSON.stringify({ type: "message", id: "m2", message: { role: "assistant", content: [{ type: "text", text: "a1" }] } }),
-        JSON.stringify({ type: "message", id: "m3", message: { role: "toolResult", toolName: "read", content: [{ type: "text", text: "ok" }] } }),
-      ];
-      writeFileSync(file, lines.join("\n") + "\n", "utf8");
-
-      const loaded = loadAllMessages(file, false);
-      expect(loaded.rendered).toHaveLength(3);
-      expect(loaded.rawMessages).toHaveLength(3);
-      expect(loaded.rendered.map((e) => e.index)).toEqual([0, 1, 2]);
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-
-  it("filters messages by allowed lineage entry IDs and preserves original message index", () => {
-    const dir = mkdtempSync(join(tmpdir(), "pi-vcc-load-filter-"));
-    const file = join(dir, "session.jsonl");
-    try {
-      const lines = [
-        JSON.stringify({ type: "message", id: "m1", message: { role: "user", content: "u1" } }),
-        JSON.stringify({ type: "message", id: "m2", message: { role: "assistant", content: [{ type: "text", text: "a1" }] } }),
-        JSON.stringify({ type: "message", id: "m3", message: { role: "user", content: "u2" } }),
-      ];
-      writeFileSync(file, lines.join("\n") + "\n", "utf8");
-
-      const loaded = loadAllMessages(file, false, new Set(["m2"]));
-      expect(loaded.rendered).toHaveLength(1);
-      expect(loaded.rawMessages).toHaveLength(1);
-      expect(loaded.rendered[0].index).toBe(1);
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-});

package/tests/model-threshold-hook.test.ts

@@ -1,311 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach, beforeAll, afterAll } from "bun:test";
-import { existsSync, unlinkSync, writeFileSync, readFileSync, mkdtempSync, rmSync } from "fs";
-import { tmpdir } from "os";
-import { join } from "path";
-import { registerBeforeCompactHook, PI_VCC_COMPACT_INSTRUCTION } from "../src/hooks/before-compact";
-
-let tmpDir: string;
-let CONFIG_PATH: string;
-
-beforeAll(() => {
-  tmpDir = mkdtempSync(join(tmpdir(), "pi-vcc-test-"));
-  CONFIG_PATH = join(tmpDir, "pi-vcc-config.json");
-  process.env.PI_VCC_CONFIG_PATH = CONFIG_PATH;
-});
-
-afterAll(() => {
-  delete process.env.PI_VCC_CONFIG_PATH;
-  rmSync(tmpDir, { recursive: true, force: true });
-});
-
-function createMockPi(model?: { id: string; provider?: string; contextWindow?: number }) {
-  const handlers: Record<string, ((e: any, c: any) => any)[]> = {};
-  const notifyCalls: Array<{ msg: string; level: string }> = [];
-  const ctx = {
-    hasUI: true,
-    model: model ?? undefined,
-    ui: {
-      notify: (msg: string, level: string) => {
-        notifyCalls.push({ msg, level });
-      },
-    },
-  } as any;
-  const pi = {
-    on: (eventName: string, h: (e: any, c: any) => any) => {
-      if (!handlers[eventName]) handlers[eventName] = [];
-      handlers[eventName].push(h);
-    },
-  } as any;
-  const emit = (eventName: string, event: any = {}) => {
-    const hs = handlers[eventName] ?? [];
-    let result: any;
-    for (const h of hs) result = h(event, ctx);
-    return result;
-  };
-  return { pi, ctx, emit, notifyCalls };
-}
-
-function setConfig(cfg: Record<string, unknown>) {
-  writeFileSync(CONFIG_PATH, JSON.stringify(cfg));
-}
-
-function makeEvent(branchEntries: any[], customInstructions?: string, tokensBefore = 100000) {
-  return {
-    type: "session_before_compact",
-    customInstructions,
-    branchEntries,
-    preparation: {
-      previousSummary: undefined,
-      fileOps: { read: [], written: [], edited: [] },
-      tokensBefore,
-    },
-    signal: new AbortController().signal,
-  };
-}
-
-const msg = (id: string, role: "user" | "assistant" | "toolResult", content = "x") => ({
-  id,
-  type: "message",
-  message: { role, content },
-});
-
-describe("session_before_compact: per-model threshold", () => {
-  afterEach(() => {
-    if (existsSync(CONFIG_PATH)) unlinkSync(CONFIG_PATH);
-  });
-
-  test("compaction proceeds when context is below per-model threshold", () => {
-    // The threshold guard was removed because session_before_compact carries no
-    // reason field — manual /compact and auto-compaction are indistinguishable.
-    // The proactive trigger handles compacting earlier than pi-core's global
-    // threshold; this hook no longer blocks compaction that arrives before the
-    // per-model threshold.
-    setConfig({
-      debug: false,
-      overrideDefaultCompaction: true,
-      modelThresholds: {
-        "neuralwatt/GLM-5.1": { reserveTokens: 32768 },
-      },
-    });
-    const { pi, ctx, emit } = createMockPi({
-      id: "GLM-5.1",
-      provider: "neuralwatt",
-      contextWindow: 200000,
-    });
-    registerBeforeCompactHook(pi);
-
-    // 100k tokens < 200k - 32768 = 167232 → below threshold, but proceeds
-    const entries = [
-      msg("m1", "user", "hello"),
-      msg("m2", "assistant", "hi"),
-      msg("m3", "user", "do work"),
-      msg("m4", "assistant", "done"),
-    ];
-    const result = emit("session_before_compact", makeEvent(entries, undefined, 100000));
-    // No longer cancelled — threshold guard removed
-    expect(result.cancel).toBeUndefined();
-    expect(result.compaction).toBeDefined();
-  });
-
-  test("compaction proceeds when context exceeds per-model threshold", () => {
-    setConfig({
-      debug: false,
-      overrideDefaultCompaction: true,
-      modelThresholds: {
-        "neuralwatt/GLM-5.1": { reserveTokens: 32768 },
-      },
-    });
-    const { pi, ctx, emit } = createMockPi({
-      id: "GLM-5.1",
-      provider: "neuralwatt",
-      contextWindow: 200000,
-    });
-    registerBeforeCompactHook(pi);
-
-    // 180k tokens > 200k - 32768 = 167232 → above threshold
-    const entries = [
-      msg("m1", "user", "hello"),
-      msg("m2", "assistant", "hi"),
-      msg("m3", "user", "do work"),
-      msg("m4", "assistant", "done"),
-    ];
-    const result = emit("session_before_compact", makeEvent(entries, undefined, 180000));
-    expect(result.cancel).toBeUndefined();
-    expect(result.compaction).toBeDefined();
-  });
-
-  test("compaction proceeds with globalThreshold compactPercent", () => {
-    // compactPercent: 65 → reserve = 128000 * 0.35 = 44800 → threshold = 83200
-    setConfig({
-      debug: false,
-      overrideDefaultCompaction: true,
-      globalThreshold: { compactPercent: 65 },
-    });
-    const { pi, ctx, emit } = createMockPi({
-      id: "some-model",
-      provider: "some-provider",
-      contextWindow: 128000,
-    });
-    registerBeforeCompactHook(pi);
-
-    // 50k tokens < 83200 → below threshold, but proceeds
-    const entries = [
-      msg("m1", "user", "hello"),
-      msg("m2", "assistant", "hi"),
-      msg("m3", "user", "do work"),
-      msg("m4", "assistant", "done"),
-    ];
-    const result = emit("session_before_compact", makeEvent(entries, undefined, 50000));
-    expect(result.cancel).toBeUndefined();
-    expect(result.compaction).toBeDefined();
-  });
-
-  test("compaction proceeds with modelThreshold compactPercent", () => {
-    // compactPercent: 80 → reserve = 200000 * 0.20 = 40000 → threshold = 160000
-    setConfig({
-      debug: false,
-      overrideDefaultCompaction: true,
-      modelThresholds: {
-        "neuralwatt/GLM-5.1": { compactPercent: 80 },
-      },
-    });
-    const { pi, ctx, emit } = createMockPi({
-      id: "GLM-5.1",
-      provider: "neuralwatt",
-      contextWindow: 200000,
-    });
-    registerBeforeCompactHook(pi);
-
-    // 100k tokens < 160000 → below threshold, but proceeds
-    const entries = [
-      msg("m1", "user", "hello"),
-      msg("m2", "assistant", "hi"),
-      msg("m3", "user", "do work"),
-      msg("m4", "assistant", "done"),
-    ];
-    const result = emit("session_before_compact", makeEvent(entries, undefined, 100000));
-    expect(result.cancel).toBeUndefined();
-    expect(result.compaction).toBeDefined();
-  });
-
-  test("compaction proceeds with defaultThreshold", () => {
-    setConfig({
-      debug: false,
-      overrideDefaultCompaction: true,
-      defaultThreshold: { reserveTokens: 16384 },
-    });
-    const { pi, ctx, emit } = createMockPi({
-      id: "some-model",
-      provider: "some-provider",
-      contextWindow: 128000,
-    });
-    registerBeforeCompactHook(pi);
-
-    // 50k tokens < 128k - 16384 = 111616 → below threshold, but proceeds
-    const entries = [
-      msg("m1", "user", "hello"),
-      msg("m2", "assistant", "hi"),
-      msg("m3", "user", "do work"),
-      msg("m4", "assistant", "done"),
-    ];
-    const result = emit("session_before_compact", makeEvent(entries, undefined, 50000));
-    expect(result.cancel).toBeUndefined();
-    expect(result.compaction).toBeDefined();
-  });
-
-  test("does NOT cancel on /pi-vcc even when below threshold", () => {
-    setConfig({
-      debug: false,
-      overrideDefaultCompaction: true,
-      modelThresholds: {
-        "neuralwatt/GLM-5.1": { reserveTokens: 32768 },
-      },
-    });
-    const { pi, ctx, emit } = createMockPi({
-      id: "GLM-5.1",
-      provider: "neuralwatt",
-      contextWindow: 200000,
-    });
-    registerBeforeCompactHook(pi);
-
-    // Below threshold, but explicit /pi-vcc command
-    const entries = [
-      msg("m1", "user", "hello"),
-      msg("m2", "assistant", "hi"),
-      msg("m3", "user", "do work"),
-      msg("m4", "assistant", "done"),
-    ];
-    const result = emit("session_before_compact", makeEvent(entries, PI_VCC_COMPACT_INSTRUCTION, 100000));
-    expect(result.cancel).toBeUndefined();
-    expect(result.compaction).toBeDefined();
-  });
-
-  test("compaction proceeds when no modelThresholds configured", () => {
-    setConfig({
-      debug: false,
-      overrideDefaultCompaction: true,
-    });
-    const { pi, ctx, emit } = createMockPi({
-      id: "GLM-5.1",
-      provider: "neuralwatt",
-      contextWindow: 200000,
-    });
-    registerBeforeCompactHook(pi);
-
-    const entries = [
-      msg("m1", "user", "hello"),
-      msg("m2", "assistant", "hi"),
-      msg("m3", "user", "do work"),
-      msg("m4", "assistant", "done"),
-    ];
-    const result = emit("session_before_compact", makeEvent(entries, undefined, 100000));
-    expect(result.cancel === true).toBe(false);
-  });
-
-  test("compaction proceeds when model is undefined", () => {
-    setConfig({
-      debug: false,
-      overrideDefaultCompaction: true,
-      modelThresholds: {
-        "GLM-5.1": { reserveTokens: 32768 },
-      },
-    });
-    const { pi, ctx, emit } = createMockPi(undefined);
-    registerBeforeCompactHook(pi);
-
-    const entries = [
-      msg("m1", "user", "hello"),
-      msg("m2", "assistant", "hi"),
-      msg("m3", "user", "do work"),
-      msg("m4", "assistant", "done"),
-    ];
-    const result = emit("session_before_compact", makeEvent(entries, undefined, 100000));
-    expect(result.cancel === true).toBe(false);
-  });
-
-  test("compaction proceeds with overrideDefaultCompaction false", () => {
-    setConfig({
-      debug: false,
-      overrideDefaultCompaction: false,
-      modelThresholds: {
-        "neuralwatt/GLM-5.1": { reserveTokens: 32768 },
-      },
-    });
-    const { pi, ctx, emit } = createMockPi({
-      id: "GLM-5.1",
-      provider: "neuralwatt",
-      contextWindow: 200000,
-    });
-    registerBeforeCompactHook(pi);
-
-    // Below threshold, overrideDefaultCompaction: false → pi-vcc doesn't
-    // handle the summary, but also doesn't cancel (threshold guard removed)
-    const entries = [
-      msg("m1", "user", "hello"),
-      msg("m2", "assistant", "hi"),
-    ];
-    const result = emit("session_before_compact", makeEvent(entries, undefined, 100000));
-    // Not cancelled — returns undefined (pi-vcc doesn't handle it)
-    expect(result).toBeUndefined();
-  });
-});

package/tests/model-threshold.test.ts

@@ -1,223 +0,0 @@
-import { describe, test, expect } from "bun:test";
-import { getModelThreshold, resolveReserveTokens, type PiVccSettings, type ModelThreshold } from "../src/core/settings";
-
-const t = (reserveTokens: number, keepRecentTokens?: number): ModelThreshold => ({
-  reserveTokens,
-  ...(keepRecentTokens !== undefined ? { keepRecentTokens } : {}),
-});
-
-describe("getModelThreshold", () => {
-  test("returns undefined when no modelThresholds and no defaultThreshold", () => {
-    const settings: PiVccSettings = {
-      overrideDefaultCompaction: true,
-      debug: false,
-    };
-    expect(getModelThreshold(settings, { id: "GLM-5.1", provider: "neuralwatt" })).toBeUndefined();
-  });
-
-  test("returns undefined when model is undefined and no defaultThreshold", () => {
-    const settings: PiVccSettings = {
-      overrideDefaultCompaction: true,
-      debug: false,
-      modelThresholds: { "neuralwatt/GLM-5.1": t(32768) },
-    };
-    expect(getModelThreshold(settings, undefined)).toBeUndefined();
-  });
-
-  test("returns defaultThreshold when model doesn't match any key", () => {
-    const settings: PiVccSettings = {
-      overrideDefaultCompaction: true,
-      debug: false,
-      modelThresholds: { "neuralwatt/GLM-5.1": t(32768) },
-      defaultThreshold: t(8192),
-    };
-    expect(getModelThreshold(settings, { id: "other-model", provider: "other" })).toEqual(t(8192));
-  });
-
-  test("returns defaultThreshold when model is undefined", () => {
-    const settings: PiVccSettings = {
-      overrideDefaultCompaction: true,
-      debug: false,
-      defaultThreshold: t(8192),
-    };
-    expect(getModelThreshold(settings, undefined)).toEqual(t(8192));
-  });
-
-  test("matches on provider/modelId key", () => {
-    const threshold = t(32768, 40000);
-    const settings: PiVccSettings = {
-      overrideDefaultCompaction: true,
-      debug: false,
-      modelThresholds: {
-        "neuralwatt/zai-org/GLM-5.1-FP8": threshold,
-      },
-      defaultThreshold: t(8192),
-    };
-    expect(getModelThreshold(settings, { id: "zai-org/GLM-5.1-FP8", provider: "neuralwatt" })).toEqual(threshold);
-  });
-
-  test("matches on modelId-only key when provider/modelId not found", () => {
-    const threshold = t(16384);
-    const settings: PiVccSettings = {
-      overrideDefaultCompaction: true,
-      debug: false,
-      modelThresholds: {
-        "zai-org/GLM-5.1-FP8": threshold,
-      },
-      defaultThreshold: t(8192),
-    };
-    // provider/modelId doesn't match, but modelId does
-    expect(getModelThreshold(settings, { id: "zai-org/GLM-5.1-FP8", provider: "other-provider" })).toEqual(threshold);
-  });
-
-  test("provider/modelId takes precedence over modelId-only key", () => {
-    const providerThreshold = t(32768);
-    const modelIdThreshold = t(16384);
-    const settings: PiVccSettings = {
-      overrideDefaultCompaction: true,
-      debug: false,
-      modelThresholds: {
-        "neuralwatt/GLM-5.1": providerThreshold,
-        "GLM-5.1": modelIdThreshold,
-      },
-    };
-    expect(getModelThreshold(settings, { id: "GLM-5.1", provider: "neuralwatt" })).toEqual(providerThreshold);
-  });
-
-  test("falls through to modelId-only when provider is absent", () => {
-    const threshold = t(16384);
-    const settings: PiVccSettings = {
-      overrideDefaultCompaction: true,
-      debug: false,
-      modelThresholds: {
-        "GLM-5.1": threshold,
-      },
-    };
-    expect(getModelThreshold(settings, { id: "GLM-5.1" })).toEqual(threshold);
-  });
-
-  test("falls through to defaultThreshold when neither key matches", () => {
-    const settings: PiVccSettings = {
-      overrideDefaultCompaction: true,
-      debug: false,
-      modelThresholds: {
-        "neuralwatt/GLM-5.1": t(32768),
-      },
-      defaultThreshold: t(8192),
-    };
-    expect(getModelThreshold(settings, { id: "Kimi-K2.6", provider: "neuralwatt" })).toEqual(t(8192));
-  });
-
-  test("returns globalThreshold when model doesn't match any key", () => {
-    const threshold: ModelThreshold = { compactPercent: 65 };
-    const settings: PiVccSettings = {
-      overrideDefaultCompaction: true,
-      debug: false,
-      modelThresholds: { "neuralwatt/GLM-5.1": t(32768) },
-      globalThreshold: threshold,
-    };
-    expect(getModelThreshold(settings, { id: "other-model", provider: "other" })).toEqual(threshold);
-  });
-
-  test("globalThreshold takes precedence over defaultThreshold", () => {
-    const settings: PiVccSettings = {
-      overrideDefaultCompaction: true,
-      debug: false,
-      globalThreshold: t(65536),
-      defaultThreshold: t(8192),
-    };
-    expect(getModelThreshold(settings, { id: "unknown", provider: "other" })).toEqual(t(65536));
-  });
-
-  test("returns globalThreshold when model is undefined", () => {
-    const threshold: ModelThreshold = { compactPercent: 70 };
-    const settings: PiVccSettings = {
-      overrideDefaultCompaction: true,
-      debug: false,
-      globalThreshold: threshold,
-    };
-    expect(getModelThreshold(settings, undefined)).toEqual(threshold);
-  });
-
-  test("falls back to defaultThreshold when globalThreshold is not set", () => {
-    const settings: PiVccSettings = {
-      overrideDefaultCompaction: true,
-      debug: false,
-      defaultThreshold: t(8192),
-    };
-    expect(getModelThreshold(settings, { id: "unknown", provider: "other" })).toEqual(t(8192));
-  });
-
-  test("works with multiple modelThresholds entries", () => {
-    const settings: PiVccSettings = {
-      overrideDefaultCompaction: true,
-      debug: false,
-      modelThresholds: {
-        "neuralwatt/zai-org/GLM-5.1-FP8": t(32768),
-        "neuralwatt/moonshotai/Kimi-K2.6": t(65536),
-        "makora/deepseek-ai/DeepSeek-V4-Pro": t(32768),
-      },
-      defaultThreshold: t(16384),
-    };
-
-    expect(getModelThreshold(settings, { id: "zai-org/GLM-5.1-FP8", provider: "neuralwatt" })).toEqual(t(32768));
-    expect(getModelThreshold(settings, { id: "moonshotai/Kimi-K2.6", provider: "neuralwatt" })).toEqual(t(65536));
-    expect(getModelThreshold(settings, { id: "deepseek-ai/DeepSeek-V4-Pro", provider: "makora" })).toEqual(t(32768));
-    expect(getModelThreshold(settings, { id: "unknown-model", provider: "other" })).toEqual(t(16384));
-  });
-});
-
-describe("resolveReserveTokens", () => {
-  test("returns reserveTokens when set", () => {
-    expect(resolveReserveTokens({ reserveTokens: 32768 }, 128000)).toBe(32768);
-  });
-
-  test("returns undefined when neither reserveTokens nor compactPercent is set", () => {
-    expect(resolveReserveTokens({}, 128000)).toBeUndefined();
-  });
-
-  test("returns undefined when only keepRecentTokens is set", () => {
-    expect(resolveReserveTokens({ keepRecentTokens: 20000 }, 128000)).toBeUndefined();
-  });
-
-  test("computes reserveTokens from compactPercent", () => {
-    // compactPercent: 65 on 128k window → reserve = 128000 * (1 - 65/100) = 44800
-    expect(resolveReserveTokens({ compactPercent: 65 }, 128000)).toBe(44800);
-  });
-
-  test("compactPercent: 50 → reserve is exactly half", () => {
-    expect(resolveReserveTokens({ compactPercent: 50 }, 200000)).toBe(100000);
-  });
-
-  test("compactPercent: 80 → reserve is 20%", () => {
-    expect(resolveReserveTokens({ compactPercent: 80 }, 200000)).toBe(40000);
-  });
-
-  test("reserveTokens takes precedence over compactPercent", () => {
-    expect(resolveReserveTokens({ reserveTokens: 32768, compactPercent: 65 }, 128000)).toBe(32768);
-  });
-
-  test("returns undefined for compactPercent < 1", () => {
-    expect(resolveReserveTokens({ compactPercent: 0 }, 128000)).toBeUndefined();
-  });
-
-  test("returns undefined for compactPercent > 99", () => {
-    expect(resolveReserveTokens({ compactPercent: 100 }, 128000)).toBeUndefined();
-  });
-
-  test("returns undefined when contextWindow is 0", () => {
-    expect(resolveReserveTokens({ compactPercent: 65 }, 0)).toBeUndefined();
-  });
-
-  test("reserveTokens still works when contextWindow is 0", () => {
-       expect(resolveReserveTokens({ reserveTokens: 32768 }, 0)).toBe(32768);
-  });
-
-  test("compactPercent = 1 → reserve is 99% of contextWindow", () => {
-    expect(resolveReserveTokens({ compactPercent: 1 }, 128000)).toBe(126720);
-  });
-
-  test("compactPercent = 99 → reserve is 1% of contextWindow", () => {
-    expect(resolveReserveTokens({ compactPercent: 99 }, 128000)).toBe(1280);
-  });
-});

package/tests/normalize.test.ts

@@ -1,104 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import { normalize } from "../src/core/normalize";
-import {
-  userMsg,
-  assistantText,
-  assistantWithThinking,
-  assistantWithToolCall,
-  toolResult,
-} from "./fixtures";
-
-describe("normalize", () => {
-  it("returns empty for empty input", () => {
-    expect(normalize([])).toEqual([]);
-  });
-
-  it("normalizes user message (string content)", () => {
-    const blocks = normalize([userMsg("fix the bug")]);
-    expect(blocks).toEqual([{ kind: "user", text: "fix the bug", sourceIndex: 0 }]);
-  });
-
-  it("normalizes assistant text message", () => {
-    const blocks = normalize([assistantText("done")]);
-    expect(blocks).toEqual([{ kind: "assistant", text: "done", sourceIndex: 0 }]);
-  });
-
-  it("normalizes assistant string content", () => {
-    const msg = { ...assistantText("done"), content: "plain text" } as any;
-    expect(normalize([msg])).toEqual([{ kind: "assistant", text: "plain text", sourceIndex: 0 }]);
-  });
-
-  it("splits assistant thinking + text", () => {
-    const blocks = normalize([assistantWithThinking("result", "hmm")]);
-    expect(blocks).toHaveLength(2);
-    expect(blocks[0]).toEqual({
-      kind: "thinking", text: "hmm", redacted: false, sourceIndex: 0,
-    });
-    expect(blocks[1]).toEqual({ kind: "assistant", text: "result", sourceIndex: 0 });
-  });
-
-  it("normalizes tool call", () => {
-    const blocks = normalize([assistantWithToolCall("Read", { path: "a.ts" })]);
-    expect(blocks).toEqual([{
-      kind: "tool_call", name: "Read", args: { path: "a.ts" }, sourceIndex: 0,
-    }]);
-  });
-
-  it("normalizes tool result", () => {
-    const blocks = normalize([toolResult("Read", "file contents")]);
-    expect(blocks).toEqual([{
-      kind: "tool_result", name: "Read",
-      text: "file contents", isError: false, sourceIndex: 0,
-    }]);
-  });
-
-  it("normalizes error tool result", () => {
-    const blocks = normalize([toolResult("Edit", "not found", true)]);
-    expect(blocks[0]).toMatchObject({
-      kind: "tool_result", isError: true,
-    });
-  });
-
-  it("handles mixed message sequence", () => {
-    const blocks = normalize([
-      userMsg("fix it"),
-      assistantWithToolCall("Read", { path: "x.ts" }),
-      toolResult("Read", "code"),
-      assistantText("done"),
-    ]);
-    expect(blocks).toHaveLength(4);
-    expect(blocks.map((b) => b.kind)).toEqual([
-      "user", "tool_call", "tool_result", "assistant",
-    ]);
-  });
-
-  it("produces image placeholder for user image content", () => {
-    const msg = {
-      role: "user" as const,
-      content: [
-        { type: "text" as const, text: "look at this" },
-        { type: "image" as const, data: "abc", mimeType: "image/png" },
-      ],
-      timestamp: Date.now(),
-    };
-    const blocks = normalize([msg]);
-    expect(blocks).toHaveLength(2);
-    expect(blocks[0]).toEqual({ kind: "user", text: "look at this", sourceIndex: 0 });
-    expect(blocks[1]).toEqual({ kind: "user", text: "[image: image/png]", sourceIndex: 0 });
-  });
-
-  it("normalizes bashExecution messages", () => {
-    const msg = { role: "bashExecution", command: "ls -la", output: "files", exitCode: 0 } as any;
-    const blocks = normalize([msg]);
-    expect(blocks).toEqual([
-      { kind: "bash", command: "ls -la", output: "files", exitCode: 0, sourceIndex: 0 },
-    ]);
-  });
-
-  it("skips truly unknown message roles gracefully", () => {
-    const custom = { role: "custom", content: "hello" } as any;
-    expect(normalize([custom])).toEqual([]);
-  });
-});
-
-