fengming 0.3.8 → 0.3.10

package/dist/api-BH7bfI5d.js

@@ -0,0 +1,6 @@
+import "./sandbox-C0ODRGI-.js";
+import "./plugin-entry-DzJsOsJI.js";
+import "./core-Bpk-qSJH.js";
+import "./device-bootstrap-0cUNoRxh.js";
+import "./qr-image-BCCBB35v.js";
+export {};

package/dist/api-BxJNXitd.js

@@ -0,0 +1,2 @@
+import "./core-Bpk-qSJH.js";
+export {};

package/dist/approval-client-helpers-CfQA9Jzh.d.ts

@@ -0,0 +1,78 @@
+import { r as FengMingConfig } from "./types.fengming-NdBrgqd4.js";
+import { b as ExecApprovalForwardTarget } from "./types.slack-BO--YUFl.js";
+import { s as ExecApprovalRequest } from "./exec-approvals-CPpcfY0H.js";
+import { r as ReplyPayload } from "./reply-payload-mCw4ZND6.js";
+import { s as PluginApprovalRequest } from "./plugin-approvals-BT7-U8LU.js";
+//#region src/infra/approval-request-filters.d.ts
+type ApprovalRequestFilterInput = {
+  agentId?: string | null;
+  sessionKey?: string | null;
+};
+declare function matchesApprovalRequestSessionFilter(sessionKey: string, patterns: string[]): boolean;
+declare function matchesApprovalRequestFilters(params: {
+  request: ApprovalRequestFilterInput;
+  agentFilter?: string[];
+  sessionFilter?: string[];
+  fallbackAgentIdFromSessionKey?: boolean;
+}): boolean;
+//#endregion
+//#region src/plugin-sdk/approval-client-helpers.d.ts
+type ApprovalRequest = ExecApprovalRequest | PluginApprovalRequest;
+type ApprovalTarget = "dm" | "channel" | "both";
+type ChannelExecApprovalEnableMode = boolean | "auto";
+type ChannelApprovalConfig = {
+  enabled?: ChannelExecApprovalEnableMode;
+  target?: ApprovalTarget;
+  agentFilter?: string[];
+  sessionFilter?: string[];
+};
+type ApprovalProfileParams = {
+  cfg: FengMingConfig;
+  accountId?: string | null;
+};
+declare function isChannelExecApprovalClientEnabledFromConfig(params: {
+  enabled?: ChannelExecApprovalEnableMode;
+  approverCount: number;
+}): boolean;
+declare function isChannelExecApprovalTargetRecipient(params: {
+  cfg: FengMingConfig;
+  senderId?: string | null;
+  accountId?: string | null;
+  channel: string;
+  normalizeSenderId?: (value: string) => string | undefined;
+  matchTarget: (params: {
+    target: ExecApprovalForwardTarget;
+    normalizedSenderId: string;
+    normalizedAccountId?: string;
+  }) => boolean;
+}): boolean;
+declare function createChannelExecApprovalProfile(params: {
+  resolveConfig: (params: ApprovalProfileParams) => ChannelApprovalConfig | undefined;
+  resolveApprovers: (params: ApprovalProfileParams) => string[];
+  normalizeSenderId?: (value: string) => string | undefined;
+  isTargetRecipient?: (params: ApprovalProfileParams & {
+    senderId?: string | null;
+  }) => boolean;
+  matchesRequestAccount?: (params: ApprovalProfileParams & {
+    request: ApprovalRequest;
+  }) => boolean;
+  fallbackAgentIdFromSessionKey?: boolean;
+  requireClientEnabledForLocalPromptSuppression?: boolean;
+}): {
+  isClientEnabled: (input: ApprovalProfileParams) => boolean;
+  isApprover: (input: ApprovalProfileParams & {
+    senderId?: string | null;
+  }) => boolean;
+  isAuthorizedSender: (input: ApprovalProfileParams & {
+    senderId?: string | null;
+  }) => boolean;
+  resolveTarget: (input: ApprovalProfileParams) => ApprovalTarget;
+  shouldHandleRequest: (input: ApprovalProfileParams & {
+    request: ApprovalRequest;
+  }) => boolean;
+  shouldSuppressLocalPrompt: (input: ApprovalProfileParams & {
+    payload: ReplyPayload;
+  }) => boolean;
+};
+//#endregion
+export { matchesApprovalRequestFilters as a, ApprovalRequestFilterInput as i, isChannelExecApprovalClientEnabledFromConfig as n, matchesApprovalRequestSessionFilter as o, isChannelExecApprovalTargetRecipient as r, createChannelExecApprovalProfile as t };

