@pixelzx/genesis 2026.5.5-3 → 2026.5.5-5

package/dist/acp-spawn-Dzb_-EiJ.js

@@ -0,0 +1,2 @@
+import { a as ACP_SPAWN_SESSION_ACCEPTED_NOTE, c as resolveAcpSpawnRuntimePolicyError, i as ACP_SPAWN_SANDBOX_MODES, l as spawnAcpDirect, n as ACP_SPAWN_ERROR_CODES, o as ACP_SPAWN_STREAM_TARGETS, r as ACP_SPAWN_MODES, s as isSpawnAcpAcceptedResult, t as ACP_SPAWN_ACCEPTED_NOTE } from "./acp-spawn-Dagbjv-c.js";
+export { ACP_SPAWN_ACCEPTED_NOTE, ACP_SPAWN_ERROR_CODES, ACP_SPAWN_MODES, ACP_SPAWN_SANDBOX_MODES, ACP_SPAWN_SESSION_ACCEPTED_NOTE, ACP_SPAWN_STREAM_TARGETS, isSpawnAcpAcceptedResult, resolveAcpSpawnRuntimePolicyError, spawnAcpDirect };

package/dist/acp-stateful-target-driver-JXFh96Nx.js

@@ -0,0 +1,89 @@
+import { n as isAcpSessionKey } from "./session-key-utils-BT0y7mVK.js";
+import { u as resolveAgentIdFromSessionKey } from "./session-key-EpIbK3Oz.js";
+import { c as resolveConfiguredAcpBindingSpecFromRecord } from "./binding-registry-CCcK_Zom.js";
+import { n as resolveConfiguredAcpBindingSpecBySessionKey } from "./persistent-bindings.resolve-3joPxiU8.js";
+import { n as readAcpSessionEntry } from "./session-meta-DHOj7FVp.js";
+import { n as ensureConfiguredAcpBindingSession, t as ensureConfiguredAcpBindingReady } from "./persistent-bindings.lifecycle-_3A07X4u.js";
+import { a as performGatewaySessionReset } from "./session-reset-service-D1taSq3b.js";
+//#region src/channels/plugins/acp-stateful-target-driver.ts
+function toAcpStatefulBindingTargetDescriptor(params) {
+	const sessionKey = params.sessionKey.trim();
+	if (!sessionKey) return null;
+	const metaAgentId = (readAcpSessionEntry({
+		...params,
+		sessionKey
+	})?.acp)?.agent?.trim();
+	if (metaAgentId) return {
+		kind: "stateful",
+		driverId: "acp",
+		sessionKey,
+		agentId: metaAgentId
+	};
+	const spec = resolveConfiguredAcpBindingSpecBySessionKey({
+		...params,
+		sessionKey
+	});
+	if (!spec) {
+		if (!isAcpSessionKey(sessionKey)) return null;
+		return {
+			kind: "stateful",
+			driverId: "acp",
+			sessionKey,
+			agentId: resolveAgentIdFromSessionKey(sessionKey)
+		};
+	}
+	return {
+		kind: "stateful",
+		driverId: "acp",
+		sessionKey,
+		agentId: spec.agentId,
+		...spec.label ? { label: spec.label } : {}
+	};
+}
+async function ensureAcpTargetReady(params) {
+	const configuredBinding = resolveConfiguredAcpBindingSpecFromRecord(params.bindingResolution.record);
+	if (!configuredBinding) return {
+		ok: false,
+		error: "Configured ACP binding unavailable"
+	};
+	return await ensureConfiguredAcpBindingReady({
+		cfg: params.cfg,
+		configuredBinding: {
+			spec: configuredBinding,
+			record: params.bindingResolution.record
+		}
+	});
+}
+async function ensureAcpTargetSession(params) {
+	const spec = resolveConfiguredAcpBindingSpecFromRecord(params.bindingResolution.record);
+	if (!spec) return {
+		ok: false,
+		sessionKey: params.bindingResolution.statefulTarget.sessionKey,
+		error: "Configured ACP binding unavailable"
+	};
+	return await ensureConfiguredAcpBindingSession({
+		cfg: params.cfg,
+		spec
+	});
+}
+async function resetAcpTargetInPlace(params) {
+	const result = await performGatewaySessionReset({
+		key: params.sessionKey,
+		reason: params.reason,
+		commandSource: params.commandSource ?? "stateful-target:acp-reset-in-place"
+	});
+	if (result.ok) return { ok: true };
+	return {
+		ok: false,
+		error: result.error.message
+	};
+}
+const acpStatefulBindingTargetDriver = {
+	id: "acp",
+	ensureReady: ensureAcpTargetReady,
+	ensureSession: ensureAcpTargetSession,
+	resolveTargetBySessionKey: toAcpStatefulBindingTargetDescriptor,
+	resetInPlace: resetAcpTargetInPlace
+};
+//#endregion
+export { acpStatefulBindingTargetDriver };

