@gaodefa/daocore 2026.5.71 → 2026.5.72

package/dist/commands-handlers.runtime.js

@@ -1 +1 @@
-export * from "./commands-handlers.runtime-BXbiNMgg.js";
+export * from "./commands-handlers.runtime-BwO7aKlP.js";

package/dist/commands-status-B7XWWKfi.js

@@ -0,0 +1,16 @@
+import { r as logVerbose } from "./globals-DhGeOA1P.js";
+import { t as buildStatusText } from "./status-text-D1rI8d_V.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-DdgNN4C5.js

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

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

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

package/dist/commands-status.runtime.js

@@ -1 +1 @@
-export * from "./commands-status.runtime-ontnXxS9.js";
+export * from "./commands-status.runtime-DdgNN4C5.js";

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,162 @@
+import { v as resolveSessionAgentIds } from "./agent-scope-Dx1S0aWX.js";
+import { k as listRegisteredPluginAgentPromptGuidance } from "./command-registration-kBnrmjif.js";
+import { s as resolveDefaultModelForAgent } from "./model-selection-D1TyOrqK.js";
+import { n as resolveSandboxRuntimeStatus } from "./runtime-status-4ANAM1GR.js";
+import { t as isAcpRuntimeSpawnAvailable } from "./availability-DhDc35jn.js";
+import { a as resolveBootstrapContextForRun } from "./bootstrap-files-CqPzStB_.js";
+import { t as createDaoCoreCodingTools } from "./pi-tools-CU6fJXHu.js";
+import { o as buildSystemPromptParams, s as resolveAgentPromptSurfaceForSessionKey, t as buildConfiguredAgentSystemPrompt } from "./system-prompt-config-ZjQ9S1fn.js";
+import "./sandbox-BgrNfelZ.js";
+import { t as buildWorkspaceSkillSnapshot } from "./workspace-NZSkR2Eg.js";
+import "./skills-CljWbiQv.js";
+import { n as resolveEmbeddedFullAccessState } from "./sandbox-info-C5ksc8fy.js";
+import { t as resolveRuntimePolicySessionKey } from "./runtime-policy-session-key-BBFWw42v.js";
+import { n as getSkillsSnapshotVersion } from "./refresh-state-PCEDjmSb.js";
+import { t as canExecRequestNode } from "./exec-defaults-BThQ887z.js";
+import { t as getRemoteSkillEligibility } from "./skills-remote-vuEE6sLa.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,
+		agentId: sessionAgentId
+	});
+	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 createDaoCoreCodingTools({
+				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,
+				modelProvider: params.provider,
+				modelId: params.model
+			});
+		} catch {
+			return [];
+		}
+	})();
+	const toolNames = tools.map((t) => t.name);
+	const promptSurface = resolveAgentPromptSurfaceForSessionKey(params.sessionKey);
+	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 };
+	return {
+		systemPrompt: buildConfiguredAgentSystemPrompt({
+			config: params.cfg,
+			agentId: sessionAgentId,
+			workspaceDir,
+			defaultThinkLevel: params.resolvedThinkLevel,
+			reasoningLevel: params.resolvedReasoningLevel,
+			extraSystemPrompt: void 0,
+			ownerNumbers: void 0,
+			reasoningTagHint: false,
+			toolNames,
+			userTimezone,
+			userTime,
+			userTimeFormat,
+			contextFiles: injectedFiles,
+			skillsPrompt,
+			heartbeatPrompt: void 0,
+			acpEnabled: isAcpRuntimeSpawnAvailable({
+				config: params.cfg,
+				sandboxed: sandboxRuntime.sandboxed
+			}),
+			promptSurface,
+			nativeCommandGuidanceLines: listRegisteredPluginAgentPromptGuidance({ surface: promptSurface }),
+			runtimeInfo,
+			sandboxInfo
+		}),
+		tools,
+		skillsPrompt,
+		bootstrapFiles,
+		injectedFiles,
+		sandboxRuntime
+	};
+}
+//#endregion
+export { resolveCommandsSystemPromptBundle as t };

