@makefinks/daemon 0.4.0 → 0.6.0

package/src/components/tool-layouts/layouts/subagent.tsx

@@ -1,7 +1,8 @@
-import type { ToolLayoutConfig, ToolHeader, ToolLayoutRenderProps } from "../types";
 import type { ToolCallStatus } from "../../../types";
+import { COLORS, REASONING_MARKDOWN_STYLE } from "../../../ui/constants";
+import { formatMarkdownTables } from "../../../utils/markdown-tables";
 import { registerToolLayout } from "../registry";
-import { COLORS } from "../../../ui/constants";
+import type { ToolHeader, ToolLayoutConfig, ToolLayoutRenderProps } from "../types";
 
 type UnknownRecord = Record<string, unknown>;
 
@@ -28,20 +29,91 @@ function extractSearchQuery(input: unknown): string | null {
 	return null;
 }
 
+function extractUrl(input: unknown): string | null {
+	if (!isRecord(input)) return null;
+	if ("url" in input && typeof input.url === "string") {
+		return input.url;
+	}
+	return null;
+}
+
+function extractPath(input: unknown): string | null {
+	if (!isRecord(input)) return null;
+	if ("path" in input && typeof input.path === "string") {
+		return input.path;
+	}
+	return null;
+}
+
+function extractCommand(input: unknown): string | null {
+	if (!isRecord(input)) return null;
+	if ("command" in input && typeof input.command === "string") {
+		return input.command;
+	}
+	return null;
+}
+
+function truncateLabel(text: string, maxLength: number): string {
+	if (text.length <= maxLength) return text;
+	if (maxLength <= 3) return text.slice(0, maxLength);
+	return `${text.slice(0, maxLength - 3)}...`;
+}
+
 function abbreviateToolName(name: string): string {
 	const abbreviations: Record<string, string> = {
 		webSearch: "search",
 		fetchUrls: "fetch",
 		renderUrl: "render",
-		getSystemInfo: "sys",
 		runBash: "bash",
 		todoManager: "todo",
 		readFile: "read",
-		groundingManager: "grounding",
 	};
 	return abbreviations[name] ?? name.slice(0, 8);
 }
 
