@vitest-agent/sdk 1.0.0

package/schemas/CoverageLevel.js

@@ -0,0 +1,117 @@
+import { Schema } from "effect";
+
+//#region src/schemas/CoverageLevel.ts
+/**
+* A coverage level configuration with per-metric thresholds and an optional
+* perFile flag. Extend this class to define custom named presets.
+* @public
+*/
+var CoverageLevel = class CoverageLevel extends Schema.Class("CoverageLevel")({
+	lines: Schema.Number,
+	functions: Schema.Number,
+	branches: Schema.Number,
+	statements: Schema.Number,
+	perFile: Schema.optional(Schema.Boolean)
+}) {
+	/** No enforcement — all metrics at 0%. */
+	static none = new CoverageLevel({
+		lines: 0,
+		functions: 0,
+		branches: 0,
+		statements: 0
+	});
+	/** Minimal coverage bar — all metrics at 50%. */
+	static basic = new CoverageLevel({
+		lines: 50,
+		functions: 50,
+		branches: 50,
+		statements: 50
+	});
+	/** Recommended default — lines/functions/statements at 70%, branches at 65%. */
+	static standard = new CoverageLevel({
+		lines: 70,
+		functions: 70,
+		branches: 65,
+		statements: 70
+	});
+	/** High-quality bar — lines/functions/statements at 80%, branches at 75%. */
+	static strict = new CoverageLevel({
+		lines: 80,
+		functions: 80,
+		branches: 75,
+		statements: 80
+	});
+	/** Near-complete coverage — lines/functions/statements at 90%, branches at 85%. */
+	static full = new CoverageLevel({
+		lines: 90,
+		functions: 90,
+		branches: 85,
+		statements: 90
+	});
+	/**
+	* Returns a new CoverageLevel instance with perFile set to true.
+	* Does not mutate the original.
+	*/
+	withPerFile() {
+		return new CoverageLevel({
+			lines: this.lines,
+			functions: this.functions,
+			branches: this.branches,
+			statements: this.statements,
+			perFile: true
+		});
+	}
+	/**
+	* Returns a new CoverageLevel instance with the given fields overridden.
+	* Does not mutate the original. Existing perFile is preserved unless
+	* explicitly overridden.
+	*/
+	extend(overrides) {
+		return new CoverageLevel({
+			lines: this.lines,
+			functions: this.functions,
+			branches: this.branches,
+			statements: this.statements,
+			perFile: this.perFile,
+			...overrides
+		});
+	}
+};
+const PRESET_MAP = Object.freeze({
+	none: CoverageLevel.none,
+	basic: CoverageLevel.basic,
+	standard: CoverageLevel.standard,
+	strict: CoverageLevel.strict,
+	full: CoverageLevel.full
+});
+/**
+* Resolves a CoverageInput (preset name or CoverageLevel instance) to a
+* CoverageLevel. When input is undefined, returns the named fallback preset.
+* Throws if a string is provided that does not match a known preset name.
+* @public
+*/
+function resolveCoverageInput(input, fallback) {
+	if (input === void 0) return PRESET_MAP[fallback];
+	if (input instanceof CoverageLevel) return input;
+	if (input in PRESET_MAP) return PRESET_MAP[input];
+	throw new Error(`[vitest-agent] Unknown coverage level name: "${input}". Valid names are: ${Object.keys(PRESET_MAP).join(", ")}.`);
+}
+/**
+* Validates that coverageTargets are not below coverageThresholds for any
+* metric, and that both agree on perFile. Throws a descriptive Error on
+* any violation.
+* @public
+*/
+function validateCoverageConfig(thresholds, targets) {
+	for (const metric of [
+		"lines",
+		"functions",
+		"branches",
+		"statements"
+	]) if (targets[metric] < thresholds[metric]) throw new Error(`[vitest-agent] coverageTargets.${metric} (${targets[metric]}%) is lower than coverageThresholds.${metric} (${thresholds[metric]}%). Targets must be ≥ thresholds.`);
+	if (thresholds.perFile === true && targets.perFile !== true) throw new Error("[vitest-agent] coverageThresholds sets perFile: true but coverageTargets does not. Both must agree on perFile.");
+	if (targets.perFile === true && thresholds.perFile !== true) throw new Error("[vitest-agent] coverageTargets sets perFile: true but coverageThresholds does not. Both must agree on perFile.");
+}
+
+//#endregion
+export { CoverageLevel, resolveCoverageInput, validateCoverageConfig };

