@gaodefa/daocore 2026.5.34 → 2026.5.36

package/dist/api-DFDhOB71.js

@@ -0,0 +1,134 @@
+import { i as formatErrorMessage } from "./errors-D_oyTIw2.js";
+import { i as stringEnum } from "./typebox-BFQUlzrn.js";
+import "./error-runtime--zM-GsR-.js";
+import "./channel-actions-BEsMIO8Q.js";
+import "./setup-core-DtXl0cMj.js";
+import { r as parseZalouserOutboundTarget } from "./session-route-CJUmMLQC.js";
+import "./channel-BM_u9Kct.js";
+import { i as listZaloFriendsMatching, n as getZaloUserInfo, s as listZaloGroupsMatching, t as checkZaloAuthenticated } from "./zalo-js-CuNhJqRW.js";
+import "./setup-surface-xoTELXW9.js";
+import "./channel.setup-x_GPUW2e.js";
+import { i as sendMessageZalouser, n as sendImageZalouser, r as sendLinkZalouser } from "./send-D4t_gmic.js";
+import { Type } from "typebox";
+//#region extensions/zalouser/src/tool.ts
+const ACTIONS = [
+	"send",
+	"image",
+	"link",
+	"friends",
+	"groups",
+	"me",
+	"status"
+];
+const ZalouserToolSchema = Type.Object({
+	action: stringEnum(ACTIONS, { description: `Action to perform: ${ACTIONS.join(", ")}` }),
+	threadId: Type.Optional(Type.String({ description: "Thread ID for messaging" })),
+	message: Type.Optional(Type.String({ description: "Message text" })),
+	isGroup: Type.Optional(Type.Boolean({ description: "Is group chat" })),
+	profile: Type.Optional(Type.String({ description: "Profile name" })),
+	query: Type.Optional(Type.String({ description: "Search query" })),
+	url: Type.Optional(Type.String({ description: "URL for media/link" }))
+}, { additionalProperties: false });
+function json(payload) {
+	return {
+		content: [{
+			type: "text",
+			text: JSON.stringify(payload, null, 2)
+		}],
+		details: payload
+	};
+}
+function resolveAmbientZalouserTarget(context) {
+	const deliveryContext = context?.deliveryContext;
+	const rawTarget = deliveryContext?.to;
+	if ((deliveryContext?.channel === void 0 || deliveryContext.channel === "zalouser") && typeof rawTarget === "string" && rawTarget.trim()) try {
+		return parseZalouserOutboundTarget(rawTarget);
+	} catch {}
+	if (deliveryContext?.channel && deliveryContext.channel !== "zalouser") return {};
+	const ambientThreadId = deliveryContext?.threadId;
+	if (typeof ambientThreadId === "string" && ambientThreadId.trim()) return { threadId: ambientThreadId.trim() };
+	if (typeof ambientThreadId === "number" && Number.isFinite(ambientThreadId)) return { threadId: String(ambientThreadId) };
+	return {};
+}
+function resolveZalouserSendTarget(params, context) {
+	const explicitThreadId = typeof params.threadId === "string" ? params.threadId.trim() : "";
+	const ambientTarget = resolveAmbientZalouserTarget(context);
+	return {
+		threadId: explicitThreadId || ambientTarget.threadId,
+		isGroup: typeof params.isGroup === "boolean" ? params.isGroup : ambientTarget.isGroup
+	};
+}
+async function executeZalouserTool(_toolCallId, params, _signal, _onUpdate, context) {
+	try {
+		switch (params.action) {
+			case "send": {
+				const target = resolveZalouserSendTarget(params, context);
+				if (!target.threadId || !params.message) throw new Error("threadId and message required for send action");
+				const result = await sendMessageZalouser(target.threadId, params.message, {
+					profile: params.profile,
+					isGroup: target.isGroup
+				});
+				if (!result.ok) throw new Error(result.error || "Failed to send message");
+				return json({
+					success: true,
+					messageId: result.messageId
+				});
+			}
+			case "image": {
+				const target = resolveZalouserSendTarget(params, context);
+				if (!target.threadId) throw new Error("threadId required for image action");
+				if (!params.url) throw new Error("url required for image action");
+				const result = await sendImageZalouser(target.threadId, params.url, {
+					profile: params.profile,
+					caption: params.message,
+					isGroup: target.isGroup
+				});
+				if (!result.ok) throw new Error(result.error || "Failed to send image");
+				return json({
+					success: true,
+					messageId: result.messageId
+				});
+			}
+			case "link": {
+				const target = resolveZalouserSendTarget(params, context);
+				if (!target.threadId || !params.url) throw new Error("threadId and url required for link action");
+				const result = await sendLinkZalouser(target.threadId, params.url, {
+					profile: params.profile,
+					caption: params.message,
+					isGroup: target.isGroup
+				});
+				if (!result.ok) throw new Error(result.error || "Failed to send link");
+				return json({
+					success: true,
+					messageId: result.messageId
+				});
+			}
+			case "friends": return json(await listZaloFriendsMatching(params.profile, params.query));
+			case "groups": return json(await listZaloGroupsMatching(params.profile, params.query));
+			case "me": return json(await getZaloUserInfo(params.profile) ?? { error: "Not authenticated" });
+			case "status": {
+				const authenticated = await checkZaloAuthenticated(params.profile);
+				return json({
+					authenticated,
+					output: authenticated ? "authenticated" : "not authenticated"
+				});
+			}
+			default:
+				params.action;
+				throw new Error(`Unknown action: ${String(params.action)}. Valid actions: send, image, link, friends, groups, me, status`);
+		}
+	} catch (err) {
+		return json({ error: formatErrorMessage(err) });
+	}
+}
+function createZalouserTool(context) {
+	return {
+		name: "zalouser",
+		label: "Zalo Personal",
+		description: "Send messages and access data via Zalo personal account. Actions: send (text message), image (send image URL), link (send link), friends (list/search friends), groups (list groups), me (profile info), status (auth check).",
+		parameters: ZalouserToolSchema,
+		execute: async (toolCallId, params, signal, onUpdate) => await executeZalouserTool(toolCallId, params, signal, onUpdate, context)
+	};
+}
+//#endregion
+export { createZalouserTool as t };

