@codeworksh/harness 0.2.0-dev.20261013042837 → 0.2.0-dev.20261013124604

package/effect.mjs

@@ -1,10 +1,10 @@
 import { n as __reExport, t as __exportAll } from "./rolldown-runtime-B4FMCO8f.mjs";
 import { a as io_exports, i as errors_exports, n as shell_exports, o as instance_exports, r as filesystem_exports, s as posix } from "./resource-DFZh0e-s.mjs";
-import "./daytona-ByTHZelc.mjs";
+import { a as decode, c as importModule, d as share, l as lendResolve, n as dimensionNote, o as load$5, r as resize, s as load$4, u as resolveModule } from "./resize-D34zcVQl.mjs";
+import "./daytona-D4sNwzSr.mjs";
 import "./vercel-3GouQSJI.mjs";
-import { a as decode, n as dimensionNote, o as load$4, r as resize } from "./resize-Dwv5dCgY.mjs";
-import { createRequire, registerHooks } from "node:module";
-import { Cause, Clock, Config, Context, Crypto, DateTime, Deferred, Duration, Effect, Exit, Fiber, FiberSet, FileSystem, Layer, LayerMap, Option, Path, Predicate, PubSub, Queue, Random, Ref, Result, Schedule, Schema, SchemaIssue, Scope, Semaphore, Stream, String as String$1 } from "effect";
+import { createRequire } from "node:module";
+import { Cause, Clock, Config, Context, Crypto, Data, DateTime, Deferred, Duration, Effect, Exit, Fiber, FiberSet, FileSystem, Layer, LayerMap, Metric, Option, Path, Predicate, PubSub, Queue, Random, Ref, Result, Schedule, Schema, SchemaIssue, Scope, Semaphore, Stream, String as String$1 } from "effect";
 import { Message, Model, getEnvApiKey, llm, normalizeOptionalNulls, stream } from "@codeworksh/aikit";
 import { MessageID as ID, SessionID as ID$1 } from "@codeworksh/plugin/ids";
 import { Migrator, SqlClient, SqlClient as SqlClient$1, SqlError, SqlSchema, SqlSchema as SqlSchema$1 } from "effect/sql";
@@ -16,10 +16,10 @@ import { NodeChildProcessSpawner, NodeCrypto, NodeFileSystem, NodePath } from "@
 import { Model as Model$1, VariantSchema } from "effect/schema";
 import { Hex } from "effect/encoding";
 import { MemoryProvider, RealFSProvider, SqliteProvider, create } from "@platformatic/vfs";
-import fs, { statSync } from "node:fs";
+import fs from "node:fs";
 import { ChildProcess, ChildProcessSpawner } from "effect/process";
 import { Buffer as Buffer$1 } from "node:buffer";
-import { Bash } from "just-bash";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import { DirectoryNotFoundError, DirectoryNotFoundError as DirectoryNotFoundError$1, Info, Info as Info$1, NotDirectoryError, NotDirectoryError as NotDirectoryError$1, Service, Service as Service$8 } from "@codeworksh/plugin/location";
 import { generateModels } from "@codeworksh/aikit/modelgen";
 import { JsonGitHubCopilotAuthStorage, getGitHubCopilotApiKey } from "@codeworksh/aikit/oauth/github/copilot";
@@ -28,9 +28,6 @@ import { parse, printParseErrorCode } from "jsonc-parser";
 import * as Section from "@codeworksh/plugin/plugin/section";
 import * as Diff from "diff";
 import { FetchHttpClient, HttpClient } from "effect/http";
-import { fileURLToPath, pathToFileURL } from "node:url";
-import path from "node:path";
-import { Script, constants } from "node:vm";
 import npa from "npm-package-arg";
 import * as AikitFailure from "@codeworksh/aikit/failure";
 import "@codeworksh/plugin/tool/error";
