@pixelzx/genesis 2026.5.3-5 → 2026.5.5

package/dist/clawbot-cli-CSmdcIMT.js

@@ -0,0 +1,9 @@
+import { t as formatDocsLink } from "./links-DmsJCU7L.js";
+import { r as theme } from "./theme-BrRleVfL.js";
+import { t as registerQrCli } from "./qr-cli-DmPti3xe.js";
+//#region src/cli/clawbot-cli.ts
+function registerClawbotCli(program) {
+	registerQrCli(program.command("clawbot").description("Legacy clawbot command aliases").addHelpText("after", () => `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/clawbot", "docs.genesis.ai/cli/clawbot")}\n`));
+}
+//#endregion
+export { registerClawbotCli };

package/dist/cli/daemon-cli.js

@@ -1,8 +1,8 @@
 // Legacy shim for pre-tsdown update-cli imports.
-import * as daemonCli from "../daemon-cli-TCubZfI_.js";
+import * as daemonCli from "../daemon-cli-C_9CNoZA.js";
 import * as daemonCliRunners0 from "../install.runtime-BclRAjYc.js";
-import * as daemonCliRunners1 from "../lifecycle.runtime-DoosWTnK.js";
-import * as daemonCliRunners2 from "../status.runtime-Cxyb3wHZ.js";
+import * as daemonCliRunners1 from "../lifecycle.runtime-DErLwVJ_.js";
+import * as daemonCliRunners2 from "../status.runtime-BFru2C4v.js";
 export const registerDaemonCli = daemonCli.t;
 export const runDaemonInstall = daemonCliRunners0.runDaemonInstall;
 export const runDaemonRestart = daemonCliRunners1.runDaemonRestart;

package/dist/cli-2u5IZTMS.js

