kaijibot 2026.8.21 → 2026.8.23

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

@@ -0,0 +1,88 @@
+import { n as isAcpSessionKey } from "./session-key-utils-DEfwsZM6.js";
+import { u as resolveAgentIdFromSessionKey } from "./session-key-Dny5dRer.js";
+import { n as readAcpSessionEntry } from "./session-meta-knhthO95.js";
+import { c as resolveConfiguredAcpBindingSpecFromRecord } from "./binding-registry-CZ0egX2f.js";
+import { i as resolveConfiguredAcpBindingSpecBySessionKey, n as ensureConfiguredAcpBindingSession, t as ensureConfiguredAcpBindingReady } from "./persistent-bindings.lifecycle-CvUywK5_.js";
+import { a as performGatewaySessionReset } from "./session-reset-service-6oOKZMC9.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-Bx5S-ZYL.js

@@ -0,0 +1,67 @@
+import { s as normalizeOptionalString } from "./string-coerce-xZwG7Dq8.js";
+import { i as normalizeChannelId, t as getChannelPlugin } from "./registry-oQjdISx1.js";
+import "./plugins-Dvy8KJPp.js";
+import { m as subagentRuns, s as countPendingDescendantRunsFromRuns, t as getSubagentRunsSnapshotForRead } from "./subagent-registry-state-CjRrrVgp.js";
+import { c as sortSubagentRuns, i as formatRunLabel } from "./subagents-format-DXuyOMu-.js";
+import { r as getSessionBindingService } from "./session-binding-service-BdDm07I2.js";
+import { h as resolveCommandSurfaceChannel, m as resolveChannelAccountId, p as stopWithText } from "./shared-igYZ1cFQ.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-DGURwLDo.js

