@spacebar_ai/moldclaw-core 2026.3.14 → 2026.3.16

package/dist/line-8rsNbJCP.js

@@ -0,0 +1,530 @@
+import { t as formatDocsLink } from "./links-C5I443Xb.js";
+import { Ag as setTopLevelChannelDmPolicyWithAllowFrom, Ev as attachFooterText, Mg as splitSetupEntries, Og as setSetupChannelEnabled } from "./auth-profiles-9zZdaXJK.js";
+import { t as DEFAULT_ACCOUNT_ID } from "./account-id-O4Og6DrK.js";
+import { i as resolveLineAccount, n as normalizeAccountId, t as listLineAccountIds } from "./accounts-BCaV8MsT.js";
+import { z } from "zod";
+//#region src/line/flex-templates/basic-cards.ts
+/**
+* Create an info card with title, body, and optional footer
+*
+* Editorial design: Clean hierarchy with accent bar, generous spacing,
+* and subtle background zones for visual separation.
+*/
+function createInfoCard(title, body, footer) {
+	const bubble = {
+		type: "bubble",
+		size: "mega",
+		body: {
+			type: "box",
+			layout: "vertical",
+			contents: [{
+				type: "box",
+				layout: "horizontal",
+				contents: [{
+					type: "box",
+					layout: "vertical",
+					contents: [],
+					width: "4px",
+					backgroundColor: "#06C755",
+					cornerRadius: "2px"
+				}, {
+					type: "text",
+					text: title,
+					weight: "bold",
+					size: "xl",
+					color: "#111111",
+					wrap: true,
+					flex: 1,
+					margin: "lg"
+				}]
+			}, {
+				type: "box",
+				layout: "vertical",
+				contents: [{
+					type: "text",
+					text: body,
+					size: "md",
+					color: "#444444",
+					wrap: true,
+					lineSpacing: "6px"
+				}],
+				margin: "xl",
+				paddingAll: "lg",
+				backgroundColor: "#F8F9FA",
+				cornerRadius: "lg"
+			}],
+			paddingAll: "xl",
+			backgroundColor: "#FFFFFF"
+		}
+	};
+	if (footer) attachFooterText(bubble, footer);
+	return bubble;
+}
+/**
+* Create a list card with title and multiple items
+*
+* Editorial design: Numbered/bulleted list with clear visual hierarchy,
+* accent dots for each item, and generous spacing.
+*/
+function createListCard(title, items) {
+	const itemContents = items.slice(0, 8).map((item, index) => {
+		const itemContents = [{
+			type: "text",
+			text: item.title,
+			size: "md",
+			weight: "bold",
+			color: "#1a1a1a",
+			wrap: true
+		}];
+		if (item.subtitle) itemContents.push({
+			type: "text",
+			text: item.subtitle,
+			size: "sm",
+			color: "#888888",
+			wrap: true,
+			margin: "xs"
+		});
+		const itemBox = {
+			type: "box",
+			layout: "horizontal",
+			contents: [{
+				type: "box",
+				layout: "vertical",
+				contents: [{
+					type: "box",
+					layout: "vertical",
+					contents: [],
+					width: "8px",
+					height: "8px",
+					backgroundColor: index === 0 ? "#06C755" : "#DDDDDD",
+					cornerRadius: "4px"
+				}],
+				width: "20px",
+				alignItems: "center",
+				paddingTop: "sm"
+			}, {
+				type: "box",
+				layout: "vertical",
+				contents: itemContents,
+				flex: 1
+			}],
+			margin: index > 0 ? "lg" : void 0
+		};
+		if (item.action) itemBox.action = item.action;
+		return itemBox;
+	});
+	return {
+		type: "bubble",
+		size: "mega",
+		body: {
+			type: "box",
+			layout: "vertical",
+			contents: [
+				{
+					type: "text",
+					text: title,
+					weight: "bold",
+					size: "xl",
+					color: "#111111",
+					wrap: true
+				},
+				{
+					type: "separator",
+					margin: "lg",
+					color: "#EEEEEE"
+				},
+				{
+					type: "box",
+					layout: "vertical",
+					contents: itemContents,
+					margin: "lg"
+				}
+			],
+			paddingAll: "xl",
+			backgroundColor: "#FFFFFF"
+		}
+	};
+}
+/**
+* Create an image card with image, title, and optional body text
+*/
+function createImageCard(imageUrl, title, body, options) {
+	const bubble = {
+		type: "bubble",
+		hero: {
+			type: "image",
+			url: imageUrl,
+			size: "full",
+			aspectRatio: options?.aspectRatio ?? "20:13",
+			aspectMode: options?.aspectMode ?? "cover",
+			action: options?.action
+		},
+		body: {
+			type: "box",
+			layout: "vertical",
+			contents: [{
+				type: "text",
+				text: title,
+				weight: "bold",
+				size: "xl",
+				wrap: true
+			}],
+			paddingAll: "lg"
+		}
+	};
+	if (body && bubble.body) bubble.body.contents.push({
+		type: "text",
+		text: body,
+		size: "md",
+		wrap: true,
+		margin: "md",
+		color: "#666666"
+	});
+	return bubble;
+}
+/**
+* Create an action card with title, body, and action buttons
+*/
+function createActionCard(title, body, actions, options) {
+	const bubble = {
+		type: "bubble",
+		body: {
+			type: "box",
+			layout: "vertical",
+			contents: [{
+				type: "text",
+				text: title,
+				weight: "bold",
+				size: "xl",
+				wrap: true
+			}, {
+				type: "text",
+				text: body,
+				size: "md",
+				wrap: true,
+				margin: "md",
+				color: "#666666"
+			}],
+			paddingAll: "lg"
+		},
+		footer: {
+			type: "box",
+			layout: "vertical",
+			contents: actions.slice(0, 4).map((action, index) => ({
+				type: "button",
+				action: action.action,
+				style: index === 0 ? "primary" : "secondary",
+				margin: index > 0 ? "sm" : void 0
+			})),
+			paddingAll: "md"
+		}
+	};
+	if (options?.imageUrl) bubble.hero = {
+		type: "image",
+		url: options.imageUrl,
+		size: "full",
+		aspectRatio: options.aspectRatio ?? "20:13",
+		aspectMode: "cover"
+	};
+	return bubble;
+}
+//#endregion
+//#region extensions/line/src/setup-core.ts
+function patchLineAccountConfig(params) {
+	const accountId = normalizeAccountId(params.accountId);
+	const lineConfig = params.cfg.channels?.line ?? {};
+	const clearFields = params.clearFields ?? [];
+	if (accountId === "default") {
+		const nextLine = { ...lineConfig };
+		for (const field of clearFields) delete nextLine[field];
+		return {
+			...params.cfg,
+			channels: {
+				...params.cfg.channels,
+				line: {
+					...nextLine,
+					...params.enabled ? { enabled: true } : {},
+					...params.patch
+				}
+			}
+		};
+	}
+	const nextAccount = { ...lineConfig.accounts?.[accountId] ?? {} };
+	for (const field of clearFields) delete nextAccount[field];
+	return {
+		...params.cfg,
+		channels: {
+			...params.cfg.channels,
+			line: {
+				...lineConfig,
+				...params.enabled ? { enabled: true } : {},
+				accounts: {
+					...lineConfig.accounts,
+					[accountId]: {
+						...nextAccount,
+						...params.enabled ? { enabled: true } : {},
+						...params.patch
+					}
+				}
+			}
+		}
+	};
+}
+function isLineConfigured(cfg, accountId) {
+	const resolved = resolveLineAccount({
+		cfg,
+		accountId
+	});
+	return Boolean(resolved.channelAccessToken.trim() && resolved.channelSecret.trim());
+}
+function parseLineAllowFromId(raw) {
+	const trimmed = raw.trim().replace(/^line:(?:user:)?/i, "");
+	if (!/^U[a-f0-9]{32}$/i.test(trimmed)) return null;
+	return trimmed;
+}
+const lineSetupAdapter = {
+	resolveAccountId: ({ accountId }) => normalizeAccountId(accountId),
+	applyAccountName: ({ cfg, accountId, name }) => patchLineAccountConfig({
+		cfg,
+		accountId,
+		patch: name?.trim() ? { name: name.trim() } : {}
+	}),
+	validateInput: ({ accountId, input }) => {
+		const typedInput = input;
+		if (typedInput.useEnv && accountId !== "default") return "LINE_CHANNEL_ACCESS_TOKEN can only be used for the default account.";
+		if (!typedInput.useEnv && !typedInput.channelAccessToken && !typedInput.tokenFile) return "LINE requires channelAccessToken or --token-file (or --use-env).";
+		if (!typedInput.useEnv && !typedInput.channelSecret && !typedInput.secretFile) return "LINE requires channelSecret or --secret-file (or --use-env).";
+		return null;
+	},
+	applyAccountConfig: ({ cfg, accountId, input }) => {
+		const typedInput = input;
+		const normalizedAccountId = normalizeAccountId(accountId);
+		if (normalizedAccountId === "default") return patchLineAccountConfig({
+			cfg,
+			accountId: normalizedAccountId,
+			enabled: true,
+			clearFields: typedInput.useEnv ? [
+				"channelAccessToken",
+				"channelSecret",
+				"tokenFile",
+				"secretFile"
+			] : void 0,
+			patch: typedInput.useEnv ? {} : {
+				...typedInput.tokenFile ? { tokenFile: typedInput.tokenFile } : typedInput.channelAccessToken ? { channelAccessToken: typedInput.channelAccessToken } : {},
+				...typedInput.secretFile ? { secretFile: typedInput.secretFile } : typedInput.channelSecret ? { channelSecret: typedInput.channelSecret } : {}
+			}
+		});
+		return patchLineAccountConfig({
+			cfg,
+			accountId: normalizedAccountId,
+			enabled: true,
+			patch: {
+				...typedInput.tokenFile ? { tokenFile: typedInput.tokenFile } : typedInput.channelAccessToken ? { channelAccessToken: typedInput.channelAccessToken } : {},
+				...typedInput.secretFile ? { secretFile: typedInput.secretFile } : typedInput.channelSecret ? { channelSecret: typedInput.channelSecret } : {}
+			}
+		});
+	}
+};
+//#endregion
+//#region extensions/line/src/setup-surface.ts
+const channel = "line";
+const LINE_SETUP_HELP_LINES = [
+	"1) Open the LINE Developers Console and create or pick a Messaging API channel",
+	"2) Copy the channel access token and channel secret",
+	"3) Enable Use webhook in the Messaging API settings",
+	"4) Point the webhook at https://<gateway-host>/line/webhook",
+	`Docs: ${formatDocsLink("/channels/line", "channels/line")}`
+];
+const LINE_ALLOW_FROM_HELP_LINES = [
+	"Allowlist LINE DMs by user id.",
+	"LINE ids are case-sensitive.",
+	"Examples:",
+	"- U1234567890abcdef1234567890abcdef",
+	"- line:user:U1234567890abcdef1234567890abcdef",
+	"Multiple entries: comma-separated.",
+	`Docs: ${formatDocsLink("/channels/line", "channels/line")}`
+];
+const lineSetupWizard = {
+	channel,
+	status: {
+		configuredLabel: "configured",
+		unconfiguredLabel: "needs token + secret",
+		configuredHint: "configured",
+		unconfiguredHint: "needs token + secret",
+		configuredScore: 1,
+		unconfiguredScore: 0,
+		resolveConfigured: ({ cfg }) => listLineAccountIds(cfg).some((accountId) => isLineConfigured(cfg, accountId)),
+		resolveStatusLines: ({ cfg, configured }) => [`LINE: ${configured ? "configured" : "needs token + secret"}`, `Accounts: ${listLineAccountIds(cfg).length || 0}`]
+	},
+	introNote: {
+		title: "LINE Messaging API",
+		lines: LINE_SETUP_HELP_LINES,
+		shouldShow: ({ cfg, accountId }) => !isLineConfigured(cfg, accountId)
+	},
+	credentials: [{
+		inputKey: "token",
+		providerHint: channel,
+		credentialLabel: "channel access token",
+		preferredEnvVar: "LINE_CHANNEL_ACCESS_TOKEN",
+		helpTitle: "LINE Messaging API",
+		helpLines: LINE_SETUP_HELP_LINES,
+		envPrompt: "LINE_CHANNEL_ACCESS_TOKEN detected. Use env var?",
+		keepPrompt: "LINE channel access token already configured. Keep it?",
+		inputPrompt: "Enter LINE channel access token",
+		allowEnv: ({ accountId }) => accountId === DEFAULT_ACCOUNT_ID,
+		inspect: ({ cfg, accountId }) => {
+			const resolved = resolveLineAccount({
+				cfg,
+				accountId
+			});
+			return {
+				accountConfigured: Boolean(resolved.channelAccessToken.trim() && resolved.channelSecret.trim()),
+				hasConfiguredValue: Boolean(resolved.config.channelAccessToken?.trim() || resolved.config.tokenFile?.trim()),
+				resolvedValue: resolved.channelAccessToken.trim() || void 0,
+				envValue: accountId === "default" ? process.env.LINE_CHANNEL_ACCESS_TOKEN?.trim() || void 0 : void 0
+			};
+		},
+		applyUseEnv: ({ cfg, accountId }) => patchLineAccountConfig({
+			cfg,
+			accountId,
+			enabled: true,
+			clearFields: ["channelAccessToken", "tokenFile"],
+			patch: {}
+		}),
+		applySet: ({ cfg, accountId, resolvedValue }) => patchLineAccountConfig({
+			cfg,
+			accountId,
+			enabled: true,
+			clearFields: ["tokenFile"],
+			patch: { channelAccessToken: resolvedValue }
+		})
+	}, {
+		inputKey: "password",
+		providerHint: "line-secret",
+		credentialLabel: "channel secret",
+		preferredEnvVar: "LINE_CHANNEL_SECRET",
+		helpTitle: "LINE Messaging API",
+		helpLines: LINE_SETUP_HELP_LINES,
+		envPrompt: "LINE_CHANNEL_SECRET detected. Use env var?",
+		keepPrompt: "LINE channel secret already configured. Keep it?",
+		inputPrompt: "Enter LINE channel secret",
+		allowEnv: ({ accountId }) => accountId === DEFAULT_ACCOUNT_ID,
+		inspect: ({ cfg, accountId }) => {
+			const resolved = resolveLineAccount({
+				cfg,
+				accountId
+			});
+			return {
+				accountConfigured: Boolean(resolved.channelAccessToken.trim() && resolved.channelSecret.trim()),
+				hasConfiguredValue: Boolean(resolved.config.channelSecret?.trim() || resolved.config.secretFile?.trim()),
+				resolvedValue: resolved.channelSecret.trim() || void 0,
+				envValue: accountId === "default" ? process.env.LINE_CHANNEL_SECRET?.trim() || void 0 : void 0
+			};
+		},
+		applyUseEnv: ({ cfg, accountId }) => patchLineAccountConfig({
+			cfg,
+			accountId,
+			enabled: true,
+			clearFields: ["channelSecret", "secretFile"],
+			patch: {}
+		}),
+		applySet: ({ cfg, accountId, resolvedValue }) => patchLineAccountConfig({
+			cfg,
+			accountId,
+			enabled: true,
+			clearFields: ["secretFile"],
+			patch: { channelSecret: resolvedValue }
+		})
+	}],
+	allowFrom: {
+		helpTitle: "LINE allowlist",
+		helpLines: LINE_ALLOW_FROM_HELP_LINES,
+		message: "LINE allowFrom (user id)",
+		placeholder: "U1234567890abcdef1234567890abcdef",
+		invalidWithoutCredentialNote: "LINE allowFrom requires raw user ids like U1234567890abcdef1234567890abcdef.",
+		parseInputs: splitSetupEntries,
+		parseId: parseLineAllowFromId,
+		resolveEntries: async ({ entries }) => entries.map((entry) => {
+			const id = parseLineAllowFromId(entry);
+			return {
+				input: entry,
+				resolved: Boolean(id),
+				id
+			};
+		}),
+		apply: ({ cfg, accountId, allowFrom }) => patchLineAccountConfig({
+			cfg,
+			accountId,
+			enabled: true,
+			patch: {
+				dmPolicy: "allowlist",
+				allowFrom
+			}
+		})
+	},
+	dmPolicy: {
+		label: "LINE",
+		channel,
+		policyKey: "channels.line.dmPolicy",
+		allowFromKey: "channels.line.allowFrom",
+		getCurrent: (cfg) => cfg.channels?.line?.dmPolicy ?? "pairing",
+		setPolicy: (cfg, policy) => setTopLevelChannelDmPolicyWithAllowFrom({
+			cfg,
+			channel,
+			dmPolicy: policy
+		})
+	},
+	completionNote: {
+		title: "LINE webhook",
+		lines: [
+			"Enable Use webhook in the LINE console after saving credentials.",
+			"Default webhook URL: https://<gateway-host>/line/webhook",
+			"If you set channels.line.webhookPath, update the URL to match.",
+			`Docs: ${formatDocsLink("/channels/line", "channels/line")}`
+		]
+	},
+	disable: (cfg) => setSetupChannelEnabled(cfg, channel, false)
+};
+//#endregion
+//#region src/line/config-schema.ts
+const DmPolicySchema = z.enum([
+	"open",
+	"allowlist",
+	"pairing",
+	"disabled"
+]);
+const GroupPolicySchema = z.enum([
+	"open",
+	"allowlist",
+	"disabled"
+]);
+const LineCommonConfigSchema = z.object({
+	enabled: z.boolean().optional(),
+	channelAccessToken: z.string().optional(),
+	channelSecret: z.string().optional(),
+	tokenFile: z.string().optional(),
+	secretFile: z.string().optional(),
+	name: z.string().optional(),
+	allowFrom: z.array(z.union([z.string(), z.number()])).optional(),
+	groupAllowFrom: z.array(z.union([z.string(), z.number()])).optional(),
+	dmPolicy: DmPolicySchema.optional().default("pairing"),
+	groupPolicy: GroupPolicySchema.optional().default("allowlist"),
+	responsePrefix: z.string().optional(),
+	mediaMaxMb: z.number().optional(),
+	webhookPath: z.string().optional()
+});
+const LineGroupConfigSchema = z.object({
+	enabled: z.boolean().optional(),
+	allowFrom: z.array(z.union([z.string(), z.number()])).optional(),
+	requireMention: z.boolean().optional(),
+	systemPrompt: z.string().optional(),
+	skills: z.array(z.string()).optional()
+}).strict();
+const LineAccountConfigSchema = LineCommonConfigSchema.extend({ groups: z.record(z.string(), LineGroupConfigSchema.optional()).optional() }).strict();
+const LineConfigSchema = LineCommonConfigSchema.extend({
+	accounts: z.record(z.string(), LineAccountConfigSchema.optional()).optional(),
+	defaultAccount: z.string().optional(),
+	groups: z.record(z.string(), LineGroupConfigSchema.optional()).optional()
+}).strict();
+//#endregion
+export { createImageCard as a, createActionCard as i, lineSetupWizard as n, createInfoCard as o, lineSetupAdapter as r, createListCard as s, LineConfigSchema as t };