package/dist/approval-native-helpers-B2zyhxWc.d.ts

@@ -0,0 +1,241 @@
+import { r as FengMingConfig } from "./types.fengming-NdBrgqd4.js";
+import { S as ExecApprovalForwardingMode, x as ExecApprovalForwardingConfig } from "./types.slack-BO--YUFl.js";
+import { s as ExecApprovalRequest } from "./exec-approvals-CPpcfY0H.js";
+import { s as ChannelOutboundPayloadHint } from "./outbound.types-DVkbsxo8.js";
+import { r as ReplyPayload } from "./reply-payload-mCw4ZND6.js";
+import { i as ChannelApprovalCapability } from "./types.adapters-DSaA0bHm.js";
+import { s as PluginApprovalRequest } from "./plugin-approvals-BT7-U8LU.js";
+import { i as ExecApprovalReplyMetadata } from "./exec-approval-reply-CoTVqtr7.js";
+import { n as ExecApprovalSessionTarget } from "./exec-approval-session-target-3ES6hy6_.js";
+
+//#region src/plugin-sdk/approval-native-helpers.d.ts
+type ApprovalRequest = ExecApprovalRequest | PluginApprovalRequest;
+type ApprovalKind = "exec" | "plugin";
+type DeliverySuppressionInput = Parameters<NonNullable<NonNullable<ChannelApprovalCapability["delivery"]>["shouldSuppressForwardingFallback"]>>[0];
+type NativeApprovalForwardTarget = DeliverySuppressionInput["target"];
+type LocalNativeExecApprovalConfig = {
+  enabled?: boolean | "auto";
+  mode?: string | null;
+  agentFilter?: string[];
+  sessionFilter?: string[];
+};
+type ChannelApprovalForwardTarget = DeliverySuppressionInput["target"];
+type ApprovalResolverParams = {
+  cfg: FengMingConfig;
+  accountId?: string | null;
+  approvalKind?: ApprovalKind;
+  request: ApprovalRequest;
+};
+type ChannelApprovalForwardingEvaluatorParams = {
+  channel: string;
+  isTransportEnabled: (params: {
+    cfg: FengMingConfig;
+    accountId?: string | null;
+  }) => boolean;
+  hasMatchingTarget: (params: {
+    cfg: FengMingConfig;
+    config: ExecApprovalForwardingConfig;
+    accountId?: string | null;
+    target?: ChannelApprovalForwardTarget;
+  }) => boolean;
+  hasOriginOrSessionTarget: (params: {
+    cfg: FengMingConfig;
+    accountId?: string | null;
+    request: ApprovalRequest;
+  }) => boolean;
+};
+type ChannelApprovalForwardingEligibilityParams = {
+  cfg: FengMingConfig;
+  accountId?: string | null;
+  approvalKind: ApprovalKind;
+  request: ApprovalRequest;
+};
+type ChannelApprovalPotentialRouteParams = {
+  cfg: FengMingConfig;
+  accountId?: string | null;
+  approvalKind: ApprovalKind;
+  nativeSessionOnly?: boolean;
+};
+type ChannelApprovalExplicitTargetEligibilityParams = ChannelApprovalForwardingEligibilityParams & {
+  target: ChannelApprovalForwardTarget;
+};
+type NativeApprovalTargetNormalizer<TTarget> = (target: TTarget, request: ApprovalRequest) => TTarget | null | undefined;
+type NativeApprovalForwardingFallbackSuppressorParams<TTarget extends NativeApprovalTarget> = {
+  channel: string;
+  normalizeForwardTarget: (target: NativeApprovalForwardTarget) => TTarget | null;
+  resolveAccountId?: (params: {
+    forwardingTarget: TTarget;
+    target: NativeApprovalForwardTarget;
+    request: ApprovalRequest;
+  }) => string | null | undefined;
+  resolveApprovalKind?: (params: {
+    approvalKind?: ApprovalKind;
+    request: ApprovalRequest;
+  }) => ApprovalKind;
+  isSessionRouteEligible: (params: {
+    cfg: FengMingConfig;
+    accountId?: string | null;
+    approvalKind: ApprovalKind;
+    request: ApprovalRequest;
+  }) => boolean;
+  isExplicitTargetEligible?: (params: {
+    cfg: FengMingConfig;
+    accountId?: string | null;
+    approvalKind: ApprovalKind;
+    request: ApprovalRequest;
+    target: NativeApprovalForwardTarget;
+  }) => boolean;
+  resolveForwardingTargetForMatch?: (params: {
+    forwardingTarget: TTarget;
+    accountId?: string | null;
+    target: NativeApprovalForwardTarget;
+    approvalKind: ApprovalKind;
+    request: ApprovalRequest;
+  }) => TTarget | null;
+  resolveOriginTarget: (params: {
+    cfg: FengMingConfig;
+    accountId?: string | null;
+    approvalKind: ApprovalKind;
+    request: ApprovalRequest;
+  }) => TTarget | null;
+  resolveApproverDmTargets: (params: {
+    cfg: FengMingConfig;
+    accountId?: string | null;
+    approvalKind: ApprovalKind;
+    request: ApprovalRequest;
+  }) => readonly TTarget[];
+  targetsMatch?: (left: TTarget, right: TTarget) => boolean;
+};
+type NativeApprovalChannelRouteGateParams<TTarget extends NativeApprovalTarget> = {
+  channel: string;
+  defaultForwardingMode: ExecApprovalForwardingMode;
+  isTransportEnabled: (params: {
+    cfg: FengMingConfig;
+    accountId?: string | null;
+  }) => boolean;
+  listAccountIds: (cfg: FengMingConfig) => readonly string[];
+  resolveDefaultAccountId: (cfg: FengMingConfig) => string;
+  normalizeForwardTarget: (target: NativeApprovalForwardTarget) => TTarget | null;
+  resolveTurnSourceTarget: (request: ApprovalRequest) => TTarget | null;
+  targetsMatch?: (left: TTarget, right: TTarget) => boolean;
+};
+type NativeApprovalChannelRouteGates = {
+  canApprovalPotentiallyRouteToChannel: (params: {
+    cfg: FengMingConfig;
+    accountId?: string | null;
+    approvalKind: ApprovalKind;
+    nativeSessionOnly?: boolean;
+  }) => boolean;
+  canAnyApprovalPotentiallyRouteToChannel: (params: {
+    cfg: FengMingConfig;
+    accountId?: string | null;
+    nativeSessionOnly?: boolean;
+  }) => boolean;
+  isNativeApprovalHandlerConfigured: (params: {
+    cfg: FengMingConfig;
+    accountId?: string | null;
+  }) => boolean;
+  isSessionApprovalEligible: (params: {
+    cfg: FengMingConfig;
+    accountId?: string | null;
+    approvalKind: ApprovalKind;
+    request: ApprovalRequest;
+  }) => boolean;
+  isExplicitTargetEligible: (params: {
+    cfg: FengMingConfig;
+    accountId?: string | null;
+    approvalKind: ApprovalKind;
+    request: ApprovalRequest;
+    target: NativeApprovalForwardTarget;
+  }) => boolean;
+  shouldHandleApprovalRequest: (params: {
+    cfg: FengMingConfig;
+    accountId?: string | null;
+    approvalKind?: ApprovalKind;
+    request: ApprovalRequest;
+  }) => boolean;
+};
+type BaseOriginResolverParams<TTarget> = {
+  channel: string;
+  shouldHandleRequest?: (params: ApprovalResolverParams) => boolean;
+  resolveTurnSourceTarget: (request: ApprovalRequest) => TTarget | null;
+  resolveSessionTarget: (sessionTarget: ExecApprovalSessionTarget, request: ApprovalRequest) => TTarget | null;
+  normalizeTarget?: NativeApprovalTargetNormalizer<TTarget>;
+  normalizeTargetForMatch?: NativeApprovalTargetNormalizer<TTarget>;
+  resolveFallbackTarget?: (request: ApprovalRequest) => TTarget | null;
+};
+type NativeOriginResolverParams<TTarget extends NativeApprovalTarget> = BaseOriginResolverParams<TTarget> & {
+  targetsMatch?: (a: TTarget, b: TTarget) => boolean;
+};
+type CustomOriginResolverParams<TTarget> = BaseOriginResolverParams<TTarget> & {
+  targetsMatch: (a: TTarget, b: TTarget) => boolean;
+};
+type NativeApprovalTarget = {
+  to: string;
+  accountId?: string | null;
+  threadId?: string | number | null;
+};
+declare function nativeApprovalTargetsMatch(params: {
+  channel?: string | null;
+  left: NativeApprovalTarget;
+  right: NativeApprovalTarget;
+}): boolean;
+declare function shouldSuppressLocalNativeExecApprovalPrompt(params: {
+  cfg: FengMingConfig;
+  accountId?: string | null;
+  payload: ReplyPayload;
+  hint?: ChannelOutboundPayloadHint;
+  isTransportEnabled?: (params: {
+    cfg: FengMingConfig;
+    accountId?: string | null;
+  }) => boolean;
+  isNativeDeliveryEnabled?: (params: {
+    cfg: FengMingConfig;
+    accountId?: string | null;
+  }) => boolean;
+  resolveApprovalConfig?: (params: {
+    cfg: FengMingConfig;
+    accountId?: string | null;
+    metadata: ExecApprovalReplyMetadata;
+  }) => LocalNativeExecApprovalConfig | undefined;
+  requireApprovalConfigEnabled?: boolean;
+  enforceForwardingMode?: boolean;
+  isSessionRouteEligible?: (params: {
+    cfg: FengMingConfig;
+    accountId?: string | null;
+    metadata: ExecApprovalReplyMetadata;
+  }) => boolean;
+  hasExactTargetProof?: boolean;
+  fallbackAgentIdFromSessionKey?: boolean;
+}): boolean;
+declare function resolveApprovalKind(request: ApprovalRequest, approvalKind?: ApprovalKind): ApprovalKind;
+declare function createChannelApprovalForwardingEvaluator(params: ChannelApprovalForwardingEvaluatorParams): {
+  canAnyPotentiallyRoute: (input: {
+    cfg: FengMingConfig;
+    accountId?: string | null;
+    nativeSessionOnly?: boolean;
+  }) => boolean;
+  isExplicitTargetEligible: (input: ChannelApprovalExplicitTargetEligibilityParams) => boolean;
+  isPotentialRoute: (input: ChannelApprovalPotentialRouteParams) => boolean;
+  isSessionEligible: (input: ChannelApprovalForwardingEligibilityParams) => boolean;
+  shouldHandleRequest: (input: {
+    cfg: FengMingConfig;
+    accountId?: string | null;
+    approvalKind?: ApprovalKind;
+    request: ApprovalRequest;
+  }) => boolean;
+};
+declare function createNativeApprovalChannelRouteGates<TTarget extends NativeApprovalTarget>(params: NativeApprovalChannelRouteGateParams<TTarget>): NativeApprovalChannelRouteGates;
+declare function createNativeApprovalForwardingFallbackSuppressor<TTarget extends NativeApprovalTarget>(params: NativeApprovalForwardingFallbackSuppressorParams<TTarget>): NonNullable<NonNullable<ChannelApprovalCapability["delivery"]>["shouldSuppressForwardingFallback"]>;
+declare function createChannelNativeOriginTargetResolver<TTarget extends NativeApprovalTarget>(params: NativeOriginResolverParams<TTarget>): (input: ApprovalResolverParams) => TTarget | null;
+declare function createChannelNativeOriginTargetResolver<TTarget>(params: CustomOriginResolverParams<TTarget>): (input: ApprovalResolverParams) => TTarget | null;
+declare function createChannelApproverDmTargetResolver<TApprover, TTarget extends NativeApprovalTarget = NativeApprovalTarget>(params: {
+  shouldHandleRequest?: (params: ApprovalResolverParams) => boolean;
+  resolveApprovers: (params: {
+    cfg: FengMingConfig;
+    accountId?: string | null;
+  }) => readonly TApprover[];
+  mapApprover: (approver: TApprover, params: ApprovalResolverParams) => TTarget | null | undefined;
+}): (input: ApprovalResolverParams) => TTarget[];
+//#endregion
+export { createChannelApproverDmTargetResolver as a, createNativeApprovalForwardingFallbackSuppressor as c, shouldSuppressLocalNativeExecApprovalPrompt as d, createChannelApprovalForwardingEvaluator as i, nativeApprovalTargetsMatch as l, ChannelApprovalForwardingEligibilityParams as n, createChannelNativeOriginTargetResolver as o, ChannelApprovalPotentialRouteParams as r, createNativeApprovalChannelRouteGates as s, ChannelApprovalExplicitTargetEligibilityParams as t, resolveApprovalKind as u };

