@agimon-ai/doompi-loop 0.0.1-alpha.9 → 0.0.1-alpha.91

package/dist/extensions/pi.cjs

@@ -1,2 +1,660 @@
-var e=require("../extension.cjs").registerLoopExtension;module.exports=e;
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+const require_loopLaunchers = require("../loopLaunchers-BtcLH_xN.cjs");
+const require_loopView = require("../loopView-C_OPuy8L.cjs");
+let _agimon_ai_doompi_core_piExtension = require("@agimon-ai/doompi-core/piExtension");
+let _agimon_ai_doompi_core_extensionFile = require("@agimon-ai/doompi-core/extensionFile");
+let _agimon_ai_doompi_minor_mode = require("@agimon-ai/doompi-minor-mode");
+let _agimon_ai_doompi_core_cordisHost = require("@agimon-ai/doompi-core/cordisHost");
+let _agimon_ai_doompi_core_uiHub = require("@agimon-ai/doompi-core/uiHub");
+let croner = require("croner");
+let _agimon_ai_doompi_ui_doomOverlay = require("@agimon-ai/doompi-ui/doomOverlay");
+let _earendil_works_pi_tui = require("@earendil-works/pi-tui");
+//#region src/services/loopCommand/index.ts
+function createLoopCommands(handlers) {
+	return [[require_loopView.START_COMMAND_NAME, {
+		description: require_loopView.START_COMMAND_DESCRIPTION,
+		handler: async (args, ctx) => handlers.start(ctx, args)
+	}], [require_loopView.LIST_COMMAND_NAME, {
+		description: require_loopView.LIST_COMMAND_DESCRIPTION,
+		handler: async (args, ctx) => handlers.list(ctx, args)
+	}]];
+}
+//#endregion
+//#region src/services/defaultLoopLauncher/index.ts
+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;
+async function prepareLoop(ui, request, cron) {
+	if (request.input !== void 0) return cron ? require_loopView.parseCronLoop(request.input) : require_loopView.parseIntervalLoop(request.input);
+	if (request.interactive === false) throw new Error("Loop configuration is required for agent launches.");
+	const prompt = (await ui.editor("Loop prompt", ""))?.trim();
+	if (!prompt || request.signal.aborted) return void 0;
+	if (cron) {
+		const expression = await ui.input("Cron expression (five fields)", "0 * * * *");
+		if (expression === void 0 || request.signal.aborted) return void 0;
+		const timezone = await ui.input("Loop timezone", "UTC");
+		if (timezone === void 0 || request.signal.aborted) return void 0;
+		return require_loopView.parseCronLoop({
+			prompt,
+			cron: expression,
+			timezone: timezone.trim() || "UTC"
+		});
+	}
+	const raw = await ui.input("Loop interval in seconds", `Default: ${DEFAULT_INTERVAL_SECONDS}s`);
+	if (raw === void 0 || request.signal.aborted) return void 0;
+	const intervalSeconds = Number(raw.trim() || DEFAULT_INTERVAL_SECONDS);
+	if (!Number.isInteger(intervalSeconds) || intervalSeconds < MIN_INTERVAL_SECONDS || intervalSeconds > MAX_INTERVAL_SECONDS) {
+		ui.notify(`Interval must be between ${MIN_INTERVAL_SECONDS} and ${MAX_INTERVAL_SECONDS} seconds.`, require_loopView.NOTIFY_WARNING_LEVEL);
+		return;
+	}
+	return require_loopView.parseIntervalLoop({
+		prompt,
+		intervalSeconds
+	});
+}
+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)}`, require_loopView.NOTIFY_WARNING_LEVEL);
+		}
+	};
+	const register = (ctx, launchers, cron) => launchers.register({
+		id: cron ? "doompi.cron" : "doompi.default",
+		source: require_loopView.PACKAGE_SOURCE,
+		label: cron ? "Cron loop" : "Default loop",
+		description: cron ? "Run a prompt on a five-field cron schedule." : "Run your own prompt in this session on an interval",
+		inputSchema: { ...cron ? require_loopView.CronLoopSchema : require_loopView.IntervalLoopSchema },
+		async launch(request) {
+			const prepared = await prepareLoop(ctx.ui, request, cron);
+			if (!prepared || request.signal.aborted) return void 0;
+			const loop = {
+				prompt: prepared.prompt,
+				context: ctx,
+				stopped: false
+			};
+			let stopTimer;
+			let schedule;
+			if ("cron" in prepared) {
+				const job = new croner.Cron(prepared.cron, {
+					timezone: prepared.timezone,
+					unref: true
+				}, () => requestPass(loop));
+				if (job.nextRun() === null) {
+					job.stop();
+					throw new Error("Cron expression has no future run.");
+				}
+				stopTimer = () => {
+					job.stop();
+				};
+				schedule = `${prepared.cron} (${prepared.timezone})`;
+			} else {
+				const timer = setInterval(() => requestPass(loop), prepared.intervalSeconds * MILLISECONDS_PER_SECOND);
+				timer.unref?.();
+				stopTimer = () => clearInterval(timer);
+				schedule = `every ${prepared.intervalSeconds}s`;
+				requestPass(loop);
+			}
+			return {
+				instanceId: request.instanceId,
+				label: cron ? "Cron loop" : "Default loop",
+				detail: `${schedule} · ${promptPreview(loop.prompt)}`,
+				stop() {
+					if (loop.stopped) return;
+					loop.stopped = true;
+					stopTimer();
+					pending.delete(loop);
+				}
+			};
+		}
+	});
+	return {
+		onAgentSettled() {
+			const next = pending.values().next().value;
+			if (next) requestPass(next);
+		},
+		register: (ctx, launchers) => register(ctx, launchers, false),
+		registerCron: (ctx, launchers) => register(ctx, launchers, true)
+	};
+}
+//#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: require_loopView.PACKAGE_SOURCE,
+		bindings: [{
+			id: "loop.start",
+			path: [LOOPS_GROUP_SEGMENT, {
+				key: "s",
+				label: "start",
+				detail: "begin a recurring loop"
+			}],
+			command: { name: require_loopView.START_COMMAND_NAME }
+		}, {
+			id: "loop.list",
+			path: [LOOPS_GROUP_SEGMENT, {
+				key: "l",
+				label: "list",
+				detail: "loops in this session"
+			}],
+			command: { name: require_loopView.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 _agimon_ai_doompi_ui_doomOverlay.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 ((0, _earendil_works_pi_tui.matchesKey)(data, "escape") || (0, _earendil_works_pi_tui.matchesKey)(data, "ctrl+c") || data === "q") {
+			this.done(void 0);
+			return;
+		}
+		if ((0, _earendil_works_pi_tui.matchesKey)(data, "up") || data === "k") {
+			this.move(-1);
+			return;
+		}
+		if ((0, _earendil_works_pi_tui.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: `${_agimon_ai_doompi_ui_doomOverlay.DOOM_NAVIGATION_KEYS.list} move · x stop · esc close · launched detached work continues`,
+			footerHints: [
+				[_agimon_ai_doompi_ui_doomOverlay.DOOM_NAVIGATION_KEYS.list, "move"],
+				["x", "stop scheduling"],
+				["esc", "close"]
+			],
+			accent: _agimon_ai_doompi_ui_doomOverlay.DOOM_OVERLAY_ACCENT
+		};
+	}
+	renderBody(width) {
+		const stopScope = this.theme.fg("dim", (0, _earendil_works_pi_tui.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 = (0, _earendil_works_pi_tui.truncateToWidth)(`${marker} ${name} · ${state}`, width);
+				const detail = instance.detail ?? instance.instanceId;
+				return [line, `    ${this.theme.fg("dim", (0, _earendil_works_pi_tui.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), _agimon_ai_doompi_ui_doomOverlay.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 _agimon_ai_doompi_ui_doomOverlay.DoomOverlay {
+	launchers;
+	done;
+	selected = 0;
+	constructor(tui, theme, launchers, done) {
+		super(tui, theme);
+		this.launchers = launchers;
+		this.done = done;
+	}
+	handleInput(data) {
+		if ((0, _earendil_works_pi_tui.matchesKey)(data, "escape") || (0, _earendil_works_pi_tui.matchesKey)(data, "ctrl+c") || data === "q") {
+			this.done(void 0);
+			return;
+		}
+		if ((0, _earendil_works_pi_tui.matchesKey)(data, "up") || data === "k") {
+			this.move(-1);
+			return;
+		}
+		if ((0, _earendil_works_pi_tui.matchesKey)(data, "down") || data === "j") {
+			this.move(1);
+			return;
+		}
+		if ((0, _earendil_works_pi_tui.matchesKey)(data, "enter")) this.done(this.launchers[this.selected]?.id);
+	}
+	getChrome() {
+		return {
+			title: "START LOOP",
+			breadcrumb: "SPC › l / loops › s / start",
+			footer: `${_agimon_ai_doompi_ui_doomOverlay.DOOM_NAVIGATION_KEYS.list} move · enter launch · esc close`,
+			footerHints: [
+				[_agimon_ai_doompi_ui_doomOverlay.DOOM_NAVIGATION_KEYS.list, "move"],
+				["enter", "launch"],
+				["esc", "close"]
+			],
+			accent: _agimon_ai_doompi_ui_doomOverlay.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} ${(0, _earendil_works_pi_tui.truncateToWidth)(label, Math.max(0, width - 2))}`];
+			if (launcher.description) lines.push(`    ${this.theme.fg("dim", (0, _earendil_works_pi_tui.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), _agimon_ai_doompi_ui_doomOverlay.DOOM_FULLSCREEN_UI_OPTIONS);
+}
+//#endregion
+//#region src/tui/loopRuntime.ts
+const MODE_ACTION_ACTIVATE = "activate";
+const MODE_ACTION_DEACTIVATE = "deactivate";
+const SESSION_REPLACED_REASON = "Pi session replaced.";
+const SESSION_SHUTDOWN_REASON = "Pi session shut down.";
+function loopModeState(enabled, instances) {
+	return {
+		activation: enabled ? "active" : "inactive",
+		condition: "ready",
+		...enabled ? {
+			detail: `${instances.length} loops`,
+			color: require_loopView.ACTIVE_MODE_COLOR
+		} : {},
+		actions: [{
+			id: MODE_ACTION_ACTIVATE,
+			enabled: !enabled,
+			...enabled ? { disabledReason: "Loop mode is already active." } : {}
+		}, {
+			id: MODE_ACTION_DEACTIVATE,
+			enabled,
+			...enabled ? {} : { disabledReason: "Loop mode is not 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();
+	let modeEnabled = false;
+	const toolListeners = /* @__PURE__ */ new Set();
+	const loopTools = require_loopView.createLoopTools(() => {
+		if (!activeSession) throw new Error("Loop launchers are unavailable for the active session.");
+		return activeSession.launchers;
+	}, () => {
+		if (!active || !modeEnabled) throw new Error("Enable Loop minor mode before using agent loop tools.");
+	});
+	const toolNames = new Set(loopTools.map((tool) => tool.name));
+	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(require_loopView.STATUS_KEY, void 0);
+		if (binding.context.mode !== "tui") binding.context.ui?.setStatus(require_loopView.LOOP_VIEW_STATUS_KEY, void 0);
+	};
+	const publishStatus = (binding) => {
+		if (!active || activeSession !== binding) return;
+		const instances = binding.launchers.listInstances();
+		binding.context.ui?.setStatus(require_loopView.STATUS_KEY, instances.length ? `loops: ${instances.length}` : void 0);
+		if (binding.context.mode !== "tui") binding.context.ui?.setStatus(require_loopView.LOOP_VIEW_STATUS_KEY, require_loopView.formatLoopStatusView(instances));
+		mode?.publish();
+	};
+	const defaultLauncher = createDefaultLoopLauncher(pi);
+	mode = (0, _agimon_ai_doompi_minor_mode.defineMinorMode)({
+		descriptor: {
+			source: require_loopView.PACKAGE_SOURCE,
+			id: require_loopView.MODE_STATUS_ID,
+			label: "Loop",
+			description: "Give the agent tools to create, inspect, and stop session loops.",
+			order: 60,
+			actions: [{
+				id: MODE_ACTION_ACTIVATE,
+				label: "Activate",
+				description: "Expose loop tools to the agent.",
+				contexts: ["tui", "headless"],
+				parameters: []
+			}, {
+				id: MODE_ACTION_DEACTIVATE,
+				label: "Deactivate",
+				description: "Hide agent loop tools. Existing loops and manual controls remain available.",
+				contexts: ["tui", "headless"],
+				parameters: []
+			}]
+		},
+		state: () => loopModeState(modeEnabled, activeSession?.launchers.listInstances() ?? []),
+		async handleAction(_runtime, actionId, _arguments, { 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_ACTIVATE && actionId !== MODE_ACTION_DEACTIVATE) throw new Error(`Unknown loop mode action: ${actionId}`);
+			modeEnabled = actionId === MODE_ACTION_ACTIVATE;
+			for (const listener of toolListeners) listener();
+			publishStatus(binding);
+			return { message: modeEnabled ? "Loop tools activated." : "Loop tools deactivated. Existing loops are unchanged." };
+		}
+	}).createOwner(void 0);
+	return {
+		onAgentSettled: defaultLauncher.onAgentSettled,
+		loopTools,
+		toolRestrictions: [{
+			source: require_loopView.PACKAGE_SOURCE,
+			restrict: (incoming) => modeEnabled ? incoming : incoming.filter((name) => !toolNames.has(name)),
+			subscribe(listener) {
+				toolListeners.add(listener);
+				return () => {
+					toolListeners.delete(listener);
+				};
+			}
+		}],
+		services: [(cordis) => {
+			cordis.inject([_agimon_ai_doompi_core_uiHub.DOOM_UI_HUB_SERVICE], (uiContext) => {
+				const dispose = registerLeaderContribution((0, _agimon_ai_doompi_core_uiHub.requireDoomUiHub)(uiContext));
+				disposeLeader = dispose;
+				return () => {
+					dispose();
+					if (disposeLeader === dispose) disposeLeader = void 0;
+				};
+			});
+			cordis.inject([_agimon_ai_doompi_core_cordisHost.DOOM_CORDIS_SESSION_SERVICE], async (sessionContext) => {
+				const hostSession = sessionContext.get(_agimon_ai_doompi_core_cordisHost.DOOM_CORDIS_SESSION_SERVICE);
+				const launchers = require_loopView.createDoomLoopLaunchersService({
+					generation: `${hostSession.generation}:loop-launchers`,
+					createInstanceId: () => crypto.randomUUID(),
+					timestamp: () => (/* @__PURE__ */ new Date()).toISOString()
+				});
+				const binding = {
+					context: hostSession.context,
+					hostSession,
+					launchers
+				};
+				activeSession = binding;
+				modeEnabled = false;
+				for (const listener of toolListeners) listener();
+				const provider = cordis.plugin((providerContext) => {
+					providerContext.provide(require_loopLaunchers.DOOM_LOOP_LAUNCHERS_SERVICE, launchers);
+				});
+				let defaultRegistration;
+				let cronRegistration;
+				let unsubscribe;
+				try {
+					defaultRegistration = defaultLauncher.register(hostSession.context, launchers);
+					cronRegistration = defaultLauncher.registerCron(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;
+					modeEnabled = false;
+					for (const listener of toolListeners) listener();
+					unsubscribe();
+					clearStatuses(binding);
+					mode?.publish();
+					const cleanupErrors = [];
+					try {
+						await Promise.all([defaultRegistration.dispose(SESSION_REPLACED_REASON), cronRegistration.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.", require_loopView.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.", require_loopView.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.`, require_loopView.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, args = "") {
+				const binding = currentSession(ctx);
+				if (!binding) return;
+				if (args.trim().startsWith("stop ")) {
+					const stopped = await binding.launchers.stop(args.trim().slice(5).trim(), "Stopped manually.");
+					ctx.ui.notify(stopped ? "Loop stopped." : "Loop instance was not active.", require_loopView.NOTIFY_INFO_LEVEL);
+					return;
+				}
+				if (args.trim()) throw new Error("Usage: /loops [stop instanceId]");
+				await openLoopListOverlay(ctx, binding.launchers);
+			}
+		},
+		minorModes: [mode],
+		onDispose() {
+			active = false;
+			const binding = activeSession;
+			activeSession = void 0;
+			modeEnabled = false;
+			for (const listener of toolListeners) listener();
+			toolListeners.clear();
+			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 ?? [], (0, _agimon_ai_doompi_minor_mode.piMinorModes)(runtime.minorModes)],
+		loopTools: runtime.loopTools,
+		toolRestrictions: runtime.toolRestrictions,
+		events: { agent_settled: runtime.onAgentSettled },
+		commands: createLoopCommands(runtime.handlers),
+		onDispose: () => runtime.onDispose(),
+		resources: [{
+			source: require_loopView.PACKAGE_SOURCE,
+			moduleUrl: require("url").pathToFileURL(__filename).href,
+			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 = (0, _agimon_ai_doompi_core_extensionFile.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$1 = (0, _agimon_ai_doompi_core_extensionFile.defineCliCommand)((context) => context.root.commands[0]);
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/command/loops.cli.ts
+var loops_cli_default = (0, _agimon_ai_doompi_core_extensionFile.defineCliCommand)((context) => context.root.commands[1]);
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/hook/agent-settled.cli.ts
+var agent_settled_cli_default = (0, _agimon_ai_doompi_core_extensionFile.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 = (0, _agimon_ai_doompi_core_extensionFile.defineResource)((context) => context.root.resources[0]);
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/tool-restriction/loop.cli.ts
+var loop_cli_default = (0, _agimon_ai_doompi_core_extensionFile.defineToolRestriction)((context) => context.root.toolRestrictions[0]);
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/tool/loop-list.cli.ts
+var loop_list_cli_default = (0, _agimon_ai_doompi_core_extensionFile.defineTool)((context) => context.root.loopTools[0]);
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/tool/loop-start.cli.ts
+var loop_start_cli_default = (0, _agimon_ai_doompi_core_extensionFile.defineTool)((context) => context.root.loopTools[1]);
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/tool/loop-stop.cli.ts
+var loop_stop_cli_default = (0, _agimon_ai_doompi_core_extensionFile.defineTool)((context) => context.root.loopTools[2]);
+//#endregion
+//#region generated/pi.ts
+const at = (value, context) => typeof value === "function" ? value(context) : value;
+const via = (identity, value) => value === void 0 ? void 0 : {
+	...identity,
+	...value
+};
+const extension = (0, _agimon_ai_doompi_core_piExtension.definePiExtension)("@agimon-ai/doompi-loop", async (context) => {
+	const scopeSession = await root_cli_default(context);
+	const contextSession = {
+		...context,
+		root: scopeSession.value
+	};
+	return {
+		...(0, _agimon_ai_doompi_core_extensionFile.composeRootHooks)(scopeSession),
+		get commands() {
+			return [at(loop_cli_default$1, contextSession), at(loops_cli_default, contextSession)];
+		},
+		events: { agent_settled: at(agent_settled_cli_default, contextSession) },
+		get resources() {
+			return [at(doompi_use_loop_cli_default, contextSession)];
+		},
+		get toolRestrictions() {
+			return [at(loop_cli_default, contextSession)];
+		},
+		...(0, _agimon_ai_doompi_core_piExtension.piToolContributions)("@agimon-ai/doompi-loop", [
+			via({ name: "loop_list" }, at(loop_list_cli_default, contextSession)),
+			via({ name: "loop_start" }, at(loop_start_cli_default, contextSession)),
+			via({ name: "loop_stop" }, at(loop_stop_cli_default, contextSession))
+		]),
+		services: [...scopeSession.services ?? []]
+	};
+});
+//#endregion
+exports.default = extension;
+exports.extension = extension;
+
 //# sourceMappingURL=pi.cjs.map