package/dist/action-agents-DevmKFPq.js

@@ -0,0 +1,67 @@
+import { c as normalizeOptionalString } from "./string-coerce-C1IzJjqi.js";
+import { i as normalizeChannelId, t as getChannelPlugin } from "./registry-DXDC8Wqv.js";
+import "./plugins-DNe6i7Rv.js";
+import { A as subagentRuns, s as countPendingDescendantRunsFromRuns, t as getSubagentRunsSnapshotForRead } from "./subagent-registry-state-TU79E4We.js";
+import { r as getSessionBindingService } from "./session-binding-service-DoeFMDT5.js";
+import { c as sortSubagentRuns, i as formatRunLabel } from "./subagents-format-C1DSWmGn.js";
+import { d as resolveChannelAccountId, f as resolveCommandSurfaceChannel, u as stopWithText } from "./shared-Cs_JtPmo.js";
+//#region src/auto-reply/reply/commands-subagents/action-agents.ts
+function formatConversationBindingText(params) {
+	return `binding:${params.conversationId}`;
+}
+function supportsConversationBindings(channel) {
+	const channelId = normalizeChannelId(channel);
+	if (!channelId) return false;
+	return getChannelPlugin(channelId)?.conversationBindings?.supportsCurrentConversationBinding === true;
+}
+function handleSubagentsAgentsAction(ctx) {
+	const { params, requesterKey, runs } = ctx;
+	const runsSnapshot = getSubagentRunsSnapshotForRead(subagentRuns);
+	const channel = resolveCommandSurfaceChannel(params);
+	const accountId = resolveChannelAccountId(params);
+	const currentConversationBindingsSupported = supportsConversationBindings(channel);
+	const bindingService = getSessionBindingService();
+	const bindingsBySession = /* @__PURE__ */ new Map();
+	const resolveSessionBindings = (sessionKey) => {
+		const cached = bindingsBySession.get(sessionKey);
+		if (cached) return cached;
+		const resolved = bindingService.listBySession(sessionKey).filter((entry) => entry.status === "active" && entry.conversation.channel === channel && entry.conversation.accountId === accountId);
+		bindingsBySession.set(sessionKey, resolved);
+		return resolved;
+	};
+	const dedupedRuns = [];
+	const seenChildSessionKeys = /* @__PURE__ */ new Set();
+	for (const entry of sortSubagentRuns(runs)) {
+		if (seenChildSessionKeys.has(entry.childSessionKey)) continue;
+		seenChildSessionKeys.add(entry.childSessionKey);
+		dedupedRuns.push(entry);
+	}
+	const recentCutoff = Date.now() - 30 * 6e4;
+	const numericOrder = [...dedupedRuns.filter((entry) => !entry.endedAt || countPendingDescendantRunsFromRuns(runsSnapshot, entry.childSessionKey) > 0), ...dedupedRuns.filter((entry) => entry.endedAt && countPendingDescendantRunsFromRuns(runsSnapshot, entry.childSessionKey) === 0 && entry.endedAt >= recentCutoff)];
+	const indexByChildSessionKey = new Map(numericOrder.map((entry, idx) => [entry.childSessionKey, idx + 1]));
+	const visibleRuns = [];
+	for (const entry of dedupedRuns) {
+		if (!(!entry.endedAt || countPendingDescendantRunsFromRuns(runsSnapshot, entry.childSessionKey) > 0 || resolveSessionBindings(entry.childSessionKey).length > 0)) continue;
+		visibleRuns.push(entry);
+	}
+	const lines = ["agents:", "-----"];
+	if (visibleRuns.length === 0) lines.push("(none)");
+	else for (const entry of visibleRuns) {
+		const binding = resolveSessionBindings(entry.childSessionKey)[0];
+		const bindingText = binding ? formatConversationBindingText({ conversationId: binding.conversation.conversationId }) : currentConversationBindingsSupported ? "unbound" : "bindings unavailable";
+		const resolvedIndex = indexByChildSessionKey.get(entry.childSessionKey);
+		const prefix = resolvedIndex ? `${resolvedIndex}.` : "-";
+		lines.push(`${prefix} ${formatRunLabel(entry)} (${bindingText})`);
+	}
+	const requesterBindings = resolveSessionBindings(requesterKey).filter((entry) => entry.targetKind === "session");
+	if (requesterBindings.length > 0) {
+		lines.push("", "acp/session bindings:", "-----");
+		for (const binding of requesterBindings) {
+			const label = normalizeOptionalString(binding.metadata?.label) ?? binding.targetSessionKey;
+			lines.push(`- ${label} (${formatConversationBindingText({ conversationId: binding.conversation.conversationId })}, session:${binding.targetSessionKey})`);
+		}
+	}
+	return stopWithText(lines.join("\n"));
+}
+//#endregion
+export { handleSubagentsAgentsAction };

