@makefinks/daemon 0.1.4 → 0.3.0

package/src/hooks/use-daemon-keyboard.ts

@@ -1,15 +1,11 @@
-/**
- * Hook for handling keyboard input across all application states.
- */
-
-import { useCallback } from "react";
+import { toast } from "@opentui-ui/toast/react";
 import type { KeyEvent } from "@opentui/core";
+import type { ScrollBoxRenderable } from "@opentui/core";
 import { useKeyboard } from "@opentui/react";
-import { toast } from "@opentui-ui/toast/react";
-import { COLORS } from "../ui/constants";
+import { useCallback } from "react";
 import { getDaemonManager } from "../state/daemon-state";
-import { DaemonState, type AppPreferences } from "../types";
-import type { ScrollBoxRenderable } from "@opentui/core";
+import { type AppPreferences, DaemonState } from "../types";
+import { COLORS } from "../ui/constants";
 export interface KeyboardHandlerState {
 	isOverlayOpen: boolean;
 	escPendingCancel: boolean;
@@ -27,6 +23,8 @@ export interface KeyboardHandlerActions {
 	setShowSessionMenu: (show: boolean) => void;
 	setShowHotkeysPane: (show: boolean) => void;
 	setShowGroundingMenu: (show: boolean) => void;
+	setShowUrlMenu: (show: boolean) => void;
+	setShowToolsMenu: (show: boolean) => void;
 	setTypingInput: (input: string | ((prev: string) => string)) => void;
 	setCurrentTranscription: (text: string) => void;
 	setCurrentResponse: (text: string) => void;
@@ -44,7 +42,19 @@ export interface KeyboardHandlerActions {
 
 export function useDaemonKeyboard(state: KeyboardHandlerState, actions: KeyboardHandlerActions) {
 	const manager = getDaemonManager();
-	const { isOverlayOpen, escPendingCancel, hasInteracted, hasGrounding } = state;
+	const { isOverlayOpen, escPendingCancel, hasInteracted, hasGrounding, showFullReasoning } = state;
+
+	const closeAllMenus = useCallback(() => {
+		actions.setShowDeviceMenu(false);
+		actions.setShowSettingsMenu(false);
+		actions.setShowModelMenu(false);
+		actions.setShowProviderMenu(false);
+		actions.setShowSessionMenu(false);
+		actions.setShowHotkeysPane(false);
+		actions.setShowGroundingMenu(false);
+		actions.setShowUrlMenu(false);
+		actions.setShowToolsMenu(false);
+	}, [actions]);
 
 	const handleKeyPress = useCallback(
 		(key: KeyEvent) => {
@@ -97,12 +107,7 @@ export function useDaemonKeyboard(state: KeyboardHandlerState, actions: Keyboard
 				currentState === DaemonState.IDLE &&
 				!hasInteracted
 			) {
-				actions.setShowModelMenu(false);
-				actions.setShowProviderMenu(false);
-				actions.setShowSessionMenu(false);
-				actions.setShowSettingsMenu(false);
-				actions.setShowGroundingMenu(false);
-				actions.setShowHotkeysPane(false);
+				closeAllMenus();
 				actions.setShowDeviceMenu(true);
 				key.preventDefault();
 				return;
@@ -114,12 +119,7 @@ export function useDaemonKeyboard(state: KeyboardHandlerState, actions: Keyboard
 				key.eventType === "press" &&
 				(currentState === DaemonState.IDLE || currentState === DaemonState.SPEAKING)
 			) {
-				actions.setShowDeviceMenu(false);
-				actions.setShowSettingsMenu(false);
-				actions.setShowModelMenu(false);
-				actions.setShowProviderMenu(false);
-				actions.setShowGroundingMenu(false);
-				actions.setShowHotkeysPane(false);
+				closeAllMenus();
 				actions.setShowSessionMenu(true);
 				key.preventDefault();
 				return;
@@ -133,12 +133,7 @@ export function useDaemonKeyboard(state: KeyboardHandlerState, actions: Keyboard
 					currentState === DaemonState.SPEAKING ||
 					currentState === DaemonState.RESPONDING)
 			) {
-				actions.setShowDeviceMenu(false);
-				actions.setShowModelMenu(false);
-				actions.setShowProviderMenu(false);
-				actions.setShowSessionMenu(false);
-				actions.setShowGroundingMenu(false);
-				actions.setShowHotkeysPane(false);
+				closeAllMenus();
 				actions.setShowSettingsMenu(true);
 				key.preventDefault();
 				return;
@@ -152,12 +147,7 @@ export function useDaemonKeyboard(state: KeyboardHandlerState, actions: Keyboard
 					currentState === DaemonState.SPEAKING ||
 					currentState === DaemonState.RESPONDING)
 			) {
-				actions.setShowDeviceMenu(false);
-				actions.setShowSettingsMenu(false);
-				actions.setShowProviderMenu(false);
-				actions.setShowSessionMenu(false);
-				actions.setShowGroundingMenu(false);
-				actions.setShowHotkeysPane(false);
+				closeAllMenus();
 				actions.setShowModelMenu(true);
 				key.preventDefault();
 				return;
@@ -169,35 +159,42 @@ export function useDaemonKeyboard(state: KeyboardHandlerState, actions: Keyboard
 				key.eventType === "press" &&
 				(currentState === DaemonState.IDLE || currentState === DaemonState.SPEAKING)
 			) {
-				actions.setShowDeviceMenu(false);
-				actions.setShowSettingsMenu(false);
-				actions.setShowModelMenu(false);
-				actions.setShowSessionMenu(false);
-				actions.setShowGroundingMenu(false);
-				actions.setShowHotkeysPane(false);
+				closeAllMenus();
 				actions.setShowProviderMenu(true);
 				key.preventDefault();
 				return;
 			}
 
-			// 'G' key to open grounding menu (in IDLE or SPEAKING state when grounding exists)
+			// 'G' key to open grounding menu (in IDLE, SPEAKING, or RESPONDING state when grounding exists)
 			if (
 				(key.sequence === "g" || key.sequence === "G") &&
 				key.eventType === "press" &&
-				(currentState === DaemonState.IDLE || currentState === DaemonState.SPEAKING) &&
+				(currentState === DaemonState.IDLE ||
+					currentState === DaemonState.SPEAKING ||
+					currentState === DaemonState.RESPONDING) &&
 				hasGrounding
 			) {
-				actions.setShowDeviceMenu(false);
-				actions.setShowSettingsMenu(false);
-				actions.setShowModelMenu(false);
-				actions.setShowProviderMenu(false);
-				actions.setShowSessionMenu(false);
-				actions.setShowHotkeysPane(false);
+				closeAllMenus();
 				actions.setShowGroundingMenu(true);
 				key.preventDefault();
 				return;
 			}
 
+			// 'U' key to open URL menu (in IDLE, SPEAKING, or RESPONDING state when hasInteracted)
+			if (
+				(key.sequence === "u" || key.sequence === "U") &&
+				key.eventType === "press" &&
+				(currentState === DaemonState.IDLE ||
+					currentState === DaemonState.SPEAKING ||
+					currentState === DaemonState.RESPONDING) &&
+				hasInteracted
+			) {
+				closeAllMenus();
+				actions.setShowUrlMenu(true);
+				key.preventDefault();
+				return;
+			}
+
 			// 'N' key to start a new session (in IDLE or SPEAKING state)
 			if (
 				(key.sequence === "n" || key.sequence === "N") &&
@@ -221,7 +218,7 @@ export function useDaemonKeyboard(state: KeyboardHandlerState, actions: Keyboard
 				return;
 			}
 
-			// 'T' key to toggle full reasoning display (in IDLE, SPEAKING, or RESPONDING state)
+			// 'T' key to open tools menu (in IDLE, SPEAKING, or RESPONDING state)
 			if (
 				(key.sequence === "t" || key.sequence === "T") &&
 				key.eventType === "press" &&
@@ -229,7 +226,21 @@ export function useDaemonKeyboard(state: KeyboardHandlerState, actions: Keyboard
 					currentState === DaemonState.SPEAKING ||
 					currentState === DaemonState.RESPONDING)
 			) {
-				const next = !state.showFullReasoning;
+				closeAllMenus();
+				actions.setShowToolsMenu(true);
+				key.preventDefault();
+				return;
+			}
+
+			// 'R' key to toggle full reasoning display (in IDLE, SPEAKING, or RESPONDING state)
+			if (
+				(key.sequence === "r" || key.sequence === "R") &&
+				key.eventType === "press" &&
+				(currentState === DaemonState.IDLE ||
+					currentState === DaemonState.SPEAKING ||
+					currentState === DaemonState.RESPONDING)
+			) {
+				const next = !showFullReasoning;
 				actions.setShowFullReasoning(next);
 				actions.persistPreferences({ showFullReasoning: next });
 				toast.info(`FULL PREVIEWS: ${next ? "ON" : "OFF"}`, {
@@ -267,12 +278,7 @@ export function useDaemonKeyboard(state: KeyboardHandlerState, actions: Keyboard
 
 			// '?' key to show hotkeys pane
 			if (key.sequence === "?" && key.eventType === "press" && currentState !== DaemonState.TYPING) {
-				actions.setShowDeviceMenu(false);
-				actions.setShowSettingsMenu(false);
-				actions.setShowModelMenu(false);
-				actions.setShowProviderMenu(false);
-				actions.setShowSessionMenu(false);
-				actions.setShowGroundingMenu(false);
+				closeAllMenus();
 				actions.setShowHotkeysPane(true);
 				key.preventDefault();
 				return;
@@ -387,7 +393,7 @@ export function useDaemonKeyboard(state: KeyboardHandlerState, actions: Keyboard
 			escPendingCancel,
 			hasInteracted,
 			hasGrounding,
-			state.showFullReasoning,
+			showFullReasoning,
 			state.showToolOutput,
 			actions,
 		]

package/src/hooks/use-daemon-runtime-controller.ts

@@ -0,0 +1,147 @@
+import type { ScrollBoxRenderable } from "@opentui/core";
+import { useCallback, useEffect, useRef } from "react";
+import type { MutableRefObject } from "react";
+
+import { useDaemonEvents } from "./use-daemon-events";
+import { useInputHistory } from "./use-input-history";
+import { useReasoningAnimation } from "./use-reasoning-animation";
+import { useResponseTimer } from "./use-response-timer";
+import { useTypingMode } from "./use-typing-mode";
+
+import { daemonEvents } from "../state/daemon-events";
+
+export interface DaemonRuntimeControllerResult {
+	reasoning: ReturnType<typeof useReasoningAnimation>;
+
+	daemonState: ReturnType<typeof useDaemonEvents>["daemonState"];
+	conversationHistory: ReturnType<typeof useDaemonEvents>["conversationHistory"];
+	currentTranscription: ReturnType<typeof useDaemonEvents>["currentTranscription"];
+	currentResponse: ReturnType<typeof useDaemonEvents>["currentResponse"];
+	currentContentBlocks: ReturnType<typeof useDaemonEvents>["currentContentBlocks"];
+	error: ReturnType<typeof useDaemonEvents>["error"];
+	sessionUsage: ReturnType<typeof useDaemonEvents>["sessionUsage"];
+	modelMetadata: ReturnType<typeof useDaemonEvents>["modelMetadata"];
+	avatarRef: ReturnType<typeof useDaemonEvents>["avatarRef"];
+	currentUserInputRef: ReturnType<typeof useDaemonEvents>["currentUserInputRef"];
+	hydrateConversationHistory: ReturnType<typeof useDaemonEvents>["hydrateConversationHistory"];
+	setCurrentTranscription: ReturnType<typeof useDaemonEvents>["setCurrentTranscription"];
+	setCurrentResponse: ReturnType<typeof useDaemonEvents>["setCurrentResponse"];
+	clearCurrentContentBlocks: ReturnType<typeof useDaemonEvents>["clearCurrentContentBlocks"];
+	resetSessionUsage: ReturnType<typeof useDaemonEvents>["resetSessionUsage"];
+	setSessionUsage: ReturnType<typeof useDaemonEvents>["setSessionUsage"];
+	applyAvatarForState: ReturnType<typeof useDaemonEvents>["applyAvatarForState"];
+
+	typing: ReturnType<typeof useTypingMode>;
+
+	responseElapsedMs: number;
+
+	conversationScrollRef: MutableRefObject<ScrollBoxRenderable | null>;
+
+	hasInteracted: boolean;
+}
+
+export function useDaemonRuntimeController({
+	currentModelId,
+	preferencesLoaded,
+	sessionId,
+	sessionIdRef,
+	ensureSessionId,
+	onFirstMessage,
+}: {
+	currentModelId: string;
+	preferencesLoaded: boolean;
+	sessionId: string | null;
+	sessionIdRef: MutableRefObject<string | null>;
+	ensureSessionId: () => Promise<string>;
+	onFirstMessage: (sessionId: string, message: string) => void;
+}): DaemonRuntimeControllerResult {
+	const reasoning = useReasoningAnimation();
+	const { addToHistory, navigateUp, navigateDown, resetNavigation } = useInputHistory();
+
+	const {
+		daemonState,
+		conversationHistory,
+		currentTranscription,
+		currentResponse,
+		currentContentBlocks,
+		error,
+		sessionUsage,
+		modelMetadata,
+		avatarRef,
+		currentUserInputRef,
+		hydrateConversationHistory,
+		setCurrentTranscription,
+		setCurrentResponse,
+		clearCurrentContentBlocks,
+		resetSessionUsage,
+		setSessionUsage,
+		applyAvatarForState,
+	} = useDaemonEvents({
+		currentModelId,
+		preferencesLoaded,
+		setReasoningQueue: reasoning.setReasoningQueue,
+		setFullReasoning: reasoning.setFullReasoning,
+		clearReasoningState: reasoning.clearReasoningState,
+		clearReasoningTicker: reasoning.clearReasoningTicker,
+		fullReasoningRef: reasoning.fullReasoningRef,
+		sessionId,
+		sessionIdRef,
+		ensureSessionId,
+		addToHistory,
+		onFirstMessage,
+	});
+
+	const typing = useTypingMode({
+		daemonState,
+		currentUserInputRef,
+		setCurrentTranscription,
+		onTypingActivity: useCallback(() => {
+			avatarRef.current?.triggerTypingPulse();
+		}, [avatarRef]),
+		navigateUp,
+		navigateDown,
+		resetNavigation,
+	});
+
+	useEffect(() => {
+		const handleTranscriptionReady = (text: string) => {
+			typing.prefillTypingInput(text);
+		};
+		daemonEvents.on("transcriptionReady", handleTranscriptionReady);
+		return () => {
+			daemonEvents.off("transcriptionReady", handleTranscriptionReady);
+		};
+	}, [typing.prefillTypingInput]);
+
+	const { responseElapsedMs } = useResponseTimer({ daemonState });
+
+	const conversationScrollRef = useRef<ScrollBoxRenderable | null>(null);
+
+	const hasInteracted =
+		conversationHistory.length > 0 || currentTranscription.length > 0 || currentContentBlocks.length > 0;
+
+	return {
+		reasoning,
+		daemonState,
+		conversationHistory,
+		currentTranscription,
+		currentResponse,
+		currentContentBlocks,
+		error,
+		sessionUsage,
+		modelMetadata,
+		avatarRef,
+		currentUserInputRef,
+		hydrateConversationHistory,
+		setCurrentTranscription,
+		setCurrentResponse,
+		clearCurrentContentBlocks,
+		resetSessionUsage,
+		setSessionUsage,
+		applyAvatarForState,
+		typing,
+		responseElapsedMs,
+		conversationScrollRef,
+		hasInteracted,
+	};
+}

package/src/hooks/use-grounding-menu-controller.ts

@@ -0,0 +1,51 @@
+import { useCallback, useEffect, useMemo, useState } from "react";
+import type { GroundingMap } from "../types";
+import { openUrlInBrowser } from "../utils/preferences";
+import { buildTextFragmentUrl } from "../utils/text-fragment";
+
+export function useGroundingMenuController(params: {
+	sessionId: string | null;
+	latestGroundingMap: GroundingMap | null;
+}) {
+	const { sessionId, latestGroundingMap } = params;
+	const [selectedIndex, setSelectedIndex] = useState(0);
+
+	useEffect(() => {
+		setSelectedIndex(0);
+	}, [sessionId]);
+
+	const initialIndex = useMemo(() => {
+		if (!latestGroundingMap) return 0;
+		return Math.min(selectedIndex, Math.max(0, latestGroundingMap.items.length - 1));
+	}, [latestGroundingMap, selectedIndex]);
+
+	const openGroundingSource = useCallback(
+		(idx: number) => {
+			if (!latestGroundingMap) return;
+			const item = latestGroundingMap.items[idx];
+			if (!item) return;
+			const { source } = item;
+			const url = source.textFragment
+				? buildTextFragmentUrl(source.url, { fragmentText: source.textFragment })
+				: source.url;
+			openUrlInBrowser(url);
+		},
+		[latestGroundingMap]
+	);
+
+	const handleSelect = useCallback(
+		(index: number) => {
+			setSelectedIndex(index);
+			openGroundingSource(index);
+		},
+		[openGroundingSource]
+	);
+
+	return {
+		groundingInitialIndex: initialIndex,
+		groundingSelectedIndex: selectedIndex,
+		setGroundingSelectedIndex: setSelectedIndex,
+		onGroundingSelect: handleSelect,
+		onGroundingIndexChange: setSelectedIndex,
+	};
+}

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

@@ -0,0 +1,84 @@
+import { useCallback, useMemo } from "react";
+
+export interface OverlayControllerState {
+	showDeviceMenu: boolean;
+	showSettingsMenu: boolean;
+	showModelMenu: boolean;
+	showProviderMenu: boolean;
+	showSessionMenu: boolean;
+	showHotkeysPane: boolean;
+	showGroundingMenu: boolean;
+	showUrlMenu: boolean;
+	showToolsMenu: boolean;
+	onboardingActive: boolean;
+}
+
+export interface OverlayControllerActions {
+	setShowDeviceMenu: (show: boolean) => void;
+	setShowSettingsMenu: (show: boolean) => void;
+	setShowModelMenu: (show: boolean) => void;
+	setShowProviderMenu: (show: boolean) => void;
+	setShowSessionMenu: (show: boolean) => void;
+	setShowHotkeysPane: (show: boolean) => void;
+	setShowGroundingMenu: (show: boolean) => void;
+	setShowUrlMenu: (show: boolean) => void;
+	setShowToolsMenu: (show: boolean) => void;
+}
+
+export function useOverlayController(state: OverlayControllerState, actions: OverlayControllerActions) {
+	const {
+		showDeviceMenu,
+		showSettingsMenu,
+		showModelMenu,
+		showProviderMenu,
+		showSessionMenu,
+		showHotkeysPane,
+		showGroundingMenu,
+		showUrlMenu,
+		showToolsMenu,
+		onboardingActive,
+	} = state;
+
+	const isOverlayOpen = useMemo(() => {
+		return (
+			showDeviceMenu ||
+			showSettingsMenu ||
+			showModelMenu ||
+			showProviderMenu ||
+			showSessionMenu ||
+			showHotkeysPane ||
+			showGroundingMenu ||
+			showUrlMenu ||
+			showToolsMenu ||
+			onboardingActive
+		);
+	}, [
+		showDeviceMenu,
+		showSettingsMenu,
+		showModelMenu,
+		showProviderMenu,
+		showSessionMenu,
+		showHotkeysPane,
+		showGroundingMenu,
+		showUrlMenu,
+		showToolsMenu,
+		onboardingActive,
+	]);
+
+	const closeAllOverlays = useCallback(() => {
+		actions.setShowDeviceMenu(false);
+		actions.setShowSettingsMenu(false);
+		actions.setShowModelMenu(false);
+		actions.setShowProviderMenu(false);
+		actions.setShowSessionMenu(false);
+		actions.setShowHotkeysPane(false);
+		actions.setShowGroundingMenu(false);
+		actions.setShowUrlMenu(false);
+		actions.setShowToolsMenu(false);
+	}, [actions]);
+
+	return {
+		isOverlayOpen,
+		closeAllOverlays,
+	};
+}

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

@@ -0,0 +1,79 @@
+import { useEffect } from "react";
+import type { MutableRefObject } from "react";
+
+import { useAppSessions } from "./use-app-sessions";
+import { useGrounding } from "./use-grounding";
+import { useGroundingMenuController } from "./use-grounding-menu-controller";
+
+import { getDaemonManager } from "../state/daemon-state";
+
+export interface SessionControllerResult {
+	currentSessionId: string | null;
+	setCurrentSessionIdSafe: (id: string | null) => void;
+	currentSessionIdRef: MutableRefObject<string | null>;
+	ensureSessionId: () => Promise<string>;
+	setSessions: ReturnType<typeof useAppSessions>["setSessions"];
+	sessionMenuItems: ReturnType<typeof useAppSessions>["sessionMenuItems"];
+	handleFirstMessage: ReturnType<typeof useAppSessions>["handleFirstMessage"];
+
+	latestGroundingMap: ReturnType<typeof useGrounding>["latestGroundingMap"];
+	hasGrounding: boolean;
+
+	groundingInitialIndex: number;
+	groundingSelectedIndex: number;
+	setGroundingSelectedIndex: (idx: number) => void;
+	onGroundingSelect: (idx: number) => void;
+	onGroundingIndexChange: (idx: number) => void;
+}
+
+export function useSessionController({
+	showSessionMenu,
+}: {
+	showSessionMenu: boolean;
+}): SessionControllerResult {
+	const {
+		currentSessionId,
+		setCurrentSessionIdSafe,
+		currentSessionIdRef,
+		ensureSessionId,
+		setSessions,
+		sessionMenuItems,
+		handleFirstMessage,
+	} = useAppSessions({ showSessionMenu });
+
+	useEffect(() => {
+		const manager = getDaemonManager();
+		manager.setEnsureSessionId(() => ensureSessionId());
+		return () => manager.setEnsureSessionId(null);
+	}, [ensureSessionId]);
+
+	const { latestGroundingMap, hasGrounding } = useGrounding(currentSessionId);
+	const {
+		groundingInitialIndex,
+		groundingSelectedIndex,
+		setGroundingSelectedIndex,
+		onGroundingSelect,
+		onGroundingIndexChange,
+	} = useGroundingMenuController({ sessionId: currentSessionId, latestGroundingMap });
+
+	useEffect(() => {
+		setGroundingSelectedIndex(0);
+	}, [currentSessionId, setGroundingSelectedIndex]);
+
+	return {
+		currentSessionId,
+		setCurrentSessionIdSafe,
+		currentSessionIdRef,
+		ensureSessionId,
+		setSessions,
+		sessionMenuItems,
+		handleFirstMessage,
+		latestGroundingMap,
+		hasGrounding,
+		groundingInitialIndex,
+		groundingSelectedIndex,
+		setGroundingSelectedIndex,
+		onGroundingSelect,
+		onGroundingIndexChange,
+	};
+}

package/src/hooks/use-url-menu-items.ts

@@ -0,0 +1,19 @@
+import { useMemo } from "react";
+import type { ContentBlock, ConversationMessage, GroundingMap, UrlMenuItem } from "../types";
+import { deriveUrlMenuItems } from "../utils/derive-url-menu-items";
+
+export function useUrlMenuItems(params: {
+	conversationHistory: ConversationMessage[];
+	currentContentBlocks: ContentBlock[];
+	latestGroundingMap: GroundingMap | null;
+}): UrlMenuItem[] {
+	const { conversationHistory, currentContentBlocks, latestGroundingMap } = params;
+
+	return useMemo(() => {
+		return deriveUrlMenuItems({
+			conversationHistory,
+			currentContentBlocks,
+			latestGroundingMap,
+		});
+	}, [conversationHistory, currentContentBlocks, latestGroundingMap]);
+}

package/src/state/app-context.tsx

@@ -29,6 +29,10 @@ export interface MenuState {
 	setShowHotkeysPane: React.Dispatch<React.SetStateAction<boolean>>;
 	showGroundingMenu: boolean;
 	setShowGroundingMenu: React.Dispatch<React.SetStateAction<boolean>>;
+	showUrlMenu: boolean;
+	setShowUrlMenu: React.Dispatch<React.SetStateAction<boolean>>;
+	showToolsMenu: boolean;
+	setShowToolsMenu: React.Dispatch<React.SetStateAction<boolean>>;
 }
 
 export interface DeviceState {

package/src/state/daemon-state.ts

@@ -5,19 +5,21 @@
 
 import { AgentTurnRunner } from "../ai/agent-turn-runner";
 import { transcribeAudio } from "../ai/daemon-ai";
-import { debug } from "../utils/debug-logger";
-import { SpeechController } from "../voice/tts/speech-controller";
-import { VoiceInputController } from "../voice/voice-input-controller";
 import type {
-	ModelMessage,
+	BashApprovalLevel,
 	InteractionMode,
-	VoiceInteractionType,
-	SpeechSpeed,
+	ModelMessage,
 	ReasoningEffort,
-	BashApprovalLevel,
+	SpeechSpeed,
+	ToolToggles,
+	VoiceInteractionType,
 } from "../types";
+import { DEFAULT_TOOL_TOGGLES } from "../types";
 import { DaemonState } from "../types";
-import { daemonEvents, type DaemonStateEvents } from "./daemon-events";
+import { debug } 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";
 import { ModelHistoryStore } from "./model-history-store";
 
 /**
@@ -39,6 +41,7 @@ class DaemonStateManager {
 	private _speechSpeed: SpeechSpeed = 1.25;
 	private _reasoningEffort: ReasoningEffort = "medium";
 	private _bashApprovalLevel: BashApprovalLevel = "dangerous";
+	private _toolToggles: ToolToggles = { ...DEFAULT_TOOL_TOGGLES };
 	private _outputDeviceName: string | undefined = undefined;
 	private _turnId = 0;
 	private speechRunId = 0;
@@ -136,6 +139,14 @@ class DaemonStateManager {
 		this._bashApprovalLevel = level;
 	}
 
+	get toolToggles(): ToolToggles {
+		return this._toolToggles;
+	}
+
+	set toolToggles(toggles: ToolToggles) {
+		this._toolToggles = toggles;
+	}
+
 	get outputDeviceName(): string | undefined {
 		return this._outputDeviceName;
 	}

package/src/state/session-store.ts

@@ -131,6 +131,10 @@ function parseSessionUsage(raw: string): TokenUsage {
 			subagentPromptTokens: typeof parsed.subagentPromptTokens === "number" ? parsed.subagentPromptTokens : 0,
 			subagentCompletionTokens:
 				typeof parsed.subagentCompletionTokens === "number" ? parsed.subagentCompletionTokens : 0,
+			latestTurnPromptTokens:
+				typeof parsed.latestTurnPromptTokens === "number" ? parsed.latestTurnPromptTokens : undefined,
+			latestTurnCompletionTokens:
+				typeof parsed.latestTurnCompletionTokens === "number" ? parsed.latestTurnCompletionTokens : undefined,
 		};
 	} catch {
 		return { ...DEFAULT_SESSION_USAGE };