package/dist/commands.runtime-Bp0sDmRC.js

@@ -0,0 +1,176 @@
+import { t as createLazyImportLoader } from "./lazy-promise-Djskx0qC.js";
+import { n as isAcpSessionKey } from "./session-key-utils-Ce_xWkNq.js";
+import { r as logVerbose } from "./globals-DhGeOA1P.js";
+import { d as updateSessionStoreEntry } from "./store-C4uyNaPD.js";
+import { t as clearBootstrapSnapshot } from "./bootstrap-cache-Czcrjhl6.js";
+import { n as shouldHandleTextCommands } from "./commands-text-routing-BEyXBSW7.js";
+import "./commands-registry-be38KiNc.js";
+import { t as clearAllCliSessions } from "./cli-session-BPlVLy8x.js";
+import { t as parseSoftResetCommand } from "./commands-reset-mode-CrHFTxVv.js";
+import "./commands-context-CDSZxl0l.js";
+import { t as isResetAuthorizedForContext } from "./reset-authorization-Cem5bPvD.js";
+import { r as resetConfiguredBindingTargetInPlace } from "./binding-targets-jjEKQFZR.js";
+import { n as resolveBoundAcpThreadSessionKey } from "./targets-5x1BXjqa.js";
+import { t as emitResetCommandHooks } from "./commands-reset-hooks-BUnv0Spk.js";
+import { t as buildStatusReply } from "./commands-status-B7XWWKfi.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) {
+			const now = Date.now();
+			clearAllCliSessions(targetSessionEntry);
+			if (params.sessionEntry && params.sessionEntry !== targetSessionEntry) {
+				clearAllCliSessions(params.sessionEntry);
+				params.sessionEntry.updatedAt = now;
+				params.sessionEntry.lastInteractionAt = now;
+			}
+			if (params.sessionKey) clearBootstrapSnapshot(params.sessionKey);
+			targetSessionEntry.updatedAt = now;
+			targetSessionEntry.lastInteractionAt = 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: now,
+						lastInteractionAt: 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;
+	const hookResult = await emitResetCommandHooks({
+		action: commandAction,
+		ctx: params.ctx,
+		cfg: params.cfg,
+		command: params.command,
+		sessionKey: params.sessionKey,
+		sessionEntry: targetSessionEntry,
+		previousSessionEntry: params.previousSessionEntry,
+		workspaceDir: params.workspaceDir
+	});
+	if (!resetTail) return {
+		shouldContinue: false,
+		...hookResult.routedReply ? {} : { reply: { text: commandAction === "reset" ? "✅ Session reset." : "✅ New session started." } }
+	};
+	return null;
+}
+//#endregion
+//#region src/auto-reply/reply/commands-core.ts
+const commandHandlersRuntimeLoader = createLazyImportLoader(() => import("./commands-handlers.runtime.js"));
+function loadCommandHandlersRuntime() {
+	return commandHandlersRuntimeLoader.load();
+}
+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-CpTdfFOn.js";
+export * from "./commands.runtime-Bp0sDmRC.js";

package/dist/commitments/runtime.js

@@ -1,2 +1,2 @@
-import { i as resetCommitmentExtractionRuntimeForTests, n as drainCommitmentExtractionQueue, r as enqueueCommitmentExtraction, t as configureCommitmentExtractionRuntime } from "../runtime-B3ogObAE.js";
+import { i as resetCommitmentExtractionRuntimeForTests, n as drainCommitmentExtractionQueue, r as enqueueCommitmentExtraction, t as configureCommitmentExtractionRuntime } from "../runtime-B96cJrbg.js";
 export { configureCommitmentExtractionRuntime, drainCommitmentExtractionQueue, enqueueCommitmentExtraction, resetCommitmentExtractionRuntimeForTests };