package/dist/action-focus-slEC2ZvE.js

@@ -0,0 +1,132 @@
+import { c as normalizeOptionalString } from "./string-coerce-C1IzJjqi.js";
+import { t as normalizeChatType } from "./chat-type-Dx2By8Y2.js";
+import { r as normalizeConversationRef } from "./conversation-id-CdkUzz0s.js";
+import { r as getSessionBindingService } from "./session-binding-service-DoeFMDT5.js";
+import { r as resolveConversationBindingContextFromAcpCommand } from "./conversation-binding-input-4r2gq_KQ.js";
+import { n as readAcpSessionEntry } from "./session-meta-DHOj7FVp.js";
+import { i as resolveThreadBindingThreadName, r as resolveThreadBindingIntroText } from "./thread-bindings-messages-BbXbfHuh.js";
+import { c as resolveThreadBindingMaxAgeMsForChannel, l as resolveThreadBindingPlacementForCurrentContext, n as formatThreadBindingSpawnDisabledError, o as resolveThreadBindingIdleTimeoutMsForChannel, t as formatThreadBindingDisabledError, u as resolveThreadBindingSpawnPolicy } from "./thread-bindings-policy-D5Cxn_pw.js";
+import { a as resolveAcpThreadSessionDetailLines, n as resolveAcpSessionCwd } from "./session-identifiers-DXuUlIGp.js";
+import { a as resolveFocusTargetSession, u as stopWithText } from "./shared-Cs_JtPmo.js";
+//#region src/auto-reply/reply/commands-subagents/action-focus.ts
+function resolveFocusBindingContext(params) {
+	const bindingContext = resolveConversationBindingContextFromAcpCommand(params);
+	if (!bindingContext) return null;
+	const chatType = normalizeChatType(params.ctx.ChatType);
+	const conversation = normalizeConversationRef({
+		channel: bindingContext.channel,
+		accountId: bindingContext.accountId,
+		conversationId: bindingContext.conversationId,
+		parentConversationId: bindingContext.parentConversationId
+	});
+	return {
+		channel: conversation.channel,
+		accountId: conversation.accountId,
+		conversationId: conversation.conversationId,
+		...conversation.parentConversationId ? { parentConversationId: conversation.parentConversationId } : {},
+		placement: chatType === "direct" ? "current" : resolveThreadBindingPlacementForCurrentContext({
+			channel: bindingContext.channel,
+			threadId: bindingContext.threadId || void 0
+		})
+	};
+}
+async function handleSubagentsFocusAction(ctx) {
+	const { params, runs, restTokens } = ctx;
+	const token = restTokens.join(" ").trim();
+	if (!token) return stopWithText("Usage: /focus <subagent-label|session-key|session-id|session-label>");
+	const bindingContext = resolveFocusBindingContext(params);
+	if (!bindingContext) return stopWithText("⚠️ /focus must be run inside a bindable conversation.");
+	const bindingService = getSessionBindingService();
+	const capabilities = bindingService.getCapabilities({
+		channel: bindingContext.channel,
+		accountId: bindingContext.accountId
+	});
+	if (!capabilities.adapterAvailable || !capabilities.bindSupported) return stopWithText("⚠️ Conversation bindings are unavailable for this account.");
+	const focusTarget = await resolveFocusTargetSession({
+		runs,
+		token
+	});
+	if (!focusTarget) return stopWithText(`⚠️ Unable to resolve focus target: ${token}`);
+	if (bindingContext.placement === "child") {
+		const spawnPolicy = resolveThreadBindingSpawnPolicy({
+			cfg: params.cfg,
+			channel: bindingContext.channel,
+			accountId: bindingContext.accountId,
+			kind: "subagent"
+		});
+		if (!spawnPolicy.enabled) return stopWithText(`⚠️ ${formatThreadBindingDisabledError({
+			channel: spawnPolicy.channel,
+			accountId: spawnPolicy.accountId,
+			kind: "subagent"
+		})}`);
+		if (bindingContext.placement === "child" && !spawnPolicy.spawnEnabled) return stopWithText(`⚠️ ${formatThreadBindingSpawnDisabledError({
+			channel: spawnPolicy.channel,
+			accountId: spawnPolicy.accountId,
+			kind: "subagent"
+		})}`);
+	}
+	const senderId = normalizeOptionalString(params.command.senderId) ?? "";
+	const conversationRef = normalizeConversationRef({
+		channel: bindingContext.channel,
+		accountId: bindingContext.accountId,
+		conversationId: bindingContext.conversationId,
+		parentConversationId: bindingContext.parentConversationId
+	});
+	const existingBinding = bindingService.resolveByConversation(conversationRef);
+	const boundBy = typeof existingBinding?.metadata?.boundBy === "string" ? existingBinding.metadata.boundBy.trim() : "";
+	if (existingBinding && boundBy && boundBy !== "system" && senderId && senderId !== boundBy) return stopWithText(`⚠️ Only ${boundBy} can refocus this conversation.`);
+	const label = focusTarget.label || token;
+	const accountId = bindingContext.accountId;
+	const acpMeta = focusTarget.targetKind === "acp" ? readAcpSessionEntry({
+		cfg: params.cfg,
+		sessionKey: focusTarget.targetSessionKey
+	})?.acp : void 0;
+	if (!capabilities.placements.includes(bindingContext.placement)) return stopWithText("⚠️ Conversation bindings are unavailable for this account.");
+	let binding;
+	try {
+		binding = await bindingService.bind({
+			targetSessionKey: focusTarget.targetSessionKey,
+			targetKind: focusTarget.targetKind === "acp" ? "session" : "subagent",
+			conversation: normalizeConversationRef({
+				channel: bindingContext.channel,
+				accountId: bindingContext.accountId,
+				conversationId: bindingContext.conversationId,
+				parentConversationId: bindingContext.parentConversationId
+			}),
+			placement: bindingContext.placement,
+			metadata: {
+				threadName: resolveThreadBindingThreadName({
+					agentId: focusTarget.agentId,
+					label
+				}),
+				agentId: focusTarget.agentId,
+				label,
+				boundBy: senderId || "unknown",
+				introText: resolveThreadBindingIntroText({
+					agentId: focusTarget.agentId,
+					label,
+					idleTimeoutMs: resolveThreadBindingIdleTimeoutMsForChannel({
+						cfg: params.cfg,
+						channel: bindingContext.channel,
+						accountId
+					}),
+					maxAgeMs: resolveThreadBindingMaxAgeMsForChannel({
+						cfg: params.cfg,
+						channel: bindingContext.channel,
+						accountId
+					}),
+					sessionCwd: focusTarget.targetKind === "acp" ? resolveAcpSessionCwd(acpMeta) : void 0,
+					sessionDetails: focusTarget.targetKind === "acp" ? resolveAcpThreadSessionDetailLines({
+						sessionKey: focusTarget.targetSessionKey,
+						meta: acpMeta
+					}) : []
+				})
+			}
+		});
+	} catch {
+		return stopWithText("⚠️ Failed to bind this conversation to the target session.");
+	}
+	return stopWithText(`✅ ${bindingContext.placement === "child" ? `created child conversation ${binding.conversation.conversationId} and bound it to ${binding.targetSessionKey}` : `bound this conversation to ${binding.targetSessionKey}`} (${focusTarget.targetKind}).`);
+}
+//#endregion
+export { handleSubagentsFocusAction };

