@pixelzx/genesis 2026.5.10-6 → 2026.5.14

package/dist/list-LwlQhQNC.js

@@ -0,0 +1,2 @@
+import { t as channelsListCommand } from "./list-kEb2jXCm.js";
+export { channelsListCommand };

package/dist/list-kEb2jXCm.js

@@ -0,0 +1,131 @@
+import { n as defaultRuntime, r as writeRuntimeJson } from "./runtime-CQ7eH0le.js";
+import { t as formatDocsLink } from "./links-DmsJCU7L.js";
+import { r as theme } from "./theme-BrRleVfL.js";
+import { n as isChannelVisibleInConfiguredLists } from "./channel-meta-BEaGWV3f.js";
+import { l as loadAuthProfileStoreWithoutExternalProfiles } from "./store-Migb-HSP.js";
+import "./auth-profiles-vW3-URAt.js";
+import { t as listReadOnlyChannelPluginsForConfig } from "./read-only-RoJzEEYr.js";
+import { n as withProgress } from "./progress-B0hhA4sH.js";
+import { t as formatUsageReportLines } from "./provider-usage-DnRRLhKs.js";
+import { t as loadProviderUsageSummary } from "./provider-usage.load-DP_lNMBl.js";
+import { c as requireValidConfig, s as formatChannelAccountLabel } from "./shared-D8yOAH4J.js";
+import { t as buildChannelAccountSnapshot } from "./status-BNY596UO.js";
+//#region src/commands/channels/list.ts
+const colorValue = (value) => {
+	if (value === "none") return theme.error(value);
+	if (value === "env") return theme.accent(value);
+	return theme.success(value);
+};
+function formatEnabled(value) {
+	return value === false ? theme.error("disabled") : theme.success("enabled");
+}
+function formatConfigured(value) {
+	return value ? theme.success("configured") : theme.warn("not configured");
+}
+function formatTokenSource(source) {
+	return `token=${colorValue(source || "none")}`;
+}
+function formatSource(label, source) {
+	return `${label}=${colorValue(source || "none")}`;
+}
+function formatLinked(value) {
+	return value ? theme.success("linked") : theme.warn("not linked");
+}
+function shouldShowConfigured(channel) {
+	return isChannelVisibleInConfiguredLists(channel.meta);
+}
+function formatAccountLine(params) {
+	const { channel, snapshot } = params;
+	const label = formatChannelAccountLabel({
+		channel: channel.id,
+		accountId: snapshot.accountId,
+		name: snapshot.name,
+		channelStyle: theme.accent,
+		accountStyle: theme.heading
+	});
+	const bits = [];
+	if (snapshot.linked !== void 0) bits.push(formatLinked(snapshot.linked));
+	if (shouldShowConfigured(channel) && typeof snapshot.configured === "boolean") bits.push(formatConfigured(snapshot.configured));
+	if (snapshot.tokenSource) bits.push(formatTokenSource(snapshot.tokenSource));
+	if (snapshot.botTokenSource) bits.push(formatSource("bot", snapshot.botTokenSource));
+	if (snapshot.appTokenSource) bits.push(formatSource("app", snapshot.appTokenSource));
+	if (snapshot.baseUrl) bits.push(`base=${theme.muted(snapshot.baseUrl)}`);
+	if (typeof snapshot.enabled === "boolean") bits.push(formatEnabled(snapshot.enabled));
+	return `- ${label}: ${bits.join(", ")}`;
+}
+async function loadUsageWithProgress(runtime) {
+	try {
+		return await withProgress({
+			label: "Fetching usage snapshot…",
+			indeterminate: true,
+			enabled: true
+		}, async () => await loadProviderUsageSummary({ skipPluginAuthWithoutCredentialSource: true }));
+	} catch (err) {
+		runtime.error(String(err));
+		return null;
+	}
+}
+async function channelsListCommand(opts, runtime = defaultRuntime) {
+	const cfg = await requireValidConfig(runtime);
+	if (!cfg) return;
+	const includeUsage = opts.usage !== false;
+	const plugins = listReadOnlyChannelPluginsForConfig(cfg);
+	const authStore = loadAuthProfileStoreWithoutExternalProfiles();
+	const authProfiles = Object.entries(authStore.profiles).map(([profileId, profile]) => ({
+		id: profileId,
+		provider: profile.provider,
+		type: profile.type,
+		isExternal: false
+	}));
+	if (opts.json) {
+		const usage = includeUsage ? await loadProviderUsageSummary({ skipPluginAuthWithoutCredentialSource: true }) : void 0;
+		const chat = {};
+		for (const plugin of plugins) chat[plugin.id] = plugin.config.listAccountIds(cfg);
+		writeRuntimeJson(runtime, {
+			chat,
+			auth: authProfiles,
+			...usage ? { usage } : {}
+		});
+		return;
+	}
+	const lines = [];
+	lines.push(theme.heading("Chat channels:"));
+	for (const plugin of plugins) {
+		const accounts = plugin.config.listAccountIds(cfg);
+		if (!accounts || accounts.length === 0) continue;
+		for (const accountId of accounts) {
+			const snapshot = await buildChannelAccountSnapshot({
+				plugin,
+				cfg,
+				accountId
+			});
+			lines.push(formatAccountLine({
+				channel: plugin,
+				snapshot
+			}));
+		}
+	}
+	lines.push("");
+	lines.push(theme.heading("Auth providers (OAuth + API keys):"));
+	if (authProfiles.length === 0) lines.push(theme.muted("- none"));
+	else for (const profile of authProfiles) {
+		const external = profile.isExternal ? theme.muted(" (synced)") : "";
+		lines.push(`- ${theme.accent(profile.id)} (${theme.success(profile.type)}${external})`);
+	}
+	runtime.log(lines.join("\n"));
+	if (includeUsage) {
+		runtime.log("");
+		const usage = await loadUsageWithProgress(runtime);
+		if (usage) {
+			const usageLines = formatUsageReportLines(usage);
+			if (usageLines.length > 0) {
+				usageLines[0] = theme.accent(usageLines[0]);
+				runtime.log(usageLines.join("\n"));
+			}
+		}
+	}
+	runtime.log("");
+	runtime.log(`Docs: ${formatDocsLink("/gateway/configuration", "gateway/configuration")}`);
+}
+//#endregion
+export { channelsListCommand as t };

