@vitest-agent/engine 2.0.1 → 3.0.0

package/layers/ProjectIdentityLive.js

@@ -1,9 +1,12 @@
 import { VitestAgentConfigFile } from "../services/Config.js";
 import { ProjectIdentity, resolveProjectIdentityFromCandidates } from "../services/ProjectIdentity.js";
+import { repositoryUrlOf } from "../utils/package-manifest.js";
+import { Git } from "@effected/git";
 import { ProjectIdentityNotResolvableError, ProjectIdentitySourceError, VitestAgentConfig } from "@vitest-agent/sdk";
-import { Effect, FileSystem, Layer, Option } from "effect";
+import { Effect, FileSystem, Layer, Option, Result } from "effect";
 import { WorkspaceDiscovery } from "@effected/workspaces";
-import { ChildProcess, ChildProcessSpawner } from "effect/process";
+import { AppDirs } from "@effected/xdg";
+import { LenientManifest } from "@effected/package-json";
 
 // src/layers/ProjectIdentityLive.ts
 /** The one-line text of a kit failure, for `ProjectIdentitySourceError.detail`. */
@@ -11,25 +14,23 @@ const detailOf = (cause) => cause instanceof Error && cause.message.length > 0 ?
 /**
 * The git remote is an OPTIONAL source: a repository with no
 * `remote.origin.url`, a directory that is not a git checkout, or a machine
-* with no `git` on `PATH` are all "no remote" rather than failures. `git
-* config --get` exits non-zero for an unset key, so every spawner failure
-* folds to `Option.none()` on purpose — this is the one catch in this module
-* that stays broad, and it is a policy, not an accident.
+* with no `git` on `PATH` are all "no remote" rather than failures, so every
+* `Git` failure folds to `Option.none()` on purpose — this is the one catch
+* in this module that stays broad, and it is a policy, not an accident.
+*
+* Read as the RAW config value (`Git.configGet`, i.e. `git config --get
+* remote.origin.url`), not `Git.remoteUrl`: `git remote get-url` applies
+* `url.<base>.insteadOf` rewrites, and the project key derived from this URL
+* names the persisted data directory, so a rewrite must not re-key it.
 */
-const readGitRemote = (cwd) => Effect.gen(function* () {
-	const trimmed = (yield* (yield* ChildProcessSpawner.ChildProcessSpawner).string(ChildProcess.make("git", [
-		"config",
-		"--get",
-		"remote.origin.url"
-	]).pipe(ChildProcess.setCwd(cwd)))).trim();
-	return trimmed.length > 0 ? Option.some(trimmed) : Option.none();
-}).pipe(Effect.catch(() => Effect.succeed(Option.none())));
+const readGitRemote = (cwd) => Effect.flatMap(Git, (git) => git.configGet(cwd, "remote.origin.url")).pipe(Effect.map(Option.filter((url) => url.length > 0)), Effect.orElseSucceed(() => Option.none()));
 /**
 * The `repository` URL of the root `package.json` discovery named.
 *
 * A file that is not there (`NotFound`) is an absent source. Any other
 * filesystem failure (permission denied, an I/O error) and a body that is not
-* JSON are `ProjectIdentitySourceError`s: the file exists and says
+* JSON (`@effected/package-json`'s `PackageJsonSyntaxError`, `invalid-json`)
+* are `ProjectIdentitySourceError`s: the file exists and says
 * something, and silently reading it as "no repository" would hand the
 * operator the wrong identity.
 */
@@ -41,23 +42,13 @@ const readPackageRepoUrl = (packageJsonPath) => Effect.gen(function* () {
 		cause: error
 	}))));
 	if (Option.isNone(raw)) return Option.none();
