@vitest-agent/engine 0.3.1 → 0.4.0

package/index.d.ts

@@ -2,6 +2,7 @@ import { Context, Effect, FileSystem, Layer, LogLevel, Option, Path, Schema } fr
 import { ConfigFileShape } from "@effected/config-file";
 import { Agent, AgentNotFoundError, AgentReport, ArtifactKind, ArtifactKind as ArtifactKind$1, ArtifactSuite, ArtifactSuite as ArtifactSuite$1, BehaviorDetail, BehaviorNotFoundError, BehaviorRow, BehaviorStatus, CacheManifest, CitedArtifact, CoverageBaselines, CoverageReport, DataStoreError, DetailLevel, DiscoveryError, Environment, Executor, FileCoverageReport, FormatterContext, GoalDetail, GoalNotFoundError, GoalRow, GoalStatus, HistoryRecord, IdempotencyHit, IllegalStatusTransitionError, OutputFormat, Phase, ProjectIdentityNotResolvableError, RegistrationConflictError, RenderedOutput, ResolvedThresholds, TddTaskAlreadyEndedError, TddTaskNotFoundError, TestClassification, TestRun, TrendEntry, TrendRecord, TurnPayload, VitestAgentConfig } from "@vitest-agent/sdk";
 import { SqlClient } from "effect/sql/SqlClient";
+import { RuntimeEnv } from "@effected/env";
 import { WorkspaceDiscovery, WorkspaceDiscoveryFailure, WorkspaceRootNotFoundError } from "@effected/workspaces";
 import { AppDirs, AppDirsError, XdgEnvError } from "@effected/xdg";
 import { ChildProcessSpawner } from "effect/process";
@@ -1206,14 +1207,24 @@ export declare class EnvironmentDetector extends EnvironmentDetector_base {}
  * Pure classification behind {@link EnvironmentDetectorLive}: an agent shell
  * wins, then GitHub Actions, then generic CI, else a terminal.
  *