package/dist/api-Dd41e_NF.js

@@ -0,0 +1,3 @@
+import "./core-DDHeEXv5.js";
+import "./agent-runtime-Cnq13raf.js";
+export {};

package/dist/api-DqSBNv8i.js

@@ -0,0 +1,6 @@
+import "./plugin-entry-CIpvZDX5.js";
+import "./core-DDHeEXv5.js";
+import "./sandbox-DOOT_Ckx.js";
+import "./device-bootstrap-qloAS7GG.js";
+import "./qr-image-BTI89vs3.js";
+export {};

package/dist/apply-DnknmYSP.js

@@ -0,0 +1,41 @@
+import { v as summarizeMigrationItems } from "./migration-DGUrqTK8.js";
+import { i as writeMigrationReport, n as copyMigrationFileItem, r as withCachedMigrationConfigRuntime, t as archiveMigrationItem } from "./migration-runtime-90Qf6vxF.js";
+import { t as appendItem } from "./helpers-xQou1j8g.js";
+import { n as applyManualItem, t as applyConfigItem } from "./config-rXQcYybF.js";
+import { t as applyGeneratedSkillItem } from "./skills-CIpJIsm1.js";
+import { t as buildClaudePlan } from "./plan-BILA3XMN.js";
+import path from "node:path";
+//#region extensions/migrate-claude/apply.ts
+async function applyClaudePlan(params) {
+	const plan = params.plan ?? await buildClaudePlan(params.ctx);
+	const reportDir = params.ctx.reportDir ?? path.join(params.ctx.stateDir, "migration", "claude");
+	const runtime = withCachedMigrationConfigRuntime(params.ctx.runtime ?? params.runtime, params.ctx.config);
+	const applyCtx = {
+		...params.ctx,
+		runtime
+	};
+	const items = [];
+	for (const item of plan.items) {
+		if (item.status !== "planned") {
+			items.push(item);
+			continue;
+		}
+		if (item.kind === "config") items.push(await applyConfigItem(applyCtx, item));
+		else if (item.kind === "manual") items.push(applyManualItem(item));
+		else if (item.action === "archive") items.push(await archiveMigrationItem(item, reportDir));
+		else if (item.action === "append") items.push(await appendItem(item));
+		else if (item.action === "create" && item.kind === "skill") items.push(await applyGeneratedSkillItem(item, { overwrite: params.ctx.overwrite }));
+		else items.push(await copyMigrationFileItem(item, reportDir, { overwrite: params.ctx.overwrite }));
+	}
+	const result = {
+		...plan,
+		items,
+		summary: summarizeMigrationItems(items),
+		backupPath: params.ctx.backupPath,
+		reportDir
+	};
+	await writeMigrationReport(result, { title: "Claude Migration Report" });
+	return result;
+}
+//#endregion
+export { applyClaudePlan as t };

