@antelopejs/dms-ai 0.8.0 → 0.9.1

package/frontend-vue/app/chat/composables/useConversationMode.ts

@@ -1,9 +1,9 @@
 import { computed, type ComputedRef, type Ref } from "vue";
+import { modeFor } from "../constants/modes";
 import { CLIENT_MESSAGE_TYPES } from "../constants/protocol";
 import type {
 	ApprovalMode,
 	ConversationModeState,
-	FullAutoDuration,
 	Scope,
 } from "../types/protocol";
 import type { AppSettings } from "../types/settings";
@@ -17,12 +17,10 @@ export interface UseConversationModeOptions {
 }
 
 export interface UseConversationModeResult {
-	/** The chat's mode, its scope and Full auto, defaults until the sidecar says. */
+	/** The chat's mode and its scope, defaults until the sidecar says. */
 	current: ComputedRef<ConversationModeState>;
 	setMode: (mode: ApprovalMode) => void;
 	setScope: (scope: Scope) => void;
-	startFullAuto: (duration: FullAutoDuration) => void;
-	stopFullAuto: () => void;
 }
 
 function effectiveScope(scope: Scope, builderAvailable: boolean): Scope {
@@ -30,9 +28,10 @@ function effectiveScope(scope: Scope, builderAvailable: boolean): Scope {
 }
 
 /**
- * The active chat's approval mode, scope and Full auto: what the sidecar says,
- * or the defaults for new chats from the settings until it has. Changes apply
- * at once here and are sent for the sidecar to confirm.
+ * The active chat's approval mode and scope: what the sidecar says,
+ * or the current provider's default from the settings until it has. A mode the
+ * provider does not have reads as Ask first. Changes apply at once here and
+ * are sent for the sidecar to confirm.
  */
 export function useConversationMode(
 	options: UseConversationModeOptions,
@@ -40,12 +39,12 @@ export function useConversationMode(
 	const current = computed<ConversationModeState>(() => {
 		const { settings, mode } = options;
 		const base: ConversationModeState = mode.value ?? {
-			mode: settings.value.mode,
+			mode: settings.value.defaultModes[settings.value.provider],
 			generationMode: settings.value.generationMode,
-			fullAuto: null,
 		};
 		return {
 			...base,
+			mode: modeFor(settings.value.provider, base.mode),
 			generationMode: effectiveScope(
 				base.generationMode,
 				settings.value.builderAvailable,
@@ -67,7 +66,5 @@ export function useConversationMode(
 		current,
 		setMode: (mode) => change({ mode }),
 		setScope: (generationMode) => change({ generationMode }),
-		startFullAuto: (duration) => change({ fullAuto: { duration } }),
-		stopFullAuto: () => change({ fullAuto: null }),
 	};
 }

package/frontend-vue/app/chat/composables/useFollowScroll.ts

@@ -0,0 +1,77 @@
+import { type Ref, watch } from "vue";
+
+const BOTTOM_EPSILON_PX = 4;
+
+function distanceFromBottom(el: HTMLElement): number {
+	return el.scrollHeight - el.scrollTop - el.clientHeight;
+}
+
+function scrollToBottom(el: HTMLElement): void {
+	el.scrollTop = el.scrollHeight;
+}
+
+/**
+ * Keeps a scrolling container on its newest content while it follows. The
+ * view follows from the start. An upward scroll that leaves it more than a few
+ * pixels from the bottom stops the following, whatever caused it (wheel, keys,
+ * scrollbar, find in page, text selection). A scroll that reaches the bottom,
+ * or a call to `follow`, starts it again. This holds because the scrolls made
+ * here only go down, and a scroll the browser makes when content shrinks
+ * still ends at the bottom. A resize of the container or of anything inside
+ * it re-pins the bottom, so growth that changes no reactive data (docks,
+ * images, wrapping, cards that open) is followed too.
+ */
+export function useFollowScroll(scrollEl: Ref<HTMLElement | null>): {
+	/** Jumps to the bottom and follows from there. */
+	follow: () => void;
+} {
+	let following = true;
+
+	function follow(): void {
+		following = true;
+		if (scrollEl.value !== null) scrollToBottom(scrollEl.value);
+	}
+
+	function attach(el: HTMLElement): () => void {
+		let lastTop = el.scrollTop;
+
+		const onScroll = (): void => {
+			const top = el.scrollTop;
+			const movedUp = top < lastTop;
+			lastTop = top;
+			if (distanceFromBottom(el) <= BOTTOM_EPSILON_PX) following = true;
+			else if (movedUp) following = false;
+		};
+
+		const resizes = new ResizeObserver(() => {
+			if (following) scrollToBottom(el);
+		});
+		const observeContent = (): void => {
+			resizes.disconnect();
+			resizes.observe(el);
+			for (const child of el.children) resizes.observe(child);
+		};
+		const children = new MutationObserver(observeContent);
+		observeContent();
+		children.observe(el, { childList: true });
+
+		el.addEventListener("scroll", onScroll, { passive: true });
+
+		return () => {
+			resizes.disconnect();
+			children.disconnect();
+			el.removeEventListener("scroll", onScroll);
+		};
+	}
+
+	watch(
+		scrollEl,
+		(el, _previous, onCleanup) => {
+			if (el === null) return;
+			onCleanup(attach(el));
+		},
+		{ immediate: true, flush: "post" },
+	);
+
+	return { follow };
+}

package/frontend-vue/app/chat/constants/modes.ts

@@ -0,0 +1,15 @@
+import type { ApprovalMode, ProviderName } from "../types/protocol";
+
+export const MODES_BY_PROVIDER: Record<ProviderName, readonly ApprovalMode[]> =
+	{
+		claude: ["normal", "auto", "acceptEdits", "plan"],
+		codex: ["normal", "acceptEdits", "plan"],
+	};
+
+/** The mode as the provider has it: one it lacks reads as Ask first. */
+export function modeFor(
+	provider: ProviderName,
+	mode: ApprovalMode,
+): ApprovalMode {
+	return MODES_BY_PROVIDER[provider].includes(mode) ? mode : "normal";
+}

package/frontend-vue/app/chat/constants/protocol.ts

@@ -14,7 +14,6 @@ export const CLIENT_MESSAGE_TYPES = {
 	QUEUE_CLEAR: "queue_clear",
 	REVOKE_RULE: "revoke_rule",
 	SET_CONVERSATION_MODE: "set_conversation_mode",
-	LEAVE_CONVERSATION: "leave_conversation",
 	STOP_AUTOFIX: "stop_autofix",
 	RETRY_TURN: "retry_turn",
 	CHANGE_SET_ACTION: "change_set_action",

package/frontend-vue/app/chat/constants/settings.ts

@@ -4,7 +4,7 @@ const DEFAULT_REQUEST_TIMEOUT_MINUTES = 5;
 
 export const DEFAULT_SETTINGS: AppSettings = {
 	provider: "claude",
-	mode: "normal",
+	defaultModes: { claude: "auto", codex: "normal" },
 	thinking: "medium",
 	generationMode: "safe",
 	allowLocalSkills: false,

package/frontend-vue/app/chat/types/protocol.ts

@@ -5,9 +5,8 @@
  */
 
 export type ProviderName = "claude" | "codex";
-export type ApprovalMode = "normal" | "acceptEdits" | "plan";
+export type ApprovalMode = "normal" | "auto" | "acceptEdits" | "plan";
 export type Scope = "safe" | "vibe";
-export type FullAutoDuration = "turn" | "30m" | "chat";
 
 export type ToolOutcome = "done" | "failed" | "denied" | "blocked" | "stopped";
 
@@ -17,6 +16,8 @@ export type AllowedBy =
 	| "approved"
 	| "rule"
 	| "full_auto"
+	| "auto_approved"
+	| "auto_denied"
 	| "blocked"
 	| "denied"
 	| "expired";
@@ -165,21 +166,30 @@ export interface FullAutoEndedNotice {
 	timestampMs: number;
 }
 
+export interface ModelFallbackNotice {
+	kind: "model_fallback";
+	requestedModel: string;
+	usedModel: string;
+	timestampMs: number;
+}
+
+export interface AutoUnavailableNotice {
+	kind: "auto_unavailable";
+	model: string;
+	timestampMs: number;
+}
+
 export type Notice =
 	| AutoFixNotice
 	| PermissionExpiredNotice
 	| QuestionSkippedNotice
-	| FullAutoEndedNotice;
-
-export interface FullAutoState {
-	duration: FullAutoDuration;
-	untilMs?: number;
-}
+	| FullAutoEndedNotice
+	| ModelFallbackNotice
+	| AutoUnavailableNotice;
 
 export interface ConversationModeState {
 	mode: ApprovalMode;
 	generationMode: Scope;
-	fullAuto: FullAutoState | null;
 }
 
 export interface QuestionAnswerRecord {

package/frontend-vue/app/chat/types/settings.ts

@@ -3,16 +3,21 @@ import type { ApprovalMode, ProviderName, Scope } from "./protocol";
 export type ThinkingLevel = "off" | "low" | "medium" | "high";
 export type { ProviderName };
 
+/** The unavailability reasons the panel words itself (sidecar `PROVIDER_UNAVAILABLE_CODES`). */
+export type ProviderUnavailableCode = "codex_not_signed_in";
+
 export interface ProviderAvailability {
 	available: boolean;
-	/** Why the provider cannot be picked; absent when it is available. */
+	/** Why the provider cannot be picked, in English; absent when it is available. */
 	reason?: string;
+	/** Names the reason when the panel has its own wording for it. */
+	code?: ProviderUnavailableCode;
 }
 
 export interface AppSettings {
 	provider: ProviderName;
 	/** The default approval mode of new chats. */
-	mode: ApprovalMode;
+	defaultModes: Record<ProviderName, ApprovalMode>;
 	thinking: ThinkingLevel;
 	/** The default scope of new chats. */
 	generationMode: Scope;

package/frontend-vue/app/chat/utils/permission-view.ts

@@ -90,6 +90,7 @@ const DESTRUCTIVE_TITLE_KEYS: Record<string, string> = {
 	BuilderRemoveField: "dms_ai.panel.approvals.destructive.remove_field",
 	BuilderDeleteCategory: "dms_ai.panel.approvals.destructive.delete_category",
 	BuilderRemoveQuery: "dms_ai.panel.approvals.destructive.remove_query",
+	BuilderMapResources: "dms_ai.panel.approvals.destructive.map_resources",
 };
 
 function destructiveTitle(

package/frontend-vue/app/chat/utils/status-label.ts

@@ -0,0 +1,50 @@
+import type { Translate } from "../composables/useChatI18n";
+import { formatClock } from "./format";
+
+export type StatusKind =
+	| "ready"
+	| "working"
+	| "waiting"
+	| "connecting"
+	| "offline";
+
+export interface StatusFacts {
+	kind: StatusKind;
+	elapsedMs: number;
+	pendingCount: number;
+	agentName: string;
+	/** The model that answered last; null until a reply names it. */
+	model: string | null;
+}
+
+const PART_SEPARATOR = " · ";
+
+function stateLabel(facts: StatusFacts, t: Translate): string {
+	const labels: Record<StatusKind, () => string> = {
+		ready: () => t("dms_ai.panel.status.ready"),
+		working: () =>
+			t("dms_ai.panel.status.working", { time: formatClock(facts.elapsedMs) }),
+		waiting: () =>
+			t(
+				"dms_ai.panel.status.waiting",
+				{ count: facts.pendingCount },
+				facts.pendingCount,
+			),
+		connecting: () => t("dms_ai.panel.status.connecting"),
+		offline: () => t("dms_ai.panel.status.offline"),
+	};
+	return labels[facts.kind]();
+}
+
+/**
+ * The panel's status line: the state, then the agent, then the model that
+ * answered last ("Ready · Claude Code · claude-opus-5-5"). Offline has no
+ * agent to name.
+ */
+export function describeStatus(facts: StatusFacts, t: Translate): string {
+	const label = stateLabel(facts, t);
+	if (facts.kind === "offline") return label;
+	const parts = [label, facts.agentName];
+	if (facts.model !== null) parts.push(facts.model);
+	return parts.join(PART_SEPARATOR);
+}

package/frontend-vue/app/chat/utils/tool-lexicon.ts

@@ -374,6 +374,16 @@ const BUILDER_TOOLS: Record<string, ToolLexiconEntry> = {
 		icon: ICONS.BLOCK,
 		target: firstOf("path"),
 	},
+	BuilderComposePage: {
+		verb: "compose_page",
+		icon: ICONS.BLOCK,
+		target: firstOf("pageRef"),
+	},
+	BuilderConfigureTableView: {
+		verb: "configure_table_view",
+		icon: ICONS.BLOCK,
+		target: firstOf("pageRef"),
+	},
 	BuilderMoveBlock: {
 		verb: "move_block",
 		icon: ICONS.BLOCK,
@@ -475,6 +485,12 @@ const BUILDER_TOOLS: Record<string, ToolLexiconEntry> = {
 		icon: ICONS.DATA,
 		target: firstOf("name"),
 	},
+	BuilderPreviewQuery: {
+		verb: "preview_query",
+		icon: ICONS.DATA,
+		target: firstOf("name"),
+		isReadOnly: true,
+	},
 	BuilderConfigureQuery: {
 		verb: "configure_query",
 		icon: ICONS.DATA,

package/frontend-vue/app/plugins/ai.client.ts

@@ -268,8 +268,8 @@ function createSession(parts: SessionParts): AssistantSession {
 			intents.push({ kind: "open", conversationId });
 			panel.open();
 		},
-		startConversation: (prompt, mode) => {
-			intents.push({ kind: "start", prompt, mode });
+		startConversation: (prompt, mode, send) => {
+			intents.push({ kind: "start", prompt, mode, send });
 			panel.open();
 		},
 		holdStream: parts.holds.hold,

package/frontend-vue/app/runtime/assistant-actions.ts

@@ -14,10 +14,12 @@ export interface PublicAssistantActions {
 	/**
 	 * Opens the assistant panel on a new conversation with `prompt` in the composer, unsent. With
 	 * `mode`, the conversation is set to it first: `plan` makes the agent end with a plan to approve.
+	 * With `send`, the prompt is sent as the first message once the stream is up, and the composer
+	 * stays empty.
 	 */
 	startConversation: (
 		prompt: string,
-		options?: { mode?: ConversationStartMode },
+		options?: { mode?: ConversationStartMode; send?: boolean },
 	) => void;
 }
 
@@ -36,6 +38,6 @@ export function publicAssistantActions(
 			return session.value !== null;
 		},
 		startConversation: (prompt, options) =>
-			session.value?.startConversation(prompt, options?.mode),
+			session.value?.startConversation(prompt, options?.mode, options?.send),
 	};
 }

package/frontend-vue/app/runtime/assistant-session.ts

@@ -38,7 +38,11 @@ export interface AssistantSession {
 	 * Opens the panel on a new conversation, the composer optionally prefilled, and the
 	 * conversation set to `mode` first when one is given.
 	 */
-	startConversation: (prompt?: string, mode?: ConversationStartMode) => void;
+	startConversation: (
+		prompt?: string,
+		mode?: ConversationStartMode,
+		send?: boolean,
+	) => void;
 	/**
 	 * Keeps the tab's stream open while the panel is closed, until the returned
 	 * function releases it: the command palette's answer streams through it.

package/frontend-vue/app/runtime/block-health.ts

@@ -0,0 +1,135 @@
+/**
+ * What the DMS data blocks (charts, KPIs, lists, tables) say about themselves.
+ * Each states its kind, its layout path and what its reader sees on its root
+ * element; a test harness reads the same attributes. A host that predates
+ * them states nothing, and the page reads as having no data block.
+ */
+const BLOCK_SELECTOR = "[data-dms-block-state]";
+const STATE_ATTRIBUTE = "data-dms-block-state";
+const TYPE_ATTRIBUTE = "data-dms-block-type";
+const PATH_ATTRIBUTE = "data-dms-block";
+const UNKNOWN_TYPE = "Block";
+
+/** How long the host waits for a page's blocks to stop loading. */
+export const BLOCK_SETTLE_BUDGET_MS = 15_000;
+/** How long the blocks of a page must stay unchanged before it counts as settled. */
+export const BLOCK_QUIET_MS = 700;
+
+const BLOCK_STATES = ["loading", "ok", "empty", "error"] as const;
+type BlockState = (typeof BLOCK_STATES)[number];
+type ReportedState = Exclude<BlockState, "ok">;
+
+export interface BlockFact {
+	path?: string;
+	type: string;
+	state: BlockState;
+}
+
+export interface ReportedBlock extends BlockFact {
+	state: ReportedState;
+}
+
+export interface PageBlocks {
+	status: "settled" | "timeout" | "superseded";
+	checked: number;
+	/** The blocks showing no data: empty, failed, or still loading. */
+	blocks: ReportedBlock[];
+}
+
+function isBlockState(value: string | null): value is BlockState {
+	return BLOCK_STATES.some((state) => state === value);
+}
+
+function isReported(block: BlockFact): block is ReportedBlock {
+	return block.state !== "ok";
+}
+
+function readBlock(element: Element): BlockFact | null {
+	const state = element.getAttribute(STATE_ATTRIBUTE);
+	if (!isBlockState(state)) return null;
+	const path = element.getAttribute(PATH_ATTRIBUTE);
+	return {
+		...(path === null ? {} : { path }),
+		type: element.getAttribute(TYPE_ATTRIBUTE) ?? UNKNOWN_TYPE,
+		state,
+	};
+}
+
+/** The data blocks under `root`, in document order. */
+export function readBlocks(root: ParentNode): BlockFact[] {
+	return [...root.querySelectorAll(BLOCK_SELECTOR)].flatMap((element) => {
+		const block = readBlock(element);
+		return block === null ? [] : [block];
+	});
+}
+
+function holdsBlock(node: Node): boolean {
+	return (
+		node instanceof Element &&
+		(node.matches(BLOCK_SELECTOR) ||
+			node.querySelector(BLOCK_SELECTOR) !== null)
+	);
+}
+
+function changesBlocks(record: MutationRecord): boolean {
+	if (record.type === "attributes") return true;
+	return [...record.addedNodes, ...record.removedNodes].some(holdsBlock);
+}
+
+export interface AwaitSettledBlocksOptions {
+	root: Document;
+	/** Aborted when another navigation starts: the wait ends as `superseded`. */
+	signal: AbortSignal;
+	budgetMs?: number;
+	quietMs?: number;
+}
+
+/**
+ * Resolves when the blocks of the page have stopped changing for `quietMs`
+ * and none is loading, or at `budgetMs` with the blocks still loading named,
+ * or at once when `signal` aborts.
+ */
+export function awaitSettledBlocks(
+	options: AwaitSettledBlocksOptions,
+): Promise<PageBlocks> {
+	const { root, signal } = options;
+	const budgetMs = options.budgetMs ?? BLOCK_SETTLE_BUDGET_MS;
+	const quietMs = options.quietMs ?? BLOCK_QUIET_MS;
+	return new Promise((resolve) => {
+		let quietTimer: ReturnType<typeof setTimeout> | undefined;
+		const finish = (status: PageBlocks["status"]): void => {
+			clearTimeout(quietTimer);
+			clearTimeout(budgetTimer);
+			observer.disconnect();
+			signal.removeEventListener("abort", onAbort);
+			const facts = readBlocks(root);
+			resolve({
+				status,
+				checked: facts.length,
+				blocks: facts.filter(isReported),
+			});
+		};
+		const onQuiet = (): void => {
+			if (readBlocks(root).every((block) => block.state !== "loading"))
+				finish("settled");
+		};
+		const restartQuiet = (): void => {
+			clearTimeout(quietTimer);
+			quietTimer = setTimeout(onQuiet, quietMs);
+		};
+		const onAbort = (): void => finish("superseded");
+		const observer = new MutationObserver((records) => {
+			if (records.some(changesBlocks)) restartQuiet();
+		});
+		const budgetTimer = setTimeout(() => finish("timeout"), budgetMs);
+		if (signal.aborted) return finish("superseded");
+		signal.addEventListener("abort", onAbort);
+		observer.observe(root, {
+			subtree: true,
+			childList: true,
+			attributes: true,
+			attributeFilter: [STATE_ATTRIBUTE],
+		});
+		restartQuiet();
+	});
+}

package/frontend-vue/app/runtime/constants.ts

@@ -40,6 +40,7 @@ export const HELLO_MESSAGE_TYPE = "hello";
 export const LOG_PREFIX = "[dms-ai]";
 export const HOST_STATE_UPDATE_TYPE = "host_state_update";
 export const HOST_NAVIGATION_COMPLETE_TYPE = "host_navigation_complete";
+export const HOST_PAGE_BLOCKS_TYPE = "host_page_blocks";
 export const HOST_COMMAND_NAVIGATE_TYPE = "host_command_navigate";
 /** Frames of the tab's stream meant for the dashboard; every other one is the chat's. */
 export const HOST_COMMAND_TYPES: ReadonlySet<string> = new Set([

package/frontend-vue/app/runtime/navigation-complete.ts

@@ -1,22 +1,63 @@
 import { router } from "@inertiajs/vue3";
-import { HOST_NAVIGATION_COMPLETE_TYPE } from "./constants";
+import {
+	awaitSettledBlocks,
+	BLOCK_SETTLE_BUDGET_MS,
+	type PageBlocks,
+} from "./block-health";
+import {
+	HOST_NAVIGATION_COMPLETE_TYPE,
+	HOST_PAGE_BLOCKS_TYPE,
+} from "./constants";
 
 interface HostNavigationCompleteMessage {
 	type: typeof HOST_NAVIGATION_COMPLETE_TYPE;
 	path: string;
+	/** A `host_page_blocks` message for this path follows within this long. */
+	blocksWithinMs: number;
 }
 
+interface HostPageBlocksMessage extends PageBlocks {
+	type: typeof HOST_PAGE_BLOCKS_TYPE;
+	path: string;
+}
+
+type NavigationMessage = HostNavigationCompleteMessage | HostPageBlocksMessage;
+
 interface InstallNavigationCompleteEmitterOptions {
-	send: (msg: HostNavigationCompleteMessage) => void;
+	send: (msg: NavigationMessage) => void;
 }
 
+/**
+ * Reports each completed visit at once, then what the page's data blocks
+ * showed once they settled, so the assistant learns of empty charts without
+ * a screenshot.
+ */
 export function installNavigationCompleteEmitter(
 	options: InstallNavigationCompleteEmitterOptions,
 ): () => void {
-	return router.on("navigate", (event) =>
+	let settling = new AbortController();
+	let stopped = false;
+	const stopNavigation = router.on("navigate", (event) => {
+		const path = new URL(event.detail.page.url, window.location.origin)
+			.pathname;
+		settling.abort();
+		settling = new AbortController();
 		options.send({
 			type: HOST_NAVIGATION_COMPLETE_TYPE,
-			path: new URL(event.detail.page.url, window.location.origin).pathname,
-		}),
-	);
+			path,
+			blocksWithinMs: BLOCK_SETTLE_BUDGET_MS,
+		});
+		void awaitSettledBlocks({
+			root: document,
+			signal: settling.signal,
+		}).then((blocks) => {
+			if (!stopped)
+				options.send({ type: HOST_PAGE_BLOCKS_TYPE, path, ...blocks });
+		});
+	});
+	return () => {
+		stopped = true;
+		settling.abort();
+		stopNavigation();
+	};
 }

package/frontend-vue/app/runtime/panel-intents.ts

@@ -7,11 +7,15 @@ interface OpenConversationIntent {
 	conversationId: string;
 }
 
-/** Opens the panel on a new conversation, the composer optionally prefilled, in `mode` when given. */
-interface StartConversationIntent {
+/**
+ * Opens the panel on a new conversation, in `mode` when given. The prompt is put in the composer,
+ * or sent as the first message when `send` is set.
+ */
+export interface StartConversationIntent {
 	kind: "start";
 	prompt?: string;
 	mode?: ConversationStartMode;
+	send?: boolean;
 }
 
 /** Puts the caret in the composer of the current conversation. */

package/frontend-vue/app/views/constants.ts

@@ -27,6 +27,8 @@ export const DECISION_STYLES: Record<AllowedBy, DecisionStyle> = {
 	approved: { icon: "i-ph-check-circle", iconClass: "text-success" },
 	rule: { icon: "i-ph-key", iconClass: "text-secondary" },
 	full_auto: { icon: "i-ph-lightning", iconClass: "text-secondary" },
+	auto_approved: { icon: "i-ph-seal-check", iconClass: "text-success" },
+	auto_denied: { icon: "i-ph-prohibit", iconClass: "text-warning" },
 	blocked: { icon: "i-ph-shield-warning", iconClass: "text-warning" },
 	denied: { icon: "i-ph-prohibit", iconClass: "text-error" },
 	expired: { icon: "i-ph-hourglass-simple", iconClass: "text-warning" },

package/frontend-vue/app/views/types.ts

@@ -2,7 +2,7 @@ import type { Tone } from "#dms-core/app/types/tone";
 
 type AgentId = "claude" | "codex";
 export type ScopeId = "safe" | "vibe";
-export type ApprovalMode = "normal" | "acceptEdits" | "plan";
+export type ApprovalMode = "normal" | "auto" | "acceptEdits" | "plan";
 type AssistantState = "ready" | "working" | "waiting";
 export type TypecheckOutcome = "passed" | "failed" | "skipped";
 export type ChangeSetState = "applied" | "undone";
@@ -16,6 +16,8 @@ export type AllowedBy =
 	| "approved"
 	| "rule"
 	| "full_auto"
+	| "auto_approved"
+	| "auto_denied"
 	| "blocked"
 	| "denied"
 	| "expired";