@pixelzx/genesis 2026.6.4 → 2026.6.6

package/dist/commands-handlers.runtime.js

@@ -1 +1 @@
-export * from "./commands-handlers.runtime-DCmZAlRN.js";
+export * from "./commands-handlers.runtime-B0gTkAC0.js";

package/dist/commands-status-BgZ64sA8.js

@@ -0,0 +1,16 @@
+import { r as logVerbose } from "./globals-wYf9_gv5.js";
+import { t as buildStatusText } from "./status-text-BdbRrl1G.js";
+//#region src/auto-reply/reply/commands-status.ts
+async function buildStatusReply(params) {
+	const { command } = params;
+	if (!command.isAuthorizedSender) {
+		logVerbose(`Ignoring /status from unauthorized sender: ${command.senderId || "<unknown>"}`);
+		return;
+	}
+	return { text: await buildStatusText({
+		...params,
+		statusChannel: command.channel
+	}) };
+}
+//#endregion
+export { buildStatusReply as t };

package/dist/commands-status.runtime-JI89gIEU.js

@@ -0,0 +1,3 @@
+import { t as buildStatusText } from "./status-text-BdbRrl1G.js";
+import { t as buildStatusReply } from "./commands-status-BgZ64sA8.js";
+export { buildStatusReply, buildStatusText };

package/dist/commands-status.runtime.js

@@ -1 +1 @@
-export * from "./commands-status.runtime-FBwoHftv.js";
+export * from "./commands-status.runtime-JI89gIEU.js";

package/dist/commands-subagents-control.runtime-B0hdcBxr.js

@@ -0,0 +1,2 @@
+import "./subagent-control-CxR0WRrx.js";
+export {};

package/dist/commands-subagents-control.runtime-DUeSQ5j4.js

@@ -0,0 +1,3 @@
+import { i as killControlledSubagentRun, l as sendControlledSubagentMessage, o as listControlledSubagentRuns, r as killAllControlledSubagentRuns, u as steerControlledSubagentRun } from "./subagent-control-CxR0WRrx.js";
+import "./commands-subagents-control.runtime-B0hdcBxr.js";
+export { killAllControlledSubagentRuns, killControlledSubagentRun, listControlledSubagentRuns, sendControlledSubagentMessage, steerControlledSubagentRun };

package/dist/commands-subagents-control.runtime.js

@@ -1 +1 @@
-export * from "./commands-subagents-control.runtime-CgIEblx3.js";
+export * from "./commands-subagents-control.runtime-DUeSQ5j4.js";

package/dist/commands-system-prompt-B7moUaCI.js