package/dist/list.probe-C_fNmtOl.js

@@ -0,0 +1,419 @@
+import { a as coerceSecretRef, u as normalizeSecretInputString } from "./types.secrets-ews2W8BF.js";
+import { i as resolveSecretRefString } from "./resolve-DeAojonS.js";
+import { n as findNormalizedProviderValue, r as normalizeProviderId } from "./provider-id-BLh32HP1.js";
+import { r as DEFAULT_PROVIDER } from "./defaults-DM8yIn8C.js";
+import { v as resolveDefaultAgentWorkspaceDir } from "./workspace-DkmPqUjp.js";
+import { b as resolveAgentWorkspaceDir, x as resolveDefaultAgentId } from "./agent-scope-CDjZLqNk.js";
+import { n as ensureAuthProfileStore } from "./store-Migb-HSP.js";
+import { t as resolveGenesisAgentDir } from "./agent-paths-C8JZWFei.js";
+import { x as parseModelRef } from "./model-selection-shared-DKTBpEsk.js";
+import "./model-selection-BJS5Z_AY.js";
+import { t as resolveEnvApiKey } from "./model-auth-env-BLGt-ENW.js";
+import { r as loadModelCatalog } from "./model-catalog-CXtye8rS.js";
+import { l as resolveSessionTranscriptsDirForAgent, o as resolveSessionTranscriptPath } from "./paths-DD6L4IvS.js";
+import { r as describeFailoverError } from "./failover-error-BHITafkz.js";
+import { i as resolveAuthProfileDisplayLabel } from "./auth-profiles-vW3-URAt.js";
+import { n as listProfilesForProvider } from "./profile-list-DxD5kVCL.js";
+import { n as resolveAuthProfileOrder, t as resolveAuthProfileEligibility } from "./order-CN1pCewQ.js";
+import { o as hasUsableCustomProviderApiKey } from "./model-auth-C8-hpEj4.js";
+import { r as formatMs } from "./shared-cdv7RlEL.js";
+import { f as redactSecrets } from "./format-zNAn_UkZ.js";
+import fs from "node:fs/promises";
+import crypto from "node:crypto";
+//#region src/commands/models/list.probe.ts
+const PROBE_PROMPT = "Reply with OK. Do not use tools.";
+let embeddedRunnerModulePromise;
+function loadEmbeddedRunnerModule() {
+	embeddedRunnerModulePromise ??= import("./pi-embedded-D5ZS7RLO.js");
+	return embeddedRunnerModulePromise;
+}
+function mapFailoverReasonToProbeStatus(reason) {
+	if (!reason) return "unknown";
+	if (reason === "auth" || reason === "auth_permanent") return "auth";
+	if (reason === "rate_limit" || reason === "overloaded") return "rate_limit";
+	if (reason === "billing") return "billing";
+	if (reason === "timeout") return "timeout";
+	if (reason === "model_not_found") return "format";
+	if (reason === "format") return "format";
+	return "unknown";
+}
+function buildCandidateMap(modelCandidates) {
+	const map = /* @__PURE__ */ new Map();
+	for (const raw of modelCandidates) {
+		const parsed = parseModelRef(raw ?? "", DEFAULT_PROVIDER);
+		if (!parsed) continue;
+		const list = map.get(parsed.provider) ?? [];
+		if (!list.includes(parsed.model)) list.push(parsed.model);
+		map.set(parsed.provider, list);
+	}
+	return map;
+}
+function selectProbeModel(params) {
+	const { provider, candidates, catalog } = params;
+	const direct = candidates.get(provider);
+	if (direct && direct.length > 0) return {
+		provider,
+		model: direct[0]
+	};
+	const fromCatalog = catalog.find((entry) => normalizeProviderId(entry.provider) === provider);
+	if (fromCatalog) return {
+		provider,
+		model: fromCatalog.id
+	};
+	return null;
+}
+function mapEligibilityReasonToProbeReasonCode(reasonCode) {
+	if (reasonCode === "missing_credential") return "missing_credential";
+	if (reasonCode === "expired") return "expired";
+	if (reasonCode === "invalid_expires") return "invalid_expires";
+	if (reasonCode === "unresolved_ref") return "unresolved_ref";
+	return "ineligible_profile";
+}
+function formatMissingCredentialProbeError(reasonCode) {
+	const legacyLine = "Auth profile credentials are missing or expired.";
+	if (reasonCode === "expired") return `${legacyLine}\n↳ Auth reason [expired]: token credentials are expired.`;
+	if (reasonCode === "invalid_expires") return `${legacyLine}\n↳ Auth reason [invalid_expires]: token expires must be a positive Unix ms timestamp.`;
+	if (reasonCode === "missing_credential") return `${legacyLine}\n↳ Auth reason [missing_credential]: no inline credential or SecretRef is configured.`;
+	if (reasonCode === "unresolved_ref") return `${legacyLine}\n↳ Auth reason [unresolved_ref]: configured SecretRef could not be resolved.`;
+	return `${legacyLine}\n↳ Auth reason [ineligible_profile]: profile is incompatible with provider config.`;
+}
+function resolveProbeSecretRef(profile, cfg) {
+	const defaults = cfg.secrets?.defaults;
+	if (profile.type === "api_key") {
+		if (normalizeSecretInputString(profile.key) !== void 0) return null;
+		return coerceSecretRef(profile.keyRef, defaults);
+	}
+	if (profile.type === "token") {
+		if (normalizeSecretInputString(profile.token) !== void 0) return null;
+		return coerceSecretRef(profile.tokenRef, defaults);
+	}
+	return null;
+}
+function formatUnresolvedRefProbeError(refLabel) {
+	return `Auth profile credentials are missing or expired.\n↳ Auth reason [unresolved_ref]: could not resolve SecretRef "${refLabel}".`;
+}
+async function maybeResolveUnresolvedRefIssue(params) {
+	if (!params.profile) return null;
+	const ref = resolveProbeSecretRef(params.profile, params.cfg);
+	if (!ref) return null;
+	try {
+		await resolveSecretRefString(ref, {
+			config: params.cfg,
+			env: process.env,
+			cache: params.cache
+		});
+		return null;
+	} catch {
+		return {
+			reasonCode: "unresolved_ref",
+			error: formatUnresolvedRefProbeError(`${ref.source}:${ref.provider}:${ref.id}`)
+		};
+	}
+}
+async function buildProbeTargets(params) {
+	const { cfg, providers, modelCandidates, options } = params;
+	const store = ensureAuthProfileStore();
+	const providerFilter = options.provider?.trim();
+	const providerFilterKey = providerFilter ? normalizeProviderId(providerFilter) : null;
+	const profileFilter = new Set((options.profileIds ?? []).map((id) => id.trim()).filter(Boolean));
+	const refResolveCache = {};
+	const catalog = await loadModelCatalog({ config: cfg });
+	const candidates = buildCandidateMap(modelCandidates);
+	const targets = [];
+	const results = [];
+	for (const provider of providers) {
+		const providerKey = normalizeProviderId(provider);
+		if (providerFilterKey && providerKey !== providerFilterKey) continue;
+		const model = selectProbeModel({
+			provider: providerKey,
+			candidates,
+			catalog
+		});
+		const profileIds = listProfilesForProvider(store, providerKey);
+		const explicitOrder = findNormalizedProviderValue(store.order, providerKey) ?? findNormalizedProviderValue(cfg?.auth?.order, providerKey);
+		const allowedProfiles = explicitOrder && explicitOrder.length > 0 ? new Set(resolveAuthProfileOrder({
+			cfg,
+			store,
+			provider: providerKey
+		})) : null;
+		const filteredProfiles = profileFilter.size ? profileIds.filter((id) => profileFilter.has(id)) : profileIds;
+		if (filteredProfiles.length > 0) {
+			for (const profileId of filteredProfiles) {
+				const profile = store.profiles[profileId];
+				const mode = profile?.type;
+				const label = resolveAuthProfileDisplayLabel({
+					cfg,
+					store,
+					profileId
+				});
+				if (explicitOrder && !explicitOrder.includes(profileId)) {
+					results.push({
+						provider: providerKey,
+						profileId,
+						model: model ? `${model.provider}/${model.model}` : void 0,
+						label,
+						source: "profile",
+						mode,
+						status: "unknown",
+						reasonCode: "excluded_by_auth_order",
+						error: "Excluded by auth.order for this provider."
+					});
+					continue;
+				}
+				if (allowedProfiles && !allowedProfiles.has(profileId)) {
+					const reasonCode = mapEligibilityReasonToProbeReasonCode(resolveAuthProfileEligibility({
+						cfg,
+						store,
+						provider: providerKey,
+						profileId
+					}).reasonCode);
+					results.push({
+						provider: providerKey,
+						model: model ? `${model.provider}/${model.model}` : void 0,
+						profileId,
+						label,
+						source: "profile",
+						mode,
+						status: "unknown",
+						reasonCode,
+						error: formatMissingCredentialProbeError(reasonCode)
+					});
+					continue;
+				}
+				const unresolvedRefIssue = await maybeResolveUnresolvedRefIssue({
+					cfg,
+					profile,
+					cache: refResolveCache
+				});
+				if (unresolvedRefIssue) {
+					results.push({
+						provider: providerKey,
+						model: model ? `${model.provider}/${model.model}` : void 0,
+						profileId,
+						label,
+						source: "profile",
+						mode,
+						status: "unknown",
+						reasonCode: unresolvedRefIssue.reasonCode,
+						error: unresolvedRefIssue.error
+					});
+					continue;
+				}
+				if (!model) {
+					results.push({
+						provider: providerKey,
+						model: void 0,
+						profileId,
+						label,
+						source: "profile",
+						mode,
+						status: "no_model",
+						reasonCode: "no_model",
+						error: "No model available for probe"
+					});
+					continue;
+				}
+				targets.push({
+					provider: providerKey,
+					model,
+					profileId,
+					label,
+					source: "profile",
+					mode
+				});
+			}
+			continue;
+		}
+		if (profileFilter.size > 0) continue;
+		const envKey = resolveEnvApiKey(providerKey);
+		const hasUsableModelsJsonKey = hasUsableCustomProviderApiKey(cfg, providerKey);
+		if (!envKey && !hasUsableModelsJsonKey) continue;
+		const label = envKey ? "env" : "models.json";
+		const source = envKey ? "env" : "models.json";
+		const mode = envKey?.source.includes("OAUTH_TOKEN") ? "oauth" : "api_key";
+		if (!model) {
+			results.push({
+				provider: providerKey,
+				model: void 0,
+				label,
+				source,
+				mode,
+				status: "no_model",
+				reasonCode: "no_model",
+				error: "No model available for probe"
+			});
+			continue;
+		}
+		targets.push({
+			provider: providerKey,
+			model,
+			label,
+			source,
+			mode
+		});
+	}
+	return {
+		targets,
+		results
+	};
+}
+async function probeTarget(params) {
+	const { cfg, agentId, agentDir, workspaceDir, sessionDir, target, timeoutMs, maxTokens } = params;
+	if (!target.model) return {
+		provider: target.provider,
+		model: void 0,
+		profileId: target.profileId,
+		label: target.label,
+		source: target.source,
+		mode: target.mode,
+		status: "no_model",
+		reasonCode: "no_model",
+		error: "No model available for probe"
+	};
+	const model = target.model;
+	const sessionId = `probe-${target.provider}-${crypto.randomUUID()}`;
+	const sessionFile = resolveSessionTranscriptPath(sessionId, agentId);
+	await fs.mkdir(sessionDir, { recursive: true });
+	const start = Date.now();
+	const buildResult = (status, error) => ({
+		provider: target.provider,
+		model: `${model.provider}/${model.model}`,
+		profileId: target.profileId,
+		label: target.label,
+		source: target.source,
+		mode: target.mode,
+		status,
+		...error ? { error } : {},
+		latencyMs: Date.now() - start
+	});
+	try {
+		const { runEmbeddedPiAgent } = await loadEmbeddedRunnerModule();
+		await runEmbeddedPiAgent({
+			sessionId,
+			sessionFile,
+			agentId,
+			workspaceDir,
+			agentDir,
+			config: cfg,
+			prompt: PROBE_PROMPT,
+			provider: target.model.provider,
+			model: target.model.model,
+			authProfileId: target.profileId,
+			authProfileIdSource: target.profileId ? "user" : void 0,
+			timeoutMs,
+			runId: `probe-${crypto.randomUUID()}`,
+			lane: `auth-probe:${target.provider}:${target.profileId ?? target.source}`,
+			thinkLevel: "off",
+			reasoningLevel: "off",
+			verboseLevel: "off",
+			streamParams: { maxTokens },
+			disableTools: true,
+			cleanupBundleMcpOnRunEnd: true
+		});
+		return buildResult("ok");
+	} catch (err) {
+		const described = describeFailoverError(err);
+		return buildResult(mapFailoverReasonToProbeStatus(described.reason), redactSecrets(described.message));
+	}
+}
+async function runTargetsWithConcurrency(params) {
+	const { cfg, targets, timeoutMs, maxTokens, onProgress } = params;
+	const concurrency = Math.max(1, Math.min(targets.length || 1, params.concurrency));
+	const agentId = resolveDefaultAgentId(cfg);
+	const agentDir = resolveGenesisAgentDir();
+	const workspaceDir = resolveAgentWorkspaceDir(cfg, agentId) ?? resolveDefaultAgentWorkspaceDir();
+	const sessionDir = resolveSessionTranscriptsDirForAgent(agentId);
+	await fs.mkdir(workspaceDir, { recursive: true });
+	let completed = 0;
+	const results = Array.from({ length: targets.length });
+	let cursor = 0;
+	const worker = async () => {
+		while (true) {
+			const index = cursor;
+			cursor += 1;
+			if (index >= targets.length) return;
+			const target = targets[index];
+			onProgress?.({
+				completed,
+				total: targets.length,
+				label: `Probing ${target.provider}${target.profileId ? ` (${target.label})` : ""}`
+			});
+			results[index] = await probeTarget({
+				cfg,
+				agentId,
+				agentDir,
+				workspaceDir,
+				sessionDir,
+				target,
+				timeoutMs,
+				maxTokens
+			});
+			completed += 1;
+			onProgress?.({
+				completed,
+				total: targets.length
+			});
+		}
+	};
+	await Promise.all(Array.from({ length: concurrency }, () => worker()));
+	return results.filter((entry) => Boolean(entry));
+}
+async function runAuthProbes(params) {
+	const startedAt = Date.now();
+	const plan = await buildProbeTargets({
+		cfg: params.cfg,
+		providers: params.providers,
+		modelCandidates: params.modelCandidates,
+		options: params.options
+	});
+	const totalTargets = plan.targets.length;
+	params.onProgress?.({
+		completed: 0,
+		total: totalTargets
+	});
+	const results = totalTargets ? await runTargetsWithConcurrency({
+		cfg: params.cfg,
+		targets: plan.targets,
+		timeoutMs: params.options.timeoutMs,
+		maxTokens: params.options.maxTokens,
+		concurrency: params.options.concurrency,
+		onProgress: params.onProgress
+	}) : [];
+	const finishedAt = Date.now();
+	return {
+		startedAt,
+		finishedAt,
+		durationMs: finishedAt - startedAt,
+		totalTargets,
+		options: params.options,
+		results: [...plan.results, ...results]
+	};
+}
+function formatProbeLatency(latencyMs) {
+	if (!latencyMs && latencyMs !== 0) return "-";
+	return formatMs(latencyMs);
+}
+function groupProbeResults(results) {
+	const map = /* @__PURE__ */ new Map();
+	for (const result of results) {
+		const list = map.get(result.provider) ?? [];
+		list.push(result);
+		map.set(result.provider, list);
+	}
+	return map;
+}
+function sortProbeResults(results) {
+	return results.slice().toSorted((a, b) => {
+		const provider = a.provider.localeCompare(b.provider);
+		if (provider !== 0) return provider;
+		const aLabel = a.label || a.profileId || "";
+		const bLabel = b.label || b.profileId || "";
+		return aLabel.localeCompare(bLabel);
+	});
+}
+function describeProbeSummary(summary) {
+	if (summary.totalTargets === 0) return "No probe targets.";
+	return `Probed ${summary.totalTargets} target${summary.totalTargets === 1 ? "" : "s"} in ${formatMs(summary.durationMs)}`;
+}
+//#endregion
+export { buildProbeTargets, describeProbeSummary, formatProbeLatency, groupProbeResults, mapFailoverReasonToProbeStatus, runAuthProbes, sortProbeResults };

