@gaodefa/daocore 2026.5.31 → 2026.5.33

package/dist/register.agent-DSrwwOvx.js

@@ -0,0 +1,156 @@
+import { a as normalizeLowercaseStringOrEmpty } from "./string-coerce-DyL154ka.js";
+import { t as formatDocsLink } from "./links-CM5vg8_V.js";
+import { r as theme } from "./theme-D58JpUfy.js";
+import { t as hasExplicitOptions } from "./command-options-Dhjl7AMa.js";
+import { n as defaultRuntime } from "./runtime-E_A14BX_.js";
+import { n as runCommandWithRuntime } from "./cli-utils-BIL-oMVy.js";
+import { t as formatHelpExamples } from "./help-format-DXVAk021.js";
+import { t as collectOption } from "./helpers-BNXNWxTW.js";
+//#region src/cli/program/register.agent.ts
+async function loadAgentCliCommand() {
+	return (await import("./agent-via-gateway-Dr06Lb5b.js")).agentCliCommand;
+}
+async function loadAgentsAddCommand() {
+	return (await import("./agents.commands.add-CtpPcYtX.js")).agentsAddCommand;
+}
+async function loadAgentsBindCommand() {
+	return (await import("./agents.commands.bind-DP5TRuoz.js")).agentsBindCommand;
+}
+async function loadAgentsBindingsCommand() {
+	return (await import("./agents.commands.bind-DP5TRuoz.js")).agentsBindingsCommand;
+}
+async function loadAgentsUnbindCommand() {
+	return (await import("./agents.commands.bind-DP5TRuoz.js")).agentsUnbindCommand;
+}
+async function loadAgentsDeleteCommand() {
+	return (await import("./agents.commands.delete-bM1Q63HK.js")).agentsDeleteCommand;
+}
+async function loadAgentsSetIdentityCommand() {
+	return (await import("./agents.commands.identity-CFD_84gv.js")).agentsSetIdentityCommand;
+}
+async function loadAgentsListCommand() {
+	return (await import("./agents.commands.list-DsX1QXPm.js")).agentsListCommand;
+}
+async function loadCreateDefaultDeps() {
+	return (await import("./deps-BYGGiJrH.js")).createDefaultDeps;
+}
+async function loadSetVerbose() {
+	return (await import("./global-state-B4gzUAcU.js")).setVerbose;
+}
+function registerAgentCommands(program, args) {
+	program.command("agent").description("Run an agent turn via the Gateway (use --local for embedded)").requiredOption("-m, --message <text>", "Message body for the agent").option("-t, --to <number>", "Recipient number in E.164 used to derive the session key").option("--session-key <key>", "Explicit session key (agent:<id>:<key>, or scoped to --agent)").option("--session-id <id>", "Use an explicit session id").option("--agent <id>", "Agent id (overrides routing bindings)").option("--model <id>", "Model override for this run (provider/model or model id)").option("--thinking <level>", "Thinking level: off | minimal | low | medium | high | xhigh | adaptive | max where supported").option("--verbose <on|off>", "Persist agent verbose level for the session").option("--channel <channel>", `Delivery channel: ${args.agentChannelOptions} (omit to use the main session channel)`).option("--reply-to <target>", "Delivery target override (separate from session routing)").option("--reply-channel <channel>", "Delivery channel override (separate from routing)").option("--reply-account <id>", "Delivery account id override").option("--local", "Run the embedded agent locally (requires model provider API keys in your shell)", false).option("--deliver", "Send the agent's reply back to the selected channel", false).option("--json", "Output result as JSON", false).option("--timeout <seconds>", "Override agent command timeout (seconds, default 600 or config value)").addHelpText("after", () => `
+${theme.heading("Examples:")}
+${formatHelpExamples([
+		["daocore agent --to +15555550123 --message \"status update\"", "Start a new session."],
+		["daocore agent --agent ops --message \"Summarize logs\"", "Use a specific agent."],
+		["daocore agent --session-key agent:ops:incident-42 --message \"Summarize status\"", "Target an exact session key."],
+		["daocore agent --session-id 1234 --message \"Summarize inbox\" --thinking medium", "Target a session with explicit thinking level."],
+		["daocore agent --to +15555550123 --message \"Trace logs\" --verbose on --json", "Enable verbose logging and JSON output."],
+		["daocore agent --to +15555550123 --message \"Summon reply\" --deliver", "Deliver reply."],
+		["daocore agent --agent ops --message \"Generate report\" --deliver --reply-channel slack --reply-to \"#reports\"", "Send reply to a different channel/target."]
+	])}
+
+${theme.muted("Docs:")} ${formatDocsLink("/cli/agent", "docs.openclaw.ai/cli/agent")}`).action(async (opts) => {
+		const verboseLevel = typeof opts.verbose === "string" ? normalizeLowercaseStringOrEmpty(opts.verbose) : "";
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			(await loadSetVerbose())(verboseLevel === "on");
+			const deps = (await loadCreateDefaultDeps())();
+			await (await loadAgentCliCommand())(opts, defaultRuntime, deps);
+		});
+	});
+	const agents = program.command("agents").description("Manage isolated agents (workspaces + auth + routing)").addHelpText("after", () => `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/agents", "docs.openclaw.ai/cli/agents")}\n`);
+	agents.command("list").description("List configured agents").option("--json", "Output JSON instead of text", false).option("--bindings", "Include routing bindings", false).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			await (await loadAgentsListCommand())({
+				json: Boolean(opts.json),
+				bindings: Boolean(opts.bindings)
+			}, defaultRuntime);
+		});
+	});
+	agents.command("bindings").description("List routing bindings").option("--agent <id>", "Filter by agent id").option("--json", "Output JSON instead of text", false).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			await (await loadAgentsBindingsCommand())({
+				agent: opts.agent,
+				json: Boolean(opts.json)
+			}, defaultRuntime);
+		});
+	});
+	agents.command("bind").description("Add routing bindings for an agent").option("--agent <id>", "Agent id (defaults to current default agent)").option("--bind <channel[:accountId]>", "Binding to add (repeatable). If omitted, accountId is resolved by channel defaults/hooks.", collectOption, []).option("--json", "Output JSON summary", false).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			await (await loadAgentsBindCommand())({
+				agent: opts.agent,
+				bind: Array.isArray(opts.bind) ? opts.bind : void 0,
+				json: Boolean(opts.json)
+			}, defaultRuntime);
+		});
+	});
+	agents.command("unbind").description("Remove routing bindings for an agent").option("--agent <id>", "Agent id (defaults to current default agent)").option("--bind <channel[:accountId]>", "Binding to remove (repeatable)", collectOption, []).option("--all", "Remove all bindings for this agent", false).option("--json", "Output JSON summary", false).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			await (await loadAgentsUnbindCommand())({
+				agent: opts.agent,
+				bind: Array.isArray(opts.bind) ? opts.bind : void 0,
+				all: Boolean(opts.all),
+				json: Boolean(opts.json)
+			}, defaultRuntime);
+		});
+	});
+	agents.command("add [name]").description("Add a new isolated agent").option("--workspace <dir>", "Workspace directory for the new agent").option("--model <id>", "Model id for this agent").option("--agent-dir <dir>", "Agent state directory for this agent").option("--bind <channel[:accountId]>", "Route channel binding (repeatable)", collectOption, []).option("--non-interactive", "Disable prompts; requires --workspace", false).option("--json", "Output JSON summary", false).action(async (name, opts, command) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const hasFlags = hasExplicitOptions(command, [
+				"workspace",
+				"model",
+				"agentDir",
+				"bind",
+				"nonInteractive"
+			]);
+			await (await loadAgentsAddCommand())({
+				name: typeof name === "string" ? name : void 0,
+				workspace: opts.workspace,
+				model: opts.model,
+				agentDir: opts.agentDir,
+				bind: Array.isArray(opts.bind) ? opts.bind : void 0,
+				nonInteractive: Boolean(opts.nonInteractive),
+				json: Boolean(opts.json)
+			}, defaultRuntime, { hasFlags });
+		});
+	});
+	agents.command("set-identity").description("Update an agent identity (name/theme/emoji/avatar)").option("--agent <id>", "Agent id to update").option("--workspace <dir>", "Workspace directory used to locate the agent + IDENTITY.md").option("--identity-file <path>", "Explicit IDENTITY.md path to read").option("--from-identity", "Read values from IDENTITY.md", false).option("--name <name>", "Identity name").option("--theme <theme>", "Identity theme").option("--emoji <emoji>", "Identity emoji").option("--avatar <value>", "Identity avatar (workspace path, http(s) URL, or data URI)").option("--json", "Output JSON summary", false).addHelpText("after", () => `
+${theme.heading("Examples:")}
+${formatHelpExamples([
+		["daocore agents set-identity --agent main --name \"DaoCore\" --emoji \"☯\"", "Set name + emoji."],
+		["daocore agents set-identity --agent main --avatar avatars/daocore.png", "Set avatar path."],
+		["daocore agents set-identity --workspace ~/.daocore/workspace --from-identity", "Load from IDENTITY.md."],
+		["daocore agents set-identity --identity-file ~/.daocore/workspace/IDENTITY.md --agent main", "Use a specific IDENTITY.md."]
+	])}
+`).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			await (await loadAgentsSetIdentityCommand())({
+				agent: opts.agent,
+				workspace: opts.workspace,
+				identityFile: opts.identityFile,
+				fromIdentity: Boolean(opts.fromIdentity),
+				name: opts.name,
+				theme: opts.theme,
+				emoji: opts.emoji,
+				avatar: opts.avatar,
+				json: Boolean(opts.json)
+			}, defaultRuntime);
+		});
+	});
+	agents.command("delete <id>").description("Delete an agent and prune workspace/state").option("--force", "Skip confirmation", false).option("--json", "Output JSON summary", false).action(async (id, opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			await (await loadAgentsDeleteCommand())({
+				id: String(id),
+				force: Boolean(opts.force),
+				json: Boolean(opts.json)
+			}, defaultRuntime);
+		});
+	});
+	agents.action(async () => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			await (await loadAgentsListCommand())({}, defaultRuntime);
+		});
+	});
+}
+//#endregion
+export { registerAgentCommands };