package/schemas/CoverageTargets.js

@@ -0,0 +1,39 @@
+import { Schema } from "effect";
+
+//#region src/schemas/CoverageTargets.ts
+/**
+* Per-metric leaf shape for coverageTargets entries. Allows optional
+* numeric targets per metric and the `100: true` shortcut.
+* @public
+*/
+const CoverageTargetsMetrics = Schema.Struct({
+	lines: Schema.optional(Schema.Positive),
+	functions: Schema.optional(Schema.Positive),
+	branches: Schema.optional(Schema.Positive),
+	statements: Schema.optional(Schema.Positive),
+	100: Schema.optional(Schema.Literal(true))
+}).annotations({ identifier: "CoverageTargetsMetrics" });
+/**
+* Typed schema for the coverageTargets option.
+*
+* Mirrors Vitest's coverage.thresholds shape — per-metric positive numbers,
+* the `100: true` shortcut (only valid at key `"100"`), and glob-pattern
+* entries with metric objects. Positive numbers only; negatives and zeros
+* are rejected. `perFile` is not allowed here — inherit it from
+* `coverage.thresholds.perFile`.
+*
+* A decode-time refinement rejects `true` at any key other than `"100"`
+* so `{ statements: true }` fails parse rather than silently flowing
+* through to a runtime parser that only honors the canonical shorthand
+* at key `"100"`.
+* @public
+*/
+const CoverageTargets = Schema.Record({
+	key: Schema.String,
+	value: Schema.Union(Schema.Positive, Schema.Literal(true), CoverageTargetsMetrics)
+}).pipe(Schema.filter((targets) => {
+	for (const [key, value] of Object.entries(targets)) if (value === true && key !== "100") return `coverageTargets.${key} cannot be true. The "true" shorthand is only valid at key "100" (meaning 100% across all metrics).`;
+}), Schema.annotations({ identifier: "CoverageTargets" }));
+
+//#endregion
+export { CoverageTargets, CoverageTargetsMetrics };

package/schemas/History.js

@@ -0,0 +1,31 @@
+import { Schema } from "effect";
+
+//#region src/schemas/History.ts
+/**
+* A single test run outcome (pass or fail only).
+* @public
+*/
+const TestRun = Schema.Struct({
+	timestamp: Schema.String,
+	state: Schema.Literal("passed", "failed")
+}).annotations({ identifier: "TestRun" });
+/**
+* History for a single test across multiple runs.
+* @public
+*/
+const TestHistory = Schema.Struct({
+	fullName: Schema.String,
+	runs: Schema.Array(TestRun)
+}).annotations({ identifier: "TestHistory" });
+/**
+* Per-project history record containing all tracked tests.
+* @public
+*/
+const HistoryRecord = Schema.Struct({
+	project: Schema.String,
+	updatedAt: Schema.String,
+	tests: Schema.Array(TestHistory)
+}).annotations({ identifier: "HistoryRecord" });
+
+//#endregion
+export { HistoryRecord, TestHistory, TestRun };

package/schemas/Identity.js