package/dist/approval-renderers-CMqSXyvm.d.ts

@@ -0,0 +1,39 @@
+import { r as ReplyPayload } from "./reply-payload-mCw4ZND6.js";
+import { l as PluginApprovalResolved, s as PluginApprovalRequest } from "./plugin-approvals-BT7-U8LU.js";
+import { r as ExecApprovalReplyDecision } from "./exec-approval-reply-CoTVqtr7.js";
+
+//#region src/plugin-sdk/approval-renderers.d.ts
+/** Build a pending approval reply payload using the portable presentation API. */
+declare function buildApprovalPendingReplyPayload(params: {
+  approvalKind?: "exec" | "plugin";
+  approvalId: string;
+  approvalSlug: string;
+  text: string;
+  agentId?: string | null;
+  allowedDecisions?: readonly ExecApprovalReplyDecision[];
+  sessionKey?: string | null;
+  channelData?: Record<string, unknown>;
+}): ReplyPayload;
+/** Build a resolved approval reply payload with approval metadata but no controls. */
+declare function buildApprovalResolvedReplyPayload(params: {
+  approvalId: string;
+  approvalSlug: string;
+  text: string;
+  channelData?: Record<string, unknown>;
+}): ReplyPayload;
+declare function buildPluginApprovalPendingReplyPayload(params: {
+  request: PluginApprovalRequest;
+  nowMs: number;
+  text?: string;
+  approvalSlug?: string;
+  allowedDecisions?: readonly ExecApprovalReplyDecision[];
+  channelData?: Record<string, unknown>;
+}): ReplyPayload;
+declare function buildPluginApprovalResolvedReplyPayload(params: {
+  resolved: PluginApprovalResolved;
+  text?: string;
+  approvalSlug?: string;
+  channelData?: Record<string, unknown>;
+}): ReplyPayload;
+//#endregion
+export { buildPluginApprovalResolvedReplyPayload as i, buildApprovalResolvedReplyPayload as n, buildPluginApprovalPendingReplyPayload as r, buildApprovalPendingReplyPayload as t };