package/dist/register.crestodian-Xxxk2-Zl.js

@@ -0,0 +1,24 @@
+import { r as theme } from "./theme-D58JpUfy.js";
+import { n as defaultRuntime } from "./runtime-E_A14BX_.js";
+import { t as runCrestodian } from "./crestodian-v9uXA3A2.js";
+import { n as runCommandWithRuntime } from "./cli-utils-BIL-oMVy.js";
+import { t as formatHelpExamples } from "./help-format-DXVAk021.js";
+//#region src/cli/program/register.crestodian.ts
+function registerCrestodianCommand(program) {
+	program.command("crestodian").description("Open the ring-zero setup and repair helper").option("-m, --message <text>", "Run one Crestodian request").option("--yes", "Approve persistent config writes for this request", false).option("--json", "Output startup overview as JSON", false).addHelpText("after", () => `\n${theme.heading("Examples:")}\n${formatHelpExamples([
+		["daocore", "Start Crestodian."],
+		["daocore crestodian", "Start Crestodian explicitly."],
+		["daocore crestodian -m \"status\"", "Run one status request."],
+		["daocore crestodian -m \"set default model openai/gpt-5.2\" --yes", "Apply a typed config write."]
+	])}`).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			await runCrestodian({
+				message: opts.message,
+				yes: Boolean(opts.yes),
+				json: Boolean(opts.json)
+			});
+		});
+	});
+}
+//#endregion
+export { registerCrestodianCommand };