package/dist/llm-slug-generator-BxS18aoP.js

@@ -0,0 +1,79 @@
+import { a as normalizeLowercaseStringOrEmpty } from "./string-coerce-C1IzJjqi.js";
+import { t as createSubsystemLogger } from "./subsystem-DTMy5YmO.js";
+import { r as DEFAULT_PROVIDER } from "./defaults-DM8yIn8C.js";
+import { b as resolveAgentWorkspaceDir, n as resolveAgentEffectiveModelPrimary, x as resolveDefaultAgentId, y as resolveAgentDir } from "./agent-scope-CDjZLqNk.js";
+import { x as parseModelRef } from "./model-selection-shared-DKTBpEsk.js";
+import "./model-selection-BJS5Z_AY.js";
+import { t as resolveAgentTimeoutMs } from "./timeout-BSZPJ2oJ.js";
+import { t as runEmbeddedPiAgent } from "./pi-embedded-CFdaZ8Aq.js";
+import path from "node:path";
+import os from "node:os";
+import fs from "node:fs/promises";
+//#region src/hooks/llm-slug-generator.ts
+/**
+* LLM-based slug generator for session memory filenames
+*/
+const log = createSubsystemLogger("llm-slug-generator");
+const DEFAULT_SLUG_GENERATOR_TIMEOUT_MS = 15e3;
+function resolveSlugGeneratorTimeoutMs(cfg) {
+	const configuredTimeoutSeconds = cfg.agents?.defaults?.timeoutSeconds;
+	if (typeof configuredTimeoutSeconds !== "number" || !Number.isFinite(configuredTimeoutSeconds)) return DEFAULT_SLUG_GENERATOR_TIMEOUT_MS;
+	return resolveAgentTimeoutMs({ cfg });
+}
+/**
+* Generate a short 1-2 word filename slug from session content using LLM
+*/
+async function generateSlugViaLLM(params) {
+	let tempSessionFile = null;
+	try {
+		const agentId = resolveDefaultAgentId(params.cfg);
+		const workspaceDir = resolveAgentWorkspaceDir(params.cfg, agentId);
+		const agentDir = resolveAgentDir(params.cfg, agentId);
+		const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "genesis-slug-"));
+		tempSessionFile = path.join(tempDir, "session.jsonl");
+		const prompt = `Based on this conversation, generate a short 1-2 word filename slug (lowercase, hyphen-separated, no file extension).
+
+Conversation summary:
+${params.sessionContent.slice(0, 2e3)}
+
+Reply with ONLY the slug, nothing else. Examples: "vendor-pitch", "api-design", "bug-fix"`;
+		const modelRef = resolveAgentEffectiveModelPrimary(params.cfg, agentId);
+		const parsed = modelRef ? parseModelRef(modelRef, DEFAULT_PROVIDER) : null;
+		const provider = parsed?.provider ?? "openai";
+		const model = parsed?.model ?? "gpt-5.5";
+		const timeoutMs = resolveSlugGeneratorTimeoutMs(params.cfg);
+		const result = await runEmbeddedPiAgent({
+			sessionId: `slug-generator-${Date.now()}`,
+			sessionKey: "temp:slug-generator",
+			agentId,
+			sessionFile: tempSessionFile,
+			workspaceDir,
+			agentDir,
+			config: params.cfg,
+			prompt,
+			provider,
+			model,
+			timeoutMs,
+			runId: `slug-gen-${Date.now()}`,
+			cleanupBundleMcpOnRunEnd: true
+		});
+		if (result.payloads && result.payloads.length > 0) {
+			const text = result.payloads[0]?.text;
+			if (text) return normalizeLowercaseStringOrEmpty(text).replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 30) || null;
+		}
+		return null;
+	} catch (err) {
+		const message = err instanceof Error ? err.stack ?? err.message : String(err);
+		log.error(`Failed to generate slug: ${message}`);
+		return null;
+	} finally {
+		if (tempSessionFile) try {
+			await fs.rm(path.dirname(tempSessionFile), {
+				recursive: true,
+				force: true
+			});
+		} catch {}
+	}
+}
+//#endregion
+export { generateSlugViaLLM as t };