-	const parsed = yield* Effect.try({
-		try: () => JSON.parse(raw.value),
-		catch: (cause) => new ProjectIdentitySourceError({
-			source: "package-json",
-			path: packageJsonPath,
-			detail: detailOf(cause),
-			cause
-		})
-	});
-	if (parsed === null || typeof parsed !== "object") return Option.none();
-	const repo = parsed.repository;
-	if (typeof repo === "string" && repo.trim().length > 0) return Option.some(repo.trim());
-	if (repo !== null && typeof repo === "object" && "url" in repo && typeof repo.url === "string") {
-		const url = repo.url.trim();
-		return url.length > 0 ? Option.some(url) : Option.none();
-	}
-	return Option.none();
+	const manifest = yield* LenientManifest.parse(raw.value).pipe(Effect.map(Option.some), Effect.catchTag("PackageJsonSyntaxError", (cause) => cause.reason === "not-an-object" ? Effect.succeed(Option.none()) : Effect.fail(new ProjectIdentitySourceError({
+		source: "package-json",
+		path: packageJsonPath,
+		detail: detailOf(cause),
+		cause
+	}))));
+	return Option.flatMap(manifest, (m) => Option.fromNullishOr(repositoryUrlOf(m.repository)));
 });
 const collectCandidates = (workspaceRoot, options) => Effect.gen(function* () {
 	const tomlConfig = yield* (yield* VitestAgentConfigFile).loadOrDefault(new VitestAgentConfig({})).pipe(Effect.mapError((cause) => new ProjectIdentitySourceError({
@@ -76,7 +67,16 @@ const collectCandidates = (workspaceRoot, options) => Effect.gen(function* () {
 	const packageJsonRepoUrl = root ? yield* readPackageRepoUrl(root.packageJsonPath) : Option.none();
 	const candidates = {};
 	if (options.projectId !== void 0) candidates.explicit = options.projectId;
-	if (tomlConfig.projectKey !== void 0) candidates.toml = tomlConfig.projectKey;
+	if (tomlConfig.projectKey !== void 0 && tomlConfig.projectKey.trim() !== "") {
+		const segment = AppDirs.segment(tomlConfig.projectKey);
+		if (Result.isFailure(segment)) return yield* new ProjectIdentitySourceError({
+			source: "toml",
+			path: workspaceRoot,
+			detail: `projectKey ${JSON.stringify(tomlConfig.projectKey)} is not a usable directory name (${segment.failure.message})`,
+			cause: segment.failure
+		});
+		candidates.toml = tomlConfig.projectKey;
+	}
 	const remoteValue = Option.getOrUndefined(gitRemote);
 	if (remoteValue !== void 0) candidates.gitRemote = remoteValue;
 	const repoUrlValue = Option.getOrUndefined(packageJsonRepoUrl);
@@ -121,13 +121,13 @@ const ProjectIdentityLive = Layer.effect(ProjectIdentity, Effect.gen(function* (
 	const fs = yield* FileSystem.FileSystem;
 	const discovery = yield* WorkspaceDiscovery;
 	const configFile = yield* VitestAgentConfigFile;
-	const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
-	return { resolve: (workspaceRoot, options = {}) => collectCandidates(workspaceRoot, options).pipe(Effect.provideService(FileSystem.FileSystem, fs), Effect.provideService(WorkspaceDiscovery, discovery), Effect.provideService(VitestAgentConfigFile, configFile), Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner), Effect.flatMap((candidates) => {
+	const git = yield* Git;
+	return { resolve: (workspaceRoot, options = {}) => collectCandidates(workspaceRoot, options).pipe(Effect.provideService(FileSystem.FileSystem, fs), Effect.provideService(WorkspaceDiscovery, discovery), Effect.provideService(VitestAgentConfigFile, configFile), Effect.provideService(Git, git), Effect.flatMap((candidates) => {
 		const result = resolveProjectIdentityFromCandidates(candidates);
 		if (result === null) return Effect.fail(new ProjectIdentityNotResolvableError({ tried: candidatesToTriedList(candidates) }));
 		return Effect.succeed(result);
 	})) };
-}));
+})).pipe(Layer.provide(Git.layer));
 /**
 * Build a Test layer that returns a fixed `ResolvedIdentity` (or
 * fails with the given `ProjectIdentityError`). Use in unit tests

package/layers/RunContextLive.js

@@ -1,73 +1,59 @@
 import { AgentContext, RunContext, RunContextService } from "../services/RunContext.js";
-import { probeHostMetadataFromEnv } from "@vitest-agent/sdk";
+import { probeHostMetadataFromEnv } from "../utils/host-metadata.js";
+import { Git } from "@effected/git";
 import { Effect, Layer, Option } from "effect";
-import { ChildProcess, ChildProcessSpawner } from "effect/process";
 
 // src/layers/RunContextLive.ts
-const runGit = (spawner, cwd, args) => spawner.string(ChildProcess.make("git", args).pipe(ChildProcess.setCwd(cwd))).pipe(Effect.map((output) => {
-	const trimmed = output.trim();
-	return trimmed.length > 0 ? Option.some(trimmed) : Option.none();
-}), Effect.catch(() => Effect.succeed(Option.none())));
-const captureRunContextEffect = (cwd, spawner, env) => Effect.gen(function* () {
-	const branch = yield* runGit(spawner, cwd, [
-		"rev-parse",
-		"--abbrev-ref",
-		"HEAD"
-	]);
-	const sha = yield* runGit(spawner, cwd, ["rev-parse", "HEAD"]);
-	const dirtyOut = yield* runGit(spawner, cwd, ["status", "--porcelain"]);
-	const upstream = yield* runGit(spawner, cwd, [
-		"rev-parse",
-		"--abbrev-ref",
-		"@{upstream}"
-	]);
-	const worktree = yield* runGit(spawner, cwd, ["rev-parse", "--show-toplevel"]);
-	const dirtyValue = Option.match(dirtyOut, {
-		onNone: () => null,
-		onSome: (out) => out.length > 0
-	});
+/** Every git failure (not a repository, no `git` on PATH, an unborn HEAD) is "no answer". */
+const orNull = (effect) => effect.pipe(Effect.orElseSucceed(() => null));
+const DETACHED_HEAD = "HEAD";
+const branchOf = (git, cwd) => orNull(git.currentBranch(cwd).pipe(Effect.map(Option.getOrElse(() => DETACHED_HEAD))));
+const shaOf = (git, cwd) => orNull(git.revParse(cwd, "HEAD"));
+const toplevelOf = (git, cwd) => orNull(git.repoRoot(cwd));
+const dirtyOf = (git, cwd) => orNull(git.status(cwd, { untrackedFiles: "normal" }).pipe(Effect.map((entries) => entries.length > 0)));
+const upstreamOf = (git, cwd) => orNull(git.upstream(cwd).pipe(Effect.map((upstream) => Option.getOrNull(Option.map(upstream, (u) => u.name)))));
+const captureRunContextEffect = (cwd, git, env) => Effect.gen(function* () {
+	const gitBranch = yield* branchOf(git, cwd);
+	const gitCommitSha = yield* shaOf(git, cwd);
+	const gitDirty = yield* dirtyOf(git, cwd);
+	const gitUpstream = yield* upstreamOf(git, cwd);
+	const gitWorktreeDir = yield* toplevelOf(git, cwd);
 	const host = probeHostMetadataFromEnv(env);
 	return new RunContext({
-		gitBranch: Option.getOrNull(branch),
-		gitCommitSha: Option.getOrNull(sha),
-		gitDirty: dirtyValue,
-		gitUpstream: Option.getOrNull(upstream),
-		gitWorktreeDir: Option.getOrNull(worktree),
+		gitBranch,
+		gitCommitSha,
+		gitDirty,
+		gitUpstream,
+		gitWorktreeDir,
 		hostSource: host.source,
 		hostValue: host.value,
 		hostMetadata: host.metadata
 	});
 });
-const captureAgentContextEffect = (cwd, spawner) => Effect.gen(function* () {
-	const branch = yield* runGit(spawner, cwd, [
-		"rev-parse",
-		"--abbrev-ref",
-		"HEAD"
-	]);
-	const sha = yield* runGit(spawner, cwd, ["rev-parse", "HEAD"]);
-	const worktree = yield* runGit(spawner, cwd, ["rev-parse", "--show-toplevel"]);
+const captureAgentContextEffect = (cwd, git) => Effect.gen(function* () {
 	return new AgentContext({
-		startGitBranch: Option.getOrNull(branch),
-		startGitCommitSha: Option.getOrNull(sha),
-		startWorktreeDir: Option.getOrNull(worktree)
+		startGitBranch: yield* branchOf(git, cwd),
+		startGitCommitSha: yield* shaOf(git, cwd),
+		startWorktreeDir: yield* toplevelOf(git, cwd)
 	});
 });
 /**
 * Live layer. Requires `ChildProcessSpawner` (provided by
-* `NodeServices.layer` at the entry point). Host-metadata probes read
-* the injected `env` map — the env walk is pure and the map is captured
-* once when the layer is built.
+* `NodeServices.layer` at the entry point), which feeds `@effected/git`'s
+* `Git` for branch / sha / dirty / upstream / toplevel. Every git failure is
+* recorded as `null`. Host metadata comes from `probeHostMetadataFromEnv`
+* over the injected `env` map, captured once when the layer is built.
 *
 * @param env - the environment map to probe (the front end passes `process.env`)
 * @public
 */
 const RunContextLive = (env) => Layer.effect(RunContextService, Effect.gen(function* () {
-	const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+	const git = yield* Git;
 	return {
-		captureRunContext: (cwd) => captureRunContextEffect(cwd, spawner, env),
-		captureAgentContext: (cwd) => captureAgentContextEffect(cwd, spawner)
+		captureRunContext: (cwd) => captureRunContextEffect(cwd, git, env),
+		captureAgentContext: (cwd) => captureAgentContextEffect(cwd, git)
 	};
-}));
+})).pipe(Layer.provide(Git.layer));
 /**
 * Build a Test layer that returns fixed `RunContext` and
 * `AgentContext` values regardless of `cwd`.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vitest-agent/engine",
-	"version": "2.0.1",
+	"version": "3.0.0",
 	"private": false,
 	"description": "Shared services, layers, SQLite data layer, migrations and platform resolution for the vitest-agent CLI and MCP server.",
 	"keywords": [
@@ -42,20 +42,22 @@
 	"dependencies": {
 		"@effect/platform-node": "^4.0.6",
 		"@effect/sql-sqlite-node": "^4.0.6",
-		"@effected/app": "^0.27.0",
-		"@effected/cli": "^0.22.1",
-		"@effected/config-file": "^0.20.0",
-		"@effected/engine": "^0.8.0",
-		"@effected/env": "^0.5.0",
-		"@effected/glob": "^0.14.0",
-		"@effected/jsonc": "^0.20.0",
-		"@effected/store": "^0.19.0",
+		"@effected/app": "^0.28.0",
+		"@effected/cli": "^0.23.0",
+		"@effected/config-file": "^0.21.0",
+		"@effected/engine": "^0.9.0",
+		"@effected/env": "^0.6.0",
+		"@effected/git": "^0.26.0",
+		"@effected/glob": "^0.15.0",
+		"@effected/jsonc": "^0.20.1",
+		"@effected/package-json": "^0.26.1",
+		"@effected/store": "^0.20.0",
 		"@effected/toml": "^0.16.0",
-		"@effected/walker": "^0.20.0",
-		"@effected/workspaces": "^0.38.1",
-		"@effected/xdg": "^0.15.0",
+		"@effected/walker": "^0.21.0",
+		"@effected/workspaces": "^0.39.1",
+		"@effected/xdg": "^0.16.0",
 		"@effected/yaml": "^0.25.1",
-		"@vitest-agent/sdk": "8.0.0",
+		"@vitest-agent/sdk": "9.0.0",
 		"effect": "^4.0.6"
 	},
 	"engines": {

package/platform.js

@@ -5,7 +5,7 @@ import { LoggerLive } from "./layers/LoggerLive.js";
 import { OutputPipelineLive } from "./layers/OutputPipelineLive.js";
 import { ProjectDiscoveryLive } from "./layers/ProjectDiscoveryLive.js";
 import { PROJECT_MIGRATIONS } from "./migrations/index.js";
-import { LEDGER_OPTIONS, toStoreMigrations } from "./stores.js";
+import { BUSY_TIMEOUT, LEDGER_OPTIONS, applyConnectionPragmas } from "./stores.js";
 import { Context, Effect, Layer } from "effect";
 import { SqlClient } from "effect/sql/SqlClient";
 import * as NodeServices from "@effect/platform-node/NodeServices";
@@ -32,11 +32,17 @@ const NodePlatformLayer = NodeServices.layer;
 * @public
 */
 const makeSqliteStack = (filename, migrations = PROJECT_MIGRATIONS) => {
-	const SqliteLayer = layer({ filename }).pipe(Layer.tap((context) => Context.get(context, SqlClient)`PRAGMA synchronous = NORMAL`));
+	const SqliteLayer = layer({
+		filename,
+		busyTimeout: BUSY_TIMEOUT
+	}).pipe(Layer.tap((context) => {
+		const sql = Context.get(context, SqlClient);
+		return Effect.andThen(sql`PRAGMA synchronous = NORMAL`, applyConnectionPragmas(sql));
+	}));
 	return {
 		SqliteLayer,
 		MigratorLayer: Layer.effectDiscard(Effect.void).pipe(Layer.provide(Store.layer({
-			migrations: toStoreMigrations(migrations),
+			migrations: Store.fromMigratorRecord(migrations),
 			...LEDGER_OPTIONS
 		}).pipe(Layer.provide(SqliteLayer))))
 	};

package/programs/hook-paths.js

@@ -1,10 +1,12 @@
 import { APP_NAMESPACE, DATA_FALLBACK_DIR } from "../layers/PathResolutionLive.js";
 import migration from "../migrations/registry_0001_initial.js";
-import { LEDGER_OPTIONS, toStoreMigrations } from "../stores.js";
+import { LEDGER_OPTIONS } from "../stores.js";
 import { ProjectIdentityNotResolvableError } from "@vitest-agent/sdk";
-import { ConfigProvider, Effect, FileSystem, Layer, Path } from "effect";
+import { Effect, FileSystem, Layer, Option, Path } from "effect";
 import { AppDirs, Xdg } from "@effected/xdg";
+import { Store } from "@effected/store";
 import { AppStore } from "@effected/app";
+import { LaunchContext } from "@effected/engine";
 
 // src/programs/hook-paths.ts
 /**
@@ -36,39 +38,43 @@ const REGISTRY_DB_FILENAME = "registry.db";
 const REGISTRY_STORE_OPTIONS = {
 	filename: REGISTRY_DB_FILENAME,
 	directory: "data",
-	migrations: toStoreMigrations({ "0001_initial": migration }),
+	migrations: Store.fromMigratorRecord({ "0001_initial": migration }),
 	...LEDGER_OPTIONS
 };
 /** Directory under the home dir that holds the per-client `sessions.db` fallback. */
 const SESSION_MAP_HOME_DIR = `.${APP_NAMESPACE}`;
 const nonEmpty = (value) => value !== void 0 && value.length > 0 ? value : void 0;
 /**
-* `AppDirs` for the hook family, resolved from the caller's `env` map.
-*
-* `Xdg.layer` reads `HOME` and `XDG_DATA_HOME` through the ambient
-* `ConfigProvider`, so the env map is installed as that provider — no
-* `process.env` read. `USERPROFILE` stands in for `HOME` when the latter is
-* unset (Windows), matching the session-map fallback order below.
-*
+* The home directory the hook family falls back on: `HOME`, then
+* `USERPROFILE`, on every platform. Deliberately not `@effected/xdg`'s win32
+* order (`USERPROFILE` first): under Git Bash / MSYS the two differ, and
+* switching would move an existing `sessions.db`.
+*/
+const homeOf = (env) => nonEmpty(env.HOME) ?? nonEmpty(env.USERPROFILE);
+/**
+* `AppDirs` for the hook family, resolved from the caller's `env` map
+* through `Xdg.layerFromEnv` — no `process.env` read. `USERPROFILE` stands
+* in for `HOME` when the latter is unset (Windows), matching the
+* session-map fallback order below.
 */
 const hookAppDirs = (env) => {
-	const home = nonEmpty(env.HOME) ?? nonEmpty(env.USERPROFILE);
-	const provider = ConfigProvider.fromEnvRecord({
-		...env,
-		...home !== void 0 && { HOME: home }
-	});
-	const XdgLive = Xdg.layer.pipe(Layer.provide(ConfigProvider.layer(provider)));
+	const home = homeOf(env);
 	return AppDirs.layer({
 		namespace: APP_NAMESPACE,
 		fallbackDir: DATA_FALLBACK_DIR
-	}).pipe(Layer.provide(XdgLive));
+	}).pipe(Layer.provide(Xdg.layerFromEnv({
+		...env,
+		...home !== void 0 && { HOME: home }
+	})));
 };
 /**
 * Resolve the per-client `sessions.db` path.
 *
 * Precedence: the `CLAUDE_PLUGIN_DATA` env var, then
 * `VITEST_AGENT_SESSION_MAP_DIR`, then `~/.vitest-agent/` (`HOME`, then
-* `USERPROFILE`). The chosen directory is created. Fails with
+* `USERPROFILE`). The two variables are read through `@effected/engine`'s
+* `LaunchContext.resolve`: a value is trimmed, and a blank or unsubstituted
+* `${...}` placeholder value counts as unset. The chosen directory is created. Fails with
 * `ProjectIdentityNotResolvableError` when no home directory is resolvable.
 *
 * @param env - the environment map to consult (the front end passes `process.env`)
@@ -78,8 +84,11 @@ const hookAppDirs = (env) => {
 const resolveSessionMapPath = (env) => Effect.gen(function* () {
 	const fs = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
-	const home = nonEmpty(env.HOME) ?? nonEmpty(env.USERPROFILE);
-	const dir = nonEmpty(env.CLAUDE_PLUGIN_DATA) ?? nonEmpty(env.VITEST_AGENT_SESSION_MAP_DIR) ?? (home !== void 0 ? path.join(home, SESSION_MAP_HOME_DIR) : void 0);
+	const home = homeOf(env);
+	const dir = LaunchContext.resolve({
+		env,
+		keys: ["CLAUDE_PLUGIN_DATA", "VITEST_AGENT_SESSION_MAP_DIR"]
+	}).pipe(Option.getOrElse(() => home !== void 0 ? path.join(home, SESSION_MAP_HOME_DIR) : void 0));
 	if (dir === void 0) return yield* new ProjectIdentityNotResolvableError({ tried: [
 		{
 			source: "CLAUDE_PLUGIN_DATA",

package/programs/platform-sidecar.js

@@ -5,7 +5,7 @@ import { LoggerLive } from "../layers/LoggerLive.js";
 import { PerClientSessionMapWriterLive } from "../layers/PerClientSessionMapLive.js";
 import { RunContextLive } from "../layers/RunContextLive.js";
 import migration from "../migrations/session_map_0001_initial.js";
-import { LEDGER_OPTIONS, RegistryStore, SessionMapStore, toStoreMigrations } from "../stores.js";
+import { CONNECTION_OPTIONS, LEDGER_OPTIONS, RegistryStore, SessionMapStore } from "../stores.js";
 import { NodePlatformLayer, makeSqliteStack } from "../platform.js";
 import { REGISTRY_STORE_OPTIONS } from "./hook-paths.js";
 import { Layer } from "effect";
@@ -13,6 +13,30 @@ import { Store } from "@effected/store";
 
 // src/programs/platform-sidecar.ts
 /**
+* The per-client session map store (`sessions.db`) at `filename`, migrated,
+* with the shared per-connection settings applied on open.
+*
+* @internal
+*/
+const SessionMapStoreLive = (filename) => Store.layerSqliteAs(SessionMapStore, {
+	filename,
+	migrations: Store.fromMigratorRecord({ "0001_initial": migration }),
+	...LEDGER_OPTIONS,
+	...CONNECTION_OPTIONS
+});
+/**
+* The global discovery registry store (`registry.db`) at `filename`, migrated,
+* with the shared per-connection settings applied on open.
+*
+* @internal
+*/
+const RegistryStoreLive = (filename) => Store.layerSqliteAs(RegistryStore, {
+	filename,
+	migrations: REGISTRY_STORE_OPTIONS.migrations,
+	...LEDGER_OPTIONS,
+	...CONNECTION_OPTIONS
+});
+/**
 * Build the sidecar Live layer for the supplied SQLite paths.
 *
 * Each store gets its own `SqlClient` connection and its own migration
@@ -28,17 +52,9 @@ import { Store } from "@effected/store";
 const SidecarPlatformLive = (paths, env) => {
 	const project = makeSqliteStack(paths.perProjectDbPath);
 	const ProjectStoreLayer = Layer.mergeAll(DataStoreLive.pipe(Layer.provide(project.SqliteLayer)), DataReaderLive.pipe(Layer.provide(project.SqliteLayer)), project.MigratorLayer);
-	const SessionMapLayer = PerClientSessionMapWriterLive.pipe(Layer.provide(Store.sqlClient(SessionMapStore)), Layer.provide(Store.layerSqliteAs(SessionMapStore, {
-		filename: paths.sessionMapDbPath,
-		migrations: toStoreMigrations({ "0001_initial": migration }),
-		...LEDGER_OPTIONS
-	})));
-	const RegistryLayer = DiscoveryRegistryLive.pipe(Layer.provide(Store.sqlClient(RegistryStore)), Layer.provide(Store.layerSqliteAs(RegistryStore, {
-		filename: paths.registryDbPath,
-		migrations: REGISTRY_STORE_OPTIONS.migrations,
-		...LEDGER_OPTIONS
-	})));
+	const SessionMapLayer = PerClientSessionMapWriterLive.pipe(Layer.provide(Store.sqlClient(SessionMapStore)), Layer.provide(SessionMapStoreLive(paths.sessionMapDbPath)));
+	const RegistryLayer = DiscoveryRegistryLive.pipe(Layer.provide(Store.sqlClient(RegistryStore)), Layer.provide(RegistryStoreLive(paths.registryDbPath)));
 	return Layer.mergeAll(ProjectStoreLayer, SessionMapLayer, RegistryLayer, RunContextLive(env)).pipe(Layer.provideMerge(NodePlatformLayer), Layer.provideMerge(LoggerLive()));
 };
 
-export { SidecarPlatformLive };
+export { RegistryStoreLive, SessionMapStoreLive, SidecarPlatformLive };

package/programs/resolve-session-for-recording.js

@@ -1,6 +1,7 @@
 import { DataReader } from "../services/DataReader.js";
 import { DataStore } from "../services/DataStore.js";
 import { Effect, FileSystem, Option } from "effect";
+import { LenientManifest } from "@effected/package-json";
 
 // src/programs/resolve-session-for-recording.ts
 /**
@@ -34,10 +35,11 @@ const resolveSessionForRecording = (input) => Effect.gen(function* () {
 	return Option.getOrThrowWith(created, () => /* @__PURE__ */ new Error(`upsertSession succeeded but row not found for ${input.chatId}`));
 });
 /**
-* Best-effort `package.json#name` read through the injected `FileSystem`.
+* Best-effort `package.json#name` read through the injected `FileSystem`
+* (`@effected/package-json`'s `LenientManifest`: a non-string name is absent).
 * Any read or parse failure resolves to `undefined` — the caller falls
 * back to `"unknown"`, exactly as the former sync `readFileSync` probe did.
 */
-const readPackageName = (fs, cwd) => fs.readFileString(`${cwd}/package.json`).pipe(Effect.flatMap((raw) => Effect.try(() => JSON.parse(raw))), Effect.map((parsed) => typeof parsed.name === "string" ? parsed.name : void 0), Effect.catch(() => Effect.succeed(void 0)));
+const readPackageName = (fs, cwd) => fs.readFileString(`${cwd}/package.json`).pipe(Effect.flatMap(LenientManifest.parse), Effect.map((manifest) => manifest.name), Effect.orElseSucceed(() => void 0));
 
 export { resolveSessionForRecording };

package/programs/session-env.js

@@ -1,41 +1,13 @@
+import { Result } from "effect";
+import { ShellExports } from "@effected/env";
 import { join, resolve } from "node:path";
 import { readFileSync, readdirSync, statSync } from "node:fs";
 
 // src/programs/session-env.ts
-const EXPORT_LINE = /^export ([A-Z_][A-Z0-9_]*)=(.*)$/;
-/**
-* Undo the `printf '%q'` quoting the SessionStart hook applies to export
-* values. UUIDs and plain paths arrive bare; values with specials arrive
-* as `$'...'`, `'...'`, `"..."`, or backslash-escaped words.
-*/
-const unquote = (raw) => {
-	let v = raw.trim();
-	if (v.startsWith("$'") && v.endsWith("'") && v.length >= 3) v = v.slice(2, -1);
-	else if (v.startsWith("'") && v.endsWith("'") || v.startsWith("\"") && v.endsWith("\"")) {
-		if (v.length >= 2) v = v.slice(1, -1);
-	}
-	return v.replace(/\\(.)/g, "$1");
-};
-/**
-* Parse `export KEY=value` lines from a session-env hook file into a
-* plain record. Non-export lines are ignored.
-*
-* @param content - the raw text of a session-env hook file
-* @returns a record of export names to unquoted values
-* @public
-*/
-const parseSessionEnvExports = (content) => {
-	const out = {};
-	for (const line of content.split("\n")) {
-		const m = EXPORT_LINE.exec(line.trim());
-		if (m?.[1] !== void 0 && m[2] !== void 0) out[m[1]] = unquote(m[2]);
-	}
-	return out;
-};
 /** The default {@link SessionEnvFileSystem}: the real disk through `node:fs`. */
 const nodeSessionEnvFileSystem = {
 	readDirectory: (path) => readdirSync(path),
-	readFile: (path) => readFileSync(path, "utf8"),
+	readFile: (path) => readFileSync(path),
 	mtimeMs: (path) => statSync(path).mtimeMs
 };
 /**
@@ -71,7 +43,9 @@ const recoverSessionContextFromSessionEnv = (opts) => {
 		const file = join(root, entry, "vitest-agent-hook.sh");
 		try {
 			const mtimeMs = fs.mtimeMs(file);
-			const env = parseSessionEnvExports(fs.readFile(file));
+			const parsed = ShellExports.parseBytesResult(fs.readFile(file));
+			if (Result.isFailure(parsed)) continue;
+			const env = parsed.success;
 			const chatId = env.VITEST_AGENT_CHAT_ID;
 			const conversationId = env.VITEST_AGENT_CONVERSATION_ID;
 			const mainAgentId = env.VITEST_AGENT_MAIN_AGENT_ID ?? env.VITEST_AGENT_AGENT_ID;
@@ -90,4 +64,4 @@ const recoverSessionContextFromSessionEnv = (opts) => {
 	return best === null ? null : best.ctx;
 };
 
-export { parseSessionEnvExports, recoverSessionContextFromSessionEnv };
+export { recoverSessionContextFromSessionEnv };

package/services/ProjectIdentity.js

@@ -1,9 +1,17 @@
-import { canonicalizeGitUrl, gitUrlToProjectKey, normalizeWorkspaceKey } from "@vitest-agent/sdk";
-import { Context } from "effect";
+import { canonicalizeGitUrl, gitUrlToProjectKey } from "@vitest-agent/sdk";
+import { Context, Result } from "effect";
+import { AppDirs } from "@effected/xdg";
 
 // src/services/ProjectIdentity.ts
 const isUseful = (value) => value !== void 0 && value.trim().length > 0;
 /**
+* The project key a name maps to: `@effected/xdg`'s `AppDirs.segment`, the
+* former `normalizeWorkspaceKey` rules byte for byte. `null` when the name
+* maps to `.` or `..`, which would name a directory outside the data root;
+* the resolver then falls through to the next source.
+*/
+const keyOf = (name) => Result.getOrNull(AppDirs.segment(name));
+/**
 * Pure priority resolver. Returns `null` when no candidate produces a
 * usable value — the caller wraps `null` into a tagged error.
 *
@@ -15,16 +23,22 @@ const isUseful = (value) => value !== void 0 && value.trim().length > 0;
 * @public
 */
 const resolveProjectIdentityFromCandidates = (candidates) => {
-	if (isUseful(candidates.explicit)) return {
-		projectKey: normalizeWorkspaceKey(candidates.explicit),
-		canonicalForm: candidates.explicit,
-		source: "explicit"
-	};
-	if (isUseful(candidates.toml)) return {
-		projectKey: normalizeWorkspaceKey(candidates.toml),
-		canonicalForm: candidates.toml,
-		source: "toml"
-	};
+	if (isUseful(candidates.explicit)) {
+		const key = keyOf(candidates.explicit);
+		if (key !== null) return {
+			projectKey: key,
+			canonicalForm: candidates.explicit,
+			source: "explicit"
+		};
+	}
+	if (isUseful(candidates.toml)) {
+		const key = keyOf(candidates.toml);
+		if (key !== null) return {
+			projectKey: key,
+			canonicalForm: candidates.toml,
+			source: "toml"
+		};
+	}
 	if (isUseful(candidates.gitRemote)) {
 		const canonical = canonicalizeGitUrl(candidates.gitRemote);
 		const key = gitUrlToProjectKey(candidates.gitRemote);
@@ -43,11 +57,14 @@ const resolveProjectIdentityFromCandidates = (candidates) => {
 			source: "package-repository"
 		};
 	}
-	if (isUseful(candidates.packageJsonName)) return {
-		projectKey: normalizeWorkspaceKey(candidates.packageJsonName),
-		canonicalForm: candidates.packageJsonName,
-		source: "package-name"
-	};
+	if (isUseful(candidates.packageJsonName)) {
+		const key = keyOf(candidates.packageJsonName);
+		if (key !== null) return {
+			projectKey: key,
+			canonicalForm: candidates.packageJsonName,
+			source: "package-name"
+		};
+	}
 	return null;
 };
 /**