@fased/fased 0.1.61 → 0.1.64

package/dist/agents/pi-project-settings.js

@@ -1,6 +1,6 @@
 import { applyMergePatch } from "../config/merge-patch.js";
 import { applyPiCompactionSettingsFromConfig } from "./pi-settings.js";
-import fs from "node:fs";
+import syncFs from "node:fs";
 import path from "node:path";
 import { SettingsManager } from "@mariozechner/pi-coding-agent";
 
@@ -28,7 +28,7 @@ function buildEmbeddedPiSettingsSnapshot(params) {
 }
 function readJsonFile(filePath) {
 	try {
-		const raw = fs.readFileSync(filePath, "utf8");
+		const raw = syncFs.readFileSync(filePath, "utf8");
 		const parsed = JSON.parse(raw);
 		return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
 	} catch {
@@ -49,7 +49,7 @@ function loadEnabledBundlePiSettingsSnapshot(params) {
 			const servers = mcp.mcpServers && typeof mcp.mcpServers === "object" && !Array.isArray(mcp.mcpServers) ? mcp.mcpServers : undefined;
 			if (servers) {
 				const resolvedServers = {};
-				const resolvedRoot = fs.realpathSync.native?.(pluginRoot) ?? fs.realpathSync(pluginRoot);
+				const resolvedRoot = syncFs.realpathSync.native?.(pluginRoot) ?? syncFs.realpathSync(pluginRoot);
 				for (const [name, server] of Object.entries(servers)) {
 					if (!server || typeof server !== "object" || Array.isArray(server)) {
 						resolvedServers[name] = server;

package/dist/agents/pi-tool-definition-adapter.js

@@ -41,6 +41,20 @@ function stringifyToolPayload(payload) {
 	} catch {}
 	return String(payload);
 }
+function normalizeClientToolParams(params) {
+	if (isPlainObject(params)) {
+		return params;
+	}
+	if (typeof params !== "string") {
+		return {};
+	}
+	try {
+		const parsed = JSON.parse(params.trim());
+		return isPlainObject(parsed) ? parsed : {};
+	} catch {
+		return {};
+	}
+}
 function normalizeToolExecutionResult(params) {
 	const { toolName, result } = params;
 	if (result && typeof result === "object") {
@@ -185,9 +199,10 @@ function toClientToolDefinitions(tools, onClientToolCall, hookContext) {
 			parameters: func.parameters,
 			execute: async (...args) => {
 				const { toolCallId, params } = splitToolExecuteArgs(args);
+				const normalizedParams = normalizeClientToolParams(params);
 				const outcome = await runBeforeToolCallHook({
 					toolName: func.name,
-					params,
+					params: normalizedParams,
 					toolCallId,
 					ctx: hookContext
 				});

package/dist/agents/pi-tools.js

@@ -332,7 +332,8 @@ function createFasedAgentCodingTools(options) {
 			senderIsOwner: options?.senderIsOwner
 		})
 	];
-	const toolsForMessageProvider = applyMessageProviderToolPolicy(tools, options?.messageProvider);
+	const provenanceSafeTools = options?.untrustedSkillContent ? tools.filter((tool) => tool.name === "read") : tools;
+	const toolsForMessageProvider = applyMessageProviderToolPolicy(provenanceSafeTools, options?.messageProvider);
 	const senderIsOwner = options?.senderIsOwner === true;
 	const toolsByAuthorization = applyOwnerOnlyToolPolicy(toolsForMessageProvider, senderIsOwner);
 	const subagentFiltered = applyToolPolicyPipeline({

package/dist/agents/sandbox/config.js

@@ -34,7 +34,7 @@ function resolveSandboxScope(params) {
 	if (typeof params.perSession === "boolean") {
 		return params.perSession ? "session" : "shared";
 	}
-	return "agent";
+	return "session";
 }
 function resolveSandboxDockerConfig(params) {
 	const agentDocker = params.scope === "shared" ? undefined : params.agentDocker;

package/dist/agents/sandbox/context.js

@@ -80,10 +80,35 @@ function resolveSandboxSession(params) {
 		cfg: params.config,
 		sessionKey: rawSessionKey
 	});
-	if (!runtime.sandboxed) {
+	if (!runtime.sandboxed && !params.forceUntrustedIsolation) {
 		return null;
 	}
-	const cfg = resolveSandboxConfigForAgent(params.config, runtime.agentId);
+	const resolvedConfig = resolveSandboxConfigForAgent(params.config, runtime.agentId);
+	const cfg = params.forceUntrustedIsolation ? {
+		...resolvedConfig,
+		mode: "all",
+		scope: "session",
+		workspaceAccess: "none",
+		docker: {
+			...resolvedConfig.docker,
+			readOnlyRoot: true,
+			network: "none",
+			capDrop: ["ALL"],
+			binds: undefined,
+			dangerouslyAllowReservedContainerTargets: false,
+			dangerouslyAllowExternalBindSources: false,
+			dangerouslyAllowContainerNamespaceJoin: false
+		},
+		browser: {
+			...resolvedConfig.browser,
+			enabled: false,
+			allowHostControl: false
+		},
+		tools: {
+			allow: ["read"],
+			deny: []
+		}
+	} : resolvedConfig;
 	return {
 		rawSessionKey,
 		runtime,

package/dist/agents/sandbox/fs-bridge.js

@@ -3,7 +3,7 @@ import { PATH_ALIAS_POLICIES } from "../../infra/path-alias-guards.js";
 import { execDockerRaw } from "./docker.js";
 import { isPathInsideContainerRoot, normalizeContainerPath } from "./path-utils.js";
 import { buildSandboxFsMounts, resolveSandboxFsPathWithMounts } from "./fs-paths.js";
-import fs from "node:fs";
+import syncFs from "node:fs";
 
 //#region src/agents/sandbox/fs-bridge.ts
 function createSandboxFsBridge(params) {
@@ -160,7 +160,7 @@ var SandboxFsBridgeImpl = class {
 				throw guarded.error instanceof Error ? guarded.error : new Error(`Sandbox boundary checks failed; cannot ${options.action}: ${target.containerPath}`);
 			}
 		} else {
-			fs.closeSync(guarded.fd);
+			syncFs.closeSync(guarded.fd);
 		}
 		const canonicalContainerPath = await this.resolveCanonicalContainerPath({
 			containerPath: target.containerPath,

package/dist/agents/session-dirs.js

@@ -1,6 +1,6 @@
-import fs from "node:fs";
+import syncFs from "node:fs";
 import path from "node:path";
-import fs$1 from "node:fs/promises";
+import fs from "node:fs/promises";
 
 //#region src/agents/session-dirs.ts
 function mapAgentSessionDirs(agentsDir, entries) {
@@ -9,7 +9,7 @@ function mapAgentSessionDirs(agentsDir, entries) {
 async function resolveAgentSessionDirsFromAgentsDir(agentsDir) {
 	let entries = [];
 	try {
-		entries = await fs$1.readdir(agentsDir, { withFileTypes: true });
+		entries = await fs.readdir(agentsDir, { withFileTypes: true });
 	} catch (err) {
 		const code = err.code;
 		if (code === "ENOENT") {
@@ -22,7 +22,7 @@ async function resolveAgentSessionDirsFromAgentsDir(agentsDir) {
 function resolveAgentSessionDirsFromAgentsDirSync(agentsDir) {
 	let entries = [];
 	try {
-		entries = fs.readdirSync(agentsDir, { withFileTypes: true });
+		entries = syncFs.readdirSync(agentsDir, { withFileTypes: true });
 	} catch (err) {
 		const code = err.code;
 		if (code === "ENOENT") {

package/dist/agents/session-write-lock.js

@@ -1,8 +1,8 @@
 import { isPidAlive } from "../shared/pid-alive.js";
 import { resolveProcessScopedMap } from "../shared/process-scoped-map.js";
-import fs from "node:fs";
+import syncFs from "node:fs";
 import path from "node:path";
-import fs$1 from "node:fs/promises";
+import fs from "node:fs/promises";
 
 //#region src/agents/session-write-lock.ts
 const CLEANUP_SIGNALS = [
@@ -84,7 +84,7 @@ async function releaseHeldLock(normalizedSessionFile, held, opts = {}) {
 			await held.handle.close();
 		} catch {}
 		try {
-			await fs$1.rm(held.lockPath, { force: true });
+			await fs.rm(held.lockPath, { force: true });
 		} catch {}
 	})();
 	try {
@@ -106,7 +106,7 @@ function releaseAllLocksSync() {
 			}
 		} catch {}
 		try {
-			fs.rmSync(held.lockPath, { force: true });
+			syncFs.rmSync(held.lockPath, { force: true });
 		} catch {}
 		HELD_LOCKS.delete(sessionFile);
 	}
@@ -175,7 +175,7 @@ function registerCleanupHandlers() {
 }
 async function readLockPayload(lockPath) {
 	try {
-		const raw = await fs$1.readFile(lockPath, "utf8");
+		const raw = await fs.readFile(lockPath, "utf8");
 		const parsed = JSON.parse(raw);
 		const payload = {};
 		if (typeof parsed.pid === "number") {
@@ -226,7 +226,7 @@ async function shouldReclaimContendedLockFile(lockPath, details, staleMs, nowMs)
 		return true;
 	}
 	try {
-		const stat = await fs$1.stat(lockPath);
+		const stat = await fs.stat(lockPath);
 		const ageMs = Math.max(0, nowMs - stat.mtimeMs);
 		return ageMs > staleMs;
 	} catch (error) {
@@ -241,7 +241,7 @@ async function cleanStaleLockFiles(params) {
 	const nowMs = params.nowMs ?? Date.now();
 	let entries = [];
 	try {
-		entries = await fs$1.readdir(sessionsDir, { withFileTypes: true });
+		entries = await fs.readdir(sessionsDir, { withFileTypes: true });
 	} catch (err) {
 		const code = err.code;
 		if (code === "ENOENT") {
@@ -265,7 +265,7 @@ async function cleanStaleLockFiles(params) {
 			removed: false
 		};
 		if (lockInfo.stale && removeStale) {
-			await fs$1.rm(lockPath, { force: true });
+			await fs.rm(lockPath, { force: true });
 			lockInfo.removed = true;
 			cleaned.push(lockInfo);
 			params.log?.warn?.(`removed stale session lock: ${lockPath} (${lockInfo.staleReasons.join(", ") || "unknown"})`);
@@ -284,10 +284,10 @@ async function acquireSessionWriteLock(params) {
 	const maxHoldMs = resolvePositiveMs(params.maxHoldMs, DEFAULT_MAX_HOLD_MS);
 	const sessionFile = path.resolve(params.sessionFile);
 	const sessionDir = path.dirname(sessionFile);
-	await fs$1.mkdir(sessionDir, { recursive: true });
+	await fs.mkdir(sessionDir, { recursive: true });
 	let normalizedDir = sessionDir;
 	try {
-		normalizedDir = await fs$1.realpath(sessionDir);
+		normalizedDir = await fs.realpath(sessionDir);
 	} catch {}
 	const normalizedSessionFile = path.join(normalizedDir, path.basename(sessionFile));
 	const lockPath = `${normalizedSessionFile}.lock`;
@@ -305,7 +305,7 @@ async function acquireSessionWriteLock(params) {
 		attempt += 1;
 		let handle = null;
 		try {
-			handle = await fs$1.open(lockPath, "wx");
+			handle = await fs.open(lockPath, "wx");
 			const createdAt = new Date().toISOString();
 			await handle.writeFile(JSON.stringify({
 				pid: process.pid,
@@ -328,7 +328,7 @@ async function acquireSessionWriteLock(params) {
 					await handle.close();
 				} catch {}
 				try {
-					await fs$1.rm(lockPath, { force: true });
+					await fs.rm(lockPath, { force: true });
 				} catch {}
 			}
 			const code = err.code;
@@ -339,7 +339,7 @@ async function acquireSessionWriteLock(params) {
 			const nowMs = Date.now();
 			const inspected = inspectLockPayload(payload, staleMs, nowMs);
 			if (await shouldReclaimContendedLockFile(lockPath, inspected, staleMs, nowMs)) {
-				await fs$1.rm(lockPath, { force: true });
+				await fs.rm(lockPath, { force: true });
 				continue;
 			}
 			const delay = Math.min(1e3, 50 * attempt);

package/dist/agents/shell-utils.js

@@ -1,4 +1,4 @@
-import fs from "node:fs";
+import syncFs from "node:fs";
 import path from "node:path";
 import { spawn } from "node:child_process";
 
@@ -6,13 +6,13 @@ import { spawn } from "node:child_process";
 function resolvePowerShellPath() {
 	const programFiles = process.env.ProgramFiles || process.env.PROGRAMFILES || "C:\\Program Files";
 	const pwsh7 = path.join(programFiles, "PowerShell", "7", "pwsh.exe");
-	if (fs.existsSync(pwsh7)) {
+	if (syncFs.existsSync(pwsh7)) {
 		return pwsh7;
 	}
 	const programW6432 = process.env.ProgramW6432;
 	if (programW6432 && programW6432 !== programFiles) {
 		const pwsh7Alt = path.join(programW6432, "PowerShell", "7", "pwsh.exe");
-		if (fs.existsSync(pwsh7Alt)) {
+		if (syncFs.existsSync(pwsh7Alt)) {
 			return pwsh7Alt;
 		}
 	}
@@ -23,7 +23,7 @@ function resolvePowerShellPath() {
 	const systemRoot = process.env.SystemRoot || process.env.WINDIR;
 	if (systemRoot) {
 		const candidate = path.join(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
-		if (fs.existsSync(candidate)) {
+		if (syncFs.existsSync(candidate)) {
 			return candidate;
 		}
 	}
@@ -73,7 +73,7 @@ function resolveShellFromPath(name) {
 	for (const entry of entries) {
 		const candidate = path.join(entry, name);
 		try {
-			fs.accessSync(candidate, fs.constants.X_OK);
+			syncFs.accessSync(candidate, syncFs.constants.X_OK);
 			return candidate;
 		} catch {}
 	}

package/dist/agents/skills/bundled-dir.js

@@ -1,12 +1,12 @@
 import { resolveFasedAgentPackageRootSync } from "../../infra/fased-root.js";
 import { fileURLToPath } from "node:url";
-import fs from "node:fs";
+import syncFs from "node:fs";
 import path from "node:path";
 
 //#region src/agents/skills/bundled-dir.ts
 function looksLikeSkillsDir(dir) {
 	try {
-		const entries = fs.readdirSync(dir, { withFileTypes: true });
+		const entries = syncFs.readdirSync(dir, { withFileTypes: true });
 		for (const entry of entries) {
 			if (entry.name.startsWith(".")) {
 				continue;
@@ -16,7 +16,7 @@ function looksLikeSkillsDir(dir) {
 				return true;
 			}
 			if (entry.isDirectory()) {
-				if (fs.existsSync(path.join(fullPath, "SKILL.md"))) {
+				if (syncFs.existsSync(path.join(fullPath, "SKILL.md"))) {
 					return true;
 				}
 			}
@@ -35,7 +35,7 @@ function resolveBundledSkillsDir(opts = {}) {
 		const execPath = opts.execPath ?? process.execPath;
 		const execDir = path.dirname(execPath);
 		const sibling = path.join(execDir, "skills");
-		if (fs.existsSync(sibling)) {
+		if (syncFs.existsSync(sibling)) {
 			return sibling;
 		}
 	} catch {}

package/dist/agents/skills/env-overrides.js

@@ -1,14 +1,22 @@
 import { createSubsystemLogger } from "../../logging/subsystem.js";
 import { isDangerousHostEnvVarName } from "../../infra/host-env-security.js";
+import { getRuntimeConfigSnapshot } from "../../config/io.js";
+import "../../config/config.js";
+import { isMarketplaceSkillDir } from "./trust.js";
+import { sanitizeEnvVars, validateEnvVarValue } from "../sandbox/sanitize-env-vars.js";
 import { resolveSkillKey } from "./frontmatter.js";
 import { resolveSkillConfig } from "./config.js";
-import { sanitizeEnvVars, validateEnvVarValue } from "../sandbox/sanitize-env-vars.js";
+import { AsyncLocalStorage } from "node:async_hooks";
 
 //#region src/agents/skills/env-overrides.ts
 const log = createSubsystemLogger("env-overrides");
-const activeSkillEnvKeys = new Set();
+const skillEnvStorage = new AsyncLocalStorage();
 function getActiveSkillEnvKeys() {
-	return activeSkillEnvKeys;
+	return new Set(Object.keys(skillEnvStorage.getStore() ?? {}));
+}
+/** Trusted, invocation-scoped env consumed by exec without mutating process.env. */
+function getActiveSkillEnvOverrides() {
+	return skillEnvStorage.getStore() ?? {};
 }
 const SKILL_ALWAYS_BLOCKED_ENV_PATTERNS = [/^OPENSSL_CONF$/i];
 function matchesAnyPattern(value, patterns) {
@@ -62,7 +70,7 @@ function sanitizeSkillEnvOverrides(params) {
 	};
 }
 function applySkillConfigEnvOverrides(params) {
-	const { updates, skillConfig, primaryEnv, requiredEnv, skillKey } = params;
+	const { overrides, skillConfig, primaryEnv, requiredEnv, skillKey } = params;
 	const allowedSensitiveKeys = new Set();
 	const normalizedPrimaryEnv = primaryEnv?.trim();
 	if (normalizedPrimaryEnv) {
@@ -104,66 +112,68 @@ function applySkillConfigEnvOverrides(params) {
 		if (process.env[envKey]) {
 			continue;
 		}
-		updates.push({
-			key: envKey,
-			prev: process.env[envKey]
-		});
-		process.env[envKey] = envValue;
-		activeSkillEnvKeys.add(envKey);
+		overrides[envKey] = envValue;
 	}
 }
-function createEnvReverter(updates) {
+function activateSkillEnv(overrides) {
+	const previous = skillEnvStorage.getStore();
+	skillEnvStorage.enterWith(Object.freeze({
+		...previous ?? {},
+		...overrides
+	}));
 	return () => {
-		for (const update of updates) {
-			if (update.prev === undefined) {
-				delete process.env[update.key];
-			} else {
-				process.env[update.key] = update.prev;
-			}
-			activeSkillEnvKeys.delete(update.key);
-		}
+		skillEnvStorage.enterWith(previous ?? Object.freeze({}));
 	};
 }
 function applySkillEnvOverrides(params) {
-	const { skills, config } = params;
-	const updates = [];
+	const skills = params.skills;
+	const config = getRuntimeConfigSnapshot() ?? params.config;
+	const overrides = {};
 	for (const entry of skills) {
+		if (params.excludeMarketplace !== false && isMarketplaceSkillDir(entry.skill.baseDir)) {
+			continue;
+		}
 		const skillKey = resolveSkillKey(entry.skill, entry);
 		const skillConfig = resolveSkillConfig(config, skillKey);
 		if (!skillConfig) {
 			continue;
 		}
 		applySkillConfigEnvOverrides({
-			updates,
+			overrides,
 			skillConfig,
 			primaryEnv: entry.metadata?.primaryEnv,
 			requiredEnv: entry.metadata?.requires?.env,
 			skillKey
 		});
 	}
-	return createEnvReverter(updates);
+	return activateSkillEnv(overrides);
 }
 function applySkillEnvOverridesFromSnapshot(params) {
-	const { snapshot, config } = params;
+	const snapshot = params.snapshot;
+	const config = getRuntimeConfigSnapshot() ?? params.config;
 	if (!snapshot) {
 		return () => {};
 	}
-	const updates = [];
+	const overrides = {};
+	const marketplaceSkills = new Set(params.excludeMarketplace === false ? [] : snapshot.marketplaceSkillIds ?? []);
 	for (const skill of snapshot.skills) {
+		if (marketplaceSkills.has(skill.name)) {
+			continue;
+		}
 		const skillConfig = resolveSkillConfig(config, skill.name);
 		if (!skillConfig) {
 			continue;
 		}
 		applySkillConfigEnvOverrides({
-			updates,
+			overrides,
 			skillConfig,
 			primaryEnv: skill.primaryEnv,
 			requiredEnv: skill.requiredEnv,
 			skillKey: skill.name
 		});
 	}
-	return createEnvReverter(updates);
+	return activateSkillEnv(overrides);
 }
 
 //#endregion
-export { applySkillEnvOverrides, applySkillEnvOverridesFromSnapshot };
+export { applySkillEnvOverrides, applySkillEnvOverridesFromSnapshot, getActiveSkillEnvOverrides };

package/dist/agents/skills/local-loader.js

@@ -1,7 +1,7 @@
 import { openVerifiedFileSync } from "../../infra/safe-open-sync.js";
 import { parseFrontmatter, resolveSkillInvocationPolicy } from "./frontmatter.js";
 import { createSyntheticSourceInfo } from "./skill-contract.js";
-import fs from "node:fs";
+import syncFs from "node:fs";
 import path from "node:path";
 
 //#region src/agents/skills/local-loader.ts
@@ -22,9 +22,9 @@ function readSkillFileSync(params) {
 		if (!isPathWithinRoot(params.rootRealPath, opened.path)) {
 			return null;
 		}
-		return fs.readFileSync(opened.fd, "utf8");
+		return syncFs.readFileSync(opened.fd, "utf8");
 	} finally {
-		fs.closeSync(opened.fd);
+		syncFs.closeSync(opened.fd);
 	}
 }
 function loadSingleSkillDirectory(params) {
@@ -69,7 +69,7 @@ function loadSingleSkillDirectory(params) {
 }
 function listCandidateSkillDirs(dir) {
 	try {
-		return fs.readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules").map((entry) => path.join(dir, entry.name)).sort((left, right) => left.localeCompare(right));
+		return syncFs.readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules").map((entry) => path.join(dir, entry.name)).sort((left, right) => left.localeCompare(right));
 	} catch {
 		return [];
 	}
@@ -78,7 +78,7 @@ function loadSkillsFromDirSafe(params) {
 	const rootDir = path.resolve(params.dir);
 	let rootRealPath;
 	try {
-		rootRealPath = fs.realpathSync(rootDir);
+		rootRealPath = syncFs.realpathSync(rootDir);
 	} catch {
 		return { skills: [] };
 	}
@@ -102,7 +102,7 @@ function loadSkillsFromDirSafe(params) {
 function readSkillFrontmatterSafe(params) {
 	let rootRealPath;
 	try {
-		rootRealPath = fs.realpathSync(path.resolve(params.rootDir));
+		rootRealPath = syncFs.realpathSync(path.resolve(params.rootDir));
 	} catch {
 		return null;
 	}

package/dist/agents/skills/plugin-skills.js

@@ -1,7 +1,7 @@
 import { createSubsystemLogger } from "../../logging/subsystem.js";
 import { normalizePluginsConfig, resolveEffectiveEnableState, resolveMemorySlotDecision } from "../../plugins/config-state.js";
 import { loadPluginManifestRegistry } from "../../plugins/manifest-registry.js";
-import fs from "node:fs";
+import syncFs from "node:fs";
 import path from "node:path";
 
 //#region src/agents/skills/plugin-skills.ts
@@ -58,7 +58,7 @@ function resolvePluginSkillDirs(params) {
 				continue;
 			}
 			const candidate = path.resolve(record.rootDir, trimmed);
-			if (!fs.existsSync(candidate)) {
+			if (!syncFs.existsSync(candidate)) {
 				log.warn(`plugin skill path not found (${record.id}): ${candidate}`);
 				continue;
 			}

package/dist/agents/skills/trust.js

@@ -0,0 +1,93 @@
+import syncFs from "node:fs";
+import path from "node:path";
+import { createHash } from "node:crypto";
+
+//#region src/agents/skills/trust.ts
+const MARKETPLACE_ORIGIN_DIRS = [".clawhub", ".clawdhub"];
+function hasMarketplaceOriginMarker(root) {
+	return MARKETPLACE_ORIGIN_DIRS.some((dir) => syncFs.existsSync(path.join(root, dir, "origin.json")));
+}
+function isTrackedMarketplaceSkill(root) {
+	const skillsDir = path.dirname(root);
+	if (path.basename(skillsDir) !== "skills") {
+		return false;
+	}
+	const slug = path.basename(root);
+	const workspaceDir = path.dirname(skillsDir);
+	for (const directory of MARKETPLACE_ORIGIN_DIRS) {
+		try {
+			const lock = JSON.parse(syncFs.readFileSync(path.join(workspaceDir, directory, "lock.json"), "utf8"));
+			if (lock.version === 1 && lock.skills?.[slug]) {
+				return true;
+			}
+		} catch {}
+	}
+	return false;
+}
+function computeSkillContentSha256Sync(skillDir) {
+	try {
+		const digest = createHash("sha256");
+		const queue = [path.resolve(skillDir)];
+		while (queue.length > 0) {
+			const current = queue.shift();
+			if (!current) {
+				continue;
+			}
+			const entries = syncFs.readdirSync(current, { withFileTypes: true }).toSorted((left, right) => left.name.localeCompare(right.name));
+			for (const entry of entries) {
+				if (entry.name.startsWith(".")) {
+					continue;
+				}
+				const fullPath = path.join(current, entry.name);
+				if (entry.isDirectory() && !entry.isSymbolicLink()) {
+					queue.push(fullPath);
+					continue;
+				}
+				if (!entry.isFile() || entry.isSymbolicLink()) {
+					return null;
+				}
+				digest.update(path.relative(skillDir, fullPath).split(path.sep).join("/"));
+				digest.update("\n");
+				digest.update(syncFs.readFileSync(fullPath));
+				digest.update("\n");
+			}
+		}
+		return digest.digest("hex");
+	} catch {
+		return null;
+	}
+}
+function marketplaceSkillProvenanceMatchesContent(skillDir) {
+	const root = skillDir.trim();
+	if (!root) {
+		return false;
+	}
+	for (const directory of MARKETPLACE_ORIGIN_DIRS) {
+		try {
+			const origin = JSON.parse(syncFs.readFileSync(path.join(root, directory, "origin.json"), "utf8"));
+			if (origin.version === 1 && origin.archiveIntegrityVerified === true && typeof origin.archiveSha256 === "string" && /^[a-f0-9]{64}$/u.test(origin.archiveSha256) && typeof origin.contentSha256 === "string" && /^[a-f0-9]{64}$/u.test(origin.contentSha256) && computeSkillContentSha256Sync(root) === origin.contentSha256) {
+				return true;
+			}
+		} catch {}
+	}
+	return false;
+}
+function isMarketplaceSkillDir(skillDir) {
+	const root = skillDir.trim();
+	return Boolean(root && (hasMarketplaceOriginMarker(root) || isTrackedMarketplaceSkill(root)));
+}
+function marketplaceSkillIdsFromEntries(entries) {
+	return [...new Set(entries.filter((entry) => isMarketplaceSkillDir(entry.skill.baseDir)).map((entry) => entry.skill.name.trim()).filter(Boolean))].toSorted();
+}
+function marketplaceSkillIdsFromSnapshot(snapshot) {
+	if (!snapshot) {
+		return [];
+	}
+	if (snapshot.marketplaceSkillIds) {
+		return [...new Set(snapshot.marketplaceSkillIds.map((id) => id.trim()).filter(Boolean))].toSorted();
+	}
+	return [...new Set((snapshot.resolvedSkills ?? []).filter((skill) => isMarketplaceSkillDir(skill.baseDir)).map((skill) => skill.name.trim()).filter(Boolean))].toSorted();
+}
+
+//#endregion
+export { isMarketplaceSkillDir, marketplaceSkillIdsFromEntries, marketplaceSkillIdsFromSnapshot, marketplaceSkillProvenanceMatchesContent };