package/dist/action-help-BNI_jV7m.js

@@ -0,0 +1,7 @@
+import { n as buildSubagentsHelp, u as stopWithText } from "./shared-Cs_JtPmo.js";
+//#region src/auto-reply/reply/commands-subagents/action-help.ts
+function handleSubagentsHelpAction() {
+	return stopWithText(buildSubagentsHelp());
+}
+//#endregion
+export { handleSubagentsHelpAction };

package/dist/action-info-A0aWRFGn.js

@@ -0,0 +1,101 @@
+import { o as parseAgentSessionKey } from "./session-key-utils-BT0y7mVK.js";
+import { u as resolveStorePath } from "./paths-DD6L4IvS.js";
+import { t as loadSessionStore } from "./store-load-CUqchamJ.js";
+import { A as subagentRuns, s as countPendingDescendantRunsFromRuns, t as getSubagentRunsSnapshotForRead } from "./subagent-registry-state-TU79E4We.js";
+import { a as sanitizeTaskStatusText } from "./task-status-LIWTrTqj.js";
+import { i as findTaskByRunIdForOwner } from "./task-owner-access-DbaTH-83.js";
+import { a as formatRunStatus, i as formatRunLabel, s as resolveSubagentTargetFromRuns } from "./subagents-format-C1DSWmGn.js";
+import { t as formatDurationCompact } from "./format-duration-D7ua_Cv_.js";
+import { n as formatTimeAgo } from "./format-relative-uQtNNoGl.js";
+//#region src/auto-reply/reply/commands-subagents/action-info.ts
+const RECENT_WINDOW_MINUTES = 30;
+function stopWithText(text) {
+	return {
+		shouldContinue: false,
+		reply: { text }
+	};
+}
+function formatTimestamp(valueMs) {
+	if (!valueMs || !Number.isFinite(valueMs) || valueMs <= 0) return "n/a";
+	return new Date(valueMs).toISOString();
+}
+function formatTimestampWithAge(valueMs) {
+	if (!valueMs || !Number.isFinite(valueMs) || valueMs <= 0) return "n/a";
+	return `${formatTimestamp(valueMs)} (${formatTimeAgo(Date.now() - valueMs, { fallback: "n/a" })})`;
+}
+function resolveDisplayStatus(entry, options) {
+	const pendingDescendants = Math.max(0, options?.pendingDescendants ?? 0);
+	if (pendingDescendants > 0) return `active (waiting on ${pendingDescendants} ${pendingDescendants === 1 ? "child" : "children"})`;
+	const status = formatRunStatus(entry);
+	return status === "error" ? "failed" : status;
+}
+function resolveSubagentEntryForToken(runs, token) {
+	const resolved = resolveSubagentTargetFromRuns({
+		runs,
+		token,
+		recentWindowMinutes: RECENT_WINDOW_MINUTES,
+		label: (entry) => formatRunLabel(entry),
+		isActive: (entry) => !entry.endedAt || Math.max(0, countPendingDescendantRunsFromRuns(getSubagentRunsSnapshotForRead(subagentRuns), entry.childSessionKey)) > 0,
+		errors: {
+			missingTarget: "Missing subagent id.",
+			invalidIndex: (value) => `Invalid subagent index: ${value}`,
+			unknownSession: (value) => `Unknown subagent session: ${value}`,
+			ambiguousLabel: (value) => `Ambiguous subagent label: ${value}`,
+			ambiguousLabelPrefix: (value) => `Ambiguous subagent label prefix: ${value}`,
+			ambiguousRunIdPrefix: (value) => `Ambiguous run id prefix: ${value}`,
+			unknownTarget: (value) => `Unknown subagent id: ${value}`
+		}
+	});
+	if (!resolved.entry) return { reply: stopWithText(`⚠️ ${resolved.error ?? "Unknown subagent."}`) };
+	return { entry: resolved.entry };
+}
+function loadSubagentSessionEntry(params, childKey) {
+	const parsed = parseAgentSessionKey(childKey);
+	return { entry: loadSessionStore(resolveStorePath(params.cfg.session?.store, { agentId: parsed?.agentId }))[childKey] };
+}
+function handleSubagentsInfoAction(ctx) {
+	const { params, requesterKey, runs, restTokens } = ctx;
+	const target = restTokens[0];
+	if (!target) return stopWithText("ℹ️ Usage: /subagents info <id|#>");
+	const targetResolution = resolveSubagentEntryForToken(runs, target);
+	if ("reply" in targetResolution) return targetResolution.reply;
+	const run = targetResolution.entry;
+	const { entry: sessionEntry } = loadSubagentSessionEntry(params, run.childSessionKey);
+	const runtime = run.startedAt && Number.isFinite(run.startedAt) ? formatDurationCompact((run.endedAt ?? Date.now()) - run.startedAt) ?? "n/a" : "n/a";
+	const outcomeError = sanitizeTaskStatusText(run.outcome?.error, { errorContext: true });
+	const outcome = run.outcome ? `${run.outcome.status}${outcomeError ? ` (${outcomeError})` : ""}` : "n/a";
+	const linkedTask = findTaskByRunIdForOwner({
+		runId: run.runId,
+		callerOwnerKey: requesterKey
+	});
+	const taskText = sanitizeTaskStatusText(run.task) || "n/a";
+	const progressText = sanitizeTaskStatusText(linkedTask?.progressSummary);
+	const taskSummaryText = sanitizeTaskStatusText(linkedTask?.terminalSummary, { errorContext: true });
+	const taskErrorText = sanitizeTaskStatusText(linkedTask?.error, { errorContext: true });
+	return stopWithText([
+		"ℹ️ Subagent info",
+		`Status: ${resolveDisplayStatus(run, { pendingDescendants: countPendingDescendantRunsFromRuns(getSubagentRunsSnapshotForRead(subagentRuns), run.childSessionKey) })}`,
+		`Label: ${formatRunLabel(run)}`,
+		`Task: ${taskText}`,
+		`Run: ${run.runId}`,
+		linkedTask ? `TaskId: ${linkedTask.taskId}` : void 0,
+		linkedTask ? `TaskStatus: ${linkedTask.status}` : void 0,
+		`Session: ${run.childSessionKey}`,
+		`SessionId: ${sessionEntry?.sessionId ?? "n/a"}`,
+		`Transcript: ${sessionEntry?.sessionFile ?? "n/a"}`,
+		`Runtime: ${runtime}`,
+		`Created: ${formatTimestampWithAge(run.createdAt)}`,
+		`Started: ${formatTimestampWithAge(run.startedAt)}`,
+		`Ended: ${formatTimestampWithAge(run.endedAt)}`,
+		`Cleanup: ${run.cleanup}`,
+		run.archiveAtMs ? `Archive: ${formatTimestampWithAge(run.archiveAtMs)}` : void 0,
+		run.cleanupHandled ? "Cleanup handled: yes" : void 0,
+		`Outcome: ${outcome}`,
+		progressText ? `Progress: ${progressText}` : void 0,
+		taskSummaryText ? `Task summary: ${taskSummaryText}` : void 0,
+		taskErrorText ? `Task error: ${taskErrorText}` : void 0,
+		linkedTask ? `Delivery: ${linkedTask.deliveryStatus}` : void 0
+	].filter(Boolean).join("\n"));
+}
+//#endregion
+export { handleSubagentsInfoAction };

