skilld-harness 3.0.0-beta.1

package/dist/index.mjs

@@ -0,0 +1,1209 @@
+import { DEFAULT_OUTPUT_POLICY, isSkillName, loadSkilldMaintainedSkill, normalizeOutputPath, resolveWithin } from "./_chunks/skills.mjs";
+import { lstat, mkdir, open, opendir, realpath, rename, rm, rmdir, unlink, writeFile } from "node:fs/promises";
+import { dirname, join, posix, relative, resolve, sep } from "node:path";
+import { HarnessAgent } from "@ai-sdk/harness/agent";
+import { createHash, randomUUID } from "node:crypto";
+import { parseDocument } from "yaml";
+import { constants } from "node:fs";
+import { Readable } from "node:stream";
+import { createGunzip } from "node:zlib";
+const ok = (value) => ({
+	_tag: "Ok",
+	value
+});
+const err = (error) => ({
+	_tag: "Err",
+	error
+});
+function invalid$2(message) {
+	return err({
+		_tag: "InvalidInput",
+		message
+	});
+}
+function isNonEmptyString(value) {
+	return typeof value === "string" && value.trim().length > 0;
+}
+function parseSkillRun(input) {
+	if (!input || typeof input !== "object" || !("_tag" in input)) return invalid$2("Skill run input must be an object with a tag.");
+	if (input._tag === "PackageSkill") {
+		if (!input.source || !input.destination) return invalid$2("Package Skill input is incomplete.");
+		if (!isNonEmptyString(input.destination.rootDir) || !isSkillName(input.destination.name)) return invalid$2("Package Skill destination is invalid.");
+		if (input.source._tag === "NpmPackage") {
+			if (!isNonEmptyString(input.source.spec)) return invalid$2("npm package spec is required.");
+			return ok({
+				_tag: "PackageSkill",
+				source: {
+					_tag: "NpmPackage",
+					spec: input.source.spec
+				},
+				destination: {
+					rootDir: resolve(input.destination.rootDir),
+					name: input.destination.name
+				}
+			});
+		}
+		if (input.source._tag === "LocalPackage") {
+			if (!isNonEmptyString(input.source.rootDir) || !isNonEmptyString(input.source.packageDir)) return invalid$2("Local package paths are required.");
+			if (resolveWithin(input.source.rootDir, input.source.packageDir) === null) return invalid$2("Local package directory must stay inside its root directory.");
+			return ok({
+				_tag: "PackageSkill",
+				source: {
+					_tag: "LocalPackage",
+					rootDir: resolve(input.source.rootDir),
+					packageDir: input.source.packageDir
+				},
+				destination: {
+					rootDir: resolve(input.destination.rootDir),
+					name: input.destination.name
+				}
+			});
+		}
+		return invalid$2("Package source tag is invalid.");
+	}
+	if (input._tag === "ProjectSkill") {
+		if (!isNonEmptyString(input.projectDir) || !input.destination) return invalid$2("Project Skill input is incomplete.");
+		if (!isNonEmptyString(input.destination.rootDir) || !isSkillName(input.destination.name)) return invalid$2("Project Skill destination is invalid.");
+		return ok({
+			_tag: "ProjectSkill",
+			projectDir: resolve(input.projectDir),
+			destination: {
+				rootDir: resolve(input.destination.rootDir),
+				name: input.destination.name
+			}
+		});
+	}
+	if (input._tag === "ReviewSkill") {
+		if (!isNonEmptyString(input.skillDir)) return invalid$2("Skill review directory is required.");
+		return ok({
+			_tag: "ReviewSkill",
+			skillDir: resolve(input.skillDir)
+		});
+	}
+	return invalid$2("Skill run tag is invalid.");
+}
+function parseOutputPolicy(policy) {
+	for (const [name, value] of Object.entries(policy)) if (!Number.isSafeInteger(value) || value <= 0) throw new TypeError(`${name} must be a positive integer.`);
+	return Object.freeze(policy);
+}
+const invalid$1 = (message, issues) => err({
+	_tag: "InvalidSkill",
+	message,
+	issues
+});
+const inventory = async (sandbox, outputDir, signal) => {
+	if (signal?.aborted) return err({
+		_tag: "Cancelled",
+		message: "Skill run was cancelled."
+	});
+	const command = "find -P \"$SKILLD_OUTPUT\" -mindepth 1 -printf '%y\\0%P\\0%s\\0'";
+	const result = await Promise.resolve().then(() => sandbox.run({
+		command,
+		env: {
+			LC_ALL: "C",
+			SKILLD_OUTPUT: outputDir
+		},
+		abortSignal: signal
+	})).catch((error) => error);
+	if (result instanceof Error) return invalid$1("Harness output cannot be inspected.", [result.message]);
+	if (result.exitCode !== 0) return invalid$1("Harness output directory is missing.", [result.stderr.trim() || "No output directory."]);
+	const fields = result.stdout.split("\0");
+	if (fields.at(-1) === "") fields.pop();
+	if (fields.length % 3 !== 0) return invalid$1("Harness output inventory is invalid.", ["File inventory has an incomplete entry."]);
+	const entries = [];
+	for (let index = 0; index < fields.length; index += 3) {
+		const type = fields[index];
+		const path = fields[index + 1];
+		const size = Number(fields[index + 2]);
+		if (!type || !path || !Number.isSafeInteger(size) || size < 0) return invalid$1("Harness output inventory is invalid.", ["File inventory has invalid fields."]);
+		entries.push({
+			type,
+			path,
+			size
+		});
+	}
+	return ok(entries);
+};
+const collectSandboxOutput = async (sandbox, outputDir, policy, signal) => {
+	const before = await inventory(sandbox, outputDir, signal);
+	if (before._tag === "Err") return before;
+	const files = [];
+	const seen = /* @__PURE__ */ new Set();
+	let totalBytes = 0;
+	for (const entry of before.value) {
+		if (signal?.aborted) return err({
+			_tag: "Cancelled",
+			message: "Skill run was cancelled."
+		});
+		const path = normalizeOutputPath(entry.path);
+		if (path === null) return invalid$1("Harness output contains an invalid path.", [entry.path]);
+		if (entry.type === "d") continue;
+		if (entry.type !== "f") return invalid$1("Harness output contains a linked or special entry.", [path]);
+		if (seen.has(path)) return invalid$1("Harness output contains duplicate paths.", [path]);
+		if (files.length >= policy.maxOutputFiles) return invalid$1("Harness output contains too many files.", [`Limit: ${policy.maxOutputFiles}`]);
+		if (entry.size > policy.maxOutputFileBytes) return invalid$1("Harness output contains an oversized file.", [path]);
+		if (totalBytes + entry.size > policy.maxOutputBytes) return invalid$1("Harness output exceeds the total byte limit.", [`Limit: ${policy.maxOutputBytes}`]);
+		const content = await Promise.resolve().then(() => sandbox.readBinaryFile({
+			path: `${outputDir}/${path}`,
+			abortSignal: signal
+		})).catch((error) => error);
+		if (content instanceof Error) {
+			if (signal?.aborted) return err({
+				_tag: "Cancelled",
+				message: "Skill run was cancelled."
+			});
+			return invalid$1("Harness output cannot be read.", [path, content.message]);
+		}
+		if (content === null || content.byteLength !== entry.size) return invalid$1("Harness output changed during collection.", [path]);
+		seen.add(path);
+		files.push({
+			path,
+			content: Uint8Array.from(content)
+		});
+		totalBytes += content.byteLength;
+	}
+	const after = await inventory(sandbox, outputDir, signal);
+	if (after._tag === "Err") return after;
+	if (JSON.stringify(before.value) !== JSON.stringify(after.value)) return invalid$1("Harness output changed during collection.", ["File inventory changed."]);
+	files.sort((left, right) => left.path.localeCompare(right.path));
+	return ok(files);
+};
+function pathError(message, path) {
+	return err({
+		_tag: "UnsafeOutputPath",
+		message,
+		path
+	});
+}
+const missing = Symbol("missing");
+async function statOrMissing(path) {
+	return lstat(path).catch((error) => error.code === "ENOENT" ? missing : Promise.reject(error));
+}
+const promoteSkill = async (rootDir, name, files, attempts) => {
+	const root = resolve(rootDir);
+	let rootStat = await statOrMissing(root).catch((error) => error);
+	if (rootStat instanceof Error) return pathError("Output root cannot be inspected.", root);
+	let createdRoot = false;
+	if (rootStat === missing) {
+		const parent = dirname(root);
+		const parentStat = await statOrMissing(parent).catch((error) => error);
+		if (parentStat instanceof Error || parentStat === missing || !parentStat.isDirectory() || parentStat.isSymbolicLink()) return pathError("Output root parent must be an existing directory.", parent);
+		const canonicalParent = await realpath(parent).catch((error) => error);
+		if (canonicalParent instanceof Error || canonicalParent !== parent) return pathError("Output root parent must not pass through a symbolic link.", parent);
+		const created = await mkdir(root, { mode: 448 }).then(() => true, (error) => error);
+		if (created instanceof Error && created.code !== "EEXIST") return pathError("Output root cannot be created.", root);
+		createdRoot = created === true;
+		rootStat = await statOrMissing(root).catch((error) => error);
+	}
+	if (rootStat instanceof Error || rootStat === missing || !rootStat.isDirectory() || rootStat.isSymbolicLink()) return pathError("Output root must be a directory, not a symbolic link.", root);
+	const canonicalRoot = await realpath(root).catch((error) => error);
+	if (canonicalRoot instanceof Error) return pathError("Output root cannot be resolved.", root);
+	if (canonicalRoot !== root) return pathError("Output root must not pass through a symbolic link.", root);
+	const target = join(root, name);
+	const targetStat = await statOrMissing(target).catch((error) => error);
+	if (targetStat instanceof Error) return pathError("Output path cannot be inspected.", target);
+	if (targetStat !== missing && (!targetStat.isDirectory() || targetStat.isSymbolicLink())) return pathError("Output path must be a directory, not a symbolic link.", target);
+	const lockPath = join(root, `.skilld-${name}.lock`);
+	const lock = await open(lockPath, "wx").catch((error) => error);
+	if (lock instanceof Error) {
+		if (lock.code === "EEXIST") return err({
+			_tag: "OutputBusy",
+			message: "Another Skill run owns this output path.",
+			path: target
+		});
+		return err({
+			_tag: "PromotionFailed",
+			message: "Output lock could not be created.",
+			path: target,
+			cause: lock
+		});
+	}
+	const nonce = randomUUID();
+	const staging = join(root, `.skilld-${name}-${nonce}.next`);
+	const backup = join(root, `.skilld-${name}-${nonce}.previous`);
+	let movedCurrent = false;
+	let promoted = false;
+	let failureMessage = "Skill output could not be promoted.";
+	let failureCause;
+	try {
+		await mkdir(staging, { mode: 448 });
+		for (const file of files) {
+			const destination = join(staging, file.path);
+			await mkdir(dirname(destination), {
+				recursive: true,
+				mode: 448
+			});
+			await writeFile(destination, file.content, {
+				flag: "wx",
+				mode: 384
+			});
+		}
+		if (targetStat !== missing) {
+			await rename(target, backup);
+			movedCurrent = true;
+		}
+		await rename(staging, target);
+		promoted = true;
+	} catch (cause) {
+		failureCause = cause;
+		if (movedCurrent && !promoted) {
+			const current = await statOrMissing(target).catch((error) => error);
+			if (current instanceof Error) {
+				failureMessage = "Skill output rollback could not inspect its destination.";
+				failureCause = new AggregateError([cause, current]);
+			}
+			if (current === missing) {
+				const rollback = await rename(backup, target).catch((error) => error);
+				if (rollback instanceof Error) {
+					failureMessage = "Skill output rollback failed.";
+					failureCause = new AggregateError([cause, rollback]);
+				}
+			}
+		}
+	}
+	const lockCleanupErrors = [];
+	await lock.close().catch((error) => lockCleanupErrors.push(error));
+	await unlink(lockPath).catch((error) => lockCleanupErrors.push(error));
+	if (promoted) {
+		const warnings = [];
+		if (lockCleanupErrors.length > 0) {
+			const detail = lockCleanupErrors.map((error) => error instanceof Error ? error.message : String(error)).join("; ");
+			warnings.push(`Output lock cleanup failed at ${lockPath}: ${detail}`);
+		}
+		if (movedCurrent) {
+			const backupCleanup = await rm(backup, { recursive: true }).catch((error) => error);
+			if (backupCleanup instanceof Error) warnings.push(`Previous Skill cleanup failed at ${backup}: ${backupCleanup.message}`);
+		}
+		return ok({
+			_tag: "GeneratedSkill",
+			name,
+			outputDir: target,
+			files: files.map((file) => ({
+				path: file.path,
+				bytes: file.content.byteLength
+			})),
+			sourceAttempts: attempts,
+			warnings
+		});
+	}
+	const cleanupErrors = [...lockCleanupErrors];
+	await rm(staging, {
+		recursive: true,
+		force: true
+	}).catch((error) => cleanupErrors.push(error));
+	if (createdRoot) await rmdir(root).catch((error) => cleanupErrors.push(error));
+	const causes = failureCause === void 0 ? cleanupErrors : [failureCause, ...cleanupErrors];
+	const cause = causes.length <= 1 ? causes[0] : new AggregateError(causes, "Skill output cleanup failed.");
+	return err({
+		_tag: "PromotionFailed",
+		message: failureMessage,
+		path: target,
+		cause
+	});
+};
+const allowedFrontmatter = /* @__PURE__ */ new Set([
+	"name",
+	"description",
+	"license",
+	"compatibility",
+	"metadata",
+	"allowed-tools"
+]);
+const invalid = (issues) => err({
+	_tag: "InvalidSkill",
+	message: "Skill output failed deterministic checks.",
+	issues
+});
+function decodeText(content) {
+	try {
+		return new TextDecoder("utf-8", { fatal: true }).decode(content);
+	} catch {
+		return null;
+	}
+}
+const isStringMap = (value) => value !== null && typeof value === "object" && !Array.isArray(value) && Object.values(value).every((item) => typeof item === "string");
+const validateGeneratedSkill = (name, files) => {
+	const issues = [];
+	const skillFiles = files.filter((file) => file.path === "SKILL.md");
+	if (skillFiles.length !== 1) return invalid(["Output must contain exactly one SKILL.md file."]);
+	const source = decodeText(skillFiles[0].content);
+	if (source === null) return invalid(["SKILL.md must contain valid UTF-8 text."]);
+	const match = source.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
+	if (!match) return invalid(["SKILL.md must start with YAML frontmatter."]);
+	if (match[2]?.trim().length === 0) issues.push("SKILL.md instructions must not be empty.");
+	const document = parseDocument(match[1], { uniqueKeys: true });
+	for (const error of document.errors) issues.push(`Frontmatter: ${error.message}`);
+	for (const warning of document.warnings) issues.push(`Frontmatter: ${warning.message}`);
+	const value = document.errors.length === 0 ? document.toJS() : null;
+	if (!value || typeof value !== "object" || Array.isArray(value)) {
+		issues.push("Frontmatter must be a mapping.");
+		return invalid(issues);
+	}
+	const frontmatter = value;
+	for (const key of Object.keys(frontmatter)) if (!allowedFrontmatter.has(key)) issues.push(`Frontmatter field is not supported: ${key}`);
+	if (frontmatter.name !== name) issues.push("Frontmatter name must match the Skill directory name.");
+	if (typeof frontmatter.name !== "string" || !isSkillName(frontmatter.name)) issues.push("Frontmatter name is invalid.");
+	if (typeof frontmatter.description !== "string" || frontmatter.description.trim().length === 0 || frontmatter.description.length > 1024) issues.push("Frontmatter description must contain 1 to 1024 characters.");
+	if (frontmatter.license !== void 0 && typeof frontmatter.license !== "string") issues.push("Frontmatter license must be a string.");
+	if (frontmatter.compatibility !== void 0 && (typeof frontmatter.compatibility !== "string" || frontmatter.compatibility.length > 500)) issues.push("Frontmatter compatibility must be a string of at most 500 characters.");
+	if (frontmatter.metadata !== void 0 && !isStringMap(frontmatter.metadata)) issues.push("Frontmatter metadata must map strings to strings.");
+	if (frontmatter["allowed-tools"] !== void 0 && typeof frontmatter["allowed-tools"] !== "string") issues.push("Frontmatter allowed-tools must be a string.");
+	return issues.length === 0 ? ok(void 0) : invalid(issues);
+};
+const findingLevels = /* @__PURE__ */ new Set([
+	"error",
+	"warning",
+	"note"
+]);
+const validateSkillReview = (files) => {
+	if (files.length !== 1 || files[0]?.path !== "review.json") return invalid(["Review output must contain only review.json."]);
+	let value;
+	try {
+		const source = decodeText(files[0].content);
+		if (source === null) return invalid(["review.json must contain valid UTF-8 text."]);
+		value = JSON.parse(source);
+	} catch {
+		return invalid(["review.json must contain valid JSON."]);
+	}
+	if (!value || typeof value !== "object" || Array.isArray(value)) return invalid(["review.json must contain an object."]);
+	const review = value;
+	if (Object.keys(review).some((key) => key !== "summary" && key !== "findings")) return invalid(["review.json contains unsupported fields."]);
+	if (typeof review.summary !== "string" || review.summary.trim().length === 0) return invalid(["Review summary is required."]);
+	if (!Array.isArray(review.findings)) return invalid(["Review findings must be an array."]);
+	const findings = [];
+	for (const item of review.findings) {
+		if (!item || typeof item !== "object" || Array.isArray(item)) return invalid(["Each review finding must be an object."]);
+		const finding = item;
+		if (Object.keys(finding).some((key) => ![
+			"level",
+			"path",
+			"message",
+			"fix"
+		].includes(key))) return invalid(["A review finding contains unsupported fields."]);
+		if (typeof finding.level !== "string" || !findingLevels.has(finding.level)) return invalid(["A review finding level is invalid."]);
+		if (typeof finding.path !== "string" || normalizeOutputPath(finding.path) === null) return invalid(["A review finding path is invalid."]);
+		if (typeof finding.message !== "string" || finding.message.trim().length === 0 || typeof finding.fix !== "string" || finding.fix.trim().length === 0) return invalid(["A review finding is incomplete."]);
+		findings.push(finding);
+	}
+	return ok({
+		_tag: "SkillReview",
+		summary: review.summary,
+		findings
+	});
+};
+const ignoredNames = /* @__PURE__ */ new Set([
+	".git",
+	".hg",
+	".next",
+	".nuxt",
+	".output",
+	".skilld",
+	".turbo",
+	"coverage",
+	"dist",
+	"node_modules",
+	"target"
+]);
+async function collectHostDirectory(directory, policy, sourceLabel = directory, signal) {
+	const root = resolve(directory);
+	const unavailable = (message, cause) => err({
+		_tag: "SourceUnavailable",
+		message,
+		attempts: [{
+			source: sourceLabel,
+			status: "skipped",
+			reason: message
+		}],
+		cause
+	});
+	const cancelled = () => err({
+		_tag: "Cancelled",
+		message: "Skill run was cancelled."
+	});
+	if (signal?.aborted) return cancelled();
+	const rootStat = await lstat(root).catch((error) => error);
+	if (rootStat instanceof Error) return unavailable("Source directory is unavailable.", rootStat);
+	if (!rootStat.isDirectory() || rootStat.isSymbolicLink()) return unavailable("Source path must be a directory, not a symbolic link.");
+	const canonicalRoot = await realpath(root).catch((error) => error);
+	if (canonicalRoot instanceof Error) return unavailable("Source directory cannot be resolved.", canonicalRoot);
+	if (canonicalRoot !== root) return unavailable("Source path must not pass through a symbolic link.");
+	const files = [];
+	let totalBytes = 0;
+	const walk = async (current) => {
+		if (signal?.aborted) return cancelled();
+		const canonicalCurrent = await realpath(current).catch((error) => error);
+		if (canonicalCurrent instanceof Error || canonicalCurrent !== current) return unavailable("Source directory changed during collection.", canonicalCurrent instanceof Error ? canonicalCurrent : void 0);
+		const directoryHandle = await opendir(current).catch((error) => error);
+		if (directoryHandle instanceof Error) return unavailable("Source directory cannot be read.", directoryHandle);
+		for await (const entry of directoryHandle) {
+			if (signal?.aborted) return cancelled();
+			if (ignoredNames.has(entry.name)) continue;
+			const absolute = join(current, entry.name);
+			const stat = await lstat(absolute).catch((error) => error);
+			if (stat instanceof Error) return unavailable("Source entry cannot be read.", stat);
+			if (stat.isSymbolicLink()) return unavailable("Source contains a symbolic link.");
+			if (stat.isDirectory()) {
+				const nested = await walk(absolute);
+				if (nested._tag === "Err") return nested;
+				continue;
+			}
+			if (!stat.isFile()) return unavailable("Source contains a special file.");
+			const path = relative(root, absolute).split(sep).join("/");
+			const handle = await open(absolute, constants.O_RDONLY | constants.O_NOFOLLOW).catch((error) => error);
+			if (handle instanceof Error) return unavailable("Source file cannot be opened without following links.", handle);
+			const openedStat = await handle.stat().catch((error) => error);
+			if (openedStat instanceof Error) {
+				await handle.close();
+				return unavailable("Source file cannot be inspected.", openedStat);
+			}
+			if (!openedStat.isFile() || openedStat.dev !== stat.dev || openedStat.ino !== stat.ino) {
+				await handle.close();
+				return unavailable("Source file changed during collection.");
+			}
+			if (openedStat.size > policy.maxSourceFileBytes) {
+				await handle.close();
+				continue;
+			}
+			if (files.length >= policy.maxSourceFiles) {
+				await handle.close();
+				return unavailable("Source contains too many files.");
+			}
+			if (totalBytes + openedStat.size > policy.maxSourceBytes) {
+				await handle.close();
+				return unavailable("Source exceeds the total byte limit.");
+			}
+			const content = await handle.readFile().catch((error) => error);
+			await handle.close();
+			if (content instanceof Error) return unavailable("Source file cannot be read.", content);
+			if (content.byteLength !== openedStat.size) return unavailable("Source file changed during collection.");
+			if (signal?.aborted) return cancelled();
+			files.push({
+				path,
+				content
+			});
+			totalBytes += content.byteLength;
+		}
+		return ok(void 0);
+	};
+	const walked = await walk(root);
+	if (walked._tag === "Err") return walked;
+	if (files.length === 0) return unavailable("Source directory has no usable files.");
+	files.sort((left, right) => left.path.localeCompare(right.path));
+	return ok({
+		files,
+		attempts: [{
+			source: sourceLabel,
+			status: "used"
+		}]
+	});
+}
+const blockBytes = 512;
+function unavailable$1(message, cause) {
+	return err({
+		_tag: "SourceUnavailable",
+		message,
+		attempts: [],
+		cause
+	});
+}
+function readString(buffer, start, length) {
+	const bytes = buffer.subarray(start, start + length);
+	const zero = bytes.indexOf(0);
+	return Buffer.from(zero === -1 ? bytes : bytes.subarray(0, zero)).toString("utf8").trim();
+}
+function readOctal(buffer, start, length) {
+	const value = readString(buffer, start, length).replace(/^\s+|\s+$/g, "");
+	if (!/^[0-7]+$/.test(value)) return null;
+	const parsed = Number.parseInt(value, 8);
+	return Number.isSafeInteger(parsed) ? parsed : null;
+}
+function hasValidChecksum(header) {
+	const expected = readOctal(header, 148, 8);
+	if (expected === null) return false;
+	let actual = 0;
+	for (let index = 0; index < header.byteLength; index += 1) actual += index >= 148 && index < 156 ? 32 : header[index];
+	return actual === expected;
+}
+function parsePaxPath(content) {
+	const text = Buffer.from(content).toString("utf8");
+	let offset = 0;
+	let path = null;
+	while (offset < text.length) {
+		const space = text.indexOf(" ", offset);
+		if (space === -1) return null;
+		const length = Number.parseInt(text.slice(offset, space), 10);
+		if (!Number.isSafeInteger(length) || length <= 0 || offset + length > text.length) return null;
+		const record = text.slice(space + 1, offset + length - 1);
+		const equals = record.indexOf("=");
+		if (equals !== -1 && record.slice(0, equals) === "path") path = record.slice(equals + 1);
+		offset += length;
+	}
+	return path;
+}
+function archivePath(value, layout) {
+	const normalized = normalizeOutputPath(value);
+	if (normalized === null) return null;
+	const segments = normalized.split("/");
+	if (layout === "npm") {
+		if (segments[0] !== "package" || segments.length < 2) return null;
+	} else if (segments.length < 2) return null;
+	return normalizeOutputPath(segments.slice(1).join("/"));
+}
+function entryContent(entry) {
+	return entry.chunks.length === 1 ? entry.chunks[0] : Buffer.concat(entry.chunks, entry.size);
+}
+async function extractArchive(compressed, policy, layout) {
+	const source = Readable.from(compressed);
+	const gunzip = createGunzip();
+	source.on("error", (error) => gunzip.destroy(error));
+	source.pipe(gunzip);
+	const files = [];
+	const seen = /* @__PURE__ */ new Set();
+	const maxArchiveBytes = policy.maxSourceBytes + (policy.maxSourceFiles + 2) * blockBytes * 2;
+	let archiveBytes = 0;
+	let fileEntries = 0;
+	let nextPath = null;
+	let pending = Buffer.alloc(0);
+	let entry = null;
+	let totalBytes = 0;
+	let ended = false;
+	try {
+		for await (const value of gunzip) {
+			const chunk = Buffer.isBuffer(value) ? value : Buffer.from(value);
+			archiveBytes += chunk.byteLength;
+			if (archiveBytes > maxArchiveBytes) return unavailable$1("Source archive exceeds the uncompressed byte limit.");
+			pending = pending.byteLength === 0 ? chunk : Buffer.concat([pending, chunk]);
+			while (pending.byteLength > 0) {
+				if (ended) {
+					if (pending.some((byte) => byte !== 0)) return unavailable$1("Source archive has data after its end marker.");
+					pending = Buffer.alloc(0);
+					break;
+				}
+				if (entry !== null) {
+					if (entry.remaining > 0) {
+						const consumed = Math.min(entry.remaining, pending.byteLength);
+						if (entry.kind === "file" || entry.kind === "metadata") entry.chunks.push(pending.subarray(0, consumed));
+						pending = pending.subarray(consumed);
+						entry.remaining -= consumed;
+						if (entry.remaining > 0) break;
+					}
+					if (entry.padding > 0) {
+						const consumed = Math.min(entry.padding, pending.byteLength);
+						pending = pending.subarray(consumed);
+						entry.padding -= consumed;
+						if (entry.padding > 0) break;
+					}
+					if (entry.kind === "metadata") {
+						const content = entryContent(entry);
+						nextPath = entry.metadataType === "pax" ? parsePaxPath(content) : content.toString("utf8").replace(/\0.*$/s, "").trim();
+						if (nextPath === null || nextPath.length === 0) return unavailable$1("Source archive has invalid path metadata.");
+					} else if (entry.kind === "file" && entry.path) {
+						files.push({
+							path: entry.path,
+							content: Uint8Array.from(entryContent(entry))
+						});
+						totalBytes += entry.size;
+					}
+					entry = null;
+					continue;
+				}
+				if (pending.byteLength < blockBytes) break;
+				const header = pending.subarray(0, blockBytes);
+				pending = pending.subarray(blockBytes);
+				if (header.every((byte) => byte === 0)) {
+					ended = true;
+					continue;
+				}
+				if (!hasValidChecksum(header)) return unavailable$1("Source archive has an invalid header checksum.");
+				const size = readOctal(header, 124, 12);
+				if (size === null) return unavailable$1("Source archive has an invalid entry size.");
+				const name = readString(header, 0, 100);
+				const prefix = readString(header, 345, 155);
+				const headerPath = prefix.length > 0 ? `${prefix}/${name}` : name;
+				const type = String.fromCharCode(header[156] ?? 0);
+				const padding = (blockBytes - size % blockBytes) % blockBytes;
+				if (type === "x" || type === "L") {
+					if (size > policy.maxSourceFileBytes) return unavailable$1("Source archive path metadata exceeds the file byte limit.");
+					entry = {
+						kind: "metadata",
+						metadataType: type === "x" ? "pax" : "long-path",
+						size,
+						remaining: size,
+						padding,
+						chunks: []
+					};
+					continue;
+				}
+				if (type === "5") {
+					nextPath = null;
+					entry = {
+						kind: "directory",
+						size,
+						remaining: size,
+						padding,
+						chunks: []
+					};
+					continue;
+				}
+				if (type !== "0" && type !== "\0") return unavailable$1("Source archive contains a linked or special entry.");
+				const path = archivePath(nextPath ?? headerPath, layout);
+				nextPath = null;
+				if (path === null) return unavailable$1("Source archive contains an invalid path.");
+				if (seen.has(path)) return unavailable$1("Source archive contains duplicate paths.");
+				seen.add(path);
+				fileEntries += 1;
+				if (fileEntries > policy.maxSourceFiles) return unavailable$1("Source archive contains too many files.");
+				if (size <= policy.maxSourceFileBytes && totalBytes + size > policy.maxSourceBytes) return unavailable$1("Source archive exceeds the total byte limit.");
+				entry = {
+					kind: size > policy.maxSourceFileBytes ? "skip" : "file",
+					path,
+					size,
+					remaining: size,
+					padding,
+					chunks: []
+				};
+			}
+		}
+	} catch (cause) {
+		const message = cause instanceof Error ? cause.message : "";
+		return unavailable$1(message.startsWith("Source archive ") ? message : "Source archive is not valid gzip data.", cause);
+	}
+	if (entry !== null || pending.some((byte) => byte !== 0) || !ended) return unavailable$1("Source archive ended before its final entry.");
+	if (files.length === 0) return unavailable$1("Source archive has no usable files.");
+	files.sort((left, right) => left.path.localeCompare(right.path));
+	return ok(files);
+}
+const packageSpecPattern = /^(@[^/@]+\/[^/@]+|[^/@]+)(?:@(\S+))?$/;
+const exactVersionPattern = /^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-[\da-z-]+(?:\.[\da-z-]+)*)?(?:\+[\da-z-]+(?:\.[\da-z-]+)*)?$/i;
+const gitCommitPattern = /^[0-9a-f]{40}$/i;
+const npmRequestTimeoutMs = 3e4;
+const npmRedirectLimit = 3;
+const packumentByteLimit = 10485760;
+function unavailable(message, attempts, cause) {
+	return err({
+		_tag: "SourceUnavailable",
+		message,
+		attempts,
+		cause
+	});
+}
+function parsePackageSpec(spec) {
+	const match = spec.match(packageSpecPattern);
+	return match?.[1] ? {
+		name: match[1],
+		version: match[2] ?? "latest"
+	} : null;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseRepository(value) {
+	if (typeof value === "string") return value;
+	if (!isRecord(value)) return void 0;
+	return {
+		type: typeof value.type === "string" ? value.type : void 0,
+		url: typeof value.url === "string" ? value.url : void 0
+	};
+}
+function parseVersion(packument, requested) {
+	if (!isRecord(packument) || !isRecord(packument["dist-tags"]) || !isRecord(packument.versions)) return null;
+	const tagged = packument["dist-tags"][requested];
+	const resolvedVersion = typeof tagged === "string" ? tagged : requested;
+	const value = packument.versions[resolvedVersion];
+	if (!isRecord(value) || typeof value.version !== "string" || !isRecord(value.dist) || typeof value.dist.tarball !== "string") return null;
+	return {
+		resolvedVersion,
+		repository: parseRepository(packument.repository),
+		version: {
+			version: value.version,
+			gitHead: typeof value.gitHead === "string" ? value.gitHead : void 0,
+			repository: parseRepository(value.repository),
+			dist: {
+				tarball: value.dist.tarball,
+				integrity: typeof value.dist.integrity === "string" ? value.dist.integrity : void 0,
+				shasum: typeof value.dist.shasum === "string" ? value.dist.shasum : void 0
+			}
+		}
+	};
+}
+async function cancelBody(response) {
+	if (!response.body) return;
+	await response.body.cancel().catch(() => void 0);
+}
+function declaredBytes(response) {
+	const value = response.headers.get("content-length");
+	if (value === null || !/^\d+$/.test(value)) return null;
+	const bytes = Number(value);
+	return Number.isSafeInteger(bytes) ? bytes : null;
+}
+async function* responseChunks(response, maxBytes, limitMessage, onChunk = () => {}) {
+	const declared = declaredBytes(response);
+	if (declared !== null && declared > maxBytes) {
+		await cancelBody(response);
+		throw new Error(limitMessage);
+	}
+	if (!response.body) return;
+	const reader = response.body.getReader();
+	let complete = false;
+	let totalBytes = 0;
+	try {
+		while (true) {
+			const result = await reader.read();
+			if (result.done) {
+				complete = true;
+				return;
+			}
+			totalBytes += result.value.byteLength;
+			if (totalBytes > maxBytes) throw new Error(limitMessage);
+			onChunk(result.value);
+			yield result.value;
+		}
+	} finally {
+		if (!complete) await reader.cancel().catch(() => void 0);
+		reader.releaseLock();
+	}
+}
+async function readBoundedResponse(response, maxBytes) {
+	const chunks = [];
+	let totalBytes = 0;
+	try {
+		for await (const chunk of responseChunks(response, maxBytes, "npm response exceeds the byte limit.")) {
+			chunks.push(chunk);
+			totalBytes += chunk.byteLength;
+		}
+	} catch (cause) {
+		return unavailable(cause instanceof Error ? cause.message : "npm response cannot be read.", [], cause);
+	}
+	return ok(Uint8Array.from(Buffer.concat(chunks, totalBytes)));
+}
+async function fetchWithRedirects(fetchClient, url, init = {}, signal) {
+	const timeout = AbortSignal.timeout(npmRequestTimeoutMs);
+	const requestSignal = signal ? AbortSignal.any([signal, timeout]) : timeout;
+	let current = url;
+	for (let redirects = 0; redirects <= npmRedirectLimit; redirects += 1) {
+		const response = await fetchClient(current, {
+			...init,
+			redirect: "manual",
+			signal: requestSignal
+		}).catch((error) => error);
+		if (response instanceof Error) return unavailable(timeout.aborted ? "npm request timed out." : "npm request failed.", [], response);
+		if (![
+			301,
+			302,
+			303,
+			307,
+			308
+		].includes(response.status)) return ok(response);
+		if (redirects === npmRedirectLimit) {
+			await cancelBody(response);
+			return unavailable("npm request exceeded the redirect limit.", []);
+		}
+		const location = response.headers.get("location");
+		if (!location) {
+			await cancelBody(response);
+			return unavailable("npm redirect is missing its location.", []);
+		}
+		const redirected = await Promise.resolve().then(() => new URL(location, current)).catch(() => null);
+		if (redirected === null) {
+			await cancelBody(response);
+			return unavailable("npm redirect location is invalid.", []);
+		}
+		if (redirected.protocol !== "https:") {
+			await cancelBody(response);
+			return unavailable("npm redirect URL must use HTTPS.", []);
+		}
+		await cancelBody(response);
+		current = redirected.href;
+	}
+	return unavailable("npm request exceeded the redirect limit.", []);
+}
+function createIntegrityVerifier(dist) {
+	const values = dist.integrity?.split(/\s+/).filter(Boolean) ?? [];
+	let expected = values.flatMap((value) => {
+		const match = value.match(/^(sha(?:1|256|384|512))-([A-Za-z0-9+/=]+)$/);
+		return match?.[1] && match[2] ? [{
+			algorithm: match[1],
+			digest: match[2]
+		}] : [];
+	});
+	if (expected.length > 0) {
+		const strength = {
+			sha1: 1,
+			sha256: 2,
+			sha384: 3,
+			sha512: 4
+		};
+		const strongest = Math.max(...expected.map((value) => strength[value.algorithm]));
+		expected = expected.filter((value) => strength[value.algorithm] === strongest);
+	}
+	if (values.length === 0 && dist.shasum && /^[0-9a-f]{40}$/i.test(dist.shasum)) expected.push({
+		algorithm: "sha1",
+		digest: Buffer.from(dist.shasum, "hex").toString("base64")
+	});
+	if (expected.length === 0) return null;
+	const hashes = /* @__PURE__ */ new Map();
+	for (const value of expected) hashes.set(value.algorithm, createHash(value.algorithm));
+	return {
+		update(content) {
+			for (const hash of hashes.values()) hash.update(content);
+		},
+		valid() {
+			const actual = new Map([...hashes].map(([algorithm, hash]) => [algorithm, hash.digest("base64")]));
+			return expected.some((value) => actual.get(value.algorithm) === value.digest);
+		}
+	};
+}
+function repositoryUrl(repository) {
+	if (typeof repository === "string") return repository;
+	return typeof repository?.url === "string" ? repository.url : null;
+}
+function githubArchiveUrl(repository, gitHead) {
+	if (!gitHead || !gitCommitPattern.test(gitHead)) return null;
+	const source = repositoryUrl(repository);
+	if (source === null) return null;
+	const match = source.match(/^(?:(?:git\+)?https?:\/\/(?:git@)?github\.com\/|git:\/\/github\.com\/|git@github\.com:)([\w.-]+)\/([\w.-]+?)(?:\.git)?\/?$/);
+	if (!match?.[1] || !match[2]) return null;
+	return `https://codeload.github.com/${encodeURIComponent(match[1])}/${encodeURIComponent(match[2])}/tar.gz/${gitHead}`;
+}
+function skipped(source, reason) {
+	return {
+		source,
+		status: "skipped",
+		reason
+	};
+}
+function used(source) {
+	return {
+		source,
+		status: "used"
+	};
+}
+function withAttempts(error, attempts) {
+	return error._tag === "SourceUnavailable" ? unavailable(error.message, attempts, error.cause) : err(error);
+}
+function remainingPolicy(policy, files) {
+	const usedBytes = files.reduce((total, file) => total + file.content.byteLength, 0);
+	const maxSourceFiles = policy.maxSourceFiles - files.length;
+	const maxSourceBytes = policy.maxSourceBytes - usedBytes;
+	if (maxSourceFiles <= 0 || maxSourceBytes <= 0) return null;
+	return {
+		...policy,
+		maxSourceFiles,
+		maxSourceBytes
+	};
+}
+async function extractResponse(response, policy, layout, verifier) {
+	return extractArchive(responseChunks(response, policy.maxSourceBytes, "Source archive exceeds the compressed byte limit.", (content) => verifier?.update(content)), policy, layout);
+}
+async function prepareNpmPackage(spec, policy, fetchClient, signal) {
+	const parsed = parsePackageSpec(spec);
+	if (parsed === null) return unavailable("npm package spec is invalid.", []);
+	const attempts = [];
+	const registryUrl = `https://registry.npmjs.org/${encodeURIComponent(parsed.name)}`;
+	const registryResponse = await fetchWithRedirects(fetchClient, registryUrl, { headers: { accept: "application/vnd.npm.install-v1+json" } }, signal);
+	if (registryResponse._tag === "Err") return withAttempts(registryResponse.error, [skipped(registryUrl, registryResponse.error.message)]);
+	const response = registryResponse.value;
+	if (!response.ok) {
+		await cancelBody(response);
+		const message = `npm registry returned HTTP ${response.status}.`;
+		return unavailable(message, [skipped(registryUrl, message)]);
+	}
+	const packumentBytes = await readBoundedResponse(response, packumentByteLimit);
+	if (packumentBytes._tag === "Err") return withAttempts(packumentBytes.error, [skipped(registryUrl, packumentBytes.error.message)]);
+	let packument;
+	try {
+		packument = JSON.parse(Buffer.from(packumentBytes.value).toString("utf8"));
+	} catch (cause) {
+		const message = "npm registry returned invalid package data.";
+		return unavailable(message, [skipped(registryUrl, message)], cause);
+	}
+	const resolution = parseVersion(packument, parsed.version);
+	if (resolution === null || !exactVersionPattern.test(resolution.resolvedVersion) || resolution.version.version !== resolution.resolvedVersion) {
+		const message = "npm package did not resolve to an exact version.";
+		return unavailable(message, [skipped(registryUrl, message)]);
+	}
+	const { repository, resolvedVersion, version } = resolution;
+	if (!version.dist.tarball.startsWith("https://")) {
+		const message = "npm package archive URL must use HTTPS.";
+		return unavailable(message, [skipped(registryUrl, message)]);
+	}
+	attempts.push(used(registryUrl));
+	const fetchedArchive = await fetchWithRedirects(fetchClient, version.dist.tarball, {}, signal);
+	if (fetchedArchive._tag === "Err") return withAttempts(fetchedArchive.error, [...attempts, skipped(version.dist.tarball, fetchedArchive.error.message)]);
+	const archiveResponse = fetchedArchive.value;
+	if (!archiveResponse.ok) {
+		await cancelBody(archiveResponse);
+		const message = `npm package archive returned HTTP ${archiveResponse.status}.`;
+		return unavailable(message, [...attempts, skipped(version.dist.tarball, message)]);
+	}
+	const verifier = createIntegrityVerifier(version.dist);
+	if (verifier === null) {
+		await cancelBody(archiveResponse);
+		const message = "npm package archive has no supported integrity value.";
+		return unavailable(message, [...attempts, skipped(version.dist.tarball, message)]);
+	}
+	const extracted = await extractResponse(archiveResponse, policy, "npm", verifier);
+	if (extracted._tag === "Err") return withAttempts(extracted.error, [...attempts, skipped(version.dist.tarball, extracted.error.message)]);
+	if (!verifier.valid()) {
+		const message = "npm package archive integrity check failed.";
+		return unavailable(message, [...attempts, skipped(version.dist.tarball, message)]);
+	}
+	attempts.push(used(version.dist.tarball));
+	let files = [...extracted.value];
+	const repositoryArchive = githubArchiveUrl(version.repository ?? repository, version.gitHead);
+	const available = remainingPolicy(policy, files);
+	if (repositoryArchive !== null && available === null) attempts.push(skipped(repositoryArchive, "Prepared package files reached the source limit."));
+	else if (repositoryArchive !== null && available !== null) {
+		const fetchedRepository = await fetchWithRedirects(fetchClient, repositoryArchive, {}, signal);
+		if (fetchedRepository._tag === "Err") attempts.push(skipped(repositoryArchive, fetchedRepository.error.message));
+		else if (!fetchedRepository.value.ok) {
+			const message = `GitHub source archive returned HTTP ${fetchedRepository.value.status}.`;
+			await cancelBody(fetchedRepository.value);
+			attempts.push(skipped(repositoryArchive, message));
+		} else {
+			const repositoryFiles = await extractResponse(fetchedRepository.value, available, "github");
+			if (repositoryFiles._tag === "Err") attempts.push(skipped(repositoryArchive, repositoryFiles.error.message));
+			else {
+				files = [...files, ...repositoryFiles.value.map((file) => ({
+					...file,
+					path: posix.join("repository", file.path)
+				}))];
+				attempts.push(used(repositoryArchive));
+			}
+		}
+	}
+	files.sort((left, right) => left.path.localeCompare(right.path));
+	return ok({
+		files,
+		attempts,
+		npmResolution: {
+			package: parsed.name,
+			version: resolvedVersion
+		}
+	});
+}
+function cancelled() {
+	return err({
+		_tag: "Cancelled",
+		message: "Skill run was cancelled."
+	});
+}
+async function prepareCurrentSkill(destination, policy, signal) {
+	const root = resolve(destination.rootDir);
+	const rootStat = await lstat(root).catch((error) => error);
+	if (rootStat instanceof Error) {
+		if (rootStat.code === "ENOENT") return ok(void 0);
+		return err({
+			_tag: "UnsafeOutputPath",
+			message: "Output root cannot be inspected.",
+			path: root
+		});
+	}
+	if (!rootStat.isDirectory() || rootStat.isSymbolicLink()) return err({
+		_tag: "UnsafeOutputPath",
+		message: "Output root must be a directory, not a symbolic link.",
+		path: root
+	});
+	const canonicalRoot = await realpath(root).catch((error) => error);
+	if (canonicalRoot instanceof Error || canonicalRoot !== root) return err({
+		_tag: "UnsafeOutputPath",
+		message: "Output root must not pass through a symbolic link.",
+		path: root
+	});
+	const target = join(root, destination.name);
+	const targetStat = await lstat(target).catch((error) => error);
+	if (targetStat instanceof Error) {
+		if (targetStat.code === "ENOENT") return ok(void 0);
+		return err({
+			_tag: "UnsafeOutputPath",
+			message: "Output path cannot be inspected.",
+			path: target
+		});
+	}
+	if (!targetStat.isDirectory() || targetStat.isSymbolicLink()) return err({
+		_tag: "UnsafeOutputPath",
+		message: "Output path must be a directory, not a symbolic link.",
+		path: target
+	});
+	return collectHostDirectory(target, policy, "current Skill", signal);
+}
+async function prepareRun(input, policy, fetchClient, signal) {
+	if (signal?.aborted) return err({
+		_tag: "Cancelled",
+		message: "Skill run was cancelled."
+	});
+	const current = input._tag === "ReviewSkill" ? ok(void 0) : await prepareCurrentSkill(input.destination, policy, signal);
+	if (current._tag === "Err") return current;
+	if (input._tag === "ProjectSkill") {
+		const source = await collectHostDirectory(input.projectDir, policy, input.projectDir, signal);
+		return source._tag === "Err" ? source : ok({
+			skillName: "generate-project-skill",
+			outputName: input.destination.name,
+			source: source.value,
+			current: current.value,
+			destination: input.destination
+		});
+	}
+	if (input._tag === "ReviewSkill") {
+		const source = await collectHostDirectory(input.skillDir, policy, input.skillDir, signal);
+		return source._tag === "Err" ? source : ok({
+			skillName: "review-skill",
+			outputName: "review",
+			source: source.value
+		});
+	}
+	if (input.source._tag === "NpmPackage") {
+		const source = await prepareNpmPackage(input.source.spec, policy, fetchClient, signal);
+		if (signal?.aborted) return err({
+			_tag: "Cancelled",
+			message: "Skill run was cancelled."
+		});
+		return source._tag === "Err" ? source : ok({
+			skillName: "generate-package-skill",
+			outputName: input.destination.name,
+			source: source.value,
+			current: current.value,
+			destination: input.destination
+		});
+	}
+	const packageDir = resolveWithin(input.source.rootDir, input.source.packageDir);
+	if (packageDir === null) return err({
+		_tag: "InvalidInput",
+		message: "Local package directory must stay inside its root directory."
+	});
+	const manifest = await lstat(join(packageDir, "package.json")).catch((error) => error);
+	if (manifest instanceof Error || !manifest.isFile() || manifest.isSymbolicLink()) return err({
+		_tag: "SourceUnavailable",
+		message: "Local package directory must contain package.json.",
+		attempts: [{
+			source: packageDir,
+			status: "skipped",
+			reason: "package.json is unavailable."
+		}]
+	});
+	const source = await collectHostDirectory(packageDir, policy, packageDir, signal);
+	return source._tag === "Err" ? source : ok({
+		skillName: "generate-package-skill",
+		outputName: input.destination.name,
+		source: source.value,
+		current: current.value,
+		destination: input.destination
+	});
+}
+function requestContent(skill) {
+	const request = skill.files?.find((file) => file.path === "assets/harness-request.md");
+	if (!request) throw new Error(`Harness request asset is missing for ${skill.name}.`);
+	return request.content;
+}
+function renderRequest(template, sourcePath, currentSkillPath, outputPath, skillName) {
+	return template.replaceAll("{{SOURCE_PATH}}", sourcePath).replaceAll("{{CURRENT_SKILL_PATH}}", currentSkillPath).replaceAll("{{OUTPUT_PATH}}", outputPath).replaceAll("{{SKILL_NAME}}", skillName);
+}
+async function writePreparedSource(active, prepared, signal) {
+	const sourcePath = posix.join(active.workDir, "input/source");
+	const reset = await active.sandbox.run({
+		command: "rm -rf -- \"$SKILLD_INPUT\" \"$SKILLD_OUTPUT\" && mkdir -p -- \"$SKILLD_INPUT\"",
+		env: {
+			SKILLD_INPUT: posix.join(active.workDir, "input"),
+			SKILLD_OUTPUT: posix.join(active.workDir, "skilld-output")
+		},
+		abortSignal: signal
+	});
+	if (reset.exitCode !== 0) throw new Error(reset.stderr.trim() || "Harness work directory cannot be prepared.");
+	for (const file of prepared.source.files) await active.sandbox.writeBinaryFile({
+		path: posix.join(sourcePath, file.path),
+		content: file.content,
+		abortSignal: signal
+	});
+	for (const file of prepared.current?.files ?? []) await active.sandbox.writeBinaryFile({
+		path: posix.join(active.workDir, "input/current-skill", file.path),
+		content: file.content,
+		abortSignal: signal
+	});
+	await active.sandbox.writeTextFile({
+		path: posix.join(active.workDir, "input/source-manifest.json"),
+		content: `${JSON.stringify({
+			sourceAttempts: prepared.source.attempts,
+			npmResolution: prepared.source.npmResolution,
+			hasCurrentSkill: prepared.current !== void 0
+		}, null, 2)}\n`,
+		abortSignal: signal
+	});
+}
+function toAgentError(cause, signal) {
+	return signal?.aborted ? cancelled() : err({
+		_tag: "AgentFailed",
+		message: "Harness Agent failed during the Skill run.",
+		cause
+	});
+}
+function createSkillHarness(options) {
+	const policy = parseOutputPolicy({
+		...DEFAULT_OUTPUT_POLICY,
+		...options.outputPolicy
+	});
+	const fetchClient = options.fetch ?? globalThis.fetch.bind(globalThis);
+	const sandboxConfig = { ...options.sandboxConfig };
+	const harness = options.harness;
+	const sandbox = options.sandbox;
+	return { run: async (input, runOptions = {}) => {
+		const parsed = parseSkillRun(input);
+		if (parsed._tag === "Err") return parsed;
+		const prepared = await prepareRun(parsed.value, policy, fetchClient, runOptions.signal);
+		if (prepared._tag === "Err") return prepared;
+		const skill = await loadSkilldMaintainedSkill(prepared.value.skillName);
+		let active;
+		const userOnSession = sandboxConfig.onSession;
+		const agent = new HarnessAgent({
+			harness,
+			sandbox,
+			skills: [skill],
+			permissionMode: "allow-all",
+			sandboxConfig: {
+				...sandboxConfig,
+				onSession: async (sessionOptions) => {
+					active = {
+						sandbox: sessionOptions.session,
+						workDir: sessionOptions.sessionWorkDir
+					};
+					await writePreparedSource(active, prepared.value, runOptions.signal);
+					await userOnSession?.(sessionOptions);
+				}
+			}
+		});
+		const sessionResult = await agent.createSession({ abortSignal: runOptions.signal }).then(ok, (cause) => err(cause));
+		if (sessionResult._tag === "Err") return toAgentError(sessionResult.error, runOptions.signal);
+		const session = sessionResult.value;
+		try {
+			if (!active) return err({
+				_tag: "AgentFailed",
+				message: "Harness did not provide its sandbox session."
+			});
+			const sourcePath = posix.join(active.workDir, "input/source");
+			const currentSkillPath = posix.join(active.workDir, "input/current-skill");
+			const outputPath = posix.join(active.workDir, "skilld-output", prepared.value.outputName);
+			const prompt = renderRequest(requestContent(skill), sourcePath, currentSkillPath, outputPath, prepared.value.outputName);
+			const generated = await agent.generate({
+				session,
+				prompt,
+				abortSignal: runOptions.signal
+			}).then(ok, (cause) => err(cause));
+			if (generated._tag === "Err") return toAgentError(generated.error, runOptions.signal);
+			if (runOptions.signal?.aborted) return cancelled();
+			const collected = await collectSandboxOutput(active.sandbox, outputPath, policy, runOptions.signal);
+			if (collected._tag === "Err") return collected;
+			if (prepared.value.skillName === "review-skill") return validateSkillReview(collected.value);
+			const validated = validateGeneratedSkill(prepared.value.outputName, collected.value);
+			if (validated._tag === "Err") return validated;
+			if (!prepared.value.destination) return err({
+				_tag: "InvalidInput",
+				message: "Skill destination is required."
+			});
+			return promoteSkill(prepared.value.destination.rootDir, prepared.value.destination.name, collected.value, prepared.value.source.attempts);
+		} finally {
+			await session.destroy();
+		}
+	} };
+}
+export { createSkillHarness };
+
+//# sourceMappingURL=index.mjs.map