package/dist/apply-XMFoVMgK.js

@@ -0,0 +1,54 @@
+import { d as markMigrationItemSkipped, v as summarizeMigrationItems } from "./migration-DGUrqTK8.js";
+import { i as writeMigrationReport, n as copyMigrationFileItem, r as withCachedMigrationConfigRuntime, t as archiveMigrationItem } from "./migration-runtime-90Qf6vxF.js";
+import { t as appendItem } from "./helpers-w2CyK9G6.js";
+import { n as applyManualItem, t as applyConfigItem } from "./config-BTXVD-PS.js";
+import { t as applyModelItem } from "./model-CrGV78vh.js";
+import { t as applySecretItem } from "./secrets-DjmhS0YO.js";
+import { t as resolveTargets } from "./targets-B8kgW-Y8.js";
+import { t as buildHermesPlan } from "./plan-DHXchBJq.js";
+import path from "node:path";
+//#region extensions/migrate-hermes/apply.ts
+const HERMES_REASON_BLOCKED_BY_APPLY_CONFLICT = "blocked by earlier apply conflict";
+async function applyHermesPlan(params) {
+	const plan = params.plan ?? await buildHermesPlan(params.ctx);
+	const reportDir = params.ctx.reportDir ?? path.join(params.ctx.stateDir, "migration", "hermes");
+	const targets = resolveTargets(params.ctx);
+	const items = [];
+	const runtime = withCachedMigrationConfigRuntime(params.ctx.runtime ?? params.runtime, params.ctx.config);
+	const applyCtx = {
+		...params.ctx,
+		runtime
+	};
+	let blockedByApplyConflict = false;
+	for (const item of plan.items) {
+		if (item.status !== "planned") {
+			items.push(item);
+			continue;
+		}
+		if (blockedByApplyConflict) {
+			items.push(markMigrationItemSkipped(item, HERMES_REASON_BLOCKED_BY_APPLY_CONFLICT));
+			continue;
+		}
+		let appliedItem;
+		if (item.id === "config:default-model") appliedItem = await applyModelItem(applyCtx, item);
+		else if (item.kind === "config") appliedItem = await applyConfigItem(applyCtx, item);
+		else if (item.kind === "manual") appliedItem = applyManualItem(item);
+		else if (item.action === "archive") appliedItem = await archiveMigrationItem(item, reportDir);
+		else if (item.kind === "secret") appliedItem = await applySecretItem(params.ctx, item, targets);
+		else if (item.action === "append") appliedItem = await appendItem(item);
+		else appliedItem = await copyMigrationFileItem(item, reportDir, { overwrite: params.ctx.overwrite });
+		items.push(appliedItem);
+		if (item.kind === "config" && (appliedItem.status === "conflict" || appliedItem.status === "error")) blockedByApplyConflict = true;
+	}
+	const result = {
+		...plan,
+		items,
+		summary: summarizeMigrationItems(items),
+		backupPath: params.ctx.backupPath,
+		reportDir
+	};
+	await writeMigrationReport(result, { title: "Hermes Migration Report" });
+	return result;
+}
+//#endregion
+export { applyHermesPlan as t };

