reeval 0.11.0 → 0.13.0

package/dist/resolve-DzdWcIL6.js

@@ -0,0 +1,724 @@
+import { p as parseDuration } from "./shared-CA61BuPJ.js";
+import { C as parseGitRepo, M as workspaceLabel, S as mcpHosts, b as isSecret, k as stepCommand, n as DEFAULT_SKILL_EXCLUDE, v as isHostFile, x as isSecretTemplate } from "./environment-B4IuURK1.js";
+import { l as sha256 } from "./ids-Bp6ut7ZD.js";
+import { c as registerSecret, r as badCharacterAt } from "./redact-CRGdfV2s.js";
+import "./config-D7TFvUpL.js";
+import { A as placeholder, R as hostAllowed, ut as run } from "./src-CIpKL45U.js";
+import { A as readPlugin, D as pluginServerName, E as pluginParts, M as skillCall, O as pluginSourceLabel, T as pluginFiles, _ as localMarketplace, c as PluginProblem, g as leavesSource, j as samePluginTwice, k as readMarketplace, m as fetchesAtStart, w as pluginCall, x as marketplaceLabel } from "./plugins-P-uh54VF.js";
+import { t as InfraError } from "./types-C5vI3g1C.js";
+import { S as refusedPlugins, b as layoutOf } from "./egress-DEAvq8Fl.js";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { basename, isAbsolute, join, relative, sep } from "node:path";
+import { parse } from "yaml";
+import { mkdir, rm } from "node:fs/promises";
+//#region src/environment/resolve.ts
+const SKILL_NAME = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+const DEFAULT_SETUP_TIMEOUT = "5m";
+function broker(secrets, name, value, hosts, where = ["header"], phase = "agent") {
+	const at = badCharacterAt(value);
+	if (at && where.includes("header")) throw new InfraError(`${name} has whitespace or a line break in it (character ${at}), so it can't go in a request header. A key copied from a wrapped terminal line picks these up; set it again as one line.`);
+	const sub = {
+		name,
+		placeholder: placeholder(),
+		value,
+		hosts: [...hosts],
+		in: [...where],
+		phase
+	};
+	secrets.brokered.push(sub);
+	return sub.placeholder;
+}
+/** The host value, or its placeholder when it's brokered to `secret.hosts` (else `hosts`). */
+function hostValue(name, secret, where, secrets, hosts = secret.hosts) {
+	const from = secret.from ?? name;
+	const value = process.env[from];
+	if (!value) {
+		if (secret.optional) {
+			secrets.unset.push(name);
+			return;
+		}
+		const source = from === name ? name : `${name} (from ${from})`;
+		throw new InfraError(`Secret ${source} for ${where} isn't set. Set it in the environment or .env.local.`);
+	}
+	registerSecret(value);
+	if (secret.to === "checks") secrets.checks.push(name);
+	else secrets.names.push(name);
+	if (!hosts) return value;
+	return broker(secrets, name, value, hosts, secret.in, secret.to === "checks" ? "checks" : "agent");
+}
+/** Each host variable in the template, or with `hosts` one placeholder per variable. */
+function template(value, where, secrets, hosts) {
+	const placeholders = /* @__PURE__ */ new Map();
+	return value.template.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (_, name) => {
+		const v = process.env[name];
+		if (!v) throw new InfraError(`secret.template for ${where} needs ${name}, which isn't set. Set it in the environment or .env.local.`);
+		registerSecret(v);
+		if (!hosts) return v;
+		const p = placeholders.get(name) ?? broker(secrets, name, v, hosts);
+		placeholders.set(name, p);
+		return p;
+	});
+}
+/** A `SKILL.md` split into its YAML frontmatter's `name` and `description` and its body. */
+function parseSkillMd(text, where) {
+	const match = /^---\r?\n(?:([\s\S]*?)\r?\n)?---[ \t]*(?:\r?\n|$)([\s\S]*)$/.exec(text);
+	if (!match) return { body: text };
+	let front;
+	try {
+		front = parse(match[1] ?? "");
+	} catch (error) {
+		const reason = error.message.split("\n")[0];
+		throw new InfraError(`${where}: the SKILL.md frontmatter isn't valid YAML (${reason}). Quote values that contain ": ".`);
+	}
+	if (front != null && (typeof front !== "object" || Array.isArray(front))) throw new InfraError(`${where}: the SKILL.md frontmatter must be a YAML mapping, e.g. name: my-skill and description: … on their own lines`);
+	const field = (key) => {
+		const value = front?.[key];
+		if (value == null) return void 0;
+		if (typeof value !== "string") throw new InfraError(`${where}: the SKILL.md ${key} must be a string (got ${typeof value})`);
+		return value.trim() || void 0;
+	};
+	return {
+		name: field("name"),
+		description: field("description"),
+		body: match[2] ?? ""
+	};
+}
+/** A gitignore-style test for `DEFAULT_SKILL_EXCLUDE`-shaped patterns against a skill-relative path. */
+function excludeMatcher(patterns) {
+	const rules = patterns.map((pattern) => {
+		const dirOnly = pattern.endsWith("/");
+		const body = pattern.replace(/\/+$/, "");
+		const anchored = body.includes("/");
+		const glob = body.replace(/^\/+/, "").split("*").map((part) => part.replace(/[.+?^${}()|[\]\\]/g, "\\$&")).join("[^/]*");
+		return {
+			dirOnly,
+			re: new RegExp(`${anchored ? "^" : "(?:^|/)"}${glob}$`)
+		};
+	});
+	return (path, isDir) => rules.some((r) => (isDir || !r.dirOnly) && r.re.test(path));
+}
+function parseSkill(dir, source, exclude) {
+	const front = parseSkillMd(readFileSync(join(dir, "SKILL.md"), "utf8"), `Skill ${basename(dir)} in ${source}`);
+	const name = front.name || basename(dir);
+	checkSkill(name, front.description, source);
+	const skip = excludeMatcher(exclude);
+	const paths = [];
+	const excluded = [];
+	const walk = (rel) => {
+		for (const entry of readdirSync(join(dir, rel), { withFileTypes: true })) {
+			const path = rel ? `${rel}/${entry.name}` : entry.name;
+			const isDir = entry.isDirectory();
+			if (entry.name === ".git") continue;
+			if (skip(path, isDir)) excluded.push(isDir ? `${path}/` : path);
+			else if (isDir) walk(path);
+			else if (entry.isFile() && path !== "SKILL.md") paths.push(path);
+		}
+	};
+	walk("");
+	const files = paths.sort().map((path) => ({
+		path,
+		content: readFileSync(join(dir, path), "utf8")
+	}));
+	return {
+		skill: {
+			name,
+			description: front.description ?? "",
+			content: front.body,
+			files
+		},
+		excluded: excluded.sort()
+	};
+}
+function checkSkill(name, description, source) {
+	if (!SKILL_NAME.test(name)) throw new InfraError(`Skill "${name}" in ${source}: the name must be kebab-case, e.g. my-skill (lower-case letters, digits and -)`);
+	if (!description) throw new InfraError(`Skill "${name}" in ${source} has no description in its SKILL.md frontmatter. Add a description: line saying when to use it.`);
+}
+function loadSkills(dir, source, only, exclude = DEFAULT_SKILL_EXCLUDE) {
+	if (!existsSync(dir) || !statSync(dir).isDirectory()) throw new InfraError(`Skill source ${source} isn't a directory. Point it at a skill's directory, or at a directory of skills.`);
+	const dirs = existsSync(join(dir, "SKILL.md")) ? [dir] : readdirSync(dir, { withFileTypes: true }).filter((e) => e.isDirectory() && existsSync(join(dir, e.name, "SKILL.md"))).map((e) => join(dir, e.name)).sort();
+	if (dirs.length === 0) throw new InfraError(`Skill source ${source} has no SKILL.md (and no subdirectories with one)`);
+	const skills = dirs.map((d) => parseSkill(d, source, exclude));
+	if (!only) return skills;
+	const missing = only.filter((n) => !skills.some((s) => s.skill.name === n));
+	if (missing.length) throw new InfraError(`only: ${JSON.stringify(missing)} not found in ${source} (found: ${skills.map((s) => s.skill.name).join(", ")})`);
+	return skills.filter((s) => only.includes(s.skill.name));
+}
+async function git(args, cwd, what) {
+	const r = await run("git", args, { cwd });
+	if (r.exitCode !== 0) throw new InfraError(`${what} failed: ${r.stderr.trim()}`);
+	return r.stdout.trim();
+}
+/** One clone per source and ref per worker process; the commit is recorded. */
+const clones = /* @__PURE__ */ new Map();
+/** A clone checks out the committed bytes, whatever the host's line-ending settings. */
+const AS_COMMITTED = [
+	"-c",
+	"core.autocrlf=false",
+	"-c",
+	"core.eol=lf"
+];
+function cloneSkills(root, url, ref) {
+	const key = `${url}#${ref ?? ""}`;
+	let clone = clones.get(key);
+	if (!clone) {
+		clone = (async () => {
+			const dir = join(root, ".reeval", "cache", "skills", `${sha256(key).slice(0, 16)}-${process.pid}`);
+			await rm(dir, {
+				recursive: true,
+				force: true
+			});
+			await mkdir(dir, { recursive: true });
+			const what = `Cloning ${url}${ref ? ` at ${ref}` : ""}`;
+			await git(["init", "-q"], dir, what);
+			await git([
+				...AS_COMMITTED,
+				"fetch",
+				"-q",
+				"--depth",
+				"1",
+				"--end-of-options",
+				url,
+				ref ?? "HEAD"
+			], dir, what);
+			await git([
+				...AS_COMMITTED,
+				"-c",
+				"advice.detachedHead=false",
+				"checkout",
+				"-q",
+				"FETCH_HEAD"
+			], dir, what);
+			return {
+				dir,
+				commit: await git(["rev-parse", "HEAD"], dir, what)
+			};
+		})();
+		clones.set(key, clone);
+		clone.catch(() => clones.delete(key));
+	}
+	return clone;
+}
+const packs = /* @__PURE__ */ new Map();
+/** `npm pack` into the cache, unpacked; returns the package directory. */
+function unpackNpm(root, spec) {
+	let pack = packs.get(spec);
+	if (!pack) {
+		pack = (async () => {
+			const dir = join(root, ".reeval", "cache", "skills", `npm-${sha256(spec).slice(0, 16)}-${process.pid}`);
+			await rm(dir, {
+				recursive: true,
+				force: true
+			});
+			await mkdir(dir, { recursive: true });
+			const packed = await run("npm", [
+				"pack",
+				spec,
+				"--silent",
+				"--pack-destination",
+				dir
+			], { cwd: dir });
+			const tarball = packed.stdout.trim().split("\n").at(-1);
+			if (packed.exitCode !== 0 || !tarball) throw new InfraError(`npm pack ${spec} failed: ${packed.stderr.trim()}`);
+			const untar = await run("tar", ["-xzf", tarball], { cwd: dir });
+			if (untar.exitCode !== 0) throw new InfraError(`Unpacking ${spec} failed: ${untar.stderr.trim()}`);
+			return join(dir, "package");
+		})();
+		packs.set(spec, pack);
+		pack.catch(() => packs.delete(spec));
+	}
+	return pack;
+}
+async function resolveSkills(root, s) {
+	switch (s.source) {
+		case "local": {
+			const label = `local:${relative(root, s.path).split(sep).join("/") || "."}`;
+			return {
+				skills: loadSkills(s.path, label, s.only, s.exclude),
+				source: label,
+				commit: null
+			};
+		}
+		case "git": {
+			const { url } = parseGitRepo(s.repo);
+			const { dir, commit } = await cloneSkills(root, url, s.ref);
+			const path = s.path ?? (!existsSync(join(dir, "SKILL.md")) && existsSync(join(dir, "skills")) ? "skills" : "");
+			const label = `${s.repo}${s.ref ? `#${s.ref}` : ""}${path ? `:${path}` : ""}`;
+			return {
+				skills: loadSkills(join(dir, path), label, s.only, s.exclude),
+				source: label,
+				commit
+			};
+		}
+		case "registry": {
+			const [repo = "", name = ""] = s.id.split("@");
+			const { dir, commit } = await cloneSkills(root, `https://github.com/${repo}.git`, s.version);
+			const label = `registry:${s.id}${s.version ? `#${s.version}` : ""}`;
+			return {
+				skills: loadSkills(existsSync(join(dir, "skills")) ? join(dir, "skills") : dir, label, [name]),
+				source: label,
+				commit
+			};
+		}
+		case "npm": {
+			const dir = await unpackNpm(root, s.spec);
+			const label = `npm:${isAbsolute(s.spec) ? relative(root, s.spec).split(sep).join("/") : s.spec}:${s.path}`;
+			return {
+				skills: loadSkills(join(dir, s.path), label, s.only, s.exclude),
+				source: label,
+				commit: null
+			};
+		}
+		case "inline": {
+			checkSkill(s.name, s.description, "skill.inline");
+			const files = Object.entries(s.files).sort(([a], [b]) => a < b ? -1 : 1).map(([path, content]) => ({
+				path,
+				content
+			}));
+			return {
+				skills: [{
+					skill: {
+						name: s.name,
+						description: s.description,
+						content: s.content,
+						files
+					},
+					excluded: []
+				}],
+				source: "inline",
+				commit: null
+			};
+		}
+	}
+}
+/** A marketplace entry's source: the marketplace itself for a `./` entry, else the entry's own. */
+async function entrySourceDir(root, p) {
+	const m = p.marketplace;
+	const label = marketplaceLabel(m, root);
+	const fetched = m.source === "git" ? await cloneSkills(root, parseGitRepo(m.repo).url, m.ref) : {
+		dir: await unpackNpm(root, m.spec),
+		commit: null
+	};
+	const { marketplace: name, entry } = readMarketplace(fetched.dir, pluginCall(p, root), label, p.name, localMarketplace(m));
+	const marketplace = {
+		name,
+		source: label,
+		commit: fetched.commit
+	};
+	switch (entry.source) {
+		case "path": return {
+			context: fetched.dir,
+			path: entry.path || ".",
+			commit: fetched.commit,
+			source: entry.path ? `${label}:${entry.path}` : label,
+			marketplace
+		};
+		case "git": {
+			const clone = await cloneSkills(root, entry.url, entry.ref);
+			if (entry.path && leavesSource(clone.dir, entry.path)) throw new PluginProblem(`the ${name} marketplace's entry "${p.name}" has path ${entry.path}, which leaves ${entry.repo} through a symlink`);
+			return {
+				context: clone.dir,
+				path: entry.path ?? ".",
+				commit: clone.commit,
+				source: `${entry.repo}${entry.ref ? `#${entry.ref}` : ""}${entry.path ? `:${entry.path}` : ""}`,
+				marketplace
+			};
+		}
+		case "npm": return {
+			context: await unpackNpm(root, entry.spec),
+			path: ".",
+			commit: null,
+			source: `npm:${entry.spec}`,
+			marketplace
+		};
+	}
+}
+/**
+* A plugin's whole source on the host, fetched once per process: the repository at its commit,
+* the unpacked package, or the local directory, with the plugin's `path` in it (`.` for the root).
+* A marketplace entry's is its marketplace's for a `./` entry, else the entry's own source.
+*/
+async function pluginSourceDir(root, p) {
+	const labelled = {
+		source: pluginSourceLabel(p, root),
+		marketplace: null
+	};
+	switch (p.source) {
+		case "local": return {
+			context: p.path,
+			path: ".",
+			commit: null,
+			...labelled
+		};
+		case "git": {
+			const clone = await cloneSkills(root, parseGitRepo(p.repo).url, p.ref);
+			return {
+				context: clone.dir,
+				path: p.path ?? ".",
+				commit: clone.commit,
+				...labelled
+			};
+		}
+		case "npm": return {
+			context: await unpackNpm(root, p.spec),
+			path: p.path ?? ".",
+			commit: null,
+			...labelled
+		};
+		case "marketplace": return entrySourceDir(root, p);
+	}
+}
+async function resolvePlugin(root, p, where) {
+	try {
+		const { context, path, commit, source, marketplace } = await pluginSourceDir(root, p);
+		return {
+			contents: readPlugin(join(context, path), pluginCall(p, root), p.only),
+			declared: p,
+			source,
+			commit,
+			marketplace
+		};
+	} catch (error) {
+		if (error instanceof PluginProblem) throw new InfraError(`${where}: ${error.message}`);
+		throw error;
+	}
+}
+const skillHash = (s) => sha256(JSON.stringify(s));
+const readHostFile = (f, where) => {
+	if (!existsSync(f.path)) throw new InfraError(`${f.path} for ${where} doesn't exist. file() paths resolve against the file that calls it, or reeval.yaml's directory.`);
+	return readFileSync(f.path);
+};
+/**
+* Layers the environment (root first; a later layer wins on shared keys, and each such key is
+* an override), over the options `env` merged down the cascade. `where` names the attempt, and
+* `rulesFile` is the workspace file the harness's agent reads `rules` from.
+*/
+async function resolveEnvironment(environment, optionsEnv, root, where, rulesFile, egress = "allow-all", prepared = () => void 0, options = {}) {
+	const envWhere = `environment ${environment.name} (${where})`;
+	const overrides = /* @__PURE__ */ new Set();
+	const env = { ...optionsEnv };
+	const files = /* @__PURE__ */ new Map();
+	const mcp = /* @__PURE__ */ new Map();
+	const skills = /* @__PURE__ */ new Map();
+	const plugins = /* @__PURE__ */ new Map();
+	let rules;
+	const setup = [];
+	const seen = {
+		env: /* @__PURE__ */ new Set(),
+		files: /* @__PURE__ */ new Set(),
+		mcp: /* @__PURE__ */ new Set()
+	};
+	let egressSet = false;
+	let workspace;
+	let sandboxSet = false;
+	for (const layer of environment.layers) {
+		const { spec } = layer;
+		if (spec.sandbox !== void 0) {
+			if (sandboxSet) overrides.add("sandbox");
+			sandboxSet = true;
+		}
+		if (spec.workspace !== void 0) {
+			if (workspace) overrides.add("workspace");
+			workspace = spec.workspace;
+		}
+		if (spec.egress !== void 0) {
+			if (egressSet) overrides.add("egress");
+			egressSet = true;
+		}
+		for (const [k, v] of Object.entries(spec.env ?? {})) {
+			if (seen.env.has(k)) overrides.add(`env.${k}`);
+			seen.env.add(k);
+			env[k] = v;
+		}
+		for (const [path, v] of Object.entries(spec.files ?? {})) {
+			if (seen.files.has(path)) overrides.add(`files.${path}`);
+			seen.files.add(path);
+			files.set(path, v);
+		}
+		if (spec.rules !== void 0) {
+			if (rules !== void 0) overrides.add("rules");
+			rules = spec.rules;
+		}
+		for (const [name, server] of Object.entries(spec.mcp ?? {})) {
+			if (seen.mcp.has(name)) overrides.add(`mcp.${name}`);
+			seen.mcp.add(name);
+			mcp.set(name, server);
+		}
+		for (const step of spec.setup ?? []) {
+			const s = typeof step === "string" ? { run: step } : step;
+			setup.push({
+				run: s.run,
+				timeoutMs: parseDuration(s.timeout ?? DEFAULT_SETUP_TIMEOUT),
+				...s.cwd ? { cwd: s.cwd } : {}
+			});
+		}
+		const layerSkills = /* @__PURE__ */ new Set();
+		for (const source of spec.skills ?? []) {
+			const found = await resolveSkills(root, source);
+			for (const loaded of found.skills) {
+				const name = loaded.skill.name;
+				if (skills.has(name) && !layerSkills.has(name)) overrides.add(`skills.${name}`);
+				layerSkills.add(name);
+				skills.delete(name);
+				skills.set(name, {
+					...loaded,
+					placement: source.placement,
+					source: found.source,
+					commit: found.commit,
+					call: skillCall(source, root)
+				});
+			}
+		}
+		const layerPlugins = /* @__PURE__ */ new Map();
+		for (const source of spec.plugins ?? []) {
+			const found = await resolvePlugin(root, source, envWhere);
+			const { name, call } = found.contents;
+			const first = layerPlugins.get(name);
+			if (first) throw new InfraError(`${envWhere}: ${samePluginTwice(layer.name, name, first, call)}`);
+			if (plugins.has(name)) overrides.add(`plugins.${name}`);
+			layerPlugins.set(name, call);
+			plugins.delete(name);
+			plugins.set(name, found);
+		}
+	}
+	const pluginList = [...plugins.values()];
+	const harness = options.harness ?? { kind: "fake" };
+	const refused = refusedPlugins(harness, pluginList.map((p) => p.contents), {
+		skills: [...skills.values()].filter((s) => s.placement === "harness").map((s) => ({
+			name: s.skill.name,
+			call: s.call
+		})),
+		mcp: [...mcp.keys()]
+	});
+	if (refused) throw new InfraError(`${envWhere}: ${refused}`);
+	const allowed = options.allowed ?? null;
+	const fetches = fetchesAtStart(pluginList.map((p) => p.contents), allowed);
+	if (fetches.refusal) throw new InfraError(`${envWhere}: ${fetches.refusal}`);
+	const pluginSkills = [];
+	const resolvedPlugins = [];
+	const pluginRecords = [];
+	for (const { contents: p, declared, source, commit, marketplace } of pluginList) {
+		const loaded = p.skills.length ? loadSkills(join(p.dir, "skills"), source, p.skills.map((s) => s.name)) : [];
+		for (const l of loaded) pluginSkills.push({
+			...l,
+			plugin: p.name,
+			source,
+			commit
+		});
+		const servers = [];
+		for (const [name, server] of Object.entries(p.mcp)) {
+			if (allowed && server.transport !== "stdio") {
+				const host = new URL(server.url).hostname;
+				if (!hostAllowed(allowed, host)) throw new InfraError(`${envWhere}: the ${p.name} plugin's MCP server "${name}" is at ${host}, which egress doesn't allow: add it to egress.allow`);
+			}
+			const key = pluginServerName(p.name, name);
+			mcp.set(key, server);
+			servers.push(key);
+		}
+		const files = pluginFiles(p);
+		resolvedPlugins.push({
+			name: p.name,
+			files,
+			parts: p.kept,
+			servers,
+			declared,
+			commit
+		});
+		pluginRecords.push({
+			name: p.name,
+			source,
+			marketplace,
+			commit,
+			sha256: sha256(JSON.stringify(files.map((f) => [f.path, sha256(f.content)]))),
+			build: null,
+			parts: pluginParts(p, loaded.map((l) => l.skill.name))
+		});
+	}
+	const secrets = {
+		names: [],
+		checks: [],
+		unset: [],
+		brokered: []
+	};
+	const vars = {};
+	const checkVars = {};
+	for (const [name, value] of Object.entries(env)) {
+		if (!isSecret(value)) {
+			vars[name] = value;
+			continue;
+		}
+		const resolved = hostValue(name, value, envWhere, secrets);
+		if (resolved === void 0) continue;
+		if (value.to === "checks") checkVars[name] = resolved;
+		else vars[name] = resolved;
+	}
+	const secretOf = (value, key, hosts) => {
+		if (typeof value === "string") return value;
+		if (isSecretTemplate(value)) return template(value, envWhere, secrets, hosts);
+		return hostValue(key, value, envWhere, secrets, value.hosts ?? hosts);
+	};
+	const resolvedMcp = {};
+	for (const [name, s] of mcp) if (s.transport === "stdio") {
+		const e = {};
+		for (const [k, v] of Object.entries(s.env)) {
+			const r = secretOf(v, k);
+			if (r !== void 0) e[k] = r;
+		}
+		resolvedMcp[name] = {
+			transport: "stdio",
+			command: s.command,
+			args: s.args,
+			env: e
+		};
+	} else {
+		const h = {};
+		const hosts = mcpHosts(s.url);
+		for (const [k, v] of Object.entries(s.headers)) {
+			const r = secretOf(v, k, hosts);
+			if (r !== void 0) h[k] = r;
+		}
+		resolvedMcp[name] = {
+			transport: s.transport,
+			url: s.url,
+			headers: h
+		};
+	}
+	const fileList = [...files].map(([path, v]) => ({
+		path,
+		content: isHostFile(v) ? readHostFile(v, envWhere) : v,
+		...isHostFile(v) && statSync(v.path).mode & 64 ? { executable: true } : {}
+	}));
+	const rulesContent = rules === void 0 ? void 0 : isHostFile(rules) ? Buffer.from(readHostFile(rules, envWhere)).toString("utf8") : rules;
+	const skillList = [...skills.values()];
+	const skillRecords = [...skillList.map(({ skill, placement, source, commit, excluded }) => ({
+		name: skill.name,
+		source,
+		commit,
+		sha256: skillHash(skill),
+		placement,
+		excluded
+	})), ...pluginSkills.map(({ skill, source, commit, excluded, plugin }) => ({
+		name: skill.name,
+		source,
+		commit,
+		sha256: skillHash(skill),
+		placement: "harness",
+		excluded,
+		plugin
+	}))];
+	const fileRecords = fileList.map((f) => ({
+		path: f.path,
+		sha256: sha256(f.content)
+	}));
+	const executable = fileList.flatMap((f) => f.executable ? [f.path] : []);
+	const rulesRecord = rulesContent === void 0 ? void 0 : {
+		path: rulesFile,
+		sha256: sha256(rulesContent)
+	};
+	if (rulesContent !== void 0) fileList.push({
+		path: rulesFile,
+		content: rulesContent
+	});
+	const secretNames = [.../* @__PURE__ */ new Set([...secrets.names, ...secrets.checks])].sort();
+	const brokered = secrets.brokered.map((b) => JSON.stringify([
+		b.name,
+		b.hosts,
+		b.in,
+		b.phase
+	])).sort();
+	const brokeredNames = [...new Set(secrets.brokered.map((b) => b.name))].sort();
+	const varNames = Object.keys(vars).filter((n) => !secrets.names.includes(n)).sort();
+	const literalVars = Object.fromEntries(varNames.map((n) => [n, vars[n]]));
+	const mcpShape = Object.fromEntries(Object.entries(resolvedMcp).map(([name, s]) => s.transport === "stdio" ? [name, {
+		command: s.command,
+		args: s.args,
+		env: Object.keys(s.env).sort()
+	}] : [name, {
+		transport: s.transport,
+		url: s.url,
+		headers: Object.keys(s.headers).sort()
+	}]));
+	const tree = workspace && prepared(workspace);
+	if (workspace && !tree) throw new InfraError(`The workspace git(${JSON.stringify(workspaceLabel(workspace))}) for ${envWhere} wasn't prepared before the run started`);
+	const workspaceRecord = workspace && tree ? {
+		source: isAbsolute(workspace.url) ? relative(root, workspace.url).split(sep).join("/") || "." : workspace.repo,
+		ref: workspace.ref ?? null,
+		path: workspace.path ?? null,
+		commit: tree.commit,
+		tree: tree.tree,
+		...workspace.init ? { init: true } : {}
+	} : void 0;
+	const digest = `sha256:${sha256(JSON.stringify({
+		setup,
+		skills: skillRecords.map((s) => [
+			s.name,
+			s.sha256,
+			s.placement
+		]),
+		mcp: mcpShape,
+		files: fileRecords,
+		...executable.length ? { executable } : {},
+		rules: rulesRecord?.sha256,
+		vars: literalVars,
+		secrets: secretNames,
+		checks: [...secrets.checks].sort(),
+		unset: [...secrets.unset].sort(),
+		brokered,
+		...egress === "allow-all" ? {} : { egress: typeof egress === "string" ? egress : [...egress.allow].sort() },
+		...pluginRecords.length ? { plugins: pluginRecords.map((p, i) => {
+			const r = resolvedPlugins[i];
+			const build = r?.declared.build;
+			return [
+				p.name,
+				p.sha256,
+				r?.parts,
+				...build === void 0 ? [] : [build]
+			];
+		}) } : {},
+		...workspaceRecord ? { workspace: workspaceRecord.init ? [workspaceRecord.tree, "init"] : workspaceRecord.tree } : {}
+	}))}`;
+	return {
+		record: {
+			name: environment.name,
+			parent: environment.parent,
+			overrides: [...overrides],
+			digest,
+			setup: setup.map(stepCommand),
+			skills: skillRecords,
+			mcp: Object.keys(resolvedMcp).sort(),
+			...pluginRecords.length ? { plugins: pluginRecords } : {},
+			files: rulesRecord ? [...fileRecords, rulesRecord] : fileRecords,
+			vars: varNames,
+			secrets: secretNames,
+			brokered: brokeredNames,
+			unset: [...secrets.unset].sort(),
+			egress,
+			...workspaceRecord ? { workspace: workspaceRecord } : {}
+		},
+		setup,
+		skills: [...skillList.filter((s) => s.placement === "harness").map((s) => s.skill), ...layoutOf(harness).pluginPlacement === "flat" ? pluginSkills.map((s) => s.skill) : []],
+		workspaceSkills: skillList.filter((s) => s.placement === "workspace").map((s) => s.skill),
+		mcp: resolvedMcp,
+		files: fileList,
+		vars,
+		checkVars,
+		substitutions: secrets.brokered,
+		plugins: resolvedPlugins,
+		...workspace && tree ? { workspace: {
+			tar: tree.tar,
+			label: workspaceLabel(workspace),
+			commit: tree.commit,
+			...workspace.init ? { init: true } : {}
+		} } : {}
+	};
+}
+/** A skill as a `SKILL.md` file plus its other files, for writing into a directory. */
+function skillFiles(skill) {
+	return [{
+		path: "SKILL.md",
+		content: `${`---\nname: ${skill.name}\ndescription: ${JSON.stringify(skill.description)}\n---\n`}${skill.content}`
+	}, ...skill.files];
+}
+//#endregion
+export { skillFiles as a, resolveEnvironment as i, parseSkillMd as n, pluginSourceDir as r, excludeMatcher as t };
+
+//# sourceMappingURL=resolve-DzdWcIL6.js.map