@tea-agent/loop-agent 0.1.0-fe-test.0

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

@@ -0,0 +1,484 @@
+/**
+ * Operator Chat — session store + tool dispatcher (plan W7 / W5).
+ *
+ * Owns:
+ *   - Chat session metadata persistence (app-data/chats)
+ *   - Tool-call dispatch from the Pi runtime into the operator action layer
+ *     (Gate 3 per-call authorization)
+ *   - History record (for degraded-mode replay, V13)
+ *
+ * The dispatcher is the SINGLE place where a Chat tool invocation becomes an
+ * operator action call. Every invocation is re-authorized here.
+ */
+import path from "node:path";
+import { readdir, rm } from "node:fs/promises";
+import { readJsonIfExists, writeSecureJson, } from "../app-data.js";
+import { dispatchOperatorAction } from "../operator-actions.js";
+import { authorizeOperatorChatTool } from "./tools.js";
+import { projectOperationForChat } from "./chat-event-store.js";
+import { scrubSecrets } from "./explore-tools.js";
+const CHAT_TITLE_MAX_CHARS = 80;
+/** Safe, one-line bounded title used for placeholders and model output. */
+export function cleanChatTitle(value) {
+    const cleaned = value
+        .replace(/```[\s\S]*?```/g, " ")
+        .replace(/^\s*(?:title|标题)\s*[:：-]\s*/i, "")
+        .split(/\r?\n/, 1)[0]
+        .trim()
+        .replace(/^["'“”‘’`]+|["'“”‘’`]+$/g, "")
+        .replace(/[。.!！？?]+$/u, "")
+        .replace(/\s+/g, " ")
+        .slice(0, CHAT_TITLE_MAX_CHARS)
+        .trim();
+    return cleaned && /[\p{L}\p{N}\p{Script=Han}]/u.test(cleaned)
+        ? cleaned
+        : undefined;
+}
+function recordPath(appData, sessionId) {
+    return path.join(appData.chats, `${sessionId}.json`);
+}
+export class ChatSessionStore {
+    appData;
+    /**
+     * Per-session write lock. Each mutating op chains onto the previous one so
+     * concurrent appendMessage / recordToolInvocation calls do not lose updates
+     * via last-write-wins on the same JSON record.
+     */
+    writeChains = new Map();
+    constructor(appData) {
+        this.appData = appData;
+    }
+    /** Read + migrate legacy V1 records into the V2 in-memory shape. */
+    async get(sessionId) {
+        const raw = await readJsonIfExists(recordPath(this.appData, sessionId));
+        if (!raw || raw.sessionId !== sessionId)
+            return undefined;
+        return {
+            schemaVersion: 2,
+            sessionId,
+            repoFingerprint: raw.repoFingerprint ?? this.appData.fingerprint,
+            repoRootDisplay: raw.repoRootDisplay ?? this.appData.repoRoot,
+            state: raw.state === "archived" ? "archived" : "active",
+            ...(typeof raw.title === "string" ? { title: raw.title } : {}),
+            ...(typeof raw.displayTitle === "string" ? { displayTitle: raw.displayTitle } : {}),
+            ...(typeof raw.sessionFile === "string" ? { sessionFile: raw.sessionFile } : {}),
+            createdAt: raw.createdAt ?? new Date(0).toISOString(),
+            updatedAt: raw.updatedAt ?? raw.createdAt ?? new Date(0).toISOString(),
+            ...(typeof raw.modelProvider === "string" ? { modelProvider: raw.modelProvider } : {}),
+            ...(typeof raw.modelId === "string" ? { modelId: raw.modelId } : {}),
+            ...(typeof raw.thinkingLevel === "string" ? { thinkingLevel: raw.thinkingLevel } : {}),
+            messages: Array.isArray(raw.messages) ? raw.messages : [],
+            toolInvocations: Array.isArray(raw.toolInvocations) ? raw.toolInvocations : [],
+        };
+    }
+    async listMessages(sessionId, options = {}) {
+        const record = await this.get(sessionId);
+        if (!record)
+            throw new Error(`chat session not found: ${sessionId}`);
+        const limit = Math.max(1, Math.min(50, Math.floor(options.limit ?? 30)));
+        const beforeIndex = options.beforeId
+            ? record.messages.findIndex((message) => message.id === options.beforeId)
+            : record.messages.length;
+        const end = beforeIndex < 0 ? record.messages.length : beforeIndex;
+        const start = Math.max(0, end - limit);
+        const messages = record.messages.slice(start, end);
+        return {
+            messages,
+            hasMore: start > 0,
+            ...(messages[0] ? { nextCursor: messages[0].id } : {}),
+        };
+    }
+    /** List repo-bound sessions, newest first. Deleted records are absent. */
+    async list(options) {
+        let names;
+        try {
+            names = await readdir(this.appData.chats);
+        }
+        catch {
+            return [];
+        }
+        const records = await Promise.all(names
+            .filter((name) => name.endsWith(".json"))
+            .map((name) => this.get(name.slice(0, -".json".length))));
+        return records
+            .filter((record) => Boolean(record) && (options?.includeArchived || record.state === "active"))
+            .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+    }
+    /** Serialize a mutating op per session. */
+    serialize(sessionId, op) {
+        const prev = this.writeChains.get(sessionId) ?? Promise.resolve();
+        const next = prev.then(op, op);
+        // Keep the chain reference for the next serializer; swallow this op's
+        // rejection so it never breaks the chain (callers still see the result).
+        this.writeChains.set(sessionId, next.then(() => undefined, () => undefined));
+        return next;
+    }
+    async create(input) {
+        return this.serialize(input.sessionId, async () => {
+            const now = new Date().toISOString();
+            const record = {
+                schemaVersion: 2,
+                sessionId: input.sessionId,
+                repoFingerprint: this.appData.fingerprint,
+                repoRootDisplay: this.appData.repoRoot,
+                state: "active",
+                ...(input.sessionFile ? { sessionFile: input.sessionFile } : {}),
+                createdAt: now,
+                updatedAt: now,
+                modelProvider: input.modelProvider,
+                modelId: input.modelId,
+                messages: [],
+                toolInvocations: [],
+            };
+            await writeSecureJson(recordPath(this.appData, input.sessionId), record);
+            return record;
+        });
+    }
+    async forkFrom(input) {
+        const source = await this.get(input.sourceSessionId);
+        if (!source)
+            throw new Error(`chat session not found: ${input.sourceSessionId}`);
+        return this.serialize(input.targetSessionId, async () => {
+            const now = new Date().toISOString();
+            const record = {
+                ...source,
+                sessionId: input.targetSessionId,
+                state: "active",
+                ...(input.targetSessionFile ? { sessionFile: input.targetSessionFile } : { sessionFile: undefined }),
+                createdAt: now,
+                updatedAt: now,
+                messages: structuredClone(source.messages),
+                toolInvocations: structuredClone(source.toolInvocations),
+            };
+            await writeSecureJson(recordPath(this.appData, input.targetSessionId), record);
+            return record;
+        });
+    }
+    async rename(sessionId, title) {
+        return this.serialize(sessionId, async () => {
+            const record = await this.get(sessionId);
+            if (!record)
+                throw new Error(`chat session not found: ${sessionId}`);
+            record.title = title.trim().slice(0, 160) || undefined;
+            record.updatedAt = new Date().toISOString();
+            await writeSecureJson(recordPath(this.appData, sessionId), record);
+            return record;
+        });
+    }
+    /** Persist an automatic title only while the original record remains active and unnamed. */
+    async setAutomaticTitle(sessionId, title) {
+        const cleaned = cleanChatTitle(title);
+        if (!cleaned)
+            return undefined;
+        return this.serialize(sessionId, async () => {
+            const record = await this.get(sessionId);
+            if (!record || record.state !== "active" || record.title)
+                return undefined;
+            record.title = cleaned;
+            record.updatedAt = new Date().toISOString();
+            await writeSecureJson(recordPath(this.appData, sessionId), record);
+            return record;
+        });
+    }
+    async setRuntimeSelection(sessionId, selection) {
+        return this.serialize(sessionId, async () => {
+            const record = await this.get(sessionId);
+            if (!record)
+                throw new Error(`chat session not found: ${sessionId}`);
+            if (selection.modelProvider !== undefined)
+                record.modelProvider = selection.modelProvider;
+            if (selection.modelId !== undefined)
+                record.modelId = selection.modelId;
+            if (selection.thinkingLevel !== undefined)
+                record.thinkingLevel = selection.thinkingLevel;
+            record.updatedAt = new Date().toISOString();
+            await writeSecureJson(recordPath(this.appData, sessionId), record);
+            return record;
+        });
+    }
+    async setState(sessionId, state) {
+        return this.serialize(sessionId, async () => {
+            const record = await this.get(sessionId);
+            if (!record)
+                throw new Error(`chat session not found: ${sessionId}`);
+            record.state = state;
+            record.updatedAt = new Date().toISOString();
+            await writeSecureJson(recordPath(this.appData, sessionId), record);
+            return record;
+        });
+    }
+    async remove(sessionId) {
+        return this.serialize(sessionId, async () => {
+            const record = await this.get(sessionId);
+            if (!record)
+                return false;
+            await rm(recordPath(this.appData, sessionId), { force: true });
+            return true;
+        });
+    }
+    async appendMessage(sessionId, message) {
+        return this.serialize(sessionId, async () => {
+            const record = await this.get(sessionId);
+            if (!record)
+                throw new Error(`chat session not found: ${sessionId}`);
+            const stored = {
+                ...message,
+                id: `m_${record.messages.length + 1}_${Math.random().toString(36).slice(2, 8)}`,
+                at: new Date().toISOString(),
+            };
+            record.messages.push(stored);
+            if (stored.role === "user" && !record.displayTitle) {
+                record.displayTitle = cleanChatTitle(stored.text);
+            }
+            record.updatedAt = stored.at;
+            await writeSecureJson(recordPath(this.appData, sessionId), record);
+            return stored;
+        });
+    }
+    async recordToolInvocation(sessionId, entry) {
+        await this.serialize(sessionId, async () => {
+            const record = await this.get(sessionId);
+            if (!record)
+                return;
+            record.toolInvocations.push({ ...entry, at: new Date().toISOString() });
+            record.updatedAt = new Date().toISOString();
+            await writeSecureJson(recordPath(this.appData, sessionId), record);
+        });
+    }
+}
+/**
+ * Dispatch a Chat tool invocation into the operator action layer.
+ *
+ * Gate 3 (per-call): authorizeOperatorChatTool is re-checked here. Even if a
+ * malicious or drifted session somehow requested a denied tool, this gate
+ * refuses before any operator action runs (V12 / V15).
+ *
+ * High-risk actions (contractApply / runDag / etc.) are NOT registered as
+ * tools, so they never reach here; but we still deny defensively.
+ */
+function redactHumanGateToken(value) {
+    const clone = structuredClone(value);
+    const confirmation = clone.confirmation;
+    if (confirmation && typeof confirmation === "object") {
+        delete confirmation.humanGateToken;
+        delete confirmation.dagBytesPath;
+    }
+    delete clone.humanGateToken;
+    return clone;
+}
+export async function dispatchChatToolCall(ctx, toolName, args, clientRequestId) {
+    const decision = authorizeOperatorChatTool(toolName);
+    if (!decision.ok) {
+        return {
+            ok: false,
+            toolName,
+            errorCode: decision.code,
+            message: decision.message,
+        };
+    }
+    const result = await dispatchOperatorAction(ctx, {
+        action: decision.toolId,
+        actionParams: args,
+        clientRequestId,
+    });
+    if (result.kind === "accepted") {
+        const canonical = await ctx.operations.get(result.body.operationId);
+        return {
+            ok: true,
+            toolName: decision.toolId,
+            result: {
+                schemaVersion: 1,
+                accepted: true,
+                operationId: result.body.operationId,
+                state: result.body.state,
+                action: result.body.action,
+                ...(canonical ? { operation: projectOperationForChat(canonical) } : {}),
+                note: "operation accepted; a durable Chat operation reference will follow canonical status",
+            },
+        };
+    }
+    const body = result.body;
+    const ok = body.ok === true;
+    if (ok) {
+        const raw = body.result ?? body;
+        return {
+            ok: true,
+            toolName: decision.toolId,
+            result: decision.toolId === "prepareDagConfirmation" || decision.toolId === "prepareMutationGate"
+                ? redactHumanGateToken(raw)
+                : raw,
+        };
+    }
+    const error = body.error ?? {};
+    return {
+        ok: false,
+        toolName: decision.toolId,
+        errorCode: typeof error.code === "string" ? error.code : "INTERNAL_ERROR",
+        message: typeof error.message === "string"
+            ? error.message
+            : `operator action ${decision.toolId} failed`,
+    };
+}
+/**
+ * Drive one full Chat turn: persist the user message, run the Pi prompt, and
+ * surface events to the caller (SSE). Tool-call events are dispatched through
+ * dispatchChatToolCall (Gate 3). The assistant's final message is persisted.
+ *
+ * The dispatcher wiring (connecting the Pi session's tool registry to
+ * dispatchChatToolCall) is performed by the runtime's customTools binding,
+ * configured at session-create time by chat-session.ts. This helper is the
+ * orchestrator the HTTP route calls.
+ */
+export async function runChatTurn(options) {
+    const { runtime, store, sessionId, text } = options;
+    if (!runtime.hasSession(sessionId)) {
+        return {
+            ok: false,
+            error: {
+                code: "NOT_FOUND",
+                message: `chat session not active: ${sessionId}`,
+            },
+        };
+    }
+    await store.appendMessage(sessionId, { role: "user", text });
+    const afterUserMessage = await store.get(sessionId);
+    if (afterUserMessage)
+        await options.onUserMessagePersisted?.(afterUserMessage);
+    let turnError;
+    // Collect persistence promises so runChatTurn does not resolve before the
+    // chat history / audit trail is durably written (also makes the outcome
+    // observable to tests and to a reconnecting client reading the record).
+    const pending = [];
+    let settledEvent;
+    try {
+        await runtime.prompt(sessionId, text, (event) => {
+            if (event.type === "agent_settled") {
+                // The durable operation-ref linker may perform an async canonical
+                // operation read. Hold settled until those writes finish so replay
+                // never observes agent_settled before its accepted operation ref.
+                settledEvent = event;
+            }
+            else {
+                options.onEvent?.(event);
+            }
+            switch (event.type) {
+                case "message_update":
+                case "message_end":
+                    if (event.type === "message_end") {
+                        pending.push(store.appendMessage(sessionId, {
+                            role: "assistant",
+                            text: event.text,
+                            ...(event.content && event.content.length > 0
+                                ? { content: event.content }
+                                : {}),
+                        }));
+                    }
+                    break;
+                case "tool_call":
+                    // Forwarded to the caller (SSE) for UI feedback. The actual tool
+                    // execution happens in the SDK's customTools[].execute(), which
+                    // routes to dispatchChatToolCall (Gate 3). Do NOT dispatch here —
+                    // that would double-execute every tool call (P0.2).
+                    break;
+                case "tool_result": {
+                    const acceptedOperationId = acceptedOperationIdFromResult(event.toolName, event.result);
+                    if (acceptedOperationId && options.onOperationAccepted) {
+                        pending.push(Promise.resolve(options.onOperationAccepted({
+                            sessionId,
+                            toolCallId: event.toolCallId,
+                            toolName: event.toolName,
+                            operationId: acceptedOperationId,
+                        })));
+                    }
+                    // tool_execution_end carries the real result of the tool call.
+                    // Persist exactly once (the tool message + audit trail). This is
+                    // the single point of record for tool outcomes (P0.2).
+                    const resultText = safeStringifyResult(event.result);
+                    // ChatSessionStore serializes writes per session, so these two calls
+                    // are safe to fire concurrently — neither clobbers the other.
+                    pending.push(store.appendMessage(sessionId, {
+                        role: "tool",
+                        text: resultText,
+                        toolCallId: event.toolCallId,
+                        toolName: event.toolName,
+                        isError: event.isError,
+                        // Durable tool→operation link (plan A): the restored timeline can
+                        // resolve operation:<id> refs without the live operation-ref event.
+                        ...(acceptedOperationId
+                            ? { operationId: acceptedOperationId }
+                            : {}),
+                    }));
+                    pending.push(store.recordToolInvocation(sessionId, {
+                        toolCallId: event.toolCallId,
+                        toolName: event.toolName,
+                        ok: !event.isError,
+                    }));
+                    break;
+                }
+                case "error":
+                    turnError = { code: "CHAT_TURN_ERROR", message: event.message };
+                    break;
+            }
+        }, { signal: options.signal, images: options.images });
+    }
+    catch (error) {
+        await Promise.allSettled(pending);
+        const message = error instanceof Error ? error.message : String(error);
+        return { ok: false, error: { code: "CHAT_TURN_FAILED", message } };
+    }
+    await Promise.allSettled(pending);
+    if (settledEvent)
+        options.onEvent?.(settledEvent);
+    return { ok: !turnError, error: turnError };
+}
+/**
+ * Stringify a tool result for persistence. Bounds the stored text length so a
+ * huge operator-action payload (e.g. a full dagReport) cannot bloat the chat
+ * history record.
+ */
+export function acceptedOperationIdFromResult(toolName, result) {
+    const candidates = [result];
+    if (result && typeof result === "object") {
+        const record = result;
+        candidates.push(record.details);
+        if (Array.isArray(record.content)) {
+            for (const item of record.content) {
+                if (!item || typeof item !== "object")
+                    continue;
+                const text = item.text;
+                if (typeof text !== "string" || text.length > 16_000)
+                    continue;
+                try {
+                    candidates.push(JSON.parse(text));
+                }
+                catch {
+                    // Only the controlled JSON tool-result envelope is accepted.
+                }
+            }
+        }
+    }
+    for (const candidate of candidates) {
+        if (!candidate || typeof candidate !== "object")
+            continue;
+        const accepted = candidate;
+        if (accepted.schemaVersion === 1 &&
+            accepted.accepted === true &&
+            accepted.action === toolName &&
+            typeof accepted.operationId === "string" &&
+            accepted.operationId.trim()) {
+            return accepted.operationId.trim();
+        }
+    }
+    return undefined;
+}
+function safeStringifyResult(result) {
+    try {
+        const raw = JSON.stringify(result ?? {});
+        const { scrubbed } = scrubSecrets(raw);
+        return scrubbed.length > 4000 ? `${scrubbed.slice(0, 4000)}…[truncated]` : scrubbed;
+    }
+    catch {
+        const { scrubbed } = scrubSecrets(String(result));
+        return scrubbed.length > 4000 ? `${scrubbed.slice(0, 4000)}…[truncated]` : scrubbed;
+    }
+}

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

@@ -0,0 +1,217 @@
+/**
+ * Operator Chat slash command catalog (UI-11).
+ *
+ * Local Operator + Pi Web commands are always available. Dynamic extension /
+ * prompt / skill commands are merged via mergeSlashCommands with conflict
+ * priority: operator/web > extension > skill > prompt.
+ */
+export const SHORTCUTS = [
+    {
+        command: "/task",
+        label: "Task context",
+        description: "查看当前任务、Draft 与 assessment",
+        action: "focus-panel:task",
+        source: "operator",
+    },
+    {
+        command: "/contract",
+        label: "Contract",
+        description: "查看 contract diff 与 apply gate",
+        action: "focus-panel:contract",
+        source: "operator",
+    },
+    {
+        command: "/dag",
+        label: "DAG",
+        description: "查看 DAG spine、确认与运行状态",
+        action: "focus-panel:dag",
+        source: "operator",
+    },
+    {
+        command: "/interview",
+        label: "Interview",
+        description: "打开 Requirement Interview",
+        action: "focus:interview",
+        source: "operator",
+    },
+    {
+        command: "/reload",
+        label: "Reload session",
+        description: "重新加载当前 Pi 会话的设置、扩展、技能、提示词、主题与上下文文件（不产生消息）",
+        action: "reload",
+        source: "operator",
+    },
+];
+/** Pi Web commands with real browser-equivalent behavior (UI-11). */
+export const WEB_SLASH_COMMANDS = [
+    {
+        command: "/compact",
+        label: "压缩上下文",
+        description: "压缩当前会话上下文，释放 token",
+        action: "compact",
+        source: "web",
+    },
+    {
+        command: "/name",
+        label: "重命名会话",
+        description: "设置当前会话标题",
+        action: "name",
+        source: "web",
+    },
+    {
+        command: "/session",
+        label: "会话信息",
+        description: "显示当前会话元信息",
+        action: "session",
+        source: "web",
+    },
+    {
+        command: "/copy",
+        label: "复制回复",
+        description: "复制最后一条助手消息原文",
+        action: "copy",
+        source: "web",
+    },
+];
+const SOURCE_PRIORITY = {
+    operator: 0,
+    web: 1,
+    extension: 2,
+    skill: 3,
+    prompt: 4,
+};
+function normalizeCommandName(raw) {
+    const token = raw.trim().split(/\s+/, 1)[0] ?? "";
+    if (!token)
+        return "";
+    return token.startsWith("/") ? token.toLowerCase() : `/${token.toLowerCase()}`;
+}
+/** Pure navigation/display resolver for local Operator + Web commands. */
+export function resolveShortcut(input) {
+    const token = input.trim().split(/\s+/, 1)[0]?.toLowerCase();
+    if (!token?.startsWith("/"))
+        return undefined;
+    const local = [...SHORTCUTS, ...WEB_SLASH_COMMANDS].find((shortcut) => shortcut.command === token);
+    if (local)
+        return { command: local.command, action: local.action };
+    return { command: token, action: "unknown" };
+}
+/** Map Operator panel shortcuts onto Console workspace routes. */
+export function workspaceForShortcut(action) {
+    if (action === "focus-panel:task" || action === "focus-panel:contract") {
+        return "tasks";
+    }
+    if (action === "focus-panel:dag")
+        return "recovery";
+    return undefined;
+}
+/**
+ * Merge Operator, Web, and dynamic Session commands with conflict dedupe.
+ * Priority: operator/web > extension > skill > prompt. /reload is single-card.
+ */
+export function mergeSlashCommands(dynamic = []) {
+    const byName = new Map();
+    const upsert = (item) => {
+        const key = normalizeCommandName(item.command);
+        if (!key)
+            return;
+        const existing = byName.get(key);
+        if (!existing) {
+            byName.set(key, { ...item, command: key });
+            return;
+        }
+        if (SOURCE_PRIORITY[item.source] < SOURCE_PRIORITY[existing.source]) {
+            byName.set(key, { ...item, command: key });
+        }
+    };
+    for (const item of SHORTCUTS) {
+        upsert({
+            command: item.command,
+            label: item.label,
+            description: item.description,
+            source: item.source,
+            action: item.action,
+        });
+    }
+    for (const item of WEB_SLASH_COMMANDS) {
+        upsert({
+            command: item.command,
+            label: item.label,
+            description: item.description,
+            source: item.source,
+            action: item.action,
+        });
+    }
+    for (const item of dynamic) {
+        const command = normalizeCommandName(item.command);
+        if (!command)
+            continue;
+        upsert({
+            command,
+            label: item.label || command,
+            description: item.description || "",
+            source: item.source,
+            action: "pi-prompt",
+        });
+    }
+    return [...byName.values()].sort((a, b) => {
+        const src = SOURCE_PRIORITY[a.source] - SOURCE_PRIORITY[b.source];
+        if (src !== 0)
+            return src;
+        return a.command.localeCompare(b.command);
+    });
+}
+/** Filter + rank slash candidates by name/description. */
+export function filterSlashCommands(commands, rawQuery) {
+    const token = (rawQuery.trim().split(/\s+/, 1)[0] ?? "").toLowerCase();
+    // After a space (args), hide the palette.
+    if (/\s/.test(rawQuery.trimStart().slice(1)) || rawQuery.includes(" ")) {
+        // Only hide when user has typed past the command token.
+        const after = rawQuery.trimStart();
+        if (after.includes(" "))
+            return [];
+    }
+    const q = token.startsWith("/") ? token : token ? `/${token}` : "/";
+    const needle = q === "/" ? "" : q.slice(1);
+    const scored = [];
+    for (const item of commands) {
+        const name = item.command.toLowerCase();
+        const bare = name.startsWith("/") ? name.slice(1) : name;
+        const desc = item.description.toLowerCase();
+        let score = 100;
+        if (!needle) {
+            score = 10 + SOURCE_PRIORITY[item.source];
+        }
+        else if (name === q || bare === needle) {
+            score = 0;
+        }
+        else if (name.startsWith(q) || bare.startsWith(needle)) {
+            score = 1;
+        }
+        else if (bare.includes(needle) || name.includes(needle)) {
+            score = 2;
+        }
+        else if (desc.includes(needle)) {
+            score = 3;
+        }
+        else {
+            continue;
+        }
+        scored.push({ ...item, score });
+    }
+    return scored.sort((a, b) => {
+        if (a.score !== b.score)
+            return a.score - b.score;
+        const src = SOURCE_PRIORITY[a.source] - SOURCE_PRIORITY[b.source];
+        if (src !== 0)
+            return src;
+        return a.command.localeCompare(b.command);
+    });
+}
+export const SLASH_SOURCE_LABEL = {
+    operator: "Operator",
+    web: "Pi Web",
+    extension: "Extensions",
+    prompt: "Prompts",
+    skill: "Skills",
+};