@pi-harness/pi-harness 0.1.13 → 0.1.14

package/packages/core/test/session-insights.test.ts

@@ -0,0 +1,486 @@
+import { Context } from "@deepseek-ai/cordis";
+import { afterEach, describe, expect, test, vi } from "vitest";
+import sessionInsightsPlugin from "../src/plugins/session-insights.js";
+import { PiPluginUiRegistry, PiToolRegistry } from "../src/services.js";
+
+const contexts: Context[] = [];
+
+afterEach(async () => {
+  await Promise.all(contexts.splice(0).map(async (context) => context.fiber.dispose()));
+});
+
+function stats(overrides: Record<string, unknown> = {}): Record<string, unknown> {
+  return {
+    sessionFile: undefined,
+    sessionId: "session-1",
+    userMessages: 2,
+    assistantMessages: 2,
+    toolCalls: 1,
+    toolResults: 1,
+    totalMessages: 5,
+    tokens: { input: 10, output: 20, cacheRead: 3, cacheWrite: 2, total: 35 },
+    cost: 0.012_345,
+    contextUsage: { tokens: 250, contextWindow: 1_000, percent: 25 },
+    ...overrides,
+  };
+}
+
+async function fixture(session: unknown = { isIdle: true, getSessionStats: () => stats(), compact: () => Promise.resolve() }) {
+  const context = new Context();
+  contexts.push(context);
+  const panels = new PiPluginUiRegistry();
+  const tools = new PiToolRegistry();
+  context.provide("piRuntime", { session } as never);
+  context.provide("piTools", tools);
+  context.provide("piPluginUi", panels);
+  await context.plugin(sessionInsightsPlugin);
+  const tool = tools.snapshot().customTools.find((candidate) => candidate.name === "session_report");
+  if (tool === undefined) throw new Error("session_report was not registered");
+  return { context, panels, tool, tools };
+}
+
+describe("session-insights", () => {
+  test("declares a strict sequential report and confirmed-compaction contract", async () => {
+    const { tool } = await fixture();
+
+    expect(sessionInsightsPlugin).toHaveProperty("Config");
+    expect(tool.executionMode).toBe("sequential");
+    expect(tool.parameters).toMatchObject({
+      type: "object",
+      additionalProperties: false,
+      properties: { compact: { type: "boolean" }, confirm: { type: "boolean" } },
+    });
+    expect(tool.promptGuidelines?.join(" ")).toMatch(/confirm.*model.*usage.*cost/iu);
+  });
+
+  test("rejects malformed raw parameters without invoking accessors", async () => {
+    let getterCalls = 0;
+    const accessor = Object.defineProperty({}, "compact", {
+      enumerable: true,
+      get() {
+        getterCalls += 1;
+        return true;
+      },
+    });
+    const withSymbol = { [Symbol("extra")]: true };
+    const revocable = Proxy.revocable({}, {});
+    revocable.revoke();
+    const hostile = new Error();
+    Object.defineProperty(hostile, "message", {
+      get() {
+        getterCalls += 1;
+        throw new Error("error message getter executed");
+      },
+    });
+    const throwingProxy = new Proxy(
+      {},
+      {
+        getPrototypeOf() {
+          throw hostile;
+        },
+      },
+    );
+    const { tool } = await fixture();
+
+    for (const parameters of [null, [], new Date(), { compact: "yes" }, { confirm: 1 }, { extra: true }, withSymbol, accessor]) {
+      await expect(tool.execute("invalid", parameters as never, undefined, undefined, {} as never)).rejects.toThrow(/session report parameters/iu);
+    }
+    await expect(tool.execute("proxy", revocable.proxy, undefined, undefined, {} as never)).rejects.toThrow(/inspected safely/iu);
+    await expect(tool.execute("throwing-proxy", throwingProxy, undefined, undefined, {} as never)).rejects.toThrow(/inspected safely/iu);
+    await expect(tool.execute("unconfirmed", { compact: true }, undefined, undefined, {} as never)).rejects.toThrow(/confirm=true/iu);
+    expect(getterCalls).toBe(0);
+  });
+
+  test("rejects unknown configuration before registering any surface", async () => {
+    const context = new Context();
+    contexts.push(context);
+    const panels = new PiPluginUiRegistry();
+    const tools = new PiToolRegistry();
+    context.provide("piTools", tools);
+    context.provide("piPluginUi", panels);
+
+    await expect(context.plugin(sessionInsightsPlugin, { unexpected: true })).rejects.toThrow(/unknown.*session-insights.*config/iu);
+    expect(() => sessionInsightsPlugin.apply(context, { [Symbol("unexpected")]: true })).toThrow(/unknown.*session-insights.*config/iu);
+    let getterCalls = 0;
+    const hostile = new Error();
+    Object.defineProperty(hostile, "message", {
+      get() {
+        getterCalls += 1;
+        throw new Error("config error message getter executed");
+      },
+    });
+    const throwingProxy = new Proxy(
+      {},
+      {
+        ownKeys() {
+          throw hostile;
+        },
+      },
+    );
+    expect(() => sessionInsightsPlugin.apply(context, throwingProxy)).toThrow(/config could not be inspected safely/iu);
+    expect(getterCalls).toBe(0);
+    expect(tools.snapshot().customTools).toEqual([]);
+    await expect(panels.snapshot()).resolves.toEqual([]);
+  });
+
+  test("validates and detaches complete session statistics", async () => {
+    const source = stats();
+    const { panels, tool } = await fixture({ isIdle: true, getSessionStats: () => source, compact: () => Promise.resolve() });
+
+    const result = await tool.execute("report", {}, undefined, undefined, {} as never);
+    expect(result.details).toMatchObject({
+      sessionFile: null,
+      sessionId: "session-1",
+      userMessages: 2,
+      assistantMessages: 2,
+      toolCalls: 1,
+      toolResults: 1,
+      totalMessages: 5,
+      tokens: { input: 10, output: 20, cacheRead: 3, cacheWrite: 2, total: 35 },
+      cost: 0.012_345,
+      contextUsage: { tokens: 250, contextWindow: 1_000, percent: 25 },
+      compaction: { status: "idle" },
+    });
+    const details = result.details as { tokens: { total: number }; contextUsage: { tokens: number }; compaction: { status: string } };
+    details.tokens.total = 999;
+    details.contextUsage.tokens = 999;
+    details.compaction.status = "failed";
+    (source.tokens as { total: number }).total = 777;
+
+    await expect(panels.snapshot()).resolves.toMatchObject([
+      {
+        id: "session-insights-panel",
+        data: {
+          tokens: { total: 35 },
+          contextUsage: { tokens: 250 },
+          compaction: { status: "idle" },
+        },
+      },
+    ]);
+  });
+
+  test("fails closed for malformed or inconsistent session statistics", async () => {
+    const malformed = [
+      null,
+      [],
+      stats({ sessionId: "" }),
+      stats({ userMessages: -1 }),
+      stats({ cost: Number.NaN }),
+      stats({ totalMessages: 4 }),
+      stats({ tokens: { input: 10, output: 20, cacheRead: 3, cacheWrite: 2, total: 34 } }),
+      stats({ contextUsage: { tokens: null, contextWindow: 1_000, percent: 25 } }),
+      stats({ contextUsage: { tokens: 250, contextWindow: 1_000, percent: 24 } }),
+    ];
+    for (const report of malformed) {
+      const { panels, tool } = await fixture({ isIdle: true, getSessionStats: () => report, compact: () => Promise.resolve() });
+      await expect(tool.execute("malformed", {}, undefined, undefined, {} as never)).rejects.toThrow(/session statistics.*invalid/iu);
+      const panelError = (await panels.snapshot())[0]?.error;
+      expect(panelError).toMatch(/session statistics.*invalid/iu);
+    }
+  });
+
+  test("does not invoke accessors while inspecting session statistics", async () => {
+    let accesses = 0;
+    const source = stats();
+    Object.defineProperty(source, "cost", {
+      enumerable: true,
+      get() {
+        accesses += 1;
+        throw new Error("cost getter executed");
+      },
+    });
+    const nested = stats();
+    Object.defineProperty(nested.tokens, "total", {
+      enumerable: true,
+      get() {
+        accesses += 1;
+        throw new Error("token getter executed");
+      },
+    });
+    const revocable = Proxy.revocable({}, {});
+    revocable.revoke();
+
+    for (const report of [source, nested, revocable.proxy]) {
+      const { tool } = await fixture({ isIdle: true, getSessionStats: () => report, compact: () => Promise.resolve() });
+      await expect(tool.execute("hostile", {}, undefined, undefined, {} as never)).rejects.toThrow(/session statistics.*invalid/iu);
+    }
+    expect(accesses).toBe(0);
+  });
+
+  test("bounds upstream statistics failures without invoking error accessors", async () => {
+    let accesses = 0;
+    const hostile = new Error();
+    Object.defineProperty(hostile, "message", {
+      get() {
+        accesses += 1;
+        throw new Error("statistics error getter executed");
+      },
+    });
+    let attempt = 0;
+    const { panels, tool } = await fixture({
+      isIdle: true,
+      getSessionStats() {
+        throw ++attempt === 1 ? new Error("x".repeat(3_000)) : hostile;
+      },
+      compact: () => Promise.resolve(),
+    });
+
+    await expect(tool.execute("long", {}, undefined, undefined, {} as never)).rejects.toThrow(/session statistics inspection failed/iu);
+    let error = (await panels.snapshot())[0]?.error;
+    expect(error).toHaveLength(2_000);
+    await expect(tool.execute("hostile", {}, undefined, undefined, {} as never)).rejects.toThrow(/session statistics inspection failed.*unknown error/iu);
+    error = (await panels.snapshot())[0]?.error;
+    expect(error).toBe("Session statistics inspection failed: unknown error");
+    expect(accesses).toBe(0);
+  });
+
+  test("serves panel polls from cache and refreshes on tools, lifecycle events, and session changes", async () => {
+    let calls = 0;
+    let current = stats();
+    const firstSession = {
+      isIdle: true,
+      getSessionStats() {
+        calls += 1;
+        return current;
+      },
+      compact: () => Promise.resolve(),
+    };
+    const { context, panels, tool } = await fixture(firstSession);
+
+    await expect(panels.snapshot()).resolves.toMatchObject([{ data: { totalMessages: 5 } }]);
+    current = stats({ totalMessages: 6 });
+    await expect(panels.snapshot()).resolves.toMatchObject([{ data: { totalMessages: 5 } }]);
+    expect(calls).toBe(1);
+
+    await expect(tool.execute("refresh", {}, undefined, undefined, {} as never)).resolves.toMatchObject({ details: { totalMessages: 6 } });
+    expect(calls).toBe(2);
+    current = stats({ totalMessages: 7 });
+    context.emit("pi/session-event", { type: "message_end" } as never);
+    await expect(panels.snapshot()).resolves.toMatchObject([{ data: { totalMessages: 7 } }]);
+    expect(calls).toBe(3);
+
+    context.reflect.set("piRuntime", {
+      session: {
+        isIdle: true,
+        getSessionStats: () => stats({ sessionId: "session-2", userMessages: 1, assistantMessages: 0, toolCalls: 0, toolResults: 0, totalMessages: 1 }),
+        compact: () => Promise.resolve(),
+      },
+    });
+    await expect(panels.snapshot()).resolves.toMatchObject([{ data: { sessionId: "session-2", totalMessages: 1 } }]);
+  });
+
+  test("runs confirmed compaction only while idle and refreshes its completed report", async () => {
+    let current = stats();
+    let compactions = 0;
+    const { tool } = await fixture({
+      isIdle: true,
+      getSessionStats: () => current,
+      compact: () => {
+        compactions += 1;
+        current = stats({
+          userMessages: 1,
+          assistantMessages: 1,
+          toolCalls: 0,
+          toolResults: 1,
+          totalMessages: 3,
+          contextUsage: { tokens: null, contextWindow: 1_000, percent: null },
+        });
+        return Promise.resolve();
+      },
+      abortCompaction: () => undefined,
+    });
+
+    await expect(tool.execute("compact", { compact: true, confirm: true }, undefined, undefined, {} as never)).resolves.toMatchObject({
+      details: { totalMessages: 3, compaction: { status: "completed" } },
+    });
+    expect(compactions).toBe(1);
+  });
+
+  test("queues confirmed compaction until an active agent run settles and enforces single flight", async () => {
+    let compactions = 0;
+    const { context, panels, tool } = await fixture({
+      isIdle: false,
+      getSessionStats: () => stats(),
+      compact: () => {
+        compactions += 1;
+        return Promise.resolve();
+      },
+      abortCompaction: () => undefined,
+    });
+
+    await expect(tool.execute("queued", { compact: true, confirm: true }, undefined, undefined, {} as never)).resolves.toMatchObject({
+      details: { compaction: { status: "queued" } },
+    });
+    expect(compactions).toBe(0);
+    await expect(tool.execute("duplicate", { compact: true, confirm: true }, undefined, undefined, {} as never)).rejects.toThrow(/already.*progress/iu);
+
+    context.emit("pi/session-event", { type: "agent_settled" } as never);
+    await vi.waitFor(() => expect(compactions).toBe(1));
+    await expect.poll(async () => (await panels.snapshot())[0]?.data).toMatchObject({ compaction: { status: "completed" } });
+  });
+
+  test("cancels queued compaction when its caller aborts or the session changes", async () => {
+    let compactions = 0;
+    const controller = new AbortController();
+    const { context, panels, tool } = await fixture({
+      isIdle: false,
+      getSessionStats: () => stats(),
+      compact: () => {
+        compactions += 1;
+        return Promise.resolve();
+      },
+      abortCompaction: () => undefined,
+    });
+    await tool.execute("queued", { compact: true, confirm: true }, controller.signal, undefined, {} as never);
+    controller.abort(new Error("caller cancelled queued compaction"));
+    await expect.poll(async () => (await panels.snapshot())[0]?.data).toMatchObject({ compaction: { status: "cancelled" } });
+    context.emit("pi/session-event", { type: "agent_settled" } as never);
+    expect(compactions).toBe(0);
+
+    await tool.execute("queued-again", { compact: true, confirm: true }, undefined, undefined, {} as never);
+    context.reflect.set("piRuntime", {
+      session: { isIdle: true, getSessionStats: () => stats({ sessionId: "replacement" }), compact: () => Promise.resolve() },
+    });
+    await expect(panels.snapshot()).resolves.toMatchObject([{ data: { sessionId: "replacement", compaction: { status: "cancelled" } } }]);
+    context.emit("pi/session-event", { type: "agent_settled" } as never);
+    expect(compactions).toBe(0);
+  });
+
+  test("uses dedicated compaction cancellation for caller abort and plugin disposal", async () => {
+    let aborts = 0;
+    let resolveCompact: (() => void) | undefined;
+    const first = await fixture({
+      isIdle: true,
+      getSessionStats: () => stats(),
+      compact: () =>
+        new Promise<void>((resolve) => {
+          resolveCompact = resolve;
+        }),
+      abortCompaction: () => {
+        aborts += 1;
+      },
+    });
+    const controller = new AbortController();
+    const execution = first.tool.execute("active", { compact: true, confirm: true }, controller.signal, undefined, {} as never);
+    await vi.waitFor(() => expect(resolveCompact).toBeDefined());
+    controller.abort(new Error("caller cancelled active compaction"));
+    resolveCompact?.();
+    await expect(execution).rejects.toThrow(/caller cancelled active compaction/iu);
+    expect(aborts).toBe(1);
+
+    let resolveDisposed: (() => void) | undefined;
+    const second = await fixture({
+      isIdle: true,
+      getSessionStats: () => stats(),
+      compact: () =>
+        new Promise<void>((resolve) => {
+          resolveDisposed = resolve;
+        }),
+      abortCompaction: () => {
+        aborts += 1;
+      },
+    });
+    const disposedExecution = second.tool.execute("dispose", { compact: true, confirm: true }, undefined, undefined, {} as never);
+    await vi.waitFor(() => expect(resolveDisposed).toBeDefined());
+    await second.context.fiber.dispose();
+    resolveDisposed?.();
+    await expect(disposedExecution).rejects.toThrow(/disposed/iu);
+    expect(aborts).toBe(2);
+    await expect(second.tool.execute("stale", {}, undefined, undefined, {} as never)).rejects.toThrow(/disposed/iu);
+  });
+
+  test("cancels in-flight compaction when the active session is replaced", async () => {
+    let aborts = 0;
+    let resolveCompact: (() => void) | undefined;
+    const oldSession = {
+      isIdle: true,
+      getSessionStats: () => stats(),
+      compact: () =>
+        new Promise<void>((resolve) => {
+          resolveCompact = resolve;
+        }),
+      abortCompaction: () => {
+        aborts += 1;
+      },
+    };
+    const { context, panels, tool } = await fixture(oldSession);
+    const execution = tool.execute("replace", { compact: true, confirm: true }, undefined, undefined, {} as never);
+    await vi.waitFor(() => expect(resolveCompact).toBeDefined());
+
+    context.reflect.set("piRuntime", {
+      session: {
+        isIdle: true,
+        getSessionStats: () => stats({ sessionId: "replacement" }),
+        compact: () => Promise.resolve(),
+        abortCompaction: () => undefined,
+      },
+    });
+    await panels.snapshot();
+    await expect(execution).rejects.toThrow(/session changed/iu);
+    expect(aborts).toBe(1);
+    await expect
+      .poll(async () => ((await panels.snapshot())[0]?.data as { compaction?: { status?: unknown } } | undefined)?.compaction?.status)
+      .toBe("cancelled");
+    const replacement = (await panels.snapshot())[0]?.data as { sessionId: string; compaction: { error: string } };
+    expect(replacement.sessionId).toBe("replacement");
+    expect(replacement.compaction.error).toMatch(/session changed/iu);
+    resolveCompact?.();
+  });
+
+  test("records bounded descriptor-safe compaction failures", async () => {
+    let accesses = 0;
+    const hostile = new Error();
+    Object.defineProperty(hostile, "message", {
+      get() {
+        accesses += 1;
+        throw new Error("error getter executed");
+      },
+    });
+    let attempt = 0;
+    const { panels, tool } = await fixture({
+      isIdle: true,
+      getSessionStats: () => stats(),
+      compact: () => Promise.reject(++attempt === 1 ? new Error("x".repeat(3_000)) : hostile),
+      abortCompaction: () => undefined,
+    });
+
+    await expect(tool.execute("long", { compact: true, confirm: true }, undefined, undefined, {} as never)).rejects.toThrow();
+    let state = ((await panels.snapshot())[0]?.data as { compaction: { error: string; status: string } }).compaction;
+    expect(state).toMatchObject({ status: "failed" });
+    expect(state.error).toHaveLength(2_000);
+    await expect(tool.execute("hostile", { compact: true, confirm: true }, undefined, undefined, {} as never)).rejects.toBe(hostile);
+    state = ((await panels.snapshot())[0]?.data as { compaction: { error: string; status: string } }).compaction;
+    expect(state).toEqual(expect.objectContaining({ status: "failed", error: "Unknown session compaction error" }));
+    expect(accesses).toBe(0);
+  });
+
+  test("rolls back every registration when the panel id is unavailable", async () => {
+    const context = new Context();
+    contexts.push(context);
+    const panels = new PiPluginUiRegistry();
+    const tools = new PiToolRegistry();
+    panels.register({ id: "session-insights-panel", pluginId: "fixture", title: "Fixture", read: () => ({}) });
+    context.provide("piTools", tools);
+    context.provide("piPluginUi", panels);
+
+    await expect(context.plugin(sessionInsightsPlugin)).rejects.toThrow(/panel is already registered/iu);
+    expect(tools.snapshot().customTools).toEqual([]);
+    await expect(panels.snapshot()).resolves.toMatchObject([{ pluginId: "fixture" }]);
+  });
+
+  test("reports a stable unavailable-runtime error and recovers after runtime activation", async () => {
+    const context = new Context();
+    contexts.push(context);
+    const panels = new PiPluginUiRegistry();
+    const tools = new PiToolRegistry();
+    context.provide("piTools", tools);
+    context.provide("piPluginUi", panels);
+    await context.plugin(sessionInsightsPlugin);
+    const tool = tools.snapshot().customTools.find((candidate) => candidate.name === "session_report")!;
+
+    await expect(tool.execute("missing", {}, undefined, undefined, {} as never)).rejects.toThrow(/^Pi runtime is not ready$/u);
+    await expect(panels.snapshot()).resolves.toMatchObject([{ error: "Pi runtime is not ready" }]);
+    context.provide("piRuntime", { session: { isIdle: true, getSessionStats: () => stats(), compact: () => Promise.resolve() } } as never);
+    await expect(panels.snapshot()).resolves.toMatchObject([{ data: { sessionId: "session-1" } }]);
+  });
+});