@@ -0,0 +1,64 @@
+import { Schema } from "effect";
+
+//#region src/schemas/Identity.ts
+/**
+* Canonical UUID for an LLM agent invocation. Generated server-side at
+* `register_agent` time. Stable across transport reconnects within an
+* agent's lifetime.
+* @public
+*/
+const AgentId = Schema.UUID.pipe(Schema.brand("AgentId"));
+/**
+* The unit "all work on this feature" rolls up to. Survives
+* `claude --resume` and parallel windows; lives in the host's
+* transcript filename for Claude Code.
+* @public
+*/
+const ConversationId = Schema.UUID.pipe(Schema.brand("ConversationId"));
+/**
+* The agent host process's chat id (Claude Code's per-process chat
+* UUID, etc.). Shorter-lived than a conversation; one conversation can
+* have multiple chats across `--resume` invocations. Distinct from
+* `sessions.id` (the SQLite agent-run PK).
+* @public
+*/
+const ChatId = Schema.UUID.pipe(Schema.brand("ChatId"));
+/**
+* One TDD orchestration task. Replaces the legacy `tdd_session_id`
+* vocabulary so "session" is unambiguous in the codebase.
+* @public
+*/
+const TddTaskId = Schema.UUID.pipe(Schema.brand("TddTaskId"));
+/**
+* Filesystem-safe key for the per-project data store directory under
+* `$XDG_DATA_HOME/vitest-agent/<projectKey>/`. Resolved by the
+* `ProjectIdentity` service from the explicit option / TOML config /
+* git remote / package.json fallback chain. Always non-empty (a missing
+* value is `ProjectIdentityNotResolvableError`, not an empty string).
+* @public
+*/
+const ProjectKey = Schema.String.pipe(Schema.minLength(1), Schema.brand("ProjectKey"));
+/**
+* Who initiated the action (test run, hypothesis, note, TDD phase, …).
+* Recorded on every action row alongside `agent_id`.
+*
+* - `agent` — an LLM agent (`agent_id` is set, `conversation_id` is set)
+* - `user`  — a human at a terminal (`agent_id` and `conversation_id` are NULL)
+* - `system` — a CI run, scheduler, or other non-human/non-agent actor
+* @public
+*/
+const ActorType = Schema.Literal("agent", "user", "system").annotations({ identifier: "ActorType" });
+/**
+* Recommended canonical host identifiers. Open enum at the SDK level so
+* a new client doesn't require an SDK release; the MCP server defaults
+* `agentType` validation against the `${hostKind}-` prefix using this
+* value.
+*
+* `unknown` is the explicit fallback when `clientInfo.name` doesn't
+* match a known pattern — preferred over guessing.
+* @public
+*/
+const HostKind = Schema.Literal("claude-code", "claude-desktop", "cursor", "goose", "chatgpt", "mcp-inspector", "unknown").annotations({ identifier: "HostKind" });
+
+//#endregion
+export { ActorType, AgentId, ChatId, ConversationId, HostKind, ProjectKey, TddTaskId };

package/schemas/Options.js

@@ -0,0 +1,57 @@
+import { AgentConsoleMode, CiConsoleMode, HumanConsoleMode } from "./Common.js";
+import { CoverageTargets } from "./CoverageTargets.js";
+import { Transport } from "./Transport.js";
+import { Schema } from "effect";
+
+//#region src/schemas/Options.ts
+/**
+* Per-executor console-output matrix. Most users never set this — the
+* built-in defaults cover the common cases. Override per slot when you
+* want to force a specific layout for debugging or to suppress one
+* channel without affecting the others.
+*
+* Defaults:
+* - `human` → `"passthrough"` today; users opt into `"stream"` explicitly
+*   for the progressively-drawn, animated agent-shaped live renderer.
+* - `agent` → `"agent"` (markdown-flavored final frame).
+* - `ci` → `"passthrough"` (Vitest's reporters produce log-friendly
+*   output). `"ci-annotations"` is opt-in until the dedicated GHA
+*   annotations writer ships.
+* @public
+*/
+const ConsoleOutputs = Schema.Struct({
+	human: Schema.optional(HumanConsoleMode),
+	agent: Schema.optional(AgentConsoleMode),
+	ci: Schema.optional(CiConsoleMode)
+}).annotations({ identifier: "ConsoleOutputs" });
+/**
+* The 2.0 user-facing options for `AgentPlugin`.
+*
+* Five fields total. Two are function-typed (`reporter`, `onRunEvent`)
+* and live on the `AgentPluginConstructorOptions` companion interface in
+* `@vitest-agent/plugin` — Effect Schema cannot encode functions cleanly,
+* so the schema-decodable struct carries the three data-shaped fields.
+* @public
+*/
+const AgentPluginOptions = Schema.Struct({
+	console: Schema.optional(ConsoleOutputs),
+	coverageTargets: Schema.optional(CoverageTargets),
+	transport: Schema.optional(Transport)
+}).annotations({ identifier: "AgentPluginOptions" });
+/**
+* Reporter-implementation options.
+*
+* Public for users building custom reporters via `@vitest-agent/reporter`;
+* most users never see this type — they wire `AgentPlugin({ reporter })`
+* and the factory receives a fully-resolved `ReporterKit` instead.
+*
+* Carries internal flags the plugin sets when constructing the reporter
+* (currently only `projectFilter` for per-project scoping).
+* @public
+*/
+const AgentReporterOptions = Schema.Struct({ 
+/** Set by the plugin per-project. Filters reports to one project. */
+projectFilter: Schema.optional(Schema.String) }).annotations({ identifier: "AgentReporterOptions" });
+
+//#endregion
+export { AgentPluginOptions, AgentReporterOptions, ConsoleOutputs };