@@ -0,0 +1,219 @@
+import { a as loadConfig, u as readConfigFileSnapshot } from "./io-h8M_Z0Lj.js";
+import "./config-B3ZoZd5V.js";
+import { i as GATEWAY_CLIENT_NAMES, r as GATEWAY_CLIENT_MODES } from "./client-info-CfESmEX1.js";
+import { t as resolveManifestActivationPluginIds } from "./activation-planner-DLBGDJz1.js";
+import { n as loadGenesisPluginCliRegistry, r as loadGenesisPlugins } from "./loader-D3VsvOWx.js";
+import { n as collectUniqueCommandDescriptors } from "./command-descriptor-utils-BdCjETQ9.js";
+import { i as resolvePluginRuntimeLoadContext, r as createPluginRuntimeLoaderLogger, t as buildPluginRuntimeLoadOptions } from "./load-context-avthPPkW.js";
+import { r as callGateway } from "./call-DkGNVvLy.js";
+import { a as registerLazyCommandGroup, n as getCommandGroupNames, o as removeCommandGroupNames, t as findCommandGroupEntry } from "./register-command-groups-q1NXEnfT.js";
+import { randomUUID } from "node:crypto";
+//#region src/plugins/cli-gateway-nodes-runtime.ts
+function createPluginCliGatewayNodesRuntime() {
+	return {
+		async list(params) {
+			const payload = await callGateway({
+				method: "node.list",
+				params: {},
+				clientName: GATEWAY_CLIENT_NAMES.CLI,
+				mode: GATEWAY_CLIENT_MODES.CLI
+			});
+			const nodes = Array.isArray(payload?.nodes) ? payload.nodes : [];
+			return { nodes: params?.connected === true ? nodes.filter((node) => node !== null && typeof node === "object" && node.connected === true) : nodes };
+		},
+		async invoke(params) {
+			return await callGateway({
+				method: "node.invoke",
+				params: {
+					nodeId: params.nodeId,
+					command: params.command,
+					...params.params !== void 0 && { params: params.params },
+					timeoutMs: params.timeoutMs,
+					idempotencyKey: params.idempotencyKey || randomUUID()
+				},
+				timeoutMs: params.timeoutMs ? params.timeoutMs + 5e3 : void 0,
+				clientName: GATEWAY_CLIENT_NAMES.CLI,
+				mode: GATEWAY_CLIENT_MODES.CLI
+			});
+		}
+	};
+}
+//#endregion
+//#region src/plugins/cli-registry-loader.ts
+function createPluginCliLogger() {
+	return createPluginRuntimeLoaderLogger();
+}
+function resolvePluginCliLogger(logger) {
+	return logger ?? createPluginCliLogger();
+}
+function buildPluginCliLoaderParams(context, params, loaderOptions) {
+	const onlyPluginIds = resolvePrimaryCommandPluginIds(context, params?.primaryCommand);
+	return buildPluginRuntimeLoadOptions(context, {
+		...loaderOptions,
+		...onlyPluginIds.length > 0 ? { onlyPluginIds } : {}
+	});
+}
+function resolvePrimaryCommandPluginIds(context, primaryCommand) {
+	const normalizedPrimary = primaryCommand?.trim();
+	if (!normalizedPrimary) return [];
+	return resolveManifestActivationPluginIds({
+		trigger: {
+			kind: "command",
+			command: normalizedPrimary
+		},
+		config: context.activationSourceConfig,
+		workspaceDir: context.workspaceDir,
+		env: context.env
+	});
+}
+function resolvePluginCliLoadContext(params) {
+	return resolvePluginRuntimeLoadContext({
+		config: params.cfg,
+		env: params.env,
+		logger: params.logger
+	});
+}
+async function loadPluginCliMetadataRegistryWithContext(context, params, loaderOptions) {
+	return {
+		...context,
+		registry: await loadGenesisPluginCliRegistry(buildPluginCliLoaderParams(context, params, loaderOptions))
+	};
+}
+async function loadPluginCliCommandRegistryWithContext(params) {
+	const onlyPluginIds = resolvePrimaryCommandPluginIds(params.context, params.primaryCommand);
+	return {
+		...params.context,
+		registry: loadGenesisPlugins(buildPluginRuntimeLoadOptions(params.context, {
+			...params.loaderOptions,
+			...onlyPluginIds.length > 0 ? { onlyPluginIds } : {},
+			activate: false,
+			cache: false,
+			runtimeOptions: { nodes: createPluginCliGatewayNodesRuntime() }
+		}))
+	};
+}
+function buildPluginCliCommandGroupEntries(params) {
+	return params.registry.cliRegistrars.map((entry) => ({
+		pluginId: entry.pluginId,
+		placeholders: entry.descriptors,
+		names: entry.commands,
+		register: async (program) => {
+			await entry.register({
+				program,
+				config: params.config,
+				workspaceDir: params.workspaceDir,
+				logger: params.logger
+			});
+		}
+	}));
+}
+async function loadPluginCliDescriptors(params) {
+	try {
+		const logger = resolvePluginCliLogger(params.logger);
+		const { registry } = await loadPluginCliMetadataRegistryWithContext(resolvePluginCliLoadContext({
+			cfg: params.cfg,
+			env: params.env,
+			logger
+		}), { primaryCommand: params.primaryCommand }, params.loaderOptions);
+		return collectUniqueCommandDescriptors(registry.cliRegistrars.map((entry) => entry.descriptors));
+	} catch {
+		return [];
+	}
+}
+async function loadPluginCliRegistrationEntries(params) {
+	const resolvedLogger = resolvePluginCliLogger(params.logger);
+	const { config, workspaceDir, logger, registry } = await loadPluginCliCommandRegistryWithContext({
+		context: resolvePluginCliLoadContext({
+			cfg: params.cfg,
+			env: params.env,
+			logger: resolvedLogger
+		}),
+		primaryCommand: params.primaryCommand,
+		loaderOptions: params.loaderOptions
+	});
+	return buildPluginCliCommandGroupEntries({
+		registry,
+		config,
+		workspaceDir,
+		logger
+	});
+}
+async function loadPluginCliRegistrationEntriesWithDefaults(params) {
+	const logger = resolvePluginCliLogger(params.logger);
+	return loadPluginCliRegistrationEntries({
+		...params,
+		logger
+	});
+}
+//#endregion
+//#region src/plugins/register-plugin-cli-command-groups.ts
+function canRegisterPluginCliLazily(entry) {
+	if (entry.placeholders.length === 0) return false;
+	const descriptorNames = new Set(entry.placeholders.map((descriptor) => descriptor.name));
+	return getCommandGroupNames(entry).every((command) => descriptorNames.has(command));
+}
+async function registerPluginCliCommandGroups(program, entries, params) {
+	for (const entry of entries) {
+		const registerEntry = async () => {
+			await entry.register(program);
+			for (const command of getCommandGroupNames(entry)) params.existingCommands.add(command);
+		};
+		if (params.primary && findCommandGroupEntry([entry], params.primary)) {
+			removeCommandGroupNames(program, entry);
+			await registerEntry();
+			continue;
+		}
+		const overlaps = getCommandGroupNames(entry).filter((command) => params.existingCommands.has(command));
+		if (overlaps.length > 0) {
+			params.logger.debug?.(`plugin CLI register skipped (${entry.pluginId}): command already registered (${overlaps.join(", ")})`);
+			continue;
+		}
+		try {
+			if (params.mode === "lazy" && canRegisterPluginCliLazily(entry)) {
+				for (const placeholder of entry.placeholders) registerLazyCommandGroup(program, entry, placeholder);
+				continue;
+			}
+			if (params.mode === "lazy" && entry.placeholders.length > 0) params.logger.debug?.(`plugin CLI lazy register fallback to eager (${entry.pluginId}): descriptors do not cover all command roots`);
+			await registerEntry();
+		} catch (error) {
+			params.logger.warn(`plugin CLI register failed (${entry.pluginId}): ${String(error)}`);
+		}
+	}
+}
+//#endregion
+//#region src/plugins/cli.ts
+const logger = createPluginCliLogger();
+const loadValidatedConfigForPluginRegistration = async () => {
+	if (!(await readConfigFileSnapshot()).valid) return null;
+	return loadConfig();
+};
+async function getPluginCliCommandDescriptors(cfg, env, loaderOptions) {
+	return loadPluginCliDescriptors({
+		cfg,
+		env,
+		loaderOptions
+	});
+}
+async function registerPluginCliCommands(program, cfg, env, loaderOptions, options) {
+	const mode = options?.mode ?? "eager";
+	const primary = options?.primary ?? void 0;
+	await registerPluginCliCommandGroups(program, await loadPluginCliRegistrationEntriesWithDefaults({
+		cfg,
+		env,
+		loaderOptions,
+		primaryCommand: primary
+	}), {
+		mode,
+		primary,
+		existingCommands: new Set(program.commands.map((cmd) => cmd.name())),
+		logger
+	});
+}
+async function registerPluginCliCommandsFromValidatedConfig(program, env, loaderOptions, options) {
+	const config = await loadValidatedConfigForPluginRegistration();
+	if (!config) return null;
+	await registerPluginCliCommands(program, config, env, loaderOptions, options);
+	return config;
+}
+//#endregion
+export { registerPluginCliCommandsFromValidatedConfig as i, loadValidatedConfigForPluginRegistration as n, registerPluginCliCommands as r, getPluginCliCommandDescriptors as t };