package/dist/register.maintenance-CDfzLTNQ.js

@@ -0,0 +1,83 @@
+import { t as formatDocsLink } from "./links-CM5vg8_V.js";
+import { r as theme } from "./theme-D58JpUfy.js";
+import { n as defaultRuntime } from "./runtime-E_A14BX_.js";
+import { n as runCommandWithRuntime } from "./cli-utils-BIL-oMVy.js";
+//#region src/cli/program/register.maintenance.ts
+function registerMaintenanceCommands(program) {
+	program.command("doctor").description("Health checks + quick fixes for the gateway and channels").addHelpText("after", () => `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/doctor", "docs.openclaw.ai/cli/doctor")}\n`).option("--no-workspace-suggestions", "Disable workspace memory system suggestions", false).option("--yes", "Accept defaults without prompting", false).option("--repair", "Apply recommended repairs without prompting", false).option("--fix", "Apply recommended repairs (alias for --repair)", false).option("--force", "Apply aggressive repairs (overwrites custom service config)", false).option("--non-interactive", "Run without prompts (safe migrations only)", false).option("--generate-gateway-token", "Generate and configure a gateway token", false).option("--deep", "Scan system services for extra gateway installs", false).option("--lint", "Run read-only health checks and report findings", false).option("--json", "With --lint: emit JSON findings instead of human output", false).option("--severity-min <level>", "With --lint: drop findings below this severity (info|warning|error)").option("--skip <id>", "With --lint: skip a specific check id (repeatable)", (v, prev) => [...prev, v], []).option("--only <id>", "With --lint: run only the specified check id (repeatable)", (v, prev) => [...prev, v], []).action(async (opts) => {
+		if (opts.lint === true) {
+			await runCommandWithRuntime(defaultRuntime, async () => {
+				const { runDoctorLintCli } = await import("./doctor-lint-DbYtxQxC.js");
+				const exitCode = await runDoctorLintCli(defaultRuntime, {
+					json: Boolean(opts.json),
+					severityMin: typeof opts.severityMin === "string" ? opts.severityMin : void 0,
+					skipIds: Array.isArray(opts.skip) ? opts.skip : [],
+					onlyIds: Array.isArray(opts.only) ? opts.only : []
+				});
+				defaultRuntime.exit(exitCode);
+			}, (err) => {
+				defaultRuntime.error(String(err));
+				defaultRuntime.exit(2);
+			});
+			return;
+		}
+		if (hasLintOnlyDoctorOptions(opts)) {
+			defaultRuntime.error("doctor lint options require --lint. Use `daocore doctor --lint ...`.");
+			defaultRuntime.exit(2);
+			return;
+		}
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const { doctorCommand } = await import("./doctor-_JI7RKJk.js");
+			await doctorCommand(defaultRuntime, {
+				workspaceSuggestions: opts.workspaceSuggestions,
+				yes: Boolean(opts.yes),
+				repair: Boolean(opts.repair) || Boolean(opts.fix),
+				force: Boolean(opts.force),
+				nonInteractive: Boolean(opts.nonInteractive),
+				generateGatewayToken: Boolean(opts.generateGatewayToken),
+				deep: Boolean(opts.deep)
+			});
+			defaultRuntime.exit(0);
+		});
+	});
+	program.command("dashboard").description("Open the Control UI with your current token").addHelpText("after", () => `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/dashboard", "docs.openclaw.ai/cli/dashboard")}\n`).option("--no-open", "Print URL but do not launch a browser").option("--yes", "Start/install the gateway without prompting when needed", false).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const { dashboardCommand } = await import("./dashboard-4-QqcZN0.js");
+			await dashboardCommand(defaultRuntime, {
+				noOpen: opts.open === false,
+				yes: Boolean(opts.yes)
+			});
+		});
+	});
+	program.command("reset").description("Reset local config/state (keeps the CLI installed)").addHelpText("after", () => `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/reset", "docs.openclaw.ai/cli/reset")}\n`).option("--scope <scope>", "config|config+creds+sessions|full (default: interactive prompt)").option("--yes", "Skip confirmation prompts", false).option("--non-interactive", "Disable prompts (requires --scope + --yes)", false).option("--dry-run", "Print actions without removing files", false).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const { resetCommand } = await import("./reset-CweQWpON.js");
+			await resetCommand(defaultRuntime, {
+				scope: opts.scope,
+				yes: Boolean(opts.yes),
+				nonInteractive: Boolean(opts.nonInteractive),
+				dryRun: Boolean(opts.dryRun)
+			});
+		});
+	});
+	program.command("uninstall").description("Uninstall the gateway service + local data (CLI remains)").addHelpText("after", () => `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/uninstall", "docs.openclaw.ai/cli/uninstall")}\n`).option("--service", "Remove the gateway service", false).option("--state", "Remove state + config", false).option("--workspace", "Remove workspace dirs", false).option("--app", "Remove the macOS app", false).option("--all", "Remove service + state + workspace + app", false).option("--yes", "Skip confirmation prompts", false).option("--non-interactive", "Disable prompts (requires --yes)", false).option("--dry-run", "Print actions without removing files", false).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const { uninstallCommand } = await import("./uninstall-UOawPwSS.js");
+			await uninstallCommand(defaultRuntime, {
+				service: Boolean(opts.service),
+				state: Boolean(opts.state),
+				workspace: Boolean(opts.workspace),
+				app: Boolean(opts.app),
+				all: Boolean(opts.all),
+				yes: Boolean(opts.yes),
+				nonInteractive: Boolean(opts.nonInteractive),
+				dryRun: Boolean(opts.dryRun)
+			});
+		});
+	});
+}
+function hasLintOnlyDoctorOptions(opts) {
+	return opts.json === true || typeof opts.severityMin === "string" || Array.isArray(opts.skip) && opts.skip.length > 0 || Array.isArray(opts.only) && opts.only.length > 0;
+}
+//#endregion
+export { registerMaintenanceCommands };