package/dist/assistant-Cu_Mzzgu.js

@@ -0,0 +1,291 @@
+import "./agent-scope-EEbMCF2I.js";
+import { c as resolveDefaultAgentId } from "./agent-scope-config-BHdZonI2.js";
+import { u as readConfigFileSnapshot } from "./io-T1CV3Z1L.js";
+import "./config-4B-JCqw_.js";
+import { n as extractAssistantText } from "./embedded-agent-utils-CFR2b0P2.js";
+import { r as prepareSimpleCompletionModelForAgent, t as completeWithPreparedSimpleCompletionModel } from "./simple-completion-runtime-D9ketq_T.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-8";
+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, FengMing's ring-zero setup helper.",
+	"Turn the user's request into exactly one safe FengMing 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 FengMing 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"}`,
+		`FengMing docs: ${params.overview.references.docsPath ?? params.overview.references.docsUrl}`,
+		`FengMing 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?.runEmbeddedAgent ?? await loadRunEmbeddedAgent())({
+				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(), "fengming-crestodian-planner-"));
+}
+async function removeTempPlannerDir(dir) {
+	await fs.rm(dir, {
+		recursive: true,
+		force: true
+	});
+}
+async function loadRunCliAgent() {
+	return (await import("./cli-runner-CimXSTVs.js")).runCliAgent;
+}
+async function loadRunEmbeddedAgent() {
+	return (await import("./embedded-agent-CEpOPW6X.js")).runEmbeddedAgent;
+}
+function extractPlannerResultText(result) {
+	return result.meta?.finalAssistantVisibleText ?? result.meta?.finalAssistantRawText ?? result.payloads?.map((payload) => payload.text?.trim()).filter(Boolean).join("\n");
+}
+//#endregion
+export { planCrestodianCommand };