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

package/dist/{src/schemas/apiContracts.cjs → apiContracts.cjs}

@@ -1,6 +1,10 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
 //#region src/schemas/apiContracts.ts
 /** This facet contributes agent tools, commands or lifecycle only, with no separate HTTP or socket surface. */
-const apiContracts = (0, require("@agimon-ai/doompi-core/api-contracts").defineApiContract)({
+const apiContracts = (0, require("@agimon-ai/doompi-core/apiContracts").defineApiContract)({
 	version: 1,
 	http: [],
 	sockets: [],

package/dist/apiContracts.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"apiContracts.cjs","names":["defineApiContract"],"sources":["../src/schemas/apiContracts.ts"],"sourcesContent":["import { defineApiContract } from '@agimon-ai/doompi-core/apiContracts';\n\n/** This facet contributes agent tools, commands or lifecycle only, with no separate HTTP or socket surface. */\nexport const apiContracts = defineApiContract({ version: 1, http: [], sockets: [], dynamic: [] });\nexport default apiContracts;\n"],"mappings":";;;;;;AAGA,MAAa,gBAAA,gDAAeA,CAAAA,CAAAA,kBAAAA,CAAkB;CAAE,SAAS;CAAG,MAAM,CAAC;CAAG,SAAS,CAAC;CAAG,SAAS,CAAC;AAAE,CAAC"}

package/dist/{src/schemas/apiContracts.d.mts.map → apiContracts.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"apiContracts.d.mts","names":[],"sources":["../../../src/schemas/apiContracts.ts"],"mappings":";;qBAGa"}
+{"version":3,"file":"apiContracts.d.mts","names":[],"sources":["../src/schemas/apiContracts.ts"],"mappings":";;qBAGa"}

package/dist/{src/schemas/apiContracts.mjs → apiContracts.mjs}

@@ -1,4 +1,4 @@
-import { defineApiContract } from "@agimon-ai/doompi-core/api-contracts";
+import { defineApiContract } from "@agimon-ai/doompi-core/apiContracts";
 //#region src/schemas/apiContracts.ts
 /** This facet contributes agent tools, commands or lifecycle only, with no separate HTTP or socket surface. */
 const apiContracts = defineApiContract({

package/dist/apiContracts.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"apiContracts.mjs","names":[],"sources":["../src/schemas/apiContracts.ts"],"sourcesContent":["import { defineApiContract } from '@agimon-ai/doompi-core/apiContracts';\n\n/** This facet contributes agent tools, commands or lifecycle only, with no separate HTTP or socket surface. */\nexport const apiContracts = defineApiContract({ version: 1, http: [], sockets: [], dynamic: [] });\nexport default apiContracts;\n"],"mappings":";;;AAGA,MAAa,eAAe,kBAAkB;CAAE,SAAS;CAAG,MAAM,CAAC;CAAG,SAAS,CAAC;CAAG,SAAS,CAAC;AAAE,CAAC"}

package/dist/extensions/pi.cjs

@@ -2,29 +2,612 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_root_cli = require("../src/extensions/workspaces/sessions/(backend)/root.cli.cjs");
-const require_loop_cli = require("../src/extensions/workspaces/sessions/(backend)/command/loop.cli.cjs");
-const require_loops_cli = require("../src/extensions/workspaces/sessions/(backend)/command/loops.cli.cjs");
-const require_agent_settled_cli = require("../src/extensions/workspaces/sessions/(backend)/hook/agent-settled.cli.cjs");
-const require_doompi_use_loop_cli = require("../src/extensions/workspaces/sessions/(backend)/resource/doompi-use-loop.cli.cjs");
-let _agimon_ai_doompi_core_pi_extension = require("@agimon-ai/doompi-core/pi-extension");
-let _agimon_ai_doompi_core_extension_file = require("@agimon-ai/doompi-core/extension-file");
+const require_loopLaunchers = require("../loopLaunchers-BtcLH_xN.cjs");
+const require_loopView = require("../loopView-CLIBhqYC.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 _agimon_ai_doompi_ui_doomOverlay = require("@agimon-ai/doompi-ui/doomOverlay");
+let _earendil_works_pi_tui = require("@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 [[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)
+	}]];
+}
+//#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: 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_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(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(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: 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([_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;
+				const provider = cordis.plugin((providerContext) => {
+					providerContext.provide(require_loopLaunchers.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 ?? [], (0, _agimon_ai_doompi_minor_mode.piMinorModes)(runtime.minorModes)],
+		events: { agent_settled: runtime.onAgentSettled },
+		commands: createLoopCommands(runtime.handlers),
+		onDispose: () => runtime.onDispose(),
+		resources: [{
+			source: 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 = (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 generated/pi.ts
 const at = (value, context) => typeof value === "function" ? value(context) : value;
-const extension = (0, _agimon_ai_doompi_core_pi_extension.definePiExtension)("@agimon-ai/doompi-loop", async (context) => {
-	const scopeSession = await require_root_cli.default(context);
+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_extension_file.composeRootHooks)(scopeSession),
+		...(0, _agimon_ai_doompi_core_extensionFile.composeRootHooks)(scopeSession),
 		get commands() {
-			return [at(require_loop_cli.default, contextSession), at(require_loops_cli.default, contextSession)];
+			return [at(loop_cli_default, contextSession), at(loops_cli_default, contextSession)];
 		},
-		events: { agent_settled: at(require_agent_settled_cli.default, contextSession) },
+		events: { agent_settled: at(agent_settled_cli_default, contextSession) },
 		get resources() {
-			return [at(require_doompi_use_loop_cli.default, contextSession)];
+			return [at(doompi_use_loop_cli_default, contextSession)];
 		},
 		services: [...scopeSession.services ?? []]
 	};