package/dist/register.runtime-BVG-Dv_-.js

@@ -0,0 +1,54 @@
+import { a as unregisterAcpRuntimeBackend, t as getAcpRuntimeBackend } from "./registry-DZLZ16sq.js";
+import "./acp-runtime-backend-Cn6L41Tg.js";
+//#region extensions/acpx/register.runtime.ts
+const ACPX_BACKEND_ID = "acpx";
+let serviceModulePromise = null;
+function loadServiceModule() {
+	serviceModulePromise ??= import("./service-DlI2U-cK.js");
+	return serviceModulePromise;
+}
+async function startRealService(state) {
+	if (state.realRuntime) return state.realRuntime;
+	if (!state.ctx) throw new Error("ACPX runtime service is not started");
+	state.startPromise ??= (async () => {
+		const { createAcpxRuntimeService } = await loadServiceModule();
+		const service = createAcpxRuntimeService(state.params);
+		state.realService = service;
+		await service.start(state.ctx);
+		const backend = getAcpRuntimeBackend(ACPX_BACKEND_ID);
+		if (!backend?.runtime) throw new Error("ACPX runtime service did not register an ACP backend");
+		state.realRuntime = backend.runtime;
+		return state.realRuntime;
+	})();
+	return await state.startPromise;
+}
+function createAcpxRuntimeService(params = {}) {
+	const state = {
+		ctx: null,
+		params,
+		realRuntime: null,
+		realService: null,
+		startPromise: null
+	};
+	return {
+		id: "acpx-runtime",
+		async start(ctx) {
+			if (process.env.DAOCORE_SKIP_ACPX_RUNTIME === "1") {
+				ctx.logger.info("skipping embedded acpx runtime backend (DAOCORE_SKIP_ACPX_RUNTIME=1)");
+				return;
+			}
+			state.ctx = ctx;
+			await startRealService(state);
+		},
+		async stop(ctx) {
+			if (state.realService) await state.realService.stop?.(ctx);
+			else unregisterAcpRuntimeBackend(ACPX_BACKEND_ID);
+			state.ctx = null;
+			state.realRuntime = null;
+			state.realService = null;
+			state.startPromise = null;
+		}
+	};
+}
+//#endregion
+export { createAcpxRuntimeService as t };

package/dist/register.runtime-BcgdXzLA.d.ts

@@ -0,0 +1,6 @@
+import { l as DaoCorePluginApi, sn as ProviderPlugin } from "./types-DHSQkzyq2.js";
+//#region extensions/anthropic/register.runtime.d.ts
+declare function buildAnthropicProvider(): ProviderPlugin;
+declare function registerAnthropicPlugin(api: DaoCorePluginApi): void;
+//#endregion
+export { registerAnthropicPlugin as n, buildAnthropicProvider as t };

