@vitest-agent/cli 3.2.7 → 4.0.1

package/commands/agent.js

@@ -1,15 +1,15 @@
 import { recordCommand } from "./record.js";
 import { triageCommand } from "./triage.js";
 import { wrapupCommand } from "./wrapup.js";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import * as NodeServices from "@effect/platform-node/NodeServices";
 import { SidecarPlatformLive, endAgentEffect, registerAgentEffect, resolveHookPaths, resolveProjectKeyFromCwd } from "@vitest-agent/engine";
-import { classifyTestPath, detectNonDefaultDiscoverStrategy, findOwningWorkspace } from "@vitest-agent/sdk";
 import { Cause, Effect, Option } from "effect";
 import { Argument, Command, Flag } from "effect/cli";
 import { existsSync, readFileSync } from "node:fs";
-import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { findWorkspaceRootSync, getWorkspacePackagesSync } from "@effected/workspaces";
 import { nodeSyncOps } from "@effected/workspaces/node-sync";
+import { classifyTestPath, detectNonDefaultDiscoverStrategy, findOwningWorkspace } from "@vitest-agent/sdk";
 import { exitCodeForTag, injectEnv } from "@vitest-agent/sdk/dispatch";
 import { resolveSidecarBinaryPath } from "@vitest-agent/sidecar";
 

package/commands/db.js

@@ -1,9 +1,8 @@
 import { formatDbQuery } from "../lib/format-db-query.js";
-import * as NodeServices from "@effect/platform-node/NodeServices";
+import { Cancelled, CliExit, CliInteractive } from "@effected/cli";
 import { DataStore, resolveDataPath } from "@vitest-agent/engine";
-import { Effect, FileSystem } from "effect";
-import { Argument, Command, Flag } from "effect/cli";
-import * as readline from "node:readline";
+import { Console, Effect, FileSystem } from "effect";
+import { Argument, Command, Flag, Prompt } from "effect/cli";
 import { layer } from "@effect/sql-sqlite-node/SqliteClient";
 import { SqlClient } from "effect/sql/SqlClient";
 