package/dist/action-kill-BSoka9Ag.js

@@ -0,0 +1,33 @@
+import { i as killControlledSubagentRun, r as killAllControlledSubagentRuns } from "./subagent-control-DoYC7NGK.js";
+import { c as resolveSubagentEntryForToken, i as resolveCommandSubagentController, u as stopWithText } from "./shared-Cs_JtPmo.js";
+import "./commands-subagents-control.runtime-2infwrLW.js";
+//#region src/auto-reply/reply/commands-subagents/action-kill.ts
+async function handleSubagentsKillAction(ctx) {
+	const { params, handledPrefix, requesterKey, runs, restTokens } = ctx;
+	const target = restTokens[0];
+	if (!target) return stopWithText(handledPrefix === "/subagents" ? "Usage: /subagents kill <id|#|all>" : "Usage: /kill <id|#|all>");
+	if (target === "all" || target === "*") {
+		const controller = resolveCommandSubagentController(params, requesterKey);
+		const result = await killAllControlledSubagentRuns({
+			cfg: params.cfg,
+			controller,
+			runs
+		});
+		if (result.status === "forbidden") return stopWithText(`⚠️ ${result.error}`);
+		if (result.killed > 0) return { shouldContinue: false };
+		return { shouldContinue: false };
+	}
+	const targetResolution = resolveSubagentEntryForToken(runs, target);
+	if ("reply" in targetResolution) return targetResolution.reply;
+	const controller = resolveCommandSubagentController(params, requesterKey);
+	const result = await killControlledSubagentRun({
+		cfg: params.cfg,
+		controller,
+		entry: targetResolution.entry
+	});
+	if (result.status === "forbidden") return stopWithText(`⚠️ ${result.error}`);
+	if (result.status === "done") return stopWithText(result.text);
+	return { shouldContinue: false };
+}
+//#endregion
+export { handleSubagentsKillAction };

