@nomix-ai/nomix-harness 0.2.5 → 0.2.6

package/dist/kernel/subagent-claude-code/lib/index.js

@@ -6,7 +6,6 @@ import { query } from "@anthropic-ai/claude-agent-sdk";
 import { SessionId } from "../../session/lib/index.js";
 import { scrubbedParentEnv } from "../../subprocess/lib/index.js";
 import { EventEmitter } from "node:events";
-import { extname } from "node:path";
 //#region lib/types/process.js
 /**
 * Projection from the shared managed-process handle to the official Claude
@@ -14,7 +13,6 @@ import { extname } from "node:path";
 *
 * @module @nomix-ai/nomix-subagent-claude-code/process
 */
-const WINDOWS_BATCH_EXECUTABLE_ENV = "NOMIX_CLAUDE_CODE_EXECUTABLE";
 function thrown$1(value) {
 	/* v8 ignore next -- the subprocess seam rejects with Error. */
 	return value instanceof Error ? value : new Error(String(value));
@@ -33,28 +31,12 @@ function sdkEnvironmentOverlay(env) {
 * Translate one official SDK spawn request to the shared process owner.
 * @param options - command, arguments, workspace, environment, and forwarded signal from the SDK.
 * @param graceMs - process-tree termination grace.
-* @param platform - host platform selecting the Windows batch-shim boundary.
 * @returns the fully explicit shared subprocess request.
-* @remarks The batch-shim path quotes only the resolved executable. The pinned SDK
-* supplies fixed flag arguments without cmd metacharacters; cmd reparses that tail.
 */
-function claudeSpawnSpec(options, graceMs, platform = process.platform) {
+function claudeSpawnSpec(options, graceMs) {
 	if (options.cwd === void 0 || options.cwd.length === 0) throw new Error("subagent-claude-code: SDK spawn request omitted its workspace");
-	const extension = extname(options.command).toLowerCase();
-	const batchShim = platform === "win32" && (extension === ".cmd" || extension === ".bat");
-	const env = sdkEnvironmentOverlay(options.env);
-	const argv = batchShim ? [
-		"cmd.exe",
-		"/d",
-		"/v:off",
-		"/s",
-		"/c",
-		`%${WINDOWS_BATCH_EXECUTABLE_ENV}%`,
-		...options.args
-	] : [options.command, ...options.args];
-	if (batchShim) env[WINDOWS_BATCH_EXECUTABLE_ENV] = `"${options.command}"`;
 	return {
-		argv,
+		argv: [options.command, ...options.args],
 		cwd: options.cwd,
 		stdio: {
 			stdin: "pipe",
@@ -63,7 +45,7 @@ function claudeSpawnSpec(options, graceMs, platform = process.platform) {
 		},
 		graceMs,
 		signal: options.signal,
-		env
+		env: sdkEnvironmentOverlay(options.env)
 	};
 }
 /**
@@ -75,8 +57,7 @@ var ManagedClaudeCodeProcess = class {
 	stdin;
 	stdout;
 	events = new EventEmitter();
-	exitCodeValue = null;
-	signalCodeValue = null;
+	outcomeValue;
 	killRequested = false;
 	/**
 	* Project a managed process with piped stdin and stdout.
@@ -88,8 +69,7 @@ var ManagedClaudeCodeProcess = class {
 		this.stdout = child.stdout;
 		this.events.on("error", () => {});
 		child.done.then((outcome) => {
-			this.exitCodeValue = outcome.exitCode;
-			this.signalCodeValue = outcome.signal;
+			this.outcomeValue = outcome;
 			this.events.emit("exit", outcome.exitCode, outcome.signal);
 		}, (error) => {
 			this.events.emit("error", thrown$1(error));
@@ -101,11 +81,15 @@ var ManagedClaudeCodeProcess = class {
 	}
 	/** Direct-child exit code, or null while running or after signal exit. */
 	get exitCode() {
-		return this.exitCodeValue;
+		return this.outcomeValue?.exitCode ?? null;
 	}
 	/** Direct-child terminating signal, if any. */
 	get signalCode() {
-		return this.signalCodeValue;
+		return this.outcomeValue?.signal ?? null;
+	}
+	/** Exact managed-process outcome after exit, or undefined while running. */
+	get outcome() {
+		return this.outcomeValue;
 	}
 	/**
 	* Route the SDK's termination request to the tree-scoped process owner.
@@ -113,7 +97,7 @@ var ManagedClaudeCodeProcess = class {
 	* @returns false only after exit or a previous termination request.
 	*/
 	kill(_signal) {
-		if (this.killRequested || this.exitCodeValue !== null || this.signalCodeValue !== null) return false;
+		if (this.killRequested || this.outcomeValue !== void 0) return false;
 		this.killRequested = true;
 		this.child.terminate();
 		return true;
@@ -142,10 +126,68 @@ var ManagedClaudeCodeProcess = class {
 */
 /** Default POSIX grace between subprocess termination tiers. */
 const DEFAULT_DISPOSE_GRACE_MS = 3e3;
+/** Claude Code permission modes that cannot wait for a human response. */
+const CLAUDE_CODE_PERMISSION_MODES = [
+	"dontAsk",
+	"acceptEdits",
+	"auto",
+	"plan",
+	"bypassPermissions"
+];
+/** Safe default for unattended Claude Code runs. */
+const DEFAULT_CLAUDE_CODE_PERMISSION_MODE = "dontAsk";
+const SUPPORTED_UNATTENDED_DIALOG_KINDS = ["refusal_fallback_prompt"];
+function failureDiagnostic(facts) {
+	const fields = [
+		"product: Claude Code",
+		`stage: ${facts.stage}`,
+		`category: ${facts.category}`
+	];
+	const exitCode = facts.outcome?.exitCode;
+	if (exitCode !== null && exitCode !== void 0) fields.push(`exit code: ${exitCode}`);
+	const signal = facts.outcome?.signal;
+	if (signal !== null && signal !== void 0) fields.push(`signal: ${signal}`);
+	return `Product subagent failure (${fields.join("; ")})`;
+}
+var ClaudeCodeFailure = class extends Error {
+	facts;
+	constructor(facts, cause) {
+		super(`subagent-claude-code: ${failureDiagnostic(facts)}`, cause === void 0 ? void 0 : { cause });
+		this.facts = facts;
+		this.name = "ClaudeCodeFailure";
+	}
+};
+function sdkFailureCategory(subtype) {
+	switch (subtype) {
+		case "error_during_execution":
+		case "error_max_turns":
+		case "error_max_budget_usd":
+		case "error_max_structured_output_retries": return subtype;
+		default: return "unknown";
+	}
+}
+/**
+* Hide an unpublished product startup failure behind fixed safe facts.
+* @param cause - original host-side failure retained only on the Error cause chain.
+* @returns a rejection safe to expose through the subagent start boundary.
+*/
+function claudeCodeStartupFailure(cause) {
+	return new ClaudeCodeFailure({
+		stage: "query-start",
+		category: "unknown"
+	}, cause);
+}
+function unattendedDiagnostic(mode, request, decision, reason) {
+	return `Claude Code unattended decision (mode: ${mode}; request: ${request}; decision: ${decision}): ${reason}`;
+}
 function thrown(value) {
 	/* v8 ignore next -- typed SDK and subprocess failures reject with Error. */
 	return value instanceof Error ? value : new Error(String(value));
 }
+/** Read live request cancellation across awaited startup cleanup. */
+function isAborted(signal) {
+	return signal.aborted;
+}
 /**
 * Validate and preserve the one-shot task before crossing the SDK boundary.
 * @param prompt - task content accepted from the shared subagent service.
@@ -167,25 +209,43 @@ function textTask(prompt) {
 * @returns exact final text for a successful, non-error result.
 */
 function successfulResult(message) {
-	if (message.subtype !== "success" || message.is_error || message.result.trim().length === 0) {
-		const detail = message.subtype === "success" ? "success result was marked as an error or contained no answer" : message.errors.join("; ") || message.subtype;
-		throw new Error(`subagent-claude-code: Claude Code failed: ${detail}`);
+	if (message.subtype !== "success") {
+		const category = sdkFailureCategory(message.subtype);
+		const detail = category === "unknown" ? void 0 : message.errors.join("; ");
+		throw new ClaudeCodeFailure({
+			stage: "query-run",
+			category
+		}, detail === void 0 || detail.length === 0 ? void 0 : new Error(detail));
 	}
+	if (message.is_error || message.result.trim().length === 0) throw new ClaudeCodeFailure({
+		stage: "query-run",
+		category: "invalid-success"
+	});
 	return message.result;
 }
 /**
 * Consume the complete SDK stream and require one strict success plus normal
 * iterator completion.
 * @param query - published official SDK query.
+* @param onPermissionDenied - records a safe fact when the SDK reports native denial.
+* @param onResult - records that the SDK supplied a terminal result message.
 * @returns the completed shared result.
 */
-async function consumeClaudeQuery(query) {
+async function consumeClaudeQuery(query, onPermissionDenied, onResult) {
 	let answer;
 	for await (const message of query) {
+		if (message.type === "system" && message.subtype === "permission_denied") {
+			onPermissionDenied?.();
+			continue;
+		}
 		if (message.type !== "result") continue;
+		onResult?.();
 		answer = successfulResult(message);
 	}
-	if (answer === void 0) throw new Error("subagent-claude-code: Claude Code ended without a result");
+	if (answer === void 0) throw new ClaudeCodeFailure({
+		stage: "query-run",
+		category: "missing-result"
+	});
 	return {
 		output: [{
 			type: "text",
@@ -198,7 +258,8 @@ async function consumeClaudeQuery(query) {
 * Close the official query, terminate the managed process tree, and wait for
 * the subprocess owner to prove it is gone.
 * @param query - official SDK query, when creation reached that point.
-* @param child - shared-service handle that owns the CLI process tree.
+* @param child - live shared-service handle that owns the CLI process tree;
+* spawn-failed handles settle at the startup boundary instead.
 */
 async function disposeClaudeCodeChild(query, child) {
 	const failures = [];
@@ -207,45 +268,60 @@ async function disposeClaudeCodeChild(query, child) {
 	} catch (error) {
 		failures.push(thrown(error));
 	}
-	if (child.pid > 0) {
-		child.terminate();
-		try {
-			await child.waitForExit();
-		} catch (error) {
-			failures.push(thrown(error));
-		}
-	}
+	child.terminate();
 	try {
-		await child.done;
+		await child.waitForExit();
 	} catch (error) {
 		failures.push(thrown(error));
 	}
+	const outcome = await child.done;
 	const firstFailure = failures[0];
-	if (failures.length === 1 && firstFailure !== void 0) throw firstFailure;
-	if (failures.length > 1) throw new AggregateError(failures, "subagent-claude-code: query and process cleanup failed");
+	if (firstFailure !== void 0) throw new ClaudeCodeFailure({
+		stage: "teardown",
+		category: "unknown",
+		outcome
+	}, failures.length === 1 ? firstFailure : new AggregateError(failures, "Claude Code teardown failures"));
 }
 /**
 * Build the fixed official SDK options for one one-shot provider run.
 * @param spec - Workspace, environment, process service, and disposal policy.
 * @param controller - per-run cancellation owner.
-* @param capture - receives the real managed child synchronously from the SDK hook.
+* @param capture - receives the shared child and SDK-facing process synchronously.
+* @param captureDiagnostic - receives safe facts from unattended interaction callbacks.
 * @returns options that inherit native settings while disabling persistence and user questions.
 */
-function claudeQueryOptions(spec, controller, capture) {
+function claudeQueryOptions(spec, controller, capture, captureDiagnostic) {
 	return {
 		abortController: controller,
 		cwd: spec.cwd,
-		pathToClaudeCodeExecutable: spec.executable,
 		env: {
 			...scrubbedParentEnv(),
 			...spec.env
 		},
 		persistSession: false,
-		disallowedTools: ["AskUserQuestion"],
+		disallowedTools: spec.permissionMode === "plan" ? ["AskUserQuestion", "ExitPlanMode"] : ["AskUserQuestion"],
+		permissionMode: spec.permissionMode,
+		...spec.permissionMode === "bypassPermissions" ? { allowDangerouslySkipPermissions: true } : { canUseTool: () => {
+			captureDiagnostic(unattendedDiagnostic(spec.permissionMode, "tool permission", "denied", "the provider does not request human approval"));
+			return Promise.resolve({
+				behavior: "deny",
+				message: "This unattended Claude Code subagent cannot request human approval."
+			});
+		} },
+		onElicitation: () => {
+			captureDiagnostic(unattendedDiagnostic(spec.permissionMode, "MCP elicitation", "declined", "the provider does not collect interactive MCP input"));
+			return Promise.resolve({ action: "decline" });
+		},
+		onUserDialog: () => {
+			captureDiagnostic(unattendedDiagnostic(spec.permissionMode, "user dialog", "cancelled", "the provider does not render blocking dialogs"));
+			return Promise.resolve({ behavior: "cancelled" });
+		},
+		supportedDialogKinds: SUPPORTED_UNATTENDED_DIALOG_KINDS,
 		spawnClaudeCodeProcess: (options) => {
 			const child = spec.spawn(claudeSpawnSpec(options, spec.disposeGraceMs));
-			capture(child);
-			return new ManagedClaudeCodeProcess(child);
+			const process = new ManagedClaudeCodeProcess(child);
+			capture(child, process);
+			return process;
 		}
 	};
 }
@@ -266,39 +342,132 @@ async function startClaudeCodeRun(request, spec) {
 		requestCancel();
 	};
 	request.signal.addEventListener("abort", onAbort, { once: true });
+	const reportFailure = (error) => {
+		try {
+			spec.onError?.(error, "error");
+		} catch {}
+	};
 	let child;
 	let query$1;
+	let managedProcess;
+	let diagnostic;
+	const capturePermissionDiagnostic = (value) => {
+		diagnostic = value;
+	};
+	const prependFailureDiagnostic = (facts) => {
+		const failure = failureDiagnostic(facts);
+		diagnostic = diagnostic === void 0 ? failure : `${failure}\n${diagnostic}`;
+	};
+	const captureChild = (captured, process) => {
+		child = captured;
+		managedProcess = process;
+	};
 	try {
 		query$1 = query({
 			prompt,
-			options: claudeQueryOptions(spec, controller, (captured) => {
-				child = captured;
-			})
+			options: claudeQueryOptions(spec, controller, captureChild, capturePermissionDiagnostic)
 		});
 		if (child === void 0 || child.pid <= 0) throw new Error("subagent-claude-code: official SDK did not publish a controllable Claude Code process");
 		if (controller.signal.aborted) throw new Error("subagent-claude-code: request was aborted before SDK startup");
 	} catch (error) {
 		request.signal.removeEventListener("abort", onAbort);
 		const cancelledBeforeCleanup = controller.signal.aborted;
+		await Promise.resolve();
+		const startupFacts = {
+			stage: "query-start",
+			category: "unknown",
+			outcome: managedProcess?.outcome
+		};
+		const startupFailure = (cause = error) => new ClaudeCodeFailure(startupFacts, thrown(cause));
 		requestCancel();
+		if (child !== void 0 && child.pid <= 0) {
+			let closeError;
+			try {
+				query$1?.close();
+			} catch (disposeError) {
+				closeError = thrown(disposeError);
+			}
+			let spawnError = thrown(error);
+			try {
+				await child.done;
+			} catch (childError) {
+				spawnError = thrown(childError);
+			}
+			if (closeError !== void 0) {
+				const failure = startupFailure(spawnError);
+				const cleanupFailure = new ClaudeCodeFailure({
+					stage: "teardown",
+					category: "unknown"
+				}, closeError);
+				const aggregate = new AggregateError([failure, cleanupFailure], `${failure.message}; ${cleanupFailure.message}`);
+				reportFailure(aggregate);
+				throw aggregate;
+			}
+			if (cancelledBeforeCleanup || isAborted(request.signal)) throw new Error("subagent-claude-code: request was aborted before SDK startup");
+			const failure = startupFailure(spawnError);
+			reportFailure(failure);
+			throw failure;
+		}
 		if (child !== void 0) try {
 			await disposeClaudeCodeChild(query$1, child);
 		} catch (disposeError) {
-			throw new AggregateError([thrown(error), thrown(disposeError)], "subagent-claude-code: startup failed and CLI cleanup also failed");
+			const failure = startupFailure();
+			const cleanupFailure = thrown(disposeError);
+			const aggregate = new AggregateError([failure, cleanupFailure], `${failure.message}; ${cleanupFailure.message}`);
+			reportFailure(aggregate);
+			throw aggregate;
 		}
 		else if (query$1 !== void 0) try {
 			query$1.close();
 		} catch (disposeError) {
-			throw new AggregateError([thrown(error), thrown(disposeError)], "subagent-claude-code: startup failed and query cleanup also failed");
+			const failure = startupFailure();
+			const cleanupFailure = new ClaudeCodeFailure({
+				stage: "teardown",
+				category: "unknown"
+			}, thrown(disposeError));
+			const aggregate = new AggregateError([failure, cleanupFailure], `${failure.message}; ${cleanupFailure.message}`);
+			reportFailure(aggregate);
+			throw aggregate;
 		}
-		if (cancelledBeforeCleanup || request.signal.aborted) throw new Error("subagent-claude-code: request was aborted before SDK startup");
-		throw thrown(error);
+		if (cancelledBeforeCleanup || isAborted(request.signal)) throw new Error("subagent-claude-code: request was aborted before SDK startup");
+		const failure = startupFailure();
+		reportFailure(failure);
+		throw failure;
 	}
 	const publishedQuery = query$1;
 	const publishedChild = child;
+	let receivedResult = false;
 	const result = settleRunResult({
-		attempt: () => consumeClaudeQuery(publishedQuery),
+		attempt: async () => {
+			try {
+				return await consumeClaudeQuery(publishedQuery, () => {
+					capturePermissionDiagnostic(unattendedDiagnostic(spec.permissionMode, "tool permission", "denied", "Claude Code denied the request before an interactive prompt"));
+				}, () => {
+					receivedResult = true;
+				});
+			} catch (error) {
+				const processOutcome = managedProcess?.outcome;
+				let facts;
+				if (error instanceof ClaudeCodeFailure) facts = {
+					...error.facts,
+					outcome: processOutcome
+				};
+				else if (processOutcome !== void 0 && !receivedResult) facts = {
+					stage: "process",
+					category: "process-exit",
+					outcome: processOutcome
+				};
+				else facts = {
+					stage: "query-run",
+					category: "unknown",
+					outcome: processOutcome
+				};
+				prependFailureDiagnostic(facts);
+				throw error instanceof ClaudeCodeFailure ? error : new ClaudeCodeFailure(facts, thrown(error));
+			}
+		},
 		collectOutput: () => [],
+		collectDiagnostic: () => diagnostic,
 		cancelled: () => controller.signal.aborted,
 		onError: spec.onError,
 		signal: request.signal,
@@ -310,60 +479,85 @@ async function startClaudeCodeRun(request, spec) {
 		signal: request.signal,
 		onAbort,
 		requestCancel,
-		teardown: () => disposeClaudeCodeChild(publishedQuery, publishedChild)
+		teardown: async () => {
+			try {
+				await disposeClaudeCodeChild(publishedQuery, publishedChild);
+			} catch (error) {
+				const failure = thrown(error);
+				reportFailure(failure);
+				throw failure;
+			}
+		}
 	});
 }
 //#endregion
 //#region lib/types/index.js
 /**
-* Fixed Claude Code one-shot subagent provider. Every accepted run invokes
-* the official Agent SDK in the delegating Session's workspace and places
-* the SDK-spawned real CLI under the shared subprocess owner.
+* Profile-named Claude Code one-shot subagent provider. Every accepted run
+* invokes the official Agent SDK in the delegating Session's workspace and
+* places the SDK-spawned real CLI under the shared subprocess owner.
 *
 * @module @nomix-ai/nomix-subagent-claude-code
 */
 const name = "subagent-claude-code";
 const inject = ["subagents", "subprocess"];
+const DEFAULT_PROVIDER_NAME = "claude-code";
 const Config = z.object({
+	providerName: z.string().min(1).default(DEFAULT_PROVIDER_NAME),
 	env: z.dict(z.string()).default({}),
+	permissionMode: z.union([...CLAUDE_CODE_PERMISSION_MODES]).default(DEFAULT_CLAUDE_CODE_PERMISSION_MODE),
 	disposeGraceMs: z.number().default(DEFAULT_DISPOSE_GRACE_MS)
 });
 var ClaudeCodeProvider = class {
+	name;
 	ctx;
 	config;
-	name = "claude-code";
 	capabilities = NO_START_CAPABILITIES;
 	inheritsParentContext = false;
-	constructor(ctx, config) {
+	constructor(name, ctx, config) {
+		this.name = name;
 		this.ctx = ctx;
 		this.config = config;
 	}
 	async start(request) {
 		const parentCwd = request.parent.session.header.cwd;
 		if (parentCwd === void 0) throw new Error("subagent-claude-code: no working directory for the child — delegate from a parent session that has one");
-		const executable = await this.ctx.subprocess.resolveExecutable("claude", this.config.env, request.signal);
+		let cwd;
+		try {
+			cwd = resolveChildCwd("subagent-claude-code", void 0, parentCwd);
+		} catch (error) {
+			if (request.signal.aborted) throw new Error("subagent-claude-code: request was aborted before SDK startup");
+			const failure = claudeCodeStartupFailure(error);
+			this.ctx.logger.warn(`subagent-claude-code "${this.name}": child start failed: %o`, failure);
+			throw failure;
+		}
 		return startClaudeCodeRun(request, {
-			cwd: resolveChildCwd("subagent-claude-code", void 0, parentCwd),
-			executable,
+			cwd,
+			permissionMode: this.config.permissionMode,
 			env: this.config.env,
 			disposeGraceMs: this.config.disposeGraceMs,
 			spawn: (spawnSpec) => this.ctx.subprocess.spawn(spawnSpec),
 			onError: (error, stopReason) => {
-				this.ctx.logger.warn(`subagent-claude-code: child run failed (${stopReason}): ${error.message}`);
+				this.ctx.logger.warn(`subagent-claude-code "${this.name}": child run failed (${stopReason}): %o`, error);
 			}
 		});
 	}
 };
 /**
-* Register the fixed `claude-code` provider.
+* Register one Profile-named Claude Code provider.
 * @param ctx - context carrying shared subagent and subprocess services.
-* @param config - explicit child environment and disposal grace.
+* @param config - registry name, permission mode, child environment, and disposal grace.
 */
 function apply(ctx, config) {
-	const resolved = config;
+	const resolved = {
+		providerName: config.providerName ?? DEFAULT_PROVIDER_NAME,
+		env: config.env,
+		permissionMode: config.permissionMode ?? "dontAsk",
+		disposeGraceMs: config.disposeGraceMs
+	};
 	assertPositiveFinite("subagent-claude-code", "disposeGraceMs", resolved.disposeGraceMs);
 	if (resolved.disposeGraceMs > MAX_TIMER_DELAY_MS) throw new Error(`subagent-claude-code: disposeGraceMs must be no greater than ${MAX_TIMER_DELAY_MS}`);
-	ctx.subagents.registerProvider(new ClaudeCodeProvider(ctx, resolved));
+	ctx.subagents.registerProvider(new ClaudeCodeProvider(resolved.providerName, ctx, resolved));
 }
 //#endregion
 export { Config, apply, inject, name };

package/dist/kernel/subagent-claude-code/lib/types/index.d.ts

@@ -1,29 +1,39 @@
 /**
- * Fixed Claude Code one-shot subagent provider. Every accepted run invokes
- * the official Agent SDK in the delegating Session's workspace and places
- * the SDK-spawned real CLI under the shared subprocess owner.
+ * Profile-named Claude Code one-shot subagent provider. Every accepted run
+ * invokes the official Agent SDK in the delegating Session's workspace and
+ * places the SDK-spawned real CLI under the shared subprocess owner.
  *
  * @module @nomix-ai/nomix-subagent-claude-code
  */
 import type { Context } from '../../../cordis/lib/index.js';
 import z from '../../../schemastery/lib/index.mjs';
+import { type ClaudeCodePermissionMode } from './run.ts';
 export declare const name = "subagent-claude-code";
 export declare const inject: string[];
-/** Deployment-owned environment and process-release bound. */
+/** Deployment-owned permission, environment, and process-release settings. */
 export interface Config {
+    /** Provider name on `ctx.subagents` (default `claude-code`). */
+    providerName?: string;
     /**
      * Explicit environment entries layered over the subprocess seam's
      * credential-scrubbed parent environment.
      */
     env?: Record<string, string>;
+    /**
+     * Native non-interactive mode fixed for this Provider instance. Defaults to
+     * `dontAsk`; `acceptEdits` accepts edits, `auto` uses the native classifier,
+     * `plan` returns a plan without approving execution, and
+     * `bypassPermissions` explicitly skips permission checks.
+     */
+    permissionMode?: ClaudeCodePermissionMode;
     /** Grace in milliseconds for Claude Code process-tree termination. */
     disposeGraceMs?: number;
 }
 export declare const Config: z<Config>;
 /**
- * Register the fixed `claude-code` provider.
+ * Register one Profile-named Claude Code provider.
  * @param ctx - context carrying shared subagent and subprocess services.
- * @param config - explicit child environment and disposal grace.
+ * @param config - registry name, permission mode, child environment, and disposal grace.
  */
 export declare function apply(ctx: Context, config: Config): void;
 //# sourceMappingURL=index.d.ts.map