@@ -380,7 +377,7 @@ var db_exports = /* @__PURE__ */ __exportAll({
 	defaultLayer: () => defaultLayer$1,
 	layer: () => layer$26,
 	locationConfig: () => locationConfig,
-	path: () => path$2,
+	path: () => path$1,
 	resolveDatabaseLocation: () => resolveDatabaseLocation
 });
 const setup = Effect.gen(function* () {
@@ -407,11 +404,11 @@ function resolveDatabaseLocation(configured, data) {
 	if (configured === ":memory:" || posix.isAbsolute(configured)) return configured;
 	return posix.join(data, configured);
 }
-const path$2 = Effect.fn("Database.path")(function* (data) {
+const path$1 = Effect.fn("Database.path")(function* (data) {
 	const directory = data ?? (yield* resolve$4()).data;
 	return resolveDatabaseLocation(yield* locationConfig, directory);
 });
-const defaultLayer$1 = Layer.unwrap(path$2().pipe(Effect.map(layer$26)));
+const defaultLayer$1 = Layer.unwrap(path$1().pipe(Effect.map(layer$26)));
 //#endregion
 //#region src/event/schema.ts
 var schema_exports$7 = /* @__PURE__ */ __exportAll({});
@@ -2643,6 +2640,114 @@ const layer$22 = Layer.effect(Service$13, Effect.gen(function* () {
 	return Service$13.of({ assemble });
 }));
 //#endregion
+//#region src/telemetry/telemetry.ts
+const durationBuckets = Metric.boundariesFromIterable([
+	.01,
+	.02,
+	.04,
+	.08,
+	.16,
+	.32,
+	.64,
+	1.28,
+	2.56,
+	5.12,
+	10.24,
+	20.48,
+	40.96,
+	81.92
+]);
+const llmDuration = Metric.histogram("codework.llm.duration", {
+	description: "Provider request duration",
+	attributes: { unit: "s" },
+	boundaries: durationBuckets
+});
+const llmTtft = Metric.histogram("codework.llm.ttft", {
+	description: "Time to first token: from request start to the first streamed content",
+	attributes: { unit: "s" },
+	boundaries: Metric.boundariesFromIterable([
+		.001,
+		.005,
+		.01,
+		.02,
+		.04,
+		.06,
+		.08,
+		.1,
+		.25,
+		.5,
+		.75,
+		1,
+		2.5,
+		5,
+		7.5,
+		10
+	])
+});
+const llmTokens = Metric.counter("codework.llm.tokens", {
+	description: "Tokens used, by type; cache and reasoning tokens are part of input and output",
+	attributes: { unit: "{token}" },
+	incremental: true
+});
+const llmCost = Metric.counter("codework.llm.cost", {
+	description: "Provider request cost from the model catalog's prices",
+	attributes: { unit: "USD" },
+	incremental: true
+});
+const agentDuration = Metric.histogram("codework.agent.duration", {
+	description: "Session run duration, across every turn it drains",
+	attributes: { unit: "s" },
+	boundaries: Metric.boundariesFromIterable([
+		.1,
+		.2,
+		.4,
+		.8,
+		1.6,
+		3.2,
+		6.4,
+		12.8,
+		25.6,
+		51.2,
+		102.4,
+		204.8,
+		409.6
+	])
+});
+const toolDuration = Metric.histogram("codework.tool.duration", {
+	description: "Tool execution duration",
+	attributes: { unit: "s" },
+	boundaries: durationBuckets
+});
+const sandboxProvisionDuration = Metric.histogram("codework.sandbox.provision.duration", {
+	description: "Sandbox driver create and wake duration",
+	attributes: { unit: "s" },
+	boundaries: durationBuckets
+});
+const sandboxExecDuration = Metric.histogram("codework.sandbox.exec.duration", {
+	description: "Sandbox shell command duration",
+	attributes: { unit: "s" },
+	boundaries: durationBuckets
+});
+const sandboxActive = Metric.gauge("codework.sandbox.active", {
+	description: "Managed and remote sandboxes with at least one mount",
+	attributes: { unit: "{sandbox}" }
+});
+const record$1 = (metric, value, attributes) => Metric.update(Metric.withAttributes(metric, attributes), value);
+const adjust = (metric, delta, attributes) => Metric.modify(Metric.withAttributes(metric, attributes), delta);
+const errorType = (cause) => {
+	if (Cause.hasInterruptsOnly(cause)) return "interrupted";
+	const error = Cause.squash(cause);
+	return typeof error === "object" && error !== null && "_tag" in error && typeof error._tag === "string" ? error._tag : "_OTHER";
+};
+const withError = (attributes, exit) => Exit.isSuccess(exit) ? attributes : {
+	...attributes,
+	error: errorType(exit.cause)
+};
+const timed = (self, observe) => Effect.clockWith((clock) => {
+	const start = clock.currentTimeMillisUnsafe();
+	return self.pipe(Effect.onExit((exit) => observe((clock.currentTimeMillisUnsafe() - start) / 1e3, exit)));
+});
+//#endregion
 //#region src/sandbox/driver.ts
 var driver_exports = /* @__PURE__ */ __exportAll({});
 import * as import__codeworksh_plugin_sandbox_driver from "@codeworksh/plugin/sandbox/driver";
@@ -3029,6 +3134,22 @@ const parseJson = (driver, operation, value) => decodeUnknownJson(value).pipe(Ef
 	operation,
 	cause
 })));
+const provision = (driver, operation, self) => timed(self, (seconds, exit) => record$1(sandboxProvisionDuration, seconds, withError({
+	driver,
+	operation
+}, exit)));
+const timedShell = (shell, driver) => {
+	const time = (self) => timed(self, (seconds, exit) => record$1(sandboxExecDuration, seconds, withError({ driver }, exit)));
+	const stream = shell.stream;
+	return {
+		exec: (command, options) => time(shell.exec(command, options)),
+		execArgv: (argv, options) => time(shell.execArgv(argv, options)),
+		...stream === void 0 ? {} : { stream: (command, options) => Stream.unwrap(Effect.clockWith((clock) => {
+			const start = clock.currentTimeMillisUnsafe();
+			return Effect.succeed(stream(command, options).pipe(Stream.onExit((exit) => record$1(sandboxExecDuration, (clock.currentTimeMillisUnsafe() - start) / 1e3, withError({ driver }, exit)))));
+		})) }
+	};
+};
 const make$14 = Effect.fn("Sandbox.Controller.make")(function* (options) {
 	const sql = yield* SqlClient.SqlClient;
 	const registry = yield* Registry;
@@ -3039,20 +3160,22 @@ const make$14 = Effect.fn("Sandbox.Controller.make")(function* (options) {
 	const hostCreatedAt = asDate(yield* DateTime.now);
 	const refCount = (id) => refs.get(id) ?? 0;
 	const usage = (id, count = refCount(id)) => id === instance_exports.SandboxInstance.ID.local ? "pinned" : count > 0 ? "busy" : "idle";
+	const activeChanged = (lease, delta) => lease.driver === void 0 ? Effect.void : adjust(sandboxActive, delta, { driver: lease.driver });
 	const acquireLease = (id, lease) => gate.withPermits(1)(Effect.sync(() => {
 		const wasIdle = refCount(id) === 0;
 		refs.set(id, refCount(id) + 1);
 		lease.held = true;
 		return wasIdle;
-	}));
+	})).pipe(Effect.tap((wasIdle) => wasIdle ? activeChanged(lease, 1) : Effect.void));
 	const releaseLease = (id, lease) => Effect.gen(function* () {
 		if (!lease.held) return;
-		yield* gate.withPermits(1)(Effect.sync(() => {
+		if (yield* gate.withPermits(1)(Effect.sync(() => {
 			const next = Math.max(0, refCount(id) - 1);
 			if (next === 0) refs.delete(id);
 			else refs.set(id, next);
 			lease.held = false;
-		}));
+			return next === 0;
+		}))) yield* activeChanged(lease, -1);
 		if (!lease.mounted) return;
 		const now = yield* Effect.clockWith((clock) => clock.currentTimeMillis);
 		yield* sql`
@@ -3222,7 +3345,7 @@ const make$14 = Effect.fn("Sandbox.Controller.make")(function* (options) {
 		const attached = yield* runtime(row, "resolveCwd");
 		return driver_exports.SandboxDriver.AbsolutePath.make(io_exports.SandboxIO.resolveMountCwd(attached.input.runtimeConfig.defaultCwd, override));
 	});
-	const create = Effect.fn("Sandbox.Controller.create")(function* (input) {
+	const create = Effect.fn("Sandbox.Controller.create", { level: "Info" })(function* (input) {
 		const driver = yield* registry.get(input.driver.name);
 		const config = yield* registry.decodeCreateConfig(input.driver.name, input.config);
 		const id = input.instanceId ?? instance_exports.SandboxInstance.ID.create();
@@ -3238,10 +3361,10 @@ const make$14 = Effect.fn("Sandbox.Controller.make")(function* (options) {
 			status: "provisioning",
 			metadata: input.metadata
 		});
-		const provisioned = yield* driver.create({
+		const provisioned = yield* provision(driver.name, "create", driver.create({
 			instanceId: id,
 			config
-		}).pipe(Effect.catch((error) => persistProviderFailure(id, "faulted", error)));
+		})).pipe(Effect.catch((error) => persistProviderFailure(id, "faulted", error)));
 		return yield* Effect.gen(function* () {
 			const encoded = yield* registry.encodeRuntimeConfig(driver.name, provisioned.runtimeConfig);
 			const runtimeConfig = yield* encodeUnknownJson$1(encoded).pipe(Effect.mapError((cause) => (0, errors_exports.providerError)({
@@ -3330,7 +3453,8 @@ const make$14 = Effect.fn("Sandbox.Controller.make")(function* (options) {
 		let invalidateBeforeAttach = false;
 		const lease = reserved ?? {
 			held: false,
-			mounted: false
+			mounted: false,
+			driver: void 0
 		};
 		if (id === instance_exports.SandboxInstance.ID.local) identity = {
 			id,
@@ -3355,6 +3479,7 @@ const make$14 = Effect.fn("Sandbox.Controller.make")(function* (options) {
 			});
 			invalidateBeforeAttach = row.status !== "online";
 			const attached = yield* runtime(row, "mount");
+			lease.driver = attached.driver.name;
 			identity = {
 				id,
 				driver: attached.driver.name,
@@ -3377,7 +3502,10 @@ const make$14 = Effect.fn("Sandbox.Controller.make")(function* (options) {
 				lease.held = true;
 				return idle;
 			}));
-			if (reserved === void 0) yield* Effect.addFinalizer(() => releaseLease(id, lease));
+			if (reserved === void 0) {
+				yield* Effect.addFinalizer(() => releaseLease(id, lease));
+				if (wasIdle) yield* activeChanged(lease, 1);
+			}
 			if (wasIdle && invalidateBeforeAttach) yield* transports.invalidate(id);
 		}
 		const handleTransportError = (error) => {
@@ -3407,7 +3535,7 @@ const make$14 = Effect.fn("Sandbox.Controller.make")(function* (options) {
 						WHERE id = ${id}
 					`.pipe(Effect.orDie);
 		}
-		return Layer.mergeAll(Layer.succeed(io_exports.SandboxIO.Current, identity), Layer.succeed(io_exports.SandboxIO.FileSystem, filesystem_exports.SandboxFileSystem.withCwd(fs, identity.cwd)), Layer.succeed(io_exports.SandboxIO.Shell, (0, shell_exports.withCwd)(shell, identity.cwd))).pipe(io_exports.SandboxIO.withMutation);
+		return Layer.mergeAll(Layer.succeed(io_exports.SandboxIO.Current, identity), Layer.succeed(io_exports.SandboxIO.FileSystem, filesystem_exports.SandboxFileSystem.withCwd(fs, identity.cwd)), Layer.succeed(io_exports.SandboxIO.Shell, timedShell((0, shell_exports.withCwd)(shell, identity.cwd), identity.driver))).pipe(io_exports.SandboxIO.withMutation);
 	}));
 	const mount = (id, mountOptions) => mountLayer(id, mountOptions);
 	const withMount = (id, use, mountOptions) => use.pipe(Effect.provide(mount(id, mountOptions)), Effect.scoped);