@@ -21,37 +20,20 @@ const yesOption = Flag.Boolean("yes").pipe(Flag.withDefault(false), Flag.withDes
 const resetCommand = Command.make("reset", { yes: yesOption }, ({ yes }) => Effect.gen(function* () {
 	const agentId = process.env.VITEST_AGENT_AGENT_ID;
 	if (agentId !== void 0 && agentId.length > 0) {
-		yield* Effect.sync(() => {
-			process.stderr.write("db reset is human-only; use db prune or run from a human terminal\n");
-			process.exit(4);
-		});
-		return;
+		yield* Console.error("db reset is human-only; use db prune or run from a human terminal");
+		return yield* CliExit.set(4);
 	}
 	const dbPath = yield* resolveDataPath(process.env.VITEST_AGENT_PROJECT_DIR ?? process.cwd());
-	if (!process.stdout.isTTY && !yes) {
-		yield* Effect.sync(() => {
-			process.stderr.write("db reset requires --yes when stdout is not a TTY\n");
-			process.exit(5);
-		});
-		return;
+	if (!yes && !(yield* CliInteractive)) {
+		yield* Console.error("db reset requires --yes when the run is not interactive (stdout or stdin is not a TTY, or the audience is not human)");
+		return yield* CliExit.set(5);
 	}
-	if (process.stdout.isTTY && !yes) {
-		if (!(yield* Effect.promise(() => {
-			return new Promise((resolve) => {
-				const rl = readline.createInterface({
-					input: process.stdin,
-					output: process.stdout
-				});
-				rl.question(`Wipe ${dbPath}? [y/N]: `, (answer) => {
-					rl.close();
-					resolve(answer === "y" || answer === "Y");
-				});
-			});
-		}))) {
-			yield* Effect.sync(() => {
-				process.stdout.write("aborted\n");
-				process.exit(0);
-			});
+	if (!yes) {
+		if (!(yield* Prompt.run(Prompt.Confirm({
+			message: `Wipe ${dbPath}?`,
+			initial: false
+		})).pipe(Effect.catchTag("QuitError", () => Effect.fail(Cancelled.make({ reason: "interrupt" })))))) {
+			yield* Console.log("aborted");
 			return;
 		}
 	}
@@ -59,10 +41,8 @@ const resetCommand = Command.make("reset", { yes: yesOption }, ({ yes }) => Effe
 	yield* fs.remove(dbPath).pipe(Effect.catch(() => Effect.void));
 	yield* fs.remove(`${dbPath}-shm`).pipe(Effect.catch(() => Effect.void));
 	yield* fs.remove(`${dbPath}-wal`).pipe(Effect.catch(() => Effect.void));
-	yield* Effect.sync(() => {
-		process.stdout.write(`Deleted database at ${dbPath}\n`);
-	});
-}).pipe(Effect.provide(NodeServices.layer))).pipe(Command.withDescription("Wipe the database (human-only; blocked in agent contexts)"));
+	yield* Console.log(`Deleted database at ${dbPath}`);
+})).pipe(Command.withDescription("Wipe the database (human-only; blocked in agent contexts)"));
 const queryFormatOption = Flag.Literals("format", ["table", "json"]).pipe(Flag.withDefault("table"), Flag.withDescription("Output format for query results"));
 const sqlArg = Argument.String("sql").pipe(Argument.withDescription("Read-only SQL statement to execute against data.db"));
 /**

package/lib/render-failure.js

@@ -0,0 +1,59 @@
+import { Cancelled, Fmt, NotInteractive } from "@effected/cli";
+import { Schema } from "effect";
+
+//#region src/lib/render-failure.ts
+/**
+* The one-line name of a typed failure: its `_tag` when it carries one (a
+* `PlatformError`, `SqlError`, `MigrationError`), else its `Error` name.
+*/
+const failureName = (error) => {
+	if (typeof error === "object" && error !== null && "_tag" in error && typeof error._tag === "string") return error._tag;
+	return error instanceof Error ? error.name : "Error";
+};
+/** Where a defect's report sends the reader: a defect is a bug in this program. */
+const ISSUE_URL = "https://github.com/spencerbeggs/vitest-agent/issues";
+/**
+* Failures the kit renders better than one `<Tag>: <message>` line: its own
+* `Cancelled` / `NotInteractive` fixed lines, and a `SchemaError` as a tree of
+* the rejected values.
+*/
+const isKitRendered = (error) => error instanceof Cancelled || error instanceof NotInteractive || Schema.isSchemaError(error);
+/** One line of text we did not write, made safe to print: controls stripped, line breaks folded to spaces. */
+const oneLine = (text) => Fmt.sanitize(text).replace(/\s*[\r\n]+\s*/g, " ").trim();
+/**
+* One rendering for every failure `CliRuntime.main` reports, its first line
+* led by `vitest-agent: `. The kit says which kind it is
+* (`details.isDefect`, exact: the cause carries no typed failure).
+*
+* - A typed failure from the error channel (a `PlatformError`, `SqlError`,
+*   `MigrationError`) is the one line we own: `vitest-agent: <Tag>: <message>`,
+*   the message passed through `Fmt.sanitize` (it can carry a path or SQL text).
+* - Everything else is delegated to `details.lines({ status: false })`, the
+*   kit's report for this run (its colour, links, and `displayPath`) with the
+*   status glyph / `[FAIL]` tag left off, so our prefix replaces the marker
+*   rather than doubling it: `Cancelled` / `NotInteractive` keep their fixed
+*   line (`vitest-agent: cancelled; nothing written`), a `SchemaError` is a
+*   tree, and a defect is its message plus a `stack` of the program's own
+*   frames (`node_modules`, Node, and Effect frames hidden and counted), then
+*   the issue link.
+*
+* `ShowHelp` and runWith-rendered `UserError`s never reach here (the kit skips
+* them).
+*
+* @internal
+*/
+const renderFailure = (error, details) => {
+	if (!details.isDefect && !isKitRendered(error)) {
+		const message = oneLine(error instanceof Error ? error.message : typeof error === "string" ? error : "");
+		return [`vitest-agent: ${oneLine(failureName(error))}${message ? `: ${message}` : ""}`];
+	}
+	const [first = failureName(error), ...rest] = details.lines({ status: false });
+	return [
+		`vitest-agent: ${first}`,
+		...rest,
+		...details.isDefect ? [`Please report at ${ISSUE_URL}`] : []
+	];
+};
+
+//#endregion
+export { renderFailure };

package/lib/version-formatter.js

@@ -1,23 +1,28 @@
-import { CliColor } from "@effected/cli";
-import { CurrentDistribution, distributionSuffix } from "@effected/engine";
-import { Effect, Layer } from "effect";
+import { distributionSuffix } from "@effected/engine";
 
 //#region src/lib/version-formatter.ts
 /**
-* The program's one `CliOutput.Formatter` layer: `CliColor.formatterLayer`
-* (the kit's single colour decision — stdout is a TTY and `NO_COLOR` is
-* unset or empty) with only `formatVersion` overridden, so `--version`
+* The `CliOutput.Formatter` methods `main.ts` replaces through
+* `CliRuntime.main`'s `env.formatter`: only `formatVersion`, so `--version`
 * prints `vitest-agent <cli version>` plus ` via <name> <version>` when a
-* carrier (`@vitest-agent/plugin`'s bin shim) threaded its identity down.
-* Help and parse-error rendering stay `CliColor`'s own.
+* carrier (`@vitest-agent/plugin`'s bin shim) passed its identity to `main`.
 *
-* `Layer.unwrap` reads `CurrentDistribution` once, at layer build time, from
-* the ambient context `main.ts` provides — so `main.ts` must provide
-* `CurrentDistribution` OUTSIDE the layer, not inside it.
+* `env.formatter` is the kit's one way to keep a formatter method of our own:
+* `main` installs its coloured default formatter inside the platform, which
+* shadows any formatter the platform sets. Every method left out keeps the
+* kit's coloured default, and `helpOnUsageError: "stderr"` still wraps the
+* result, so usage-error help keeps going to stderr.
+*
+* `distribution` is the same value `main.ts` provides as `CurrentDistribution`;
+* it is known when `main` is called, so it is read here directly rather than
+* from the context when `--version` runs.
 *
 * @internal
 */
-const versionFormatterLayer = Layer.unwrap(Effect.map(CurrentDistribution, (distribution) => CliColor.formatterLayer({ formatVersion: (name, version) => `${name} ${version}${distributionSuffix(distribution)}` })));
+const carrierVersionFormatter = (distribution) => {
+	const suffix = distributionSuffix(distribution);
+	return { formatVersion: (name, version) => `${name} ${version}${suffix}` };
+};
 
 //#endregion
-export { versionFormatterLayer };
+export { carrierVersionFormatter };

package/main.d.ts

@@ -18,28 +18,48 @@ export interface MainOptions {
  * re-exported from `index.ts` — a library consumer's import graph must not
  * pull in the process-owning module.
  *
+ * The one `@effected/cli` wiring: the root carries `CliAudience.flags()`
+ * (`--audience <human|agent|ci>`, `--human`, `--agent`, `--ci`), runs through
+ * `CliAudience.run`, and `CliRuntime.main`'s `env` option builds the
+ * `@effected/env` services (`Audience` with the `VITEST_AGENT_AUDIENCE`
+ * override, `TerminalEnv`, `CliTheme`, `CliInteractive`, the gated `Terminal`)
+ * plus the kit's colour-decided help formatter, inside failure reporting.
+ * `env.formatter` replaces only that formatter's `formatVersion`, so
+ * `--version` names the carrier (`via @vitest-agent/plugin <version>`) when
+ * `options.distribution` is given; the same value is provided as
+ * `CurrentDistribution`. An audience flag recomputes `CliInteractive` from the
+ * TTY facts, so `--human` in an agent-detected shell (Claude Code's terminal)
+ * at a real terminal may prompt.
+ *
  * Output routing (hooks parse `agent *` stdout with jq, so stdout carries
  * only what a command writes as its result):
  *
- * - Inside the platform, the engine's `LoggerLive` (installed by
- *   `PlatformLive`) is the active logger: silent unless
- *   `VITEST_REPORTER_LOG_LEVEL` is set, then NDJSON on stderr (plus
- *   `VITEST_REPORTER_LOG_FILE`). Every `Effect.log*` a command or engine
- *   service emits goes there.
- * - Outside the platform, `CliRuntime.main`'s default `CliLogger` is
- *   outermost and sends every level to stderr. It is what renders reported
- *   failures (a layer-build failure, a typed command failure, a defect)
- *   through `renderFailure`.
+ * - `env.log` makes `CliLog.layer` the one logger set, outermost: a
+ *   `CliLogger` for ordinary lines and failure reports, plus a diagnostics
+ *   sink that is silent unless `VITEST_REPORTER_LOG_LEVEL` is set (then
+ *   NDJSON on stderr for every audience), plus an
+ *   async NDJSON file when `VITEST_REPORTER_LOG_FILE` is set. The platform
+ *   therefore installs no logger of its own (`PlatformLive`'s `logger: false`:
+ *   the engine's `LoggerLive` would otherwise replace this set inside the
+ *   program). The platform is built under that logger, so what it logs
+ *   while building (the engine's migration records) reaches the same sink.
+ *   `format: "auto"`: NDJSON for an agent or a CI, plain lines for a person.
+ *   `argv` (`process.argv.slice(2)`) lets the build-time records follow the
+ *   audience flags too, so `--agent` with no agent detected is all NDJSON and
+ *   `--human` in an agent shell is all plain, migration records included.
+ * - Failures render through `renderFailure` on stderr, first line led by
+ *   `vitest-agent: `. `env.displayPath` shows a defect's stack frames
+ *   relative to the project directory (absolute when outside it).
  * - An explicit `--help` (or a bare group invocation) prints help on
- *   stdout. A usage error (unknown flag, bad value, unknown subcommand)
- *   prints help AND the parse errors on stderr (`helpOnUsageError: "stderr"`),
- *   so stdout stays empty for a jq-piping hook. Both render via
- *   the `CliOutput` formatter (`versionFormatterLayer`), which must come
- *   through `platform` for the kit to reroute it.
+ *   stdout. A usage error (unknown flag, bad value, unknown subcommand,
+ *   conflicting audience flags) prints help AND the parse errors on stderr
+ *   (`helpOnUsageError: "stderr"`), so stdout stays empty for a jq-piping
+ *   hook.
  *
  * Exit codes are the kit's: `0` success (including bare `--help`), `64` a
- * usage error (parse error, unknown subcommand), `1` any other reported
- * failure. Commands that `process.exit` with their own code still do so.
+ * usage error, `130` a cancelled prompt, `1` any other reported failure.
+ * Commands that record their own code through `CliExit` (`db reset`) or
+ * `process.exit` with it still exit with it.
  *
  * @public
  */

package/main.js

@@ -2,13 +2,14 @@ import { CURRENT_CLI_VERSION } from "./version.js";
 import { agentCommand } from "./commands/agent.js";
 import { dbCommand } from "./commands/db.js";
 import { doctorCommand } from "./commands/doctor.js";
-import { versionFormatterLayer } from "./lib/version-formatter.js";
+import { renderFailure } from "./lib/render-failure.js";
+import { carrierVersionFormatter } from "./lib/version-formatter.js";
+import { isAbsolute, relative } from "node:path";
 import * as NodeRuntime from "@effect/platform-node/NodeRuntime";
 import * as NodeServices from "@effect/platform-node/NodeServices";
-import { CliRuntime } from "@effected/cli";
+import { CliAudience, CliRuntime } from "@effected/cli";
 import { CurrentDistribution } from "@effected/engine";
-import { PathResolutionLive, PlatformLive, resolveDataPath, resolveLogFile, resolveLogLevel, resolveProjectDir } from "@vitest-agent/engine";
-import { formatFatalError } from "@vitest-agent/sdk";
+import { PathResolutionLive, PlatformLive, resolveDataPath, resolveProjectDir } from "@vitest-agent/engine";
 import { Effect, Layer, Option } from "effect";
 import { Command } from "effect/cli";
 
@@ -25,81 +26,102 @@ import { Command } from "effect/cli";
 *
 * @packageDocumentation
 */
-const rootCommand = Command.make("vitest-agent").pipe(Command.withSubcommands([
+/**
+* The environment variable that overrides the detected audience
+* (`human` | `agent` | `ci`), read by `@effected/env`'s `Audience` through
+* `Config`. The `VITEST_AGENT_` prefix is the family's runtime-override
+* namespace (`VITEST_AGENT_CONSOLE`, `VITEST_AGENT_PROJECT_DIR`,
+* `VITEST_AGENT_CLI_CMD`); the `VITEST_REPORTER_` prefix survives only on the
+* two legacy logging variables.
+*/
+const AUDIENCE_ENV_VAR = "VITEST_AGENT_AUDIENCE";
+const rootCommand = Command.make("vitest-agent").pipe(Command.withSharedFlags(CliAudience.flags()), Command.withSubcommands([
 	dbCommand,
 	doctorCommand,
 	agentCommand
 ]));
 /**
-* The one-line name of a typed failure: its `_tag` when it carries one (a
-* `PlatformError`, `SqlError`, `MigrationError`), else its `Error` name.
-*/
-const failureName = (error) => {
-	if (typeof error === "object" && error !== null && "_tag" in error && typeof error._tag === "string") return error._tag;
-	return error instanceof Error ? error.name : "Error";
-};
-/**
-* One rendering for every failure `CliRuntime.main` reports. The kit says
-* which kind it is (`details.isDefect`, exact: the cause carries no typed
-* failure): a typed failure from the error channel is one line, a defect
-* keeps the issue-report rendering `formatFatalError` gives it. `ShowHelp`
-* and runWith-rendered `UserError`s never reach here (the kit skips them).
-*/
-const renderFailure = (error, details) => {
-	if (details.isDefect) return `vitest-agent: ${formatFatalError(error)}`;
-	const message = error instanceof Error ? error.message : typeof error === "string" ? error : "";
-	return `vitest-agent: ${failureName(error)}${message ? `: ${message}` : ""}`;
-};
-/**
 * Assembles and runs the CLI program, taking over the process. Not
 * re-exported from `index.ts` — a library consumer's import graph must not
 * pull in the process-owning module.
 *
+* The one `@effected/cli` wiring: the root carries `CliAudience.flags()`
+* (`--audience <human|agent|ci>`, `--human`, `--agent`, `--ci`), runs through
+* `CliAudience.run`, and `CliRuntime.main`'s `env` option builds the
+* `@effected/env` services (`Audience` with the `VITEST_AGENT_AUDIENCE`
+* override, `TerminalEnv`, `CliTheme`, `CliInteractive`, the gated `Terminal`)
+* plus the kit's colour-decided help formatter, inside failure reporting.
+* `env.formatter` replaces only that formatter's `formatVersion`, so
+* `--version` names the carrier (`via @vitest-agent/plugin <version>`) when
+* `options.distribution` is given; the same value is provided as
+* `CurrentDistribution`. An audience flag recomputes `CliInteractive` from the
+* TTY facts, so `--human` in an agent-detected shell (Claude Code's terminal)
+* at a real terminal may prompt.
+*
 * Output routing (hooks parse `agent *` stdout with jq, so stdout carries
 * only what a command writes as its result):
 *
-* - Inside the platform, the engine's `LoggerLive` (installed by
-*   `PlatformLive`) is the active logger: silent unless
-*   `VITEST_REPORTER_LOG_LEVEL` is set, then NDJSON on stderr (plus
-*   `VITEST_REPORTER_LOG_FILE`). Every `Effect.log*` a command or engine
-*   service emits goes there.
-* - Outside the platform, `CliRuntime.main`'s default `CliLogger` is
-*   outermost and sends every level to stderr. It is what renders reported
-*   failures (a layer-build failure, a typed command failure, a defect)
-*   through `renderFailure`.
+* - `env.log` makes `CliLog.layer` the one logger set, outermost: a
+*   `CliLogger` for ordinary lines and failure reports, plus a diagnostics
+*   sink that is silent unless `VITEST_REPORTER_LOG_LEVEL` is set (then
+*   NDJSON on stderr for every audience), plus an
+*   async NDJSON file when `VITEST_REPORTER_LOG_FILE` is set. The platform
+*   therefore installs no logger of its own (`PlatformLive`'s `logger: false`:
+*   the engine's `LoggerLive` would otherwise replace this set inside the
+*   program). The platform is built under that logger, so what it logs
+*   while building (the engine's migration records) reaches the same sink.
+*   `format: "auto"`: NDJSON for an agent or a CI, plain lines for a person.
+*   `argv` (`process.argv.slice(2)`) lets the build-time records follow the
+*   audience flags too, so `--agent` with no agent detected is all NDJSON and
+*   `--human` in an agent shell is all plain, migration records included.
+* - Failures render through `renderFailure` on stderr, first line led by
+*   `vitest-agent: `. `env.displayPath` shows a defect's stack frames
+*   relative to the project directory (absolute when outside it).
 * - An explicit `--help` (or a bare group invocation) prints help on
-*   stdout. A usage error (unknown flag, bad value, unknown subcommand)
-*   prints help AND the parse errors on stderr (`helpOnUsageError: "stderr"`),
-*   so stdout stays empty for a jq-piping hook. Both render via
-*   the `CliOutput` formatter (`versionFormatterLayer`), which must come
-*   through `platform` for the kit to reroute it.
+*   stdout. A usage error (unknown flag, bad value, unknown subcommand,
+*   conflicting audience flags) prints help AND the parse errors on stderr
+*   (`helpOnUsageError: "stderr"`), so stdout stays empty for a jq-piping
+*   hook.
 *
 * Exit codes are the kit's: `0` success (including bare `--help`), `64` a
-* usage error (parse error, unknown subcommand), `1` any other reported
-* failure. Commands that `process.exit` with their own code still do so.
+* usage error, `130` a cancelled prompt, `1` any other reported failure.
+* Commands that record their own code through `CliExit` (`db reset`) or
+* `process.exit` with it still exit with it.
 *
 * @public
 */
 const main = (options = {}) => {
 	const env = process.env;
-	const logLevel = resolveLogLevel(env);
-	const logFile = resolveLogFile(env);
 	const projectDir = resolveProjectDir({
 		env,
 		cwd: process.cwd()
 	});
-	const dataLayer = Layer.unwrap(Effect.map(resolveDataPath(projectDir), (dbPath) => PlatformLive({
+	const platform = Layer.unwrap(Effect.map(resolveDataPath(projectDir), (dbPath) => PlatformLive({
 		dbPath,
 		env,
-		logLevel,
-		logFile
-	})));
-	const platform = Layer.mergeAll(dataLayer, versionFormatterLayer).pipe(Layer.provideMerge(PathResolutionLive(projectDir)), Layer.provideMerge(NodeServices.layer));
-	const program = CliRuntime.main(Command.run(rootCommand, { version: CURRENT_CLI_VERSION }), {
+		logger: false
+	}))).pipe(Layer.provideMerge(PathResolutionLive(projectDir)), Layer.provideMerge(NodeServices.layer));
+	const distribution = Option.fromNullishOr(options.distribution);
+	const displayPath = (absolute) => {
+		const rel = relative(projectDir, absolute);
+		return rel === "" || rel.startsWith("..") || isAbsolute(rel) ? absolute : rel;
+	};
+	const program = CliRuntime.main(CliAudience.run(rootCommand, { version: CURRENT_CLI_VERSION }), {
 		platform,
 		render: renderFailure,
-		helpOnUsageError: "stderr"
-	}).pipe(Effect.provideService(CurrentDistribution, Option.fromNullishOr(options.distribution)));
+		helpOnUsageError: "stderr",
+		env: {
+			audienceEnvVar: AUDIENCE_ENV_VAR,
+			formatter: carrierVersionFormatter(distribution),
+			displayPath,
+			log: {
+				envVar: "VITEST_REPORTER_LOG_LEVEL",
+				format: "auto",
+				argv: process.argv.slice(2),
+				file: { envVar: "VITEST_REPORTER_LOG_FILE" }
+			}
+		}
+	}).pipe(Effect.provideService(CurrentDistribution, distribution));
 	NodeRuntime.runMain(program);
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vitest-agent/cli",
-	"version": "3.2.7",
+	"version": "4.0.1",
 	"private": false,
 	"description": "On-demand CLI for vitest-agent. Reads cached test data and reports status, overview, coverage, history, trends, and cache health.",
 	"keywords": [
@@ -43,17 +43,19 @@
 		"vitest-agent": "bin/vitest-agent.js"
 	},
 	"dependencies": {
-		"@effect/platform-node": "4.0.0-rc.118",
-		"@effect/sql-sqlite-node": "4.0.0-rc.118",
-		"@effected/cli": "^0.10.0",
-		"@effected/config-file": "^0.13.1",
-		"@effected/engine": "^0.2.0",
-		"@effected/walker": "^0.14.0",
-		"@effected/workspaces": "^0.30.3",
-		"@vitest-agent/engine": "0.3.2",
-		"@vitest-agent/sdk": "5.1.3",
-		"@vitest-agent/sidecar": "2.2.3",
-		"effect": "4.0.0-rc.118"
+		"@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/walker": "^0.15.0",
+		"@effected/workspaces": "^0.31.0",
+		"@vitest-agent/engine": "0.5.0",
+		"@vitest-agent/sdk": "6.0.0",
+		"@vitest-agent/sidecar": "2.2.5",
+		"effect": "^4.0.0"
 	},
 	"engines": {
 		"node": ">=24.11.0"

package/version.js

@@ -7,7 +7,7 @@
 *
 * @public
 */
-const CURRENT_CLI_VERSION = "3.2.7";
+const CURRENT_CLI_VERSION = "4.0.1";
 
 //#endregion
 export { CURRENT_CLI_VERSION };