package/dist/cli-Bk8uXnyc.js

@@ -0,0 +1,72 @@
+import { t as formatDocsLink } from "./links-DmsJCU7L.js";
+import { r as theme } from "./theme-BrRleVfL.js";
+import { t as formatHelpExamples } from "./help-format-DM-hbV3N.js";
+import "./memory-core-host-runtime-cli-UgLo6ezC.js";
+import { t as DEFAULT_PROMOTION_MIN_SCORE } from "./short-term-promotion-BIzj922a.js";
+//#region extensions/memory-core/src/cli.ts
+let memoryCliRuntimePromise = null;
+async function loadMemoryCliRuntime() {
+	memoryCliRuntimePromise ??= import("./cli.runtime-mKvJpLwI.js");
+	return await memoryCliRuntimePromise;
+}
+async function runMemoryStatus(opts) {
+	await (await loadMemoryCliRuntime()).runMemoryStatus(opts);
+}
+async function runMemoryIndex(opts) {
+	await (await loadMemoryCliRuntime()).runMemoryIndex(opts);
+}
+async function runMemorySearch(queryArg, opts) {
+	await (await loadMemoryCliRuntime()).runMemorySearch(queryArg, opts);
+}
+async function runMemoryPromote(opts) {
+	await (await loadMemoryCliRuntime()).runMemoryPromote(opts);
+}
+async function runMemoryPromoteExplain(selectorArg, opts) {
+	await (await loadMemoryCliRuntime()).runMemoryPromoteExplain(selectorArg, opts);
+}
+async function runMemoryRemHarness(opts) {
+	await (await loadMemoryCliRuntime()).runMemoryRemHarness(opts);
+}
+async function runMemoryRemBackfill(opts) {
+	await (await loadMemoryCliRuntime()).runMemoryRemBackfill(opts);
+}
+function registerMemoryCli(program) {
+	const memory = program.command("memory").description("Search, inspect, and reindex memory files").addHelpText("after", () => `\n${theme.heading("Examples:")}\n${formatHelpExamples([
+		["genesis memory status", "Show index and provider status."],
+		["genesis memory status --fix", "Repair stale recall locks and normalize promotion metadata."],
+		["genesis memory status --deep", "Probe embedding provider readiness."],
+		["genesis memory index --force", "Force a full reindex."],
+		["genesis memory search \"meeting notes\"", "Quick search using positional query."],
+		["genesis memory search --query \"deployment\" --max-results 20", "Limit results for focused troubleshooting."],
+		[`genesis memory promote --limit 10 --min-score ${DEFAULT_PROMOTION_MIN_SCORE}`, "Review weighted short-term candidates for long-term memory."],
+		["genesis memory promote --apply", "Append top-ranked short-term candidates into MEMORY.md."],
+		["genesis memory promote-explain \"router vlan\"", "Explain why a specific candidate would or would not promote."],
+		["genesis memory rem-harness --json", "Preview REM reflections, candidate truths, and deep promotion output."],
+		["genesis memory rem-backfill --path ./memory", "Write grounded historical REM entries into DREAMS.md for UI review."],
+		["genesis memory rem-backfill --path ./memory --stage-short-term", "Also seed durable grounded candidates into the live short-term promotion store."],
+		["genesis memory status --json", "Output machine-readable JSON (good for scripts)."]
+	])}\n\n${theme.muted("Docs:")} ${formatDocsLink("/cli/memory", "docs.genesis.ai/cli/memory")}\n`);
+	memory.command("status").description("Show memory search index status").option("--agent <id>", "Agent id (default: default agent)").option("--json", "Print JSON").option("--deep", "Probe embedding provider availability").option("--index", "Reindex if dirty (implies --deep)").option("--fix", "Repair stale recall locks and normalize promotion metadata").option("--verbose", "Verbose logging", false).action(async (opts) => {
+		await runMemoryStatus(opts);
+	});
+	memory.command("index").description("Reindex memory files").option("--agent <id>", "Agent id (default: default agent)").option("--force", "Force full reindex", false).option("--verbose", "Verbose logging", false).action(async (opts) => {
+		await runMemoryIndex(opts);
+	});
+	memory.command("search").description("Search memory files").argument("[query]", "Search query").option("--query <text>", "Search query (alternative to positional argument)").option("--agent <id>", "Agent id (default: default agent)").option("--max-results <n>", "Max results", (value) => Number(value)).option("--min-score <n>", "Minimum score", (value) => Number(value)).option("--json", "Print JSON").action(async (queryArg, opts) => {
+		await runMemorySearch(queryArg, opts);
+	});
+	memory.command("promote").description("Rank short-term recalls and optionally append top entries to MEMORY.md").option("--agent <id>", "Agent id (default: default agent)").option("--limit <n>", "Max candidates", (value) => Number(value)).option("--min-score <n>", `Minimum weighted score (default: ${DEFAULT_PROMOTION_MIN_SCORE})`, (value) => Number(value)).option("--min-recall-count <n>", `Minimum recall count (default: 3)`, (value) => Number(value)).option("--min-unique-queries <n>", `Minimum distinct query count (default: 2)`, (value) => Number(value)).option("--apply", "Append selected candidates to MEMORY.md", false).option("--include-promoted", "Include already promoted candidates", false).option("--json", "Print JSON").action(async (opts) => {
+		await runMemoryPromote(opts);
+	});
+	memory.command("promote-explain").description("Explain a specific promotion candidate and its score breakdown").argument("<selector>", "Candidate key, path fragment, or snippet fragment").option("--agent <id>", "Agent id (default: default agent)").option("--include-promoted", "Include already promoted candidates", false).option("--json", "Print JSON").action(async (selectorArg, opts) => {
+		await runMemoryPromoteExplain(selectorArg, opts);
+	});
+	memory.command("rem-harness").description("Preview REM reflections, candidate truths, and deep promotions without writing").option("--agent <id>", "Agent id (default: default agent)").option("--path <file-or-dir>", "Seed the harness from historical daily memory file(s)").option("--grounded", "Also render a grounded day-level REM preview").option("--include-promoted", "Include already promoted deep candidates", false).option("--json", "Print JSON").action(async (opts) => {
+		await runMemoryRemHarness(opts);
+	});
+	memory.command("rem-backfill").description("Write grounded historical REM summaries into DREAMS.md for UI review").option("--agent <id>", "Agent id (default: default agent)").option("--path <file-or-dir>", "Historical daily memory file(s) or directory").option("--rollback", "Remove previously written grounded REM backfill entries", false).option("--stage-short-term", "Also seed grounded durable candidates into the short-term promotion store", false).option("--rollback-short-term", "Remove previously seeded grounded short-term candidates", false).option("--json", "Print JSON").action(async (opts) => {
+		await runMemoryRemBackfill(opts);
+	});
+}
+//#endregion
+export { runMemoryStatus as n, registerMemoryCli as t };