@@ -0,0 +1,124 @@
+import { s as normalizeOptionalString } from "./string-coerce-xZwG7Dq8.js";
+import { t as normalizeChatType } from "./chat-type-DEgo6tv3.js";
+import { r as getSessionBindingService } from "./session-binding-service-BdDm07I2.js";
+import { n as readAcpSessionEntry } from "./session-meta-knhthO95.js";
+import { r as resolveAcpThreadSessionDetailLines, t as resolveAcpSessionCwd } from "./session-identifiers-B50OHgBr.js";
+import { i as resolveThreadBindingThreadName, r as resolveThreadBindingIntroText } from "./thread-bindings-messages-DX9YBEdF.js";
+import { d as resolveThreadBindingSpawnPolicy, l as resolveThreadBindingMaxAgeMsForChannel, n as formatThreadBindingSpawnDisabledError, o as resolveThreadBindingIdleTimeoutMsForChannel, t as formatThreadBindingDisabledError, u as resolveThreadBindingPlacementForCurrentContext } from "./thread-bindings-policy-eUVk8lQk.js";
+import { r as resolveConversationBindingContextFromAcpCommand } from "./conversation-binding-input-BFDOo5Tc.js";
+import { c as resolveFocusTargetSession, p as stopWithText } from "./shared-igYZ1cFQ.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);
+	return {
+		channel: bindingContext.channel,
+		accountId: bindingContext.accountId,
+		conversationId: bindingContext.conversationId,
+		...bindingContext.parentConversationId ? { parentConversationId: bindingContext.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 existingBinding = bindingService.resolveByConversation({
+		channel: bindingContext.channel,
+		accountId: bindingContext.accountId,
+		conversationId: bindingContext.conversationId,
+		...bindingContext.parentConversationId && bindingContext.parentConversationId !== bindingContext.conversationId ? { parentConversationId: bindingContext.parentConversationId } : {}
+	});
+	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: {
+				channel: bindingContext.channel,
+				accountId: bindingContext.accountId,
+				conversationId: bindingContext.conversationId,
+				...bindingContext.parentConversationId && bindingContext.parentConversationId !== 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-7ey3e-V9.js

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

package/dist/action-info-BxQpOqFZ.js

@@ -0,0 +1,58 @@
+import { l as resolveStorePath } from "./paths-DrQr2my6.js";
+import { t as loadSessionStore } from "./store-load-5DAj5ABj.js";
+import { m as subagentRuns, s as countPendingDescendantRunsFromRuns, t as getSubagentRunsSnapshotForRead } from "./subagent-registry-state-CjRrrVgp.js";
+import { t as formatDurationCompact } from "./format-duration-B0hjKqUJ.js";
+import { i as formatRunLabel } from "./subagents-format-DXuyOMu-.js";
+import { a as sanitizeTaskStatusText } from "./task-status-DDGIH7lj.js";
+import { r as findTaskByRunIdForOwner } from "./task-owner-access-rwopIPhc.js";
+import { a as loadSubagentSessionEntry, d as resolveSubagentEntryForToken, i as formatTimestampWithAge, p as stopWithText, s as resolveDisplayStatus } from "./shared-igYZ1cFQ.js";
+//#region src/auto-reply/reply/commands-subagents/action-info.ts
+function handleSubagentsInfoAction(ctx) {
+	const { params, 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, {
+		loadSessionStore,
+		resolveStorePath
+	});
+	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: params.sessionKey
+	});
+	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-C7kGSXgP.js

@@ -0,0 +1,33 @@
+import { i as killControlledSubagentRun, r as killAllControlledSubagentRuns } from "./subagent-control-CoVHKnJF.js";
+import { d as resolveSubagentEntryForToken, o as resolveCommandSubagentController, p as stopWithText } from "./shared-igYZ1cFQ.js";
+import "./commands-subagents-control.runtime-BLHWicyx.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-cwGVroWS.js

@@ -0,0 +1,21 @@
+import { n as buildSubagentList } from "./subagent-list-BPsxOWK_.js";
+import { p as stopWithText } from "./shared-igYZ1cFQ.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-DT-bRM9X.js

@@ -0,0 +1,30 @@
+import { i as normalizeLowercaseStringOrEmpty } from "./string-coerce-xZwG7Dq8.js";
+import { r as callGateway } from "./call-Cisydyym.js";
+import { i as formatRunLabel } from "./subagents-format-DXuyOMu-.js";
+import { i as stripToolMessages } from "./chat-history-text-CZhwQ5__.js";
+import { d as resolveSubagentEntryForToken, p as stopWithText, r as formatLogLines } from "./shared-igYZ1cFQ.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-BNv-Wz-l.js

@@ -0,0 +1,39 @@
+import { i as formatRunLabel } from "./subagents-format-DXuyOMu-.js";
+import { l as sendControlledSubagentMessage, u as steerControlledSubagentRun } from "./subagent-control-CoVHKnJF.js";
+import { d as resolveSubagentEntryForToken, o as resolveCommandSubagentController, p as stopWithText } from "./shared-igYZ1cFQ.js";
+import "./commands-subagents-control.runtime-BLHWicyx.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-DkEYjxPF.js

@@ -0,0 +1,46 @@
+import { s as normalizeOptionalString } from "./string-coerce-xZwG7Dq8.js";
+import { n as spawnSubagentDirect } from "./subagent-spawn-BOLGVu7f.js";
+import { p as stopWithText } from "./shared-igYZ1cFQ.js";
+//#region src/auto-reply/reply/commands-subagents/action-spawn.ts
+async function handleSubagentsSpawnAction(ctx) {
+	const { params, requesterKey, restTokens } = ctx;
+	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: params.sessionEntry?.groupId ?? null,
+		agentGroupChannel: params.sessionEntry?.groupChannel ?? null,
+		agentGroupSpace: params.sessionEntry?.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-CU1WRop0.js

@@ -0,0 +1,28 @@
+import { s as normalizeOptionalString } from "./string-coerce-xZwG7Dq8.js";
+import { r as getSessionBindingService } from "./session-binding-service-BdDm07I2.js";
+import { r as resolveConversationBindingContextFromAcpCommand } from "./conversation-binding-input-BFDOo5Tc.js";
+import { p as stopWithText } from "./shared-igYZ1cFQ.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({
+		channel: bindingContext.channel,
+		accountId: bindingContext.accountId,
+		conversationId: bindingContext.conversationId,
+		...bindingContext.parentConversationId && bindingContext.parentConversationId !== 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/agent-BOaVCAE9.js

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