@iowarp/clio-coder 0.4.8 → 0.4.9

package/src/tools/file-mutation-queue.ts

@@ -1,14 +1,25 @@
-import { realpathSync } from "node:fs";
-import { resolve } from "node:path";
+import { randomUUID } from "node:crypto";
+import { lstatSync, readlinkSync, realpathSync } from "node:fs";
+import { lstat, mkdir, open, readlink, realpath, rename, stat, unlink } from "node:fs/promises";
+import { basename, dirname, join, resolve } from "node:path";
 
 const fileMutationQueues = new Map<string, Promise<void>>();
 
-function mutationQueueKey(filePath: string): string {
+function mutationQueueKey(filePath: string, depth = 0): string {
 	const resolved = resolve(filePath);
+	if (depth > 40) throw new Error("Too many symbolic links");
 	try {
 		return realpathSync.native(resolved);
 	} catch {
-		return resolved;
+		try {
+			if (lstatSync(resolved).isSymbolicLink()) {
+				return mutationQueueKey(resolve(dirname(resolved), readlinkSync(resolved)), depth + 1);
+			}
+		} catch {
+			// Missing paths still share a key through the nearest real ancestor.
+		}
+		const parent = dirname(resolved);
+		return parent === resolved ? resolved : join(mutationQueueKey(parent, depth), basename(resolved));
 	}
 }
 
@@ -33,3 +44,102 @@ export async function withFileMutationQueue<T>(filePath: string, fn: () => Promi
 		}
 	}
 }
+
+export interface FileIdentity {
+	bytes: number;
+	mtimeMs: number;
+}
+
+export interface AtomicPublishResult {
+	before: FileIdentity | null;
+	after: FileIdentity;
+	/** Publication succeeded, but directory durability could not be confirmed. */
+	durabilityWarning?: string;
+}
+
+export interface AtomicPublishOptions {
+	/** Test seam. Must either perform the rename or throw before publishing. */
+	rename?: (tempPath: string, targetPath: string) => Promise<void>;
+}
+
+async function resolvePublishTarget(filePath: string, depth = 0): Promise<string> {
+	if (depth > 40) throw new Error("Too many symbolic links");
+	const absolute = resolve(filePath);
+	try {
+		const info = await lstat(absolute);
+		if (info.isSymbolicLink()) {
+			return resolvePublishTarget(resolve(dirname(absolute), await readlink(absolute)), depth + 1);
+		}
+		if (!info.isFile()) throw new Error(`Refusing non-file target (including directories): ${filePath}`);
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+	}
+	await mkdir(dirname(absolute), { recursive: true });
+	return join(await realpath(dirname(absolute)), basename(absolute));
+}
+
+/**
+ * Atomically replaces the resolved target, preserving symlinks and existing mode bits.
+ * Call inside withFileMutationQueue when a read/modify/write transaction is needed.
+ * External writers are not locked; the last rename wins. Atomicity and durability
+ * depend on the filesystem's rename/fsync guarantees, including on shared storage.
+ * Ownership, timestamps, ACLs, and extended attributes are not copied.
+ */
+export async function publishFileAtomically(
+	filePath: string,
+	content: string | Uint8Array,
+	options: AtomicPublishOptions = {},
+): Promise<AtomicPublishResult> {
+	let tempPath: string | undefined;
+	try {
+		const target = await resolvePublishTarget(filePath);
+		const previous = await stat(target).catch((error: NodeJS.ErrnoException) => {
+			if (error.code === "ENOENT") return null;
+			throw error;
+		});
+		if (previous && !previous.isFile()) throw new Error(`Refusing directory or non-file target: ${filePath}`);
+		tempPath = join(dirname(target), `.clio-coder-publish-${randomUUID()}.tmp`);
+		const handle = await open(tempPath, "wx", previous ? previous.mode & 0o7777 : 0o666);
+		let after: FileIdentity;
+		try {
+			await handle.writeFile(content);
+			if (previous) await handle.chmod(previous.mode & 0o7777);
+			await handle.sync();
+			const info = await handle.stat();
+			after = { bytes: info.size, mtimeMs: info.mtimeMs };
+		} finally {
+			await handle.close();
+		}
+		await (options.rename ?? rename)(tempPath, target);
+		tempPath = undefined;
+		const result: AtomicPublishResult = {
+			before: previous ? { bytes: previous.size, mtimeMs: previous.mtimeMs } : null,
+			after,
+		};
+		// Rename is the commit point. A later durability failure cannot honestly
+		// be described as an unpublished write or safely rolled back over other writers.
+		try {
+			const directory = await open(dirname(target), "r");
+			try {
+				await directory.sync();
+			} finally {
+				await directory.close();
+			}
+		} catch (error) {
+			result.durabilityWarning = `Published, but directory fsync was unavailable or failed: ${String(error)}`;
+		}
+		return result;
+	} catch (error) {
+		let cleanup = "";
+		if (tempPath) {
+			try {
+				await unlink(tempPath);
+			} catch (cleanupError) {
+				if ((cleanupError as NodeJS.ErrnoException).code !== "ENOENT") {
+					cleanup = ` Temporary file cleanup failed at ${tempPath}: ${String(cleanupError)}`;
+				}
+			}
+		}
+		throw new Error(`Nothing was published: ${String(error)}.${cleanup}`, { cause: error });
+	}
+}

