nextclaw 0.46.0 → 0.47.0

package/dist/cli/app/index.js

@@ -5,7 +5,7 @@ import { NextclawDistributionService } from "@nextclaw/service";
 const distribution = createNextclawDistribution(import.meta.url);
 repairPackagedPortableRunnerPermissions(distribution);
 NextclawDistributionService.configureRuntime(distribution);
-const { nextclawCliProgram } = await import("../../nextclaw-cli-app-BVdP2e0w.js");
+const { nextclawCliProgram } = await import("../../nextclaw-cli-app-wU9aUEKj.js");
 await nextclawCliProgram.parseAsync(process.argv);
 //#endregion
 export {};

package/dist/{nextclaw-cli-app-BVdP2e0w.js → nextclaw-cli-app-wU9aUEKj.js}

@@ -5416,6 +5416,36 @@ var AppPackageLiveService = class {
 		method: "POST",
 		body: input
 	});
+	inspectSecrets = async (appId) => await this.requireApiClient().request({ path: `/api/app-packages/${encodeURIComponent(this.requireId(appId))}/secrets` });
+	inspectAiCapabilities = async (appId) => await this.requireApiClient().request({ path: `/api/service-apps/${encodeURIComponent(this.requireId(appId))}/ai-capabilities` });
+	verifyAiCapabilities = async (appId) => await this.requireApiClient().request({
+		path: `/api/service-apps/${encodeURIComponent(this.requireId(appId))}/ai-capabilities/verify`,
+		method: "POST"
+	});
+	bindAiCapability = async (appId, input) => await this.requireApiClient().request({
+		path: `/api/service-apps/${encodeURIComponent(this.requireId(appId))}/ai-capabilities/bind`,
+		method: "POST",
+		body: input
+	});
+	unbindAiCapability = async (appId, input) => await this.requireApiClient().request({
+		path: `/api/service-apps/${encodeURIComponent(this.requireId(appId))}/ai-capabilities/unbind`,
+		method: "POST",
+		body: input
+	});
+	verifySecrets = async (appId) => await this.requireApiClient().request({
+		path: `/api/app-packages/${encodeURIComponent(this.requireId(appId))}/secrets/verify`,
+		method: "POST"
+	});
+	bindSecret = async (appId, input) => await this.requireApiClient().request({
+		path: `/api/app-packages/${encodeURIComponent(this.requireId(appId))}/secrets/bind`,
+		method: "POST",
+		body: input
+	});
+	unbindSecret = async (appId, slotId) => await this.requireApiClient().request({
+		path: `/api/app-packages/${encodeURIComponent(this.requireId(appId))}/secrets/unbind`,
+		method: "POST",
+		body: { slotId: this.requireValue(slotId, "Secret slot") }
+	});
 	install = async (source, registryUrl) => await this.requireApiClient().request({
 		path: "/api/app-package-operations/install",
 		method: "POST",
@@ -5426,6 +5456,37 @@ var AppPackageLiveService = class {
 	});
 	enable = async (appId) => await this.changeEnabled(appId, "enable");
 	disable = async (appId) => await this.changeEnabled(appId, "disable");
+	invoke = async (appId, actionName, input) => await this.requireApiClient().request({
+		path: `/api/service-apps/${encodeURIComponent(this.requireId(appId))}/actions/${encodeURIComponent(this.requireValue(actionName, "Action name"))}/invoke`,
+		method: "POST",
+		body: { input }
+	});
+	listJobs = async (appId) => await this.requireApiClient().request({ path: `/api/service-apps/${encodeURIComponent(this.requireId(appId))}/jobs` });
+	inspectJob = async (appId, jobId) => await this.requireApiClient().request({ path: `/api/service-apps/${encodeURIComponent(this.requireId(appId))}/jobs/${encodeURIComponent(this.requireValue(jobId, "Job id"))}` });
+	watchJob = async (appId, jobId, afterSequence) => {
+		const query = afterSequence === void 0 ? "" : `?afterSequence=${afterSequence}`;
+		return await this.requireApiClient().request({ path: `/api/service-apps/${encodeURIComponent(this.requireId(appId))}/jobs/${encodeURIComponent(this.requireValue(jobId, "Job id"))}/watch${query}` });
+	};
+	cancelJob = async (appId, jobId) => await this.requireApiClient().request({
+		path: `/api/service-apps/${encodeURIComponent(this.requireId(appId))}/jobs/${encodeURIComponent(this.requireValue(jobId, "Job id"))}/cancel`,
+		method: "POST"
+	});
+	listResidentInbox = async (appId, deadLettersOnly = false) => await this.requireApiClient().request({ path: `/api/service-apps/${encodeURIComponent(this.requireId(appId))}/resident-inbox${deadLettersOnly ? "?deadLetters=true" : ""}` });
+	replayResidentDeadLetter = async (appId, eventId) => await this.requireApiClient().request({
+		path: `/api/service-apps/${encodeURIComponent(this.requireId(appId))}/resident-inbox/${encodeURIComponent(this.requireValue(eventId, "Event id"))}/replay`,
+		method: "POST"
+	});
+	listVerificationRecords = async (filters = {}) => {
+		const query = new URLSearchParams();
+		if (filters.acceptanceId?.trim()) query.set("acceptanceId", filters.acceptanceId.trim());
+		if (filters.appId?.trim()) query.set("appId", filters.appId.trim());
+		if (filters.limit !== void 0) query.set("limit", String(filters.limit));
+		const suffix = query.size > 0 ? `?${query.toString()}` : "";
+		return await this.requireApiClient().request({ path: `/api/runtime-verification-records${suffix}` });
+	};
+	portableRuntimeAcceptanceContract = async (locale) => await this.requireApiClient().request({ path: `/api/portable-runtime/acceptance/contract${locale === "en" ? "?locale=en" : ""}` });
+	portableRuntimeAcceptanceStatus = async (params = {}) => await this.requireApiClient().request({ path: this.portableRuntimeAcceptancePath("status", params) });
+	exportPortableRuntimeAcceptance = async (params = {}) => await this.requireApiClient().request({ path: this.portableRuntimeAcceptancePath("export", params) });
 	update = async (appId, options) => await this.requireApiClient().request({
 		path: `/api/app-package-operations/${encodeURIComponent(this.requireId(appId))}/update`,
 		method: "POST",
@@ -5457,6 +5518,12 @@ var AppPackageLiveService = class {
 		return this.looksLikeLocalPath(source) ? path.resolve(source) : source;
 	};
 	looksLikeLocalPath = (value) => value.startsWith(".") || path.isAbsolute(value) || value.includes(path.sep) || value.endsWith(".napp");
+	portableRuntimeAcceptancePath = (action, params) => {
+		const query = new URLSearchParams();
+		if (params.appId?.trim()) query.set("appId", params.appId.trim());
+		if (params.locale === "en") query.set("locale", "en");
+		return `/api/portable-runtime/acceptance/${action}${query.size > 0 ? `?${query.toString()}` : ""}`;
+	};
 	requireVersion = (value) => this.requireValue(value, "App version");
 	requireValue = (value, name) => {
 		const normalized = value.trim();
@@ -5501,10 +5568,75 @@ var AppPackageCommandController = class {
 		requirementKind: options.requirementKind,
 		requirementId: options.requirementId
 	}), options, this.formatDependencyView);
+	inspectSecrets = async (appId, options) => this.write(await this.liveService.inspectSecrets(appId), options, this.formatSecretReadiness);
+	inspectAiCapabilities = async (appId, options) => this.write(await this.liveService.inspectAiCapabilities(appId), options, (value) => JSON.stringify(value, null, 2));
+	verifyAiCapabilities = async (appId, options) => this.write(await this.liveService.verifyAiCapabilities(appId), options, (value) => JSON.stringify(value, null, 2));
+	bindAiCapability = async (appId, options) => this.write(await this.liveService.bindAiCapability(appId, {
+		kind: options.kind,
+		slotId: options.slot,
+		targetId: options.target
+	}), options, (value) => JSON.stringify(value, null, 2));
+	unbindAiCapability = async (appId, options) => this.write(await this.liveService.unbindAiCapability(appId, {
+		kind: options.kind,
+		slotId: options.slot
+	}), options, (value) => JSON.stringify(value, null, 2));
+	verifySecrets = async (appId, options) => this.write(await this.liveService.verifySecrets(appId), options, this.formatSecretReadiness);
+	bindSecret = async (appId, options) => {
+		const { slot, source, provider, id } = options;
+		this.write(await this.liveService.bindSecret(appId, {
+			slotId: slot,
+			source,
+			provider,
+			id
+		}), options, this.formatSecretReadiness);
+	};
+	unbindSecret = async (appId, options) => this.write(await this.liveService.unbindSecret(appId, options.slot), options, this.formatSecretReadiness);
 	operations = async (options) => this.write(await this.liveService.listOperations(), options, this.formatOperations);
 	install = async (source, options) => this.write(await this.liveService.install(source, options.registry), options, this.formatOperation);
 	enable = async (appId, options) => this.write(await this.liveService.enable(appId), options, this.formatApp);
 	disable = async (appId, options) => this.write(await this.liveService.disable(appId), options, this.formatApp);
+	invoke = async (appId, actionName, options) => {
+		const input = this.readInput(options.input);
+		this.write(await this.liveService.invoke(appId, actionName, input), options, (result) => [
+			`Installed App action ${result.actionId}`,
+			`  call: ${result.invocation?.callId ?? "-"}`,
+			`  trace: ${result.invocation?.traceId ?? "-"}`,
+			`  data version: ${result.invocation?.dataVersion ?? "-"}`,
+			`  verification: ${result.invocation?.verificationRunId ?? "-"}`,
+			`  result: ${JSON.stringify(result.result)}`
+		].join("\n") + "\n");
+	};
+	verificationRecords = async (options) => {
+		const { acceptance, app, limit: rawLimit } = options;
+		const limit = rawLimit === void 0 ? void 0 : Number(rawLimit);
+		if (limit !== void 0 && (!Number.isInteger(limit) || limit < 1)) throw new Error("--limit must be a positive integer.");
+		this.write(await this.liveService.listVerificationRecords({
+			acceptanceId: acceptance,
+			appId: app,
+			limit
+		}), options, (result) => result.entries.length === 0 ? "Verification records: none\n" : `${result.entries.map((record) => `${record.acceptanceId} ${record.status} ${record.entrySurface} ${record.actionOrEvent} ${record.verificationRunId}`).join("\n")}\n`);
+	};
+	acceptanceContract = async (options) => this.write(await this.liveService.portableRuntimeAcceptanceContract(options.locale), options, this.formatAcceptanceContract);
+	acceptanceStatus = async (options) => this.write(await this.liveService.portableRuntimeAcceptanceStatus({
+		appId: options.app,
+		locale: options.locale
+	}), options, this.formatAcceptanceStatus);
+	acceptanceExport = async (options) => this.write(await this.liveService.exportPortableRuntimeAcceptance({
+		appId: options.app,
+		locale: options.locale
+	}), {
+		...options,
+		json: true
+	}, (value) => `${JSON.stringify(value, null, 2)}\n`);
+	listJobs = async (appId, options) => this.write(await this.liveService.listJobs(appId), options, this.formatJobList);
+	inspectJob = async (appId, jobId, options) => this.write(await this.liveService.inspectJob(appId, jobId), options, this.formatJob);
+	watchJob = async (appId, jobId, options) => {
+		const afterSequence = this.readAfterSequence(options.after);
+		this.write(await this.liveService.watchJob(appId, jobId, afterSequence), options, this.formatJobWatch);
+	};
+	cancelJob = async (appId, jobId, options) => this.write(await this.liveService.cancelJob(appId, jobId), options, this.formatJob);
+	listResidentInbox = async (appId, options) => this.write(await this.liveService.listResidentInbox(appId, options.deadLetters === true), options, this.formatResidentInbox);
+	replayResidentDeadLetter = async (appId, eventId, options) => this.write(await this.liveService.replayResidentDeadLetter(appId, eventId), options, this.formatResidentEvent);
 	update = async (appId, options) => this.write(await this.liveService.update(appId, {
 		version: options.version,
 		registryUrl: options.registry
@@ -5547,11 +5679,41 @@ var AppPackageCommandController = class {
 		if (result.entries.length === 0) return "App operations: none\n";
 		return `${result.entries.map((operation) => this.formatOperation(operation).trim()).join("\n\n")}\n`;
 	};
+	formatAcceptanceContract = (result) => [`Portable runtime acceptance contract ${result.contractFingerprint}`, ...result.definitions.map((definition) => `  ${definition.id} [${definition.category}] ${definition.presentation.title}`)].join("\n") + "\n";
+	formatAcceptanceStatus = (result) => [
+		`Portable runtime acceptance status for ${result.appId}`,
+		result.identity.available ? `  product: ${result.identity.context.productVersion}; runtime: ${result.identity.context.runtimeVersion} (${result.identity.runtimeVersionSource})` : `  identity unavailable: ${result.identity.reason}`,
+		`  contract: ${result.contract.contractFingerprint}`,
+		...result.entries.map((entry) => `  ${entry.id} ${entry.result.status} ${entry.presentation.title}${entry.result.latestRecord ? ` (${entry.result.latestRecord.finishedAt})` : ""}`)
+	].join("\n") + "\n";
+	formatJobList = (result) => result.entries.length === 0 ? "App jobs: none\n" : `${result.entries.map((job) => this.formatJob(job).trim()).join("\n\n")}\n`;
+	formatJob = (job) => [
+		`App job ${job.id}`,
+		`  status: ${job.status}`,
+		`  action: ${job.componentId}.${job.actionName}`,
+		`  call: ${job.callId}`,
+		`  trace: ${job.traceId}`,
+		job.error ? `  error: ${job.error.code ?? "JOB_FAILED"} ${job.error.message}` : ""
+	].filter(Boolean).join("\n") + "\n";
+	formatJobWatch = (result) => [
+		this.formatJob(result.job).trim(),
+		`  cursor: ${result.cursor}`,
+		...result.events.map((event) => `  [${event.sequence}] ${event.type}`)
+	].join("\n") + "\n";
+	formatResidentInbox = (result) => result.entries.length === 0 ? `Resident inbox: none${result.frozen ? " (frozen)" : ""}\n` : `${result.entries.map((event) => this.formatResidentEvent(event).trim()).join("\n\n")}\n`;
+	formatResidentEvent = (event) => [
+		`Resident event ${event.eventId}`,
+		`  status: ${event.status}`,
+		`  stream: ${event.streamKey} #${event.sequence}`,
+		`  attempt: ${event.attempt}`,
+		event.lastError ? `  error: ${event.lastError.code ?? "RESIDENT_RETRY"} ${event.lastError.message}` : ""
+	].filter(Boolean).join("\n") + "\n";
 	formatDependencyView = (result) => [
 		`Dependency readiness: ${result.readiness.status}`,
 		...result.readiness.requirements.map((requirement) => `  requirement: ${requirement.componentId}/${requirement.kind}/${requirement.id}`),
 		...result.bindings.map((binding) => `  binding: ${binding.componentId}/${binding.requirementKind}/${binding.requirementId} -> ${binding.providerId}`)
 	].join("\n") + "\n";
+	formatSecretReadiness = (result) => [`Secret readiness: ${result.readiness.status}`, ...result.slots.map((slot) => `  slot: ${slot.id} ${slot.status}${slot.binding ? ` (${slot.binding.source}/${slot.binding.provider ?? slot.binding.source}/${slot.binding.id})` : ""}${slot.errorCode ? ` [${slot.errorCode}]` : ""}`)].join("\n") + "\n";
 	formatOperation = (operation) => [
 		`App operation ${operation.id}`,
 		`  action: ${operation.action}`,
@@ -5562,8 +5724,68 @@ var AppPackageCommandController = class {
 	requirePurgeConfirmation = (appId, confirmation) => {
 		if (confirmation?.trim() !== appId.trim()) throw new Error("--purge-data requires --confirm <app-id> matching the exact App id.");
 	};
+	readInput = (raw) => {
+		if (!raw) return {};
+		try {
+			const parsed = JSON.parse(raw);
+			if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("--input must be a JSON object.");
+			return parsed;
+		} catch (error) {
+			throw new Error(error instanceof Error && error.message === "--input must be a JSON object." ? error.message : `--input is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	};
+	readAfterSequence = (raw) => {
+		if (raw === void 0) return void 0;
+		const value = Number(raw);
+		if (!Number.isInteger(value) || value < 0) throw new Error("--after must be a non-negative integer.");
+		return value;
+	};
 };
 //#endregion
+//#region src/cli/app/commands/register-portable-runtime-app-commands.ts
+function registerPortableRuntimeAppCommands(app, controller) {
+	app.command("verification").description("Read real runtime verification records from the running host").option("--acceptance <id>", "Filter by stable acceptance id").option("--app <id>", "Filter by App id").option("--limit <n>", "Maximum records to return").option("--json", "Output JSON", false).action(async (opts) => controller.verificationRecords(opts));
+	const acceptance = app.command("acceptance").description("Read the portable runtime acceptance contract and current evidence status");
+	acceptance.command("contract").description("Read the stable portable runtime acceptance contract").option("--locale <locale>", "Presentation locale: zh-CN or en", "zh-CN").option("--json", "Output JSON", false).action(async (opts) => controller.acceptanceContract({
+		...opts,
+		locale: readAcceptanceLocale(opts.locale)
+	}));
+	acceptance.command("status").description("Read current portable runtime acceptance evidence status").option("--app <id>", "Acceptance App id").option("--locale <locale>", "Presentation locale: zh-CN or en", "zh-CN").option("--json", "Output JSON", false).action(async (opts) => controller.acceptanceStatus({
+		...opts,
+		locale: readAcceptanceLocale(opts.locale)
+	}));
+	acceptance.command("export").description("Export the portable runtime acceptance contract, identity, and evidence status as JSON").option("--app <id>", "Acceptance App id").option("--locale <locale>", "Presentation locale: zh-CN or en", "zh-CN").option("--json", "Output JSON", false).action(async (opts) => controller.acceptanceExport({
+		...opts,
+		locale: readAcceptanceLocale(opts.locale)
+	}));
+	registerAiCommands(app, controller);
+	registerJobCommands(app, controller);
+	registerResidentCommands(app, controller);
+}
+function registerAiCommands(app, controller) {
+	const ai = app.command("ai-capabilities").description("Inspect and bind non-secret model and Agent slots for a Service App");
+	ai.command("inspect <app-id>").option("--json", "Output JSON", false).action(async (id, opts) => controller.inspectAiCapabilities(id, opts));
+	ai.command("verify <app-id>").option("--json", "Output JSON", false).action(async (id, opts) => controller.verifyAiCapabilities(id, opts));
+	ai.command("bind <app-id>").requiredOption("--kind <kind>", "Slot kind: model or agent").requiredOption("--slot <id>", "Declared slot id").requiredOption("--target <id>", "Configured model or Agent id").option("--json", "Output JSON", false).action(async (id, opts) => controller.bindAiCapability(id, opts));
+	ai.command("unbind <app-id>").requiredOption("--kind <kind>", "Slot kind: model or agent").requiredOption("--slot <id>", "Declared slot id").option("--json", "Output JSON", false).action(async (id, opts) => controller.unbindAiCapability(id, opts));
+}
+function registerJobCommands(app, controller) {
+	const jobs = app.command("jobs").description("Inspect, replay, and cancel durable App Jobs through the running host");
+	jobs.command("list <app-id>").description("List durable Jobs for one installed App instance").option("--json", "Output JSON", false).action(async (id, opts) => controller.listJobs(id, opts));
+	jobs.command("inspect <app-id> <job-id>").description("Inspect one durable App Job").option("--json", "Output JSON", false).action(async (id, jobId, opts) => controller.inspectJob(id, jobId, opts));
+	jobs.command("watch <app-id> <job-id>").description("Replay retained Job progress and stream output from a cursor").option("--after <sequence>", "Replay only events after this sequence").option("--json", "Output JSON", false).action(async (id, jobId, opts) => controller.watchJob(id, jobId, opts));
+	jobs.command("cancel <app-id> <job-id>").description("Request cancellation; the Job remains pending until the runner confirms it").option("--json", "Output JSON", false).action(async (id, jobId, opts) => controller.cancelJob(id, jobId, opts));
+}
+function registerResidentCommands(app, controller) {
+	const inbox = app.command("resident-inbox").description("Inspect and replay durable Resident events through the running host");
+	inbox.command("list <app-id>").description("List retained Resident event delivery state").option("--dead-letters", "Show only dead-letter events", false).option("--json", "Output JSON", false).action(async (id, opts) => controller.listResidentInbox(id, opts));
+	inbox.command("replay <app-id> <event-id>").description("Replay one dead-letter Resident event through the durable inbox").option("--json", "Output JSON", false).action(async (id, eventId, opts) => controller.replayResidentDeadLetter(id, eventId, opts));
+}
+function readAcceptanceLocale(value) {
+	if (value === "zh-CN" || value === "en") return value;
+	throw new Error("--locale must be zh-CN or en.");
+}
+//#endregion
 //#region src/cli/app/register-app-commands.ts
 function registerAppCommands(program, options = {}) {
 	const app = program.command("app").description("Develop, validate, and publish NextClaw apps");
@@ -5613,14 +5835,24 @@ function registerAppPackageCommands(app, appPackages) {
 	app.command("list").description("List Apps installed in the running NextClaw host").option("--json", "Output JSON", false).action(async (opts) => appPackages.list(opts));
 	app.command("info <app-id>").description("Show an App installed in the running NextClaw host").option("--json", "Output JSON", false).action(async (appId, opts) => appPackages.info(appId, opts));
 	registerAppDependencyCommands(app, appPackages);
+	registerAppSecretCommands(app, appPackages);
+	registerPortableRuntimeAppCommands(app, appPackages);
 	app.command("operations").description("List App install, update, rollback, and uninstall operations").option("--json", "Output JSON", false).action(async (opts) => appPackages.operations(opts));
 	app.command("install <source>").description("Install an App through the running NextClaw host").option("--registry <url>", "Registry URL for an App id").option("--json", "Output JSON", false).action(async (source, opts) => appPackages.install(source, opts));
 	app.command("enable <app-id>").description("Enable an installed App").option("--json", "Output JSON", false).action(async (appId, opts) => appPackages.enable(appId, opts));
 	app.command("disable <app-id>").description("Disable an installed App").option("--json", "Output JSON", false).action(async (appId, opts) => appPackages.disable(appId, opts));
+	app.command("invoke <app-id> <action-name>").description("Call an Action on an enabled installed App through the running host").option("--input <json>", "JSON object input for the action").option("--json", "Output JSON", false).action(async (appId, actionName, opts) => appPackages.invoke(appId, actionName, opts));
 	app.command("update <app-id>").description("Update an App through the running NextClaw host").option("--version <version>", "Target version").option("--registry <url>", "Registry URL").option("--json", "Output JSON", false).action(async (appId, opts) => appPackages.update(appId, opts));
 	app.command("rollback <app-id>").description("Roll back an App to an installed version").requiredOption("--version <version>", "Installed version to activate").option("--json", "Output JSON", false).action(async (appId, opts) => appPackages.rollback(appId, opts));
 	app.command("uninstall <app-id>").description("Uninstall an App through the running NextClaw host").option("--purge-data", "Permanently delete App data", false).option("--confirm <app-id>", "Confirm the exact App id when purging data").option("--json", "Output JSON", false).action(async (appId, opts) => appPackages.uninstall(appId, opts));
 }
+function registerAppSecretCommands(app, controller) {
+	const secrets = app.command("secrets").description("Inspect and manage non-sensitive SecretRef bindings for an App");
+	secrets.command("inspect <app-id>").description("Show declared Secret slots and non-sensitive bindings").option("--json", "Output JSON", false).action(async (appId, opts) => controller.inspectSecrets(appId, opts));
+	secrets.command("verify <app-id>").description("Resolve each declared Secret binding without returning its value").option("--json", "Output JSON", false).action(async (appId, opts) => controller.verifySecrets(appId, opts));
+	secrets.command("bind <app-id>").description("Bind one declared Secret slot to a configured Secret provider").requiredOption("--slot <id>", "Declared Secret slot id").requiredOption("--source <source>", "Secret source: env, file, or exec").option("--provider <id>", "Configured Secret provider id").requiredOption("--id <id>", "Secret id within the provider").option("--json", "Output JSON", false).action(async (appId, opts) => controller.bindSecret(appId, opts));
+	secrets.command("unbind <app-id>").description("Remove a SecretRef binding from an App").requiredOption("--slot <id>", "Declared Secret slot id").option("--json", "Output JSON", false).action(async (appId, opts) => controller.unbindSecret(appId, opts));
+}
 function registerAppDependencyCommands(app, controller) {
 	const dependencies = app.command("dependencies").description("Inspect and manage an App's capability and resource dependencies");
 	dependencies.command("inspect <app-id>").description("Inspect dependency readiness and available providers").option("--json", "Output JSON", false).action(async (appId, opts) => controller.inspectDependencies(appId, opts));
@@ -5909,4 +6141,4 @@ program.command("usage").description("Show observed LLM usage snapshots, history
 //#endregion
 export { program as nextclawCliProgram };
 
-//# sourceMappingURL=nextclaw-cli-app-BVdP2e0w.js.map
+//# sourceMappingURL=nextclaw-cli-app-wU9aUEKj.js.map