- * @param env - the environment map to consult
- * @param agentShell - whether the process runs under an AI agent (`std-env`'s `isAgent`)
+ * @remarks
+ * The agent/CI/human split is `@effected/env`'s `Audience.detect`, so the
+ * engine and every `@effected/cli` front end agree on who is running; this
+ * only refines CI into GitHub Actions versus any other CI.
+ *
+ * @param runtime - the `@effected/env` runtime snapshot to classify
  * @public
  */
-export declare const classifyEnvironment: (env: Record<string, string | undefined>, agentShell: boolean) => Environment;
+export declare const classifyEnvironment: (runtime: RuntimeEnv) => Environment;
 /**
- * Live environment detector. CI detection reads `GITHUB_ACTIONS` / `CI`
- * from the injected `env` map; agent detection comes from `std-env`.
+ * Live environment detector over `@effected/env`'s `CurrentRuntimeEnv`, read
+ * from the injected `env` map only: agent, GitHub Actions and generic CI
+ * detection all come from `env`, never from the ambient process.
+ *
+ * @remarks
+ * The snapshot is taken once, when the layer is built, through
+ * `CurrentRuntimeEnv.layerFrom(env)`: a fresh layer per call and per use, so two
+ * detectors built over different maps in one layer graph each see their own.
  *
  * @param env - the environment map to consult (the front end passes `process.env`)
  * @public
@@ -1313,15 +1324,35 @@ export declare const HistoryTrackerTest: {
 //#endregion
 //#region src/layers/LoggerLive.d.ts
 /**
- * Create a structured JSON (NDJSON) logger layer for stderr.
+ * Create a structured JSON (NDJSON) logger layer for stderr, over
+ * `@effected/cli`'s `CliLog` in its diagnostics-only mode
+ * (`format: "json"`, `plainLogger: false`): the already-resolved level is
+ * passed as `level`, and no plain `CliLogger` is installed beside the sink, so
+ * each record prints once and nothing reads the audience or the terminal.
  *
  * When level is undefined or `"None"`, installs an empty logger set (silent).
- * When logFile is set, composes the stderr logger with a file logger.
- * Uses `Logger.formatJson` / `Logger.formatStructured` for machine-readable
- * output.
+ * When logFile is set, `CliLog`'s asynchronous file sink also appends each
+ * NDJSON line (the same shape as the stderr line) to that file; the first
+ * write error prints one stderr line and disables the file sink.
+ *
+ * When `env` is given, it is built into `CurrentRuntimeEnv` for the layer's
+ * own build context, which `CliLog` captures: under GitHub Actions every
+ * stderr record is neutralized (no workflow command at line start, `##[`
+ * escaped), including records logged from a fiber that carries no
+ * `CurrentRuntimeEnv` of its own. Without `env`, records are sanitised but
+ * not neutralized unless the logging fiber provides one.
+ *
+ * @remarks
+ * The file sink needs `FileSystem` and `Path`. `CliLog` leaves them in `R`
+ * (for `file: undefined` too), but they are provided here (Node) so the
+ * public signature stays `Layer.Layer<never>` for every caller.
+ *
+ * @param level - the diagnostics level; see {@link resolveLogLevel}
+ * @param logFile - a file to append NDJSON lines to; see {@link resolveLogFile}
+ * @param env - the environment map to detect the runtime from (the front end passes `process.env`)
  * @public
  */
-export declare const LoggerLive: (level?: LogLevel.LogLevel, logFile?: string) => Layer.Layer<never>;
+export declare const LoggerLive: (level?: LogLevel.LogLevel, logFile?: string, env?: Readonly<Record<string, string | undefined>>) => Layer.Layer<never>;
 /**
  * Resolve log level from option or environment variable.
  * Priority: explicit option \> `VITEST_REPORTER_LOG_LEVEL` in `env` \> undefined.
@@ -1835,6 +1866,15 @@ export interface PlatformOptions {
   readonly logLevel?: LogLevel.LogLevel | undefined;
   /** Optional path for structured NDJSON log output. */
   readonly logFile?: string | undefined;
+  /**
+   * Whether `PlatformLive` installs its own logger set (`LoggerLive`, from
+   * `logLevel` / `logFile`). Defaults to `true`. Pass `false` when the caller
+   * already owns the logger set (for example `@effected/cli`'s `CliLog`
+   * installed by `CliRuntime.main`'s `env.log`): `LoggerLive` replaces the
+   * installed loggers, so leaving it in would silence the caller's set.
+   * `logLevel` and `logFile` are ignored when this is `false`.
+   */
+  readonly logger?: boolean | undefined;
 }
 /**
  * The services {@link PlatformLive} provides.
@@ -2583,9 +2623,15 @@ export declare function assembleHistoryRecord(rows: HistoryRow[]): AssembledHist
  * most once per dbPath in the current process; concurrent calls share the
  * same in-flight promise. Subsequent calls (after the first resolves) are
  * no-ops.
+ *
+ * @param dbPath - the SQLite file to migrate
+ * @param logLevel - the diagnostics level for the migrator's records; see `LoggerLive`
+ * @param logFile - a file to append NDJSON diagnostics to; see `LoggerLive`
+ * @param env - the environment map `LoggerLive` detects the runtime from, so
+ *   records are neutralized under GitHub Actions (the front end passes `process.env`)
  * @public
  */
-export declare function ensureMigrated(dbPath: string, logLevel?: LogLevel.LogLevel, logFile?: string): Promise<void>;
+export declare function ensureMigrated(dbPath: string, logLevel?: LogLevel.LogLevel, logFile?: string, env?: Readonly<Record<string, string | undefined>>): Promise<void>;
 /**
  * Reset the migration cache. Test-only.
  *

package/layers/EnvironmentDetectorLive.js

@@ -1,36 +1,56 @@
 import { EnvironmentDetector } from "../services/EnvironmentDetector.js";
-import { Effect, Layer } from "effect";
-import { agent, isAgent } from "std-env";
+import { Effect, Layer, Option } from "effect";
+import { Audience, CurrentRuntimeEnv } from "@effected/env";
 
 //#region src/layers/EnvironmentDetectorLive.ts
-const isGitHub = (env) => env.GITHUB_ACTIONS === "true" || env.GITHUB_ACTIONS === "1";
-const isCI = (env) => isGitHub(env) || env.CI === "true";
+/** The engine environment for each CI `@effected/env` names; exhaustive over `CiName`. */
+const CI_ENVIRONMENT = {
+	"github-actions": "ci-github",
+	generic: "ci-generic"
+};
 /**
 * Pure classification behind {@link EnvironmentDetectorLive}: an agent shell
 * wins, then GitHub Actions, then generic CI, else a terminal.
 *
-* @param env - the environment map to consult
-* @param agentShell - whether the process runs under an AI agent (`std-env`'s `isAgent`)
+* @remarks
+* The agent/CI/human split is `@effected/env`'s `Audience.detect`, so the
+* engine and every `@effected/cli` front end agree on who is running; this
+* only refines CI into GitHub Actions versus any other CI.
+*
+* @param runtime - the `@effected/env` runtime snapshot to classify
 * @public
 */
