@tea-agent/loop-agent 0.40.0-next.4 → 0.40.0-next.6

package/dist/worker/console/chat/session-stats.js

@@ -0,0 +1,179 @@
+import { aggregateUsage, } from "./usage.js";
+function finiteNonNegative(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0
+        ? value
+        : undefined;
+}
+function eventTime(event) {
+    const value = Date.parse(event.at);
+    return Number.isFinite(value) ? value : undefined;
+}
+function usageSample(data) {
+    if (!data || typeof data !== "object")
+        return undefined;
+    const source = data;
+    const sample = {};
+    const numberFields = [
+        "inputTokens",
+        "outputTokens",
+        "cacheReadTokens",
+        "cacheWriteTokens",
+        "totalTokens",
+        "cost",
+    ];
+    for (const field of numberFields) {
+        const value = finiteNonNegative(source[field]);
+        if (value !== undefined)
+            sample[field] = value;
+    }
+    if (typeof source.estimated === "boolean")
+        sample.estimated = source.estimated;
+    if (typeof source.responseKey === "string" && source.responseKey) {
+        sample.responseKey = source.responseKey;
+    }
+    return Object.keys(sample).length > 0 ? sample : undefined;
+}
+function contextUsage(data) {
+    if (!data || typeof data !== "object")
+        return undefined;
+    const raw = data.contextUsage;
+    if (!raw || typeof raw !== "object")
+        return undefined;
+    const source = raw;
+    const contextWindow = finiteNonNegative(source.contextWindow);
+    if (contextWindow === undefined)
+        return undefined;
+    const tokens = source.tokens === null ? null : finiteNonNegative(source.tokens) ?? null;
+    const percent = source.percent === null ? null : finiteNonNegative(source.percent) ?? null;
+    return { tokens, contextWindow, percent };
+}
+function stepTiming(data) {
+    if (!data || typeof data !== "object")
+        return undefined;
+    const raw = data.timing;
+    if (!raw || typeof raw !== "object")
+        return undefined;
+    const source = raw;
+    return {
+        llmMs: finiteNonNegative(source.llmMs),
+        ttftMs: finiteNonNegative(source.ttftMs),
+        decodeMs: finiteNonNegative(source.decodeMs),
+        outputTokens: finiteNonNegative(source.outputTokens),
+    };
+}
+/**
+ * Fold the durable event log into the same whole-session statistics DSH shows
+ * below its composer. Missing timing evidence is omitted instead of inferred.
+ */
+export function deriveChatSessionTelemetry(events) {
+    const turns = new Set();
+    const stepStarts = new Map();
+    const toolStarts = new Map();
+    const usageSamples = [];
+    let latestContextUsage;
+    let steps = 0;
+    let llmMs = 0;
+    let toolMs = 0;
+    let ttftMs = 0;
+    let ttftSteps = 0;
+    let decodeMs = 0;
+    let decodeTokens = 0;
+    for (const event of events) {
+        const at = eventTime(event);
+        if (event.kind === "usage") {
+            const sample = usageSample(event.data);
+            if (sample)
+                usageSamples.push(sample);
+            latestContextUsage = contextUsage(event.data) ?? latestContextUsage;
+            continue;
+        }
+        if (event.kind === "agent_start") {
+            if (at !== undefined)
+                stepStarts.set(event.turnId, at);
+            continue;
+        }
+        if (event.kind === "tool_call") {
+            const toolCallId = event.data.toolCallId;
+            if (typeof toolCallId === "string" && toolCallId && at !== undefined) {
+                toolStarts.set(`${event.turnId}\u0000${toolCallId}`, at);
+            }
+            continue;
+        }
+        if (event.kind === "tool_result") {
+            const toolCallId = event.data.toolCallId;
+            if (typeof toolCallId === "string" && toolCallId && at !== undefined) {
+                const key = `${event.turnId}\u0000${toolCallId}`;
+                const startedAt = toolStarts.get(key);
+                if (startedAt !== undefined && at >= startedAt)
+                    toolMs += at - startedAt;
+                toolStarts.delete(key);
+                // The next assistant step starts after the last completed tool.
+                stepStarts.set(event.turnId, at);
+            }
+            continue;
+        }
+        if (event.kind !== "message_end")
+            continue;
+        turns.add(event.turnId);
+        steps += 1;
+        const recorded = stepTiming(event.data);
+        const startedAt = stepStarts.get(event.turnId);
+        if (recorded?.llmMs !== undefined)
+            llmMs += recorded.llmMs;
+        else if (at !== undefined && startedAt !== undefined && at >= startedAt) {
+            llmMs += at - startedAt;
+        }
+        if (recorded?.ttftMs !== undefined) {
+            ttftMs += recorded.ttftMs;
+            ttftSteps += 1;
+        }
+        if (recorded?.decodeMs !== undefined &&
+            recorded.decodeMs > 0 &&
+            recorded.outputTokens !== undefined) {
+            decodeMs += recorded.decodeMs;
+            decodeTokens += recorded.outputTokens;
+        }
+        stepStarts.delete(event.turnId);
+    }
+    const usage = aggregateUsage(usageSamples);
+    return {
+        stats: {
+            turns: turns.size,
+            steps,
+            llmMs,
+            toolMs,
+            ttftMs,
+            ttftSteps,
+            decodeMs,
+            decodeTokens,
+        },
+        usage: {
+            ...usage,
+            ...(latestContextUsage ? { contextUsage: latestContextUsage } : {}),
+        },
+    };
+}
+export function billedInputTokens(usage) {
+    return usage.inputTokens + usage.cacheReadTokens + usage.cacheWriteTokens;
+}
+export function cacheHitPercent(usage) {
+    const billed = billedInputTokens(usage);
+    return billed > 0 ? Math.round((usage.cacheReadTokens / billed) * 100) : null;
+}
+export function formatSessionDuration(ms) {
+    const seconds = ms / 1_000;
+    if (seconds < 60)
+        return `${Math.round(seconds * 10) / 10}s`;
+    const whole = Math.round(seconds);
+    return `${Math.floor(whole / 60)}m${whole % 60}s`;
+}
+export function formatSessionTokens(tokens) {
+    const scaled = (value) => value >= 100
+        ? String(Math.round(value))
+        : String(Math.round(value * 10) / 10);
+    if (tokens < 1_000)
+        return String(tokens);
+    if (tokens < 1_000_000)
+        return `${scaled(tokens / 1_000)}K`;
+    return `${scaled(tokens / 1_000_000)}M`;
+}

