chore(vendor): import pi 0.85.1

Imported as a linear vendor commit so forge rebases do not replay the upstream root tree.

git-subtree-dir: third_party/pi

git-subtree-split: d981de1229ef899957bbe968bc8dcda02a21f477

third_party/pi/packages/session-backends/sqlite-node/benchmark/session/session-repo-targets.ts

@@ -0,0 +1,33 @@
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { BACKGROUND_CONTEXT, type SessionRepo } from "@earendil-works/pi-agent-core";
+import { createNodeSqliteFactory, SqliteSessionRepo } from "../../src/index.ts";
+import type { BenchmarkTarget } from "../../../../agent/benchmark/session/benchmark.ts";
+
+export interface SessionRepoBenchmarkFixture extends AsyncDisposable {
+	readonly repo: SessionRepo;
+}
+
+const NOW = 1_700_000_000_000;
+
+export const sessionRepoBenchmarkTargets = [
+	{
+		name: "sqlite",
+		async createFixture() {
+			const directory = await mkdtemp(join(tmpdir(), "pi-sqlite-session-repo-benchmark-"));
+			const repo = new SqliteSessionRepo({
+				directory,
+				databaseFactory: createNodeSqliteFactory(),
+				now: () => NOW,
+			});
+			return {
+				repo,
+				async [Symbol.asyncDispose]() {
+					await repo.close(BACKGROUND_CONTEXT);
+					await rm(directory, { recursive: true, force: true });
+				},
+			};
+		},
+	},
+] satisfies readonly BenchmarkTarget<SessionRepoBenchmarkFixture>[];

third_party/pi/packages/session-backends/sqlite-node/benchmark/session/session-repo.bench.ts

@@ -0,0 +1,62 @@
+import {
+	SESSION_REPO_CATALOG_BENCHMARK_DATASETS,
+	SESSION_REPO_CATALOG_READ_BENCHMARK_SCENARIOS,
+	SESSION_REPO_CATALOG_WRITE_BENCHMARK_SCENARIOS,
+	SESSION_REPO_FORK_BENCHMARK_DATASETS,
+	SESSION_REPO_FORK_WRITE_BENCHMARK_SCENARIOS,
+	seedSessionRepoCatalogBenchmark,
+	seedSessionRepoForkBenchmark,
+} from "@earendil-works/pi-agent-core/harness/session/testing";
+import { registerReadBenchmarks, registerWriteBenchmarks } from "../../../../agent/benchmark/session/benchmark.ts";
+import { sessionRepoBenchmarkTargets } from "./session-repo-targets.ts";
+
+await registerReadBenchmarks({
+	datasets: SESSION_REPO_CATALOG_BENCHMARK_DATASETS,
+	targets: sessionRepoBenchmarkTargets,
+	scenarios: SESSION_REPO_CATALOG_READ_BENCHMARK_SCENARIOS,
+	async prepare(fixture, dataset) {
+		await seedSessionRepoCatalogBenchmark(fixture.repo, dataset);
+	},
+	getSubject(fixture) {
+		return fixture.repo;
+	},
+});
+
+await registerWriteBenchmarks({
+	targets: sessionRepoBenchmarkTargets,
+	scenarios: SESSION_REPO_CATALOG_WRITE_BENCHMARK_SCENARIOS,
+	prepare(fixture, scenario) {
+		return scenario.prepare(fixture.repo);
+	},
+	expectedResult(scenario) {
+		return scenario.expectedResult;
+	},
+	run(operation) {
+		return operation.run();
+	},
+});
+
+const forkBenchmarks = SESSION_REPO_FORK_BENCHMARK_DATASETS.flatMap((dataset) =>
+	SESSION_REPO_FORK_WRITE_BENCHMARK_SCENARIOS.map((scenario) => ({
+		name: `${scenario.name} (${dataset.name})`,
+		dataset,
+		scenario,
+	})),
+);
+
+await registerWriteBenchmarks({
+	targets: sessionRepoBenchmarkTargets,
+	scenarios: forkBenchmarks,
+	async prepare(fixture, benchmark) {
+		return {
+			repo: fixture.repo,
+			source: await seedSessionRepoForkBenchmark(fixture.repo, benchmark.dataset),
+		};
+	},
+	expectedResult(benchmark) {
+		return benchmark.scenario.expectedResult(benchmark.dataset);
+	},
+	run(subject, benchmark) {
+		return benchmark.scenario.run(subject.repo, subject.source, benchmark.dataset);
+	},
+});