package/dist/cli-DBfw9jCz.js

@@ -0,0 +1,2 @@
+import { t as registerMemoryCli } from "./cli-Bk8uXnyc.js";
+export { registerMemoryCli };

package/dist/cli-runner-BEqvX1ky.js

@@ -0,0 +1,286 @@
+import { i as formatErrorMessage } from "./errors-Jbvi20TW.js";
+import { t as getGlobalHookRunner } from "./hook-runner-global-DA2gGjRr.js";
+import "./tokens-Bq9TB3gs.js";
+import "./pi-embedded-helpers-BhsTiD6Y.js";
+import { p as isFailoverErrorMessage, t as classifyFailoverReason } from "./errors-Bbrw2LeD.js";
+import { i as isFailoverError, s as resolveFailoverStatus, t as FailoverError } from "./failover-error-BHITafkz.js";
+import { n as runAgentHarnessLlmInputHook, r as runAgentHarnessLlmOutputHook, t as runAgentHarnessAgentEndHook } from "./lifecycle-hook-helpers-B-p0SqJw.js";
+import { n as buildAgentHookConversationMessages, t as loadCliSessionHistoryMessages } from "./session-history-D9wAXCNG.js";
+//#region src/agents/cli-runner.ts
+function buildHandledReplyPayloads(reply) {
+	const normalized = reply ?? { text: "NO_REPLY" };
+	return [{
+		text: normalized.text,
+		mediaUrl: normalized.mediaUrl,
+		mediaUrls: normalized.mediaUrls,
+		replyToId: normalized.replyToId,
+		audioAsVoice: normalized.audioAsVoice,
+		isError: normalized.isError,
+		isReasoning: normalized.isReasoning
+	}];
+}
+function buildCliHookUserMessage(prompt) {
+	return {
+		role: "user",
+		content: prompt,
+		timestamp: Date.now()
+	};
+}
+function buildCliHookAssistantMessage(params) {
+	return {
+		role: "assistant",
+		content: [{
+			type: "text",
+			text: params.text
+		}],
+		api: "responses",
+		provider: params.provider,
+		model: params.model,
+		...params.usage ? { usage: params.usage } : {},
+		stopReason: "stop",
+		timestamp: Date.now()
+	};
+}
+async function runCliAgent(params) {
+	if (params.trigger === "cron") {
+		const startedAt = Date.now();
+		const hookRunner = getGlobalHookRunner();
+		if (hookRunner?.hasHooks("before_agent_reply")) {
+			const hookContext = {
+				runId: params.runId,
+				agentId: params.agentId,
+				sessionKey: params.sessionKey,
+				sessionId: params.sessionId,
+				workspaceDir: params.workspaceDir,
+				messageProvider: params.messageProvider,
+				trigger: params.trigger,
+				channelId: params.messageChannel ?? params.messageProvider
+			};
+			const hookResult = await hookRunner.runBeforeAgentReply({ cleanedBody: params.prompt }, hookContext);
+			if (hookResult?.handled) return {
+				payloads: buildHandledReplyPayloads(hookResult.reply),
+				meta: {
+					durationMs: Date.now() - startedAt,
+					agentMeta: {
+						sessionId: params.sessionId,
+						provider: params.provider,
+						model: params.model ?? ""
+					},
+					finalAssistantVisibleText: hookResult.reply?.text ?? "NO_REPLY",
+					finalAssistantRawText: hookResult.reply?.text ?? "NO_REPLY"
+				}
+			};
+		}
+	}
+	const { prepareCliRunContext } = await import("./prepare.runtime-BPA6jMiM.js");
+	return runPreparedCliAgent(await prepareCliRunContext(params));
+}
+async function runPreparedCliAgent(context) {
+	const { executePreparedCliRun } = await import("./execute.runtime-COmoY37L.js");
+	const { params } = context;
+	const hookRunner = getGlobalHookRunner();
+	const hasLlmInputHooks = hookRunner?.hasHooks("llm_input") === true;
+	const hasLlmOutputHooks = hookRunner?.hasHooks("llm_output") === true;
+	const hasAgentEndHooks = hookRunner?.hasHooks("agent_end") === true;
+	const historyMessages = hasLlmInputHooks || hasAgentEndHooks ? loadCliSessionHistoryMessages({
+		sessionId: params.sessionId,
+		sessionFile: params.sessionFile,
+		sessionKey: params.sessionKey,
+		agentId: params.agentId,
+		config: params.config
+	}) : [];
+	const llmInputEvent = {
+		runId: params.runId,
+		sessionId: params.sessionId,
+		provider: params.provider,
+		model: context.modelId,
+		systemPrompt: context.systemPrompt,
+		prompt: params.prompt,
+		historyMessages,
+		imagesCount: params.images?.length ?? 0
+	};
+	const hookContext = {
+		runId: params.runId,
+		agentId: params.agentId,
+		sessionKey: params.sessionKey,
+		sessionId: params.sessionId,
+		workspaceDir: params.workspaceDir,
+		messageProvider: params.messageProvider,
+		trigger: params.trigger,
+		channelId: params.messageChannel ?? params.messageProvider
+	};
+	const buildAgentEndMessages = (lastAssistant) => [...buildAgentHookConversationMessages({
+		historyMessages,
+		currentTurnMessages: [buildCliHookUserMessage(params.prompt), ...lastAssistant ? [lastAssistant] : []]
+	})];
+	const buildFailedAgentEndEvent = (error) => ({
+		messages: buildAgentEndMessages(),
+		success: false,
+		error,
+		durationMs: Date.now() - context.started
+	});
+	const toCliRunFailure = (error) => {
+		if (isFailoverError(error)) throw error;
+		const message = formatErrorMessage(error);
+		if (isFailoverErrorMessage(message, { provider: params.provider })) {
+			const reason = classifyFailoverReason(message, { provider: params.provider }) ?? "unknown";
+			const status = resolveFailoverStatus(reason);
+			throw new FailoverError(message, {
+				reason,
+				provider: params.provider,
+				model: context.modelId,
+				status
+			});
+		}
+		throw error;
+	};
+	const executeCliAttempt = async (cliSessionIdToUse) => {
+		const output = await executePreparedCliRun(context, cliSessionIdToUse);
+		const assistantText = output.text.trim();
+		const assistantTexts = assistantText ? [assistantText] : [];
+		const lastAssistant = assistantText.length > 0 ? buildCliHookAssistantMessage({
+			text: assistantText,
+			provider: params.provider,
+			model: context.modelId,
+			usage: output.usage
+		}) : void 0;
+		if (assistantText.length > 0 && hasLlmOutputHooks) runAgentHarnessLlmOutputHook({
+			event: {
+				runId: params.runId,
+				sessionId: params.sessionId,
+				provider: params.provider,
+				model: context.modelId,
+				resolvedRef: `${params.provider}/${context.modelId}`,
+				assistantTexts,
+				...lastAssistant ? { lastAssistant } : {},
+				...output.usage ? { usage: output.usage } : {}
+			},
+			ctx: hookContext,
+			hookRunner
+		});
+		return {
+			output,
+			assistantText,
+			lastAssistant
+		};
+	};
+	const buildCliRunResult = (resultParams) => {
+		const text = resultParams.output.text?.trim();
+		const rawText = resultParams.output.rawText?.trim();
+		return {
+			payloads: text ? [{ text }] : void 0,
+			meta: {
+				durationMs: Date.now() - context.started,
+				...resultParams.output.finalPromptText ? { finalPromptText: resultParams.output.finalPromptText } : {},
+				...text || rawText ? {
+					...text ? { finalAssistantVisibleText: text } : {},
+					...rawText ? { finalAssistantRawText: rawText } : {}
+				} : {},
+				systemPromptReport: context.systemPromptReport,
+				executionTrace: {
+					winnerProvider: params.provider,
+					winnerModel: context.modelId,
+					attempts: [{
+						provider: params.provider,
+						model: context.modelId,
+						result: "success"
+					}],
+					fallbackUsed: false,
+					runner: "cli"
+				},
+				requestShaping: {
+					...params.thinkLevel ? { thinking: params.thinkLevel } : {},
+					...context.effectiveAuthProfileId ? { authMode: "auth-profile" } : {}
+				},
+				completion: {
+					finishReason: "stop",
+					stopReason: "completed",
+					refusal: false
+				},
+				agentMeta: {
+					sessionId: resultParams.effectiveCliSessionId ?? params.sessionId ?? "",
+					provider: params.provider,
+					model: context.modelId,
+					usage: resultParams.output.usage,
+					...resultParams.effectiveCliSessionId ? { cliSessionBinding: {
+						sessionId: resultParams.effectiveCliSessionId,
+						...context.effectiveAuthProfileId ? { authProfileId: context.effectiveAuthProfileId } : {},
+						...context.authEpoch ? { authEpoch: context.authEpoch } : {},
+						authEpochVersion: context.authEpochVersion,
+						...context.extraSystemPromptHash ? { extraSystemPromptHash: context.extraSystemPromptHash } : {},
+						...context.preparedBackend.mcpConfigHash ? { mcpConfigHash: context.preparedBackend.mcpConfigHash } : {},
+						...context.preparedBackend.mcpResumeHash ? { mcpResumeHash: context.preparedBackend.mcpResumeHash } : {}
+					} } : {}
+				}
+			}
+		};
+	};
+	try {
+		runAgentHarnessLlmInputHook({
+			event: llmInputEvent,
+			ctx: hookContext,
+			hookRunner
+		});
+		try {
+			const { output, lastAssistant } = await executeCliAttempt(context.reusableCliSession.sessionId);
+			const effectiveCliSessionId = output.sessionId ?? context.reusableCliSession.sessionId;
+			runAgentHarnessAgentEndHook({
+				event: {
+					messages: buildAgentEndMessages(lastAssistant),
+					success: true,
+					durationMs: Date.now() - context.started
+				},
+				ctx: hookContext,
+				hookRunner
+			});
+			return buildCliRunResult({
+				output,
+				effectiveCliSessionId
+			});
+		} catch (err) {
+			if (isFailoverError(err)) {
+				const retryableSessionId = context.reusableCliSession.sessionId ?? params.cliSessionId;
+				if (err.reason === "session_expired" && retryableSessionId && params.sessionKey) try {
+					const { output, lastAssistant } = await executeCliAttempt(void 0);
+					const effectiveCliSessionId = output.sessionId;
+					runAgentHarnessAgentEndHook({
+						event: {
+							messages: buildAgentEndMessages(lastAssistant),
+							success: true,
+							durationMs: Date.now() - context.started
+						},
+						ctx: hookContext,
+						hookRunner
+					});
+					return buildCliRunResult({
+						output,
+						effectiveCliSessionId
+					});
+				} catch (retryErr) {
+					runAgentHarnessAgentEndHook({
+						event: buildFailedAgentEndEvent(formatErrorMessage(retryErr)),
+						ctx: hookContext,
+						hookRunner
+					});
+					return toCliRunFailure(retryErr);
+				}
+				runAgentHarnessAgentEndHook({
+					event: buildFailedAgentEndEvent(formatErrorMessage(err)),
+					ctx: hookContext,
+					hookRunner
+				});
+				throw err;
+			}
+			runAgentHarnessAgentEndHook({
+				event: buildFailedAgentEndEvent(formatErrorMessage(err)),
+				ctx: hookContext,
+				hookRunner
+			});
+			return toCliRunFailure(err);
+		}
+	} finally {
+		await context.preparedBackend.cleanup?.();
+	}
+}
+//#endregion
+export { runCliAgent as t };