@@ -3434,7 +3562,7 @@ const make$14 = Effect.fn("Sandbox.Controller.make")(function* (options) {
 		});
 		return yield* reload(id);
 	});
-	const wake = Effect.fn("Sandbox.Controller.wake")(function* (id) {
+	const wake = Effect.fn("Sandbox.Controller.wake", { level: "Info" })(function* (id) {
 		if (id === instance_exports.SandboxInstance.ID.local) return hostInfo();
 		const row = yield* requireRow(id);
 		if (row.status === "removed") return yield* new errors_exports.SandboxRemovedError({
@@ -3448,7 +3576,7 @@ const make$14 = Effect.fn("Sandbox.Controller.make")(function* (options) {
 			operation: "wake"
 		});
 		if (refCount(id) === 0) yield* transports.invalidate(id);
-		const observed = yield* attached.driver.wake(attached.input).pipe(Effect.catch((error) => (0, errors_exports.providerErrorIsNotFound)(error) ? markUnavailable(id, error) : persistProviderFailure(id, "faulted", error)));
+		const observed = yield* provision(attached.driver.name, "wake", attached.driver.wake(attached.input)).pipe(Effect.catch((error) => (0, errors_exports.providerErrorIsNotFound)(error) ? markUnavailable(id, error) : persistProviderFailure(id, "faulted", error)));
 		yield* updateObservation({
 			id,
 			status: observed.status,
@@ -3607,7 +3735,8 @@ const make$14 = Effect.fn("Sandbox.Controller.make")(function* (options) {
 		const id = input.instanceId ?? instance_exports.SandboxInstance.ID.create();
 		const lease = {
 			held: false,
-			mounted: false
+			mounted: false,
+			driver: input.driver.name
 		};
 		return Layer.unwrap(Effect.gen(function* () {
 			yield* acquireLease(id, lease);
@@ -3875,7 +4004,8 @@ const fromBash = (bash) => {
 	});
 	return shell_exports.Shell.of((0, shell_exports.fromExec)({ exec }));
 };
-const make$12 = (vfs, cwd) => fromBash(new Bash({
+const JustBash = load$4("just-bash").pipe(Effect.map((module) => module), Effect.orDie);
+const make$12 = (module, vfs, cwd) => fromBash(new module.Bash({
 	fs: bridge(vfs, cwd),
 	cwd
 }));
@@ -3884,9 +4014,10 @@ const make$12 = (vfs, cwd) => fromBash(new Bash({
 * mount binds its cwd. This matches Flue's BashFactory ownership: mounts share
 * the VFS, but shell state (functions, options, command hashes) is mount-local.
 */
-const transport$1 = (inner) => Layer.provideMerge(Layer.effect(shell_exports.Shell, Effect.map(Vfs, (vfs) => {
-	const root = make$12(vfs, "/");
-	return (0, shell_exports.perMount)(root, (cwd) => make$12(vfs, cwd));
+const transport$1 = (inner) => Layer.provideMerge(Layer.effect(shell_exports.Shell, Effect.gen(function* () {
+	const module = yield* JustBash;
+	const vfs = yield* Vfs;
+	return (0, shell_exports.perMount)(make$12(module, vfs, "/"), (cwd) => make$12(module, vfs, cwd));
 })), inner);
 //#endregion
 //#region src/sandbox/virtual.ts
@@ -5650,7 +5781,7 @@ const ancestors = (directory) => {
 * Which of `paths` are files. Absence is the expected answer and stays silent; any other failure
 * (permissions, a remote blip) is logged so a dropped file is not a mystery, then counts as absent.
 */
-const present$1 = (fs, paths) => Effect.forEach(paths, (path) => fs.stat(path).pipe(Effect.map((stat) => stat.isFile), Effect.catch((error) => filesystem_exports.SandboxFileSystem.isNotFoundError(error.cause) ? Effect.succeed(false) : Effect.logWarning(`could not stat instruction file ${path}`, error.cause).pipe(Effect.as(false)))), { concurrency: "unbounded" }).pipe(Effect.map((hits) => new Set(paths.filter((_, index) => hits[index]))));
+const present$1 = (fs, paths) => Effect.forEach(paths, (path) => fs.exists(path).pipe(Effect.flatMap((exists) => exists ? fs.stat(path).pipe(Effect.map((stat) => stat.isFile)) : Effect.succeed(false)), Effect.catch((error) => filesystem_exports.SandboxFileSystem.isNotFoundError(error.cause) ? Effect.succeed(false) : Effect.logWarning(`could not stat instruction file ${path}`, error.cause).pipe(Effect.as(false)))), { concurrency: "unbounded" }).pipe(Effect.map((hits) => new Set(paths.filter((_, index) => hits[index]))));
 /** A file that stats but does not read falls through to the next candidate. */
 const first = Effect.fnUntraced(function* (fs, directory, files) {
 	for (const name of names) {
@@ -6002,7 +6133,7 @@ var Accumulator = class {
 //#endregion
 //#region src/tool/output.ts
 /** A new, unused output file path under `spillPath`. */
-const path$1 = (spillPath, prefix) => crypto.randomBytes(8).pipe(Effect.map((bytes) => posix.join(spillPath, `${prefix}-${Hex.encode(bytes)}.log`)), Effect.orDie);
+const path = (spillPath, prefix) => crypto.randomBytes(8).pipe(Effect.map((bytes) => posix.join(spillPath, `${prefix}-${Hex.encode(bytes)}.log`)), Effect.orDie);
 /** First line printed when the output file cannot be created; the command then runs unsaved. */
 const unsaved = (file) => `codework: output not saved, cannot create ${file}`;
 const HEADER = "codework-output";
@@ -6390,7 +6521,7 @@ const runStreaming = (shell, stream, params, file) => Effect.gen(function* () {
 });
 const bashHandler = (params) => Effect.gen(function* () {
 	const shell = yield* ToolShell;
-	const file = yield* path$1((yield* io_exports.SandboxIO.Current).spillPath, "codework-bash");
+	const file = yield* path((yield* io_exports.SandboxIO.Current).spillPath, "codework-bash");
 	return yield* (shell.stream !== void 0 ? runStreaming(shell, shell.stream, params, file) : runBuffered(shell, params, file)).pipe(Effect.onInterrupt(() => cleanUp(shell, file, {
 		output: "",
 		truncated: false
@@ -7220,7 +7351,7 @@ const grepHandler = (params) => Effect.gen(function* () {
 	const isDirectory = stat.value.isDirectory;
 	const context = params.context && params.context > 0 ? Math.trunc(params.context) : 0;
 	const limit = Math.max(1, Math.trunc(params.limit ?? DEFAULT_LIMIT$1));
-	const errors = yield* path$1(sandbox.spillPath, "codework-grep");
+	const errors = yield* path(sandbox.spillPath, "codework-grep");
 	const run = yield* withCommand("rg", sandbox, shell, fs, (command) => Effect.gen(function* () {
 		const argv = [
 			command,
@@ -7495,7 +7626,7 @@ const INLINE = /* @__PURE__ */ new Set([
 	"image/gif",
 	"image/webp"
 ]);
-const toPng = (bytes) => load$4.pipe(Effect.map((photon) => {
+const toPng = (bytes) => load$5.pipe(Effect.map((photon) => {
 	if (photon === void 0) return void 0;
 	try {
 		const image = decode(photon, bytes);
@@ -7803,124 +7934,6 @@ const builtins = Object.freeze([
 	instructionPlugin
 ]);
 //#endregion
-//#region src/util/module.ts
-/*!
-* Adapted from OpenCode packages/util/src/runtime/import.node.ts.
-*
-* MIT License
-*
-* Copyright (c) 2025 opencode
-*
-* Permission is hereby granted, free of charge, to any person obtaining a copy
-* of this software and associated documentation files (the "Software"), to deal
-* in the Software without restriction, including without limitation the rights
-* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-* copies of the Software, and to permit persons to whom the Software is
-* furnished to do so, subject to the following conditions:
-*
-* The above copyright notice and this permission notice shall be included in all
-* copies or substantial portions of the Software.
-*
-* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-* SOFTWARE.
-*/
-/**
-* Packages a plugin must share with the harness instead of using the copy installed beside it.
-*
-* A plugin is installed into the store as its own npm tree, so `effect` and the plugin SDK land
-* there a second time. Two copies of the *same version* are still two module instances, and
-* Effect Schema's checks do not survive the crossing: a schema built by one copy and evaluated by
-* the other reports every check as failed, so a tool whose success type is `Schema.Finite` dies
-* on "Expected a finite number" for `22800`. Nothing about that is visible at registration --
-* `Schema.isSchema` passes, the JSON Schema is derived correctly, and the tool reaches the model
-* -- so it surfaces on the first call rather than at boot.
-*
-* Resolution is the right place to fix it. A symlink into the store cannot be: a generation is
-* immutable and shared by every project on the machine, while the harness doing the loading is
-* whichever one is running now, and two applications embedding the harness need not agree on
-* where their `effect` lives.
-*/
-const sharedPackages = /* @__PURE__ */ new Set(["effect", "@codeworksh/plugin"]);
-/** The package a bare specifier names: `effect/Schema` -> `effect`, `@a/b/c` -> `@a/b`. */
-function packageOf(specifier) {
-	if (specifier.startsWith(".") || specifier.startsWith("/") || specifier.includes(":")) return "";
-	const segments = specifier.split("/");
-	return specifier.startsWith("@") ? segments.slice(0, 2).join("/") : segments[0] ?? "";
-}
-/**
-* Resolve the shared packages as though this module had imported them, for as long as `run`
-* takes. Anything else resolves exactly as it would have.
-*/
-function withSharedModules(run) {
-	const hook = registerHooks({ resolve(specifier, context, nextResolve) {
-		return sharedPackages.has(packageOf(specifier)) ? nextResolve(specifier, {
-			...context,
-			parentURL: import.meta.url
-		}) : nextResolve(specifier, context);
-	} });
-	return run().finally(() => hook.deregister());
-}
-/** Use Node's main loader even when the caller runs inside a bundler or test VM. */
-async function importModule(specifier) {
-	const imported = await withSharedModules(() => new Script(`import(${JSON.stringify(specifier)})`, { importModuleDynamically: constants.USE_MAIN_CONTEXT_DEFAULT_LOADER }).runInThisContext());
-	if (typeof imported !== "object" || imported === null) return imported;
-	const module = imported;
-	const exports = module["module.exports"];
-	if (exports !== module.default || typeof exports !== "object" && typeof exports !== "function" || exports === null) return imported;
-	return Object.assign({}, module, exports);
-}
-/** Node resolution scoped synchronously to the caller. */
-function resolveModule(specifier, directory, conditions) {
-	const hook = registerHooks({ resolve(target, context, nextResolve) {
-		return nextResolve(target, {
-			...context,
-			parentURL: pathToFileURL(path.join(directory, "package.json")).href,
-			...conditions === void 0 ? {} : { conditions: [.../* @__PURE__ */ new Set([...context.conditions, ...conditions])] }
-		});
-	} });
-	try {
-		const resolve = (target) => {
-			const resolved = import.meta.resolve(path.isAbsolute(target) ? pathToFileURL(target).href : target);
-			if (resolved.startsWith("file:")) statSync(new URL(resolved));
-			return resolved;
-		};
-		try {
-			return resolve(specifier);
-		} catch (error) {
-			if (path.extname(specifier) || !missing(error)) throw error;
-			for (const extension of [
-				".ts",
-				".tsx",
-				".js",
-				".jsx",
-				".mts",
-				".mjs",
-				".cts",
-				".cjs"
-			]) try {
-				return resolve(specifier + extension);
-			} catch (cause) {
-				if (!missing(cause)) throw cause;
-			}
-			throw error;
-		}
-	} finally {
-		hook.deregister();
-	}
-}
-function missing(error) {
-	return error instanceof Error && "code" in error && [
-		"ENOENT",
-		"ENOTDIR",
-		"ERR_MODULE_NOT_FOUND"
-	].includes(String(error.code));
-}
-//#endregion
 //#region src/plugin/error.ts
 /**
 * The reference as the person wrote it -- the string they will recognise in their settings file,
@@ -9800,31 +9813,116 @@ const openWith = (options = {}) => Effect.fn("LLM.open")(function* (input, signa
 	});
 });
 const open = openWith();
+const isProviderError = Schema.is(ProviderError);
+/** `error.type` for a request: the provider's failure reason, so a terminal and a thrown failure agree. */
+const requestErrorType = (input, exit) => {
+	if (Exit.isFailure(exit)) {
+		const error = Cause.squash(exit.cause);
+		return isProviderError(error) ? error.reason._tag : errorType(exit.cause);
+	}
+	if (exit.value.outcome === "ended") return void 0;
+	if (exit.value.reason === "aborted") return "aborted";
+	return providerError(input, messageFailure(exit.value.message)).reason._tag;
+};
+const observe = Effect.fnUntraced(function* (input, timing, exit, drained) {
+	const now = yield* Effect.clockWith((clock) => clock.currentTimeMillis);
+	const labels = {
+		provider: input.provider,
+		model: input.model
+	};
+	const errorType = requestErrorType(input, exit);
+	yield* record$1(llmDuration, (now - timing.start) / 1e3, errorType === void 0 ? labels : {
+		...labels,
+		error: errorType
+	});
+	if (timing.firstToken !== void 0) {
+		const ttft = (timing.firstToken - timing.start) / 1e3;
+		yield* record$1(llmTtft, ttft, labels);
+		yield* Effect.annotateCurrentSpan("gen_ai.response.time_to_first_chunk", ttft);
+	}
+	if (errorType !== void 0) yield* Effect.annotateCurrentSpan("error.type", errorType);
+	const terminal = Exit.isSuccess(exit) ? exit.value : drained;
+	if (terminal === void 0) return;
+	const { message } = terminal;
+	const { usage } = message;
+	const inputTokens = usage.input + usage.cacheRead + usage.cacheWrite;
+	const tokens = {
+		input: inputTokens,
+		output: usage.output,
+		cache_read: usage.cacheRead,
+		cache_write: usage.cacheWrite,
+		reasoning: usage.reasoning ?? 0
+	};
+	for (const [type, count] of Object.entries(tokens)) if (count > 0) yield* record$1(llmTokens, count, {
+		...labels,
+		type
+	});
+	if (usage.cost.total > 0) yield* record$1(llmCost, usage.cost.total, labels);
+	yield* Effect.annotateCurrentSpan({
+		"gen_ai.response.model": message.responseModel ?? message.model,
+		...message.responseId === void 0 ? {} : { "gen_ai.response.id": message.responseId },
+		"gen_ai.response.finish_reasons": [terminal.reason],
+		"gen_ai.usage.input_tokens": inputTokens,
+		"gen_ai.usage.output_tokens": usage.output,
+		"gen_ai.usage.cache_read.input_tokens": usage.cacheRead,
+		"gen_ai.usage.cache_write.input_tokens": usage.cacheWrite,
+		...usage.reasoning === void 0 ? {} : { "gen_ai.usage.reasoning.output_tokens": usage.reasoning }
+	});
+});
+const isToken = (event) => event.type === "text.delta" || event.type === "thinking.delta" || event.type === "toolcall.delta";
+/**
+* A failed terminal is the request's result, not an error. It leaves the
+* traced request as a failure so the span records an error status, and is
+* recovered just outside it.
+*/
+var FailedTerminal = class extends Data.TaggedError("LLM.FailedTerminal") {};
 /**
 * Build a provider request from an opener. Tests use this with deterministic
 * aikit event streams; production uses `open` above.
 */
 const make$5 = (openStream) => {
-	const request = Effect.fn("LLM.run")(function* (input) {
+	const request = Effect.fn("LLM.run", {
+		kind: "client",
+		level: "Info"
+	})(function* (input) {
+		yield* Effect.annotateCurrentSpan({
+			"gen_ai.operation.name": "chat",
+			"gen_ai.provider.name": input.provider,
+			"gen_ai.request.model": input.model,
+			"gen_ai.conversation.id": input.sessionId,
+			"gen_ai.request.stream": true
+		});
+		const start = yield* Effect.clockWith((clock) => clock.currentTimeMillis);
+		let firstToken;
+		let drained;
+		const markToken = (event) => firstToken !== void 0 || !isToken(event) ? Effect.void : Effect.clockWith((clock) => Effect.sync(() => {
+			firstToken = clock.currentTimeMillisUnsafe();
+		}));
 		const signalScope = yield* Scope.make();
 		yield* Effect.addFinalizer((exit) => Scope.close(signalScope, exit));
 		const signal = yield* Effect.abortSignal.pipe(Scope.provide(signalScope));
 		const abort = Scope.close(signalScope, Exit.void);
-		return yield* Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+		const terminal = yield* Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
 			const iterable = yield* restore(openStream(input, signal)).pipe(Effect.onInterrupt(() => abort));
-			const consumer = yield* Stream.fromAsyncIterable(iterable, (cause) => providerErrorFromUnknown(input, cause)).pipe(Stream.runForEach(input.publisher.publish), Effect.andThen(input.publisher.terminal), Effect.interruptible).pipe(Effect.forkScoped({ startImmediately: true }));
+			const consumer = yield* Stream.fromAsyncIterable(iterable, (cause) => providerErrorFromUnknown(input, cause)).pipe(Stream.runForEach((event) => Effect.andThen(markToken(event), input.publisher.publish(event))), Effect.andThen(input.publisher.terminal), Effect.interruptible).pipe(Effect.forkScoped({ startImmediately: true }));
 			const awaited = yield* restore(Fiber.await(consumer)).pipe(Effect.onInterrupt(() => abort), Effect.exit);
 			if (Exit.isFailure(awaited)) {
-				const drained = yield* Fiber.await(consumer);
-				if (Exit.isFailure(drained)) return yield* Effect.failCause(drained.cause);
+				const consumed = yield* Fiber.await(consumer);
+				if (Exit.isFailure(consumed)) return yield* Effect.failCause(consumed.cause);
+				drained = consumed.value;
 				return yield* Effect.failCause(awaited.cause);
 			}
 			const completed = awaited.value;
 			if (Exit.isFailure(completed)) return yield* Effect.failCause(completed.cause);
 			return completed.value;
-		}));
-	});
-	return (input) => request(input).pipe(Effect.scoped);
+		})).pipe(Effect.onExit((exit) => observe(input, {
+			start,
+			firstToken
+		}, exit, drained)));
+		if (terminal.outcome === "failed") return yield* new FailedTerminal({ terminal });
+		return terminal;
+	});
+	return (input) => request(input).pipe(Effect.catchTag("LLM.FailedTerminal", (failed) => Effect.succeed(failed.terminal)), Effect.scoped);
 };
 const run$1 = make$5(open);
 //#endregion
@@ -10735,6 +10833,17 @@ const errorPart = (call, cause, now) => ({
 		end: endTime(call, now)
 	}
 });
+const observeTool = (snapshot, call, seconds, exit) => {
+	const tool = snapshot.tools.defs.some((def) => def.name === call.name) ? call.name : "_OTHER";
+	const labels = Exit.isFailure(exit) ? {
+		tool,
+		error: errorType(exit.cause)
+	} : exit.value.status === "completed" ? { tool } : {
+		tool,
+		error: exit.value.status
+	};
+	return record$1(toolDuration, seconds, labels);
+};
 const layer$3 = (options = {}) => Layer.effect(Service$7, Effect.gen(function* () {
 	const context = yield* Service$13;
 	const events = yield* Service$16;
@@ -10773,7 +10882,7 @@ const layer$3 = (options = {}) => Layer.effect(Service$7, Effect.gen(function* (
 		if (draft === void 0) return;
 		yield* publishFailure(draft, { _tag: "interrupted" });
 	});
-	const settleTools = Effect.fn("Loop.settleTools")(function* (snapshot, message, reason, markCommitted) {
+	const settleTools = Effect.fn("Loop.settleTools", { level: "Info" })(function* (snapshot, message, reason, markCommitted) {
 		const pending = message.parts.filter((part) => part.type === "toolCall" && part.status === "pending");
 		let interruptedCause;
 		const messageId = ID.from(message.messageId);
@@ -10812,7 +10921,12 @@ const layer$3 = (options = {}) => Layer.effect(Service$7, Effect.gen(function* (
 				return;
 			}
 			const settled = /* @__PURE__ */ new Set();
-			const handle = Effect.fn("Loop.handleTool")(function* (call) {
+			const handle = Effect.fn("Loop.handleTool", { level: "Info" })(function* (call) {
+				yield* Effect.annotateCurrentSpan({
+					"gen_ai.operation.name": "execute_tool",
+					"gen_ai.tool.name": call.name,
+					"gen_ai.tool.call.id": call.callID
+				});
 				yield* events.publish(ToolStarted, {
 					timestamp: yield* DateTime.now,
 					sessionId: snapshot.sessionId,
@@ -10822,7 +10936,7 @@ const layer$3 = (options = {}) => Layer.effect(Service$7, Effect.gen(function* (
 					label: snapshot.tools.defs.find((def) => def.name === call.name)?.label,
 					arguments: call.arguments
 				});
-				const handled = yield* snapshot.tools.handle(call, {
+				const execute = snapshot.tools.handle(call, {
 					sessionId: snapshot.sessionId,
 					messageId,
 					onProgress: (progress) => events.publish(ToolProgress$2, {
@@ -10833,6 +10947,7 @@ const layer$3 = (options = {}) => Layer.effect(Service$7, Effect.gen(function* (
 						partial: progress.partial
 					}).pipe(Effect.asVoid)
 				}).pipe(Effect.catchCauseIf((cause) => !Cause.hasInterrupts(cause), (cause) => Effect.map(Effect.clockWith((clock) => clock.currentTimeMillis), (now) => errorPart(call, cause, now))));
+				const handled = yield* timed(execute, (seconds, exit) => observeTool(snapshot, call, seconds, exit));
 				yield* Effect.uninterruptible(Effect.gen(function* () {
 					yield* settle(call, handled);
 					yield* Effect.sync(() => settled.add(call.callID));
@@ -10855,7 +10970,7 @@ const layer$3 = (options = {}) => Layer.effect(Service$7, Effect.gen(function* (
 		}));
 		return interruptedCause;
 	});
-	const runTurnAttempt = Effect.fn("Loop.runTurnAttempt")(function* (promotion, snapshot) {
+	const runTurnAttempt = Effect.fn("Loop.runTurnAttempt", { level: "Info" })(function* (promotion, snapshot) {
 		const sessionId = snapshot.sessionId;
 		if (promotion !== void 0) {
 			const cutoff = yield* events.latestSequence(sessionId);
@@ -10959,27 +11074,35 @@ const layer$3 = (options = {}) => Layer.effect(Service$7, Effect.gen(function* (
 			});
 		}));
 	});
-	const runTurn = Effect.fn("Loop.runTurn")(function* (promotion, snapshot) {
+	const runTurn = Effect.fn("Loop.runTurn", { level: "Info" })(function* (promotion, snapshot) {
 		return yield* runTurnAttempt(promotion, snapshot);
 	});
-	const run = Effect.fn("Loop.run")(function* (input) {
+	const run = Effect.fn("Loop.run", { level: "Info" })(function* (input) {
 		yield* healDanglingDraft(input.sessionId);
 		const hasSteer = yield* inputs.hasPending(input.sessionId, "steer");
 		const hasFollowUp = hasSteer ? false : yield* inputs.hasPending(input.sessionId, "followUp");
 		if (!input.force && !hasSteer && !hasFollowUp) return;
+		yield* Effect.annotateCurrentSpan({
+			"gen_ai.operation.name": "invoke_agent",
+			"gen_ai.agent.name": "codework",
+			"gen_ai.conversation.id": input.sessionId
+		});
 		let promotion = hasSteer ? "steer" : hasFollowUp ? "followUp" : void 0;
-		let shouldRun = true;
-		while (shouldRun) {
-			const snapshot = yield* state.snapshot(input.sessionId);
-			let needsContinuation = true;
-			while (needsContinuation) {
-				const result = yield* runTurn(promotion, snapshot);
-				promotion = "steer";
-				needsContinuation = result.needsContinuation || (yield* inputs.hasPending(input.sessionId, "steer"));
+		const drain = Effect.gen(function* () {
+			let shouldRun = true;
+			while (shouldRun) {
+				const snapshot = yield* state.snapshot(input.sessionId);
+				let needsContinuation = true;
+				while (needsContinuation) {
+					const result = yield* runTurn(promotion, snapshot);
+					promotion = "steer";
+					needsContinuation = result.needsContinuation || (yield* inputs.hasPending(input.sessionId, "steer"));
+				}
+				shouldRun = yield* inputs.hasPending(input.sessionId, "followUp");
+				promotion = shouldRun ? "followUp" : void 0;
 			}
-			shouldRun = yield* inputs.hasPending(input.sessionId, "followUp");
-			promotion = shouldRun ? "followUp" : void 0;
-		}
+		});
+		yield* timed(drain, (seconds, exit) => record$1(agentDuration, seconds, withError({}, exit)));
 	});
 	return Service$7.of({ run });
 }));
@@ -11300,7 +11423,7 @@ const runtimeOverrides = (driver, value) => {
 	}));
 	return Effect.succeed(value);
 };
-const create$2 = Effect.fn("Sandbox.create")(function* (input) {
+const create$2 = Effect.fn("Sandbox.create", { level: "Info" })(function* (input) {
 	const controller = yield* Controller;
 	const registry = yield* Registry;
 	const driverName = name(input.driver);
@@ -11326,7 +11449,7 @@ const Selection = Schema.Union([Schema.Struct({ id: instance_exports.SandboxInst
 	driver: Schema.String,
 	providerResourceId: (0, schema_exports$9.optional)(Schema.String)
 })]);
-const resolve = Effect.fn("Sandbox.resolve")(function* (input) {
+const resolve = Effect.fn("Sandbox.resolve", { level: "Info" })(function* (input) {
 	if ("id" in input) {
 		const found = yield* get$1(input.id);
 		if (Option.isNone(found)) return yield* new errors_exports.SandboxNotFoundError({ id: input.id });
@@ -11379,7 +11502,7 @@ const list = Effect.fn("Sandbox.list")(function* (input) {
 const refresh = Effect.fn("Sandbox.refresh")(function* (id) {
 	return yield* (yield* Controller).refresh(id);
 });
-const wake = Effect.fn("Sandbox.wake")(function* (id) {
+const wake = Effect.fn("Sandbox.wake", { level: "Info" })(function* (id) {
 	return yield* (yield* Controller).wake(id);
 });
 const stop = Effect.fn("Sandbox.stop")(function* (id) {
@@ -11602,12 +11725,14 @@ var plugin_exports = /* @__PURE__ */ __exportAll({
 	definition: () => definition$1,
 	identity: () => digest,
 	inspect: () => inspect,
+	lendResolve: () => lendResolve,
 	localName: () => localName,
 	parse: () => parse$1,
 	probe: () => probe,
 	resolve: () => resolve$2,
 	resolveCached: () => required,
 	settingsLock: () => lock,
+	share: () => share,
 	update: () => update
 });
 //#endregion