package/dist/llm-slug-generator.js

@@ -1,2 +1,2 @@
-import { t as generateSlugViaLLM } from "./llm-slug-generator-BGBzQWBi.js";
+import { t as generateSlugViaLLM } from "./llm-slug-generator-BxS18aoP.js";
 export { generateSlugViaLLM };

package/dist/load-config-D93X3FB6.js

@@ -0,0 +1,35 @@
+import { i as getRuntimeConfig, m as readSourceConfigSnapshotForWrite } from "./io-DK8qz7fQ.js";
+import { d as setRuntimeConfigSnapshot } from "./runtime-snapshot-BsPVTNgF.js";
+import "./config-978YFBb1.js";
+import "./command-secret-gateway-CeBdQ0UB.js";
+import { i as getModelsCommandSecretTargetIds } from "./command-secret-targets-0Wyup4PV.js";
+import { t as resolveCommandConfigWithSecrets } from "./command-config-resolution-41LV2AE4.js";
+//#region src/commands/models/load-config.ts
+async function loadSourceConfigSnapshot(fallback) {
+	try {
+		const { snapshot } = await readSourceConfigSnapshotForWrite();
+		if (snapshot.valid) return snapshot.sourceConfig;
+	} catch {}
+	return fallback;
+}
+async function loadModelsConfigWithSource(params) {
+	const runtimeConfig = getRuntimeConfig();
+	const sourceConfig = await loadSourceConfigSnapshot(runtimeConfig);
+	const { resolvedConfig, diagnostics } = await resolveCommandConfigWithSecrets({
+		config: runtimeConfig,
+		commandName: params.commandName,
+		targetIds: getModelsCommandSecretTargetIds(),
+		runtime: params.runtime
+	});
+	setRuntimeConfigSnapshot(resolvedConfig, sourceConfig);
+	return {
+		sourceConfig,
+		resolvedConfig,
+		diagnostics
+	};
+}
+async function loadModelsConfig(params) {
+	return (await loadModelsConfigWithSource(params)).resolvedConfig;
+}
+//#endregion
+export { loadModelsConfigWithSource as n, loadModelsConfig as t };

package/dist/local-dispatch.runtime-DlNzE_mQ.js

@@ -0,0 +1,8 @@
+import { a as createBrowserRouteDispatcher, r as startBrowserControlServiceFromConfig, t as createBrowserControlContext } from "./control-service-Iw7H8uVc.js";
+//#region extensions/browser/src/browser/local-dispatch.runtime.ts
+async function dispatchBrowserControlRequest(req) {
+	if (!await startBrowserControlServiceFromConfig()) throw new Error("browser control disabled");
+	return await createBrowserRouteDispatcher(createBrowserControlContext()).dispatch(req);
+}
+//#endregion
+export { dispatchBrowserControlRequest };

package/dist/local-dispatch.runtime.js

@@ -1 +1 @@
-export * from "./local-dispatch.runtime-CfgwapOU.js";
+export * from "./local-dispatch.runtime-DlNzE_mQ.js";