package/packages/core/test/session.test.ts

@@ -0,0 +1,153 @@
+import { access, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Context } from "@deepseek-ai/cordis";
+import { SessionManager } from "@earendil-works/pi-coding-agent";
+import { afterEach, describe, expect, test } from "vitest";
+import sessionPlugin, { Config as SessionConfig } from "../src/plugins/session.js";
+import { provideLaunchContext } from "../src/services.js";
+
+const contexts: Context[] = [];
+const temporaryDirectories: string[] = [];
+
+afterEach(async () => {
+  await Promise.all(contexts.splice(0).map(async (context) => context.fiber.dispose()));
+  await Promise.all(temporaryDirectories.splice(0).map(async (directory) => rm(directory, { recursive: true, force: true })));
+});
+
+async function createContext(): Promise<{ context: Context; cwd: string; agentDir: string }> {
+  const cwd = await mkdtemp(join(tmpdir(), "pi-harness-session-cwd-"));
+  const agentDir = await mkdtemp(join(tmpdir(), "pi-harness-session-agent-"));
+  temporaryDirectories.push(cwd, agentDir);
+  const context = new Context();
+  contexts.push(context);
+  provideLaunchContext(context, { cwd, agentDir, args: [], requestExit() {} });
+  return { context, cwd, agentDir };
+}
+
+describe("session plugin", () => {
+  test.each([42, "jsonl", []])("rejects a non-object configuration: %j", async (config) => {
+    const { context } = await createContext();
+
+    await expect(context.plugin(sessionPlugin, config as never)).rejects.toBeInstanceOf(Error);
+    expect(context.get("piSession")).toBeUndefined();
+  });
+
+  test.each(["   ", "sessions\0hidden", "sessions\nhidden", "sessions\u001bhidden", "x".repeat(4_097)])(
+    "rejects an unsafe or unbounded session directory: %j",
+    (directory) => {
+      expect(() => SessionConfig({ storage: "jsonl", directory })).toThrow(/directory/u);
+    },
+  );
+
+  test.each([{ storage: "disk" }, { storage: 1 }, { directory: 42 }])("rejects an invalid session option type: %j", (config) => {
+    expect(() => SessionConfig(config as never)).toThrow();
+  });
+
+  test("rejects a directory option that memory storage would silently ignore", async () => {
+    const { context } = await createContext();
+    let activationError: unknown;
+    try {
+      await context.plugin(sessionPlugin, { storage: "memory", directory: "sessions" });
+    } catch (error) {
+      activationError = error;
+    }
+
+    expect(activationError).toBeInstanceOf(Error);
+    expect((activationError as Error).message).toMatch(/directory.*memory/iu);
+    expect(context.get("piSession")).toBeUndefined();
+  });
+
+  test("creates the default JSONL manager under the configured agent directory", async () => {
+    const { context, cwd, agentDir } = await createContext();
+
+    await context.plugin(sessionPlugin);
+
+    expect(context.piSession.manager.isPersisted()).toBe(true);
+    expect(context.piSession.manager.getCwd()).toBe(cwd);
+    expect(context.piSession.manager.getSessionDir()).toBe(join(agentDir, "sessions"));
+  });
+
+  test.each(["relative", "absolute"])("resolves a %s custom JSONL directory deterministically", async (kind) => {
+    const { context, cwd } = await createContext();
+    const external = await mkdtemp(join(tmpdir(), "pi-harness-session-external-"));
+    temporaryDirectories.push(external);
+    const configured = kind === "relative" ? join("var", "sessions") : external;
+
+    await context.plugin(sessionPlugin, { storage: "jsonl", directory: configured });
+
+    expect(context.piSession.manager.getSessionDir()).toBe(kind === "relative" ? join(cwd, configured) : external);
+  });
+
+  test("rejects an existing file as the JSONL session directory during activation", async () => {
+    const { context, cwd } = await createContext();
+    const file = join(cwd, "sessions-file");
+    await writeFile(file, "not a directory", "utf8");
+    let activationError: unknown;
+    try {
+      await context.plugin(sessionPlugin, { storage: "jsonl", directory: file });
+    } catch (error) {
+      activationError = error;
+    }
+
+    expect(activationError).toBeInstanceOf(Error);
+    expect((activationError as Error).message).toMatch(/session directory.*directory/iu);
+    expect(context.get("piSession")).toBeUndefined();
+  });
+
+  test("persists a complete JSONL transcript and reopens it through the upstream manager", async () => {
+    const { context, cwd } = await createContext();
+    const directory = join(cwd, "sessions");
+    await context.plugin(sessionPlugin, { storage: "jsonl", directory });
+    const manager = context.piSession.manager;
+    const sessionFile = manager.getSessionFile();
+    expect(sessionFile).toBeDefined();
+
+    manager.appendMessage({ role: "user", content: "hello", timestamp: 1 });
+    await expect(access(sessionFile ?? "")).rejects.toMatchObject({ code: "ENOENT" });
+    manager.appendMessage({
+      role: "assistant",
+      content: [{ type: "text", text: "world" }],
+      api: "test",
+      provider: "test",
+      model: "test",
+      usage: { input: 1, output: 1, cacheRead: 0, cacheWrite: 0, totalTokens: 2, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
+      stopReason: "stop",
+      timestamp: 2,
+    });
+
+    const lines = (await readFile(sessionFile ?? "", "utf8"))
+      .trim()
+      .split("\n")
+      .map((line) => JSON.parse(line) as { type: string });
+    expect(lines.map((line) => line.type)).toEqual(["session", "message", "message"]);
+    const reopened = SessionManager.open(sessionFile ?? "");
+    expect(reopened.getSessionId()).toBe(manager.getSessionId());
+    expect(reopened.getCwd()).toBe(cwd);
+    expect(reopened.buildSessionContext().messages.map((message) => message.role)).toEqual(["user", "assistant"]);
+  });
+
+  test("keeps memory sessions entirely in process", async () => {
+    const { context, cwd } = await createContext();
+    await context.plugin(sessionPlugin, { storage: "memory" });
+    const manager = context.piSession.manager;
+
+    manager.appendMessage({ role: "user", content: "ephemeral", timestamp: 1 });
+
+    expect(manager.isPersisted()).toBe(false);
+    expect(manager.getCwd()).toBe(cwd);
+    expect(manager.getSessionDir()).toBe("");
+    expect(manager.getSessionFile()).toBeUndefined();
+    expect(manager.buildSessionContext().messages).toEqual([{ role: "user", content: "ephemeral", timestamp: 1 }]);
+  });
+
+  test("removes the session service on disposal", async () => {
+    const { context } = await createContext();
+    await context.plugin(sessionPlugin, { storage: "memory" });
+    expect(context.get("piSession")).toBeDefined();
+
+    await context.fiber.dispose();
+
+    expect(context.get("piSession")).toBeUndefined();
+  });
+});