package/dist/action-list-DnKS7NUS.js

@@ -0,0 +1,21 @@
+import { n as buildSubagentList } from "./subagent-list-w3yWfW9R.js";
+import { u as stopWithText } from "./shared-Cs_JtPmo.js";
+//#region src/auto-reply/reply/commands-subagents/action-list.ts
+function handleSubagentsListAction(ctx) {
+	const { params, runs } = ctx;
+	const list = buildSubagentList({
+		cfg: params.cfg,
+		runs,
+		recentMinutes: 30,
+		taskMaxChars: 110
+	});
+	const lines = ["active subagents:", "-----"];
+	if (list.active.length === 0) lines.push("(none)");
+	else lines.push(list.active.map((entry) => entry.line).join("\n"));
+	lines.push("", `recent subagents (last 30m):`, "-----");
+	if (list.recent.length === 0) lines.push("(none)");
+	else lines.push(list.recent.map((entry) => entry.line).join("\n"));
+	return stopWithText(lines.join("\n"));
+}
+//#endregion
+export { handleSubagentsListAction };

package/dist/action-log-pjPufssA.js

@@ -0,0 +1,30 @@
+import { a as normalizeLowercaseStringOrEmpty } from "./string-coerce-C1IzJjqi.js";
+import { r as callGateway } from "./call-Bu6qiSj3.js";
+import { r as stripToolMessages } from "./chat-history-text-SnTuV_CR.js";
+import { i as formatRunLabel } from "./subagents-format-C1DSWmGn.js";
+import { c as resolveSubagentEntryForToken, r as formatLogLines, u as stopWithText } from "./shared-Cs_JtPmo.js";
+//#region src/auto-reply/reply/commands-subagents/action-log.ts
+async function handleSubagentsLogAction(ctx) {
+	const { runs, restTokens } = ctx;
+	const target = restTokens[0];
+	if (!target) return stopWithText("📜 Usage: /subagents log <id|#> [limit]");
+	const includeTools = restTokens.some((token) => normalizeLowercaseStringOrEmpty(token) === "tools");
+	const limitToken = restTokens.find((token) => /^\d+$/.test(token));
+	const limit = limitToken ? Math.min(200, Math.max(1, Number.parseInt(limitToken, 10))) : 20;
+	const targetResolution = resolveSubagentEntryForToken(runs, target);
+	if ("reply" in targetResolution) return targetResolution.reply;
+	const history = await callGateway({
+		method: "chat.history",
+		params: {
+			sessionKey: targetResolution.entry.childSessionKey,
+			limit
+		}
+	});
+	const rawMessages = Array.isArray(history?.messages) ? history.messages : [];
+	const lines = formatLogLines(includeTools ? rawMessages : stripToolMessages(rawMessages));
+	const header = `📜 Subagent log: ${formatRunLabel(targetResolution.entry)}`;
+	if (lines.length === 0) return stopWithText(`${header}\n(no messages)`);
+	return stopWithText([header, ...lines].join("\n"));
+}
+//#endregion
+export { handleSubagentsLogAction };