package/dist/approval-handler.runtime-BIKhPCUE.js

@@ -0,0 +1,130 @@
+import { c as normalizeOptionalString } from "./string-coerce-DyL154ka.js";
+import { t as createSubsystemLogger } from "./subsystem-CppbuBPw.js";
+import { t as buildChannelApprovalNativeTargetKey } from "./approval-native-target-key-D2RQhpuG.js";
+import "./runtime-env-BSECk1Nm.js";
+import "./string-coerce-runtime-DcopKqDR.js";
+import { c as buildExecApprovalPendingReplyPayload, i as buildApprovalPresentationFromActionDescriptors } from "./exec-approval-reply-C55wf2Le.js";
+import { r as createChannelApprovalNativeRuntimeAdapter } from "./approval-handler-runtime-prQTgPuS.js";
+import "./approval-handler-runtime-yqyUv6e3.js";
+import "./approval-native-runtime-UafzK2xu.js";
+import { r as buildPluginApprovalPendingReplyPayload } from "./approval-renderers-BYwKQNbO.js";
+import "./approval-reply-runtime-DDfe9Pyl.js";
+import { a as isTelegramExecApprovalHandlerConfigured, u as shouldHandleTelegramExecApprovalRequest } from "./exec-approvals-CwwQA-_B.js";
+import { t as resolveTelegramInlineButtons } from "./button-types-C0Gyj4Tz.js";
+import { i as editMessageReplyMarkupTelegram, p as sendTypingTelegram, u as sendMessageTelegram } from "./send-BlmkYrI0.js";
+//#region extensions/telegram/src/approval-handler.runtime.ts
+const log = createSubsystemLogger("telegram/approvals");
+function resolveHandlerContext(params) {
+	const context = params.context;
+	const accountId = normalizeOptionalString(params.accountId) ?? "";
+	if (!context?.token || !accountId) return null;
+	return {
+		accountId,
+		context
+	};
+}
+function buildPendingPayload(params) {
+	return {
+		text: (params.approvalKind === "plugin" ? buildPluginApprovalPendingReplyPayload({
+			request: params.request,
+			nowMs: params.nowMs
+		}) : buildExecApprovalPendingReplyPayload({
+			approvalId: params.request.id,
+			approvalSlug: params.request.id.slice(0, 8),
+			approvalCommandId: params.request.id,
+			warningText: params.view.approvalKind === "exec" ? params.view.warningText ?? void 0 : void 0,
+			command: params.view.approvalKind === "exec" ? params.view.commandText : "",
+			cwd: params.view.approvalKind === "exec" ? params.view.cwd ?? void 0 : void 0,
+			host: params.view.approvalKind === "exec" && params.view.host === "node" ? "node" : "gateway",
+			nodeId: params.view.approvalKind === "exec" ? params.view.nodeId ?? void 0 : void 0,
+			allowedDecisions: params.view.actions.map((action) => action.decision),
+			expiresAtMs: params.request.expiresAtMs,
+			nowMs: params.nowMs
+		})).text ?? "",
+		buttons: resolveTelegramInlineButtons({ presentation: buildApprovalPresentationFromActionDescriptors(params.view.actions) })
+	};
+}
+const telegramApprovalNativeRuntime = createChannelApprovalNativeRuntimeAdapter({
+	eventKinds: ["exec", "plugin"],
+	availability: {
+		isConfigured: (params) => {
+			const resolved = resolveHandlerContext(params);
+			return resolved ? isTelegramExecApprovalHandlerConfigured({
+				cfg: params.cfg,
+				accountId: resolved.accountId
+			}) : false;
+		},
+		shouldHandle: (params) => {
+			const resolved = resolveHandlerContext(params);
+			return resolved ? shouldHandleTelegramExecApprovalRequest({
+				cfg: params.cfg,
+				accountId: resolved.accountId,
+				request: params.request
+			}) : false;
+		}
+	},
+	presentation: {
+		buildPendingPayload: ({ request, approvalKind, nowMs, view }) => buildPendingPayload({
+			request,
+			approvalKind,
+			nowMs,
+			view
+		}),
+		buildResolvedResult: () => ({ kind: "clear-actions" }),
+		buildExpiredResult: () => ({ kind: "clear-actions" })
+	},
+	transport: {
+		prepareTarget: ({ plannedTarget }) => ({
+			dedupeKey: buildChannelApprovalNativeTargetKey(plannedTarget.target),
+			target: {
+				chatId: plannedTarget.target.to,
+				messageThreadId: typeof plannedTarget.target.threadId === "number" ? plannedTarget.target.threadId : void 0
+			}
+		}),
+		deliverPending: async ({ cfg, accountId, context, preparedTarget, pendingPayload }) => {
+			const resolved = resolveHandlerContext({
+				cfg,
+				accountId,
+				context
+			});
+			if (!resolved) return null;
+			const sendTyping = resolved.context.deps?.sendTyping ?? sendTypingTelegram;
+			const sendMessage = resolved.context.deps?.sendMessage ?? sendMessageTelegram;
+			await sendTyping(preparedTarget.chatId, {
+				cfg,
+				token: resolved.context.token,
+				accountId: resolved.accountId,
+				...preparedTarget.messageThreadId != null ? { messageThreadId: preparedTarget.messageThreadId } : {}
+			}).catch(() => {});
+			const result = await sendMessage(preparedTarget.chatId, pendingPayload.text, {
+				cfg,
+				token: resolved.context.token,
+				accountId: resolved.accountId,
+				buttons: pendingPayload.buttons,
+				...preparedTarget.messageThreadId != null ? { messageThreadId: preparedTarget.messageThreadId } : {}
+			});
+			return {
+				chatId: result.chatId,
+				messageId: result.messageId
+			};
+		}
+	},
+	interactions: { clearPendingActions: async ({ cfg, accountId, context, entry }) => {
+		const resolved = resolveHandlerContext({
+			cfg,
+			accountId,
+			context
+		});
+		if (!resolved) return;
+		await (resolved.context.deps?.editReplyMarkup ?? editMessageReplyMarkupTelegram)(entry.chatId, entry.messageId, [], {
+			cfg,
+			token: resolved.context.token,
+			accountId: resolved.accountId
+		});
+	} },
+	observe: { onDeliveryError: ({ error, request }) => {
+		log.error(`telegram approvals: failed to send request ${request.id}: ${String(error)}`);
+	} }
+});
+//#endregion
+export { telegramApprovalNativeRuntime };