package/dist/line-D_cvIf6B.d.ts

@@ -0,0 +1,75 @@
+import { eO as ChannelSetupWizard, xi as ChannelSetupAdapter } from "./types-DBhDdMQd.js";
+import { z } from "zod";
+
+//#region extensions/line/src/setup-core.d.ts
+declare const lineSetupAdapter: ChannelSetupAdapter;
+//#endregion
+//#region extensions/line/src/setup-surface.d.ts
+declare const lineSetupWizard: ChannelSetupWizard;
+//#endregion
+//#region src/line/config-schema.d.ts
+declare const LineConfigSchema: z.ZodObject<{
+  enabled: z.ZodOptional<z.ZodBoolean>;
+  channelAccessToken: z.ZodOptional<z.ZodString>;
+  channelSecret: z.ZodOptional<z.ZodString>;
+  tokenFile: z.ZodOptional<z.ZodString>;
+  secretFile: z.ZodOptional<z.ZodString>;
+  name: z.ZodOptional<z.ZodString>;
+  allowFrom: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+  groupAllowFrom: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+  dmPolicy: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+    disabled: "disabled";
+    open: "open";
+    allowlist: "allowlist";
+    pairing: "pairing";
+  }>>>;
+  groupPolicy: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+    disabled: "disabled";
+    open: "open";
+    allowlist: "allowlist";
+  }>>>;
+  responsePrefix: z.ZodOptional<z.ZodString>;
+  mediaMaxMb: z.ZodOptional<z.ZodNumber>;
+  webhookPath: z.ZodOptional<z.ZodString>;
+  accounts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodOptional<z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    channelAccessToken: z.ZodOptional<z.ZodString>;
+    channelSecret: z.ZodOptional<z.ZodString>;
+    tokenFile: z.ZodOptional<z.ZodString>;
+    secretFile: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    allowFrom: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+    groupAllowFrom: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+    dmPolicy: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+      disabled: "disabled";
+      open: "open";
+      allowlist: "allowlist";
+      pairing: "pairing";
+    }>>>;
+    groupPolicy: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+      disabled: "disabled";
+      open: "open";
+      allowlist: "allowlist";
+    }>>>;
+    responsePrefix: z.ZodOptional<z.ZodString>;
+    mediaMaxMb: z.ZodOptional<z.ZodNumber>;
+    webhookPath: z.ZodOptional<z.ZodString>;
+    groups: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodOptional<z.ZodObject<{
+      enabled: z.ZodOptional<z.ZodBoolean>;
+      allowFrom: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+      requireMention: z.ZodOptional<z.ZodBoolean>;
+      systemPrompt: z.ZodOptional<z.ZodString>;
+      skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>>>;
+  }, z.core.$strict>>>>;
+  defaultAccount: z.ZodOptional<z.ZodString>;
+  groups: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodOptional<z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    allowFrom: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+    requireMention: z.ZodOptional<z.ZodBoolean>;
+    systemPrompt: z.ZodOptional<z.ZodString>;
+    skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  }, z.core.$strict>>>>;
+}, z.core.$strict>;
+//#endregion
+export { lineSetupWizard as n, lineSetupAdapter as r, LineConfigSchema as t };