package/dist/worker/console/chat/session-store.js

@@ -17,7 +17,7 @@ import { dispatchOperatorAction } from "../operator-actions.js";
 import { authorizeOperatorChatTool } from "./tools.js";
 import { projectOperationForChat } from "./chat-event-store.js";
 import { scrubSecrets } from "./explore-tools.js";
-import { hashDeferredTurnPayload, parseDeferredTurn, } from "./deferred-turn.js";
+import { hashDeferredTurnPayload, parseDeferredTurns, } from "./deferred-turn.js";
 const CHAT_TITLE_MAX_CHARS = 80;
 /** Safe, one-line bounded title used for placeholders and model output. */
 export function cleanChatTitle(value) {
@@ -54,7 +54,13 @@ export class ChatSessionStore {
         const raw = await readJsonIfExists(recordPath(this.appData, sessionId));
         if (!raw || raw.sessionId !== sessionId)
             return undefined;
-        const deferredTurn = parseDeferredTurn(raw.deferredTurn);
+        const deferredTurns = parseDeferredTurns(raw.deferredTurns);
+        const legacyDeferredTurn = parseDeferredTurns(raw.deferredTurn ? [raw.deferredTurn] : [])[0];
+        const normalizedDeferredTurns = deferredTurns.length > 0
+            ? deferredTurns
+            : legacyDeferredTurn
+                ? [legacyDeferredTurn]
+                : [];
         return {
             schemaVersion: 2,
             sessionId,
@@ -69,7 +75,14 @@ export class ChatSessionStore {
             ...(typeof raw.modelProvider === "string" ? { modelProvider: raw.modelProvider } : {}),
             ...(typeof raw.modelId === "string" ? { modelId: raw.modelId } : {}),
             ...(typeof raw.thinkingLevel === "string" ? { thinkingLevel: raw.thinkingLevel } : {}),
-            ...(deferredTurn ? { deferredTurn } : {}),
+            ...(typeof raw.workspaceId === "string" && raw.workspaceId
+                ? { workspaceId: raw.workspaceId }
+                : {}),
+            deferredTurns: normalizedDeferredTurns,
+            ...(normalizedDeferredTurns[0] ? { deferredTurn: normalizedDeferredTurns[0] } : {}),
+            deferredQueueRevision: Number.isSafeInteger(raw.deferredQueueRevision) && (raw.deferredQueueRevision ?? 0) >= 0
+                ? raw.deferredQueueRevision
+                : 0,
             messages: Array.isArray(raw.messages) ? raw.messages : [],
             toolInvocations: Array.isArray(raw.toolInvocations) ? raw.toolInvocations : [],
         };
@@ -125,6 +138,7 @@ export class ChatSessionStore {
                 repoFingerprint: this.appData.fingerprint,
                 repoRootDisplay: this.appData.repoRoot,
                 state: "active",
+                ...(input.workspaceId ? { workspaceId: input.workspaceId } : {}),
                 ...(input.sessionFile ? { sessionFile: input.sessionFile } : {}),
                 createdAt: now,
                 updatedAt: now,
@@ -150,7 +164,8 @@ export class ChatSessionStore {
                 ...(input.targetSessionFile ? { sessionFile: input.targetSessionFile } : { sessionFile: undefined }),
                 createdAt: now,
                 updatedAt: now,
-                deferredTurn: undefined,
+                deferredTurns: [],
+                deferredQueueRevision: 0,
                 messages: structuredClone(source.messages),
                 toolInvocations: structuredClone(source.toolInvocations),
             };
@@ -232,35 +247,21 @@ export class ChatSessionStore {
                 return { ok: false, code: "INVALID_INPUT" };
             }
             const payloadHash = hashDeferredTurnPayload({ text, images: input.images });
-            const existing = record.deferredTurn;
+            const queue = [...(record.deferredTurns ?? [])];
+            const existingIndex = queue.findIndex((item) => item.clientRequestId === clientRequestId);
+            const existing = existingIndex >= 0 ? queue[existingIndex] : undefined;
             if (existing) {
-                if (existing.clientRequestId === clientRequestId) {
-                    if (existing.payloadHash !== payloadHash) {
-                        return {
-                            ok: false,
-                            code: "REQUEST_ID_REUSE_CONFLICT",
-                            deferredTurn: existing,
-                        };
-                    }
+                if (existing.payloadHash === payloadHash) {
                     return { ok: true, deferredTurn: existing, idempotent: true };
                 }
-                if (existing.state !== "queued") {
-                    return {
-                        ok: false,
-                        code: "NOT_REPLACEABLE",
-                        deferredTurn: existing,
-                    };
+                if (existing.state !== "queued" && existing.state !== "failed") {
+                    return { ok: false, code: "NOT_REPLACEABLE", deferredTurn: existing };
                 }
                 if (input.expectedRevision !== existing.revision) {
-                    return {
-                        ok: false,
-                        code: "REVISION_CONFLICT",
-                        deferredTurn: existing,
-                    };
+                    return { ok: false, code: "REVISION_CONFLICT", deferredTurn: existing };
                 }
             }
-            else if (input.expectedRevision !== undefined &&
-                input.expectedRevision !== 0) {
+            else if (input.expectedRevision !== undefined && input.expectedRevision !== 0) {
                 return { ok: false, code: "REVISION_CONFLICT" };
             }
             const now = new Date().toISOString();
@@ -276,31 +277,41 @@ export class ChatSessionStore {
                 createdAt: existing?.createdAt ?? now,
                 updatedAt: now,
             };
-            record.deferredTurn = deferredTurn;
+            if (existingIndex >= 0)
+                queue[existingIndex] = deferredTurn;
+            else
+                queue.push(deferredTurn);
+            record.deferredTurns = queue;
+            record.deferredTurn = queue[0];
+            record.deferredQueueRevision = (record.deferredQueueRevision ?? 0) + 1;
             record.updatedAt = now;
             await writeSecureJson(recordPath(this.appData, sessionId), record);
             return { ok: true, deferredTurn, idempotent: false };
         });
     }
-    async claimDeferredTurn(sessionId, expectedRevision) {
+    async listDeferredTurns(sessionId) {
+        const record = await this.get(sessionId);
+        return record ? [...(record.deferredTurns ?? [])] : [];
+    }
+    async claimDeferredTurn(sessionId, expectedRevision, clientRequestId) {
         return this.serialize(sessionId, async () => {
             const record = await this.get(sessionId);
-            const existing = record?.deferredTurn;
+            const queue = [...(record?.deferredTurns ?? [])];
+            const index = clientRequestId
+                ? queue.findIndex((item) => item.clientRequestId === clientRequestId)
+                : queue.findIndex((item) => item.state === "queued");
+            const existing = index >= 0 ? queue[index] : undefined;
             if (!record || !existing)
                 return { ok: false, code: "NOT_FOUND" };
-            if (existing.revision !== expectedRevision) {
+            if (existing.revision !== expectedRevision)
                 return { ok: false, code: "REVISION_CONFLICT", deferredTurn: existing };
-            }
-            if (existing.state !== "queued") {
+            if (existing.state !== "queued")
                 return { ok: false, code: "NOT_CLAIMABLE", deferredTurn: existing };
-            }
-            const next = {
-                ...existing,
-                revision: existing.revision + 1,
-                state: "dispatching",
-                updatedAt: new Date().toISOString(),
-            };
-            record.deferredTurn = next;
+            const next = { ...existing, revision: existing.revision + 1, state: "dispatching", updatedAt: new Date().toISOString() };
+            queue[index] = next;
+            record.deferredTurns = queue;
+            record.deferredTurn = queue[0];
+            record.deferredQueueRevision = (record.deferredQueueRevision ?? 0) + 1;
             record.updatedAt = next.updatedAt;
             await writeSecureJson(recordPath(this.appData, sessionId), record);
             return { ok: true, deferredTurn: next };
@@ -309,20 +320,20 @@ export class ChatSessionStore {
     async transitionDeferredTurn(sessionId, input) {
         return this.serialize(sessionId, async () => {
             const record = await this.get(sessionId);
-            const existing = record?.deferredTurn;
+            const queue = [...(record?.deferredTurns ?? [])];
+            const index = input.clientRequestId
+                ? queue.findIndex((item) => item.clientRequestId === input.clientRequestId)
+                : queue.findIndex((item) => item.revision === input.expectedRevision);
+            const existing = index >= 0 ? queue[index] : undefined;
             if (!record || !existing || existing.revision !== input.expectedRevision)
                 return undefined;
-            const next = {
-                ...existing,
-                revision: existing.revision + 1,
-                state: input.state,
-                updatedAt: new Date().toISOString(),
-                ...(input.acceptedTurnId ? { acceptedTurnId: input.acceptedTurnId } : {}),
-                ...(input.lastError ? { lastError: input.lastError } : {}),
-            };
+            const next = { ...existing, revision: existing.revision + 1, state: input.state, updatedAt: new Date().toISOString(), ...(input.acceptedTurnId ? { acceptedTurnId: input.acceptedTurnId } : {}), ...(input.lastError ? { lastError: input.lastError } : {}) };
             if (!input.lastError)
                 delete next.lastError;
-            record.deferredTurn = next;
+            queue[index] = next;
+            record.deferredTurns = queue;
+            record.deferredTurn = queue[0];
+            record.deferredQueueRevision = (record.deferredQueueRevision ?? 0) + 1;
             record.updatedAt = next.updatedAt;
             await writeSecureJson(recordPath(this.appData, sessionId), record);
             return next;
@@ -331,17 +342,19 @@ export class ChatSessionStore {
     async deleteDeferredTurn(sessionId, input) {
         return this.serialize(sessionId, async () => {
             const record = await this.get(sessionId);
-            const existing = record?.deferredTurn;
-            if (!record || !existing || existing.clientRequestId !== input.clientRequestId) {
+            const queue = [...(record?.deferredTurns ?? [])];
+            const index = queue.findIndex((item) => item.clientRequestId === input.clientRequestId);
+            const existing = index >= 0 ? queue[index] : undefined;
+            if (!record || !existing)
                 return { ok: false, code: "NOT_FOUND" };
-            }
-            if (existing.state !== "queued" && existing.state !== "failed") {
+            if (existing.state !== "queued" && existing.state !== "failed")
                 return { ok: false, code: "NOT_CANCELLABLE", deferredTurn: existing };
-            }
-            if (existing.revision !== input.expectedRevision) {
+            if (existing.revision !== input.expectedRevision)
                 return { ok: false, code: "REVISION_CONFLICT", deferredTurn: existing };
-            }
-            delete record.deferredTurn;
+            queue.splice(index, 1);
+            record.deferredTurns = queue;
+            record.deferredTurn = queue[0];
+            record.deferredQueueRevision = (record.deferredQueueRevision ?? 0) + 1;
             record.updatedAt = new Date().toISOString();
             await writeSecureJson(recordPath(this.appData, sessionId), record);
             return { ok: true, deferredTurn: existing };
@@ -350,11 +363,15 @@ export class ChatSessionStore {
     async clearDeferredTurnForRequest(sessionId, clientRequestId) {
         return this.serialize(sessionId, async () => {
             const record = await this.get(sessionId);
-            const existing = record?.deferredTurn;
-            if (!record || !existing || existing.clientRequestId !== clientRequestId) {
+            const queue = [...(record?.deferredTurns ?? [])];
+            const index = queue.findIndex((item) => item.clientRequestId === clientRequestId);
+            const existing = index >= 0 ? queue[index] : undefined;
+            if (!record || !existing)
                 return undefined;
-            }
-            delete record.deferredTurn;
+            queue.splice(index, 1);
+            record.deferredTurns = queue;
+            record.deferredTurn = queue[0];
+            record.deferredQueueRevision = (record.deferredQueueRevision ?? 0) + 1;
             record.updatedAt = new Date().toISOString();
             await writeSecureJson(recordPath(this.appData, sessionId), record);
             return { deferredTurn: existing, clearedRevision: existing.revision + 1 };
@@ -561,9 +578,22 @@ export async function runChatTurn(options) {
                 }
                 case "error":
                     turnError = { code: "CHAT_TURN_ERROR", message: event.message };
+                    pending.push(store.appendMessage(sessionId, {
+                        role: "assistant",
+                        kind: "provider-error",
+                        text: event.providerError.message,
+                        providerError: event.providerError,
+                        ...(event.content && event.content.length > 0
+                            ? { content: event.content }
+                            : {}),
+                    }));
                     break;
             }
-        }, { signal: options.signal, images: options.images });
+        }, {
+            signal: options.signal,
+            images: options.images,
+            ...(options.turnId ? { turnId: options.turnId } : {}),
+        });
     }
     catch (error) {
         await Promise.allSettled(pending);

package/dist/worker/console/chat/todos.js

@@ -0,0 +1,115 @@
+export function normalizeTodos(raw) {
+    if (!Array.isArray(raw))
+        throw new Error("todos must be an array");
+    const seen = new Set();
+    return raw.map((item, index) => {
+        if (!item || typeof item !== "object")
+            throw new Error(`todo item ${index + 1} must be an object`);
+        const value = item;
+        const keys = Object.keys(value);
+        if (keys.some((key) => key !== "content" && key !== "status"))
+            throw new Error(`todo item ${index + 1} contains unknown fields`);
+        const content = typeof value.content === "string" ? value.content.trim() : "";
+        if (!content)
+            throw new Error(`todo item ${index + 1} content must not be empty`);
+        if (seen.has(content))
+            throw new Error(`duplicate todo content: ${content}`);
+        seen.add(content);
+        if (value.status !== "pending" && value.status !== "in_progress" && value.status !== "completed")
+            throw new Error(`todo item ${index + 1} has invalid status`);
+        return { content, status: value.status };
+    });
+}
+export function countTodos(todos) {
+    return {
+        pending: todos.filter((todo) => todo.status === "pending").length,
+        inProgress: todos.filter((todo) => todo.status === "in_progress").length,
+        completed: todos.filter((todo) => todo.status === "completed").length,
+    };
+}
+export class TodoListRegistry {
+    current = new Map();
+    turns = new Map();
+    listeners = new Set();
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    startTurn(sessionId, turnId) {
+        this.turns.set(sessionId, turnId);
+        this.current.delete(sessionId);
+        this.publish({ type: "cleared", sessionId, turnId, todos: [] });
+    }
+    write(sessionId, toolCallId, raw) {
+        const todos = normalizeTodos(raw);
+        this.current.set(sessionId, todos);
+        this.publish({
+            type: "updated",
+            sessionId,
+            turnId: this.turns.get(sessionId),
+            toolCallId,
+            todos,
+        });
+        return { todos, counts: countTodos(todos) };
+    }
+    get(sessionId) {
+        const todos = this.current.get(sessionId);
+        return todos ? todos.map((todo) => ({ ...todo })) : null;
+    }
+    clear(sessionId) {
+        this.current.delete(sessionId);
+        this.turns.delete(sessionId);
+    }
+    publish(change) {
+        for (const listener of this.listeners) {
+            try {
+                listener(change);
+            }
+            catch { /* observers must not break tool execution */ }
+        }
+    }
+}
+export function projectCurrentTodos(events) {
+    let current = null;
+    for (const event of events) {
+        if (event.kind === "todo_cleared")
+            current = null;
+        if (event.kind === "todo_updated") {
+            const data = event.data;
+            try {
+                current = normalizeTodos(data.todos);
+            }
+            catch { /* ignore malformed historical data */ }
+        }
+    }
+    return current;
+}
+export function buildTodoCompactionInstructions(rawInstructions, todos) {
+    const todoReminder = todos && todos.length > 0
+        ? [
+            "Preserve the current Todo plan in the compaction summary and continuation context. Do not drop or invent tasks. Current whole-list state:",
+            JSON.stringify(todos),
+            "Keep each item's content and status (pending, in_progress, completed).",
+        ].join("\n")
+        : undefined;
+    return [rawInstructions?.trim(), todoReminder]
+        .filter((value) => Boolean(value))
+        .join("\n\n") || undefined;
+}
+/**
+ * Ephemeral model context used after a successful Pi compaction in the same
+ * turn. The Todo event remains the durable/UI source of truth; this text only
+ * prevents the compacted continuation from losing the current whole-list
+ * state. A later turn/start clears the registry, matching DSH's lifetime.
+ */
+export function buildTodoContinuationContext(todos) {
+    if (!todos || todos.length === 0)
+        return undefined;
+    return [
+        "<current_todo_plan>",
+        "Continue the active turn using this exact current Todo whole-list state after context compaction. Do not drop, rename, or invent tasks.",
+        JSON.stringify(todos),
+        "Preserve each item's content and status (pending, in_progress, completed).",
+        "</current_todo_plan>",
+    ].join("\n");
+}

package/dist/worker/console/chat/tool-preview.js

@@ -141,6 +141,48 @@ export function getToolPreview(args, options) {
         return "";
     return s.length > maxLen ? `${s.slice(0, maxLen)}…` : s;
 }
+/** Stable DSH-style tool row identity; unknown tools keep their real name. */
+export function getToolPresentation(toolName) {
+    const raw = toolName?.trim() || "Tool";
+    const name = raw.toLowerCase();
+    if (name === "bash" || name === "shell" || name.includes("exec_command")) {
+        return { kind: "bash", label: "Bash" };
+    }
+    if (name === "read" ||
+        name === "read_file" ||
+        name.startsWith("read_") ||
+        name.includes("view_file")) {
+        return { kind: "read", label: "Read" };
+    }
+    if (name === "search" ||
+        name === "grep" ||
+        name === "glob" ||
+        name.includes("search") ||
+        name.includes("codegraph") ||
+        name.includes("lsp")) {
+        return { kind: "search", label: name === "glob" ? "Glob" : "Search" };
+    }
+    if (name === "write" ||
+        name === "edit" ||
+        name.includes("apply_patch") ||
+        name.includes("write_file") ||
+        name.includes("edit_file")) {
+        return {
+            kind: "write",
+            label: name === "write" || name.includes("write_file") ? "Write" : "Edit",
+        };
+    }
+    if (name === "web" ||
+        name.includes("browser") ||
+        name.includes("fetch") ||
+        name.includes("web_")) {
+        return { kind: "web", label: "Web" };
+    }
+    if (name === "mcp" || name.startsWith("mcp_") || name.includes("__")) {
+        return { kind: "mcp", label: name === "mcp" ? "MCP" : raw };
+    }
+    return { kind: "tool", label: raw };
+}
 /** Section labels for ToolCard expand body. */
 export function getToolSectionLabels(toolName) {
     const name = (toolName ?? "").toLowerCase();