remoteclaw 0.0.0 → 0.1.0-next.2abd2fa

package/dist/hooks-cli-RuEn0-oy.js

@@ -0,0 +1,1222 @@
+import "./paths-BTaH3rLn.js";
+import { L as theme, _ as resolveUserPath, b as shortenHomePath, t as CONFIG_DIR } from "./utils-LBKvDoPx.js";
+import "./agent-helpers-B6VfZ9_u.js";
+import "./reply-CCu_DY64.js";
+import { a as resolveAgentWorkspaceDir, s as resolveDefaultAgentId } from "./agent-scope-BGYzhtWQ.js";
+import "./subsystem-COd61u0P.js";
+import { n as defaultRuntime } from "./runtime-DJNp29jv.js";
+import "./ansi-D04X81yq.js";
+import "./subagent-registry-Du_j0Fnt.js";
+import "./message-channel-DzJqHVZD.js";
+import "./targets-D-u6Kyio.js";
+import { F as LEGACY_MANIFEST_KEYS, I as MANIFEST_KEY, i as loadConfig, l as writeConfigFile, ot as isPathInside, st as isPathInsideWithRealpath } from "./config-D5XU45KD.js";
+import "./env-DeF64iu0.js";
+import "./host-env-security-Bms2_EMV.js";
+import "./inbound-path-policy-Bg4gZBx-.js";
+import "./env-vars-CLGbxdpL.js";
+import "./dock-CQuu41bw.js";
+import "./runner-yVJ4HB2K.js";
+import "./logger-Bw3cFE5t.js";
+import "./ip-C9q3Oq20.js";
+import "./ssrf-m7kFIobZ.js";
+import "./local-roots-nImrw2WR.js";
+import "./exec-DbKuYyM1.js";
+import "./tool-images-BNfIJ_Kj.js";
+import "./redact-eZq1uwNK.js";
+import "./errors-8F-77i6m.js";
+import "./mime-BS3jhcZE.js";
+import { t as formatCliCommand } from "./command-format-DgXcqxBt.js";
+import "./auth-profiles-D8vKiBPq.js";
+import "./file-lock-CIvloidc.js";
+import "./plugins-woGRXMzU.js";
+import "./accounts-BFy_Z3od.js";
+import "./accounts-DqRQ75w3.js";
+import "./accounts-iODF3SK2.js";
+import "./bindings-DQZAu8Wv.js";
+import "./tokens-DzFOtLlW.js";
+import "./reply-payloads-D_BM1Anb.js";
+import "./targets-DfqPGOmM.js";
+import "./loader-Ccwsh8Sh.js";
+import "./commands-D_-bgTlO.js";
+import "./commands-registry-Ci8_cFk9.js";
+import "./pairing-store-BxdqFZGK.js";
+import "./fetch-C6XKGA11.js";
+import "./retry-BhuXOEVR.js";
+import "./client-DdpmATKq.js";
+import "./chat-envelope-el7Uo-Fe.js";
+import "./store-SusmIfz7.js";
+import "./strip-inbound-meta-jy3bkUab.js";
+import "./audio-DPOuhNq7.js";
+import "./call-PivL7Uex.js";
+import "./net-D6D0wgcF.js";
+import "./tailnet-PnMrjwGT.js";
+import "./lanes-ByWMUgrz.js";
+import "./response-prefix-template-rVZQOViK.js";
+import "./image-ops-Bi6JPSkD.js";
+import "./tool-display-sgNwLOBj.js";
+import "./channel-activity-BaCNOZpP.js";
+import "./send-C3pdJ6p-.js";
+import "./fs-safe-DkBhNAc3.js";
+import "./ir-BpaAMTfW.js";
+import "./chunk-D0Y_w4oX.js";
+import "./markdown-tables-CrmghPAr.js";
+import "./render-CCLsW6Lz.js";
+import "./tables-TWiml6b1.js";
+import "./session-cost-usage-yYi525j3.js";
+import "./common-CMI-qsF8.js";
+import "./reply-directives-BHJKp1Du.js";
+import "./ack-reactions-BWVjL4H6.js";
+import "./resolve-route-DGEgTEif.js";
+import "./provider-dispatcher-Bfauw6zz.js";
+import "./store-C3tOpizT.js";
+import "./reply-prefix-Q4DOJSn_.js";
+import "./agent-CTizRPIJ.js";
+import { t as promptYesNo } from "./prompt-Bllj1dhc.js";
+import "./send-Ds63eF4a.js";
+import "./send-BN_zYVlx.js";
+import "./send-B1_Ymjb9.js";
+import "./proxy-DL3MD6-P.js";
+import "./replies-Cl2gYBVt.js";
+import "./channel-selection-BGl53D5K.js";
+import "./deliver-D56J4-1F.js";
+import "./outbound-attachment-BCNs1u1F.js";
+import "./delivery-queue-CxVRi4tw.js";
+import "./send-DHldI3gf.js";
+import "./onboard-helpers-BCzZUD0z.js";
+import "./prompt-style-DVEm3BZW.js";
+import "./pairing-labels-B-N8S5Fc.js";
+import { t as formatDocsLink } from "./links-C3soDNDH.js";
+import { c as resolveInstallModeOptions, d as withExtractedArchiveRoot, f as resolveArchiveSourcePath, g as resolveArchiveKind, h as readJsonFile, i as resolveSafeInstallDir, l as resolveTimedInstallModeOptions, m as fileExists, n as finalizeNpmSpecArchiveInstall, o as unscopedPackageName, r as installFromNpmSpecArchiveWithInstaller, s as installPackageDir, t as validateRegistryNpmSpec, u as resolveExistingInstallPath } from "./npm-registry-spec-0qiKawvv.js";
+import { t as renderTable } from "./table-DPTzZyhu.js";
+import { n as hasBinary } from "./config-eval-CjGZtLwx.js";
+import { a as parseFrontmatter, n as isConfigPathTruthy, r as resolveHookConfig, t as loadWorkspaceHookEntries } from "./workspace-B8PA8oxJ.js";
+import { n as resolvePinnedNpmInstallRecordForCli, r as buildPluginStatusReport, t as buildNpmInstallRecordFields } from "./npm-resolution-6v_Zm-9G.js";
+import fs from "node:fs";
+import path from "node:path";
+import fs$1 from "node:fs/promises";
+
+//#region src/shared/entry-metadata.ts
+function resolveEmojiAndHomepage(params) {
+	const emoji = params.metadata?.emoji ?? params.frontmatter?.emoji;
+	const homepageRaw = params.metadata?.homepage ?? params.frontmatter?.homepage ?? params.frontmatter?.website ?? params.frontmatter?.url;
+	const homepage = homepageRaw?.trim() ? homepageRaw.trim() : void 0;
+	return {
+		...emoji ? { emoji } : {},
+		...homepage ? { homepage } : {}
+	};
+}
+
+//#endregion
+//#region src/shared/requirements.ts
+function resolveMissingBins(params) {
+	const remote = params.hasRemoteBin;
+	return params.required.filter((bin) => {
+		if (params.hasLocalBin(bin)) return false;
+		if (remote?.(bin)) return false;
+		return true;
+	});
+}
+function resolveMissingAnyBins(params) {
+	if (params.required.length === 0) return [];
+	if (params.required.some((bin) => params.hasLocalBin(bin))) return [];
+	if (params.hasRemoteAnyBin?.(params.required)) return [];
+	return params.required;
+}
+function resolveMissingOs(params) {
+	if (params.required.length === 0) return [];
+	if (params.required.includes(params.localPlatform)) return [];
+	if (params.remotePlatforms?.some((platform) => params.required.includes(platform))) return [];
+	return params.required;
+}
+function resolveMissingEnv(params) {
+	const missing = [];
+	for (const envName of params.required) {
+		if (params.isSatisfied(envName)) continue;
+		missing.push(envName);
+	}
+	return missing;
+}
+function buildConfigChecks(params) {
+	return params.required.map((pathStr) => {
+		return {
+			path: pathStr,
+			satisfied: params.isSatisfied(pathStr)
+		};
+	});
+}
+function evaluateRequirements(params) {
+	const missingBins = resolveMissingBins({
+		required: params.required.bins,
+		hasLocalBin: params.hasLocalBin,
+		hasRemoteBin: params.hasRemoteBin
+	});
+	const missingAnyBins = resolveMissingAnyBins({
+		required: params.required.anyBins,
+		hasLocalBin: params.hasLocalBin,
+		hasRemoteAnyBin: params.hasRemoteAnyBin
+	});
+	const missingOs = resolveMissingOs({
+		required: params.required.os,
+		localPlatform: params.localPlatform,
+		remotePlatforms: params.remotePlatforms
+	});
+	const missingEnv = resolveMissingEnv({
+		required: params.required.env,
+		isSatisfied: params.isEnvSatisfied
+	});
+	const configChecks = buildConfigChecks({
+		required: params.required.config,
+		isSatisfied: params.isConfigSatisfied
+	});
+	const missingConfig = configChecks.filter((check) => !check.satisfied).map((check) => check.path);
+	const missing = params.always ? {
+		bins: [],
+		anyBins: [],
+		env: [],
+		config: [],
+		os: []
+	} : {
+		bins: missingBins,
+		anyBins: missingAnyBins,
+		env: missingEnv,
+		config: missingConfig,
+		os: missingOs
+	};
+	return {
+		missing,
+		eligible: params.always || missing.bins.length === 0 && missing.anyBins.length === 0 && missing.env.length === 0 && missing.config.length === 0 && missing.os.length === 0,
+		configChecks
+	};
+}
+function evaluateRequirementsFromMetadata(params) {
+	const required = {
+		bins: params.metadata?.requires?.bins ?? [],
+		anyBins: params.metadata?.requires?.anyBins ?? [],
+		env: params.metadata?.requires?.env ?? [],
+		config: params.metadata?.requires?.config ?? [],
+		os: params.metadata?.os ?? []
+	};
+	return {
+		required,
+		...evaluateRequirements({
+			always: params.always,
+			required,
+			hasLocalBin: params.hasLocalBin,
+			hasRemoteBin: params.hasRemoteBin,
+			hasRemoteAnyBin: params.hasRemoteAnyBin,
+			localPlatform: params.localPlatform,
+			remotePlatforms: params.remotePlatforms,
+			isEnvSatisfied: params.isEnvSatisfied,
+			isConfigSatisfied: params.isConfigSatisfied
+		})
+	};
+}
+function evaluateRequirementsFromMetadataWithRemote(params) {
+	return evaluateRequirementsFromMetadata({
+		always: params.always,
+		metadata: params.metadata,
+		hasLocalBin: params.hasLocalBin,
+		hasRemoteBin: params.remote?.hasBin,
+		hasRemoteAnyBin: params.remote?.hasAnyBin,
+		localPlatform: params.localPlatform,
+		remotePlatforms: params.remote?.platforms,
+		isEnvSatisfied: params.isEnvSatisfied,
+		isConfigSatisfied: params.isConfigSatisfied
+	});
+}
+
+//#endregion
+//#region src/shared/entry-status.ts
+function evaluateEntryMetadataRequirements(params) {
+	const { emoji, homepage } = resolveEmojiAndHomepage({
+		metadata: params.metadata,
+		frontmatter: params.frontmatter
+	});
+	const { required, missing, eligible, configChecks } = evaluateRequirementsFromMetadataWithRemote({
+		always: params.always,
+		metadata: params.metadata ?? void 0,
+		hasLocalBin: params.hasLocalBin,
+		localPlatform: params.localPlatform,
+		remote: params.remote,
+		isEnvSatisfied: params.isEnvSatisfied,
+		isConfigSatisfied: params.isConfigSatisfied
+	});
+	return {
+		...emoji ? { emoji } : {},
+		...homepage ? { homepage } : {},
+		required,
+		missing,
+		requirementsSatisfied: eligible,
+		configChecks
+	};
+}
+function evaluateEntryMetadataRequirementsForCurrentPlatform(params) {
+	return evaluateEntryMetadataRequirements({
+		...params,
+		localPlatform: process.platform
+	});
+}
+function evaluateEntryRequirementsForCurrentPlatform(params) {
+	return evaluateEntryMetadataRequirementsForCurrentPlatform({
+		always: params.always,
+		metadata: params.entry.metadata,
+		frontmatter: params.entry.frontmatter,
+		hasLocalBin: params.hasLocalBin,
+		remote: params.remote,
+		isEnvSatisfied: params.isEnvSatisfied,
+		isConfigSatisfied: params.isConfigSatisfied
+	});
+}
+
+//#endregion
+//#region src/hooks/hooks-status.ts
+function resolveHookKey(entry) {
+	return entry.metadata?.hookKey ?? entry.hook.name;
+}
+function normalizeInstallOptions(entry) {
+	const install = entry.metadata?.install ?? [];
+	if (install.length === 0) return [];
+	return install.map((spec, index) => {
+		const id = (spec.id ?? `${spec.kind}-${index}`).trim();
+		const bins = spec.bins ?? [];
+		let label = (spec.label ?? "").trim();
+		if (!label) if (spec.kind === "bundled") label = "Bundled with RemoteClaw";
+		else if (spec.kind === "npm" && spec.package) label = `Install ${spec.package} (npm)`;
+		else if (spec.kind === "git" && spec.repository) label = `Install from ${spec.repository}`;
+		else label = "Run installer";
+		return {
+			id,
+			kind: spec.kind,
+			label,
+			bins
+		};
+	});
+}
+function buildHookStatus(entry, config, eligibility) {
+	const hookKey = resolveHookKey(entry);
+	const hookConfig = resolveHookConfig(config, hookKey);
+	const managedByPlugin = entry.hook.source === "remoteclaw-plugin";
+	const disabled = managedByPlugin ? false : hookConfig?.enabled === false;
+	const always = entry.metadata?.always === true;
+	const events = entry.metadata?.events ?? [];
+	const isEnvSatisfied = (envName) => Boolean(process.env[envName] || hookConfig?.env?.[envName]);
+	const isConfigSatisfied = (pathStr) => isConfigPathTruthy(config, pathStr);
+	const { emoji, homepage, required, missing, requirementsSatisfied, configChecks } = evaluateEntryRequirementsForCurrentPlatform({
+		always,
+		entry,
+		hasLocalBin: hasBinary,
+		remote: eligibility?.remote,
+		isEnvSatisfied,
+		isConfigSatisfied
+	});
+	const eligible = !disabled && requirementsSatisfied;
+	return {
+		name: entry.hook.name,
+		description: entry.hook.description,
+		source: entry.hook.source,
+		pluginId: entry.hook.pluginId,
+		filePath: entry.hook.filePath,
+		baseDir: entry.hook.baseDir,
+		handlerPath: entry.hook.handlerPath,
+		hookKey,
+		emoji,
+		homepage,
+		events,
+		always,
+		disabled,
+		eligible,
+		managedByPlugin,
+		requirements: required,
+		missing,
+		configChecks,
+		install: normalizeInstallOptions(entry)
+	};
+}
+function buildWorkspaceHookStatus(workspaceDir, opts) {
+	return {
+		workspaceDir,
+		managedHooksDir: opts?.managedHooksDir ?? path.join(CONFIG_DIR, "hooks"),
+		hooks: (opts?.entries ?? loadWorkspaceHookEntries(workspaceDir, opts)).map((entry) => buildHookStatus(entry, opts?.config, opts?.eligibility))
+	};
+}
+
+//#endregion
+//#region src/hooks/install.ts
+const defaultLogger = {};
+function validateHookId(hookId) {
+	if (!hookId) return "invalid hook name: missing";
+	if (hookId === "." || hookId === "..") return "invalid hook name: reserved path segment";
+	if (hookId.includes("/") || hookId.includes("\\")) return "invalid hook name: path separators not allowed";
+	return null;
+}
+function resolveHookInstallDir(hookId, hooksDir) {
+	const hooksBase = hooksDir ? resolveUserPath(hooksDir) : path.join(CONFIG_DIR, "hooks");
+	const hookIdError = validateHookId(hookId);
+	if (hookIdError) throw new Error(hookIdError);
+	const targetDirResult = resolveSafeInstallDir({
+		baseDir: hooksBase,
+		id: hookId,
+		invalidNameMessage: "invalid hook name: path traversal detected"
+	});
+	if (!targetDirResult.ok) throw new Error(targetDirResult.error);
+	return targetDirResult.path;
+}
+async function ensureRemoteClawHooks(manifest) {
+	let hooks = manifest[MANIFEST_KEY]?.hooks;
+	if (!Array.isArray(hooks)) for (const key of LEGACY_MANIFEST_KEYS) {
+		const legacy = manifest[key]?.hooks;
+		if (Array.isArray(legacy)) {
+			hooks = legacy;
+			break;
+		}
+	}
+	if (!Array.isArray(hooks)) throw new Error("package.json missing remoteclaw.hooks");
+	const list = hooks.map((e) => typeof e === "string" ? e.trim() : "").filter(Boolean);
+	if (list.length === 0) throw new Error("package.json remoteclaw.hooks is empty");
+	return list;
+}
+async function resolveInstallTargetDir(id, hooksDir) {
+	const baseHooksDir = hooksDir ? resolveUserPath(hooksDir) : path.join(CONFIG_DIR, "hooks");
+	await fs$1.mkdir(baseHooksDir, { recursive: true });
+	const targetDirResult = resolveSafeInstallDir({
+		baseDir: baseHooksDir,
+		id,
+		invalidNameMessage: "invalid hook name: path traversal detected"
+	});
+	if (!targetDirResult.ok) return {
+		ok: false,
+		error: targetDirResult.error
+	};
+	return {
+		ok: true,
+		targetDir: targetDirResult.path
+	};
+}
+async function resolveHookNameFromDir(hookDir) {
+	const hookMdPath = path.join(hookDir, "HOOK.md");
+	if (!await fileExists(hookMdPath)) throw new Error(`HOOK.md missing in ${hookDir}`);
+	return parseFrontmatter(await fs$1.readFile(hookMdPath, "utf-8")).name || path.basename(hookDir);
+}
+async function validateHookDir(hookDir) {
+	if (!await fileExists(path.join(hookDir, "HOOK.md"))) throw new Error(`HOOK.md missing in ${hookDir}`);
+	if (!await Promise.all([
+		"handler.ts",
+		"handler.js",
+		"index.ts",
+		"index.js"
+	].map(async (candidate) => fileExists(path.join(hookDir, candidate)))).then((results) => results.some(Boolean))) throw new Error(`handler.ts/handler.js/index.ts/index.js missing in ${hookDir}`);
+}
+async function installHookPackageFromDir(params) {
+	const { logger, timeoutMs, mode, dryRun } = resolveTimedInstallModeOptions(params, defaultLogger);
+	const manifestPath = path.join(params.packageDir, "package.json");
+	if (!await fileExists(manifestPath)) return {
+		ok: false,
+		error: "package.json missing"
+	};
+	let manifest;
+	try {
+		manifest = await readJsonFile(manifestPath);
+	} catch (err) {
+		return {
+			ok: false,
+			error: `invalid package.json: ${String(err)}`
+		};
+	}
+	let hookEntries;
+	try {
+		hookEntries = await ensureRemoteClawHooks(manifest);
+	} catch (err) {
+		return {
+			ok: false,
+			error: String(err)
+		};
+	}
+	const pkgName = typeof manifest.name === "string" ? manifest.name : "";
+	const hookPackId = pkgName ? unscopedPackageName(pkgName) : path.basename(params.packageDir);
+	const hookIdError = validateHookId(hookPackId);
+	if (hookIdError) return {
+		ok: false,
+		error: hookIdError
+	};
+	if (params.expectedHookPackId && params.expectedHookPackId !== hookPackId) return {
+		ok: false,
+		error: `hook pack id mismatch: expected ${params.expectedHookPackId}, got ${hookPackId}`
+	};
+	const targetDirResult = await resolveInstallTargetDir(hookPackId, params.hooksDir);
+	if (!targetDirResult.ok) return {
+		ok: false,
+		error: targetDirResult.error
+	};
+	const targetDir = targetDirResult.targetDir;
+	if (mode === "install" && await fileExists(targetDir)) return {
+		ok: false,
+		error: `hook pack already exists: ${targetDir} (delete it first)`
+	};
+	const resolvedHooks = [];
+	for (const entry of hookEntries) {
+		const hookDir = path.resolve(params.packageDir, entry);
+		if (!isPathInside(params.packageDir, hookDir)) return {
+			ok: false,
+			error: `remoteclaw.hooks entry escapes package directory: ${entry}`
+		};
+		await validateHookDir(hookDir);
+		if (!isPathInsideWithRealpath(params.packageDir, hookDir, { requireRealpath: true })) return {
+			ok: false,
+			error: `remoteclaw.hooks entry resolves outside package directory: ${entry}`
+		};
+		const hookName = await resolveHookNameFromDir(hookDir);
+		resolvedHooks.push(hookName);
+	}
+	if (dryRun) return {
+		ok: true,
+		hookPackId,
+		hooks: resolvedHooks,
+		targetDir,
+		version: typeof manifest.version === "string" ? manifest.version : void 0
+	};
+	const deps = manifest.dependencies ?? {};
+	const hasDeps = Object.keys(deps).length > 0;
+	const installRes = await installPackageDir({
+		sourceDir: params.packageDir,
+		targetDir,
+		mode,
+		timeoutMs,
+		logger,
+		copyErrorPrefix: "failed to copy hook pack",
+		hasDeps,
+		depsLogMessage: "Installing hook pack dependencies…"
+	});
+	if (!installRes.ok) return installRes;
+	return {
+		ok: true,
+		hookPackId,
+		hooks: resolvedHooks,
+		targetDir,
+		version: typeof manifest.version === "string" ? manifest.version : void 0
+	};
+}
+async function installHookFromDir(params) {
+	const { logger, mode, dryRun } = resolveInstallModeOptions(params, defaultLogger);
+	await validateHookDir(params.hookDir);
+	const hookName = await resolveHookNameFromDir(params.hookDir);
+	const hookIdError = validateHookId(hookName);
+	if (hookIdError) return {
+		ok: false,
+		error: hookIdError
+	};
+	if (params.expectedHookPackId && params.expectedHookPackId !== hookName) return {
+		ok: false,
+		error: `hook id mismatch: expected ${params.expectedHookPackId}, got ${hookName}`
+	};
+	const targetDirResult = await resolveInstallTargetDir(hookName, params.hooksDir);
+	if (!targetDirResult.ok) return {
+		ok: false,
+		error: targetDirResult.error
+	};
+	const targetDir = targetDirResult.targetDir;
+	if (mode === "install" && await fileExists(targetDir)) return {
+		ok: false,
+		error: `hook already exists: ${targetDir} (delete it first)`
+	};
+	if (dryRun) return {
+		ok: true,
+		hookPackId: hookName,
+		hooks: [hookName],
+		targetDir
+	};
+	logger.info?.(`Installing to ${targetDir}…`);
+	let backupDir = null;
+	if (mode === "update" && await fileExists(targetDir)) {
+		backupDir = `${targetDir}.backup-${Date.now()}`;
+		await fs$1.rename(targetDir, backupDir);
+	}
+	try {
+		await fs$1.cp(params.hookDir, targetDir, { recursive: true });
+	} catch (err) {
+		if (backupDir) {
+			await fs$1.rm(targetDir, {
+				recursive: true,
+				force: true
+			}).catch(() => void 0);
+			await fs$1.rename(backupDir, targetDir).catch(() => void 0);
+		}
+		return {
+			ok: false,
+			error: `failed to copy hook: ${String(err)}`
+		};
+	}
+	if (backupDir) await fs$1.rm(backupDir, {
+		recursive: true,
+		force: true
+	}).catch(() => void 0);
+	return {
+		ok: true,
+		hookPackId: hookName,
+		hooks: [hookName],
+		targetDir
+	};
+}
+async function installHooksFromArchive(params) {
+	const logger = params.logger ?? defaultLogger;
+	const timeoutMs = params.timeoutMs ?? 12e4;
+	const archivePathResult = await resolveArchiveSourcePath(params.archivePath);
+	if (!archivePathResult.ok) return archivePathResult;
+	const archivePath = archivePathResult.path;
+	return await withExtractedArchiveRoot({
+		archivePath,
+		tempDirPrefix: "remoteclaw-hook-",
+		timeoutMs,
+		logger,
+		onExtracted: async (rootDir) => {
+			if (await fileExists(path.join(rootDir, "package.json"))) return await installHookPackageFromDir({
+				packageDir: rootDir,
+				hooksDir: params.hooksDir,
+				timeoutMs,
+				logger,
+				mode: params.mode,
+				dryRun: params.dryRun,
+				expectedHookPackId: params.expectedHookPackId
+			});
+			return await installHookFromDir({
+				hookDir: rootDir,
+				hooksDir: params.hooksDir,
+				logger,
+				mode: params.mode,
+				dryRun: params.dryRun,
+				expectedHookPackId: params.expectedHookPackId
+			});
+		}
+	});
+}
+async function installHooksFromNpmSpec(params) {
+	const { logger, timeoutMs, mode, dryRun } = resolveTimedInstallModeOptions(params, defaultLogger);
+	const expectedHookPackId = params.expectedHookPackId;
+	const spec = params.spec.trim();
+	const specError = validateRegistryNpmSpec(spec);
+	if (specError) return {
+		ok: false,
+		error: specError
+	};
+	logger.info?.(`Downloading ${spec}…`);
+	return finalizeNpmSpecArchiveInstall(await installFromNpmSpecArchiveWithInstaller({
+		tempDirPrefix: "remoteclaw-hook-pack-",
+		spec,
+		timeoutMs,
+		expectedIntegrity: params.expectedIntegrity,
+		onIntegrityDrift: params.onIntegrityDrift,
+		warn: (message) => {
+			logger.warn?.(message);
+		},
+		installFromArchive: installHooksFromArchive,
+		archiveInstallParams: {
+			hooksDir: params.hooksDir,
+			timeoutMs,
+			logger,
+			mode,
+			dryRun,
+			expectedHookPackId
+		}
+	}));
+}
+async function installHooksFromPath(params) {
+	const pathResult = await resolveExistingInstallPath(params.path);
+	if (!pathResult.ok) return pathResult;
+	const { resolvedPath: resolved, stat } = pathResult;
+	if (stat.isDirectory()) {
+		if (await fileExists(path.join(resolved, "package.json"))) return await installHookPackageFromDir({
+			packageDir: resolved,
+			hooksDir: params.hooksDir,
+			timeoutMs: params.timeoutMs,
+			logger: params.logger,
+			mode: params.mode,
+			dryRun: params.dryRun,
+			expectedHookPackId: params.expectedHookPackId
+		});
+		return await installHookFromDir({
+			hookDir: resolved,
+			hooksDir: params.hooksDir,
+			logger: params.logger,
+			mode: params.mode,
+			dryRun: params.dryRun,
+			expectedHookPackId: params.expectedHookPackId
+		});
+	}
+	if (!resolveArchiveKind(resolved)) return {
+		ok: false,
+		error: `unsupported hook file: ${resolved}`
+	};
+	return await installHooksFromArchive({
+		archivePath: resolved,
+		hooksDir: params.hooksDir,
+		timeoutMs: params.timeoutMs,
+		logger: params.logger,
+		mode: params.mode,
+		dryRun: params.dryRun,
+		expectedHookPackId: params.expectedHookPackId
+	});
+}
+
+//#endregion
+//#region src/hooks/installs.ts
+function recordHookInstall(cfg, update) {
+	const { hookId, ...record } = update;
+	const installs = {
+		...cfg.hooks?.internal?.installs,
+		[hookId]: {
+			...cfg.hooks?.internal?.installs?.[hookId],
+			...record,
+			installedAt: record.installedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+		}
+	};
+	return {
+		...cfg,
+		hooks: {
+			...cfg.hooks,
+			internal: {
+				...cfg.hooks?.internal,
+				installs: {
+					...installs,
+					[hookId]: installs[hookId]
+				}
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/cli/hooks-cli.ts
+function mergeHookEntries(pluginEntries, workspaceEntries) {
+	const merged = /* @__PURE__ */ new Map();
+	for (const entry of pluginEntries) merged.set(entry.hook.name, entry);
+	for (const entry of workspaceEntries) merged.set(entry.hook.name, entry);
+	return Array.from(merged.values());
+}
+function buildHooksReport(config) {
+	const workspaceDir = resolveAgentWorkspaceDir(config, resolveDefaultAgentId(config));
+	const workspaceEntries = loadWorkspaceHookEntries(workspaceDir, { config });
+	return buildWorkspaceHookStatus(workspaceDir, {
+		config,
+		entries: mergeHookEntries(buildPluginStatusReport({
+			config,
+			workspaceDir
+		}).hooks.map((hook) => hook.entry), workspaceEntries)
+	});
+}
+function resolveHookForToggle(report, hookName, opts) {
+	const hook = report.hooks.find((h) => h.name === hookName);
+	if (!hook) throw new Error(`Hook "${hookName}" not found`);
+	if (hook.managedByPlugin) throw new Error(`Hook "${hookName}" is managed by plugin "${hook.pluginId ?? "unknown"}" and cannot be enabled/disabled.`);
+	if (opts?.requireEligible && !hook.eligible) throw new Error(`Hook "${hookName}" is not eligible (missing requirements)`);
+	return hook;
+}
+function buildConfigWithHookEnabled(params) {
+	const entries = { ...params.config.hooks?.internal?.entries };
+	entries[params.hookName] = {
+		...entries[params.hookName],
+		enabled: params.enabled
+	};
+	const internal = {
+		...params.config.hooks?.internal,
+		...params.ensureHooksEnabled ? { enabled: true } : {},
+		entries
+	};
+	return {
+		...params.config,
+		hooks: {
+			...params.config.hooks,
+			internal
+		}
+	};
+}
+function formatHookStatus(hook) {
+	if (hook.eligible) return theme.success("✓ ready");
+	if (hook.disabled) return theme.warn("⏸ disabled");
+	return theme.error("✗ missing");
+}
+function formatHookName(hook) {
+	return `${hook.emoji ?? "🔗"} ${theme.command(hook.name)}`;
+}
+function formatHookSource(hook) {
+	if (!hook.managedByPlugin) return hook.source;
+	return `plugin:${hook.pluginId ?? "unknown"}`;
+}
+function formatHookMissingSummary(hook) {
+	const missing = [];
+	if (hook.missing.bins.length > 0) missing.push(`bins: ${hook.missing.bins.join(", ")}`);
+	if (hook.missing.anyBins.length > 0) missing.push(`anyBins: ${hook.missing.anyBins.join(", ")}`);
+	if (hook.missing.env.length > 0) missing.push(`env: ${hook.missing.env.join(", ")}`);
+	if (hook.missing.config.length > 0) missing.push(`config: ${hook.missing.config.join(", ")}`);
+	if (hook.missing.os.length > 0) missing.push(`os: ${hook.missing.os.join(", ")}`);
+	return missing.join("; ");
+}
+function exitHooksCliWithError(err) {
+	defaultRuntime.error(`${theme.error("Error:")} ${err instanceof Error ? err.message : String(err)}`);
+	process.exit(1);
+}
+async function runHooksCliAction(action) {
+	try {
+		await action();
+	} catch (err) {
+		exitHooksCliWithError(err);
+	}
+}
+function createInstallLogger() {
+	return {
+		info: (msg) => defaultRuntime.log(msg),
+		warn: (msg) => defaultRuntime.log(theme.warn(msg))
+	};
+}
+function logGatewayRestartHint() {
+	defaultRuntime.log("Restart the gateway to load hooks.");
+}
+function logIntegrityDriftWarning(hookId, drift) {
+	const specLabel = drift.resolution.resolvedSpec ?? drift.spec;
+	defaultRuntime.log(theme.warn(`Integrity drift detected for "${hookId}" (${specLabel})\nExpected: ${drift.expectedIntegrity}\nActual:   ${drift.actualIntegrity}`));
+}
+async function readInstalledPackageVersion(dir) {
+	try {
+		const raw = await fs$1.readFile(path.join(dir, "package.json"), "utf-8");
+		const parsed = JSON.parse(raw);
+		return typeof parsed.version === "string" ? parsed.version : void 0;
+	} catch {
+		return;
+	}
+}
+function enableInternalHookEntries(config, hookNames) {
+	const entries = { ...config.hooks?.internal?.entries };
+	for (const hookName of hookNames) entries[hookName] = {
+		...entries[hookName],
+		enabled: true
+	};
+	return {
+		...config,
+		hooks: {
+			...config.hooks,
+			internal: {
+				...config.hooks?.internal,
+				enabled: true,
+				entries
+			}
+		}
+	};
+}
+/**
+* Format the hooks list output
+*/
+function formatHooksList(report, opts) {
+	const hooks = opts.eligible ? report.hooks.filter((h) => h.eligible) : report.hooks;
+	if (opts.json) {
+		const jsonReport = {
+			workspaceDir: report.workspaceDir,
+			managedHooksDir: report.managedHooksDir,
+			hooks: hooks.map((h) => ({
+				name: h.name,
+				description: h.description,
+				emoji: h.emoji,
+				eligible: h.eligible,
+				disabled: h.disabled,
+				source: h.source,
+				pluginId: h.pluginId,
+				events: h.events,
+				homepage: h.homepage,
+				missing: h.missing,
+				managedByPlugin: h.managedByPlugin
+			}))
+		};
+		return JSON.stringify(jsonReport, null, 2);
+	}
+	if (hooks.length === 0) return opts.eligible ? `No eligible hooks found. Run \`${formatCliCommand("remoteclaw hooks list")}\` to see all hooks.` : "No hooks found.";
+	const eligible = hooks.filter((h) => h.eligible);
+	const tableWidth = Math.max(60, (process.stdout.columns ?? 120) - 1);
+	const rows = hooks.map((hook) => {
+		const missing = formatHookMissingSummary(hook);
+		return {
+			Status: formatHookStatus(hook),
+			Hook: formatHookName(hook),
+			Description: theme.muted(hook.description),
+			Source: formatHookSource(hook),
+			Missing: missing ? theme.warn(missing) : ""
+		};
+	});
+	const columns = [
+		{
+			key: "Status",
+			header: "Status",
+			minWidth: 10
+		},
+		{
+			key: "Hook",
+			header: "Hook",
+			minWidth: 18,
+			flex: true
+		},
+		{
+			key: "Description",
+			header: "Description",
+			minWidth: 24,
+			flex: true
+		},
+		{
+			key: "Source",
+			header: "Source",
+			minWidth: 12,
+			flex: true
+		}
+	];
+	if (opts.verbose) columns.push({
+		key: "Missing",
+		header: "Missing",
+		minWidth: 18,
+		flex: true
+	});
+	const lines = [];
+	lines.push(`${theme.heading("Hooks")} ${theme.muted(`(${eligible.length}/${hooks.length} ready)`)}`);
+	lines.push(renderTable({
+		width: tableWidth,
+		columns,
+		rows
+	}).trimEnd());
+	return lines.join("\n");
+}
+/**
+* Format detailed info for a single hook
+*/
+function formatHookInfo(report, hookName, opts) {
+	const hook = report.hooks.find((h) => h.name === hookName || h.hookKey === hookName);
+	if (!hook) {
+		if (opts.json) return JSON.stringify({
+			error: "not found",
+			hook: hookName
+		}, null, 2);
+		return `Hook "${hookName}" not found. Run \`${formatCliCommand("remoteclaw hooks list")}\` to see available hooks.`;
+	}
+	if (opts.json) return JSON.stringify(hook, null, 2);
+	const lines = [];
+	const emoji = hook.emoji ?? "🔗";
+	const status = hook.eligible ? theme.success("✓ Ready") : hook.disabled ? theme.warn("⏸ Disabled") : theme.error("✗ Missing requirements");
+	lines.push(`${emoji} ${theme.heading(hook.name)} ${status}`);
+	lines.push("");
+	lines.push(hook.description);
+	lines.push("");
+	lines.push(theme.heading("Details:"));
+	if (hook.managedByPlugin) lines.push(`${theme.muted("  Source:")} ${hook.source} (${hook.pluginId ?? "unknown"})`);
+	else lines.push(`${theme.muted("  Source:")} ${hook.source}`);
+	lines.push(`${theme.muted("  Path:")} ${shortenHomePath(hook.filePath)}`);
+	lines.push(`${theme.muted("  Handler:")} ${shortenHomePath(hook.handlerPath)}`);
+	if (hook.homepage) lines.push(`${theme.muted("  Homepage:")} ${hook.homepage}`);
+	if (hook.events.length > 0) lines.push(`${theme.muted("  Events:")} ${hook.events.join(", ")}`);
+	if (hook.managedByPlugin) lines.push(theme.muted("  Managed by plugin; enable/disable via hooks CLI not available."));
+	if (hook.requirements.bins.length > 0 || hook.requirements.anyBins.length > 0 || hook.requirements.env.length > 0 || hook.requirements.config.length > 0 || hook.requirements.os.length > 0) {
+		lines.push("");
+		lines.push(theme.heading("Requirements:"));
+		if (hook.requirements.bins.length > 0) {
+			const binsStatus = hook.requirements.bins.map((bin) => {
+				return hook.missing.bins.includes(bin) ? theme.error(`✗ ${bin}`) : theme.success(`✓ ${bin}`);
+			});
+			lines.push(`${theme.muted("  Binaries:")} ${binsStatus.join(", ")}`);
+		}
+		if (hook.requirements.anyBins.length > 0) {
+			const anyBinsStatus = hook.missing.anyBins.length > 0 ? theme.error(`✗ (any of: ${hook.requirements.anyBins.join(", ")})`) : theme.success(`✓ (any of: ${hook.requirements.anyBins.join(", ")})`);
+			lines.push(`${theme.muted("  Any binary:")} ${anyBinsStatus}`);
+		}
+		if (hook.requirements.env.length > 0) {
+			const envStatus = hook.requirements.env.map((env) => {
+				return hook.missing.env.includes(env) ? theme.error(`✗ ${env}`) : theme.success(`✓ ${env}`);
+			});
+			lines.push(`${theme.muted("  Environment:")} ${envStatus.join(", ")}`);
+		}
+		if (hook.requirements.config.length > 0) {
+			const configStatus = hook.configChecks.map((check) => {
+				return check.satisfied ? theme.success(`✓ ${check.path}`) : theme.error(`✗ ${check.path}`);
+			});
+			lines.push(`${theme.muted("  Config:")} ${configStatus.join(", ")}`);
+		}
+		if (hook.requirements.os.length > 0) {
+			const osStatus = hook.missing.os.length > 0 ? theme.error(`✗ (${hook.requirements.os.join(", ")})`) : theme.success(`✓ (${hook.requirements.os.join(", ")})`);
+			lines.push(`${theme.muted("  OS:")} ${osStatus}`);
+		}
+	}
+	return lines.join("\n");
+}
+/**
+* Format check output
+*/
+function formatHooksCheck(report, opts) {
+	if (opts.json) {
+		const eligible = report.hooks.filter((h) => h.eligible);
+		const notEligible = report.hooks.filter((h) => !h.eligible);
+		return JSON.stringify({
+			total: report.hooks.length,
+			eligible: eligible.length,
+			notEligible: notEligible.length,
+			hooks: {
+				eligible: eligible.map((h) => h.name),
+				notEligible: notEligible.map((h) => ({
+					name: h.name,
+					missing: h.missing
+				}))
+			}
+		}, null, 2);
+	}
+	const eligible = report.hooks.filter((h) => h.eligible);
+	const notEligible = report.hooks.filter((h) => !h.eligible);
+	const lines = [];
+	lines.push(theme.heading("Hooks Status"));
+	lines.push("");
+	lines.push(`${theme.muted("Total hooks:")} ${report.hooks.length}`);
+	lines.push(`${theme.success("Ready:")} ${eligible.length}`);
+	lines.push(`${theme.warn("Not ready:")} ${notEligible.length}`);
+	if (notEligible.length > 0) {
+		lines.push("");
+		lines.push(theme.heading("Hooks not ready:"));
+		for (const hook of notEligible) {
+			const reasons = [];
+			if (hook.disabled) reasons.push("disabled");
+			if (hook.missing.bins.length > 0) reasons.push(`bins: ${hook.missing.bins.join(", ")}`);
+			if (hook.missing.anyBins.length > 0) reasons.push(`anyBins: ${hook.missing.anyBins.join(", ")}`);
+			if (hook.missing.env.length > 0) reasons.push(`env: ${hook.missing.env.join(", ")}`);
+			if (hook.missing.config.length > 0) reasons.push(`config: ${hook.missing.config.join(", ")}`);
+			if (hook.missing.os.length > 0) reasons.push(`os: ${hook.missing.os.join(", ")}`);
+			lines.push(`  ${hook.emoji ?? "🔗"} ${hook.name} - ${reasons.join("; ")}`);
+		}
+	}
+	return lines.join("\n");
+}
+async function enableHook(hookName) {
+	const config = loadConfig();
+	const hook = resolveHookForToggle(buildHooksReport(config), hookName, { requireEligible: true });
+	await writeConfigFile(buildConfigWithHookEnabled({
+		config,
+		hookName,
+		enabled: true,
+		ensureHooksEnabled: true
+	}));
+	defaultRuntime.log(`${theme.success("✓")} Enabled hook: ${hook.emoji ?? "🔗"} ${theme.command(hookName)}`);
+}
+async function disableHook(hookName) {
+	const config = loadConfig();
+	const hook = resolveHookForToggle(buildHooksReport(config), hookName);
+	await writeConfigFile(buildConfigWithHookEnabled({
+		config,
+		hookName,
+		enabled: false
+	}));
+	defaultRuntime.log(`${theme.warn("⏸")} Disabled hook: ${hook.emoji ?? "🔗"} ${theme.command(hookName)}`);
+}
+function registerHooksCli(program) {
+	const hooks = program.command("hooks").description("Manage internal agent hooks").addHelpText("after", () => `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/hooks", "docs.remoteclaw.org/cli/hooks")}\n`);
+	hooks.command("list").description("List all hooks").option("--eligible", "Show only eligible hooks", false).option("--json", "Output as JSON", false).option("-v, --verbose", "Show more details including missing requirements", false).action(async (opts) => runHooksCliAction(async () => {
+		const report = buildHooksReport(loadConfig());
+		defaultRuntime.log(formatHooksList(report, opts));
+	}));
+	hooks.command("info <name>").description("Show detailed information about a hook").option("--json", "Output as JSON", false).action(async (name, opts) => runHooksCliAction(async () => {
+		const report = buildHooksReport(loadConfig());
+		defaultRuntime.log(formatHookInfo(report, name, opts));
+	}));
+	hooks.command("check").description("Check hooks eligibility status").option("--json", "Output as JSON", false).action(async (opts) => runHooksCliAction(async () => {
+		const report = buildHooksReport(loadConfig());
+		defaultRuntime.log(formatHooksCheck(report, opts));
+	}));
+	hooks.command("enable <name>").description("Enable a hook").action(async (name) => runHooksCliAction(async () => {
+		await enableHook(name);
+	}));
+	hooks.command("disable <name>").description("Disable a hook").action(async (name) => runHooksCliAction(async () => {
+		await disableHook(name);
+	}));
+	hooks.command("install").description("Install a hook pack (path, archive, or npm spec)").argument("<path-or-spec>", "Path to a hook pack or npm package spec").option("-l, --link", "Link a local path instead of copying", false).option("--pin", "Record npm installs as exact resolved <name>@<version>", false).action(async (raw, opts) => {
+		const resolved = resolveUserPath(raw);
+		const cfg = loadConfig();
+		if (fs.existsSync(resolved)) {
+			if (opts.link) {
+				if (!fs.statSync(resolved).isDirectory()) {
+					defaultRuntime.error("Linked hook paths must be directories.");
+					process.exit(1);
+				}
+				const existing = cfg.hooks?.internal?.load?.extraDirs ?? [];
+				const merged = Array.from(new Set([...existing, resolved]));
+				const probe = await installHooksFromPath({
+					path: resolved,
+					dryRun: true
+				});
+				if (!probe.ok) {
+					defaultRuntime.error(probe.error);
+					process.exit(1);
+				}
+				let next = {
+					...cfg,
+					hooks: {
+						...cfg.hooks,
+						internal: {
+							...cfg.hooks?.internal,
+							enabled: true,
+							load: {
+								...cfg.hooks?.internal?.load,
+								extraDirs: merged
+							}
+						}
+					}
+				};
+				next = enableInternalHookEntries(next, probe.hooks);
+				next = recordHookInstall(next, {
+					hookId: probe.hookPackId,
+					source: "path",
+					sourcePath: resolved,
+					installPath: resolved,
+					version: probe.version,
+					hooks: probe.hooks
+				});
+				await writeConfigFile(next);
+				defaultRuntime.log(`Linked hook path: ${shortenHomePath(resolved)}`);
+				logGatewayRestartHint();
+				return;
+			}
+			const result = await installHooksFromPath({
+				path: resolved,
+				logger: createInstallLogger()
+			});
+			if (!result.ok) {
+				defaultRuntime.error(result.error);
+				process.exit(1);
+			}
+			let next = enableInternalHookEntries(cfg, result.hooks);
+			const source = resolveArchiveKind(resolved) ? "archive" : "path";
+			next = recordHookInstall(next, {
+				hookId: result.hookPackId,
+				source,
+				sourcePath: resolved,
+				installPath: result.targetDir,
+				version: result.version,
+				hooks: result.hooks
+			});
+			await writeConfigFile(next);
+			defaultRuntime.log(`Installed hooks: ${result.hooks.join(", ")}`);
+			logGatewayRestartHint();
+			return;
+		}
+		if (opts.link) {
+			defaultRuntime.error("`--link` requires a local path.");
+			process.exit(1);
+		}
+		if (raw.startsWith(".") || raw.startsWith("~") || path.isAbsolute(raw) || raw.endsWith(".zip") || raw.endsWith(".tgz") || raw.endsWith(".tar.gz") || raw.endsWith(".tar")) {
+			defaultRuntime.error(`Path not found: ${resolved}`);
+			process.exit(1);
+		}
+		const result = await installHooksFromNpmSpec({
+			spec: raw,
+			logger: createInstallLogger()
+		});
+		if (!result.ok) {
+			defaultRuntime.error(result.error);
+			process.exit(1);
+		}
+		let next = enableInternalHookEntries(cfg, result.hooks);
+		const installRecord = resolvePinnedNpmInstallRecordForCli(raw, Boolean(opts.pin), result.targetDir, result.version, result.npmResolution, defaultRuntime.log, theme.warn);
+		next = recordHookInstall(next, {
+			hookId: result.hookPackId,
+			...installRecord,
+			hooks: result.hooks
+		});
+		await writeConfigFile(next);
+		defaultRuntime.log(`Installed hooks: ${result.hooks.join(", ")}`);
+		logGatewayRestartHint();
+	});
+	hooks.command("update").description("Update installed hooks (npm installs only)").argument("[id]", "Hook pack id (omit with --all)").option("--all", "Update all tracked hooks", false).option("--dry-run", "Show what would change without writing", false).action(async (id, opts) => {
+		const cfg = loadConfig();
+		const installs = cfg.hooks?.internal?.installs ?? {};
+		const targets = opts.all ? Object.keys(installs) : id ? [id] : [];
+		if (targets.length === 0) {
+			defaultRuntime.error("Provide a hook id or use --all.");
+			process.exit(1);
+		}
+		let nextCfg = cfg;
+		let updatedCount = 0;
+		for (const hookId of targets) {
+			const record = installs[hookId];
+			if (!record) {
+				defaultRuntime.log(theme.warn(`No install record for "${hookId}".`));
+				continue;
+			}
+			if (record.source !== "npm") {
+				defaultRuntime.log(theme.warn(`Skipping "${hookId}" (source: ${record.source}).`));
+				continue;
+			}
+			if (!record.spec) {
+				defaultRuntime.log(theme.warn(`Skipping "${hookId}" (missing npm spec).`));
+				continue;
+			}
+			let installPath;
+			try {
+				installPath = record.installPath ?? resolveHookInstallDir(hookId);
+			} catch (err) {
+				defaultRuntime.log(theme.error(`Invalid install path for "${hookId}": ${String(err)}`));
+				continue;
+			}
+			const currentVersion = await readInstalledPackageVersion(installPath);
+			if (opts.dryRun) {
+				const probe = await installHooksFromNpmSpec({
+					spec: record.spec,
+					mode: "update",
+					dryRun: true,
+					expectedHookPackId: hookId,
+					expectedIntegrity: record.integrity,
+					onIntegrityDrift: async (drift) => {
+						logIntegrityDriftWarning(hookId, drift);
+						return true;
+					},
+					logger: createInstallLogger()
+				});
+				if (!probe.ok) {
+					defaultRuntime.log(theme.error(`Failed to check ${hookId}: ${probe.error}`));
+					continue;
+				}
+				const nextVersion = probe.version ?? "unknown";
+				const currentLabel = currentVersion ?? "unknown";
+				if (currentVersion && probe.version && currentVersion === probe.version) defaultRuntime.log(`${hookId} is up to date (${currentLabel}).`);
+				else defaultRuntime.log(`Would update ${hookId}: ${currentLabel} → ${nextVersion}.`);
+				continue;
+			}
+			const result = await installHooksFromNpmSpec({
+				spec: record.spec,
+				mode: "update",
+				expectedHookPackId: hookId,
+				expectedIntegrity: record.integrity,
+				onIntegrityDrift: async (drift) => {
+					logIntegrityDriftWarning(hookId, drift);
+					return await promptYesNo(`Continue updating "${hookId}" with this artifact?`);
+				},
+				logger: createInstallLogger()
+			});
+			if (!result.ok) {
+				defaultRuntime.log(theme.error(`Failed to update ${hookId}: ${result.error}`));
+				continue;
+			}
+			const nextVersion = result.version ?? await readInstalledPackageVersion(result.targetDir);
+			nextCfg = recordHookInstall(nextCfg, {
+				hookId,
+				...buildNpmInstallRecordFields({
+					spec: record.spec,
+					installPath: result.targetDir,
+					version: nextVersion,
+					resolution: result.npmResolution
+				}),
+				hooks: result.hooks
+			});
+			updatedCount += 1;
+			const currentLabel = currentVersion ?? "unknown";
+			const nextLabel = nextVersion ?? "unknown";
+			if (currentVersion && nextVersion && currentVersion === nextVersion) defaultRuntime.log(`${hookId} already at ${currentLabel}.`);
+			else defaultRuntime.log(`Updated ${hookId}: ${currentLabel} → ${nextLabel}.`);
+		}
+		if (updatedCount > 0) {
+			await writeConfigFile(nextCfg);
+			logGatewayRestartHint();
+		}
+	});
+	hooks.action(async () => runHooksCliAction(async () => {
+		const report = buildHooksReport(loadConfig());
+		defaultRuntime.log(formatHooksList(report, {}));
+	}));
+}
+
+//#endregion
+export { registerHooksCli };