@vitest-agent/engine 3.0.1 → 3.1.0

package/index.d.ts

@@ -1565,7 +1565,7 @@ declare const ProjectDiscovery_base: Context.ServiceClass<ProjectDiscovery, "vit
 /** @public */
 export declare class ProjectDiscovery extends ProjectDiscovery_base {}
 /** @public */
-export declare const ProjectDiscoveryLive: Layer.Layer<ProjectDiscovery, never, FileSystem.FileSystem>;
+export declare const ProjectDiscoveryLive: Layer.Layer<ProjectDiscovery, never, FileSystem.FileSystem | Path.Path>;
 /** @public */
 export declare const ProjectDiscoveryTest: {
   readonly layer: (entries: ReadonlyArray<TestFileEntry>) => Layer.Layer<ProjectDiscovery>;
@@ -1865,8 +1865,8 @@ export interface SqliteStack {
 }
 /**
  * The Node platform services every SQLite stack and every Live layer share.
- * `NodeServices.layer` aggregates FileSystem | Path | ChildProcessSpawner |
- * Crypto | Stdio | Terminal.
+ * `NodeServices.layer` aggregates ChildProcessSpawner | FileSystem | Path |
+ * Stdio | Terminal; since Effect 4.1 it carries no crypto service.
  * @public
  */
 export declare const NodePlatformLayer: Layer.Layer<NodeServices.NodeServices, never, never>;
@@ -2207,7 +2207,7 @@ export interface RecordTddArtifactResult {
  * @param input - the artifact to record, keyed by host chat id
  * @public
  */
-export declare const recordTddArtifactEffect: (input: RecordTddArtifactInput) => Effect.Effect<RecordTddArtifactResult, DataStoreError | Error, DataReader | DataStore | FileSystem.FileSystem>;
+export declare const recordTddArtifactEffect: (input: RecordTddArtifactInput) => Effect.Effect<RecordTddArtifactResult, DataStoreError | Error, DataReader | DataStore | FileSystem.FileSystem | Path.Path>;
 /**
  * Input for {@link recordTddArtifactByTaskIdEffect}: an artifact keyed by an
  * explicit TDD task id.
@@ -2290,7 +2290,7 @@ export interface DispatchRecordTddArtifactInput {
  * @param input - the artifact plus either a chat id or a TDD task id
  * @public
  */
-export declare const dispatchRecordTddArtifactEffect: (input: DispatchRecordTddArtifactInput) => Effect.Effect<RecordTddArtifactResult, DataStoreError | Error, DataReader | DataStore | FileSystem.FileSystem>;
+export declare const dispatchRecordTddArtifactEffect: (input: DispatchRecordTddArtifactInput) => Effect.Effect<RecordTddArtifactResult, DataStoreError | Error, DataReader | DataStore | FileSystem.FileSystem | Path.Path>;
 /**
  * Outcome of {@link parseAndValidateTurnPayload}: the decoded `TurnPayload`
  * on success, or a human-readable error string.
@@ -2308,6 +2308,9 @@ export type ParseResult = {
  * Parse a raw JSON string and validate it against the `TurnPayload` schema
  * without throwing.
  *
+ * Text that is not JSON at all reads `Invalid JSON: …`; JSON whose body is
+ * not a `TurnPayload` reads `Invalid TurnPayload: …`.
+ *
  * @param raw - the JSON text delivered by the hook
  * @returns the decoded payload, or an error describing why it was rejected
  * @public
@@ -2350,7 +2353,7 @@ export interface RecordTurnInput {
  */
 export declare const recordTurnEffect: (input: RecordTurnInput) => Effect.Effect<{
   turnId: number;
-}, Error, DataReader | DataStore | FileSystem.FileSystem>;
+}, Error, DataReader | DataStore | FileSystem.FileSystem | Path.Path>;
 /**
  * Input for {@link recordRunWorkspaceChangesEffect}: one commit plus the
  * files it touched.
@@ -2485,7 +2488,7 @@ export interface ResolveSessionForRecordingInput {
  * @returns the resolved (or newly created) session row
  * @public
  */
-export declare const resolveSessionForRecording: (input: ResolveSessionForRecordingInput) => Effect.Effect<SessionDetail, DataStoreError, DataReader | DataStore | FileSystem.FileSystem>;
+export declare const resolveSessionForRecording: (input: ResolveSessionForRecordingInput) => Effect.Effect<SessionDetail, DataStoreError, DataReader | DataStore | FileSystem.FileSystem | Path.Path>;
 /**
  * Recovered session attribution context — the canonical UUIDs the
  * SessionStart hook wrote to `${CLAUDE_ENV_FILE}` (auto-sourced into the
@@ -2854,7 +2857,7 @@ export interface ResolveDataPathOptions {
  * @param options - Optional programmatic overrides.
  * @public
  */
-export declare const resolveDataPath: (projectDir: string, options?: ResolveDataPathOptions) => Effect.Effect<string, import("@effected/xdg").AppDirsError | import("effect/PlatformError").PlatformError | ProjectIdentitySourceError | import("@effected/config-file").ConfigReadError<import("@effected/config-file").ConfigCodecError>, AppDirs$1 | FileSystem.FileSystem | VitestAgentConfigFile>;
+export declare const resolveDataPath: (projectDir: string, options?: ResolveDataPathOptions) => Effect.Effect<string, import("@effected/xdg").AppDirsError | import("effect/PlatformError").PlatformError | ProjectIdentitySourceError | import("@effected/config-file").ConfigReadError<import("@effected/config-file").ConfigCodecError>, AppDirs$1 | FileSystem.FileSystem | import("effect/Path").Path | VitestAgentConfigFile>;
 /**
  * Compute the project key for a workspace by reading `package.json`
  * fields directly. Returns the canonical `host__path` form when a git
@@ -2864,15 +2867,17 @@ export declare const resolveDataPath: (projectDir: string, options?: ResolveData
  * (or `"anonymous-project"`) so callers don't have to handle the
  * empty case.
  *
- * Synchronous and reads the real disk through `node:fs`; Effect callers
- * that already hold a `FileSystem` use
- * {@link resolveProjectKeyFromCwdEffect}, which applies the same rules.
+ * Synchronous and reads the real disk through `node:fs`: it runs
+ * {@link resolveProjectKeyFromCwdEffect} under `Effect.runSync` over a
+ * read-only synchronous `FileSystem` and the host's Node `Path`. Effect
+ * callers that already hold a `FileSystem` and `Path` use the Effect form
+ * directly.
  * @public
  */
 export declare const resolveProjectKeyFromCwd: (cwd: string) => string;
 /**
  * {@link resolveProjectKeyFromCwd} read through the ambient
- * `FileSystem` service instead of `node:fs` — same upward walk to the
+ * `FileSystem` and `Path` services instead of `node:fs` — same upward walk to the
  * nearest `package.json` (`@effected/walker`'s `Walker.ascend` +
  * `Walker.findUpward`), same precedence, same basename fallback.
  *
@@ -2883,7 +2888,7 @@ export declare const resolveProjectKeyFromCwd: (cwd: string) => string;
  * @param cwd - Absolute directory to start the upward walk from.
  * @public
  */
-export declare const resolveProjectKeyFromCwdEffect: (cwd: string) => Effect.Effect<string, never, FileSystem.FileSystem>;
+export declare const resolveProjectKeyFromCwdEffect: (cwd: string) => Effect.Effect<string, never, FileSystem.FileSystem | Path.Path>;
 /**
  * Resolve the normalized workspace key for the workspace containing
  * `projectDir`.

package/layers/DataStoreLive.js

@@ -1,10 +1,10 @@
 import { DataStore, INLINE_ATTACHMENT_BODY_CAP_BYTES } from "../services/DataStore.js";
 import { PersistBatch, withPersistSavepoint } from "../utils/persist-transaction.js";
-import { Agent, AgentNotFoundError, BehaviorNotFoundError, DataStoreError, GoalNotFoundError, IdempotencyHit, IllegalStatusTransitionError, RegistrationConflictError, TddTaskAlreadyEndedError, TddTaskNotFoundError, coerceErrorText, extractSqlReason } from "@vitest-agent/sdk";
-import { Clock, Effect, Layer, Option } from "effect";
+import { Agent, AgentNotFoundError, BehaviorNotFoundError, DataStoreError, FileEditPayload, GoalNotFoundError, IdempotencyHit, IllegalStatusTransitionError, RegistrationConflictError, TddTaskAlreadyEndedError, TddTaskNotFoundError, ToolResultPayload, coerceErrorText, extractSqlReason } from "@vitest-agent/sdk";
+import { Clock, Effect, Layer, Option, Schema, Struct } from "effect";
 import { SqlClient } from "effect/sql/SqlClient";
 import { Buffer } from "node:buffer";
-import { randomUUID } from "node:crypto";
+import { SecureRandom } from "effect/crypto";
 
 // src/layers/DataStoreLive.ts
 /**
@@ -50,6 +50,8 @@ const behaviorRowFromDb = (row) => ({
 	createdAt: row.created_at
 });
 const boolToInt = (v) => v === void 0 ? null : v ? 1 : 0;
+const decodeFileEditPayload = Schema.decodeUnknownEffect(Schema.fromJsonString(FileEditPayload.mapFields(Struct.omit(["type"]))));
+const decodeToolResultPayload = Schema.decodeUnknownEffect(Schema.fromJsonString(ToolResultPayload.mapFields(Struct.omit(["type"]))));
 /** @public */
 const DataStoreLive = Layer.effect(DataStore, Effect.gen(function* () {
 	const sql = yield* SqlClient;
@@ -456,45 +458,42 @@ const DataStoreLive = Layer.effect(DataStore, Effect.gen(function* () {
 		if (input.turnNo !== void 0) yield* sql`INSERT INTO turns (session_id, turn_no, type, payload, occurred_at) VALUES (${input.sessionId}, ${input.turnNo}, ${input.type}, ${input.payload}, ${input.occurredAt})`;
 		else yield* sql`INSERT INTO turns (session_id, turn_no, type, payload, occurred_at) SELECT ${input.sessionId}, COALESCE(MAX(turn_no), 0) + 1, ${input.type}, ${input.payload}, ${input.occurredAt} FROM turns WHERE session_id = ${input.sessionId}`;
 		const turnId = (yield* sql`SELECT last_insert_rowid() as id`)[0].id;
-		if (input.type === "file_edit" || input.type === "tool_result") {
-			const payload = yield* Effect.try({
-				try: () => JSON.parse(input.payload),
-				catch: (e) => new DataStoreError({
-					operation: "write",
-					table: input.type === "file_edit" ? "file_edits" : "tool_invocations",
-					reason: `invalid turn payload JSON: ${e.message}`
-				})
-			});
-			if (input.type === "file_edit") {
-				const filePath = payload.file_path;
-				yield* sql`INSERT OR IGNORE INTO files (path) VALUES (${filePath})`;
-				const fileId = (yield* sql`SELECT id FROM files WHERE path = ${filePath}`)[0].id;
-				yield* sql`
-									INSERT INTO file_edits (turn_id, file_id, edit_kind, lines_added, lines_removed, diff)
-									VALUES (
-										${turnId},
-										${fileId},
-										${payload.edit_kind},
-										${payload.lines_added ?? null},
-										${payload.lines_removed ?? null},
-										${payload.diff ?? null}
-									)
-								`;
-			} else {
-				const rawToolName = payload.tool_name;
-				const toolName = typeof rawToolName === "string" && rawToolName.startsWith("mcp__") ? rawToolName.split("__").at(-1) ?? rawToolName : rawToolName;
-				yield* sql`
-									INSERT INTO tool_invocations (turn_id, tool_name, params_hash, result_summary, duration_ms, success)
-									VALUES (
-										${turnId},
-										${toolName},
-										${null},
-										${payload.result_summary ?? null},
-										${payload.duration_ms ?? null},
-										${boolToInt(payload.success) ?? 0}
-									)
-								`;
-			}
+		const invalidPayload = (table) => (e) => new DataStoreError({
+			operation: "write",
+			table,
+			reason: `invalid turn payload: ${e.message}`
+		});
+		if (input.type === "file_edit") {
+			const payload = yield* decodeFileEditPayload(input.payload).pipe(Effect.mapError(invalidPayload("file_edits")));
+			const filePath = payload.file_path;
+			yield* sql`INSERT OR IGNORE INTO files (path) VALUES (${filePath})`;
+			const fileId = (yield* sql`SELECT id FROM files WHERE path = ${filePath}`)[0].id;
+			yield* sql`
+								INSERT INTO file_edits (turn_id, file_id, edit_kind, lines_added, lines_removed, diff)
+								VALUES (
+									${turnId},
+									${fileId},
+									${payload.edit_kind},
+									${payload.lines_added ?? null},
+									${payload.lines_removed ?? null},
+									${payload.diff ?? null}
+								)
+							`;
+		} else if (input.type === "tool_result") {
+			const payload = yield* decodeToolResultPayload(input.payload).pipe(Effect.mapError(invalidPayload("tool_invocations")));
+			const rawToolName = payload.tool_name;
+			const toolName = rawToolName.startsWith("mcp__") ? rawToolName.split("__").at(-1) ?? rawToolName : rawToolName;
+			yield* sql`
+								INSERT INTO tool_invocations (turn_id, tool_name, params_hash, result_summary, duration_ms, success)
+								VALUES (
+									${turnId},
+									${toolName},
+									${null},
+									${payload.result_summary ?? null},
+									${payload.duration_ms ?? null},
+									${boolToInt(payload.success) ?? 0}
+								)
+							`;
 		}
 		return turnId;
 	})).pipe(Effect.annotateLogs("service", "DataStore"), Effect.mapError((e) => e instanceof DataStoreError ? e : new DataStoreError({
@@ -1295,7 +1294,7 @@ const DataStoreLive = Layer.effect(DataStore, Effect.gen(function* () {
 			const parentSession = parentRows[0].session_id;
 			if (parentSession !== input.sessionId && parentSession !== registeringParentSessionId) return yield* Effect.fail(new RegistrationConflictError({ reason: `parent agent ${input.parentAgentId} belongs to session ${parentSession}, which is neither the registering session ${input.sessionId} nor its parent session ${registeringParentSessionId ?? "(none)"}` }));
 		}
-		const agentId = input.agentId ?? randomUUID();
+		const agentId = input.agentId ?? SecureRandom.uuidV4Unsafe();
 		yield* sql`
 					INSERT INTO agents (
 						agent_id, session_id, parent_agent_id, conversation_id, agent_type,

package/layers/PerClientSessionMapLive.js

@@ -2,7 +2,7 @@ import { PerClientSessionMapReader, PerClientSessionMapWriter } from "../service
 import { DataStoreError, extractSqlReason } from "@vitest-agent/sdk";
 import { Effect, Layer, Option } from "effect";
 import { SqlClient } from "effect/sql/SqlClient";
-import { randomUUID } from "node:crypto";
+import { SecureRandom } from "effect/crypto";
 import { basename } from "node:path";
 
 // src/layers/PerClientSessionMapLive.ts
@@ -83,7 +83,7 @@ const PerClientSessionMapWriterLive = Layer.effect(PerClientSessionMapWriter, Ef
 			yield* sql`UPDATE conversation_map SET last_seen_at = ${now} WHERE transcript_uuid = ${uuid}`;
 			return existing[0].conversation_id;
 		}
-		const conversationId = randomUUID();
+		const conversationId = SecureRandom.uuidV4Unsafe();
 		yield* sql`
 					INSERT INTO conversation_map (transcript_uuid, transcript_path, conversation_id, first_seen_at, last_seen_at)
 					VALUES (${uuid}, ${transcriptPath}, ${conversationId}, ${now}, ${now})
@@ -102,7 +102,7 @@ const PerClientSessionMapWriterLive = Layer.effect(PerClientSessionMapWriter, Ef
 			mainAgentId: existing[0].main_agent_id,
 			conversationId: existing[0].conversation_id
 		};
-		const mainAgentId = randomUUID();
+		const mainAgentId = SecureRandom.uuidV4Unsafe();
 		const now = Date.now();
 		yield* sql`
 					INSERT INTO session_map (

package/layers/ProjectDiscoveryLive.js

@@ -1,6 +1,7 @@
 import { ProjectDiscovery } from "../services/ProjectDiscovery.js";
 import { DiscoveryError, NON_DISCOVERABLE_DIRS } from "@vitest-agent/sdk";
 import { Effect, FileSystem, Layer, Path } from "effect";
+import { ErrorText } from "@effected/engine";
 import { GlobPattern, GlobPatternOptions } from "@effected/glob";
 import { descend } from "@effected/walker";
 
@@ -17,39 +18,39 @@ function testFileToSource(testFile) {
 	return testFile.replace(/\.(test|spec)\.(ts|tsx)$/, ".$2");
 }
 /**
-* Every test file under `rootDir`, as `${rootDir}/<relative>` paths sorted by
-* relative path. `@effected/walker`'s `descend` follows directory symlinks
+* Every test file under `rootDir`, each joined to `rootDir` with the ambient
+* `Path` (backslashes on win32), sorted by relative path. `@effected/walker`'s `descend` follows directory symlinks
 * (as the former `fs.stat`-based walk did) under its ancestor-chain cycle
 * guard, so a link back to an ancestor is skipped instead of recursing until
 * the OS answers `ELOOP` and failing the whole discovery.
 */
 const walkTestFiles = (rootDir) => Effect.gen(function* () {
 	const pattern = yield* GlobPattern.compile(TEST_FILE_GLOB, TEST_FILE_GLOB_OPTIONS);
-	const relative = yield* descend(pattern, {
+	const path = yield* Path.Path;
+	return (yield* descend(pattern, {
 		cwd: rootDir,
 		prune: SKIP_DIRS,
 		followSymlinks: true
-	});
-	const base = rootDir.endsWith("/") ? rootDir.slice(0, -1) : rootDir;
-	return relative.map((rel) => `${base}/${rel}`);
-}).pipe(Effect.provide(Path.layer));
+	})).map((rel) => path.join(rootDir, rel));
+});
 /** @public */
 const ProjectDiscoveryLive = Layer.effect(ProjectDiscovery, Effect.gen(function* () {
 	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
 	const mapTestToSource = (testFile) => Effect.gen(function* () {
 		const sourceFile = testFileToSource(testFile);
 		return (yield* fs.exists(sourceFile)) ? [sourceFile] : [];
 	}).pipe(Effect.mapError((error) => new DiscoveryError({
 		operation: "stat",
 		path: testFile,
-		reason: String(error)
+		reason: ErrorText.describe(error)
 	})));
 	return {
 		discoverTestFiles: (rootDir) => Effect.gen(function* () {
-			const testFiles = yield* walkTestFiles(rootDir).pipe(Effect.provideService(FileSystem.FileSystem, fs), Effect.mapError((error) => new DiscoveryError({
+			const testFiles = yield* walkTestFiles(rootDir).pipe(Effect.provideService(FileSystem.FileSystem, fs), Effect.provideService(Path.Path, path), Effect.mapError((error) => new DiscoveryError({
 				operation: "glob",
 				path: rootDir,
-				reason: String(error)
+				reason: ErrorText.describe(error)
 			})));
 			const entries = [];
 			for (const testFile of testFiles) {

package/layers/ProjectIdentityLive.js

@@ -6,11 +6,10 @@ import { ProjectIdentityNotResolvableError, ProjectIdentitySourceError, VitestAg
 import { Effect, FileSystem, Layer, Option, Result } from "effect";
 import { WorkspaceDiscovery } from "@effected/workspaces";
 import { AppDirs } from "@effected/xdg";
+import { ErrorText } from "@effected/engine";
 import { LenientManifest } from "@effected/package-json";
 
 // src/layers/ProjectIdentityLive.ts
-/** The one-line text of a kit failure, for `ProjectIdentitySourceError.detail`. */
-const detailOf = (cause) => cause instanceof Error && cause.message.length > 0 ? cause.message : String(cause);
 /**
 * 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
@@ -38,14 +37,14 @@ const readPackageRepoUrl = (packageJsonPath) => Effect.gen(function* () {
 	const raw = yield* (yield* FileSystem.FileSystem).readFileString(packageJsonPath).pipe(Effect.map(Option.some), Effect.catchTag("PlatformError", (error) => error.reason._tag === "NotFound" ? Effect.succeed(Option.none()) : Effect.fail(new ProjectIdentitySourceError({
 		source: "package-json",
 		path: packageJsonPath,
-		detail: detailOf(error),
+		detail: ErrorText.describe(error),
 		cause: error
 	}))));
 	if (Option.isNone(raw)) 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),
+		detail: ErrorText.describe(cause),
 		cause
 	}))));
 	return Option.flatMap(manifest, (m) => Option.fromNullishOr(repositoryUrlOf(m.repository)));
@@ -54,14 +53,14 @@ const collectCandidates = (workspaceRoot, options) => Effect.gen(function* () {
 	const tomlConfig = yield* (yield* VitestAgentConfigFile).loadOrDefault(new VitestAgentConfig({})).pipe(Effect.mapError((cause) => new ProjectIdentitySourceError({
 		source: "toml",
 		path: cause._tag === "ConfigValidationError" ? Option.getOrElse(cause.path, () => workspaceRoot) : cause.path ?? workspaceRoot,
-		detail: detailOf(cause),
+		detail: ErrorText.describe(cause),
 		cause
 	})));
 	const gitRemote = yield* readGitRemote(workspaceRoot);
 	const root = (yield* (yield* WorkspaceDiscovery).listPackagesIn(workspaceRoot).pipe(Effect.catchTag("WorkspaceRootNotFoundError", () => Effect.succeed([])), Effect.mapError((cause) => new ProjectIdentitySourceError({
 		source: "workspace",
 		path: cause._tag === "WorkspacePatternError" ? cause.root : cause.path,
-		detail: detailOf(cause),
+		detail: ErrorText.describe(cause),
 		cause
 	})))).find((pkg) => pkg.isRootWorkspace);
 	const packageJsonRepoUrl = root ? yield* readPackageRepoUrl(root.packageJsonPath) : Option.none();

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vitest-agent/engine",
-	"version": "3.0.1",
+	"version": "3.1.0",
 	"private": false,
 	"description": "Shared services, layers, SQLite data layer, migrations and platform resolution for the vitest-agent CLI and MCP server.",
 	"keywords": [
@@ -40,25 +40,26 @@
 		"./package.json": "./package.json"
 	},
 	"dependencies": {
-		"@effect/platform-node": "^4.0.7",
-		"@effect/sql-sqlite-node": "^4.0.7",
-		"@effected/app": "^0.29.0",
-		"@effected/cli": "^0.24.0",
-		"@effected/config-file": "^0.22.0",
-		"@effected/engine": "^0.10.0",
-		"@effected/env": "^0.7.0",
-		"@effected/git": "^0.27.0",
-		"@effected/glob": "^0.16.0",
-		"@effected/jsonc": "^0.21.0",
-		"@effected/package-json": "^0.27.0",
-		"@effected/store": "^0.21.0",
-		"@effected/toml": "^0.17.0",
-		"@effected/walker": "^0.22.0",
-		"@effected/workspaces": "^0.40.0",
-		"@effected/xdg": "^0.17.0",
-		"@effected/yaml": "^0.26.0",
-		"@vitest-agent/sdk": "9.0.1",
-		"effect": "^4.0.7"
+		"@effect/platform-node": "~4.1.1",
+		"@effect/sql-sqlite-node": "~4.1.1",
+		"@effected/app": "^0.30.0",
+		"@effected/cli": "^0.25.0",
+		"@effected/config-file": "^0.23.0",
+		"@effected/engine": "^0.11.0",
+		"@effected/env": "^0.9.0",
+		"@effected/git": "^0.29.0",
+		"@effected/glob": "^0.17.0",
+		"@effected/jsonc": "^0.22.0",
+		"@effected/memfs": "^0.22.0",
+		"@effected/package-json": "^0.28.0",
+		"@effected/store": "^0.22.0",
+		"@effected/toml": "^0.18.0",
+		"@effected/walker": "^0.24.0",
+		"@effected/workspaces": "^0.41.0",
+		"@effected/xdg": "^0.18.0",
+		"@effected/yaml": "^0.27.0",
+		"@vitest-agent/sdk": "9.0.2",
+		"effect": "~4.1.1"
 	},
 	"engines": {
 		"node": ">=24.11.0"

package/platform.js

@@ -15,8 +15,8 @@ import { Store } from "@effected/store";
 // src/platform.ts
 /**
 * The Node platform services every SQLite stack and every Live layer share.
-* `NodeServices.layer` aggregates FileSystem | Path | ChildProcessSpawner |
-* Crypto | Stdio | Terminal.
+* `NodeServices.layer` aggregates ChildProcessSpawner | FileSystem | Path |
+* Stdio | Terminal; since Effect 4.1 it carries no crypto service.
 * @public
 */
 const NodePlatformLayer = NodeServices.layer;

package/programs/hook-paths.js

@@ -4,9 +4,9 @@ import { LEDGER_OPTIONS } from "../stores.js";
 import { ProjectIdentityNotResolvableError } from "@vitest-agent/sdk";
 import { Effect, FileSystem, Layer, Option, Path } from "effect";
 import { AppDirs, Xdg } from "@effected/xdg";
+import { LaunchContext } from "@effected/engine";
 import { Store } from "@effected/store";
 import { AppStore } from "@effected/app";
-import { LaunchContext } from "@effected/engine";
 
 // src/programs/hook-paths.ts
 /**

package/programs/record-turn.js

@@ -1,37 +1,31 @@
 import { DataStore } from "../services/DataStore.js";
 import { resolveSessionForRecording } from "./resolve-session-for-recording.js";
 import { TurnPayload } from "@vitest-agent/sdk";
-import { Effect, Schema } from "effect";
-import { ErrorText } from "@effected/engine";
+import { Effect, Result, Schema } from "effect";
 
 // src/programs/record-turn.ts
+const decodeTurnPayload = Schema.decodeUnknownResult(Schema.fromJsonString(TurnPayload));
 /**
 * Parse a raw JSON string and validate it against the `TurnPayload` schema
 * without throwing.
 *
+* Text that is not JSON at all reads `Invalid JSON: …`; JSON whose body is
+* not a `TurnPayload` reads `Invalid TurnPayload: …`.
+*
 * @param raw - the JSON text delivered by the hook
 * @returns the decoded payload, or an error describing why it was rejected
 * @public
 */
 const parseAndValidateTurnPayload = (raw) => {
-	let parsed;
-	try {
-		parsed = JSON.parse(raw);
-	} catch (e) {
-		return {
-			ok: false,
-			error: `Invalid JSON: ${ErrorText.describe(e)}`
-		};
-	}
-	const decoded = Schema.decodeUnknownResult(TurnPayload)(parsed);
-	if (decoded._tag === "Failure") return {
-		ok: false,
-		error: `Invalid TurnPayload: ${decoded.failure.message}`
-	};
-	return {
+	const decoded = decodeTurnPayload(raw);
+	if (Result.isSuccess(decoded)) return {
 		ok: true,
 		payload: decoded.success
 	};
+	return {
+		ok: false,
+		error: `${decoded.failure.issue._tag === "Encoding" ? "Invalid JSON" : "Invalid TurnPayload"}: ${decoded.failure.message}`
+	};
 };
 /**
 * Validate a turn payload and write it as a `turns` row under the session

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

@@ -1,6 +1,6 @@
 import { DataReader } from "../services/DataReader.js";
 import { DataStore } from "../services/DataStore.js";
-import { Effect, FileSystem, Option } from "effect";
+import { Effect, FileSystem, Option, Path } from "effect";
 import { LenientManifest } from "@effected/package-json";
 
 // src/programs/resolve-session-for-recording.ts
@@ -17,12 +17,13 @@ const resolveSessionForRecording = (input) => Effect.gen(function* () {
 	const reader = yield* DataReader;
 	const store = yield* DataStore;
 	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
 	const exact = yield* reader.getSessionByChatId(input.chatId);
 	if (Option.isSome(exact)) return exact.value;
 	const synthetic = yield* reader.findSessionsByChatPrefix(`${input.chatId}-subagent-`);
 	if (synthetic.length > 0) return synthetic[0];
 	const cwd = input.cwd;
-	const project = input.project ?? (yield* readPackageName(fs, cwd)) ?? "unknown";
+	const project = input.project ?? (yield* readPackageName(fs, path.join(cwd, "package.json"))) ?? "unknown";
 	yield* store.upsertSession({
 		chatId: input.chatId,
 		project,
@@ -40,6 +41,6 @@ const resolveSessionForRecording = (input) => Effect.gen(function* () {
 * 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(LenientManifest.parse), Effect.map((manifest) => manifest.name), Effect.orElseSucceed(() => void 0));
+const readPackageName = (fs, packageJsonPath) => fs.readFileString(packageJsonPath).pipe(Effect.flatMap(LenientManifest.parse), Effect.map((manifest) => manifest.name), Effect.orElseSucceed(() => void 0));
 
 export { resolveSessionForRecording };

package/utils/resolve-project-key-from-cwd.js

@@ -1,19 +1,14 @@
 import { repositoryUrlOf } from "./package-manifest.js";
 import { gitUrlToProjectKey } from "@vitest-agent/sdk";
-import { Effect, FileSystem, Option, Path, Result } from "effect";
+import { Effect, FileSystem, Layer, Option, Path, Result } from "effect";
+import * as NodePath from "@effect/platform-node/NodePath";
 import { AppDirs } from "@effected/xdg";
-import { join } from "node:path";
 import { Walker } from "@effected/walker";
 import { LenientManifest } from "@effected/package-json";
-import { readFileSync } from "node:fs";
-import { nodeWalkerSyncOps } from "@effected/walker/node-sync";
+import { NodeSyncFileSystem } from "@effected/memfs/node-sync";
 
 // src/utils/resolve-project-key-from-cwd.ts
 const PACKAGE_JSON = "package.json";
-const findNearestPackageJson = (startDir) => {
-	const dirs = Walker.ascendSync(startDir, { path: nodeWalkerSyncOps.path });
-	return Option.getOrNull(Walker.findUpwardSync(dirs, (dir) => [join(dir, PACKAGE_JSON)], nodeWalkerSyncOps));
-};
 /**
 * The key a `package.json` body names: the canonical `host__path` form of
 * `repository.url` when present and canonicalizable, else the normalized
@@ -32,10 +27,11 @@ const keyFromPackageJson = (content) => {
 	if (manifest.name !== void 0) return Result.getOrNull(AppDirs.segment(manifest.name));
 	return null;
 };
-const basenameKey = (cwd) => {
-	const basename = cwd.split("/").filter((segment) => segment.length > 0).pop() ?? "anonymous-project";
-	return Result.getOrElse(AppDirs.segment(basename), () => "anonymous-project");
+const basenameKey = (path, cwd) => {
+	const basename = path.basename(cwd);
+	return basename.length === 0 ? "anonymous-project" : Result.getOrElse(AppDirs.segment(basename), () => "anonymous-project");
 };
+const NodeSyncPlatform = Layer.merge(NodeSyncFileSystem.layer, NodePath.layer);
 /**
 * Compute the project key for a workspace by reading `package.json`
 * fields directly. Returns the canonical `host__path` form when a git
@@ -45,26 +41,17 @@ const basenameKey = (cwd) => {
 * (or `"anonymous-project"`) so callers don't have to handle the
 * empty case.
 *
-* Synchronous and reads the real disk through `node:fs`; Effect callers
-* that already hold a `FileSystem` use
-* {@link resolveProjectKeyFromCwdEffect}, which applies the same rules.
+* Synchronous and reads the real disk through `node:fs`: it runs
+* {@link resolveProjectKeyFromCwdEffect} under `Effect.runSync` over a
+* read-only synchronous `FileSystem` and the host's Node `Path`. Effect
+* callers that already hold a `FileSystem` and `Path` use the Effect form
+* directly.
 * @public
 */
-const resolveProjectKeyFromCwd = (cwd) => {
-	const pkgPath = findNearestPackageJson(cwd);
-	if (pkgPath !== null) {
-		let content = null;
-		try {
-			content = readFileSync(pkgPath, "utf-8");
-		} catch {}
-		const key = content === null ? null : keyFromPackageJson(content);
-		if (key !== null) return key;
-	}
-	return basenameKey(cwd);
-};
+const resolveProjectKeyFromCwd = (cwd) => Effect.runSync(resolveProjectKeyFromCwdEffect(cwd).pipe(Effect.provide(NodeSyncPlatform)));
 /**
 * {@link resolveProjectKeyFromCwd} read through the ambient
-* `FileSystem` service instead of `node:fs` — same upward walk to the
+* `FileSystem` and `Path` services instead of `node:fs` — same upward walk to the
 * nearest `package.json` (`@effected/walker`'s `Walker.ascend` +
 * `Walker.findUpward`), same precedence, same basename fallback.
 *
@@ -77,11 +64,12 @@ const resolveProjectKeyFromCwd = (cwd) => {
 */
 const resolveProjectKeyFromCwdEffect = (cwd) => Effect.gen(function* () {
 	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
 	const dirs = yield* Walker.ascend(cwd);
-	const found = yield* Walker.findUpward(dirs, (dir) => [join(dir, PACKAGE_JSON)]);
-	if (Option.isNone(found)) return basenameKey(cwd);
+	const found = yield* Walker.findUpward(dirs, (dir) => [path.join(dir, PACKAGE_JSON)]);
+	if (Option.isNone(found)) return basenameKey(path, cwd);
 	const content = yield* fs.readFileString(found.value).pipe(Effect.orElseSucceed(() => null));
-	return (content === null ? null : keyFromPackageJson(content)) ?? basenameKey(cwd);
-}).pipe(Effect.provide(Path.layer));
+	return (content === null ? null : keyFromPackageJson(content)) ?? basenameKey(path, cwd);
+});
 
 export { resolveProjectKeyFromCwd, resolveProjectKeyFromCwdEffect };

package/version.js

@@ -1,5 +1,5 @@
 // src/version.ts
 /** Build-time injected package version (see architecture.md D36). @public */
-const CURRENT_ENGINE_VERSION = "3.0.1";
+const CURRENT_ENGINE_VERSION = "3.1.0";
 
 export { CURRENT_ENGINE_VERSION };