@agimon-ai/doompi-loop 0.0.1-alpha.81 → 0.0.1-alpha.82

package/dist/extensions/pi.mjs

@@ -1,10 +1,593 @@
-import root_cli_default from "../src/extensions/workspaces/sessions/(backend)/root.cli.mjs";
-import loop_cli_default from "../src/extensions/workspaces/sessions/(backend)/command/loop.cli.mjs";
-import loops_cli_default from "../src/extensions/workspaces/sessions/(backend)/command/loops.cli.mjs";
-import agent_settled_cli_default from "../src/extensions/workspaces/sessions/(backend)/hook/agent-settled.cli.mjs";
-import doompi_use_loop_cli_default from "../src/extensions/workspaces/sessions/(backend)/resource/doompi-use-loop.cli.mjs";
-import { definePiExtension } from "@agimon-ai/doompi-core/pi-extension";
-import { composeRootHooks } from "@agimon-ai/doompi-core/extension-file";
+import { t as DOOM_LOOP_LAUNCHERS_SERVICE } from "../loopLaunchers-cCniFbVA.mjs";
+import { a as LIST_COMMAND_NAME, i as LIST_COMMAND_DESCRIPTION, n as formatLoopStatusView, o as START_COMMAND_DESCRIPTION, r as createDoomLoopLaunchersService, s as START_COMMAND_NAME, t as LOOP_VIEW_STATUS_KEY } from "../loopView-CmuIEbUa.mjs";
+import { definePiExtension } from "@agimon-ai/doompi-core/piExtension";
+import { composeRootHooks, defineCliCommand, defineCliHook, defineResource, defineRoot } from "@agimon-ai/doompi-core/extensionFile";
+import { defineMinorMode, piMinorModes } from "@agimon-ai/doompi-minor-mode";
+import { DOOM_CORDIS_SESSION_SERVICE } from "@agimon-ai/doompi-core/cordisHost";
+import { DOOM_UI_HUB_SERVICE, requireDoomUiHub } from "@agimon-ai/doompi-core/uiHub";
+import { DOOM_FULLSCREEN_UI_OPTIONS, DOOM_NAVIGATION_KEYS, DOOM_OVERLAY_ACCENT, DoomOverlay } from "@agimon-ai/doompi-ui/doomOverlay";
+import { matchesKey, truncateToWidth } from "@earendil-works/pi-tui";
+//#region src/constants/piLoop.ts
+const PACKAGE_SOURCE = "@agimon-ai/doompi-loop";
+const STATUS_KEY = "doom-loop";
+const MODE_STATUS_ID = "loop.active";
+const ACTIVE_MODE_COLOR = "warning";
+const NOTIFY_INFO_LEVEL = "info";
+const NOTIFY_WARNING_LEVEL = "warning";
+//#endregion
+//#region src/services/loopCommand/index.ts
+function createLoopCommands(handlers) {
+	return [[START_COMMAND_NAME, {
+		description: START_COMMAND_DESCRIPTION,
+		handler: async (args, ctx) => handlers.start(ctx, args)
+	}], [LIST_COMMAND_NAME, {
+		description: LIST_COMMAND_DESCRIPTION,
+		handler: async (_args, ctx) => handlers.list(ctx)
+	}]];
+}
+//#endregion
+//#region src/services/defaultLoopLauncher/index.ts
+const DEFAULT_LAUNCHER_ID = "doompi.default";
+const DEFAULT_INTERVAL_SECONDS = 300;
+const MIN_INTERVAL_SECONDS = 30;
+const MAX_INTERVAL_SECONDS = 3600;
+const MILLISECONDS_PER_SECOND = 1e3;
+const PROMPT_PREVIEW_LENGTH = 80;
+function intervalError(raw) {
+	const seconds = Number(raw);
+	if (!Number.isInteger(seconds)) return `Interval must be a whole number of seconds, got ${raw}.`;
+	if (seconds < MIN_INTERVAL_SECONDS || seconds > MAX_INTERVAL_SECONDS) return `Interval must be between ${MIN_INTERVAL_SECONDS} and ${MAX_INTERVAL_SECONDS} seconds.`;
+}
+async function prepareDefaultLoop(ui, signal) {
+	const prompt = (await ui.editor("Loop prompt", ""))?.trim();
+	if (!prompt || signal.aborted) return void 0;
+	const rawInterval = await ui.input("Loop interval in seconds", `Default: ${DEFAULT_INTERVAL_SECONDS}s`);
+	if (rawInterval === void 0 || signal.aborted) return void 0;
+	const normalizedInterval = rawInterval.trim() || String(DEFAULT_INTERVAL_SECONDS);
+	const error = intervalError(normalizedInterval);
+	if (error) {
+		ui.notify(error, NOTIFY_WARNING_LEVEL);
+		return;
+	}
+	return {
+		prompt,
+		intervalSeconds: Number(normalizedInterval)
+	};
+}
+function promptPreview(prompt) {
+	const oneLine = prompt.replaceAll(/\s+/gu, " ").trim();
+	return oneLine.length > PROMPT_PREVIEW_LENGTH ? `${oneLine.slice(0, 79)}…` : oneLine;
+}
+function createDefaultLoopLauncher(pi) {
+	const pending = /* @__PURE__ */ new Set();
+	const requestPass = (loop) => {
+		if (loop.stopped) return;
+		if (!loop.context.isIdle()) {
+			pending.add(loop);
+			return;
+		}
+		pending.delete(loop);
+		try {
+			pi.sendUserMessage(loop.prompt);
+		} catch (error) {
+			loop.context.ui.notify(`Default loop pass could not start: ${error instanceof Error ? error.message : String(error)}`, NOTIFY_WARNING_LEVEL);
+		}
+	};
+	const onAgentSettled = () => {
+		const next = pending.values().next().value;
+		if (next) requestPass(next);
+	};
+	return {
+		onAgentSettled,
+		register(ctx, launchers) {
+			return launchers.register({
+				id: DEFAULT_LAUNCHER_ID,
+				source: PACKAGE_SOURCE,
+				label: "Default loop",
+				description: "Run your own prompt in this session on an interval",
+				async launch({ instanceId, signal }) {
+					const prepared = await prepareDefaultLoop(ctx.ui, signal);
+					if (!prepared || signal.aborted) return void 0;
+					const loop = {
+						...prepared,
+						context: ctx,
+						stopped: false
+					};
+					loop.timer = setInterval(() => requestPass(loop), loop.intervalSeconds * MILLISECONDS_PER_SECOND);
+					loop.timer.unref?.();
+					requestPass(loop);
+					return {
+						instanceId,
+						label: "Default loop",
+						detail: `every ${loop.intervalSeconds}s · ${promptPreview(loop.prompt)}`,
+						stop() {
+							if (loop.stopped) return;
+							loop.stopped = true;
+							if (loop.timer) clearInterval(loop.timer);
+							loop.timer = void 0;
+							pending.delete(loop);
+						}
+					};
+				}
+			});
+		}
+	};
+}
+//#endregion
+//#region src/tui/leader.ts
+const LOOPS_GROUP_SEGMENT = {
+	key: "l",
+	label: "loops",
+	detail: "recurring prompt loops",
+	order: 60
+};
+function registerLeaderContribution(hub) {
+	const contribution = hub.registerLeader({
+		source: PACKAGE_SOURCE,
+		bindings: [{
+			id: "loop.start",
+			path: [LOOPS_GROUP_SEGMENT, {
+				key: "s",
+				label: "start",
+				detail: "begin a recurring loop"
+			}],
+			command: { name: START_COMMAND_NAME }
+		}, {
+			id: "loop.list",
+			path: [LOOPS_GROUP_SEGMENT, {
+				key: "l",
+				label: "list",
+				detail: "loops in this session"
+			}],
+			command: { name: LIST_COMMAND_NAME }
+		}]
+	});
+	return () => contribution.dispose();
+}
+//#endregion
+//#region src/tui/loopListOverlay.ts
+const EMPTY_MESSAGE$1 = "No loop instances are active in this session.";
+const STOP_SCOPE_MESSAGE = "Stopping a loop does not cancel detached work already launched.";
+const STOP_REASON = "Stopped from the loop list.";
+var LoopListOverlay = class extends DoomOverlay {
+	client;
+	done;
+	unsubscribe;
+	instances;
+	selected = 0;
+	constructor(tui, theme, client, done) {
+		super(tui, theme);
+		this.client = client;
+		this.done = done;
+		this.instances = client.listInstances();
+		this.unsubscribe = client.subscribe(() => this.refresh());
+	}
+	dispose() {
+		this.unsubscribe();
+	}
+	handleInput(data) {
+		if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c") || data === "q") {
+			this.done(void 0);
+			return;
+		}
+		if (matchesKey(data, "up") || data === "k") {
+			this.move(-1);
+			return;
+		}
+		if (matchesKey(data, "down") || data === "j") {
+			this.move(1);
+			return;
+		}
+		if (data === "x") {
+			const instance = this.instances[this.selected];
+			if (instance) this.client.stop(instance.instanceId, STOP_REASON);
+		}
+	}
+	getChrome() {
+		return {
+			title: "LOOPS",
+			breadcrumb: "SPC › l / loops › l / list",
+			headerRight: `${this.instances.length} active`,
+			footer: `${DOOM_NAVIGATION_KEYS.list} move · x stop · esc close · launched detached work continues`,
+			footerHints: [
+				[DOOM_NAVIGATION_KEYS.list, "move"],
+				["x", "stop scheduling"],
+				["esc", "close"]
+			],
+			accent: DOOM_OVERLAY_ACCENT
+		};
+	}
+	renderBody(width) {
+		const stopScope = this.theme.fg("dim", truncateToWidth(STOP_SCOPE_MESSAGE, width));
+		if (!this.instances.length) return [
+			this.theme.fg("dim", EMPTY_MESSAGE$1),
+			"",
+			stopScope
+		];
+		return [
+			stopScope,
+			"",
+			...this.instances.flatMap((instance, index) => {
+				const marker = index === this.selected ? this.theme.fg("accent", "▸") : " ";
+				const name = instance.label ?? instance.launcherLabel;
+				const state = this.theme.fg(instance.state === "running" ? "success" : "warning", instance.state);
+				const line = truncateToWidth(`${marker} ${name} · ${state}`, width);
+				const detail = instance.detail ?? instance.instanceId;
+				return [line, `    ${this.theme.fg("dim", truncateToWidth(detail, Math.max(0, width - 4)))}`];
+			})
+		];
+	}
+	refresh() {
+		this.instances = this.client.listInstances();
+		this.selected = Math.min(this.selected, Math.max(0, this.instances.length - 1));
+		this.invalidate();
+	}
+	move(delta) {
+		if (!this.instances.length) return;
+		this.selected = Math.max(0, Math.min(this.selected + delta, this.instances.length - 1));
+		this.invalidate();
+	}
+};
+async function openLoopListOverlay(ctx, client) {
+	if (ctx.mode !== "tui") {
+		const instances = client.listInstances();
+		const labels = instances.map((instance) => `${instance.label ?? instance.launcherLabel} (${instance.instanceId})`);
+		const selected = await ctx.ui.select("Stop loop scheduling", labels);
+		const instance = instances[labels.indexOf(selected ?? "")];
+		if (instance) await client.stop(instance.instanceId, STOP_REASON);
+		return;
+	}
+	await ctx.ui.custom((tui, theme, _keybindings, done) => new LoopListOverlay(tui, theme, client, done), DOOM_FULLSCREEN_UI_OPTIONS);
+}
+//#endregion
+//#region src/tui/startLoopOverlay.ts
+const EMPTY_MESSAGE = "No loop launchers are registered for this session.";
+var StartLoopOverlay = class extends DoomOverlay {
+	launchers;
+	done;
+	selected = 0;
+	constructor(tui, theme, launchers, done) {
+		super(tui, theme);
+		this.launchers = launchers;
+		this.done = done;
+	}
+	handleInput(data) {
+		if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c") || data === "q") {
+			this.done(void 0);
+			return;
+		}
+		if (matchesKey(data, "up") || data === "k") {
+			this.move(-1);
+			return;
+		}
+		if (matchesKey(data, "down") || data === "j") {
+			this.move(1);
+			return;
+		}
+		if (matchesKey(data, "enter")) this.done(this.launchers[this.selected]?.id);
+	}
+	getChrome() {
+		return {
+			title: "START LOOP",
+			breadcrumb: "SPC › l / loops › s / start",
+			footer: `${DOOM_NAVIGATION_KEYS.list} move · enter launch · esc close`,
+			footerHints: [
+				[DOOM_NAVIGATION_KEYS.list, "move"],
+				["enter", "launch"],
+				["esc", "close"]
+			],
+			accent: DOOM_OVERLAY_ACCENT
+		};
+	}
+	renderBody(width) {
+		if (!this.launchers.length) return [this.theme.fg("dim", EMPTY_MESSAGE)];
+		return this.launchers.flatMap((launcher, index) => {
+			const selected = index === this.selected;
+			const marker = selected ? this.theme.fg("accent", "▸") : " ";
+			const label = selected ? this.theme.bold(launcher.label) : launcher.label;
+			const lines = [`${marker} ${truncateToWidth(label, Math.max(0, width - 2))}`];
+			if (launcher.description) lines.push(`    ${this.theme.fg("dim", truncateToWidth(launcher.description, Math.max(0, width - 4)))}`);
+			return lines;
+		});
+	}
+	move(delta) {
+		if (!this.launchers.length) return;
+		this.selected = Math.max(0, Math.min(this.selected + delta, this.launchers.length - 1));
+		this.invalidate();
+	}
+};
+async function openStartLoopOverlay(ctx, launchers) {
+	if (ctx.mode !== "tui") {
+		const labels = launchers.map((launcher) => launcher.label);
+		const selected = await ctx.ui.select("Start loop", labels);
+		return launchers[labels.indexOf(selected ?? "")]?.id;
+	}
+	return ctx.ui.custom((tui, theme, _keybindings, done) => new StartLoopOverlay(tui, theme, launchers, done), DOOM_FULLSCREEN_UI_OPTIONS);
+}
+//#endregion
+//#region src/tui/loopRuntime.ts
+const MODE_ACTION_START = "start";
+const MODE_ACTION_STOP = "stop";
+const SESSION_REPLACED_REASON = "Pi session replaced.";
+const SESSION_SHUTDOWN_REASON = "Pi session shut down.";
+function loopModeState(launchers, instances) {
+	const active = instances.length > 0;
+	return {
+		activation: active ? "active" : "inactive",
+		condition: instances.some(({ state }) => state === "starting" || state === "stopping") ? "queued" : "ready",
+		...active ? {
+			detail: `${instances.length} active`,
+			color: ACTIVE_MODE_COLOR
+		} : {},
+		actions: [...launchers.length > 0 ? [{
+			id: MODE_ACTION_START,
+			enabled: true
+		}] : [{
+			id: MODE_ACTION_START,
+			enabled: false,
+			disabledReason: "No loop launchers are registered."
+		}], ...active ? [{
+			id: MODE_ACTION_STOP,
+			enabled: true
+		}] : [{
+			id: MODE_ACTION_STOP,
+			enabled: false,
+			disabledReason: "No loops are active."
+		}]]
+	};
+}
+/** Install Loop state and external resources into its host-owned Cordis plugin fiber. */
+function createLoopPiRuntime(pi) {
+	let active = true;
+	let activeSession;
+	let mode;
+	let disposeLeader;
+	const launchesInProgress = /* @__PURE__ */ new WeakSet();
+	const currentSession = (context) => {
+		const binding = activeSession;
+		if (!active || !binding || binding.context.sessionManager !== context.sessionManager || binding.hostSession.sessionId !== context.sessionManager.getSessionId()) return;
+		return binding;
+	};
+	const clearStatuses = (binding) => {
+		binding.context.ui?.setStatus(STATUS_KEY, void 0);
+		if (binding.context.mode !== "tui") binding.context.ui?.setStatus(LOOP_VIEW_STATUS_KEY, void 0);
+	};
+	const publishStatus = (binding) => {
+		if (!active || activeSession !== binding) return;
+		const instances = binding.launchers.listInstances();
+		binding.context.ui?.setStatus(STATUS_KEY, instances.length ? `loops: ${instances.length}` : void 0);
+		if (binding.context.mode !== "tui") binding.context.ui?.setStatus(LOOP_VIEW_STATUS_KEY, formatLoopStatusView(instances));
+		mode?.publish();
+	};
+	const defaultLauncher = createDefaultLoopLauncher(pi);
+	mode = defineMinorMode({
+		descriptor: {
+			source: PACKAGE_SOURCE,
+			id: MODE_STATUS_ID,
+			label: "Loop",
+			description: "Session-scoped recurring prompt loops.",
+			order: 60,
+			actions: [{
+				id: MODE_ACTION_START,
+				label: "Start",
+				description: "Start a loop with a registered launcher.",
+				contexts: ["tui", "headless"],
+				parameters: [{
+					name: "launcherId",
+					label: "Launcher",
+					kind: "string",
+					required: true,
+					minLength: 1
+				}, {
+					name: "instanceId",
+					label: "Instance ID",
+					kind: "string",
+					required: false,
+					minLength: 1
+				}]
+			}, {
+				id: MODE_ACTION_STOP,
+				label: "Stop",
+				description: "Stop one active loop instance.",
+				contexts: ["tui", "headless"],
+				parameters: [{
+					name: "instanceId",
+					label: "Instance ID",
+					kind: "string",
+					required: true,
+					minLength: 1
+				}, {
+					name: "reason",
+					label: "Reason",
+					kind: "string",
+					required: false,
+					minLength: 1
+				}]
+			}]
+		},
+		state: () => activeSession ? loopModeState(activeSession.launchers.listLaunchers(), activeSession.launchers.listInstances()) : loopModeState([], []),
+		async handleAction(_runtime, actionId, argumentsValue, { signal }) {
+			signal.throwIfAborted();
+			const binding = activeSession ? currentSession(activeSession.context) : void 0;
+			if (!binding) throw new Error("Loop launchers are unavailable for the active session.");
+			if (actionId === MODE_ACTION_START) {
+				const instance = await binding.launchers.launch(argumentsValue.launcherId, argumentsValue.instanceId ? { instanceId: argumentsValue.instanceId } : {});
+				if (activeSession !== binding) throw new Error("Loop action became stale.");
+				return { message: instance ? `Loop '${instance.instanceId}' started.` : "Loop launch was cancelled." };
+			}
+			if (actionId === MODE_ACTION_STOP) {
+				const stopped = await binding.launchers.stop(argumentsValue.instanceId, argumentsValue.reason ?? "Stopped through minor_mode.");
+				if (activeSession !== binding) throw new Error("Loop action became stale.");
+				return { message: stopped ? "Loop stopped." : "Loop instance was not active." };
+			}
+			throw new Error(`Unknown loop mode action: ${actionId}`);
+		}
+	}).createOwner(void 0);
+	return {
+		onAgentSettled: defaultLauncher.onAgentSettled,
+		services: [(cordis) => {
+			cordis.inject([DOOM_UI_HUB_SERVICE], (uiContext) => {
+				const dispose = registerLeaderContribution(requireDoomUiHub(uiContext));
+				disposeLeader = dispose;
+				return () => {
+					dispose();
+					if (disposeLeader === dispose) disposeLeader = void 0;
+				};
+			});
+			cordis.inject([DOOM_CORDIS_SESSION_SERVICE], async (sessionContext) => {
+				const hostSession = sessionContext.get(DOOM_CORDIS_SESSION_SERVICE);
+				const launchers = createDoomLoopLaunchersService({
+					generation: `${hostSession.generation}:loop-launchers`,
+					createInstanceId: () => crypto.randomUUID(),
+					timestamp: () => (/* @__PURE__ */ new Date()).toISOString()
+				});
+				const binding = {
+					context: hostSession.context,
+					hostSession,
+					launchers
+				};
+				activeSession = binding;
+				const provider = cordis.plugin((providerContext) => {
+					providerContext.provide(DOOM_LOOP_LAUNCHERS_SERVICE, launchers);
+				});
+				let defaultRegistration;
+				let unsubscribe;
+				try {
+					defaultRegistration = defaultLauncher.register(hostSession.context, launchers);
+					unsubscribe = launchers.subscribe(() => publishStatus(binding));
+					publishStatus(binding);
+				} catch (error) {
+					if (activeSession === binding) activeSession = void 0;
+					await launchers.dispose(SESSION_REPLACED_REASON);
+					await provider.dispose();
+					throw error;
+				}
+				return async () => {
+					if (activeSession === binding) activeSession = void 0;
+					unsubscribe();
+					clearStatuses(binding);
+					mode?.publish();
+					const cleanupErrors = [];
+					try {
+						await defaultRegistration.dispose(SESSION_REPLACED_REASON);
+					} catch (error) {
+						cleanupErrors.push(error);
+					}
+					try {
+						await launchers.dispose(SESSION_SHUTDOWN_REASON);
+					} catch (error) {
+						cleanupErrors.push(error);
+					}
+					try {
+						await provider.dispose();
+					} catch (error) {
+						cleanupErrors.push(error);
+					}
+					if (cleanupErrors.length > 0) throw new AggregateError(cleanupErrors, "Loop session cleanup failed.");
+				};
+			});
+		}],
+		handlers: {
+			async start(ctx, args) {
+				const binding = currentSession(ctx);
+				if (!binding) return;
+				if (launchesInProgress.has(binding)) {
+					ctx.ui.notify("A loop setup is already in progress.", NOTIFY_INFO_LEVEL);
+					return;
+				}
+				launchesInProgress.add(binding);
+				try {
+					const launchers = binding.launchers.listLaunchers();
+					if (!launchers.length) {
+						ctx.ui.notify("No loop launchers are registered for this session.", NOTIFY_INFO_LEVEL);
+						return;
+					}
+					const argument = args.trim();
+					let launcherId;
+					if (argument) {
+						if (argument.split(/\s+/u).length !== 1) {
+							ctx.ui.notify("Usage: /loop [launcherId]", "error");
+							return;
+						}
+						if (!launchers.some((launcher) => launcher.id === argument)) {
+							ctx.ui.notify(`Unknown loop launcher: ${argument}`, "error");
+							return;
+						}
+						launcherId = argument;
+					} else {
+						launcherId = await openStartLoopOverlay(ctx, launchers);
+						if (activeSession !== binding || !launcherId) return;
+					}
+					const instance = await binding.launchers.launch(launcherId);
+					if (activeSession !== binding) return;
+					if (instance) ctx.ui.notify(`${instance.label ?? instance.launcherLabel} started.`, NOTIFY_INFO_LEVEL);
+				} catch (error) {
+					if (activeSession !== binding) return;
+					ctx.ui.notify(`Loop could not start: ${error instanceof Error ? error.message : String(error)}`, "error");
+				} finally {
+					launchesInProgress.delete(binding);
+				}
+			},
+			async list(ctx) {
+				const binding = currentSession(ctx);
+				if (!binding) return;
+				await openLoopListOverlay(ctx, binding.launchers);
+			}
+		},
+		minorModes: [mode],
+		onDispose() {
+			active = false;
+			const binding = activeSession;
+			activeSession = void 0;
+			if (binding) clearStatuses(binding);
+			mode?.publish();
+			disposeLeader?.();
+			disposeLeader = void 0;
+		}
+	};
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/_lib/runtime.cli.ts
+var runtime_cli_default = (({ pi }) => {
+	const runtime = createLoopPiRuntime(pi);
+	return {
+		services: [...runtime.services ?? [], piMinorModes(runtime.minorModes)],
+		events: { agent_settled: runtime.onAgentSettled },
+		commands: createLoopCommands(runtime.handlers),
+		onDispose: () => runtime.onDispose(),
+		resources: [{
+			source: PACKAGE_SOURCE,
+			moduleUrl: import.meta.url,
+			skills: [{
+				name: "doompi-use-loop",
+				description: "Use Doom Pi Loop to start, inspect, and stop session-scoped recurring prompts safely."
+			}]
+		}]
+	};
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/root.cli.ts
+var root_cli_default = defineRoot((context) => {
+	const value = runtime_cli_default(context);
+	return {
+		value,
+		services: value.services,
+		onDispose: value.onDispose
+	};
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/command/loop.cli.ts
+var loop_cli_default = defineCliCommand((context) => context.root.commands[0]);
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/command/loops.cli.ts
+var loops_cli_default = defineCliCommand((context) => context.root.commands[1]);
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/hook/agent-settled.cli.ts
+var agent_settled_cli_default = defineCliHook((context) => context.root.events["agent_settled"]);
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/resource/doompi-use-loop.cli.ts
+var doompi_use_loop_cli_default = defineResource((context) => context.root.resources[0]);
+//#endregion
 //#region generated/pi.ts
 const at = (value, context) => typeof value === "function" ? value(context) : value;
 const extension = definePiExtension("@agimon-ai/doompi-loop", async (context) => {