+function formatStepLabel(step: { toolName: string; input?: unknown }): string {
+	const toolLabel = abbreviateToolName(step.toolName);
+	const MAX_URL_LENGTH = 56;
+	const MAX_PATH_LENGTH = 56;
+	const MAX_COMMAND_LENGTH = 72;
+	const MAX_QUERY_LENGTH = 56;
+
+	if (step.toolName === "webSearch") {
+		const query = extractSearchQuery(step.input);
+		if (query) {
+			return `${toolLabel}: "${truncateLabel(query, MAX_QUERY_LENGTH)}"`;
+		}
+		return toolLabel;
+	}
+
+	if (step.toolName === "fetchUrls" || step.toolName === "renderUrl") {
+		const url = extractUrl(step.input);
+		if (url) {
+			return `${toolLabel}: ${truncateLabel(url, MAX_URL_LENGTH)}`;
+		}
+		return toolLabel;
+	}
+
+	if (step.toolName === "readFile") {
+		const path = extractPath(step.input);
+		if (path) {
+			return `${toolLabel}: ${truncateLabel(path, MAX_PATH_LENGTH)}`;
+		}
+		return toolLabel;
+	}
+
+	if (step.toolName === "runBash") {
+		const command = extractCommand(step.input);
+		if (command) {
+			const cleanCommand = command.replace(/\s+/g, " ").trim();
+			return `${toolLabel}: ${truncateLabel(cleanCommand, MAX_COMMAND_LENGTH)}`;
+		}
+		return toolLabel;
+	}
+
+	return toolLabel;
+}
+
 function getStepStatusIcon(status: ToolCallStatus): string {
 	switch (status) {
 		case "running":
@@ -68,22 +140,50 @@ function getStepStatusColor(status: ToolCallStatus): string {
 	}
 }
 
-function SubagentBody({ call }: ToolLayoutRenderProps) {
-	if (!call.subagentSteps || call.subagentSteps.length === 0) {
+function formatSubagentResponse(result: unknown): string | null {
+	if (!isRecord(result)) return null;
+	if (typeof result.response !== "string") return null;
+	const raw = result.response.trim();
+	if (!raw) return null;
+
+	const MAX_LINES = 6;
+	const MAX_CHARS = 160;
+	const lines = raw
+		.replace(/\r\n/g, "\n")
+		.split("\n")
+		.map((line) => line.trimEnd())
+		.filter((line) => line.length > 0);
+	if (lines.length === 0) return null;
+
+	const trimmed = lines.slice(0, MAX_LINES).map((line) => truncateLabel(line, MAX_CHARS));
+	if (lines.length > MAX_LINES && trimmed.length > 0) {
+		const lastIndex = trimmed.length - 1;
+		const lastLine = trimmed[lastIndex] ?? "";
+		trimmed[lastIndex] = lastLine.endsWith("...") ? lastLine : `${lastLine}...`;
+	}
+
+	return trimmed.join("\n");
+}
+
+function SubagentBody({ call, result }: ToolLayoutRenderProps) {
+	const steps = call.subagentSteps ?? [];
+	const responseText = formatSubagentResponse(result);
+	if (steps.length === 0 && !responseText) {
 		return null;
 	}
 
+	const maxWidth =
+		typeof process !== "undefined" && process.stdout?.columns ? process.stdout.columns : undefined;
+	const renderedResponse = responseText ? formatMarkdownTables(responseText, { maxWidth }) : "";
+
 	return (
 		<box flexDirection="column" paddingLeft={2} marginTop={0}>
-			{call.subagentSteps.map((step, idx) => {
-				const toolLabel = abbreviateToolName(step.toolName);
-				let stepLabel = toolLabel;
-				if (step.toolName === "webSearch") {
-					const query = extractSearchQuery(step.input);
-					if (query) {
-						stepLabel = `${toolLabel}: "${query}"`;
-					}
-				}
+			{steps.map((step, idx) => {
+				const stepLabel = formatStepLabel(step);
+				const inputLabel = stepLabel.slice(stepLabel.indexOf(":") + 1).trim();
+				const toolLabel = stepLabel.includes(":")
+					? stepLabel.slice(0, stepLabel.indexOf(":") + 1)
+					: stepLabel;
 
 				return (
 					<box key={`${step.toolName}-${idx}`} flexDirection="row" alignItems="center">
@@ -95,11 +195,35 @@ function SubagentBody({ call }: ToolLayoutRenderProps) {
 							</text>
 						)}
 						<text marginLeft={1}>
-							<span fg={COLORS.TOOL_INPUT_TEXT}>{stepLabel}</span>
+							<span fg={COLORS.TOOL_INPUT_TEXT}>{toolLabel}</span>
+							{stepLabel.includes(":") && <span fg={COLORS.REASONING_DIM}>{` ${inputLabel}`}</span>}
 						</text>
 					</box>
 				);
 			})}
+			{responseText && (
+				<box flexDirection="column" marginTop={steps.length > 0 ? 1 : 0}>
+					<text>
+						<span fg={COLORS.REASONING_DIM}>{"response"}</span>
+					</text>
+					<box
+						borderStyle="single"
+						borderColor={COLORS.TOOL_INPUT_BORDER}
+						paddingLeft={1}
+						paddingRight={1}
+						paddingTop={0}
+						paddingBottom={0}
+					>
+						<code
+							content={renderedResponse}
+							filetype="markdown"
+							syntaxStyle={REASONING_MARKDOWN_STYLE}
+							conceal={true}
+							drawUnstyledText={false}
+						/>
+					</box>
+				</box>
+			)}
 		</box>
 	);
 }

package/src/hooks/daemon-event-handlers.ts

@@ -22,7 +22,7 @@ import type {
 import { DaemonState } from "../types";
 import { REASONING_COLORS, STATE_COLORS } from "../types/theme";
 import { REASONING_ANIMATION } from "../ui/constants";
-import { debug } from "../utils/debug-logger";
+import { debug, messageDebug } from "../utils/debug-logger";
 import { hasVisibleText } from "../utils/formatters";
 import {
 	INTERRUPTED_TOOL_RESULT,
@@ -736,7 +736,7 @@ export function createCancelledHandler(
 		const hasBlocks = refs.contentBlocksRef.current.length > 0;
 		const contentBlocks = hasBlocks ? buildInterruptedContentBlocks(refs.contentBlocksRef.current) : [];
 
-		debug.info("agent-turn-incomplete", {
+		messageDebug.info("agent-turn-incomplete", {
 			userText,
 			contentBlocks,
 		});
@@ -753,7 +753,7 @@ export function createCancelledHandler(
 					}
 				: null;
 
-			debug.info("agent-turn-incomplete-messages", {
+			messageDebug.info("agent-turn-incomplete-messages", {
 				responseMessages,
 			});
 

package/src/hooks/use-app-controller.ts

@@ -1,4 +1,4 @@
-import { useRenderer } from "@opentui/react";
+import { useOnResize, useRenderer } from "@opentui/react";
 import { useCallback, useEffect, useMemo, useState } from "react";
 
 import type { ConversationPaneProps } from "../app/components/ConversationPane";
@@ -21,6 +21,7 @@ import { useSessionController } from "./use-session-controller";
 import { getDaemonManager } from "../state/daemon-state";
 import { deleteSession } from "../state/session-store";
 import { DaemonState } from "../types";
+import { STARTUP_BANNER_DURATION_MS, STARTUP_IDLE_CHROME_LEAD_MS } from "../ui/startup";
 
 export interface AppControllerResult {
 	handleCopyOnSelectMouseUp: () => void;
@@ -31,6 +32,9 @@ export interface AppControllerResult {
 		width: number;
 		height: number;
 		zIndex: number;
+		showBanner: boolean;
+		animateBanner: boolean;
+		startupAnimationActive: boolean;
 	};
 	isListeningDim: boolean;
 	listeningDimTop: number;
@@ -54,6 +58,18 @@ export function useAppController({
 	const { handleCopyOnSelectMouseUp } = useCopyOnSelect();
 
 	const [preferencesLoaded, setPreferencesLoaded] = useState(false);
+	const [terminalSize, setTerminalSize] = useState({
+		width: renderer.terminalWidth,
+		height: renderer.terminalHeight,
+	});
+	// Track if this is initial app load for startup animation
+	const [isInitialLoad, setIsInitialLoad] = useState(true);
+	const [startupIntroDone, setStartupIntroDone] = useState(false);
+
+	// Update terminal size state on resize to trigger re-render
+	useOnResize((width, height) => {
+		setTerminalSize({ width, height });
+	});
 
 	const menus = useAppMenus();
 	const {
@@ -119,6 +135,19 @@ export function useAppController({
 		preferencesLoaded,
 		showDeviceMenu,
 	});
+	const onboardingComplete = preferencesLoaded && !bootstrap.onboardingActive;
+
+	useEffect(() => {
+		if (!onboardingComplete) {
+			setStartupIntroDone(false);
+			return;
+		}
+		// Delay idle UI chrome (status/hotkeys) so the banner can resolve first.
+		const delayMs = Math.max(0, STARTUP_BANNER_DURATION_MS - STARTUP_IDLE_CHROME_LEAD_MS);
+		setStartupIntroDone(false);
+		const t = setTimeout(() => setStartupIntroDone(true), delayMs);
+		return () => clearTimeout(t);
+	}, [onboardingComplete]);
 
 	const daemon = useDaemonRuntimeController({
 		currentModelId,
@@ -373,6 +402,21 @@ export function useAppController({
 		}
 	}, [daemon.daemonState]);
 
+	// Turn off initial load state once user interacts (banner animation is one-time only)
+	useEffect(() => {
+		if (daemon.hasInteracted && isInitialLoad) {
+			setIsInitialLoad(false);
+		}
+	}, [daemon.hasInteracted, isInitialLoad]);
+
+	useEffect(() => {
+		if (daemon.hasInteracted && !startupIntroDone) {
+			setStartupIntroDone(true);
+		}
+	}, [daemon.hasInteracted, startupIntroDone]);
+
+	const startupAnimationActive = onboardingComplete && isInitialLoad;
+
 	const appContextValue = useAppContextBuilder({
 		menus: {
 			showDeviceMenu,
@@ -485,6 +529,11 @@ export function useAppController({
 			width: avatarWidth,
 			height: avatarHeight,
 			zIndex: isListening && daemon.hasInteracted ? 2 : 0,
+			// Show banner only when idle, not interacted, and terminal is large enough
+			showBanner:
+				onboardingComplete && !daemon.hasInteracted && terminalSize.height >= 30 && terminalSize.width >= 100,
+			animateBanner: startupAnimationActive,
+			startupAnimationActive,
 		},
 		isListeningDim,
 		listeningDimTop: statusBarHeight,
@@ -536,6 +585,7 @@ export function useAppController({
 			modelName: modelName ?? "",
 			sessionTitle: sessionTitle ?? "",
 			isVoiceOutputEnabled: interactionMode === "voice",
+			startupIntroDone,
 		},
 		appContextValue,
 		overlaysProps: {

package/src/hooks/use-app-display-state.ts

@@ -1,9 +1,9 @@
 import { useMemo } from "react";
 import { DaemonState } from "../types";
 import type { ContentBlock, SessionInfo } from "../types";
-import type { ModelMetadata } from "../utils/model-metadata";
 import { COLORS, STATE_COLOR_HEX, STATUS_TEXT } from "../ui/constants";
 import { formatElapsedTime } from "../utils/formatters";
+import type { ModelMetadata } from "../utils/model-metadata";
 
 export interface UseAppDisplayStateParams {
 	daemonState: DaemonState;

package/src/hooks/use-glitchy-banner.ts

@@ -0,0 +1,175 @@
+import { useEffect, useState } from "react";
+
+import { STARTUP_BANNER_DURATION_MS } from "../ui/startup";
+
+const DAEMON_BANNER_LINES = [
+	"88888888ba,         db         88888888888  88b           d88    ,ad8888ba,    888b      88",
+	'88      `"8b       d88b        88           888b         d888   d8"\'    `"8b   8888b     88',
+	"88        `8b     d8'`8b       88           88`8b       d8'88  d8'        `8b  88 `8b    88",
+	"88         88    d8'  `8b      88aaaaa      88 `8b     d8' 88  88          88  88  `8b   88",
+	'88         88   d8YaaaaY8b     88"""""      88  `8b   d8\'  88  88          88  88   `8b  88',
+	'88         8P  d8""""""""8b    88           88   `8b d8\'   88  Y8,        ,8P  88    `8b 88',
+	"88      .a8P  d8'        `8b   88           88    `888'    88   Y8a.    .a8P   88     `8888",
+	"88888888Y\"'  d8'          `8b  88888888888  88     `8'     88    `\"Y8888Y\"'    88      `888",
+];
+
+const BANNER_GRADIENT = [
+	"#8a3434",
+	"#7a2f2f",
+	"#692929",
+	"#582323",
+	"#481c1c",
+	"#371515",
+	"#260f0f",
+	"#160808",
+];
+
+// glitch chars
+const GLITCH_CHARS = "!@#$%^&*()_+-=[]{}|;:',.<>?/\\`~01";
+
+const BANNER_ANIMATION_DURATION = STARTUP_BANNER_DURATION_MS;
+const LINE_STAGGER_MS = 80;
+
+export interface GlitchyBannerState {
+	lines: string[];
+	colors: string[];
+	progress: number;
+	complete: boolean;
+}
+
+/**
+ * Generates a glitched version of a string.
+ * @param original The original string
+ * @param glitchAmount 0-1, where 1 = fully glitched
+ * @param revealProgress 0-1, where 1 = fully revealed from left
+ */
+function glitchString(original: string, glitchAmount: number, revealProgress: number): string {
+	const revealedLength = Math.floor(original.length * revealProgress);
+	let result = "";
+
+	for (let i = 0; i < original.length; i++) {
+		const char = original[i];
+
+		if (i >= revealedLength) {
+			// Not yet revealed - either empty or glitch
+			if (Math.random() < glitchAmount * 0.7) {
+				result += GLITCH_CHARS[Math.floor(Math.random() * GLITCH_CHARS.length)];
+			} else {
+				result += " ";
+			}
+		} else {
+			// Revealed area - occasional glitch corruption
+			if (char !== " " && Math.random() < glitchAmount * 0.15) {
+				result += GLITCH_CHARS[Math.floor(Math.random() * GLITCH_CHARS.length)];
+			} else {
+				result += char;
+			}
+		}
+	}
+
+	return result;
+}
+
+/**
+ * Generates glitched color - subtle brightness/saturation shifts within red spectrum
+ */
+function glitchColor(baseColor: string, glitchAmount: number): string {
+	if (glitchAmount > 0.2 && Math.random() < glitchAmount * 0.4) {
+		const hex = baseColor.replace("#", "");
+		const r = parseInt(hex.substring(0, 2), 16);
+		const g = parseInt(hex.substring(2, 4), 16);
+		const b = parseInt(hex.substring(4, 6), 16);
+
+		// Subtle variation: shift brightness and add slight color temperature changes
+		const brightnessShift = (Math.random() - 0.3) * glitchAmount * 80;
+		const newR = Math.max(0, Math.min(255, r + brightnessShift + Math.random() * 30));
+		const newG = Math.max(0, Math.min(255, g + brightnessShift * 0.3));
+		const newB = Math.max(0, Math.min(255, b + brightnessShift * 0.2));
+
+		return `#${Math.round(newR).toString(16).padStart(2, "0")}${Math.round(newG).toString(16).padStart(2, "0")}${Math.round(newB).toString(16).padStart(2, "0")}`;
+	}
+	return baseColor;
+}
+
+export function useGlitchyBanner(isActive: boolean): GlitchyBannerState {
+	const [state, setState] = useState<GlitchyBannerState>({
+		lines: DAEMON_BANNER_LINES.map(() => ""),
+		colors: BANNER_GRADIENT.map(() => "#000000"),
+		progress: 0,
+		complete: false,
+	});
+
+	// Animation loop
+	useEffect(() => {
+		if (!isActive) {
+			setState({
+				lines: DAEMON_BANNER_LINES.map(() => ""),
+				colors: BANNER_GRADIENT.map(() => "#000000"),
+				progress: 0,
+				complete: false,
+			});
+			return;
+		}
+
+		const startTime = performance.now();
+		const animate = () => {
+			const elapsed = performance.now() - startTime;
+			const progress = Math.min(1, elapsed / BANNER_ANIMATION_DURATION);
+
+			if (progress >= 1) {
+				// Animation complete, show final state
+				setState({
+					lines: [...DAEMON_BANNER_LINES],
+					colors: [...BANNER_GRADIENT],
+					progress: 1,
+					complete: true,
+				});
+				return;
+			}
+
+			// Calculate glitch intensity (high at start, fades out)
+			const glitchIntensity = Math.pow(1 - progress, 2);
+
+			// Generate glitched lines with staggered reveal
+			const lines = DAEMON_BANNER_LINES.map((line, i) => {
+				const lineStartTime = i * LINE_STAGGER_MS;
+				const lineElapsed = Math.max(0, elapsed - lineStartTime);
+				const lineProgress = Math.min(1, lineElapsed / (BANNER_ANIMATION_DURATION - i * LINE_STAGGER_MS));
+
+				// Reveal from left + glitch effect
+				const revealProgress = Math.pow(lineProgress, 0.7); // Ease out
+				return glitchString(line, glitchIntensity, revealProgress);
+			});
+
+			// Generate colors with occasional glitch flash
+			const colors = BANNER_GRADIENT.map((color, i) => {
+				const lineStartTime = i * LINE_STAGGER_MS;
+				const lineElapsed = Math.max(0, elapsed - lineStartTime);
+				const lineProgress = Math.min(1, lineElapsed / (BANNER_ANIMATION_DURATION - i * LINE_STAGGER_MS));
+
+				if (lineProgress < 0.1) {
+					return "#000000";
+				}
+				return glitchColor(color, glitchIntensity);
+			});
+
+			setState({
+				lines,
+				colors,
+				progress,
+				complete: false,
+			});
+		};
+
+		// Run at ~30fps for glitchy effect
+		const intervalId = setInterval(animate, 33);
+		// Run once immediately
+		animate();
+
+		return () => clearInterval(intervalId);
+	}, [isActive]);
+
+	return state;
+}
+
+export { DAEMON_BANNER_LINES, BANNER_GRADIENT };

package/src/hooks/use-reasoning-animation.ts

@@ -59,7 +59,7 @@ export function useReasoningAnimation(): UseReasoningAnimationReturn {
 
 				const terminalWidth =
 					typeof process !== "undefined" && process.stdout?.columns ? process.stdout.columns : undefined;
-				const maxWidth = terminalWidth ? Math.max(20, terminalWidth - 12) : REASONING_ANIMATION.LINE_WIDTH;
+				const maxWidth = terminalWidth ? Math.max(20, terminalWidth - 14) : REASONING_ANIMATION.LINE_WIDTH;
 				const lineWidth = Math.min(REASONING_ANIMATION.LINE_WIDTH, maxWidth);
 
 				// Add to display, restart when reaching the line width

package/src/state/daemon-state.ts

@@ -16,7 +16,7 @@ import type {
 } from "../types";
 import { DEFAULT_TOOL_TOGGLES } from "../types";
 import { DaemonState } from "../types";
-import { debug } from "../utils/debug-logger";
+import { debug, messageDebug } from "../utils/debug-logger";
 import { SpeechController } from "../voice/tts/speech-controller";
 import { VoiceInputController } from "../voice/voice-input-controller";
 import { type DaemonStateEvents, daemonEvents } from "./daemon-events";
@@ -272,7 +272,7 @@ class DaemonStateManager {
 		this.setState(DaemonState.RESPONDING);
 		this._response = "";
 		const turnId = ++this._turnId;
-		debug.info("agent-turn-start", {
+		messageDebug.info("agent-turn-start", {
 			turnId,
 			text,
 			mode: this._interactionMode,
@@ -319,7 +319,7 @@ class DaemonStateManager {
 				return;
 			}
 
-			debug.info("agent-turn-complete", {
+			messageDebug.info("agent-turn-complete", {
 				turnId,
 				fullText: result.fullText,
 				finalText: result.finalText,

package/src/ui/reasoning-ticker.tsx

@@ -28,7 +28,10 @@ export function renderReasoningTicker(reasoningDisplay: string) {
 
 	return (
 		<text>
-			<span fg={REASONING_ANIMATION.PREFIX_COLOR}>{"// "}</span>
+			<span fg={COLORS.REASONING_DIM} attributes={TextAttributes.BOLD}>
+				{"REASONING"}
+			</span>
+			<span fg={REASONING_ANIMATION.PREFIX_COLOR}>{" | "}</span>
 			{segments.map((segment, index) => (
 				<span fg={segment.color} key={`reasoning-seg-${index}`} attributes={TextAttributes.ITALIC}>
 					{segment.text}

package/src/ui/startup.ts

@@ -0,0 +1,5 @@
+export const STARTUP_BANNER_DURATION_MS = 1800;
+
+export const STARTUP_IDLE_CHROME_LEAD_MS = 250;
+
+export const STARTUP_BANNER_DURATION_S = STARTUP_BANNER_DURATION_MS / 1000;

package/src/utils/debug-logger.ts

@@ -6,19 +6,24 @@
  *   import { debug } from "../utils/debug-logger";
  *   debug.log("message", someObject);
  *
- * Then run `tail -f debug.log` in a separate terminal.
+ * Then run `tail -f ~/.config/daemon/logs/debug.log` in a separate terminal.
+ * Tool-specific logging uses `~/.config/daemon/logs/tools.log`.
+ * Message logging uses `~/.config/daemon/logs/messages.log`.
  */
 
 import fs from "node:fs";
 import path from "node:path";
 import { getAppConfigDir } from "./preferences";
 
-const LOG_FILE = path.join(getAppConfigDir(), "debug.log");
+const LOG_DIR = path.join(getAppConfigDir(), "logs");
+const LOG_FILE = path.join(LOG_DIR, "debug.log");
+const TOOLS_LOG_FILE = path.join(LOG_DIR, "tools.log");
+const MESSAGES_LOG_FILE = path.join(LOG_DIR, "messages.log");
 const ENABLED = process.env.DEBUG_LOG === "1" || process.env.DEBUG_LOG === "true";
 
-function ensureLogDir(): void {
+function ensureLogDir(logDir: string): void {
 	try {
-		fs.mkdirSync(getAppConfigDir(), { recursive: true });
+		fs.mkdirSync(logDir, { recursive: true });
 	} catch {
 		// Silently fail if we can't create the directory
 	}
@@ -35,7 +40,7 @@ function formatValue(value: unknown): string {
 	}
 }
 
-function writeLog(level: string, args: unknown[]): void {
+function writeLog(logFile: string, level: string, args: unknown[]): void {
 	if (!ENABLED) return;
 
 	const timestamp = new Date().toISOString();
@@ -43,27 +48,33 @@ function writeLog(level: string, args: unknown[]): void {
 	const line = `[${timestamp}] [${level}] ${formatted}\n`;
 
 	try {
-		ensureLogDir();
-		fs.appendFileSync(LOG_FILE, line);
+		ensureLogDir(LOG_DIR);
+		fs.appendFileSync(logFile, line);
 	} catch {
 		// Silently fail if we can't write
 	}
 }
 
-export const debug = {
-	log: (...args: unknown[]) => writeLog("LOG", args),
-	info: (...args: unknown[]) => writeLog("INFO", args),
-	warn: (...args: unknown[]) => writeLog("WARN", args),
-	error: (...args: unknown[]) => writeLog("ERROR", args),
+function createDebugLogger(logFile: string) {
+	return {
+		log: (...args: unknown[]) => writeLog(logFile, "LOG", args),
+		info: (...args: unknown[]) => writeLog(logFile, "INFO", args),
+		warn: (...args: unknown[]) => writeLog(logFile, "WARN", args),
+		error: (...args: unknown[]) => writeLog(logFile, "ERROR", args),
 
-	/** Clear the log file */
-	clear: () => {
-		if (!ENABLED) return;
-		try {
-			ensureLogDir();
-			fs.writeFileSync(LOG_FILE, "");
-		} catch {
-			// Silently fail
-		}
-	},
-};
+		/** Clear the log file */
+		clear: () => {
+			if (!ENABLED) return;
+			try {
+				ensureLogDir(LOG_DIR);
+				fs.writeFileSync(logFile, "");
+			} catch {
+				// Silently fail
+			}
+		},
+	};
+}
+
+export const debug = createDebugLogger(LOG_FILE);
+export const toolDebug = createDebugLogger(TOOLS_LOG_FILE);
+export const messageDebug = createDebugLogger(MESSAGES_LOG_FILE);