package/schemas/RenderState.js

@@ -0,0 +1,161 @@
+import { ReportError, TestClassification, TestState } from "./Common.js";
+import { MetricThresholds } from "./Thresholds.js";
+import { CoverageTotals } from "./Coverage.js";
+import { ActionSeverity, CoverageGap, CoverageMetric } from "./RunEvent.js";
+import { Schema } from "effect";
+
+//#region src/schemas/RenderState.ts
+/**
+* Per-test record accumulated as `TestStarted` / `TestFinished` events arrive.
+* @public
+*/
+const TestRecord = Schema.Struct({
+	testName: Schema.String,
+	suitePath: Schema.Array(Schema.String),
+	status: Schema.Union(TestState, Schema.Literal("running", "timed-out")),
+	durationMs: Schema.NullOr(Schema.Number),
+	error: Schema.optional(ReportError)
+}).annotations({ identifier: "TestRecord" });
+/**
+* Per-module aggregation. The reducer keeps modules keyed on
+* `modulePath` so out-of-order events can update the right slot.
+* @public
+*/
+const ModuleRecord = Schema.Struct({
+	modulePath: Schema.String,
+	status: Schema.Literal("queued", "running", "finished"),
+	passCount: Schema.Number,
+	failCount: Schema.Number,
+	skipCount: Schema.Number,
+	timeoutCount: Schema.Number,
+	durationMs: Schema.Number,
+	tests: Schema.Array(TestRecord),
+	/**
+	* Owning Vitest project name. Optional — events from project-less
+	* configs or older replays leave it `undefined`, which the renderer
+	* treats as a single anonymous project.
+	*/
+	projectName: Schema.optional(Schema.String),
+	/**
+	* ISO wall-clock stamp captured at `onTestModuleStart`. The live
+	* renderer derives a ticking elapsed column from it while the module
+	* runs; once finished it shows `durationMs` instead. Optional — a
+	* module seeded by `ModuleQueued` (or replayed) has no start stamp.
+	*/
+	startedAt: Schema.optional(Schema.String),
+	tagCounts: Schema.optional(Schema.Record({
+		key: Schema.String,
+		value: Schema.Number
+	}))
+}).annotations({ identifier: "ModuleRecord" });
+/**
+* One row in the failure list. A failure can exist before its
+* classification arrives (`FailureClassified` is emitted from a
+* separate pipeline), so `classification` is nullable.
+* @public
+*/
+const FailureRecord = Schema.Struct({
+	modulePath: Schema.String,
+	testName: Schema.String,
+	suitePath: Schema.Array(Schema.String),
+	error: Schema.optional(ReportError),
+	timedOut: Schema.optional(Schema.Boolean),
+	classification: Schema.NullOr(TestClassification)
+}).annotations({ identifier: "FailureRecord" });
+/**
+* Coverage block, populated only after `CoverageReady`. Threshold
+* violations are accumulated separately as they arrive.
+* @public
+*/
+const CoverageRenderState = Schema.Struct({
+	metrics: CoverageTotals,
+	thresholds: MetricThresholds,
+	gaps: Schema.Array(CoverageGap),
+	violations: Schema.Array(Schema.Struct({
+		metric: CoverageMetric,
+		expected: Schema.Number,
+		actual: Schema.Number
+	}))
+}).annotations({ identifier: "CoverageRenderState" });
+/**
+* A `SuggestedAction` event, denormalized into the queue the renderer reads.
+* @public
+*/
+const SuggestedActionRecord = Schema.Struct({
+	severity: ActionSeverity,
+	title: Schema.String,
+	detail: Schema.String,
+	targetTool: Schema.optional(Schema.String)
+}).annotations({ identifier: "SuggestedActionRecord" });
+/**
+* Per-run totals, recomputed on every `ModuleFinished` and reconciled
+* against `RunFinished` (which carries the runner's own count).
+* @public
+*/
+const RenderTotals = Schema.Struct({
+	passCount: Schema.Number,
+	failCount: Schema.Number,
+	skipCount: Schema.Number,
+	timeoutCount: Schema.Number,
+	durationMs: Schema.Number
+}).annotations({ identifier: "RenderTotals" });
+/**
+* The renderer state. Both the human (Ink) and agent (string)
+* renderers read this shape; the reducer is the only producer.
+*
+* `phase` is the layout discriminator — agent mode emits one final
+* frame when `phase === "finished"`; human mode redraws at every
+* state change. `"timed-out"` is a terminal phase like `"finished"`
+* — the run is over, but it ended because `onProcessTimeout` fired
+* rather than the suite completing.
+* @public
+*/
+const RenderState = Schema.Struct({
+	phase: Schema.Literal("idle", "running", "finished", "timed-out"),
+	runId: Schema.NullOr(Schema.String),
+	configHash: Schema.NullOr(Schema.String),
+	startedAt: Schema.NullOr(Schema.String),
+	finishedAt: Schema.NullOr(Schema.String),
+	modules: Schema.Record({
+		key: Schema.String,
+		value: ModuleRecord
+	}),
+	moduleOrder: Schema.Array(Schema.String),
+	totals: RenderTotals,
+	coverage: Schema.NullOr(CoverageRenderState),
+	trend: Schema.NullOr(Schema.Struct({
+		direction: Schema.Literal("improving", "regressing", "stable"),
+		runCount: Schema.Number
+	})),
+	failures: Schema.Array(FailureRecord),
+	suggestedActions: Schema.Array(SuggestedActionRecord)
+}).annotations({ identifier: "RenderState" });
+/**
+* Initial state — what the reducer returns when no events have been
+* applied yet. Exported so tests and the renderers' bootstrapping
+* code share one definition.
+* @public
+*/
+const initialRenderState = {
+	phase: "idle",
+	runId: null,
+	configHash: null,
+	startedAt: null,
+	finishedAt: null,
+	modules: {},
+	moduleOrder: [],
+	totals: {
+		passCount: 0,
+		failCount: 0,
+		skipCount: 0,
+		timeoutCount: 0,
+		durationMs: 0
+	},
+	coverage: null,
+	trend: null,
+	failures: [],
+	suggestedActions: []
+};
+
+//#endregion
+export { CoverageRenderState, FailureRecord, ModuleRecord, RenderState, RenderTotals, SuggestedActionRecord, TestRecord, initialRenderState };