@@ -0,0 +1,158 @@
+import { m as resolveSessionAgentIds } from "./agent-scope-Duyu_T59.js";
+import { o as resolveDefaultModelForAgent } from "./model-selection-Le6XU3cD.js";
+import { n as buildTtsSystemPromptHint } from "./tts-Dk_Qpk02.js";
+import { i as resolveBootstrapContextForRun } from "./bootstrap-files-Cs14P9iA.js";
+import { n as resolveSandboxRuntimeStatus } from "./runtime-status-D1e_kpiA.js";
+import { t as createGenesisCodingTools } from "./pi-tools-k60jrAVq.js";
+import "./sandbox-Bz5RkkUC.js";
+import { t as buildWorkspaceSkillSnapshot } from "./workspace-D53YVcOL.js";
+import "./skills-vs6LL8lJ.js";
+import { t as buildSystemPromptParams } from "./system-prompt-params-DAxt6aca.js";
+import { t as buildAgentSystemPrompt } from "./system-prompt-D0-v5t6Z.js";
+import { n as resolveEmbeddedFullAccessState } from "./sandbox-info-dhe7IUMD.js";
+import { t as resolveRuntimePolicySessionKey } from "./runtime-policy-session-key-C4bUGX5a.js";
+import { n as getSkillsSnapshotVersion } from "./refresh-state-zzoMrn6l.js";
+import { t as canExecRequestNode } from "./exec-defaults-kMA0YYH5.js";
+import { t as getRemoteSkillEligibility } from "./skills-remote-Cda5p4DM.js";
+//#region src/auto-reply/reply/commands-system-prompt.ts
+async function resolveCommandsSystemPromptBundle(params) {
+	const workspaceDir = params.workspaceDir;
+	const targetSessionEntry = params.sessionStore?.[params.sessionKey] ?? params.sessionEntry;
+	const { sessionAgentId } = resolveSessionAgentIds({
+		sessionKey: params.sessionKey,
+		config: params.cfg,
+		agentId: params.agentId
+	});
+	const { bootstrapFiles, contextFiles: injectedFiles } = await resolveBootstrapContextForRun({
+		workspaceDir,
+		config: params.cfg,
+		sessionKey: params.sessionKey,
+		sessionId: targetSessionEntry?.sessionId
+	});
+	const sandboxRuntime = resolveSandboxRuntimeStatus({
+		cfg: params.cfg,
+		sessionKey: resolveRuntimePolicySessionKey({
+			cfg: params.cfg,
+			ctx: params.ctx,
+			sessionKey: params.sessionKey ?? params.ctx.SessionKey
+		})
+	});
+	const toolPolicySessionKey = resolveRuntimePolicySessionKey({
+		cfg: params.cfg,
+		ctx: params.ctx,
+		sessionKey: params.sessionKey
+	});
+	const skillsPrompt = (() => {
+		try {
+			return buildWorkspaceSkillSnapshot(workspaceDir, {
+				config: params.cfg,
+				agentId: sessionAgentId,
+				eligibility: { remote: getRemoteSkillEligibility({ advertiseExecNode: canExecRequestNode({
+					cfg: params.cfg,
+					sessionEntry: targetSessionEntry,
+					sessionKey: params.sessionKey,
+					agentId: sessionAgentId
+				}) }) },
+				snapshotVersion: getSkillsSnapshotVersion(workspaceDir)
+			});
+		} catch {
+			return {
+				prompt: "",
+				skills: [],
+				resolvedSkills: []
+			};
+		}
+	})().prompt ?? "";
+	const tools = (() => {
+		try {
+			return createGenesisCodingTools({
+				config: params.cfg,
+				agentId: sessionAgentId,
+				workspaceDir,
+				sessionKey: toolPolicySessionKey,
+				allowGatewaySubagentBinding: true,
+				messageProvider: params.command.channel,
+				groupId: targetSessionEntry?.groupId ?? void 0,
+				groupChannel: targetSessionEntry?.groupChannel ?? void 0,
+				groupSpace: targetSessionEntry?.space ?? void 0,
+				spawnedBy: targetSessionEntry?.spawnedBy ?? void 0,
+				senderId: params.command.senderId,
+				senderName: params.ctx.SenderName,
+				senderUsername: params.ctx.SenderUsername,
+				senderE164: params.ctx.SenderE164,
+				senderIsOwner: params.command.senderIsOwner,
+				modelProvider: params.provider,
+				modelId: params.model
+			});
+		} catch {
+			return [];
+		}
+	})();
+	const toolNames = tools.map((t) => t.name);
+	const defaultModelRef = resolveDefaultModelForAgent({
+		cfg: params.cfg,
+		agentId: sessionAgentId
+	});
+	const defaultModelLabel = `${defaultModelRef.provider}/${defaultModelRef.model}`;
+	const { runtimeInfo, userTimezone, userTime, userTimeFormat } = buildSystemPromptParams({
+		config: params.cfg,
+		agentId: sessionAgentId,
+		workspaceDir,
+		cwd: process.cwd(),
+		runtime: {
+			host: "unknown",
+			os: "unknown",
+			arch: "unknown",
+			node: process.version,
+			model: `${params.provider}/${params.model}`,
+			defaultModel: defaultModelLabel
+		}
+	});
+	const fullAccessState = resolveEmbeddedFullAccessState({ execElevated: {
+		enabled: params.elevated.enabled,
+		allowed: params.elevated.allowed,
+		defaultLevel: params.resolvedElevatedLevel ?? "off"
+	} });
+	const sandboxInfo = sandboxRuntime.sandboxed ? {
+		enabled: true,
+		workspaceDir,
+		workspaceAccess: "rw",
+		elevated: {
+			allowed: params.elevated.allowed,
+			defaultLevel: params.resolvedElevatedLevel ?? "off",
+			fullAccessAvailable: fullAccessState.available,
+			...fullAccessState.blockedReason ? { fullAccessBlockedReason: fullAccessState.blockedReason } : {}
+		}
+	} : { enabled: false };
+	const ttsHint = params.cfg ? buildTtsSystemPromptHint(params.cfg) : void 0;
+	return {
+		systemPrompt: buildAgentSystemPrompt({
+			workspaceDir,
+			defaultThinkLevel: params.resolvedThinkLevel,
+			reasoningLevel: params.resolvedReasoningLevel,
+			extraSystemPrompt: void 0,
+			ownerNumbers: void 0,
+			reasoningTagHint: false,
+			toolNames,
+			modelAliasLines: [],
+			userTimezone,
+			userTime,
+			userTimeFormat,
+			contextFiles: injectedFiles,
+			skillsPrompt,
+			heartbeatPrompt: void 0,
+			ttsHint,
+			acpEnabled: params.cfg?.acp?.enabled !== false,
+			runtimeInfo,
+			sandboxInfo,
+			memoryCitationsMode: params.cfg?.memory?.citations
+		}),
+		tools,
+		skillsPrompt,
+		bootstrapFiles,
+		injectedFiles,
+		sandboxRuntime
+	};
+}
+//#endregion
+export { resolveCommandsSystemPromptBundle as t };

