@oh-my-pi/pi-coding-agent 13.18.0 → 13.19.0

package/src/modes/components/session-observer-overlay.ts

@@ -0,0 +1,472 @@
+/**
+ * Session observer overlay component.
+ *
+ * Picker mode: lists main + active subagent sessions with live status.
+ * Viewer mode: renders a read-only transcript of the selected subagent's session
+ *   by reading its JSONL session file — shows thinking, text, tool calls, results.
+ *
+ * Lifecycle:
+ *   - shortcut opens picker
+ *   - Enter on a subagent -> viewer
+ *   - shortcut while in viewer -> back to picker
+ *   - Esc from viewer -> back to picker
+ *   - Esc from picker -> close overlay
+ *   - Enter on main session -> close overlay (jump back)
+ */
+import type { AssistantMessage, ToolResultMessage } from "@oh-my-pi/pi-ai";
+import { Container, Markdown, matchesKey, type SelectItem, SelectList, Spacer, Text } from "@oh-my-pi/pi-tui";
+import { formatDuration, formatNumber, logger } from "@oh-my-pi/pi-utils";
+import type { KeyId } from "../../config/keybindings";
+import type { SessionMessageEntry } from "../../session/session-manager";
+import { parseSessionEntries } from "../../session/session-manager";
+import { replaceTabs, shortenPath, truncateToWidth } from "../../tools/render-utils";
+import type { ObservableSession, SessionObserverRegistry } from "../session-observer-registry";
+import { getMarkdownTheme, getSelectListTheme, theme } from "../theme/theme";
+import { DynamicBorder } from "./dynamic-border";
+
+type Mode = "picker" | "viewer";
+
+/** Max thinking characters to show (long thinking can be huge) */
+const MAX_THINKING_CHARS = 600;
+/** Max tool args characters to display */
+const MAX_TOOL_ARGS_CHARS = 200;
+/** Max tool result text to display */
+const MAX_TOOL_RESULT_CHARS = 300;
+
+export class SessionObserverOverlayComponent extends Container {
+	#registry: SessionObserverRegistry;
+	#onDone: () => void;
+	#mode: Mode = "picker";
+	#selectList: SelectList;
+	#viewerContainer: Container;
+	#selectedSessionId?: string;
+	#observeKeys: KeyId[];
+	/** Cached parsed transcript per session file to avoid reparsing on every refresh */
+	#transcriptCache?: { path: string; bytesRead: number; entries: SessionMessageEntry[] };
+
+	constructor(registry: SessionObserverRegistry, onDone: () => void, observeKeys: KeyId[]) {
+		super();
+		this.#registry = registry;
+		this.#onDone = onDone;
+		this.#observeKeys = observeKeys;
+		this.#selectList = new SelectList([], 0, getSelectListTheme());
+		this.#viewerContainer = new Container();
+
+		this.#setupPicker();
+	}
+
+	#setupPicker(): void {
+		this.#mode = "picker";
+		this.children = [];
+
+		this.addChild(new DynamicBorder());
+		this.addChild(new Text(theme.bold(theme.fg("accent", "Session Observer")), 1, 0));
+		this.addChild(new Spacer(1));
+
+		const items = this.#buildPickerItems();
+		this.#selectList = new SelectList(items, Math.min(items.length, 12), getSelectListTheme());
+
+		this.#selectList.onSelect = item => {
+			if (item.value === "main") {
+				this.#onDone();
+				return;
+			}
+			this.#selectedSessionId = item.value;
+			this.#setupViewer();
+		};
+
+		this.#selectList.onCancel = () => {
+			this.#onDone();
+		};
+
+		this.addChild(this.#selectList);
+		this.addChild(new DynamicBorder());
+	}
+
+	#setupViewer(): void {
+		this.#mode = "viewer";
+		this.children = [];
+		this.#viewerContainer = new Container();
+		this.#refreshViewer();
+
+		this.addChild(new DynamicBorder());
+		this.addChild(this.#viewerContainer);
+		this.addChild(new Spacer(1));
+		this.addChild(new Text(theme.fg("dim", "Esc: back to picker  |  Ctrl+S: back to picker"), 1, 0));
+		this.addChild(new DynamicBorder());
+	}
+
+	/** Rebuild content from live registry data */
+	refreshFromRegistry(): void {
+		if (this.#mode === "picker") {
+			this.#refreshPickerItems();
+		} else if (this.#mode === "viewer" && this.#selectedSessionId) {
+			this.#refreshViewer();
+		}
+	}
+
+	#refreshPickerItems(): void {
+		// Preserve selection across refresh by matching on value
+		const previousValue = this.#selectList.getSelectedItem()?.value;
+
+		const items = this.#buildPickerItems();
+		const newList = new SelectList(items, Math.min(items.length, 12), getSelectListTheme());
+		newList.onSelect = this.#selectList.onSelect;
+		newList.onCancel = this.#selectList.onCancel;
+
+		if (previousValue) {
+			const newIndex = items.findIndex(i => i.value === previousValue);
+			if (newIndex >= 0) newList.setSelectedIndex(newIndex);
+		}
+
+		const idx = this.children.indexOf(this.#selectList);
+		if (idx >= 0) {
+			this.children[idx] = newList;
+		}
+		this.#selectList = newList;
+	}
+
+	#refreshViewer(): void {
+		this.#viewerContainer.clear();
+
+		const sessions = this.#registry.getSessions();
+		const session = sessions.find(s => s.id === this.#selectedSessionId);
+		if (!session) {
+			this.#viewerContainer.addChild(new Text(theme.fg("dim", "Session no longer available."), 1, 0));
+			return;
+		}
+
+		this.#renderSessionHeader(session);
+		this.#renderSessionTranscript(session);
+	}
+
+	#renderSessionHeader(session: ObservableSession): void {
+		const c = this.#viewerContainer;
+		const progress = session.progress;
+
+		// Header: label + status + [agent]
+		const statusColor = session.status === "active" ? "success" : session.status === "failed" ? "error" : "dim";
+		const statusText = theme.fg(statusColor, session.status);
+		const agentTag = session.agent ? theme.fg("dim", ` [${session.agent}]`) : "";
+		c.addChild(new Text(`${theme.bold(theme.fg("accent", session.label))}  ${statusText}${agentTag}`, 1, 0));
+
+		if (session.description) {
+			c.addChild(new Text(theme.fg("muted", session.description), 1, 0));
+		}
+
+		// Stats from progress
+		if (progress) {
+			const stats: string[] = [];
+			if (progress.toolCount > 0) stats.push(`${formatNumber(progress.toolCount)} tools`);
+			if (progress.tokens > 0) stats.push(`${formatNumber(progress.tokens)} tokens`);
+			if (progress.durationMs > 0) stats.push(formatDuration(progress.durationMs));
+			if (stats.length > 0) {
+				c.addChild(new Text(theme.fg("dim", stats.join(theme.sep.dot)), 1, 0));
+			}
+		}
+
+		if (session.sessionFile) {
+			c.addChild(new Text(theme.fg("dim", `Session: ${shortenPath(session.sessionFile)}`), 1, 0));
+		}
+
+		c.addChild(new DynamicBorder());
+	}
+
+	/** Incrementally read and parse the session JSONL, caching already-parsed entries. */
+	#loadTranscript(sessionFile: string): SessionMessageEntry[] | null {
+		// Invalidate cache if session file changed (e.g. switched to different subagent)
+		if (this.#transcriptCache && this.#transcriptCache.path !== sessionFile) {
+			this.#transcriptCache = undefined;
+		}
+
+		const fromByte = this.#transcriptCache?.bytesRead ?? 0;
+		const result = readFileIncremental(sessionFile, fromByte);
+		if (!result) {
+			logger.debug("Session observer: failed to read session file", { path: sessionFile });
+			return this.#transcriptCache?.entries ?? null;
+		}
+
+		// File shrank (compaction or pruning rewrote it) — invalidate and re-read from scratch
+		if (result.newSize < fromByte) {
+			this.#transcriptCache = undefined;
+			return this.#loadTranscript(sessionFile);
+		}
+
+		if (!this.#transcriptCache) {
+			this.#transcriptCache = { path: sessionFile, bytesRead: 0, entries: [] };
+		}
+
+		// Parse only new bytes, but only up to the last complete line.
+		// A partial trailing record (mid-write) must not be consumed —
+		// we leave those bytes for the next refresh.
+		if (result.text.length > 0) {
+			const lastNewline = result.text.lastIndexOf("\n");
+			if (lastNewline >= 0) {
+				const completeChunk = result.text.slice(0, lastNewline + 1);
+				const newEntries = parseSessionEntries(completeChunk);
+				for (const entry of newEntries) {
+					if (entry.type === "message") {
+						this.#transcriptCache.entries.push(entry as SessionMessageEntry);
+					}
+				}
+				this.#transcriptCache.bytesRead = fromByte + Buffer.byteLength(completeChunk, "utf-8");
+			}
+			// If no newline found, the entire chunk is partial — leave bytesRead unchanged
+		}
+		return this.#transcriptCache.entries;
+	}
+
+	#renderSessionTranscript(session: ObservableSession): void {
+		const c = this.#viewerContainer;
+
+		if (!session.sessionFile) {
+			c.addChild(new Text(theme.fg("dim", "No session file available yet."), 1, 0));
+			return;
+		}
+
+		const messageEntries = this.#loadTranscript(session.sessionFile);
+		if (!messageEntries) {
+			c.addChild(new Text(theme.fg("dim", "Unable to read session file."), 1, 0));
+			return;
+		}
+		if (messageEntries.length === 0) {
+			c.addChild(new Text(theme.fg("dim", "No messages yet."), 1, 0));
+			return;
+		}
+
+		// Build a tool call ID -> tool result map for matching
+		const toolResults = new Map<string, ToolResultMessage>();
+		for (const entry of messageEntries) {
+			if (entry.message.role === "toolResult") {
+				toolResults.set(entry.message.toolCallId, entry.message);
+			}
+		}
+
+		for (const entry of messageEntries) {
+			const msg = entry.message;
+
+			if (msg.role === "assistant") {
+				this.#renderAssistantMessage(c, msg, toolResults);
+			} else if (msg.role === "user" || msg.role === "developer") {
+				// Show user/developer messages briefly
+				const text =
+					typeof msg.content === "string"
+						? msg.content
+						: msg.content
+								.filter((b): b is { type: "text"; text: string } => b.type === "text")
+								.map(b => b.text)
+								.join("\n");
+				if (text.trim()) {
+					const label = msg.role === "developer" ? "System" : "User";
+					c.addChild(new Spacer(1));
+					c.addChild(
+						new Text(
+							`${theme.fg("dim", `[${label}]`)} ${theme.fg("muted", truncateToWidth(text.trim(), 80))}`,
+							1,
+							0,
+						),
+					);
+				}
+			}
+			// toolResult entries are rendered inline with their tool calls above
+		}
+	}
+
+	#renderAssistantMessage(c: Container, msg: AssistantMessage, toolResults: Map<string, ToolResultMessage>): void {
+		for (const content of msg.content) {
+			if (content.type === "thinking" && content.thinking.trim()) {
+				const thinking = content.thinking.trim();
+				c.addChild(new Spacer(1));
+				if (thinking.length > MAX_THINKING_CHARS) {
+					// Show truncated thinking as markdown for proper formatting
+					const truncated = `${thinking.slice(0, MAX_THINKING_CHARS)}...`;
+					c.addChild(
+						new Markdown(truncated, 1, 0, getMarkdownTheme(), {
+							color: (t: string) => theme.fg("thinkingText", t),
+							italic: true,
+						}),
+					);
+				} else {
+					c.addChild(
+						new Markdown(thinking, 1, 0, getMarkdownTheme(), {
+							color: (t: string) => theme.fg("thinkingText", t),
+							italic: true,
+						}),
+					);
+				}
+			} else if (content.type === "text" && content.text.trim()) {
+				c.addChild(new Spacer(1));
+				c.addChild(new Markdown(content.text.trim(), 1, 0, getMarkdownTheme()));
+			} else if (content.type === "toolCall") {
+				this.#renderToolCall(c, content, toolResults);
+			}
+		}
+	}
+
+	#renderToolCall(
+		c: Container,
+		call: { id: string; name: string; arguments: Record<string, unknown>; intent?: string },
+		toolResults: Map<string, ToolResultMessage>,
+	): void {
+		c.addChild(new Spacer(1));
+
+		// Tool call header with intent
+		const intentStr = call.intent ? theme.fg("dim", ` ${truncateToWidth(call.intent, 50)}`) : "";
+		c.addChild(new Text(`${theme.fg("accent", "▸")} ${theme.bold(theme.fg("muted", call.name))}${intentStr}`, 1, 0));
+
+		// Key arguments (skip very long ones, show summary)
+		const argEntries = Object.entries(call.arguments);
+		if (argEntries.length > 0) {
+			const argSummary = this.#formatToolArgs(call.name, call.arguments);
+			if (argSummary) {
+				c.addChild(new Text(`  ${theme.fg("dim", argSummary)}`, 1, 0));
+			}
+		}
+
+		// Inline tool result
+		const result = toolResults.get(call.id);
+		if (result) {
+			this.#renderToolResult(c, result);
+		}
+	}
+
+	#formatToolArgs(toolName: string, args: Record<string, unknown>): string {
+		// Show the most relevant arg for common tools
+		switch (toolName) {
+			case "read":
+				return args.path ? `path: ${args.path}` : "";
+			case "write":
+				return args.path ? `path: ${args.path}` : "";
+			case "edit":
+				return args.path ? `path: ${args.path}` : "";
+			case "grep":
+				return [args.pattern ? `pattern: ${args.pattern}` : "", args.path ? `path: ${args.path}` : ""]
+					.filter(Boolean)
+					.join(", ");
+			case "find":
+				return args.pattern ? `pattern: ${args.pattern}` : "";
+			case "bash": {
+				const cmd = args.command;
+				if (typeof cmd === "string") {
+					return truncateToWidth(replaceTabs(cmd), 70);
+				}
+				return "";
+			}
+			case "lsp":
+				return [args.action, args.file, args.symbol].filter(Boolean).join(" ");
+			case "ast_grep":
+			case "ast_edit":
+				return args.path ? `path: ${args.path}` : "";
+			case "task": {
+				const tasks = args.tasks;
+				if (Array.isArray(tasks)) {
+					return `${tasks.length} task(s)`;
+				}
+				return "";
+			}
+			default: {
+				// Generic: show first few args truncated
+				const parts: string[] = [];
+				let total = 0;
+				for (const [key, value] of Object.entries(args)) {
+					if (key.startsWith("_")) continue;
+					const v = typeof value === "string" ? value : JSON.stringify(value);
+					const entry = `${key}: ${truncateToWidth(replaceTabs(v ?? ""), 40)}`;
+					if (total + entry.length > MAX_TOOL_ARGS_CHARS) break;
+					parts.push(entry);
+					total += entry.length;
+				}
+				return parts.join(", ");
+			}
+		}
+	}
+
+	#renderToolResult(c: Container, result: ToolResultMessage): void {
+		const textParts = result.content
+			.filter((p): p is { type: "text"; text: string } => p.type === "text")
+			.map(p => p.text);
+		const text = textParts.join("\n").trim();
+
+		if (result.isError) {
+			const preview = truncateToWidth(replaceTabs(text || "Error"), 70);
+			c.addChild(new Text(`  ${theme.fg("error", `✗ ${preview}`)}`, 1, 0));
+		} else if (text) {
+			// Show brief result preview
+			const lines = text.split("\n");
+			if (lines.length === 1 && text.length < MAX_TOOL_RESULT_CHARS) {
+				c.addChild(new Text(`  ${theme.fg("dim", `✓ ${truncateToWidth(replaceTabs(text), 70)}`)}`, 1, 0));
+			} else {
+				c.addChild(new Text(`  ${theme.fg("dim", `✓ ${lines.length} lines`)}`, 1, 0));
+			}
+		} else {
+			c.addChild(new Text(`  ${theme.fg("dim", "✓ done")}`, 1, 0));
+		}
+	}
+
+	#buildPickerItems(): SelectItem[] {
+		const sessions = this.#registry.getSessions();
+		return sessions.map(s => {
+			const statusIcon =
+				s.status === "active" ? "●" : s.status === "completed" ? "✓" : s.status === "failed" ? "✗" : "○";
+			const statusColor = s.status === "active" ? "success" : s.status === "failed" ? "error" : "dim";
+			const prefix = theme.fg(statusColor, statusIcon);
+			const agentSuffix = s.agent ? theme.fg("dim", ` [${s.agent}]`) : "";
+			const label = s.kind === "main" ? `${prefix} ${s.label} (return)` : `${prefix} ${s.label}${agentSuffix}`;
+
+			// Show current activity in the picker description for subagents
+			let description = s.description;
+			if (s.progress?.currentTool) {
+				const intent = s.progress.lastIntent;
+				description = intent ? `${s.progress.currentTool}: ${truncateToWidth(intent, 40)}` : s.progress.currentTool;
+			}
+
+			return { value: s.id, label, description };
+		});
+	}
+
+	handleInput(keyData: string): void {
+		for (const key of this.#observeKeys) {
+			if (matchesKey(keyData, key)) {
+				if (this.#mode === "viewer") {
+					this.#setupPicker();
+					return;
+				}
+				this.#onDone();
+				return;
+			}
+		}
+
+		if (this.#mode === "picker") {
+			this.#selectList.handleInput(keyData);
+		} else if (this.#mode === "viewer") {
+			if (matchesKey(keyData, "escape")) {
+				this.#setupPicker();
+				return;
+			}
+		}
+	}
+}
+
+// Sync helpers for render path — avoid async in component rendering
+import * as fs from "node:fs";
+
+/**
+ * Read new bytes from a file starting at the given byte offset.
+ * Returns the new text and updated file size, or null on error.
+ */
+function readFileIncremental(filePath: string, fromByte: number): { text: string; newSize: number } | null {
+	try {
+		const stat = fs.statSync(filePath);
+		if (stat.size <= fromByte) return { text: "", newSize: stat.size };
+		const buf = Buffer.alloc(stat.size - fromByte);
+		const fd = fs.openSync(filePath, "r");
+		try {
+			fs.readSync(fd, buf, 0, buf.length, fromByte);
+		} finally {
+			fs.closeSync(fd);
+		}
+		return { text: buf.toString("utf-8"), newSize: stat.size };
+	} catch {
+		return null;
+	}
+}

