@pixelzx/genesis 2026.5.3-2 → 2026.5.3-3

package/dist/session-kill-http-BN9Ql6UD.js

@@ -0,0 +1,110 @@
+import { c as normalizeOptionalString } from "./string-coerce-C1IzJjqi.js";
+import { o as isLocalDirectRequest } from "./auth-I7fIjFrM.js";
+import { a as loadConfig } from "./io-CRPT2IUI.js";
+import "./config-DcheqK7J.js";
+import { n as authorizeOperatorScopesForMethod } from "./method-scopes-Dut0EB9J.js";
+import { a as loadSessionEntry } from "./session-utils-BRO58_d4.js";
+import { o as getLatestSubagentRunByChildSessionKey } from "./subagent-registry-BYuzIniG.js";
+import { a as killSubagentRunAdmin, c as resolveSubagentController, i as killControlledSubagentRun } from "./subagent-control-DsUeBdrz.js";
+import { S as sendMethodNotAllowed, h as resolveTrustedHttpOperatorScopes, r as authorizeGatewayHttpRequestOrReply, x as sendJson } from "./http-utils-Dwz38Ezf.js";
+//#region src/gateway/session-kill-http.ts
+const REQUESTER_SESSION_KEY_HEADER = "x-genesis-requester-session-key";
+function resolveSessionKeyFromPath(pathname) {
+	const match = pathname.match(/^\/sessions\/([^/]+)\/kill$/);
+	if (!match) return null;
+	try {
+		return decodeURIComponent(match[1] ?? "").trim() || null;
+	} catch {
+		return null;
+	}
+}
+async function handleSessionKillHttpRequest(req, res, opts) {
+	const cfg = loadConfig();
+	const sessionKey = resolveSessionKeyFromPath(new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`).pathname);
+	if (!sessionKey) return false;
+	if (req.method !== "POST") {
+		sendMethodNotAllowed(res, "POST");
+		return true;
+	}
+	const requestAuth = await authorizeGatewayHttpRequestOrReply({
+		req,
+		res,
+		auth: opts.auth,
+		trustedProxies: opts.trustedProxies ?? cfg.gateway?.trustedProxies,
+		allowRealIpFallback: opts.allowRealIpFallback ?? cfg.gateway?.allowRealIpFallback,
+		rateLimiter: opts.rateLimiter
+	});
+	if (!requestAuth) return true;
+	const trustedProxies = opts.trustedProxies ?? cfg.gateway?.trustedProxies;
+	const allowRealIpFallback = opts.allowRealIpFallback ?? cfg.gateway?.allowRealIpFallback;
+	const requesterSessionKey = normalizeOptionalString(req.headers[REQUESTER_SESSION_KEY_HEADER]?.toString());
+	const allowLocalAdminKill = isLocalDirectRequest(req, trustedProxies, allowRealIpFallback);
+	const requestedScopes = resolveTrustedHttpOperatorScopes(req, requestAuth);
+	if (!requesterSessionKey && !allowLocalAdminKill) {
+		sendJson(res, 403, {
+			ok: false,
+			error: {
+				type: "forbidden",
+				message: "Session kills require a local admin request or requester session ownership."
+			}
+		});
+		return true;
+	}
+	const scopeAuth = authorizeOperatorScopesForMethod(requesterSessionKey && !allowLocalAdminKill ? "sessions.abort" : "sessions.delete", requestedScopes);
+	if (!scopeAuth.allowed) {
+		sendJson(res, 403, {
+			ok: false,
+			error: {
+				type: "forbidden",
+				message: `missing scope: ${scopeAuth.missingScope}`
+			}
+		});
+		return true;
+	}
+	const { entry, canonicalKey } = loadSessionEntry(sessionKey);
+	if (!entry) {
+		sendJson(res, 404, {
+			ok: false,
+			error: {
+				type: "not_found",
+				message: `Session not found: ${sessionKey}`
+			}
+		});
+		return true;
+	}
+	let killed = false;
+	if (!allowLocalAdminKill && requesterSessionKey) {
+		const runEntry = getLatestSubagentRunByChildSessionKey(canonicalKey);
+		if (runEntry) {
+			const result = await killControlledSubagentRun({
+				cfg,
+				controller: resolveSubagentController({
+					cfg,
+					agentSessionKey: requesterSessionKey
+				}),
+				entry: runEntry
+			});
+			if (result.status === "forbidden") {
+				sendJson(res, 403, {
+					ok: false,
+					error: {
+						type: "forbidden",
+						message: result.error
+					}
+				});
+				return true;
+			}
+			killed = result.status === "ok";
+		}
+	} else killed = (await killSubagentRunAdmin({
+		cfg,
+		sessionKey: canonicalKey
+	})).killed;
+	sendJson(res, 200, {
+		ok: true,
+		killed
+	});
+	return true;
+}
+//#endregion
+export { handleSessionKillHttpRequest };

package/dist/session-reset-service-hNFKFmB3.js

@@ -0,0 +1,471 @@
+import { r as logVerbose } from "./globals-C5IxqXPj.js";
+import { a as loadConfig } from "./io-CRPT2IUI.js";
+import { a as isSubagentSessionKey, o as parseAgentSessionKey } from "./session-key-utils-BT0y7mVK.js";
+import { c as normalizeAgentId } from "./session-key-EpIbK3Oz.js";
+import { b as resolveAgentWorkspaceDir, x as resolveDefaultAgentId } from "./agent-scope-CDjZLqNk.js";
+import "./config-DcheqK7J.js";
+import { on as ErrorCodes, sn as errorShape } from "./client-DWrM2Yms.js";
+import { t as getGlobalHookRunner } from "./hook-runner-global-BHm-9u5R.js";
+import { m as triggerInternalHook, n as createInternalHookEvent } from "./internal-hooks-B2c7dDLy.js";
+import { a as resolveSessionFilePathOptions, i as resolveSessionFilePath } from "./paths-CyaKOUSX.js";
+import { m as snapshotSessionOrigin, o as updateSessionStore } from "./store-Cxyeks39.js";
+import "./sessions-BGtpdShC.js";
+import { i as readSessionMessages } from "./session-utils.fs-DK1dJtSj.js";
+import { o as resolveStableSessionEndTranscript, r as archiveSessionTranscriptsDetailed } from "./session-transcript-files.fs-CS4AQvZ1.js";
+import { a as loadSessionEntry, d as resolveGatewaySessionStoreTarget, o as migrateAndPruneGatewaySessionStoreKey, p as resolveSessionModelRef } from "./session-utils-BRO58_d4.js";
+import { t as clearBootstrapSnapshot } from "./bootstrap-cache-tn5TRTX6.js";
+import { o as retireSessionMcpRuntime } from "./pi-bundle-mcp-runtime-Dm3dV4hJ.js";
+import "./pi-bundle-mcp-tools-cmwRH2ga.js";
+import { a as clearSessionQueues } from "./queue-CAmq33Dw.js";
+import { r as getSessionBindingService } from "./session-binding-service-CW4KC3dE.js";
+import { f as waitForEmbeddedPiRunEnd, t as abortEmbeddedPiRun } from "./runs-B8k9nDbi.js";
+import "./pi-embedded-DD7aPF12.js";
+import { t as resolveResetPreservedSelection } from "./reset-preserved-selection-DaQ_cmzj.js";
+import { n as buildSessionStartHookPayload, t as buildSessionEndHookPayload } from "./session-hooks-Dkd8gqqp.js";
+import { a as getAcpRuntimeBackend, n as getAcpSessionManager } from "./manager-C8C_r6-q.js";
+import { i as upsertAcpSessionMeta, n as readAcpSessionEntry } from "./session-meta-CBRBgtpD.js";
+import { r as stopSubagentsForRequester } from "./abort-91r4UulC.js";
+import { t as closeTrackedBrowserTabsForSessions } from "./browser-maintenance-CjMO3r9I.js";
+import fs from "node:fs";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import { CURRENT_SESSION_VERSION } from "@mariozechner/pi-coding-agent";
+//#region src/gateway/session-reset-service.ts
+const ACP_RUNTIME_CLEANUP_TIMEOUT_MS = 15e3;
+function stripRuntimeModelState(entry) {
+	if (!entry) return entry;
+	return {
+		...entry,
+		model: void 0,
+		modelProvider: void 0,
+		contextTokens: void 0,
+		systemPromptReport: void 0
+	};
+}
+function archiveSessionTranscriptsForSessionDetailed(params) {
+	if (!params.sessionId) return [];
+	return archiveSessionTranscriptsDetailed({
+		sessionId: params.sessionId,
+		storePath: params.storePath,
+		sessionFile: params.sessionFile,
+		agentId: params.agentId,
+		reason: params.reason
+	});
+}
+function emitGatewaySessionEndPluginHook(params) {
+	if (!params.sessionId) return;
+	const hookRunner = getGlobalHookRunner();
+	if (!hookRunner?.hasHooks("session_end")) return;
+	const transcript = resolveStableSessionEndTranscript({
+		sessionId: params.sessionId,
+		storePath: params.storePath,
+		sessionFile: params.sessionFile,
+		agentId: params.agentId,
+		archivedTranscripts: params.archivedTranscripts
+	});
+	const payload = buildSessionEndHookPayload({
+		sessionId: params.sessionId,
+		sessionKey: params.sessionKey,
+		cfg: params.cfg,
+		reason: params.reason,
+		sessionFile: transcript.sessionFile,
+		transcriptArchived: transcript.transcriptArchived,
+		nextSessionId: params.nextSessionId,
+		nextSessionKey: params.nextSessionKey
+	});
+	hookRunner.runSessionEnd(payload.event, payload.context).catch((err) => {
+		logVerbose(`session_end hook failed: ${String(err)}`);
+	});
+}
+function emitGatewaySessionStartPluginHook(params) {
+	if (!params.sessionId) return;
+	const hookRunner = getGlobalHookRunner();
+	if (!hookRunner?.hasHooks("session_start")) return;
+	const payload = buildSessionStartHookPayload({
+		sessionId: params.sessionId,
+		sessionKey: params.sessionKey,
+		cfg: params.cfg,
+		resumedFrom: params.resumedFrom
+	});
+	hookRunner.runSessionStart(payload.event, payload.context).catch((err) => {
+		logVerbose(`session_start hook failed: ${String(err)}`);
+	});
+}
+async function emitSessionUnboundLifecycleEvent(params) {
+	const targetKind = isSubagentSessionKey(params.targetSessionKey) ? "subagent" : "acp";
+	await getSessionBindingService().unbind({
+		targetSessionKey: params.targetSessionKey,
+		reason: params.reason
+	});
+	if (params.emitHooks === false) return;
+	const hookRunner = getGlobalHookRunner();
+	if (!hookRunner?.hasHooks("subagent_ended")) return;
+	await hookRunner.runSubagentEnded({
+		targetSessionKey: params.targetSessionKey,
+		targetKind,
+		reason: params.reason,
+		sendFarewell: true,
+		outcome: params.reason === "session-reset" ? "reset" : "deleted"
+	}, { childSessionKey: params.targetSessionKey });
+}
+async function ensureSessionRuntimeCleanup(params) {
+	const closeTrackedBrowserTabs = async () => {
+		return await closeTrackedBrowserTabsForSessions({
+			sessionKeys: [...new Set([
+				params.key,
+				params.target.canonicalKey,
+				...params.target.storeKeys,
+				params.sessionId ?? ""
+			])],
+			onWarn: (message) => logVerbose(message)
+		});
+	};
+	const queueKeys = new Set(params.target.storeKeys);
+	queueKeys.add(params.target.canonicalKey);
+	if (params.sessionId) queueKeys.add(params.sessionId);
+	clearSessionQueues([...queueKeys]);
+	stopSubagentsForRequester({
+		cfg: params.cfg,
+		requesterSessionKey: params.target.canonicalKey
+	});
+	if (!params.sessionId) {
+		clearBootstrapSnapshot(params.target.canonicalKey);
+		await closeTrackedBrowserTabs();
+		return;
+	}
+	abortEmbeddedPiRun(params.sessionId);
+	const ended = await waitForEmbeddedPiRunEnd(params.sessionId, 15e3);
+	clearBootstrapSnapshot(params.target.canonicalKey);
+	if (ended) {
+		await retireSessionMcpRuntime({
+			sessionId: params.sessionId,
+			reason: "gateway-session-cleanup",
+			onError: (error, sessionId) => {
+				logVerbose(`sessions cleanup: failed to dispose bundle MCP runtime for ${sessionId}: ${String(error)}`);
+			}
+		});
+		await closeTrackedBrowserTabs();
+		return;
+	}
+	return errorShape(ErrorCodes.UNAVAILABLE, `Session ${params.key} is still active; try again in a moment.`);
+}
+async function runAcpCleanupStep(params) {
+	let timer;
+	const timeoutPromise = new Promise((resolve) => {
+		timer = setTimeout(() => resolve({ status: "timeout" }), ACP_RUNTIME_CLEANUP_TIMEOUT_MS);
+	});
+	const opPromise = params.op().then(() => ({ status: "ok" })).catch((error) => ({
+		status: "error",
+		error
+	}));
+	const outcome = await Promise.race([opPromise, timeoutPromise]);
+	if (timer) clearTimeout(timer);
+	return outcome;
+}
+async function closeAcpRuntimeForSession(params) {
+	if (!params.entry?.acp) return;
+	const acpManager = getAcpSessionManager();
+	const cancelOutcome = await runAcpCleanupStep({ op: async () => {
+		await acpManager.cancelSession({
+			cfg: params.cfg,
+			sessionKey: params.sessionKey,
+			reason: params.reason
+		});
+	} });
+	if (cancelOutcome.status === "timeout") return errorShape(ErrorCodes.UNAVAILABLE, `Session ${params.sessionKey} is still active; try again in a moment.`);
+	if (cancelOutcome.status === "error") logVerbose(`sessions.${params.reason}: ACP cancel failed for ${params.sessionKey}: ${String(cancelOutcome.error)}`);
+	const closeOutcome = await runAcpCleanupStep({ op: async () => {
+		await acpManager.closeSession({
+			cfg: params.cfg,
+			sessionKey: params.sessionKey,
+			reason: params.reason,
+			discardPersistentState: true,
+			requireAcpSession: false,
+			allowBackendUnavailable: true
+		});
+	} });
+	if (closeOutcome.status === "timeout") return errorShape(ErrorCodes.UNAVAILABLE, `Session ${params.sessionKey} is still active; try again in a moment.`);
+	if (closeOutcome.status === "error") logVerbose(`sessions.${params.reason}: ACP runtime close failed for ${params.sessionKey}: ${String(closeOutcome.error)}`);
+	await ensureFreshAcpResetState({
+		cfg: params.cfg,
+		sessionKey: params.sessionKey,
+		reason: params.reason,
+		entry: params.entry
+	});
+}
+function buildPendingAcpMeta(base, now) {
+	const currentIdentity = base.identity;
+	const nextIdentity = currentIdentity ? {
+		state: "pending",
+		...currentIdentity.acpxRecordId ? { acpxRecordId: currentIdentity.acpxRecordId } : {},
+		source: currentIdentity.source,
+		lastUpdatedAt: now
+	} : void 0;
+	return {
+		backend: base.backend,
+		agent: base.agent,
+		runtimeSessionName: base.runtimeSessionName,
+		...nextIdentity ? { identity: nextIdentity } : {},
+		mode: base.mode,
+		...base.runtimeOptions ? { runtimeOptions: base.runtimeOptions } : {},
+		...base.cwd ? { cwd: base.cwd } : {},
+		state: "idle",
+		lastActivityAt: now
+	};
+}
+async function ensureFreshAcpResetState(params) {
+	if (params.reason !== "session-reset" || !params.entry?.acp) return;
+	const latestMeta = readAcpSessionEntry({
+		cfg: params.cfg,
+		sessionKey: params.sessionKey
+	})?.acp;
+	if (!latestMeta?.identity || latestMeta.identity.state !== "resolved" || !latestMeta.identity.acpxSessionId && !latestMeta.identity.agentSessionId) return;
+	const backendId = (latestMeta.backend || params.cfg.acp?.backend || "").trim() || void 0;
+	try {
+		await getAcpRuntimeBackend(backendId)?.runtime.prepareFreshSession?.({ sessionKey: params.sessionKey });
+	} catch (error) {
+		logVerbose(`sessions.${params.reason}: ACP prepareFreshSession failed for ${params.sessionKey}: ${String(error)}`);
+	}
+	const now = Date.now();
+	await upsertAcpSessionMeta({
+		cfg: params.cfg,
+		sessionKey: params.sessionKey,
+		mutate: (current, entry) => {
+			const base = current ?? entry?.acp;
+			if (!base) return null;
+			return buildPendingAcpMeta(base, now);
+		}
+	});
+}
+async function cleanupSessionBeforeMutation(params) {
+	const cleanupError = await ensureSessionRuntimeCleanup({
+		cfg: params.cfg,
+		key: params.key,
+		target: params.target,
+		sessionId: params.entry?.sessionId
+	});
+	if (cleanupError) return cleanupError;
+	return await closeAcpRuntimeForSession({
+		cfg: params.cfg,
+		sessionKey: params.legacyKey ?? params.canonicalKey ?? params.target.canonicalKey ?? params.key,
+		entry: params.entry,
+		reason: params.reason
+	});
+}
+function emitGatewayBeforeResetPluginHook(params) {
+	const hookRunner = getGlobalHookRunner();
+	if (!hookRunner?.hasHooks("before_reset")) return;
+	const sessionKey = params.target.canonicalKey ?? params.key;
+	const sessionId = params.entry?.sessionId;
+	const sessionFile = params.entry?.sessionFile;
+	const agentId = normalizeAgentId(params.target.agentId ?? resolveDefaultAgentId(params.cfg));
+	const workspaceDir = resolveAgentWorkspaceDir(params.cfg, agentId);
+	let messages = [];
+	try {
+		if (typeof sessionId === "string" && sessionId.trim().length > 0) messages = readSessionMessages(sessionId, params.storePath, sessionFile);
+	} catch (err) {
+		logVerbose(`before_reset: failed to read session messages for ${sessionId ?? "(none)"}; firing hook with empty messages (${String(err)})`);
+	}
+	hookRunner.runBeforeReset({
+		sessionFile,
+		messages,
+		reason: params.reason
+	}, {
+		agentId,
+		sessionKey,
+		sessionId,
+		workspaceDir
+	}).catch((err) => {
+		logVerbose(`before_reset hook failed: ${String(err)}`);
+	});
+}
+async function performGatewaySessionReset(params) {
+	const { cfg, target, storePath } = (() => {
+		const cfg = loadConfig();
+		const target = resolveGatewaySessionStoreTarget({
+			cfg,
+			key: params.key
+		});
+		return {
+			cfg,
+			target,
+			storePath: target.storePath
+		};
+	})();
+	const { entry, legacyKey, canonicalKey } = loadSessionEntry(params.key);
+	const hadExistingEntry = Boolean(entry);
+	const workspaceDir = resolveAgentWorkspaceDir(cfg, normalizeAgentId(target.agentId ?? resolveDefaultAgentId(cfg)));
+	await triggerInternalHook(createInternalHookEvent("command", params.reason, target.canonicalKey ?? params.key, {
+		sessionEntry: entry,
+		previousSessionEntry: entry,
+		commandSource: params.commandSource,
+		cfg,
+		workspaceDir
+	}));
+	const mutationCleanupError = await cleanupSessionBeforeMutation({
+		cfg,
+		key: params.key,
+		target,
+		entry,
+		legacyKey,
+		canonicalKey,
+		reason: "session-reset"
+	});
+	if (mutationCleanupError) return {
+		ok: false,
+		error: mutationCleanupError
+	};
+	let oldSessionId;
+	let oldSessionFile;
+	let resetSourceEntry;
+	const next = await updateSessionStore(storePath, (store) => {
+		const { primaryKey } = migrateAndPruneGatewaySessionStoreKey({
+			cfg,
+			key: params.key,
+			store
+		});
+		const currentEntry = store[primaryKey];
+		resetSourceEntry = currentEntry ? { ...currentEntry } : void 0;
+		const sessionAgentId = normalizeAgentId(parseAgentSessionKey(primaryKey)?.agentId ?? resolveDefaultAgentId(cfg));
+		const resetPreservedSelection = resolveResetPreservedSelection({ entry: currentEntry });
+		const resetEntry = {
+			...stripRuntimeModelState(currentEntry),
+			providerOverride: void 0,
+			modelOverride: void 0,
+			modelOverrideSource: void 0,
+			authProfileOverride: void 0,
+			authProfileOverrideSource: void 0,
+			authProfileOverrideCompactionCount: void 0,
+			...resetPreservedSelection
+		};
+		const resolvedModel = resolveSessionModelRef(cfg, resetEntry, sessionAgentId);
+		oldSessionId = currentEntry?.sessionId;
+		oldSessionFile = currentEntry?.sessionFile;
+		const now = Date.now();
+		const nextSessionId = randomUUID();
+		const nextEntry = {
+			sessionId: nextSessionId,
+			sessionFile: resolveSessionFilePath(nextSessionId, currentEntry?.sessionFile ? { sessionFile: currentEntry.sessionFile } : void 0, resolveSessionFilePathOptions({
+				storePath,
+				agentId: sessionAgentId
+			})),
+			updatedAt: now,
+			systemSent: false,
+			abortedLastRun: false,
+			thinkingLevel: currentEntry?.thinkingLevel,
+			fastMode: currentEntry?.fastMode,
+			verboseLevel: currentEntry?.verboseLevel,
+			traceLevel: currentEntry?.traceLevel,
+			reasoningLevel: currentEntry?.reasoningLevel,
+			elevatedLevel: currentEntry?.elevatedLevel,
+			ttsAuto: currentEntry?.ttsAuto,
+			execHost: currentEntry?.execHost,
+			execSecurity: currentEntry?.execSecurity,
+			execAsk: currentEntry?.execAsk,
+			execNode: currentEntry?.execNode,
+			responseUsage: currentEntry?.responseUsage,
+			...resetPreservedSelection,
+			groupActivation: currentEntry?.groupActivation,
+			groupActivationNeedsSystemIntro: currentEntry?.groupActivationNeedsSystemIntro,
+			chatType: currentEntry?.chatType,
+			model: resolvedModel.model,
+			modelProvider: resolvedModel.provider,
+			contextTokens: resetEntry?.contextTokens,
+			compactionCount: currentEntry?.compactionCount,
+			compactionCheckpoints: currentEntry?.compactionCheckpoints,
+			sendPolicy: currentEntry?.sendPolicy,
+			queueMode: currentEntry?.queueMode,
+			queueDebounceMs: currentEntry?.queueDebounceMs,
+			queueCap: currentEntry?.queueCap,
+			queueDrop: currentEntry?.queueDrop,
+			spawnedBy: currentEntry?.spawnedBy,
+			spawnedWorkspaceDir: currentEntry?.spawnedWorkspaceDir,
+			parentSessionKey: currentEntry?.parentSessionKey,
+			forkedFromParent: currentEntry?.forkedFromParent,
+			spawnDepth: currentEntry?.spawnDepth,
+			subagentRole: currentEntry?.subagentRole,
+			subagentControlScope: currentEntry?.subagentControlScope,
+			label: currentEntry?.label,
+			displayName: currentEntry?.displayName,
+			channel: currentEntry?.channel,
+			groupId: currentEntry?.groupId,
+			subject: currentEntry?.subject,
+			groupChannel: currentEntry?.groupChannel,
+			space: currentEntry?.space,
+			origin: snapshotSessionOrigin(currentEntry),
+			deliveryContext: currentEntry?.deliveryContext,
+			cliSessionBindings: currentEntry?.cliSessionBindings,
+			cliSessionIds: currentEntry?.cliSessionIds,
+			claudeCliSessionId: currentEntry?.claudeCliSessionId,
+			lastChannel: currentEntry?.lastChannel,
+			lastTo: currentEntry?.lastTo,
+			lastAccountId: currentEntry?.lastAccountId,
+			lastThreadId: currentEntry?.lastThreadId,
+			skillsSnapshot: currentEntry?.skillsSnapshot,
+			acp: currentEntry?.acp,
+			inputTokens: 0,
+			outputTokens: 0,
+			totalTokens: 0,
+			totalTokensFresh: true
+		};
+		store[primaryKey] = nextEntry;
+		return nextEntry;
+	});
+	emitGatewayBeforeResetPluginHook({
+		cfg,
+		key: params.key,
+		target,
+		storePath,
+		entry: resetSourceEntry,
+		reason: params.reason
+	});
+	const archivedTranscripts = archiveSessionTranscriptsForSessionDetailed({
+		sessionId: oldSessionId,
+		storePath,
+		sessionFile: oldSessionFile,
+		agentId: target.agentId,
+		reason: "reset"
+	});
+	fs.mkdirSync(path.dirname(next.sessionFile), { recursive: true });
+	if (!fs.existsSync(next.sessionFile)) {
+		const header = {
+			type: "session",
+			version: CURRENT_SESSION_VERSION,
+			id: next.sessionId,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			cwd: process.cwd()
+		};
+		fs.writeFileSync(next.sessionFile, `${JSON.stringify(header)}\n`, {
+			encoding: "utf-8",
+			mode: 384
+		});
+	}
+	emitGatewaySessionEndPluginHook({
+		cfg,
+		sessionKey: target.canonicalKey ?? params.key,
+		sessionId: oldSessionId,
+		storePath,
+		sessionFile: oldSessionFile,
+		agentId: target.agentId,
+		reason: params.reason,
+		archivedTranscripts,
+		nextSessionId: next.sessionId
+	});
+	emitGatewaySessionStartPluginHook({
+		cfg,
+		sessionKey: target.canonicalKey ?? params.key,
+		sessionId: next.sessionId,
+		resumedFrom: oldSessionId
+	});
+	if (hadExistingEntry) await emitSessionUnboundLifecycleEvent({
+		targetSessionKey: target.canonicalKey ?? params.key,
+		reason: "session-reset"
+	});
+	return {
+		ok: true,
+		key: target.canonicalKey,
+		entry: next
+	};
+}
+//#endregion
+export { performGatewaySessionReset as a, emitSessionUnboundLifecycleEvent as i, cleanupSessionBeforeMutation as n, emitGatewaySessionEndPluginHook as r, archiveSessionTranscriptsForSessionDetailed as t };

package/dist/session-route-DErqiFgk.js

@@ -0,0 +1,93 @@
+import { a as normalizeLowercaseStringOrEmpty, s as normalizeOptionalLowercaseString } from "./string-coerce-C1IzJjqi.js";
+import "./text-runtime-BGtvBT2C.js";
+import { t as buildChannelOutboundSessionRoute } from "./core-ChqnJuFH.js";
+//#region extensions/zalouser/src/session-route.ts
+function stripZalouserTargetPrefix(raw) {
+	return raw.trim().replace(/^(zalouser|zlu):/i, "").trim();
+}
+function normalizeZalouserTarget(raw) {
+	const trimmed = stripZalouserTargetPrefix(raw);
+	if (!trimmed) return;
+	const lower = normalizeLowercaseStringOrEmpty(trimmed);
+	if (lower.startsWith("group:")) {
+		const id = trimmed.slice(6).trim();
+		return id ? `group:${id}` : void 0;
+	}
+	if (lower.startsWith("g:")) {
+		const id = trimmed.slice(2).trim();
+		return id ? `group:${id}` : void 0;
+	}
+	if (lower.startsWith("user:")) {
+		const id = trimmed.slice(5).trim();
+		return id ? `user:${id}` : void 0;
+	}
+	if (lower.startsWith("dm:")) {
+		const id = trimmed.slice(3).trim();
+		return id ? `user:${id}` : void 0;
+	}
+	if (lower.startsWith("u:")) {
+		const id = trimmed.slice(2).trim();
+		return id ? `user:${id}` : void 0;
+	}
+	if (/^g-\S+$/i.test(trimmed)) return `group:${trimmed}`;
+	if (/^u-\S+$/i.test(trimmed)) return `user:${trimmed}`;
+	return trimmed;
+}
+function parseZalouserOutboundTarget(raw) {
+	const normalized = normalizeZalouserTarget(raw);
+	if (!normalized) throw new Error("Zalouser target is required");
+	const lowered = normalizeLowercaseStringOrEmpty(normalized);
+	if (lowered.startsWith("group:")) {
+		const threadId = normalized.slice(6).trim();
+		if (!threadId) throw new Error("Zalouser group target is missing group id");
+		return {
+			threadId,
+			isGroup: true
+		};
+	}
+	if (lowered.startsWith("user:")) {
+		const threadId = normalized.slice(5).trim();
+		if (!threadId) throw new Error("Zalouser user target is missing user id");
+		return {
+			threadId,
+			isGroup: false
+		};
+	}
+	return {
+		threadId: normalized,
+		isGroup: false
+	};
+}
+function parseZalouserDirectoryGroupId(raw) {
+	const normalized = normalizeZalouserTarget(raw);
+	if (!normalized) throw new Error("Zalouser group target is required");
+	const lowered = normalizeLowercaseStringOrEmpty(normalized);
+	if (lowered.startsWith("group:")) {
+		const groupId = normalized.slice(6).trim();
+		if (!groupId) throw new Error("Zalouser group target is missing group id");
+		return groupId;
+	}
+	if (lowered.startsWith("user:")) throw new Error("Zalouser group members lookup requires a group target (group:<id>)");
+	return normalized;
+}
+function resolveZalouserOutboundSessionRoute(params) {
+	const normalized = normalizeZalouserTarget(params.target);
+	if (!normalized) return null;
+	const isGroup = (normalizeOptionalLowercaseString(normalized) ?? "").startsWith("group:");
+	const peerId = normalized.replace(/^(group|user):/i, "").trim();
+	return buildChannelOutboundSessionRoute({
+		cfg: params.cfg,
+		agentId: params.agentId,
+		channel: "zalouser",
+		accountId: params.accountId,
+		peer: {
+			kind: isGroup ? "group" : "direct",
+			id: peerId
+		},
+		chatType: isGroup ? "group" : "direct",
+		from: isGroup ? `zalouser:group:${peerId}` : `zalouser:${peerId}`,
+		to: `zalouser:${peerId}`
+	});
+}
+//#endregion
+export { resolveZalouserOutboundSessionRoute as i, parseZalouserDirectoryGroupId as n, parseZalouserOutboundTarget as r, normalizeZalouserTarget as t };

package/dist/session-status.runtime-Cu7JU8_U.js

@@ -0,0 +1,2 @@
+import { t as buildStatusText } from "./status-text-DyIs2f8P.js";
+export { buildStatusText };

package/dist/session-status.runtime.js

@@ -1 +1 @@
-export * from "./session-status.runtime-BenL5h6z.js";
+export * from "./session-status.runtime-Cu7JU8_U.js";

package/dist/session-subagent-reactivation.runtime-Bbagi0__.js

@@ -0,0 +1,2 @@
+import { m as replaceSubagentRunAfterSteer } from "./subagent-registry-BYuzIniG.js";
+export { replaceSubagentRunAfterSteer };

package/dist/session-subagent-reactivation.runtime.js

@@ -1 +1 @@
-export * from "./session-subagent-reactivation.runtime-VrwlEPse.js";
+export * from "./session-subagent-reactivation.runtime-Bbagi0__.js";