package/dist/action-send-rCD6KNIM.js

@@ -0,0 +1,39 @@
+import { i as formatRunLabel } from "./subagents-format-C1DSWmGn.js";
+import { l as sendControlledSubagentMessage, u as steerControlledSubagentRun } from "./subagent-control-DoYC7NGK.js";
+import { c as resolveSubagentEntryForToken, i as resolveCommandSubagentController, u as stopWithText } from "./shared-Cs_JtPmo.js";
+import "./commands-subagents-control.runtime-2infwrLW.js";
+//#region src/auto-reply/reply/commands-subagents/action-send.ts
+async function handleSubagentsSendAction(ctx, steerRequested) {
+	const { params, handledPrefix, runs, restTokens } = ctx;
+	const target = restTokens[0];
+	const message = restTokens.slice(1).join(" ").trim();
+	if (!target || !message) return stopWithText(steerRequested ? handledPrefix === "/subagents" ? "Usage: /subagents steer <id|#> <message>" : `Usage: ${handledPrefix} <id|#> <message>` : "Usage: /subagents send <id|#> <message>");
+	const targetResolution = resolveSubagentEntryForToken(runs, target);
+	if ("reply" in targetResolution) return targetResolution.reply;
+	const controller = resolveCommandSubagentController(params, ctx.requesterKey);
+	if (steerRequested) {
+		const result = await steerControlledSubagentRun({
+			cfg: params.cfg,
+			controller,
+			entry: targetResolution.entry,
+			message
+		});
+		if (result.status === "accepted") return stopWithText(`steered ${formatRunLabel(targetResolution.entry)} (run ${result.runId.slice(0, 8)}).`);
+		if (result.status === "done" && result.text) return stopWithText(result.text);
+		if (result.status === "error") return stopWithText(`send failed: ${result.error ?? "error"}`);
+		return stopWithText(`⚠️ ${result.error ?? "send failed"}`);
+	}
+	const result = await sendControlledSubagentMessage({
+		cfg: params.cfg,
+		controller,
+		entry: targetResolution.entry,
+		message
+	});
+	if (result.status === "timeout") return stopWithText(`⏳ Subagent still running (run ${result.runId.slice(0, 8)}).`);
+	if (result.status === "error") return stopWithText(`⚠️ Subagent error: ${result.error} (run ${result.runId.slice(0, 8)}).`);
+	if (result.status === "forbidden") return stopWithText(`⚠️ ${result.error ?? "send failed"}`);
+	if (result.status === "done") return stopWithText(result.text);
+	return stopWithText(result.replyText ?? `✅ Sent to ${formatRunLabel(targetResolution.entry)} (run ${result.runId.slice(0, 8)}).`);
+}
+//#endregion
+export { handleSubagentsSendAction };

package/dist/action-spawn-Z9Cs9AKM.js

@@ -0,0 +1,47 @@
+import { c as normalizeOptionalString } from "./string-coerce-C1IzJjqi.js";
+import { t as spawnSubagentDirect } from "./subagent-spawn-Bu71yN3K.js";
+import { u as stopWithText } from "./shared-Cs_JtPmo.js";
+//#region src/auto-reply/reply/commands-subagents/action-spawn.ts
+async function handleSubagentsSpawnAction(ctx) {
+	const { params, requesterKey, restTokens } = ctx;
+	const requesterSessionEntry = params.sessionStore?.[requesterKey] ?? params.sessionEntry;
+	const agentId = restTokens[0];
+	const taskParts = [];
+	let model;
+	let thinking;
+	for (let i = 1; i < restTokens.length; i++) if (restTokens[i] === "--model" && i + 1 < restTokens.length) {
+		i += 1;
+		model = restTokens[i];
+	} else if (restTokens[i] === "--thinking" && i + 1 < restTokens.length) {
+		i += 1;
+		thinking = restTokens[i];
+	} else taskParts.push(restTokens[i]);
+	const task = taskParts.join(" ").trim();
+	if (!agentId || !task) return stopWithText("Usage: /subagents spawn <agentId> <task> [--model <model>] [--thinking <level>]");
+	const commandTo = normalizeOptionalString(params.command.to) ?? "";
+	const originatingTo = normalizeOptionalString(params.ctx.OriginatingTo) ?? "";
+	const fallbackTo = normalizeOptionalString(params.ctx.To) ?? "";
+	const normalizedTo = originatingTo || commandTo || fallbackTo || void 0;
+	const result = await spawnSubagentDirect({
+		task,
+		agentId,
+		model,
+		thinking,
+		mode: "run",
+		cleanup: "keep",
+		expectsCompletionMessage: true
+	}, {
+		agentSessionKey: requesterKey,
+		agentChannel: params.ctx.OriginatingChannel ?? params.command.channel,
+		agentAccountId: params.ctx.AccountId,
+		agentTo: normalizedTo,
+		agentThreadId: params.ctx.MessageThreadId,
+		agentGroupId: requesterSessionEntry?.groupId ?? null,
+		agentGroupChannel: requesterSessionEntry?.groupChannel ?? null,
+		agentGroupSpace: requesterSessionEntry?.space ?? null
+	});
+	if (result.status === "accepted") return stopWithText(`Spawned subagent ${agentId} (session ${result.childSessionKey}, run ${result.runId?.slice(0, 8)}).`);
+	return stopWithText(`Spawn failed: ${result.error ?? result.status}`);
+}
+//#endregion
+export { handleSubagentsSpawnAction };

