@codeworksh/harness 0.2.0 → 0.3.0-canary.29.1.g334eb9ee

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,21 +16,20 @@ 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";
 import { JsonOpenAICodexAuthStorage, getOpenAICodexApiKey } from "@codeworksh/aikit/oauth/openai/codex";
 import { parse, printParseErrorCode } from "jsonc-parser";
 import * as Section from "@codeworksh/plugin/plugin/section";
+import ignore from "ignore";
+import { parse as parse$1 } from "yaml";
 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 +379,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 +406,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 +2642,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 +3136,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 +3162,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 +3347,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 +3363,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 +3455,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 +3481,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 +3504,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 +3537,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 +3564,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 +3578,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 +3737,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 +4006,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 +4016,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
@@ -4333,7 +4466,8 @@ const up = Effect.fn("SandboxFileSystem.up")(function* (fs, options) {
 const isDirectory$1 = Effect.fn("SandboxFileSystem.isDirectory")(function* (fs, path) {
 	return yield* fs.stat(path).pipe(Effect.map((stat) => stat.isDirectory), Effect.orElseSucceed(() => false));
 });
-Effect.fn("SandboxFileSystem.isFile")(function* (fs, path) {
+/** True when `path` exists and is a regular file; false when it is absent or unreadable. */
+const isFile = Effect.fn("SandboxFileSystem.isFile")(function* (fs, path) {
 	return yield* fs.stat(path).pipe(Effect.map((stat) => stat.isFile), Effect.orElseSucceed(() => false));
 });
 /** Read a file, or `undefined` when it is missing or unreadable. */
@@ -5181,7 +5315,7 @@ var settings_exports = /* @__PURE__ */ __exportAll({
 	layer: () => layer$8,
 	load: () => load$3,
 	modules: () => modules,
-	parse: () => parse$4,
+	parse: () => parse$5,
 	paths: () => paths,
 	projectRoot: () => projectRoot,
 	userConfigDir: () => userConfigDir
@@ -5270,7 +5404,7 @@ const decodeFormatter = SchemaIssue.makeFormatterStandardSchemaV1({ leafHook: (i
 	const message = "annotations" in issue ? issue.annotations?.message : void 0;
 	return typeof message === "string" ? message.replaceAll(/\s*\n\s*/g, " ") : "invalid value";
 } });
-const parse$4 = Effect.fn("Settings.parse")(function* (path, source) {
+const parse$5 = Effect.fn("Settings.parse")(function* (path, source) {
 	const errors = [];
 	const json = parse(source, errors, {
 		allowTrailingComma: true,
@@ -5318,7 +5452,7 @@ const attempt = (path) => fileSystem.readFileString(path).pipe(Effect.mapError((
 	path,
 	reason: "read",
 	detail: error.reason._tag
-})), Effect.flatMap((source) => parse$4(path, source)));
+})), Effect.flatMap((source) => parse$5(path, source)));
 /**
 * One read of every layer. Exported for the harness constructor, which needs the plugin
 * selection before any layer is built; everything else goes through `Service`.
@@ -5624,6 +5758,22 @@ const defaultPromptPlugin = (0, plugin_exports$1.define)({
 	})
 });
 //#endregion
+//#region src/plugin/builtin/prompt/walk.ts
+const stripBom$1 = (raw) => raw.charCodeAt(0) === 65279 ? raw.slice(1) : raw;
+/** `directory` and every ancestor up to the sandbox root, closest first. */
+const ancestors = (directory) => {
+	const chain = [];
+	for (let current = directory;; current = posix.dirname(current)) {
+		chain.push(current);
+		if (posix.dirname(current) === current) return chain;
+	}
+};
+/**
+* Which of `paths` exist as the requested kind (`entry` takes either). Absence stays silent; any other failure
+* (permissions, a remote blip) is logged so a dropped entry is not a mystery, then counts as absent.
+*/
+const present$1 = (fs, paths, kind, label) => Effect.forEach(paths, (path) => fs.exists(path).pipe(Effect.filterOrElse((exists) => !exists || kind === "entry", () => fs.stat(path).pipe(Effect.map((stat) => kind === "file" ? stat.isFile : stat.isDirectory))), Effect.catch((error) => filesystem_exports.SandboxFileSystem.isNotFoundError(error.cause) ? Effect.succeed(false) : Effect.logWarning(`could not stat ${label} ${path}`, error.cause).pipe(Effect.as(false)))), { concurrency: "unbounded" }).pipe(Effect.map((hits) => new Set(paths.filter((_, index) => hits[index]))));
+//#endregion
 //#region src/plugin/builtin/prompt/instruction.ts
 /** First readable match per directory wins. */
 const names = [
@@ -5635,22 +5785,9 @@ const names = [
 	"CLAUDE.MD"
 ];
 const content = (raw) => {
-	const text = raw.charCodeAt(0) === 65279 ? raw.slice(1) : raw;
+	const text = stripBom$1(raw);
 	return text.trim().length === 0 ? void 0 : text;
 };
-/** `directory` and every ancestor up to the sandbox root, closest first. */
-const ancestors = (directory) => {
-	const chain = [];
-	for (let current = directory;; current = posix.dirname(current)) {
-		chain.push(current);
-		if (posix.dirname(current) === current) return chain;
-	}
-};
-/**
-* 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]))));
 /** 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) {
@@ -5678,9 +5815,9 @@ const shadowing = (location) => {
 	return location.space.location.startsWith(`${main}/`) ? main : void 0;
 };
 /** One file per directory from the sandbox root down to the cwd, closest last so it has the final word. */
-const discover = Effect.fnUntraced(function* (fs, location) {
+const discover$1 = Effect.fnUntraced(function* (fs, location) {
 	const chain = ancestors(location.directory);
-	const files = yield* present$1(fs, chain.flatMap((directory) => names.map((name) => posix.join(directory, name))));
+	const files = yield* present$1(fs, chain.flatMap((directory) => names.map((name) => posix.join(directory, name))), "file", "instruction file");
 	const found = yield* Effect.forEach(chain, (directory) => first(fs, directory, files), { concurrency: "unbounded" });
 	const main = shadowing(location);
 	const worktree = main === void 0 ? void 0 : found[chain.indexOf(location.space.location)];
@@ -5696,7 +5833,7 @@ const instructionPlugin = (0, plugin_exports$1.define)({
 	kind: "prompt",
 	setup: Effect.fn("InstructionPlugin.setup")(function* (ctx) {
 		const fs = yield* io_exports.SandboxIO.FileSystem;
-		const files = (yield* discover(fs, ctx.location)).filter((file) => file.content !== void 0);
+		const files = (yield* discover$1(fs, ctx.location)).filter((file) => file.content !== void 0);
 		if (files.length === 0) return;
 		const prompt = ctx.plugin.prompt;
 		prompt.sections.append(Section.ProjectContext, "Project-Specific Instructions & Guidelines:");
@@ -5704,6 +5841,236 @@ const instructionPlugin = (0, plugin_exports$1.define)({
 	})
 });
 //#endregion
+//#region src/plugin/builtin/prompt/skill.ts
+/** Max name length per Agent Skills spec. */
+const MAX_NAME_LENGTH = 64;
+/** Max description length per Agent Skills spec. */
+const MAX_DESCRIPTION_LENGTH = 1024;
+const IGNORE_FILE_NAMES = [
+	".gitignore",
+	".ignore",
+	".fdignore"
+];
+const normalizeNewlines = (value) => value.replaceAll("\r\n", "\n").replaceAll("\r", "\n");
+const extractFrontmatter = (content) => {
+	const normalized = normalizeNewlines(stripBom$1(content));
+	if (!normalized.startsWith("---")) return void 0;
+	const endIndex = normalized.indexOf("\n---", 3);
+	if (endIndex === -1) return void 0;
+	return normalized.slice(4, endIndex);
+};
+const parseFrontmatter = (raw) => {
+	const yamlString = extractFrontmatter(raw);
+	if (yamlString === void 0) return { frontmatter: {} };
+	try {
+		const parsed = parse$1(yamlString);
+		return { frontmatter: typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : {} };
+	} catch (error) {
+		return {
+			frontmatter: {},
+			error
+		};
+	}
+};
+const validateName = (name) => {
+	const errors = [];
+	if (name.length > MAX_NAME_LENGTH) errors.push(`name exceeds ${MAX_NAME_LENGTH} characters (${name.length})`);
+	if (!/^[a-z0-9-]+$/.test(name)) errors.push("name contains invalid characters (must be lowercase a-z, 0-9, hyphens only)");
+	if (name.startsWith("-") || name.endsWith("-")) errors.push("name must not start or end with a hyphen");
+	if (name.includes("--")) errors.push("name must not contain consecutive hyphens");
+	return errors;
+};
+const validateDescription = (description) => {
+	const errors = [];
+	if (typeof description !== "string" || description.trim() === "") errors.push("description is required");
+	else if (description.length > MAX_DESCRIPTION_LENGTH) errors.push(`description exceeds ${MAX_DESCRIPTION_LENGTH} characters (${description.length})`);
+	return errors;
+};
+const prefixIgnorePattern = (line, prefix) => {
+	const trimmed = line.trim();
+	if (!trimmed) return void 0;
+	if (trimmed.startsWith("#") && !trimmed.startsWith("\\#")) return void 0;
+	let pattern = line;
+	let negated = false;
+	if (pattern.startsWith("!")) {
+		negated = true;
+		pattern = pattern.slice(1);
+	} else if (pattern.startsWith("\\!")) pattern = pattern.slice(1);
+	if (pattern.startsWith("/")) pattern = pattern.slice(1);
+	const prefixed = prefix ? `${prefix}${pattern}` : pattern;
+	return negated ? `!${prefixed}` : prefixed;
+};
+const addIgnoreRules = Effect.fnUntraced(function* (fs, ig, dir, root, entryNames) {
+	const relativeDir = posix.relative(root, dir);
+	const prefix = relativeDir && relativeDir !== "." ? `${relativeDir}/` : "";
+	const presentIgnoreFiles = IGNORE_FILE_NAMES.filter((name) => entryNames.has(name));
+	if (presentIgnoreFiles.length === 0) return;
+	const contents = yield* Effect.forEach(presentIgnoreFiles, (filename) => fs.readFile(posix.join(dir, filename)).pipe(Effect.option), { concurrency: "unbounded" });
+	for (const content of contents) {
+		if (Option.isNone(content)) continue;
+		const patterns = content.value.split(/\r?\n/).map((line) => prefixIgnorePattern(line, prefix)).filter((line) => line !== void 0);
+		if (patterns.length > 0) ig.add(patterns);
+	}
+});
+const loadSkillFromFile = Effect.fnUntraced(function* (fs, filePath) {
+	const isDeclaredSkill = posix.basename(filePath) === "SKILL.md";
+	const raw = yield* fs.readFile(filePath).pipe(Effect.tapError((error) => Effect.logWarning(`could not read skill file ${filePath}`, error.cause)), Effect.option);
+	if (Option.isNone(raw)) return void 0;
+	const { frontmatter, error } = parseFrontmatter(raw.value);
+	if (error !== void 0) {
+		if (isDeclaredSkill) yield* Effect.logWarning(`could not parse skill file ${filePath}`, error);
+		return;
+	}
+	const description = frontmatter.description;
+	const hasDescription = typeof description === "string" && description.trim() !== "";
+	if (!isDeclaredSkill && !hasDescription) return void 0;
+	const skillDir = posix.dirname(filePath);
+	const parentDirName = posix.basename(skillDir);
+	for (const error of validateDescription(description)) yield* Effect.logWarning(`skill ${filePath}: ${error}`);
+	const name = (typeof frontmatter.name === "string" ? frontmatter.name : void 0) || parentDirName;
+	for (const error of validateName(name)) yield* Effect.logWarning(`skill ${filePath}: ${error}`);
+	if (!hasDescription) return void 0;
+	return {
+		name,
+		description,
+		filePath,
+		baseDir: skillDir,
+		disableModelInvocation: frontmatter["disable-model-invocation"] === true
+	};
+});
+const scanDir = (fs, dir, mode, root, ig, visited) => Effect.gen(function* () {
+	const realDir = yield* realpath(fs, dir);
+	if (visited.has(realDir)) return [];
+	const nextVisited = /* @__PURE__ */ new Set([...visited, realDir]);
+	const listed = yield* fs.readdir(dir).pipe(Effect.tapError((error) => filesystem_exports.SandboxFileSystem.isNotFoundError(error.cause) ? Effect.void : Effect.logWarning(`could not read skill directory ${dir}`, error.cause)), Effect.option);
+	if (Option.isNone(listed)) return [];
+	const entries = [...listed.value].sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+	const entrySet = new Set(entries);
+	yield* addIgnoreRules(fs, ig, dir, root, entrySet);
+	if (entrySet.has("SKILL.md")) {
+		const fullPath = posix.join(dir, "SKILL.md");
+		const relPath = posix.relative(root, fullPath);
+		if ((yield* isFile(fs, fullPath)) && !ig.ignores(relPath)) {
+			const skill = yield* loadSkillFromFile(fs, fullPath);
+			return skill === void 0 ? [] : [skill];
+		}
+	}
+	const visible = entries.filter((name) => !name.startsWith(".") && name !== "node_modules");
+	const statted = yield* Effect.forEach(visible, (name) => {
+		const fullPath = posix.join(dir, name);
+		return fs.stat(fullPath).pipe(Effect.map((stat) => ({
+			name,
+			fullPath,
+			stat
+		})), Effect.option);
+	}, { concurrency: "unbounded" });
+	const skills = [];
+	for (const item of statted) {
+		if (Option.isNone(item)) continue;
+		const { name, fullPath, stat } = item.value;
+		const relPath = posix.relative(root, fullPath);
+		if (ig.ignores(stat.isDirectory ? `${relPath}/` : relPath)) continue;
+		if (stat.isDirectory) {
+			const nested = yield* scanDir(fs, fullPath, mode, root, ig, nextVisited);
+			skills.push(...nested);
+			continue;
+		}
+		if (stat.isFile && name.endsWith(".md") && (mode === "codework" && dir === root || mode === "agents" && dir !== root)) {
+			const skill = yield* loadSkillFromFile(fs, fullPath);
+			if (skill !== void 0) skills.push(skill);
+		}
+	}
+	return skills;
+});
+/**
+* Load skills from a single directory in the sandbox.
+*
+* Discovery rules:
+* - If a directory contains `SKILL.md`, treat it as a skill root and do not recurse further.
+* - In `"codework"` mode, direct `.md` children in the root are also loaded; in `"agents"` mode,
+*   `.md` files in subdirectories are loaded while root `.md` files are ignored.
+* - Recurse into subdirectories (skipping dotfiles, `node_modules`, and ignored paths).
+*/
+const loadSkillsFromDir = (fs, dir, mode) => scanDir(fs, dir, mode, dir, ignore(), /* @__PURE__ */ new Set());
+/**
+* Discover skills inside the sandbox: `.codework/skills` at the cwd, then
+* `.agents/skills` from the cwd up to the git root (the closest ancestor holding `.git`), or up to
+* the sandbox root outside a repository. Earlier skills win name collisions.
+*/
+const discover = Effect.fnUntraced(function* (fs, location) {
+	const chain = ancestors(location.directory);
+	const own = posix.join(location.directory, appConfigDir, "skills");
+	const agents = chain.map((directory) => posix.join(directory, ".agents", "skills"));
+	const [dirs, gits] = yield* Effect.all([present$1(fs, [own, ...agents], "directory", "skill directory"), present$1(fs, chain.map((directory) => posix.join(directory, ".git")), "entry", "git marker")], { concurrency: "unbounded" });
+	const root = chain.findIndex((directory) => gits.has(posix.join(directory, ".git")));
+	const walked = root === -1 ? agents : agents.slice(0, root + 1);
+	const sources = [{
+		dir: own,
+		mode: "codework"
+	}, ...walked.map((dir) => ({
+		dir,
+		mode: "agents"
+	}))].filter(({ dir }) => dirs.has(dir));
+	const found = yield* Effect.forEach(sources, ({ dir, mode }) => loadSkillsFromDir(fs, dir, mode), { concurrency: "unbounded" });
+	const skillMap = /* @__PURE__ */ new Map();
+	const realPathSet = /* @__PURE__ */ new Set();
+	for (const skill of found.flat()) {
+		const realPath = yield* realpath(fs, skill.filePath);
+		if (realPathSet.has(realPath)) continue;
+		const existing = skillMap.get(skill.name);
+		if (existing !== void 0) yield* Effect.logWarning(`skill ${skill.filePath}: name "${skill.name}" collision with ${existing.filePath}`);
+		else {
+			skillMap.set(skill.name, skill);
+			realPathSet.add(realPath);
+		}
+	}
+	return Array.from(skillMap.values());
+});
+const escapeXml = (str) => str.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&apos;");
+/**
+* Format skills for inclusion in `Section.Skills` per the Agent Skills specification.
+* Skills with `disableModelInvocation: true` are excluded from the prompt.
+*/
+const formatSkillsForPrompt = (skills, fileReadTool = "read") => {
+	const visibleSkills = skills.filter((s) => !s.disableModelInvocation);
+	if (visibleSkills.length === 0) return "";
+	const lines = [
+		"The following skills provide specialized instructions for specific tasks.",
+		fileReadTool === "read" ? "Use the read tool to load a skill's file when the task matches its description." : fileReadTool === "bash" ? "Use bash to load a skill's file when the task matches its description." : "Load a skill's file when the task matches its description.",
+		"When a skill file references a relative path, resolve it against the skill directory (parent of SKILL.md / dirname of the path) and use that absolute path in tool commands.",
+		"",
+		"<available_skills>"
+	];
+	for (const skill of visibleSkills) {
+		lines.push("  <skill>");
+		lines.push(`    <name>${escapeXml(skill.name)}</name>`);
+		lines.push(`    <description>${escapeXml(skill.description)}</description>`);
+		lines.push(`    <location>${escapeXml(skill.filePath)}</location>`);
+		lines.push("  </skill>");
+	}
+	lines.push("</available_skills>");
+	return lines.join("\n");
+};
+const readers = ["read", "bash"];
+const skillPlugin = (0, plugin_exports$1.define)({
+	id: "codework.prompt.skill",
+	kind: "prompt",
+	setup: Effect.fn("SkillPlugin.setup")(function* (ctx) {
+		const tools = ctx.plugin.tools;
+		const visible = (name) => {
+			const tool = tools.get(name);
+			return tool !== void 0 && tool.promptSnippet !== void 0 && tool.promptSnippet.length > 0;
+		};
+		const fileReadTool = readers.find(visible) ?? (readers.some((name) => tools.has(name)) ? "indirect" : void 0);
+		if (fileReadTool === void 0) return;
+		const fs = yield* io_exports.SandboxIO.FileSystem;
+		const skills = yield* discover(fs, ctx.location);
+		const formatted = formatSkillsForPrompt(skills, fileReadTool);
+		if (formatted.length === 0) return;
+		ctx.plugin.prompt.sections.append(Section.Skills, formatted);
+	})
+});
+//#endregion
 //#region src/tool/truncate.ts
 /**
 * Shared truncation utilities for tool outputs.
@@ -6002,7 +6369,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";
@@ -6034,7 +6401,7 @@ const script = (command, file, limits, pipeline, report) => [
 	"run 2>&1"
 ].join("\n");
 const header = new RegExp(`^${HEADER} (\\d+) (\\d+) ([01])(?: (\\d+))?$`, "m");
-const parse$3 = (match) => ({
+const parse$4 = (match) => ({
 	bytes: Number(match[1]),
 	newlines: Number(match[2]),
 	kept: match[3] === "1"
@@ -6053,7 +6420,7 @@ const report = (stderr) => {
 		rest: stderr
 	};
 	return {
-		report: parse$3(match),
+		report: parse$4(match),
 		rest: stderr.slice(0, match.index) + stderr.slice(match.index + match[0].length).replace(/^\n/, "")
 	};
 };
@@ -6076,7 +6443,7 @@ const window = (stdout) => {
 	const match = header.exec(newline === -1 ? stdout : stdout.slice(0, newline));
 	if (match === null || match[4] === void 0) return void 0;
 	return {
-		...parse$3(match),
+		...parse$4(match),
 		text: stdout.slice(newline + 1),
 		textBytes: Number(match[4])
 	};
@@ -6390,7 +6757,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
@@ -7151,7 +7518,7 @@ const pipeline = (argv, limit, errors) => [
 ].join("; ");
 const STATUS = /^\{"type":"rc","code":(\d+)\}$/;
 /** The pipeline's output: match events, ripgrep's status, and anything else, which is its stderr. */
-const parse$2 = (stdout, stderr) => {
+const parse$3 = (stdout, stderr) => {
 	const matches = [];
 	const errors = [];
 	let status;
@@ -7220,7 +7587,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,
@@ -7235,7 +7602,7 @@ const grepHandler = (params) => Effect.gen(function* () {
 		if (params.glob) argv.push("--glob", params.glob);
 		argv.push("-e", params.pattern, searchPath);
 		const result = yield* shell.exec(pipeline(argv, limit, errors));
-		const parsed = parse$2(result.stdout, result.stderr);
+		const parsed = parse$3(result.stdout, result.stderr);
 		return {
 			...parsed,
 			exitCode: parsed.status ?? result.exitCode
@@ -7495,7 +7862,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);
@@ -7800,127 +8167,10 @@ const builtins = Object.freeze([
 	findPlugin,
 	lsPlugin,
 	defaultPromptPlugin,
-	instructionPlugin
+	instructionPlugin,
+	skillPlugin
 ]);
 //#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,
@@ -8358,7 +8608,7 @@ const isPath = (reference) => reference.startsWith("file:") || reference.startsW
 * - a **CLI argument** anchors to the process's startup directory, because that is where the
 *   person typed it.
 */
-const parse$1 = (reference, from) => Effect.gen(function* () {
+const parse$2 = (reference, from) => Effect.gen(function* () {
 	const fail = (reason, message) => new SourceError({
 		reason,
 		reference,
@@ -9034,7 +9284,7 @@ const inspect = Effect.fn("PluginLoader.inspect")(function* (reference, options)
 		reference,
 		file: options.file
 	};
-	const target = yield* parse$1(reference, options.hostDir);
+	const target = yield* parse$2(reference, options.hostDir);
 	const loaded = yield* load$2(target, origin, options);
 	return {
 		id: loaded.plugin.id,
@@ -9060,7 +9310,7 @@ const load$2 = Effect.fn("PluginLoader.load")(function* (target, origin, options
 * are one package, and `./plugins/x.ts` is the file it resolves to from the directory that
 * declared it. Pure -- nothing is installed, imported or read.
 */
-const canonical = (reference, hostDir) => Effect.map(parse$1(reference, hostDir), canonical$1);
+const canonical = (reference, hostDir) => Effect.map(parse$2(reference, hostDir), canonical$1);
 //#endregion
 //#region src/plugin/catalog.ts
 /**
@@ -9122,7 +9372,7 @@ const load$1 = Effect.fn("PluginCatalog.load")(function* (references, options) {
 			remember(plugin, []);
 			continue;
 		}
-		const target = yield* parse$1(reference, options.hostDir);
+		const target = yield* parse$2(reference, options.hostDir);
 		const key = target.kind === "local" ? target.path : target.spec;
 		const already = seen.get(key);
 		if (already !== void 0) {
@@ -9800,31 +10050,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 +11070,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 +11119,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 +11158,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 +11173,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 +11184,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 +11207,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 +11311,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 });
 }));
@@ -11214,7 +11574,7 @@ const layer = (options = {}) => Layer.unwrap(Effect.gen(function* () {
 	* `hostDir` led to; only the process view falls back to `hostCwd`.
 	*/
 	const hostDirOf = (root) => root ?? hostCwd;
-	const filed = (reference, from) => parse$1(reference, from).pipe(Effect.flatMap((target) => target.kind === "local" ? fileSystem.exists(target.path).pipe(Effect.map((there) => there ? Option.some({}) : Option.none())) : resolve$2(target, paths.cache, from).pipe(Effect.map((entry) => Option.fromUndefinedOr(entry)))), Effect.orElseSucceed(() => Option.none()));
+	const filed = (reference, from) => parse$2(reference, from).pipe(Effect.flatMap((target) => target.kind === "local" ? fileSystem.exists(target.path).pipe(Effect.map((there) => there ? Option.some({}) : Option.none())) : resolve$2(target, paths.cache, from).pipe(Effect.map((entry) => Option.fromUndefinedOr(entry)))), Effect.orElseSucceed(() => Option.none()));
 	const resolveOnly = {
 		...catalogOptions,
 		install: required
@@ -11300,7 +11660,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 +11686,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 +11739,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 +11962,14 @@ var plugin_exports = /* @__PURE__ */ __exportAll({
 	definition: () => definition$1,
 	identity: () => digest,
 	inspect: () => inspect,
+	lendResolve: () => lendResolve,
 	localName: () => localName,
-	parse: () => parse$1,
+	parse: () => parse$2,
 	probe: () => probe,
 	resolve: () => resolve$2,
 	resolveCached: () => required,
 	settingsLock: () => lock,
+	share: () => share,
 	update: () => update
 });
 //#endregion