package/dist/links-BOnvOj1z.d.ts

@@ -0,0 +1,7 @@
+//#region src/terminal/links.d.ts
+declare function formatDocsLink(path: string, label?: string, opts?: {
+  fallback?: string;
+  force?: boolean;
+}): string;
+//#endregion
+export { formatDocsLink as t };

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

@@ -0,0 +1,67 @@
+import { t as createSubsystemLogger } from "./subsystem-S4LNMNHd.js";
+import { Gc as runEmbeddedPiAgent } from "./auth-profiles-9zZdaXJK.js";
+import { d as parseModelRef, k as DEFAULT_PROVIDER } from "./model-selection-DfA4esOK.js";
+import { a as resolveAgentDir, m as resolveDefaultAgentId, o as resolveAgentEffectiveModelPrimary, p as resolveAgentWorkspaceDir } from "./agent-scope-DA7O8MVG.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");
+/**
+* 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(), "moldclaw-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 ?? "anthropic";
+		const model = parsed?.model ?? "claude-opus-4-6";
+		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: 15e3,
+			runId: `slug-gen-${Date.now()}`
+		});
+		if (result.payloads && result.payloads.length > 0) {
+			const text = result.payloads[0]?.text;
+			if (text) return text.trim().toLowerCase().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.d.ts

@@ -0,0 +1,12 @@
+import { Ll as moldClawConfig } from "./types-DBhDdMQd.js";
+
+//#region src/hooks/llm-slug-generator.d.ts
+/**
+ * Generate a short 1-2 word filename slug from session content using LLM
+ */
+declare function generateSlugViaLLM(params: {
+  sessionContent: string;
+  cfg: moldClawConfig;
+}): Promise<string | null>;
+//#endregion
+export { generateSlugViaLLM };