package/schemas/RunEvent.js

@@ -0,0 +1,163 @@
+import { ReportError, TestClassification, TestState } from "./Common.js";
+import { MetricThresholds } from "./Thresholds.js";
+import { CoverageTotals, FileCoverageReport } from "./Coverage.js";
+import { Schema } from "effect";
+
+//#region src/schemas/RunEvent.ts
+/**
+* Coverage metric whose threshold can be violated independently.
+* @public
+*/
+const CoverageMetric = Schema.Literal("lines", "branches", "functions", "statements").annotations({ identifier: "CoverageMetric" });
+/**
+* Severity tier for a suggested action emitted during a run.
+* @public
+*/
+const ActionSeverity = Schema.Literal("info", "warn", "blocker").annotations({ identifier: "ActionSeverity" });
+/**
+* Lifecycle scope of a Vitest setup/teardown hook.
+* @public
+*/
+const HookType = Schema.Literal("beforeAll", "afterAll", "beforeEach", "afterEach").annotations({ identifier: "HookType" });
+/**
+* Terminal status of a Vitest hook run.
+* @public
+*/
+const HookStatus = Schema.Literal("passed", "failed").annotations({ identifier: "HookStatus" });
+/**
+* Output stream a captured user `console.log` was written to.
+* @public
+*/
+const ConsoleLogLevel = Schema.Literal("stdout", "stderr").annotations({ identifier: "ConsoleLogLevel" });
+/**
+* A coverage gap surfaced to the renderer — a per-file shortfall that
+* a renderer may want to call out individually.
+* @public
+*/
+const CoverageGap = Schema.Struct({
+	file: Schema.String,
+	missing: CoverageTotals,
+	uncoveredLines: Schema.optional(Schema.String)
+}).annotations({ identifier: "CoverageGap" });
+/**
+* The reducer projects this union into `RenderState`. Renderers
+* never read the raw event stream — they read the projected state.
+*
+* @remarks
+* Adding a variant here is one change in one place; the reducer's
+* exhaustive `Match.exhaustive` will surface any renderer that hasn't
+* been updated to consume the new state shape.
+* @public
+*/
+const RunEvent = Schema.Union(Schema.TaggedStruct("RunStarted", {
+	runId: Schema.String,
+	startedAt: Schema.String,
+	configHash: Schema.String
+}), Schema.TaggedStruct("ModuleQueued", {
+	modulePath: Schema.String,
+	projectName: Schema.optional(Schema.String)
+}), Schema.TaggedStruct("ModuleStarted", {
+	modulePath: Schema.String,
+	startedAt: Schema.String,
+	projectName: Schema.optional(Schema.String)
+}), Schema.TaggedStruct("TestStarted", {
+	modulePath: Schema.String,
+	testName: Schema.String,
+	suitePath: Schema.Array(Schema.String)
+}), Schema.TaggedStruct("TestFinished", {
+	modulePath: Schema.String,
+	testName: Schema.String,
+	suitePath: Schema.Array(Schema.String),
+	status: TestState,
+	durationMs: Schema.Number,
+	error: Schema.optional(ReportError),
+	timedOut: Schema.optional(Schema.Boolean)
+}), Schema.TaggedStruct("ModuleFinished", {
+	modulePath: Schema.String,
+	passCount: Schema.Number,
+	failCount: Schema.Number,
+	skipCount: Schema.Number,
+	durationMs: Schema.Number,
+	projectName: Schema.optional(Schema.String),
+	timeoutCount: Schema.optional(Schema.Number),
+	tagCounts: Schema.optional(Schema.Record({
+		key: Schema.String,
+		value: Schema.Number
+	}))
+}), Schema.TaggedStruct("ModuleCollected", {
+	modulePath: Schema.String,
+	testCount: Schema.Number,
+	suiteCount: Schema.Number
+}), Schema.TaggedStruct("SuiteStarted", {
+	modulePath: Schema.String,
+	suitePath: Schema.Array(Schema.String),
+	suiteName: Schema.String
+}), Schema.TaggedStruct("SuiteFinished", {
+	modulePath: Schema.String,
+	suitePath: Schema.Array(Schema.String),
+	suiteName: Schema.String,
+	passCount: Schema.Number,
+	failCount: Schema.Number,
+	skipCount: Schema.Number
+}), Schema.TaggedStruct("HookStarted", {
+	modulePath: Schema.String,
+	hookType: HookType,
+	scopeName: Schema.String
+}), Schema.TaggedStruct("HookFinished", {
+	modulePath: Schema.String,
+	hookType: HookType,
+	scopeName: Schema.String,
+	durationMs: Schema.Number,
+	status: HookStatus,
+	error: Schema.optional(ReportError)
+}), Schema.TaggedStruct("ConsoleLog", {
+	modulePath: Schema.optional(Schema.String),
+	testName: Schema.optional(Schema.String),
+	level: ConsoleLogLevel,
+	content: Schema.String,
+	time: Schema.Number
+}), Schema.TaggedStruct("RunTimedOut", { message: Schema.String }), Schema.TaggedStruct("TestAnnotated", {
+	modulePath: Schema.String,
+	testName: Schema.String,
+	suitePath: Schema.Array(Schema.String),
+	annotation: Schema.String
+}), Schema.TaggedStruct("TestArtifactRecorded", {
+	modulePath: Schema.String,
+	testName: Schema.String,
+	suitePath: Schema.Array(Schema.String),
+	artifact: Schema.String
+}), Schema.TaggedStruct("WatcherReady", {}), Schema.TaggedStruct("WatcherRerun", {
+	triggerFiles: Schema.Array(Schema.String),
+	reason: Schema.optional(Schema.String)
+}), Schema.TaggedStruct("TrendComputed", {
+	direction: Schema.Literal("improving", "regressing", "stable"),
+	runCount: Schema.Number
+}), Schema.TaggedStruct("CoverageReady", {
+	metrics: CoverageTotals,
+	thresholds: MetricThresholds,
+	gaps: Schema.Array(CoverageGap)
+}), Schema.TaggedStruct("ThresholdViolation", {
+	metric: CoverageMetric,
+	expected: Schema.Number,
+	actual: Schema.Number
+}), Schema.TaggedStruct("FailureClassified", {
+	modulePath: Schema.String,
+	testName: Schema.String,
+	classification: TestClassification
+}), Schema.TaggedStruct("SuggestedAction", {
+	severity: ActionSeverity,
+	title: Schema.String,
+	detail: Schema.String,
+	targetTool: Schema.optional(Schema.String)
+}), Schema.TaggedStruct("RunFinished", {
+	runId: Schema.String,
+	finishedAt: Schema.String,
+	passCount: Schema.Number,
+	failCount: Schema.Number,
+	skipCount: Schema.Number,
+	durationMs: Schema.Number,
+	timeoutCount: Schema.optional(Schema.Number)
+})).annotations({ identifier: "RunEvent" });
+
+//#endregion
+export { ActionSeverity, ConsoleLogLevel, CoverageGap, CoverageMetric, HookStatus, HookType, RunEvent };