package/dist/register.status-health-sessions-B36GUeBl.js

@@ -0,0 +1,282 @@
+import { t as formatDocsLink } from "./links-CM5vg8_V.js";
+import { r as theme } from "./theme-D58JpUfy.js";
+import { n as defaultRuntime } from "./runtime-E_A14BX_.js";
+import { r as setVerbose } from "./global-state-BAD7XgmL.js";
+import "./globals-DhGeOA1P.js";
+import { n as runCommandWithRuntime } from "./cli-utils-BIL-oMVy.js";
+import { t as formatHelpExamples } from "./help-format-DXVAk021.js";
+import { n as parsePositiveIntOrUndefined } from "./helpers-BNXNWxTW.js";
+//#region src/cli/program/register.status-health-sessions.ts
+function resolveVerbose(opts) {
+	return Boolean(opts.verbose || opts.debug);
+}
+function addSessionsListOptions(command) {
+	return command.option("--json", "Output as JSON", false).option("--verbose", "Verbose logging", false).option("--store <path>", "Path to session store (default: resolved from config)").option("--agent <id>", "Agent id to inspect (default: configured default agent)").option("--all-agents", "Aggregate sessions across all configured agents", false).option("--active <minutes>", "Only show sessions updated within the past N minutes").option("--limit <count>", "Max sessions to show (default: 100; use \"all\" for full output)");
+}
+function mergeSessionsListOptions(opts, parentOpts) {
+	return {
+		json: Boolean(opts.json || parentOpts?.json),
+		verbose: Boolean(opts.verbose || parentOpts?.verbose),
+		store: opts.store ?? parentOpts?.store,
+		agent: opts.agent ?? parentOpts?.agent,
+		allAgents: Boolean(opts.allAgents || parentOpts?.allAgents),
+		active: opts.active ?? parentOpts?.active,
+		limit: opts.limit ?? parentOpts?.limit
+	};
+}
+async function runSessionsListCli(opts) {
+	setVerbose(Boolean(opts.verbose));
+	const { sessionsCommand } = await import("./sessions-Cv4BZV8s.js");
+	await sessionsCommand({
+		json: Boolean(opts.json),
+		store: opts.store,
+		agent: opts.agent,
+		allAgents: Boolean(opts.allAgents),
+		active: opts.active,
+		limit: opts.limit
+	}, defaultRuntime);
+}
+function parseTimeoutMs(timeout) {
+	const parsed = parsePositiveIntOrUndefined(timeout);
+	if (timeout !== void 0 && parsed === void 0) {
+		defaultRuntime.error("--timeout must be a positive integer (milliseconds)");
+		defaultRuntime.exit(1);
+		return null;
+	}
+	return parsed;
+}
+async function runWithVerboseAndTimeout(opts, action) {
+	const verbose = resolveVerbose(opts);
+	setVerbose(verbose);
+	const timeoutMs = parseTimeoutMs(opts.timeout);
+	if (timeoutMs === null) return;
+	await runCommandWithRuntime(defaultRuntime, async () => {
+		await action({
+			verbose,
+			timeoutMs
+		});
+	});
+}
+function registerStatusHealthSessionsCommands(program) {
+	program.command("status").description("Show channel health and recent session recipients").option("--json", "Output JSON instead of text", false).option("--all", "Full diagnosis (read-only, pasteable)", false).option("--usage", "Show model provider usage/quota snapshots", false).option("--deep", "Probe channels (WhatsApp Web + Telegram + Discord + Slack + Signal)", false).option("--timeout <ms>", "Probe timeout in milliseconds", "10000").option("--verbose", "Verbose logging", false).option("--debug", "Alias for --verbose", false).addHelpText("after", () => `\n${theme.heading("Examples:")}\n${formatHelpExamples([
+		["daocore status", "Show channel health + session summary."],
+		["daocore status --all", "Full diagnosis (read-only)."],
+		["daocore status --json", "Machine-readable output."],
+		["daocore status --usage", "Show model provider usage/quota snapshots."],
+		["daocore status --deep", "Run channel probes (WA + Telegram + Discord + Slack + Signal)."],
+		["daocore status --deep --timeout 5000", "Tighten probe timeout."]
+	])}`).addHelpText("after", () => `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/status", "docs.openclaw.ai/cli/status")}\n`).action(async (opts) => {
+		await runWithVerboseAndTimeout(opts, async ({ verbose, timeoutMs }) => {
+			const { statusCommand } = await import("./status-_UeuGVi3.js");
+			await statusCommand({
+				json: Boolean(opts.json),
+				all: Boolean(opts.all),
+				deep: Boolean(opts.deep),
+				usage: Boolean(opts.usage),
+				timeoutMs,
+				verbose
+			}, defaultRuntime);
+		});
+	});
+	program.command("health").description("Fetch health from the running gateway").option("--json", "Output JSON instead of text", false).option("--timeout <ms>", "Connection timeout in milliseconds", "10000").option("--verbose", "Verbose logging", false).option("--debug", "Alias for --verbose", false).addHelpText("after", () => `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/health", "docs.openclaw.ai/cli/health")}\n`).action(async (opts) => {
+		await runWithVerboseAndTimeout(opts, async ({ verbose, timeoutMs }) => {
+			const { healthCommand } = await import("./health-DJs4PS7H.js");
+			await healthCommand({
+				json: Boolean(opts.json),
+				timeoutMs,
+				verbose
+			}, defaultRuntime);
+		});
+	});
+	const sessionsCmd = addSessionsListOptions(program.command("sessions").description("List stored conversation sessions")).addHelpText("after", () => `\n${theme.heading("Examples:")}\n${formatHelpExamples([
+		["daocore sessions", "List all sessions."],
+		["daocore sessions --agent work", "List sessions for one agent."],
+		["daocore sessions --all-agents", "Aggregate sessions across agents."],
+		["daocore sessions --active 120", "Only last 2 hours."],
+		["daocore sessions --limit 25", "Show the newest 25 sessions."],
+		["daocore sessions --json", "Machine-readable output."],
+		["daocore sessions --store ./tmp/sessions.json", "Use a specific session store."]
+	])}\n\n${theme.muted("Shows token usage per session when the agent reports it; set agents.defaults.contextTokens to cap the window and show %.")}`).addHelpText("after", () => `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/sessions", "docs.openclaw.ai/cli/sessions")}\n`).action(async (opts) => {
+		await runSessionsListCli(opts);
+	});
+	sessionsCmd.enablePositionalOptions();
+	addSessionsListOptions(sessionsCmd.command("list").description("List stored conversation sessions")).action(async (opts, command) => {
+		const parentOpts = command.parent?.opts();
+		await runSessionsListCli(mergeSessionsListOptions(opts, parentOpts));
+	});
+	sessionsCmd.command("cleanup").description("Run session-store maintenance now").option("--store <path>", "Path to session store (default: resolved from config)").option("--agent <id>", "Agent id to maintain (default: configured default agent)").option("--all-agents", "Run maintenance across all configured agents", false).option("--dry-run", "Preview maintenance actions without writing", false).option("--enforce", "Apply maintenance even when configured mode is warn", false).option("--fix-missing", "Remove store entries whose transcript files are missing (bypasses age/count retention)", false).option("--fix-dm-scope", "Retire stale direct-DM session rows that no longer match session.dmScope=main", false).option("--active-key <key>", "Protect this session key from budget-eviction").option("--json", "Output JSON", false).addHelpText("after", () => `\n${theme.heading("Examples:")}\n${formatHelpExamples([
+		["daocore sessions cleanup --dry-run", "Preview stale/cap cleanup."],
+		["daocore sessions cleanup --dry-run --fix-missing", "Also preview pruning entries with missing transcript files."],
+		["daocore sessions cleanup --dry-run --fix-dm-scope", "Preview stale direct-DM rows after returning dmScope to main."],
+		["daocore sessions cleanup --enforce", "Apply maintenance now."],
+		["daocore sessions cleanup --agent work --dry-run", "Preview one agent store."],
+		["daocore sessions cleanup --all-agents --dry-run", "Preview all agent stores."],
+		["daocore sessions cleanup --enforce --store ./tmp/sessions.json", "Use a specific store."]
+	])}`).action(async (opts, command) => {
+		const parentOpts = command.parent?.opts();
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const { sessionsCleanupCommand } = await import("./sessions-cleanup-CdyylTAK.js");
+			await sessionsCleanupCommand({
+				store: opts.store ?? parentOpts?.store,
+				agent: opts.agent ?? parentOpts?.agent,
+				allAgents: Boolean(opts.allAgents || parentOpts?.allAgents),
+				dryRun: Boolean(opts.dryRun),
+				enforce: Boolean(opts.enforce),
+				fixMissing: Boolean(opts.fixMissing),
+				fixDmScope: Boolean(opts.fixDmScope),
+				activeKey: opts.activeKey,
+				json: Boolean(opts.json || parentOpts?.json)
+			}, defaultRuntime);
+		});
+	});
+	sessionsCmd.command("export-trajectory").description("Export a redacted trajectory bundle for a stored session").option("--session-key <key>", "Session key to export").option("--output <path>", "Output directory name inside .daocore/trajectory-exports").option("--workspace <path>", "Workspace root for the export (default: current directory)").option("--store <path>", "Path to session store (default: resolved from session key)").option("--agent <id>", "Agent id for resolving the default session store").option("--request-json-base64 <payload>", "Base64url-encoded export request").option("--json", "Output JSON", false).action(async (opts, command) => {
+		const parentOpts = command.parent?.opts();
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const { exportTrajectoryCommand } = await import("./export-trajectory-DdHsmq6y.js");
+			await exportTrajectoryCommand({
+				sessionKey: opts.sessionKey,
+				output: opts.output,
+				workspace: opts.workspace,
+				store: opts.store ?? parentOpts?.store,
+				agent: opts.agent ?? parentOpts?.agent,
+				requestJsonBase64: opts.requestJsonBase64,
+				json: Boolean(opts.json || parentOpts?.json)
+			}, defaultRuntime);
+		});
+	});
+	const commitmentsCmd = program.command("commitments").description("List and manage inferred follow-up commitments").option("--json", "Output JSON instead of text", false).option("--agent <id>", "Agent id to inspect").option("--status <status>", "Filter by status (pending, sent, dismissed, snoozed, expired)").option("--all", "Show all statuses", false).addHelpText("after", () => `\n${theme.heading("Examples:")}\n${formatHelpExamples([
+		["daocore commitments", "List pending inferred follow-ups."],
+		["daocore commitments --all", "List all inferred follow-ups."],
+		["daocore commitments --agent work", "List one agent's inferred follow-ups."],
+		["daocore commitments dismiss cm_abc123", "Dismiss a follow-up."]
+	])}`).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const { commitmentsListCommand } = await import("./commitments-Bjh_ZjqN.js");
+			await commitmentsListCommand({
+				json: Boolean(opts.json),
+				agent: opts.agent,
+				status: opts.status,
+				all: Boolean(opts.all)
+			}, defaultRuntime);
+		});
+	});
+	commitmentsCmd.enablePositionalOptions();
+	commitmentsCmd.command("list").description("List inferred follow-up commitments").option("--json", "Output JSON instead of text", false).option("--agent <id>", "Agent id to inspect").option("--status <status>", "Filter by status (pending, sent, dismissed, snoozed, expired)").option("--all", "Show all statuses", false).action(async (opts, command) => {
+		const parentOpts = command.parent?.opts();
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const { commitmentsListCommand } = await import("./commitments-Bjh_ZjqN.js");
+			await commitmentsListCommand({
+				json: Boolean(opts.json || parentOpts?.json),
+				agent: opts.agent ?? parentOpts?.agent,
+				status: opts.status ?? parentOpts?.status,
+				all: Boolean(opts.all || parentOpts?.all)
+			}, defaultRuntime);
+		});
+	});
+	commitmentsCmd.command("dismiss <ids...>").description("Dismiss inferred follow-up commitments").option("--json", "Output JSON instead of text", false).action(async (ids, opts, command) => {
+		const parentOpts = command.parent?.opts();
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const { commitmentsDismissCommand } = await import("./commitments-Bjh_ZjqN.js");
+			await commitmentsDismissCommand({
+				ids,
+				json: Boolean(opts.json || parentOpts?.json)
+			}, defaultRuntime);
+		});
+	});
+	const tasksCmd = program.command("tasks").description("Inspect durable background tasks and TaskFlow state").option("--json", "Output as JSON", false).option("--runtime <name>", "Filter by kind (subagent, acp, cron, cli)").option("--status <name>", "Filter by status (queued, running, succeeded, failed, timed_out, cancelled, lost)").action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const { tasksListCommand } = await import("./tasks-Co_sDSdB.js");
+			await tasksListCommand({
+				json: Boolean(opts.json),
+				runtime: opts.runtime,
+				status: opts.status
+			}, defaultRuntime);
+		});
+	});
+	tasksCmd.enablePositionalOptions();
+	tasksCmd.command("list").description("List tracked background tasks").option("--json", "Output as JSON", false).option("--runtime <name>", "Filter by kind (subagent, acp, cron, cli)").option("--status <name>", "Filter by status (queued, running, succeeded, failed, timed_out, cancelled, lost)").action(async (opts, command) => {
+		const parentOpts = command.parent?.opts();
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const { tasksListCommand } = await import("./tasks-Co_sDSdB.js");
+			await tasksListCommand({
+				json: Boolean(opts.json || parentOpts?.json),
+				runtime: opts.runtime ?? parentOpts?.runtime,
+				status: opts.status ?? parentOpts?.status
+			}, defaultRuntime);
+		});
+	});
+	tasksCmd.command("audit").description("Show stale or broken background tasks and TaskFlows").option("--json", "Output as JSON", false).option("--severity <level>", "Filter by severity (warn, error)").option("--code <name>", "Filter by finding code (stale_queued, stale_running, lost, delivery_failed, missing_cleanup, inconsistent_timestamps, restore_failed, stale_waiting, stale_blocked, cancel_stuck, missing_linked_tasks, blocked_task_missing)").option("--limit <n>", "Limit displayed findings").action(async (opts, command) => {
+		const parentOpts = command.parent?.opts();
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const { tasksAuditCommand } = await import("./tasks-Co_sDSdB.js");
+			await tasksAuditCommand({
+				json: Boolean(opts.json || parentOpts?.json),
+				severity: opts.severity,
+				code: opts.code,
+				limit: parsePositiveIntOrUndefined(opts.limit)
+			}, defaultRuntime);
+		});
+	});
+	tasksCmd.command("maintenance").description("Preview or apply tasks and TaskFlow maintenance").option("--json", "Output as JSON", false).option("--apply", "Apply reconciliation, cleanup stamping, and pruning", false).action(async (opts, command) => {
+		const parentOpts = command.parent?.opts();
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const { tasksMaintenanceCommand } = await import("./tasks-Co_sDSdB.js");
+			await tasksMaintenanceCommand({
+				json: Boolean(opts.json || parentOpts?.json),
+				apply: Boolean(opts.apply)
+			}, defaultRuntime);
+		});
+	});
+	tasksCmd.command("show").description("Show one background task by task id, run id, or session key").argument("<lookup>", "Task id, run id, or session key").option("--json", "Output as JSON", false).action(async (lookup, opts, command) => {
+		const parentOpts = command.parent?.opts();
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const { tasksShowCommand } = await import("./tasks-Co_sDSdB.js");
+			await tasksShowCommand({
+				lookup,
+				json: Boolean(opts.json || parentOpts?.json)
+			}, defaultRuntime);
+		});
+	});
+	tasksCmd.command("notify").description("Set task notify policy").argument("<lookup>", "Task id, run id, or session key").argument("<notify>", "Notify policy (done_only, state_changes, silent)").action(async (lookup, notify) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const { tasksNotifyCommand } = await import("./tasks-Co_sDSdB.js");
+			await tasksNotifyCommand({
+				lookup,
+				notify
+			}, defaultRuntime);
+		});
+	});
+	tasksCmd.command("cancel").description("Cancel a running background task").argument("<lookup>", "Task id, run id, or session key").action(async (lookup) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const { tasksCancelCommand } = await import("./tasks-Co_sDSdB.js");
+			await tasksCancelCommand({ lookup }, defaultRuntime);
+		});
+	});
+	const tasksFlowCmd = tasksCmd.command("flow").description("Inspect durable TaskFlow state under tasks");
+	tasksFlowCmd.command("list").description("List tracked TaskFlows").option("--json", "Output as JSON", false).option("--status <name>", "Filter by status (queued, running, waiting, blocked, succeeded, failed, cancelled, lost)").action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const { flowsListCommand } = await import("./flows-DlZLmyNk.js");
+			await flowsListCommand({
+				json: Boolean(opts.json),
+				status: opts.status
+			}, defaultRuntime);
+		});
+	});
+	tasksFlowCmd.command("show").description("Show one TaskFlow by flow id or owner key").argument("<lookup>", "Flow id or owner key").option("--json", "Output as JSON", false).action(async (lookup, opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const { flowsShowCommand } = await import("./flows-DlZLmyNk.js");
+			await flowsShowCommand({
+				lookup,
+				json: Boolean(opts.json)
+			}, defaultRuntime);
+		});
+	});
+	tasksFlowCmd.command("cancel").description("Cancel a running TaskFlow").argument("<lookup>", "Flow id or owner key").action(async (lookup) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const { flowsCancelCommand } = await import("./flows-DlZLmyNk.js");
+			await flowsCancelCommand({ lookup }, defaultRuntime);
+		});
+	});
+}
+//#endregion
+export { registerStatusHealthSessionsCommands };