package/src/tools/find.ts

@@ -1,6 +1,6 @@
 import { existsSync, statSync } from "node:fs";
 import { readdir } from "node:fs/promises";
-import { join, relative } from "node:path";
+import { join, relative, resolve } from "node:path";
 import { Type } from "typebox";
 import { ToolNames } from "../core/tool-names.js";
 import { StringEnum } from "../engine/ai.js";
@@ -18,7 +18,16 @@ import {
 } from "./observation.js";
 import { resolveReadPath, toPosixPath } from "./path-utils.js";
 import type { ToolInvokeOptions, ToolResult, ToolSpec } from "./registry.js";
-import { SEARCH_SPAWN_TIMEOUT_MS, spawnLineStream, validateSearchPatternSize } from "./spawn-hygiene.js";
+import {
+	createSearchDiagnostics,
+	finishSearch,
+	newSearchCompleteness,
+	type SearchCompleteness,
+	searchNotice,
+	skipSearchPath,
+	spawnLineStream,
+	validateSearchPatternSize,
+} from "./spawn-hygiene.js";
 import { truncateHead } from "./truncate.js";
 
 const DEFAULT_LIMIT = 500;
@@ -32,9 +41,9 @@ type FindOrder = "path" | "mtime";
 // Build fd's argv. Ignore semantics (hidden files, .gitignore honoring,
 // generated-dir excludes, include_ignored) come entirely from the shared
 // ignore policy so grep and find never disagree about tree visibility.