package/dist/commands-system-prompt-DTUkp9TH.js

@@ -0,0 +1,2 @@
+import { t as resolveCommandsSystemPromptBundle } from "./commands-system-prompt-B7moUaCI.js";
+export { resolveCommandsSystemPromptBundle };

package/dist/commands.runtime-BjCVVqol.js

@@ -0,0 +1,167 @@
+import { r as logVerbose } from "./globals-wYf9_gv5.js";
+import { n as isAcpSessionKey } from "./session-key-utils-DDwuwYKT.js";
+import { s as updateSessionStoreEntry } from "./store-4uu5L7Eg.js";
+import { t as clearBootstrapSnapshot } from "./bootstrap-cache-lSrFbRwK.js";
+import { f as shouldHandleTextCommands } from "./commands-registry-vIVRcWI1.js";
+import "./commands-context-ojGcHTsc.js";
+import { n as parseSoftResetCommand, t as isResetAuthorizedForContext } from "./reset-authorization-DnCXXdJm.js";
+import { t as clearAllCliSessions } from "./cli-session-DuAWtTPW.js";
+import { r as resetConfiguredBindingTargetInPlace } from "./binding-targets-CCv7agx9.js";
+import { n as resolveBoundAcpThreadSessionKey } from "./targets-CUnlEj96.js";
+import { t as emitResetCommandHooks } from "./commands-reset-hooks-B2b33emL.js";
+import { t as buildStatusReply } from "./commands-status-BgZ64sA8.js";
+//#region src/auto-reply/reply/commands-reset.ts
+function applyAcpResetTailContext(ctx, resetTail) {
+	const mutableCtx = ctx;
+	mutableCtx.Body = resetTail;
+	mutableCtx.RawBody = resetTail;
+	mutableCtx.CommandBody = resetTail;
+	mutableCtx.BodyForCommands = resetTail;
+	mutableCtx.BodyForAgent = resetTail;
+	mutableCtx.BodyStripped = resetTail;
+	mutableCtx.AcpDispatchTailAfterReset = true;
+}
+function isResetAuthorized(params) {
+	return isResetAuthorizedForContext({
+		ctx: params.ctx,
+		cfg: params.cfg,
+		commandAuthorized: params.command.isAuthorizedSender || params.ctx.CommandAuthorized === true
+	});
+}
+async function maybeHandleResetCommand(params) {
+	const softReset = parseSoftResetCommand(params.command.commandBodyNormalized);
+	if (softReset.matched) {
+		if (!isResetAuthorized(params)) {
+			logVerbose(`Ignoring /reset soft from unauthorized sender: ${params.command.senderId || "<unknown>"}`);
+			return { shouldContinue: false };
+		}
+		const boundAcpSessionKey = resolveBoundAcpThreadSessionKey(params);
+		if (boundAcpSessionKey && isAcpSessionKey(boundAcpSessionKey) ? boundAcpSessionKey.trim() : void 0) return {
+			shouldContinue: false,
+			reply: { text: "Usage: /reset soft is not available for ACP-bound sessions yet." }
+		};
+		const targetSessionEntry = params.sessionStore?.[params.sessionKey] ?? params.sessionEntry;
+		const previousSessionEntry = params.previousSessionEntry ?? (targetSessionEntry ? { ...targetSessionEntry } : void 0);
+		if (targetSessionEntry) {
+			clearAllCliSessions(targetSessionEntry);
+			if (params.sessionEntry && params.sessionEntry !== targetSessionEntry) {
+				clearAllCliSessions(params.sessionEntry);
+				params.sessionEntry.updatedAt = Date.now();
+			}
+			if (params.sessionKey) clearBootstrapSnapshot(params.sessionKey);
+			targetSessionEntry.updatedAt = Date.now();
+			if (params.sessionStore && params.sessionKey) params.sessionStore[params.sessionKey] = targetSessionEntry;
+			if (params.storePath && params.sessionKey) await updateSessionStoreEntry({
+				storePath: params.storePath,
+				sessionKey: params.sessionKey,
+				update: async (entry) => {
+					const next = { ...entry };
+					clearAllCliSessions(next);
+					return {
+						cliSessionBindings: next.cliSessionBindings,
+						cliSessionIds: next.cliSessionIds,
+						claudeCliSessionId: next.claudeCliSessionId,
+						updatedAt: Date.now()
+					};
+				}
+			});
+		}
+		await emitResetCommandHooks({
+			action: "reset",
+			ctx: params.ctx,
+			cfg: params.cfg,
+			command: params.command,
+			sessionKey: params.sessionKey,
+			sessionEntry: targetSessionEntry,
+			previousSessionEntry,
+			workspaceDir: params.workspaceDir
+		});
+		params.command.softResetTriggered = true;
+		params.command.softResetTail = softReset.tail;
+		return null;
+	}
+	const resetMatch = params.command.commandBodyNormalized.match(/^\/(new|reset)(?:\s|$)/);
+	if (!resetMatch) return null;
+	if (!isResetAuthorized(params)) {
+		logVerbose(`Ignoring /reset from unauthorized sender: ${params.command.senderId || "<unknown>"}`);
+		return { shouldContinue: false };
+	}
+	const commandAction = resetMatch[1] === "reset" ? "reset" : "new";
+	const resetTail = params.command.commandBodyNormalized.slice(resetMatch[0].length).trimStart();
+	const boundAcpSessionKey = resolveBoundAcpThreadSessionKey(params);
+	const boundAcpKey = boundAcpSessionKey && isAcpSessionKey(boundAcpSessionKey) ? boundAcpSessionKey.trim() : void 0;
+	if (boundAcpKey) {
+		const resetResult = await resetConfiguredBindingTargetInPlace({
+			cfg: params.cfg,
+			sessionKey: boundAcpKey,
+			reason: commandAction,
+			commandSource: `${params.command.surface}:${params.ctx.CommandSource ?? "text"}`
+		});
+		if (!resetResult.ok) logVerbose(`acp reset failed for ${boundAcpKey}: ${resetResult.error ?? "unknown error"}`);
+		if (resetResult.ok) {
+			params.command.resetHookTriggered = true;
+			if (resetTail) {
+				applyAcpResetTailContext(params.ctx, resetTail);
+				if (params.rootCtx && params.rootCtx !== params.ctx) applyAcpResetTailContext(params.rootCtx, resetTail);
+				return { shouldContinue: false };
+			}
+			return {
+				shouldContinue: false,
+				reply: { text: "✅ ACP session reset in place." }
+			};
+		}
+		return {
+			shouldContinue: false,
+			reply: { text: "⚠️ ACP session reset failed. Check /acp status and try again." }
+		};
+	}
+	const targetSessionEntry = params.sessionStore?.[params.sessionKey] ?? params.sessionEntry;
+	await emitResetCommandHooks({
+		action: commandAction,
+		ctx: params.ctx,
+		cfg: params.cfg,
+		command: params.command,
+		sessionKey: params.sessionKey,
+		sessionEntry: targetSessionEntry,
+		previousSessionEntry: params.previousSessionEntry,
+		workspaceDir: params.workspaceDir,
+		announceNewSession: true
+	});
+	return null;
+}
+//#endregion
+//#region src/auto-reply/reply/commands-core.ts
+let commandHandlersRuntimePromise = null;
+function loadCommandHandlersRuntime() {
+	commandHandlersRuntimePromise ??= import("./commands-handlers.runtime-B0gTkAC0.js");
+	return commandHandlersRuntimePromise;
+}
+let HANDLERS = null;
+function normalizeCommandHandlerResult(result) {
+	if (!result.reply) return result;
+	return {
+		...result,
+		reply: {
+			...result.reply,
+			replyToId: void 0,
+			replyToCurrent: false
+		}
+	};
+}
+async function handleCommands(params) {
+	if (HANDLERS === null) HANDLERS = (await loadCommandHandlersRuntime()).loadCommandHandlers();
+	const resetResult = await maybeHandleResetCommand(params);
+	if (resetResult) return normalizeCommandHandlerResult(resetResult);
+	const allowTextCommands = shouldHandleTextCommands({
+		cfg: params.cfg,
+		surface: params.command.surface,
+		commandSource: params.ctx.CommandSource
+	});
+	for (const handler of HANDLERS) {
+		const result = await handler(params, allowTextCommands);
+		if (result) return normalizeCommandHandlerResult(result);
+	}
+	return { shouldContinue: true };
+}
+//#endregion
+export { buildStatusReply, handleCommands };

package/dist/commands.runtime.js

@@ -1 +1 @@
-export * from "./commands.runtime-CHSb1kYa.js";
+export * from "./commands.runtime-BjCVVqol.js";