-const classifyEnvironment = (env, agentShell) => {
-	if (agentShell) return "agent-shell";
-	if (isGitHub(env)) return "ci-github";
-	if (isCI(env)) return "ci-generic";
-	return "terminal";
+const classifyEnvironment = (runtime) => {
+	switch (Audience.detect(runtime)) {
+		case "agent": return "agent-shell";
+		case "ci": return Option.match(runtime.ci, {
+			onNone: () => "ci-generic",
+			onSome: (ci) => CI_ENVIRONMENT[ci]
+		});
+		case "human": return "terminal";
+	}
 };
 /**
-* Live environment detector. CI detection reads `GITHUB_ACTIONS` / `CI`
-* from the injected `env` map; agent detection comes from `std-env`.
+* Live environment detector over `@effected/env`'s `CurrentRuntimeEnv`, read
+* from the injected `env` map only: agent, GitHub Actions and generic CI
+* detection all come from `env`, never from the ambient process.
+*
+* @remarks
+* The snapshot is taken once, when the layer is built, through
+* `CurrentRuntimeEnv.layerFrom(env)`: a fresh layer per call and per use, so two
+* detectors built over different maps in one layer graph each see their own.
 *
 * @param env - the environment map to consult (the front end passes `process.env`)
 * @public
 */
-const EnvironmentDetectorLive = (env) => Layer.succeed(EnvironmentDetector, {
-	detect: () => Effect.sync(() => classifyEnvironment(env, isAgent)),
-	isAgent: Effect.sync(() => isAgent),
-	agentName: Effect.sync(() => agent ?? void 0)
-});
+const EnvironmentDetectorLive = (env) => Layer.effect(EnvironmentDetector, Effect.map(CurrentRuntimeEnv, (runtime) => {
+	const environment = classifyEnvironment(runtime);
+	return {
+		detect: () => Effect.succeed(environment),
+		isAgent: Effect.succeed(Option.isSome(runtime.agent)),
+		agentName: Effect.succeed(Option.getOrUndefined(runtime.agent))
+	};
+})).pipe(Layer.provide(CurrentRuntimeEnv.layerFrom(env)));
 
 //#endregion
 export { EnvironmentDetectorLive, classifyEnvironment };

package/layers/ExecutorResolverLive.js

@@ -2,8 +2,20 @@ import { ExecutorResolver } from "../services/ExecutorResolver.js";
 import { Effect, Layer } from "effect";
 
 //#region src/layers/ExecutorResolverLive.ts
+/**
+* The `@effected/env` audience each environment implies. An `Executor` is the
+* same three-way split as an `AudienceKind` (`human` / `agent` / `ci`); typing
+* the table as `AudienceKind` and returning it as `Executor` keeps the two
+* unions from drifting apart at compile time.
+*/
+const AUDIENCE_OF = {
+	"agent-shell": "agent",
+	terminal: "human",
+	"ci-github": "ci",
+	"ci-generic": "ci"
+};
 /** @public */
-const ExecutorResolverLive = Layer.succeed(ExecutorResolver, { resolve: (env) => Effect.succeed(env === "agent-shell" ? "agent" : env === "terminal" ? "human" : "ci") });
+const ExecutorResolverLive = Layer.succeed(ExecutorResolver, { resolve: (env) => Effect.succeed(AUDIENCE_OF[env]) });
 
 //#endregion
 export { ExecutorResolverLive };

package/layers/LoggerLive.js

@@ -1,33 +1,48 @@
-import { Layer, LogLevel, Logger, References } from "effect";
-import { appendFileSync } from "node:fs";
+import { Layer, LogLevel, Logger } from "effect";
+import { CurrentRuntimeEnv } from "@effected/env";
+import * as NodeFileSystem from "@effect/platform-node/NodeFileSystem";
+import * as NodePath from "@effect/platform-node/NodePath";
+import { CliLog } from "@effected/cli";
 
 //#region src/layers/LoggerLive.ts
 /**
-* Create a structured JSON (NDJSON) logger layer for stderr.
+* Create a structured JSON (NDJSON) logger layer for stderr, over
+* `@effected/cli`'s `CliLog` in its diagnostics-only mode
+* (`format: "json"`, `plainLogger: false`): the already-resolved level is
+* passed as `level`, and no plain `CliLogger` is installed beside the sink, so
+* each record prints once and nothing reads the audience or the terminal.
 *
 * When level is undefined or `"None"`, installs an empty logger set (silent).
-* When logFile is set, composes the stderr logger with a file logger.
-* Uses `Logger.formatJson` / `Logger.formatStructured` for machine-readable
-* output.
+* When logFile is set, `CliLog`'s asynchronous file sink also appends each
+* NDJSON line (the same shape as the stderr line) to that file; the first
+* write error prints one stderr line and disables the file sink.
+*
+* When `env` is given, it is built into `CurrentRuntimeEnv` for the layer's
+* own build context, which `CliLog` captures: under GitHub Actions every
+* stderr record is neutralized (no workflow command at line start, `##[`
+* escaped), including records logged from a fiber that carries no
+* `CurrentRuntimeEnv` of its own. Without `env`, records are sanitised but
+* not neutralized unless the logging fiber provides one.
+*
+* @remarks
+* The file sink needs `FileSystem` and `Path`. `CliLog` leaves them in `R`
+* (for `file: undefined` too), but they are provided here (Node) so the
+* public signature stays `Layer.Layer<never>` for every caller.
+*
+* @param level - the diagnostics level; see {@link resolveLogLevel}
+* @param logFile - a file to append NDJSON lines to; see {@link resolveLogFile}
+* @param env - the environment map to detect the runtime from (the front end passes `process.env`)
 * @public
 */
-const LoggerLive = (level, logFile) => {
+const LoggerLive = (level, logFile, env) => {
 	if (!level || level === "None") return Logger.layer([]);
-	const stderrLogger = Logger.formatJson.pipe(Logger.withConsoleError);
-	const fileLogger = logFile ? Logger.formatStructured.pipe(Logger.map((entry) => {
-		const line = JSON.stringify({
-			timestamp: entry.timestamp,
-			level: entry.level,
-			message: entry.message,
-			...entry.annotations
-		});
-		try {
-			appendFileSync(logFile, `${line}\n`);
-		} catch {}
-		return line;
-	})) : void 0;
-	const loggers = fileLogger ? [stderrLogger, fileLogger] : [stderrLogger];
-	return Layer.merge(Logger.layer(loggers), Layer.succeed(References.MinimumLogLevel, level));
+	const sink = CliLog.layer({
+		format: "json",
+		plainLogger: false,
+		level,
+		file: logFile === void 0 ? void 0 : { path: logFile }
+	}).pipe(Layer.provide(Layer.merge(NodeFileSystem.layer, NodePath.layer)));
+	return env === void 0 ? sink : sink.pipe(Layer.provide(CurrentRuntimeEnv.layerFrom(env)));
 };
 const LEVEL_ALIASES = {
 	warn: "Warn",

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vitest-agent/engine",
-	"version": "0.3.1",
+	"version": "0.4.0",
 	"private": false,
 	"description": "Shared services, layers, SQLite data layer, migrations and platform resolution for the vitest-agent CLI and MCP server.",
 	"keywords": [
@@ -40,20 +40,21 @@
 		"./package.json": "./package.json"
 	},
 	"dependencies": {
-		"@effect/platform-node": "4.0.0-rc.118",
-		"@effect/sql-sqlite-node": "4.0.0-rc.118",
-		"@effected/config-file": "^0.13.1",
-		"@effected/engine": "^0.2.0",
-		"@effected/glob": "^0.9.0",
-		"@effected/jsonc": "^0.14.0",
-		"@effected/toml": "^0.10.0",
-		"@effected/walker": "^0.14.0",
-		"@effected/workspaces": "^0.30.2",
-		"@effected/xdg": "^0.8.2",
-		"@effected/yaml": "^0.18.0",
-		"@vitest-agent/sdk": "5.1.3",
-		"effect": "4.0.0-rc.118",
-		"std-env": "^4.2.0"
+		"@effect/platform-node": "^4.0.0",
+		"@effect/sql-sqlite-node": "^4.0.0",
+		"@effected/cli": "^0.11.0",
+		"@effected/config-file": "^0.14.0",
+		"@effected/engine": "^0.3.0",
+		"@effected/env": "^0.1.0",
+		"@effected/glob": "^0.10.0",
+		"@effected/jsonc": "^0.15.0",
+		"@effected/toml": "^0.11.0",
+		"@effected/walker": "^0.15.0",
+		"@effected/workspaces": "^0.31.0",
+		"@effected/xdg": "^0.9.0",
+		"@effected/yaml": "^0.19.0",
+		"@vitest-agent/sdk": "5.2.0",
+		"effect": "^4.0.0"
 	},
 	"engines": {
 		"node": ">=24.11.0"

package/platform.js

@@ -51,7 +51,8 @@ const makeSqliteStack = (filename, migrations = PROJECT_MIGRATIONS) => {
 */
 const PlatformLive = (options) => {
 	const { SqliteLayer, MigratorLayer } = makeSqliteStack(options.dbPath);
-	return Layer.mergeAll(ProjectDiscoveryLive, HistoryTrackerLive, OutputPipelineLive(options.env)).pipe(Layer.provideMerge(DataReaderLive), Layer.provideMerge(DataStoreLive), Layer.provideMerge(MigratorLayer), Layer.provideMerge(SqliteLayer), Layer.provideMerge(NodePlatformLayer), Layer.provideMerge(LoggerLive(options.logLevel, options.logFile)));
+	const platform = Layer.mergeAll(ProjectDiscoveryLive, HistoryTrackerLive, OutputPipelineLive(options.env)).pipe(Layer.provideMerge(DataReaderLive), Layer.provideMerge(DataStoreLive), Layer.provideMerge(MigratorLayer), Layer.provideMerge(SqliteLayer), Layer.provideMerge(NodePlatformLayer));
+	return options.logger === false ? platform : platform.pipe(Layer.provideMerge(LoggerLive(options.logLevel, options.logFile, options.env)));
 };
 
 //#endregion

package/programs/session-env.js

@@ -1,5 +1,5 @@
-import { readFileSync, readdirSync, statSync } from "node:fs";
 import { join, resolve } from "node:path";
+import { readFileSync, readdirSync, statSync } from "node:fs";
 
 //#region src/programs/session-env.ts
 const EXPORT_LINE = /^export ([A-Z_][A-Z0-9_]*)=(.*)$/;

package/utils/ensure-migrated.js

@@ -19,16 +19,22 @@ const getCache = () => {
 * most once per dbPath in the current process; concurrent calls share the
 * same in-flight promise. Subsequent calls (after the first resolves) are
 * no-ops.
+*
+* @param dbPath - the SQLite file to migrate
+* @param logLevel - the diagnostics level for the migrator's records; see `LoggerLive`
+* @param logFile - a file to append NDJSON diagnostics to; see `LoggerLive`
+* @param env - the environment map `LoggerLive` detects the runtime from, so
+*   records are neutralized under GitHub Actions (the front end passes `process.env`)
 * @public
 */
-function ensureMigrated(dbPath, logLevel, logFile) {
+function ensureMigrated(dbPath, logLevel, logFile, env) {
 	const cache = getCache();
 	const cached = cache.get(dbPath);
 	if (cached) return cached;
 	const { SqliteLayer, MigratorLayer } = makeSqliteStack(dbPath);
 	const program = Effect.gen(function* () {
 		yield* SqlClient;
-	}).pipe(Effect.provide(MigratorLayer), Effect.provide(Layer.merge(SqliteLayer, NodePlatformLayer)), Effect.provide(LoggerLive(logLevel, logFile)));
+	}).pipe(Effect.provide(MigratorLayer), Effect.provide(Layer.merge(SqliteLayer, NodePlatformLayer)), Effect.provide(LoggerLive(logLevel, logFile, env)));
 	const promise = Effect.runPromise(program);
 	cache.set(dbPath, promise);
 	promise.catch(() => {});

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

@@ -1,7 +1,7 @@
 import { gitUrlToProjectKey, normalizeWorkspaceKey } from "@vitest-agent/sdk";
 import { Effect, FileSystem } from "effect";
-import { existsSync, readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
 
 //#region src/utils/resolve-project-key-from-cwd.ts
 const PACKAGE_JSON = "package.json";

package/version.js

@@ -1,6 +1,6 @@
 //#region src/version.ts
 /** Build-time injected package version (see architecture.md D36). @public */
-const CURRENT_ENGINE_VERSION = "0.3.1";
+const CURRENT_ENGINE_VERSION = "0.4.0";
 
 //#endregion
 export { CURRENT_ENGINE_VERSION };