third_party/pi/packages/session-backends/sqlite-node/benchmark/session/storage-targets.ts

@@ -0,0 +1,48 @@
+import { BACKGROUND_CONTEXT } from "@earendil-works/pi-agent-core";
+import type { StorageFixture } from "@earendil-works/pi-agent-core/harness/session/testing";
+import { createNodeSqliteFactory, SQLITE_STORAGE_VERSION, SqliteStorage, sql } from "../../src/index.ts";
+import { applyInitialSchema } from "../../src/sqlite/migrations.ts";
+import type { BenchmarkTarget } from "../../../../agent/benchmark/session/benchmark.ts";
+
+const SESSION_ID = "session";
+const NOW = 1_700_000_000_000;
+const EMPTY_USAGE = {
+	input: 0,
+	output: 0,
+	cacheRead: 0,
+	cacheWrite: 0,
+	totalTokens: 0,
+	cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+};
+
+export const storageBenchmarkTargets = [
+	{
+		name: "sqlite",
+		async createFixture() {
+			const db = await createNodeSqliteFactory().open(":memory:");
+			try {
+				db.exec("PRAGMA journal_mode = WAL; PRAGMA busy_timeout = 5000;");
+				await applyInitialSchema(db);
+				sql`INSERT INTO sessions
+					(id, created_at, parent_session_id, storage_version, metadata, message_count, usage_payload, next_seq)
+					VALUES (${SESSION_ID}, ${NOW}, ${null}, ${SQLITE_STORAGE_VERSION}, ${null}, ${0}, ${JSON.stringify(EMPTY_USAGE)}, ${1})`.run(
+					db,
+				);
+				const storage = new SqliteStorage(db, { sessionId: SESSION_ID, now: () => NOW });
+				return {
+					storage,
+					async [Symbol.asyncDispose]() {
+						try {
+							await storage.close(BACKGROUND_CONTEXT);
+						} finally {
+							db.close();
+						}
+					},
+				} satisfies StorageFixture;
+			} catch (error) {
+				db.close();
+				throw error;
+			}
+		},
+	},
+] satisfies readonly BenchmarkTarget<StorageFixture>[];

third_party/pi/packages/session-backends/sqlite-node/benchmark/session/storage.bench.ts

@@ -0,0 +1,35 @@
+import {
+	STORAGE_BENCHMARK_DATASETS,
+	STORAGE_READ_BENCHMARK_SCENARIOS,
+	STORAGE_WRITE_BENCHMARK_SCENARIOS,
+	seedStorageBenchmark,
+} from "@earendil-works/pi-agent-core/harness/session/testing";
+import { registerReadBenchmarks, registerWriteBenchmarks } from "../../../../agent/benchmark/session/benchmark.ts";
+import { storageBenchmarkTargets } from "./storage-targets.ts";
+
+await registerReadBenchmarks({
+	datasets: STORAGE_BENCHMARK_DATASETS,
+	targets: storageBenchmarkTargets,
+	scenarios: STORAGE_READ_BENCHMARK_SCENARIOS,
+	prepare(fixture, dataset) {
+		return seedStorageBenchmark(fixture.storage, dataset);
+	},
+	getSubject(fixture) {
+		return fixture.storage;
+	},
+});
+
+await registerWriteBenchmarks({
+	targets: storageBenchmarkTargets,
+	scenarios: STORAGE_WRITE_BENCHMARK_SCENARIOS,
+	async prepare(fixture, scenario) {
+		await scenario.prepare?.(fixture.storage);
+		return fixture.storage;
+	},
+	expectedResult(scenario) {
+		return scenario.writeCount;
+	},
+	run(storage, scenario) {
+		return scenario.run(storage);
+	},
+});