package/dist/cli-runner.runtime-BIUcUGDa.js

@@ -0,0 +1,4 @@
+import { c as setCliSessionId, i as getCliSessionId } from "./cli-session-CQTFkzh2.js";
+import { t as runCliAgent } from "./cli-runner-BEqvX1ky.js";
+import "./cli-runner.runtime-D2u3Yw0W.js";
+export { getCliSessionId, runCliAgent, setCliSessionId };

package/dist/cli-runner.runtime-D2u3Yw0W.js

@@ -0,0 +1,3 @@
+import "./cli-session-CQTFkzh2.js";
+import "./cli-runner-BEqvX1ky.js";
+export {};

package/dist/cli-runner.runtime.js

@@ -1 +1 @@
-export * from "./cli-runner.runtime-BT8ZZn-R.js";
+export * from "./cli-runner.runtime-D2u3Yw0W.js";

package/dist/cli-startup-metadata.json

@@ -25,6 +25,6 @@
     "twitch"
   ],
   "channelCatalogSignature": "42572c297ec512116b06530236f3aa8b204823e5",
-  "rootHelpBundleSignature": "aaa67db669d510a78a26d06b3f4307f7fba947d6",
-  "rootHelpText": "\n🦞 Genesis 2026.5.3-5 (098b75f) — Less clicking, more shipping, fewer \"where did that file go\" moments.\n\nUsage: genesis [options] [command]\n\nOptions:\n  --container <name>   Run the CLI inside a running Podman/Docker container\n                       named <name> (default: env GENESIS_CONTAINER)\n  --dev                Dev profile: isolate state under ~/.genesis-dev, default\n                       gateway port 19001, and shift derived ports\n                       (browser/canvas)\n  -h, --help           Display help for command\n  --log-level <level>  Global log level override for file + console\n                       (silent|fatal|error|warn|info|debug|trace)\n  --no-color           Disable ANSI colors\n  --profile <name>     Use a named profile (isolates\n                       GENESIS_STATE_DIR/GENESIS_CONFIG_PATH under\n                       ~/.genesis-<name>)\n  -V, --version        output the version number\n\nCommands:\n  Hint: commands suffixed with * have subcommands. Run <command> --help for details.\n  acp *                Agent Control Protocol tools\n  agent                Run one agent turn via the Gateway\n  agents *             Manage isolated agents (workspaces, auth, routing)\n  approvals *          Manage exec approvals (gateway or node host)\n  backup *             Create and verify local backup archives for Genesis state\n  capability *         Run provider-backed inference commands (fallback alias:\n                       infer)\n  channels *           Manage connected chat channels (Telegram, Discord, etc.)\n  chat                 Open a local terminal UI (alias for tui --local)\n  clawbot *            Legacy clawbot command aliases\n  completion           Generate shell completion script\n  config *             Non-interactive config helpers\n                       (get/set/unset/file/validate). Default: starts guided\n                       setup.\n  configure            Interactive configuration for credentials, channels,\n                       gateway, and agent defaults\n  cron *               Manage cron jobs via the Gateway scheduler\n  daemon *             Gateway service (legacy alias)\n  dashboard            Open the Control UI with your current token\n  devices *            Device pairing + token management\n  directory *          Lookup contact and group IDs (self, peers, groups) for\n                       supported chat channels\n  dns *                DNS helpers for wide-area discovery (Tailscale + CoreDNS)\n  docs                 Search the live Genesis docs\n  doctor               Health checks + quick fixes for the gateway and channels\n  exec-policy *        Show or synchronize requested exec policy with host\n                       approvals\n  gateway *            Run, inspect, and query the WebSocket Gateway\n  health               Fetch health from the running gateway\n  help                 Display help for command\n  hooks *              Manage internal agent hooks\n  infer *              Run provider-backed inference commands\n  logs                 Tail gateway file logs via RPC\n  mcp *                Manage Genesis MCP config and channel bridge\n  memory               Search, inspect, and reindex memory files\n  message *            Send, read, and manage messages\n  models *             Discover, scan, and configure models\n  node *               Run and manage the headless node host service\n  nodes *              Manage gateway-owned node pairing and node commands\n  onboard              Interactive onboarding for gateway, workspace, and skills\n  pairing *            Secure DM pairing (approve inbound requests)\n  plugins *            Manage Genesis plugins\n  proxy *              Run the Genesis debug proxy and inspect captured traffic\n  qr                   Generate mobile pairing QR/setup code\n  reset                Reset local config/state (keeps the CLI installed)\n  sandbox *            Manage sandbox containers for agent isolation\n  secrets *            Secrets runtime reload controls\n  security *           Security tools and local config audits\n  sessions *           List stored conversation sessions\n  setup                Initialize local config and agent workspace\n  skills *             List and inspect available skills\n  status               Show channel health and recent session recipients\n  system *             System events, heartbeat, and presence\n  tasks *              Inspect durable background task state\n  terminal             Open a local terminal UI (alias for tui --local)\n  tui                  Open a terminal UI connected to the Gateway\n  uninstall            Uninstall the gateway service + local data (CLI remains)\n  update *             Update Genesis and inspect update channel status\n  wallet *             Manage the encrypted local wallet and public addresses\n  webhooks *           Webhook helpers and integrations\n\nExamples:\n  genesis models --help\n    Show detailed help for the models command.\n  genesis channels login --verbose\n    Link personal WhatsApp Web and show QR + connection logs.\n  genesis message send --target +15555550123 --message \"Hi\" --json\n    Send via your web session and print JSON result.\n  genesis gateway --port 18789\n    Run the WebSocket Gateway locally.\n  genesis --dev gateway\n    Run a dev Gateway (isolated state/config) on ws://127.0.0.1:19001.\n  genesis gateway --force\n    Kill anything bound to the default gateway port, then start it.\n  genesis gateway ...\n    Gateway control via WebSocket.\n  genesis agent --to +15555550123 --message \"Run summary\" --deliver\n    Talk directly to the agent using the Gateway; optionally send the WhatsApp reply.\n  genesis message send --channel telegram --target @mychat --message \"Hi\"\n    Send via your Telegram bot.\n\nDocs: https://docs.genesis.ai/cli\n\n"
+  "rootHelpBundleSignature": "eb20ede2b4c38ee895f81cde4f9197e2bbe8ddb9",
+  "rootHelpText": "\n🦞 Genesis 2026.5.5 (3a5a746) — If something's on fire, I can't extinguish it—but I can write a beautiful postmortem.\n\nUsage: genesis [options] [command]\n\nOptions:\n  --container <name>   Run the CLI inside a running Podman/Docker container\n                       named <name> (default: env GENESIS_CONTAINER)\n  --dev                Dev profile: isolate state under ~/.genesis-dev, default\n                       gateway port 19001, and shift derived ports\n                       (browser/canvas)\n  -h, --help           Display help for command\n  --log-level <level>  Global log level override for file + console\n                       (silent|fatal|error|warn|info|debug|trace)\n  --no-color           Disable ANSI colors\n  --profile <name>     Use a named profile (isolates\n                       GENESIS_STATE_DIR/GENESIS_CONFIG_PATH under\n                       ~/.genesis-<name>)\n  -V, --version        output the version number\n\nCommands:\n  Hint: commands suffixed with * have subcommands. Run <command> --help for details.\n  acp *                Agent Control Protocol tools\n  agent                Run one agent turn via the Gateway\n  agents *             Manage isolated agents (workspaces, auth, routing)\n  approvals *          Manage exec approvals (gateway or node host)\n  backup *             Create and verify local backup archives for Genesis state\n  capability *         Run provider-backed inference commands (fallback alias:\n                       infer)\n  channels *           Manage connected chat channels (Telegram, Discord, etc.)\n  chat                 Open a local terminal UI (alias for tui --local)\n  clawbot *            Legacy clawbot command aliases\n  completion           Generate shell completion script\n  config *             Non-interactive config helpers\n                       (get/set/unset/file/validate). Default: starts guided\n                       setup.\n  configure            Interactive configuration for credentials, channels,\n                       gateway, and agent defaults\n  cron *               Manage cron jobs via the Gateway scheduler\n  daemon *             Gateway service (legacy alias)\n  dashboard            Open the Control UI with your current token\n  devices *            Device pairing + token management\n  directory *          Lookup contact and group IDs (self, peers, groups) for\n                       supported chat channels\n  dns *                DNS helpers for wide-area discovery (Tailscale + CoreDNS)\n  docs                 Search the live Genesis docs\n  doctor               Health checks + quick fixes for the gateway and channels\n  exec-policy *        Show or synchronize requested exec policy with host\n                       approvals\n  gateway *            Run, inspect, and query the WebSocket Gateway\n  health               Fetch health from the running gateway\n  help                 Display help for command\n  hooks *              Manage internal agent hooks\n  infer *              Run provider-backed inference commands\n  logs                 Tail gateway file logs via RPC\n  mcp *                Manage Genesis MCP config and channel bridge\n  memory               Search, inspect, and reindex memory files\n  message *            Send, read, and manage messages\n  models *             Discover, scan, and configure models\n  node *               Run and manage the headless node host service\n  nodes *              Manage gateway-owned node pairing and node commands\n  onboard              Interactive onboarding for gateway, workspace, and skills\n  pairing *            Secure DM pairing (approve inbound requests)\n  plugins *            Manage Genesis plugins\n  proxy *              Run the Genesis debug proxy and inspect captured traffic\n  qr                   Generate mobile pairing QR/setup code\n  reset                Reset local config/state (keeps the CLI installed)\n  sandbox *            Manage sandbox containers for agent isolation\n  secrets *            Secrets runtime reload controls\n  security *           Security tools and local config audits\n  sessions *           List stored conversation sessions\n  setup                Initialize local config and agent workspace\n  skills *             List and inspect available skills\n  status               Show channel health and recent session recipients\n  system *             System events, heartbeat, and presence\n  tasks *              Inspect durable background task state\n  terminal             Open a local terminal UI (alias for tui --local)\n  tui                  Open a terminal UI connected to the Gateway\n  uninstall            Uninstall the gateway service + local data (CLI remains)\n  update *             Update Genesis and inspect update channel status\n  wallet *             Manage the encrypted local wallet and public addresses\n  webhooks *           Webhook helpers and integrations\n\nExamples:\n  genesis models --help\n    Show detailed help for the models command.\n  genesis channels login --verbose\n    Link personal WhatsApp Web and show QR + connection logs.\n  genesis message send --target +15555550123 --message \"Hi\" --json\n    Send via your web session and print JSON result.\n  genesis gateway --port 18789\n    Run the WebSocket Gateway locally.\n  genesis --dev gateway\n    Run a dev Gateway (isolated state/config) on ws://127.0.0.1:19001.\n  genesis gateway --force\n    Kill anything bound to the default gateway port, then start it.\n  genesis gateway ...\n    Gateway control via WebSocket.\n  genesis agent --to +15555550123 --message \"Run summary\" --deliver\n    Talk directly to the agent using the Gateway; optionally send the WhatsApp reply.\n  genesis message send --channel telegram --target @mychat --message \"Hi\"\n    Send via your Telegram bot.\n\nDocs: https://docs.genesis.ai/cli\n\n"
 }

package/dist/cli-waH8839u.js

@@ -0,0 +1,2 @@
+import { i as registerPluginCliCommandsFromValidatedConfig } from "./cli-2u5IZTMS.js";
+export { registerPluginCliCommandsFromValidatedConfig };