-function buildFdArgs(pattern: string, searchPath: string, maxResults: number, includeIgnored: boolean): string[] {
+function buildFdArgs(pattern: string, searchPath: string, collectLimit: number, includeIgnored: boolean): string[] {
 	const args = ["--glob", "--color=never", ...fdIgnoreArgs(searchPath, includeIgnored)];
-	args.push("--max-results", String(maxResults));
+	args.push("--show-errors", "--max-results", String(collectLimit));
 	let effectivePattern = pattern;
 	if (pattern.includes("/")) {
 		args.push("--full-path");
@@ -52,33 +61,45 @@ async function fdFind(
 	searchPath: string,
 	collectLimit: number,
 	includeIgnored: boolean,
+	search: SearchCompleteness,
+	allows: (path: string) => boolean,
 	signal?: AbortSignal,
 ): Promise<{ ok: true; paths: string[] } | { ok: false; message: string }> {
 	const lines: string[] = [];
+	const diagnostics = createSearchDiagnostics(search, (path) => allows(resolve(process.cwd(), path)));
 	const result = await spawnLineStream(fdPath, buildFdArgs(pattern, searchPath, collectLimit, includeIgnored), {
 		...(signal ? { signal } : {}),
+		onStderrLine: diagnostics.onLine,
 		onLine(line, stop) {
 			lines.push(line);
 			if (lines.length >= collectLimit) stop();
 		},
 	});
-	if (result.aborted) return { ok: false, message: "find: operation aborted" };
-	if (result.timedOut) {
+	finishSearch(search, result);
+	if (!result.aborted && !result.timedOut && !result.stoppedEarly && result.exitCode !== 0) {
+		search.complete = false;
+		search.reason = "errors";
+	}
+	if (result.spawnError !== null) return { ok: false, message: `find: failed to run fd: ${result.spawnError}` };
+	if (
+		!result.aborted &&
+		!result.timedOut &&
+		!result.stoppedEarly &&
+		result.exitCode !== 0 &&
+		lines.length === 0 &&
+		(diagnostics.realError || (search.skipped.count === 0 && !search.skipped.unknown))
+	) {
 		return {
 			ok: false,
-			message: `find: fd timed out after ${SEARCH_SPAWN_TIMEOUT_MS / 1000}s. Narrow the pattern or path, or lower limit.`,
+			message: `find: fd rejected the search or failed (exit code ${result.exitCode}). Check the glob and search path.`,
 		};
 	}
-	if (result.spawnError !== null) return { ok: false, message: `find: failed to run fd: ${result.spawnError}` };
-	if (!result.stoppedEarly && result.exitCode !== 0 && lines.length === 0) {
-		return { ok: false, message: `find: ${result.stderr.trim() || `fd exited with code ${result.exitCode}`}` };
-	}
 	const paths = lines
-		.map((rawLine) => rawLine.replace(/\r$/, "").trim())
+		.map((rawLine) => rawLine.replace(/\r$/, ""))
 		.filter((line) => line.length > 0)
 		.map((line) => {
 			const hadTrailingSlash = line.endsWith("/") || line.endsWith("\\");
-			let relPath = line.startsWith(searchPath) ? line.slice(searchPath.length + 1) : relative(searchPath, line);
+			let relPath = relative(searchPath, line);
 			if (hadTrailingSlash && !relPath.endsWith("/")) relPath += "/";
 			return toPosixPath(relPath);
 		});
@@ -94,6 +115,8 @@ async function fallbackFind(
 	searchPath: string,
 	collectLimit: number,
 	includeIgnored: boolean,
+	search: SearchCompleteness,
+	allows: (path: string) => boolean,
 	signal?: AbortSignal,
 ): Promise<string[]> {
 	const matcher = compileGlobRegex(pattern.includes("/") ? pattern : `**/${pattern}`);
@@ -105,11 +128,13 @@ async function fallbackFind(
 		try {
 			entries = (await readdir(dir, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name));
 		} catch {
+			skipSearchPath(search, dir, allows);
 			return;
 		}
 		for (const entry of entries) {
 			if (out.length >= collectLimit || signal?.aborted) return;
 			const absPath = join(dir, entry.name);
+			if (!allows(absPath)) continue;
 			if (entry.isDirectory() && !entry.isSymbolicLink()) {
 				if (ignored.has(entry.name)) continue;
 				const relDir = `${toPosixPath(relative(searchPath, absPath))}/`;
@@ -117,7 +142,13 @@ async function fallbackFind(
 				await walk(absPath);
 				continue;
 			}
-			if (!entry.isFile()) continue;
+			if (entry.isSymbolicLink()) {
+				try {
+					if (statSync(absPath).isDirectory()) skipSearchPath(search, absPath, allows);
+				} catch {
+					skipSearchPath(search, absPath, allows);
+				}
+			} else if (!entry.isFile()) continue;
 			const relPath = toPosixPath(relative(searchPath, absPath));
 			if (matcher.test(normalizeGlobInput(relPath))) out.push(relPath);
 		}
@@ -133,14 +164,21 @@ interface OrderedPaths {
 	candidateCap: number | null;
 }
 
-function orderByMtime(paths: string[], searchPath: string, limit: number, candidateCap: number): OrderedPaths {
+function orderByMtime(
+	paths: string[],
+	searchPath: string,
+	limit: number,
+	candidateCap: number,
+	search: SearchCompleteness,
+): OrderedPaths {
 	const candidateCapHit = paths.length >= candidateCap;
 	const stamped = paths.map((relPath) => {
 		let mtimeMs = 0;
 		try {
 			mtimeMs = statSync(join(searchPath, relPath)).mtimeMs;
 		} catch {
-			// Entries that vanish mid-scan sort last instead of failing the call.
+			// Entries that vanish mid-scan sort last and remain explicitly incomplete.
+			skipSearchPath(search, join(searchPath, relPath));
 		}
 		return { relPath, mtimeMs };
 	});
@@ -149,6 +187,8 @@ function orderByMtime(paths: string[], searchPath: string, limit: number, candid
 }
 
 function renderFindResult(input: {
+	search: SearchCompleteness;
+	fallback: boolean;
 	withheldPaths: number;
 	ordered: OrderedPaths;
 	collected: number;
@@ -158,16 +198,27 @@ function renderFindResult(input: {
 	reservation: ObservationReservation;
 	options: ToolInvokeOptions | undefined;
 }): ToolResult {
-	const { ordered, collected, collectLimit, limit, order, reservation, options } = input;
+	const { ordered, collected, collectLimit, limit, order, reservation, options, search } = input;
+	if ((collected > limit || collected >= collectLimit || ordered.candidateCapHit) && search.complete) {
+		search.complete = false;
+		search.reason = "limit";
+	}
+	const coverageNotice = input.fallback
+		? "\n[Fallback search uses GENERATED_DIRS only; .gitignore is not applied.]"
+		: "\n[Native fd search: skipped symlinked directories are not counted.]";
 	if (ordered.paths.length === 0) {
 		return finalizeObservation({
 			tool: ToolNames.Find,
 			withheldPaths: input.withheldPaths,
 			unit: "paths",
-			output: "No visible files found matching pattern",
+			output:
+				(search.complete ? "No visible files found matching pattern" : "Search incomplete") +
+				searchNotice(search, 0, "paths") +
+				coverageNotice,
+			details: { search, symlinkDirectories: { counted: input.fallback } },
 			shownCount: 0,
-			totalCount: collected >= collectLimit ? null : 0,
-			truncated: collected >= collectLimit,
+			totalCount: search.complete ? 0 : null,
+			truncated: !search.complete,
 			...(collected >= collectLimit ? { next: `limit=${limit * 2}` } : {}),
 			reservation,
 			...(options ? { options } : {}),
@@ -181,10 +232,14 @@ function renderFindResult(input: {
 	const limitHit = collected > limit || collected >= collectLimit;
 	// Unknown totals: the collector stopped at its cap, so matches beyond it
 	// exist but were never counted.
-	const totalKnown = !limitHit && !ordered.candidateCapHit;
-	const truncated = limitHit || ordered.candidateCapHit || truncation.truncated;
+	if (truncation.truncated && search.complete) {
+		search.complete = false;
+		search.reason = "limit";
+	}
+	const totalKnown = search.complete;
+	const truncated = !search.complete || limitHit || ordered.candidateCapHit || truncation.truncated;
 	const next = limitHit ? `limit=${limit * 2}` : ordered.candidateCapHit ? "order=path" : undefined;
-	const details: Record<string, unknown> = {};
+	const details: Record<string, unknown> = { search, symlinkDirectories: { counted: input.fallback } };
 	if (order === "mtime" && ordered.candidateCap !== null) {
 		details.candidates = {
 			cap: ordered.candidateCap,
@@ -197,7 +252,7 @@ function renderFindResult(input: {
 		tool: ToolNames.Find,
 		withheldPaths: input.withheldPaths,
 		unit: "paths",
-		output: truncation.content,
+		output: truncation.content + searchNotice(search, truncation.outputLines, "paths") + coverageNotice,
 		// Offload only when the byte cap cut collected paths; a bare result
 		// limit continues via `next`, and the offload would duplicate the body.
 		...(truncation.truncated ? { fullOutput } : {}),
@@ -214,7 +269,7 @@ function renderFindResult(input: {
 export const findTool: ToolSpec = {
 	name: ToolNames.Find,
 	description:
-		"Find files and directories by glob pattern (supports *, **, ?, [abc]); returns paths relative to the search directory. Respects .gitignore and skips generated dirs (node_modules, dist, build, ...) unless include_ignored=true. order=path (default) returns fd's native order; order=mtime returns newest first from a bounded candidate set. Truncated results say how to continue and where the full list was saved.",
+		"Find files and directories by glob pattern (supports *, **, ?, [abc]); returns paths relative to the search directory. Respects .gitignore and skips generated dirs (node_modules, dist, build, ...) unless include_ignored=true. Symlinked directories are never followed. Only the fallback counts skipped symlinked directories; native fd leaves that count unmeasured, as indicated by details.symlinkDirectories.counted=false. Without fd the fallback uses GENERATED_DIRS only, with no .gitignore support. order=path (default) returns fd's native order; order=mtime returns newest first from a bounded candidate set. Truncated results say how to continue and where the full list was saved.",
 	parameters: Type.Object({
 		pattern: Type.String({ description: "Glob pattern, e.g. 'src/**/*.ts'." }),
 		path: Type.Optional(Type.String({ description: "Directory to search in." })),
@@ -260,28 +315,52 @@ export const findTool: ToolSpec = {
 		commitObservationReservation(reservation);
 		try {
 			let collectedPaths: string[];
+			const search = newSearchCompleteness();
+			const pathFilter = createObservationPathFilter(process.cwd(), options?.allowsObservationPath);
 			const fdPath = resolveFdBinary();
 			if (fdPath) {
-				const result = await fdFind(fdPath, pattern, searchPath, collectLimit, includeIgnored, options?.signal);
+				const result = await fdFind(
+					fdPath,
+					pattern,
+					searchPath,
+					collectLimit,
+					includeIgnored,
+					search,
+					pathFilter.allows,
+					options?.signal,
+				);
 				if (!result.ok) return { kind: "error", message: result.message };
 				collectedPaths = result.paths;
 			} else {
 				try {
-					collectedPaths = await fallbackFind(pattern, searchPath, collectLimit, includeIgnored, options?.signal);
+					collectedPaths = await fallbackFind(
+						pattern,
+						searchPath,
+						collectLimit,
+						includeIgnored,
+						search,
+						pathFilter.allows,
+						options?.signal,
+					);
 				} catch (err) {
 					const message = err instanceof Error ? err.message : String(err);
 					return { kind: "error", message: `find: ${message}` };
 				}
 			}
 
+			if (options?.signal?.aborted) {
+				search.complete = false;
+				search.reason = "cancelled";
+			}
 			const collectedCount = collectedPaths.length;
-			const pathFilter = createObservationPathFilter(process.cwd(), options?.allowsObservationPath);
 			collectedPaths = collectedPaths.filter((entry) => pathFilter.allows(join(searchPath, entry)));
 			const ordered: OrderedPaths =
 				order === "mtime"
-					? orderByMtime(collectedPaths, searchPath, limit, collectLimit)
+					? orderByMtime(collectedPaths, searchPath, limit, collectLimit, search)
 					: { paths: collectedPaths.slice(0, limit), candidateCapHit: false, candidateCap: null };
 			return renderFindResult({
+				search,
+				fallback: !fdPath,
 				withheldPaths: pathFilter.withheldPaths,
 				ordered,
 				collected: collectedCount,

package/src/tools/gateway/caps.ts

@@ -0,0 +1,11 @@
+/**
+ * Self-caps of the gateway-plane observation envelopes. Kept in a module with
+ * no imports so the bootstrap policy assertion and the catalog can read them
+ * without loading the tools themselves.
+ */
+
+/** Bytes of one `data` result body before the JSON stub rule offloads it. */
+export const DATA_OBSERVATION_SELF_CAP_BYTES = 32 * 1024;
+
+/** Bytes of one `gateway` find listing before the JSON stub rule offloads it. */
+export const GATEWAY_FIND_SELF_CAP_BYTES = 32 * 1024;

package/src/tools/gateway/clio-context-surface.ts

@@ -0,0 +1,41 @@
+import { Type } from "typebox";
+import { ToolNames } from "../../core/tool-names.js";
+import { StringEnum } from "../../engine/ai.js";
+import type { ToolSurface } from "../lazy-tool.js";
+
+/**
+ * Immutable surfaces of the two Clio-internal reads that left the permanent
+ * `context` schema: `clio_docs` (bundled documentation) and `clio_library`
+ * (the recipe catalog). The implementations load on first call.
+ */
+
+export const clioDocsToolSurface = {
+	name: ToolNames.ClioDocs,
+	description:
+		"Search Clio's bundled documentation for a question or terms and return cited sections as JSON; omit query to list the corpus (files and counts). Read-only; charges the per-turn observation pool.",
+	parameters: Type.Object({
+		query: Type.Optional(Type.String({ description: "Question or terms; omit to list the corpus." })),
+		limit: Type.Optional(Type.Number({ description: "Max sections (default 5, max 12)." })),
+	}),
+	baseActionClass: "read",
+	executionMode: "parallel",
+} satisfies ToolSurface;
+
+export const clioLibraryToolSurface = {
+	name: ToolNames.ClioLibrary,
+	description:
+		"Read the recipe catalog: installed skills, agents, prompts, and fleets with their owner and invocation, plus installable packages. Body-free rows, bounded pages; activates and installs nothing. Unavailable inside a worker.",
+	parameters: Type.Object({
+		query: Type.Optional(Type.String({ description: "Name, owner, or description terms." })),
+		kind: Type.Optional(
+			StringEnum(["skill", "agent", "prompt", "fleet", "plugin"], {
+				description: "One recipe kind, or plugin for installable package rows.",
+			}),
+		),
+		ref: Type.Optional(Type.String({ description: "Exact kind:name or resource key for one record." })),
+		limit: Type.Optional(Type.Number({ description: "Max rows (default 20, max 50)." })),
+		offset: Type.Optional(Type.Number({ description: "Zero-based offset; follow nextOffset (default 0)." })),
+	}),
+	baseActionClass: "read",
+	executionMode: "parallel",
+} satisfies ToolSurface;

package/src/tools/gateway/clio-context-tools.ts

@@ -0,0 +1,77 @@
+import { ToolNames } from "../../core/tool-names.js";
+import type { LoadSkillsInput } from "../../domains/resources/index.js";
+import { runDocsScope } from "../context/index.js";
+import { OBSERVE_SELF_CAPS, observationBudgetExhausted, reserveObservation } from "../observation.js";
+import type { ToolResult, ToolSpec } from "../registry.js";
+import { clioDocsToolSurface, clioLibraryToolSurface } from "./clio-context-surface.js";
+
+export { clioDocsToolSurface, clioLibraryToolSurface } from "./clio-context-surface.js";
+
+/**
+ * The two Clio-internal reads that left the permanent `context` schema:
+ * `clio_docs` (bundled documentation) and `clio_library` (the recipe catalog).
+ * Each is the former context scope under its own name, reusing the scope
+ * function unchanged, so what the gateway returns is exactly what
+ * context(scope="docs"|"library") returned.
+ */
+
+export function createClioDocsTool(): ToolSpec {
+	return {
+		...clioDocsToolSurface,
+		async run(args, options): Promise<ToolResult> {
+			const reservation = reserveObservation(OBSERVE_SELF_CAPS.contextDocs, options);
+			if (reservation.exhausted) {
+				return observationBudgetExhausted({
+					tool: ToolNames.ClioDocs,
+					unit: "sections",
+					reservation,
+					subject: typeof args.query === "string" && args.query.length > 0 ? `query=${args.query}` : "corpus",
+					hint: "Continue in a follow-up turn.",
+				});
+			}
+			return runDocsScope(args, reservation, options, ToolNames.ClioDocs);
+		},
+	};
+}
+
+export interface ClioLibraryToolDeps {
+	getCwd?: () => string;
+	/** False on every worker registry: the read refuses there, as the context scope did. */
+	skillMarketplace?: boolean;
+	getSkillLoaderOptions?: () => Pick<
+		LoadSkillsInput,
+		"trustProjectCompatRoots" | "disableDiscovery" | "explicitSkillPaths"
+	>;
+}
+
+export function createClioLibraryTool(deps: ClioLibraryToolDeps = {}): ToolSpec {
+	return {
+		...clioLibraryToolSurface,
+		async run(args, options): Promise<ToolResult> {
+			// Reserved before the inventory is walked, so an exhausted pool answers
+			// with the notice and no catalog read happens for nothing.
+			const reservation = reserveObservation(OBSERVE_SELF_CAPS.contextLibrary, options);
+			if (reservation.exhausted) {
+				return observationBudgetExhausted({
+					tool: ToolNames.ClioLibrary,
+					unit: "entries",
+					reservation,
+					subject: "catalog",
+					hint: "Continue in a follow-up turn.",
+				});
+			}
+			const { runLibraryScope } = await import("../context/library.js");
+			return runLibraryScope(
+				{
+					getCwd: () => deps.getCwd?.() ?? process.cwd(),
+					...(deps.skillMarketplace !== undefined ? { skillMarketplace: deps.skillMarketplace } : {}),
+					...(deps.getSkillLoaderOptions ? { skillLoaderOptions: deps.getSkillLoaderOptions() } : {}),
+				},
+				args,
+				reservation,
+				options,
+				ToolNames.ClioLibrary,
+			);
+		},
+	};
+}