package/dist/register.subclis-BHzKPsu3.js

@@ -0,0 +1,31 @@
+import { h as getSubCliEntries } from "./argv-BEXMl80F.js";
+import { t as resolveCliArgvInvocation } from "./argv-invocation-BVIVPYjV.js";
+import { i as shouldRegisterPrimarySubcommandOnly, n as shouldEagerRegisterSubcommands } from "./command-registration-policy-DNB5-kPy.js";
+import { i as registerCommandGroups, r as registerCommandGroupByName } from "./register-command-groups-BJJkSUKS.js";
+import { i as buildCommandGroupEntries, n as registerSubCliByName$1, o as defineImportedProgramCommandGroupSpecs, r as registerSubCliCommands$1 } from "./register.subclis-core-DqSQ4XoR.js";
+//#region src/cli/program/register.subclis.ts
+const entrySpecs = [...defineImportedProgramCommandGroupSpecs([{
+	commandNames: ["completion"],
+	loadModule: () => import("./completion-cli-DoizagFW.js"),
+	exportName: "registerCompletionCli"
+}])];
+function resolveSubCliCommandGroups(argv, context = {}) {
+	return buildCommandGroupEntries(getSubCliEntries(), entrySpecs, (register) => async (program) => {
+		await register(program, argv, context);
+	});
+}
+async function registerSubCliByName(program, name, argv = process.argv, context = {}) {
+	if (await registerSubCliByName$1(program, name, argv, context)) return true;
+	return registerCommandGroupByName(program, resolveSubCliCommandGroups(argv, context), name);
+}
+function registerSubCliCommands(program, argv = process.argv) {
+	registerSubCliCommands$1(program, argv);
+	const { primary } = resolveCliArgvInvocation(argv);
+	registerCommandGroups(program, resolveSubCliCommandGroups(argv), {
+		eager: shouldEagerRegisterSubcommands(),
+		primary,
+		registerPrimaryOnly: Boolean(primary && shouldRegisterPrimarySubcommandOnly(argv))
+	});
+}
+//#endregion
+export { registerSubCliCommands as n, registerSubCliByName as t };