package/schemas/Tdd.js

@@ -0,0 +1,44 @@
+import { Schema } from "effect";
+
+//#region src/schemas/Tdd.ts
+/** @public */
+const GoalStatus = Schema.Literal("pending", "in_progress", "done", "abandoned").annotations({ identifier: "GoalStatus" });
+/** @public */
+const BehaviorStatus = Schema.Literal("pending", "in_progress", "done", "abandoned").annotations({ identifier: "BehaviorStatus" });
+/** @public */
+const GoalRow = Schema.Struct({
+	id: Schema.Number,
+	sessionId: Schema.Number,
+	ordinal: Schema.Number,
+	goal: Schema.String,
+	status: GoalStatus,
+	createdAt: Schema.String
+}).annotations({ identifier: "GoalRow" });
+/** @public */
+const BehaviorRow = Schema.Struct({
+	id: Schema.Number,
+	goalId: Schema.Number,
+	ordinal: Schema.Number,
+	behavior: Schema.String,
+	suggestedTestName: Schema.NullOr(Schema.String),
+	status: BehaviorStatus,
+	createdAt: Schema.String
+}).annotations({ identifier: "BehaviorRow" });
+/** @public */
+const GoalDetail = Schema.Struct({
+	...GoalRow.fields,
+	behaviors: Schema.Array(BehaviorRow)
+}).annotations({ identifier: "GoalDetail" });
+/** @public */
+const BehaviorDetail = Schema.Struct({
+	...BehaviorRow.fields,
+	parentGoal: Schema.Struct({
+		id: Schema.Number,
+		goal: Schema.String,
+		status: GoalStatus
+	}),
+	dependencies: Schema.Array(BehaviorRow)
+}).annotations({ identifier: "BehaviorDetail" });
+
+//#endregion
+export { BehaviorDetail, BehaviorRow, BehaviorStatus, GoalDetail, GoalRow, GoalStatus };