package/src/modes/components/settings-defs.ts

@@ -109,6 +109,25 @@ const OPTION_PROVIDERS: Partial<Record<SettingPath, OptionProvider>> = {
 		{ value: "300000", label: "300K tokens", description: "Large context window" },
 		{ value: "500000", label: "500K tokens", description: "Very large context window" },
 	],
+	"compaction.idleThresholdTokens": [
+		{ value: "100000", label: "100K tokens" },
+		{ value: "200000", label: "200K tokens" },
+		{ value: "300000", label: "300K tokens" },
+		{ value: "400000", label: "400K tokens" },
+		{ value: "500000", label: "500K tokens" },
+		{ value: "600000", label: "600K tokens" },
+		{ value: "700000", label: "700K tokens" },
+		{ value: "800000", label: "800K tokens" },
+		{ value: "900000", label: "900K tokens" },
+	],
+	"compaction.idleTimeoutSeconds": [
+		{ value: "60", label: "1 minute" },
+		{ value: "120", label: "2 minutes" },
+		{ value: "300", label: "5 minutes" },
+		{ value: "600", label: "10 minutes" },
+		{ value: "1800", label: "30 minutes" },
+		{ value: "3600", label: "1 hour" },
+	],
 	// Retry max retries
 	"retry.maxRetries": [
 		{ value: "1", label: "1 retry" },

package/src/modes/components/status-line.ts

@@ -1,20 +1,20 @@
 import * as fs from "node:fs";
 import type { AssistantMessage } from "@oh-my-pi/pi-ai";
 import { type Component, truncateToWidth, visibleWidth } from "@oh-my-pi/pi-tui";
-import { formatCount } from "@oh-my-pi/pi-utils";
+import { formatCount, getProjectDir } from "@oh-my-pi/pi-utils";
 import { $ } from "bun";
 import { settings } from "../../config/settings";
 import type { StatusLinePreset, StatusLineSegmentId, StatusLineSeparatorStyle } from "../../config/settings-schema";
 import { theme } from "../../modes/theme/theme";
 import type { AgentSession } from "../../session/agent-session";
 import { calculatePromptTokens } from "../../session/compaction/compaction";
-import { findGitHeadPathSync, sanitizeStatusText } from "../shared";
+import * as git from "../../utils/git";
+import { sanitizeStatusText } from "../shared";
 import {
 	canReuseCachedPr,
 	createPrCacheContext,
 	isSamePrCacheContext,
 	type PrCacheContext,
-	parseDefaultBranch,
 } from "./status-line/git-utils";
 import { getPreset } from "./status-line/presets";
 import { renderSegment, type SegmentContext } from "./status-line/segments";
@@ -120,7 +120,7 @@ export class StatusLineComponent implements Component {
 			this.#gitWatcher = null;
 		}
 
-		const gitHeadPath = findGitHeadPathSync();
+		const gitHeadPath = git.repo.resolveSync(getProjectDir())?.headPath ?? null;
 		if (!gitHeadPath) return;
 
 		try {
@@ -152,46 +152,33 @@ export class StatusLineComponent implements Component {
 		this.#cachedPrContext = undefined;
 	}
 	#getCurrentBranch(): string | null {
-		const gitHeadPath = findGitHeadPathSync();
+		const head = git.head.resolveSync(getProjectDir());
+		const gitHeadPath = head?.headPath ?? null;
 		if (this.#cachedBranch !== undefined && this.#cachedBranchRepoId === gitHeadPath) {
 			return this.#cachedBranch;
 		}
 
 		this.#cachedBranchRepoId = gitHeadPath;
-		if (!gitHeadPath) {
+		if (!head) {
 			this.#cachedBranch = null;
 			return null;
 		}
 
-		try {
-			const content = fs.readFileSync(gitHeadPath, "utf8").trim();
-
-			if (content.startsWith("ref: refs/heads/")) {
-				this.#cachedBranch = content.slice(16);
-			} else {
-				this.#cachedBranch = "detached";
-			}
-		} catch {
-			this.#cachedBranch = null;
-		}
+		this.#cachedBranch = head.kind === "ref" ? (head.branchName ?? head.ref) : "detached";
 
 		return this.#cachedBranch ?? null;
 	}
 
 	#isDefaultBranch(branch: string): boolean {
 		if (this.#defaultBranch === undefined) {
-			// Kick off async resolution, use hardcoded fallback until it resolves
 			this.#defaultBranch = "main";
 			(async () => {
-				// Try origin/HEAD first, fall back to upstream/HEAD
-				const origin = await $`git rev-parse --abbrev-ref origin/HEAD`.quiet().nothrow();
-				if (origin.exitCode === 0) {
-					this.#defaultBranch = parseDefaultBranch(origin.stdout.toString().trim());
-					return;
-				}
-				const upstream = await $`git rev-parse --abbrev-ref upstream/HEAD`.quiet().nothrow();
-				if (upstream.exitCode === 0) {
-					this.#defaultBranch = parseDefaultBranch(upstream.stdout.toString().trim());
+				const resolved = await git.branch.default(getProjectDir());
+				if (resolved) {
+					this.#defaultBranch = resolved;
+					if (this.#onBranchChange) {
+						this.#onBranchChange();
+					}
 				}
 			})();
 		}
@@ -205,42 +192,9 @@ export class StatusLineComponent implements Component {
 
 		this.#gitStatusInFlight = true;
 
-		// Fire async fetch, return cached value
 		(async () => {
 			try {
-				const result = await $`git --no-optional-locks status --porcelain`.quiet().nothrow();
-
-				if (result.exitCode !== 0) {
-					this.#cachedGitStatus = null;
-					return;
-				}
-
-				const output = result.stdout.toString();
-
-				let staged = 0;
-				let unstaged = 0;
-				let untracked = 0;
-
-				for (const line of output.split("\n")) {
-					if (!line) continue;
-					const x = line[0];
-					const y = line[1];
-
-					if (x === "?" && y === "?") {
-						untracked++;
-						continue;
-					}
-
-					if (x && x !== " " && x !== "?") {
-						staged++;
-					}
-
-					if (y && y !== " ") {
-						unstaged++;
-					}
-				}
-
-				this.#cachedGitStatus = { staged, unstaged, untracked };
+				this.#cachedGitStatus = await git.status.summary(getProjectDir());
 			} catch {
 				this.#cachedGitStatus = null;
 			} finally {

package/src/modes/controllers/command-controller.ts

@@ -586,6 +586,7 @@ export class CommandController {
 			}
 		}
 		await this.ctx.session.newSession();
+		this.ctx.resetObserverRegistry();
 		setSessionTerminalTitle(this.ctx.sessionManager.getSessionName(), this.ctx.sessionManager.getCwd());
 
 		this.ctx.statusLine.invalidate();