package/dist/assistant-Cfzr-QfG.js

@@ -0,0 +1,291 @@
+import "./agent-scope-Dx1S0aWX.js";
+import { c as resolveDefaultAgentId } from "./agent-scope-config-CJUQxn7u.js";
+import { u as readConfigFileSnapshot } from "./io-Ct2JqgbR.js";
+import "./config-CLrwLpl0.js";
+import { n as extractAssistantText } from "./pi-embedded-utils-B5v2j1CN.js";
+import { r as prepareSimpleCompletionModelForAgent, t as completeWithPreparedSimpleCompletionModel } from "./simple-completion-runtime-CJFmCkYk.js";
+import path from "node:path";
+import fs from "node:fs/promises";
+import os from "node:os";
+import { randomUUID } from "node:crypto";
+//#region src/crestodian/assistant-backends.ts
+const CRESTODIAN_CLAUDE_CLI_MODEL = "claude-opus-4-7";
+const CRESTODIAN_CODEX_MODEL = "gpt-5.5";
+const CLAUDE_CLI_BACKEND = {
+	kind: "claude-cli",
+	label: `claude-cli/${CRESTODIAN_CLAUDE_CLI_MODEL}`,
+	runner: "cli",
+	provider: "claude-cli",
+	model: CRESTODIAN_CLAUDE_CLI_MODEL,
+	buildConfig: (workspaceDir) => buildCliPlannerConfig(workspaceDir, `claude-cli/${CRESTODIAN_CLAUDE_CLI_MODEL}`)
+};
+const CODEX_APP_SERVER_BACKEND = {
+	kind: "codex-app-server",
+	label: `openai/${CRESTODIAN_CODEX_MODEL} via codex`,
+	runner: "embedded",
+	provider: "openai",
+	model: CRESTODIAN_CODEX_MODEL,
+	buildConfig: buildCodexAppServerPlannerConfig
+};
+function selectCrestodianLocalPlannerBackends(overview) {
+	const backends = [];
+	if (overview.tools.claude.found) backends.push(CLAUDE_CLI_BACKEND);
+	if (overview.tools.codex.found) backends.push(CODEX_APP_SERVER_BACKEND);
+	return backends;
+}
+function buildCliPlannerConfig(workspaceDir, modelRef) {
+	return { agents: { defaults: {
+		workspace: workspaceDir,
+		model: { primary: modelRef }
+	} } };
+}
+function buildCodexAppServerPlannerConfig(workspaceDir) {
+	return {
+		agents: { defaults: {
+			workspace: workspaceDir,
+			model: { primary: `openai/${CRESTODIAN_CODEX_MODEL}` }
+		} },
+		plugins: { entries: { codex: { enabled: true } } }
+	};
+}
+//#endregion
+//#region src/crestodian/assistant-prompts.ts
+const CRESTODIAN_ASSISTANT_TIMEOUT_MS = 1e4;
+const CRESTODIAN_ASSISTANT_SYSTEM_PROMPT = [
+	"You are Crestodian, DaoCore's ring-zero setup helper.",
+	"Turn the user's request into exactly one safe DaoCore Crestodian command.",
+	"Return only compact JSON with keys reply and command.",
+	"Do not invent commands. Do not claim a write was applied.",
+	"Do not use tools, shell commands, file edits, or network lookups; plan only from the supplied overview.",
+	"Use the provided DaoCore docs/source references when the user's request needs behavior, config, or architecture details.",
+	"If local source is available, prefer inspecting it. Otherwise point to GitHub and strongly recommend reviewing source when docs are not enough.",
+	"Allowed commands:",
+	"- setup",
+	"- status",
+	"- health",
+	"- doctor",
+	"- doctor fix",
+	"- gateway status",
+	"- restart gateway",
+	"- start gateway",
+	"- stop gateway",
+	"- agents",
+	"- models",
+	"- plugins list",
+	"- plugins search <query>",
+	"- plugin install <npm-or-clawhub-spec>",
+	"- plugin uninstall <id>",
+	"- audit",
+	"- validate config",
+	"- set default model <provider/model>",
+	"- config set <path> <value>",
+	"- config set-ref <path> env <ENV_VAR>",
+	"- create agent <id> workspace <path> model <provider/model>",
+	"- talk to <id> agent",
+	"- talk to agent",
+	"If unsure, choose overview."
+].join("\n");
+function buildCrestodianAssistantUserPrompt(params) {
+	const agents = params.overview.agents.map((agent) => {
+		return `- ${[
+			`id=${agent.id}`,
+			agent.name ? `name=${agent.name}` : void 0,
+			agent.workspace ? `workspace=${agent.workspace}` : void 0,
+			agent.model ? `model=${agent.model}` : void 0,
+			agent.isDefault ? "default=true" : void 0
+		].filter(Boolean).join(", ")}`;
+	}).join("\n");
+	return [
+		`User request: ${params.input}`,
+		"",
+		`Default agent: ${params.overview.defaultAgentId}`,
+		`Default model: ${params.overview.defaultModel ?? "not configured"}`,
+		`Config valid: ${params.overview.config.valid}`,
+		`Gateway reachable: ${params.overview.gateway.reachable}`,
+		`Codex binary: ${params.overview.tools.codex.found ? "found" : "not found"}`,
+		`Claude Code CLI: ${params.overview.tools.claude.found ? "found" : "not found"}`,
+		`OpenAI API key: ${params.overview.tools.apiKeys.openai ? "found" : "not found"}`,
+		`Anthropic API key: ${params.overview.tools.apiKeys.anthropic ? "found" : "not found"}`,
+		`DaoCore docs: ${params.overview.references.docsPath ?? params.overview.references.docsUrl}`,
+		`DaoCore source: ${params.overview.references.sourcePath ?? params.overview.references.sourceUrl}`,
+		params.overview.references.sourcePath ? "Source mode: local git checkout; inspect source directly when docs are insufficient." : "Source mode: package/install; use GitHub source when docs are insufficient.",
+		"",
+		"Agents:",
+		agents || "- none"
+	].join("\n");
+}
+function parseCrestodianAssistantPlanText(rawText) {
+	const text = rawText?.trim();
+	if (!text) return null;
+	const jsonText = extractFirstJsonObject(text);
+	if (!jsonText) return null;
+	let parsed;
+	try {
+		parsed = JSON.parse(jsonText);
+	} catch {
+		return null;
+	}
+	if (!parsed || typeof parsed !== "object") return null;
+	const record = parsed;
+	const command = typeof record.command === "string" ? record.command.trim() : "";
+	if (!command) return null;
+	const reply = typeof record.reply === "string" ? record.reply.trim() : void 0;
+	return {
+		command,
+		...reply ? { reply } : {}
+	};
+}
+function extractFirstJsonObject(text) {
+	const start = text.indexOf("{");
+	const end = text.lastIndexOf("}");
+	if (start < 0 || end <= start) return null;
+	return text.slice(start, end + 1);
+}
+//#endregion
+//#region src/crestodian/assistant.ts
+async function planCrestodianCommand(params) {
+	const configured = await planCrestodianCommandWithConfiguredModel(params);
+	if (configured) return configured;
+	return await planCrestodianCommandWithLocalRuntime(params);
+}
+async function planCrestodianCommandWithConfiguredModel(params) {
+	const input = params.input.trim();
+	if (!input) return null;
+	const snapshot = await (params.deps?.readConfigFileSnapshot ?? readConfigFileSnapshot)();
+	if (!snapshot.exists || !snapshot.valid) return null;
+	const cfg = snapshot.runtimeConfig ?? snapshot.config;
+	const agentId = resolveDefaultAgentId(cfg);
+	const prepared = await (params.deps?.prepareSimpleCompletionModelForAgent ?? prepareSimpleCompletionModelForAgent)({
+		cfg,
+		agentId,
+		allowMissingApiKeyModes: ["aws-sdk"]
+	});
+	if ("error" in prepared) return null;
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(), CRESTODIAN_ASSISTANT_TIMEOUT_MS);
+	try {
+		const parsed = parseCrestodianAssistantPlanText(extractAssistantText(await (params.deps?.completeWithPreparedSimpleCompletionModel ?? completeWithPreparedSimpleCompletionModel)({
+			model: prepared.model,
+			auth: prepared.auth,
+			context: {
+				systemPrompt: CRESTODIAN_ASSISTANT_SYSTEM_PROMPT,
+				messages: [{
+					role: "user",
+					content: buildCrestodianAssistantUserPrompt({
+						input,
+						overview: params.overview
+					}),
+					timestamp: Date.now()
+				}]
+			},
+			options: {
+				maxTokens: 512,
+				signal: controller.signal
+			}
+		})));
+		if (!parsed) return null;
+		return {
+			...parsed,
+			modelLabel: `${prepared.selection.provider}/${prepared.selection.modelId}`
+		};
+	} catch {
+		return null;
+	} finally {
+		clearTimeout(timer);
+	}
+}
+async function planCrestodianCommandWithLocalRuntime(params) {
+	const input = params.input.trim();
+	if (!input) return null;
+	const backends = selectCrestodianLocalPlannerBackends(params.overview);
+	if (backends.length === 0) return null;
+	const prompt = buildCrestodianAssistantUserPrompt({
+		input,
+		overview: params.overview
+	});
+	for (const backend of backends) try {
+		const parsed = parseCrestodianAssistantPlanText(await runLocalRuntimePlanner(backend, {
+			prompt,
+			deps: params.deps
+		}));
+		if (parsed) return {
+			...parsed,
+			modelLabel: backend.label
+		};
+	} catch {}
+	return null;
+}
+async function runLocalRuntimePlanner(backend, params) {
+	const tempDir = await (params.deps?.createTempDir ?? createTempPlannerDir)();
+	try {
+		const runId = `crestodian-planner-${randomUUID()}`;
+		const sessionFile = path.join(tempDir, "session.jsonl");
+		const sessionId = `${runId}-session`;
+		const sessionKey = `temp:crestodian-planner:${runId}`;
+		switch (backend.runner) {
+			case "cli": return extractPlannerResultText(await (params.deps?.runCliAgent ?? await loadRunCliAgent())({
+				sessionId,
+				sessionKey,
+				agentId: "crestodian",
+				trigger: "manual",
+				sessionFile,
+				workspaceDir: tempDir,
+				config: backend.buildConfig(tempDir),
+				prompt: params.prompt,
+				provider: backend.provider,
+				model: backend.model,
+				timeoutMs: CRESTODIAN_ASSISTANT_TIMEOUT_MS,
+				runId,
+				extraSystemPrompt: CRESTODIAN_ASSISTANT_SYSTEM_PROMPT,
+				extraSystemPromptStatic: CRESTODIAN_ASSISTANT_SYSTEM_PROMPT,
+				messageChannel: "crestodian",
+				messageProvider: "crestodian",
+				cleanupCliLiveSessionOnRunEnd: true
+			}));
+			case "embedded": return extractPlannerResultText(await (params.deps?.runEmbeddedPiAgent ?? await loadRunEmbeddedPiAgent())({
+				sessionId,
+				sessionKey,
+				agentId: "crestodian",
+				trigger: "manual",
+				sessionFile,
+				workspaceDir: tempDir,
+				config: backend.buildConfig(tempDir),
+				prompt: params.prompt,
+				provider: backend.provider,
+				model: backend.model,
+				agentHarnessId: "codex",
+				disableTools: true,
+				toolsAllow: [],
+				timeoutMs: CRESTODIAN_ASSISTANT_TIMEOUT_MS,
+				runId,
+				extraSystemPrompt: CRESTODIAN_ASSISTANT_SYSTEM_PROMPT,
+				messageChannel: "crestodian",
+				messageProvider: "crestodian",
+				cleanupBundleMcpOnRunEnd: true
+			}));
+		}
+		return;
+	} finally {
+		await (params.deps?.removeTempDir ?? removeTempPlannerDir)(tempDir);
+	}
+}
+async function createTempPlannerDir() {
+	return await fs.mkdtemp(path.join(os.tmpdir(), "daocore-crestodian-planner-"));
+}
+async function removeTempPlannerDir(dir) {
+	await fs.rm(dir, {
+		recursive: true,
+		force: true
+	});
+}
+async function loadRunCliAgent() {
+	return (await import("./cli-runner-Df8f6aib.js")).runCliAgent;
+}
+async function loadRunEmbeddedPiAgent() {
+	return (await import("./pi-embedded-BKpKsszm.js")).runEmbeddedPiAgent;
+}
+function extractPlannerResultText(result) {
+	return result.meta?.finalAssistantVisibleText ?? result.meta?.finalAssistantRawText ?? result.payloads?.map((payload) => payload.text?.trim()).filter(Boolean).join("\n");
+}
+//#endregion
+export { planCrestodianCommand };