package/dist/action-unfocus-D2zbhGSQ.js

@@ -0,0 +1,29 @@
+import { c as normalizeOptionalString } from "./string-coerce-C1IzJjqi.js";
+import { r as normalizeConversationRef } from "./conversation-id-CdkUzz0s.js";
+import { r as getSessionBindingService } from "./session-binding-service-DoeFMDT5.js";
+import { r as resolveConversationBindingContextFromAcpCommand } from "./conversation-binding-input-4r2gq_KQ.js";
+import { u as stopWithText } from "./shared-Cs_JtPmo.js";
+//#region src/auto-reply/reply/commands-subagents/action-unfocus.ts
+async function handleSubagentsUnfocusAction(ctx) {
+	const { params } = ctx;
+	const bindingService = getSessionBindingService();
+	const bindingContext = resolveConversationBindingContextFromAcpCommand(params);
+	if (!bindingContext) return stopWithText("⚠️ /unfocus must be run inside a focused conversation.");
+	const binding = bindingService.resolveByConversation(normalizeConversationRef({
+		channel: bindingContext.channel,
+		accountId: bindingContext.accountId,
+		conversationId: bindingContext.conversationId,
+		parentConversationId: bindingContext.parentConversationId
+	}));
+	if (!binding) return stopWithText("ℹ️ This conversation is not currently focused.");
+	const senderId = normalizeOptionalString(params.command.senderId) ?? "";
+	const boundBy = normalizeOptionalString(binding.metadata?.boundBy) ?? "";
+	if (boundBy && boundBy !== "system" && senderId && senderId !== boundBy) return stopWithText(`⚠️ Only ${boundBy} can unfocus this conversation.`);
+	await bindingService.unbind({
+		bindingId: binding.bindingId,
+		reason: "manual"
+	});
+	return stopWithText("✅ Conversation unfocused.");
+}
+//#endregion
+export { handleSubagentsUnfocusAction };

package/dist/actions.runtime-DCIg2FO0.js

@@ -0,0 +1,18 @@
+import { a as resolveBlueBubblesMessageId, b as sendMessageBlueBubbles, c as editBlueBubblesMessage, d as removeBlueBubblesParticipant, f as renameBlueBubblesChat, h as unsendBlueBubblesMessage, l as leaveBlueBubblesChat, m as setGroupIconBlueBubbles, n as sendBlueBubblesReaction, s as addBlueBubblesParticipant, v as sendBlueBubblesAttachment, y as resolveChatGuidForTarget } from "./reactions-DrQks01C.js";
+//#region extensions/bluebubbles/src/actions.runtime.ts
+const blueBubblesActionsRuntime = {
+	sendBlueBubblesAttachment,
+	addBlueBubblesParticipant,
+	editBlueBubblesMessage,
+	leaveBlueBubblesChat,
+	removeBlueBubblesParticipant,
+	renameBlueBubblesChat,
+	setGroupIconBlueBubbles,
+	unsendBlueBubblesMessage,
+	resolveBlueBubblesMessageId,
+	sendBlueBubblesReaction,
+	resolveChatGuidForTarget,
+	sendMessageBlueBubbles
+};
+//#endregion
+export { blueBubblesActionsRuntime };

package/dist/actions.runtime-io4CYWEl.js

@@ -0,0 +1,5 @@
+import { t as sendMessageZalo } from "./send-CM9Yk5Kl.js";
+//#region extensions/zalo/src/actions.runtime.ts
+const zaloActionsRuntime = { sendMessageZalo };
+//#endregion
+export { zaloActionsRuntime };

package/dist/actions.runtime.js

@@ -1 +1 @@
-export * from "./actions.runtime-BvY67XKu.js";
+export * from "./actions.runtime-io4CYWEl.js";

package/dist/agent-BIsY2xbQ.js

@@ -0,0 +1,2 @@
+import "./agent-command-Bko5m9ND.js";
+export {};