opencode-copilot-account-switcher 0.10.12 → 0.11.1

package/dist/model-account-map.js

@@ -75,7 +75,9 @@ export function rewriteModelAccountAssignments(store, rename) {
         const seen = new Set();
         const resolvedNames = [];
         for (const originalName of accountNames) {
-            const mappedName = rename[originalName] ?? originalName;
+            const mappedName = Object.prototype.hasOwnProperty.call(rename, originalName)
+                ? rename[originalName]
+                : originalName;
             if (typeof mappedName !== "string" || !store.accounts[mappedName] || seen.has(mappedName))
                 continue;
             seen.add(mappedName);

package/dist/plugin-hooks.d.ts

@@ -5,6 +5,7 @@ import { type StoreFile, type StoreWriteDebugMeta } from "./store.js";
 import { type CopilotAuthState, type CopilotProviderConfig, type OfficialCopilotConfig, type OfficialChatHeadersHook } from "./upstream/copilot-loader-adapter.js";
 import { type RefreshActiveAccountQuotaResult } from "./active-account-quota.js";
 import { handleStatusCommand } from "./status-command.js";
+import { handleCompactCommand, handleStopToolCommand } from "./session-control-command.js";
 import { type AppendSessionTouchEventInput, type RouteDecisionEvent, type RoutingSnapshot, type RoutingEvent } from "./routing-state.js";
 type ChatHeadersHook = (input: {
     sessionID: string;
@@ -31,6 +32,8 @@ type CopilotPluginHooksWithChatHeaders = CopilotPluginHooks & {
     "chat.headers"?: ChatHeadersHook;
 };
 type StatusCommandHandler = typeof handleStatusCommand;
+type CompactCommandHandler = typeof handleCompactCommand;
+type StopToolCommandHandler = typeof handleStopToolCommand;
 type RefreshQuota = (store: StoreFile) => Promise<RefreshActiveAccountQuotaResult>;
 type CandidateAccountLoads = Record<string, number> | Map<string, number>;
 type TriggerBillingCompensationInput = {
@@ -79,6 +82,8 @@ export declare function buildPluginHooks(input: {
     now?: () => number;
     refreshQuota?: RefreshQuota;
     handleStatusCommandImpl?: StatusCommandHandler;
+    handleCompactCommandImpl?: CompactCommandHandler;
+    handleStopToolCommandImpl?: StopToolCommandHandler;
     loadCandidateAccountLoads?: (input: {
         sessionID: string;
         modelID?: string;

package/dist/plugin-hooks.js

@@ -11,6 +11,7 @@ import { createNotifyTool } from "./notify-tool.js";
 import { createWaitTool } from "./wait-tool.js";
 import { refreshActiveAccountQuota } from "./active-account-quota.js";
 import { handleStatusCommand, showStatusToast } from "./status-command.js";
+import { handleCompactCommand, handleStopToolCommand, } from "./session-control-command.js";
 import { appendRoutingEvent, appendRouteDecisionEvent, appendSessionTouchEvent, buildCandidateAccountLoads, isAccountRateLimitCooledDown, readRoutingState, routingStatePath, } from "./routing-state.js";
 const SESSION_BINDING_IDLE_TTL_MS = 30 * 60 * 1000;
 const RATE_LIMIT_WINDOW_MS = 5 * 60 * 1000;
@@ -364,6 +365,8 @@ export function buildPluginHooks(input) {
     };
     const refreshQuota = input.refreshQuota ?? ((store) => refreshActiveAccountQuota({ store }));
     const handleStatusCommandImpl = input.handleStatusCommandImpl ?? handleStatusCommand;
+    const handleCompactCommandImpl = input.handleCompactCommandImpl ?? handleCompactCommand;
+    const handleStopToolCommandImpl = input.handleStopToolCommandImpl ?? handleStopToolCommand;
     const loadOfficialConfig = input.loadOfficialConfig ?? loadOfficialCopilotConfig;
     const loadOfficialChatHeaders = input.loadOfficialChatHeaders ?? loadOfficialCopilotChatHeaders;
     const createRetryFetch = input.createRetryFetch ?? createCopilotRetryingFetch;
@@ -556,7 +559,7 @@ export function buildPluginHooks(input) {
             const initiator = getMergedRequestHeader(selectionRequest, selectionInit, "x-initiator");
             const candidates = latestStore ? resolveCopilotModelAccounts(latestStore, modelID) : [];
             if (candidates.length === 0) {
-                const outbound = stripInternalSessionHeader(request, init);
+                const outbound = stripInternalSessionHeader(selectionRequest, selectionInit);
                 return config.fetch(outbound.request, outbound.init);
             }
             const hasExistingBinding = sessionID.length > 0 && sessionAccountBindings.has(sessionID);
@@ -600,7 +603,7 @@ export function buildPluginHooks(input) {
                 })
                 : undefined;
             if (!resolved) {
-                const outbound = stripInternalSessionHeader(request, init);
+                const outbound = stripInternalSessionHeader(selectionRequest, selectionInit);
                 return config.fetch(outbound.request, outbound.init);
             }
             const candidateNames = candidates.map((item) => item.name);
@@ -639,13 +642,13 @@ export function buildPluginHooks(input) {
             if (isFirstUse) {
                 modelAccountFirstUse.add(resolved.name);
             }
-            let nextRequest = request;
-            let nextInit = init;
-            const currentInitiator = getMergedRequestHeader(request, init, "x-initiator");
+            let nextRequest = selectionRequest;
+            let nextInit = selectionInit;
+            const currentInitiator = getMergedRequestHeader(selectionRequest, selectionInit, "x-initiator");
             const shouldStripAgentInitiator = classification.reason === "unbound-fallback"
                 || (isFirstUse && currentInitiator === "agent");
             if (shouldStripAgentInitiator && currentInitiator === "agent") {
-                const rewritten = mergeAndRewriteRequestHeaders(request, init, (headers) => {
+                const rewritten = mergeAndRewriteRequestHeaders(selectionRequest, selectionInit, (headers) => {
                     headers.delete("x-initiator");
                 });
                 nextRequest = rewritten.request;
@@ -1034,6 +1037,14 @@ export function buildPluginHooks(input) {
                 template: "Show the current GitHub Copilot quota status via the experimental workaround path.",
                 description: "Experimental Copilot quota status workaround",
             };
+            config.command["copilot-compact"] = {
+                template: "Summarize the current session via real session compacting flow.",
+                description: "Experimental compact command for Copilot sessions",
+            };
+            config.command["copilot-stop-tool"] = {
+                template: "Interrupt the current session tool flow, annotate the interrupted result, and append a synthetic continue.",
+                description: "Experimental interrupt-and-annotate recovery with synthetic continue for Copilot sessions",
+            };
             config.command["copilot-inject"] = {
                 template: "Arm an immediate tool-output inject marker flow that drives model to question.",
                 description: "Experimental force-intervene hook for Copilot workflows",
@@ -1072,6 +1083,25 @@ export function buildPluginHooks(input) {
                     refreshQuota,
                 });
             }
+            if (hookInput.command === "copilot-compact") {
+                if (!areExperimentalSlashCommandsEnabled(store))
+                    return;
+                await handleCompactCommandImpl({
+                    client: input.client ?? {},
+                    sessionID: hookInput.sessionID,
+                    model: hookInput.model,
+                });
+            }
+            if (hookInput.command === "copilot-stop-tool") {
+                if (!areExperimentalSlashCommandsEnabled(store))
+                    return;
+                await handleStopToolCommandImpl({
+                    client: input.client ?? {},
+                    sessionID: hookInput.sessionID,
+                    runningTools: hookInput.runningTools,
+                    syntheticAgentInitiatorEnabled: store?.syntheticAgentInitiatorEnabled === true,
+                });
+            }
         },
         "tool.execute.before": async (hookInput) => {
             if (!injectArmed)

package/dist/session-control-command.d.ts

@@ -0,0 +1,38 @@
+type SessionToolPart = {
+    id?: unknown;
+    type?: unknown;
+    callID?: unknown;
+    state?: unknown;
+    output?: unknown;
+    error?: unknown;
+};
+export type SessionControlSessionToolPart = SessionToolPart;
+export type SessionControlSessionPart = SessionToolPart;
+export type SessionControlRunningTool = {
+    callID?: unknown;
+    tool?: unknown;
+    state?: unknown;
+};
+export type SessionControlToolContext = {
+    parts?: Array<SessionControlSessionPart>;
+};
+export type SessionControlToolInput = {
+    sessionID: string;
+    runningTools?: Array<SessionControlRunningTool>;
+    context?: SessionControlToolContext;
+};
+export declare class SessionControlCommandHandledError extends Error {
+    constructor();
+}
+export declare function handleCompactCommand(input: {
+    client?: unknown;
+    sessionID: string;
+    model?: string;
+}): Promise<never>;
+export declare function handleStopToolCommand(input: {
+    client?: unknown;
+    sessionID: string;
+    runningTools?: unknown;
+    syntheticAgentInitiatorEnabled?: boolean;
+}): Promise<never>;
+export {};

package/dist/session-control-command.js

@@ -0,0 +1,434 @@
+import { showStatusToast } from "./status-command.js";
+export class SessionControlCommandHandledError extends Error {
+    constructor() {
+        super("session-control-command-handled");
+        this.name = "SessionControlCommandHandledError";
+    }
+}
+function warnToastFailure(scope, error) {
+    console.warn(`[${scope}] failed to show toast`, error);
+}
+async function showToast(input) {
+    await showStatusToast({
+        client: input.client,
+        message: input.message,
+        variant: input.variant,
+        warn: warnToastFailure,
+    });
+}
+async function getSessionMessages(session, sessionID) {
+    const messages = await session?.messages?.({
+        path: {
+            id: sessionID,
+        },
+    }).catch(() => undefined);
+    return Array.isArray(messages?.data) ? messages.data : [];
+}
+function getLatestAssistantModel(messages) {
+    for (const message of messages) {
+        if (message?.info?.role !== "assistant")
+            continue;
+        if (typeof message.model === "string" && message.model.length > 0)
+            return message.model;
+    }
+    for (const message of messages) {
+        if (typeof message.model === "string" && message.model.length > 0)
+            return message.model;
+    }
+    return undefined;
+}
+function normalizeRunningTools(runningTools) {
+    if (!Array.isArray(runningTools))
+        return [];
+    return runningTools.filter((item) => {
+        if (!item || typeof item !== "object")
+            return false;
+        const callID = item.callID;
+        return typeof callID === "string" && callID.length > 0;
+    }).map((item) => {
+        const normalized = item;
+        return {
+            callID: normalized.callID,
+            tool: normalized.tool,
+            state: normalized.state,
+        };
+    });
+}
+function normalizeToolState(state) {
+    if (state === "running" || state === "pending")
+        return "running";
+    if (typeof state === "string" && state.length > 0)
+        return "other";
+    return "unknown";
+}
+function getToolStateFromMessage(message, callID) {
+    const parts = Array.isArray(message.parts) ? message.parts : [];
+    for (const part of parts) {
+        if (part?.type !== "tool")
+            continue;
+        if (part?.callID !== callID)
+            continue;
+        if (part?.state === "running" || part?.state === "pending")
+            return "running";
+        return "done";
+    }
+    return "missing";
+}
+function findAssistantStateForCallID(input) {
+    const assistants = input.messages.filter((message) => message?.info?.role === "assistant");
+    if (input.targetAssistantID) {
+        const target = assistants.find((message) => message?.info?.id === input.targetAssistantID);
+        if (!target)
+            return "unknown";
+        const targetState = getToolStateFromMessage(target, input.callID);
+        if (targetState === "running")
+            return "running";
+        if (targetState === "done")
+            return "done";
+        return "unknown";
+    }
+    for (const assistant of assistants) {
+        const state = getToolStateFromMessage(assistant, input.callID);
+        if (state === "running")
+            return "running";
+        if (state === "done")
+            return "done";
+    }
+    return "unknown";
+}
+function resolveRunningCandidates(input) {
+    const running = [];
+    for (const callID of input.callIDs) {
+        for (const message of input.messages) {
+            if (message?.info?.role !== "assistant")
+                continue;
+            const state = getToolStateFromMessage(message, callID);
+            if (state !== "running")
+                continue;
+            running.push({
+                callID,
+                assistantID: typeof message.info?.id === "string" && message.info.id.length > 0
+                    ? message.info.id
+                    : undefined,
+            });
+            break;
+        }
+    }
+    return running;
+}
+async function waitForUniqueRunningCandidate(input) {
+    const sleep = input.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+    const maxAttempts = input.maxAttempts ?? 8;
+    const intervalMs = input.intervalMs ?? 30;
+    let sawMultiple = false;
+    for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+        const messages = await getSessionMessages(input.session, input.sessionID);
+        const candidates = resolveRunningCandidates({
+            messages,
+            callIDs: input.callIDs,
+        });
+        if (candidates.length === 1)
+            return {
+                type: "unique",
+                candidate: candidates[0],
+            };
+        if (candidates.length > 1)
+            sawMultiple = true;
+        if (attempt < maxAttempts - 1)
+            await sleep(intervalMs);
+    }
+    if (sawMultiple) {
+        return {
+            type: "multiple",
+        };
+    }
+    return {
+        type: "none",
+    };
+}
+function findRecentAssistantByCallID(input) {
+    for (const message of input.messages) {
+        if (message?.info?.role !== "assistant")
+            continue;
+        if (getToolStateFromMessage(message, input.callID) === "missing")
+            continue;
+        const id = message.info?.id;
+        if (typeof id === "string" && id.length > 0)
+            return id;
+        return undefined;
+    }
+    return undefined;
+}
+async function waitForToolToStop(input) {
+    const sleep = input.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+    const maxAttempts = input.maxAttempts ?? 30;
+    const intervalMs = input.intervalMs ?? 30;
+    let resolvedTargetAssistantID = input.targetAssistantID;
+    for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+        const messages = await getSessionMessages(input.session, input.sessionID);
+        const assistants = messages.filter((message) => message?.info?.role === "assistant");
+        if (!resolvedTargetAssistantID) {
+            resolvedTargetAssistantID = findRecentAssistantByCallID({
+                messages,
+                callID: input.callID,
+            });
+        }
+        const targets = resolvedTargetAssistantID
+            ? assistants.filter((message) => message?.info?.id === resolvedTargetAssistantID)
+            : assistants;
+        for (const message of targets) {
+            const parts = Array.isArray(message.parts) ? message.parts : [];
+            for (const part of parts) {
+                if (part?.type !== "tool")
+                    continue;
+                if (part?.callID !== input.callID)
+                    continue;
+                if (part?.state === "completed" || part?.state === "error") {
+                    return {
+                        type: "settled",
+                        messageID: typeof message.info?.id === "string" ? message.info.id : undefined,
+                        part,
+                    };
+                }
+            }
+        }
+        const state = findAssistantStateForCallID({
+            messages,
+            callID: input.callID,
+            targetAssistantID: resolvedTargetAssistantID,
+        });
+        if (state === "done") {
+            return {
+                type: "done-without-part",
+            };
+        }
+        if (attempt < maxAttempts - 1)
+            await sleep(intervalMs);
+    }
+    return {
+        type: "timeout",
+    };
+}
+function appendInterruptedNote(base) {
+    const note = "用户主动中止，结果可能不完整。Interrupted by user; result may be incomplete.";
+    return `${base}${base.length > 0 ? "\n\n" : ""}${note}`;
+}
+async function patchStoppedToolTranscript(input) {
+    const partID = typeof input.part.id === "string" ? input.part.id : undefined;
+    const partState = input.part.state;
+    let patch;
+    if (partState === "completed") {
+        const output = typeof input.part.output === "string" ? input.part.output : "";
+        patch = {
+            output: appendInterruptedNote(output),
+        };
+    }
+    else if (partState === "error") {
+        const error = typeof input.part.error === "string" ? input.part.error : "";
+        patch = {
+            error: appendInterruptedNote(error),
+        };
+    }
+    else {
+        throw new Error("tool part is not in completed/error state");
+    }
+    const partClient = input.client?.part;
+    if (!partClient?.update || !input.messageID || !partID) {
+        throw new Error("client.part.update unavailable");
+    }
+    await partClient.update({
+        sessionID: input.sessionID,
+        messageID: input.messageID,
+        partID,
+        part: patch,
+    });
+}
+export async function handleCompactCommand(input) {
+    const session = input.client?.session;
+    const summarize = session?.summarize;
+    const model = input.model ?? getLatestAssistantModel(await getSessionMessages(session, input.sessionID));
+    if (!model) {
+        await showToast({
+            client: input.client,
+            message: "No assistant model context available for compact.",
+            variant: "warning",
+        });
+        throw new SessionControlCommandHandledError();
+    }
+    if (summarize) {
+        await summarize({
+            auto: true,
+            model,
+        });
+        throw new SessionControlCommandHandledError();
+    }
+    await showToast({
+        client: input.client,
+        message: "Session summarize is unavailable for compact.",
+        variant: "warning",
+    });
+    throw new SessionControlCommandHandledError();
+}
+export async function handleStopToolCommand(input) {
+    if (input.syntheticAgentInitiatorEnabled !== true) {
+        await showToast({
+            client: input.client,
+            message: "Enable 'Send synthetic messages as agent' first; otherwise this recovery adds one extra billed synthetic turn.",
+            variant: "warning",
+        });
+        throw new SessionControlCommandHandledError();
+    }
+    const runningTools = normalizeRunningTools(input.runningTools);
+    if (runningTools.length === 0) {
+        await showToast({
+            client: input.client,
+            message: "No running tool found.",
+            variant: "warning",
+        });
+        throw new SessionControlCommandHandledError();
+    }
+    const runningPendingTools = runningTools.filter((item) => normalizeToolState(item.state) === "running");
+    const hasExplicitToolState = runningTools.some((item) => normalizeToolState(item.state) !== "unknown");
+    if (hasExplicitToolState && runningPendingTools.length === 0) {
+        await showToast({
+            client: input.client,
+            message: "No running/pending tool found.",
+            variant: "warning",
+        });
+        throw new SessionControlCommandHandledError();
+    }
+    if (hasExplicitToolState && runningPendingTools.length > 1) {
+        await showToast({
+            client: input.client,
+            message: "Found multiple running/pending tools; abort a single tool only.",
+            variant: "warning",
+        });
+        throw new SessionControlCommandHandledError();
+    }
+    if (!hasExplicitToolState && runningTools.length > 1) {
+        await showToast({
+            client: input.client,
+            message: "Found multiple running tools; abort a single tool only.",
+            variant: "warning",
+        });
+        throw new SessionControlCommandHandledError();
+    }
+    const session = input.client?.session;
+    const sessionCandidate = hasExplicitToolState && runningPendingTools.length === 1
+        ? {
+            type: "unique",
+            candidate: {
+                callID: runningPendingTools[0].callID,
+                assistantID: undefined,
+            },
+        }
+        : await waitForUniqueRunningCandidate({
+            session,
+            sessionID: input.sessionID,
+            callIDs: [...new Set(runningTools.map((item) => item.callID))],
+        });
+    if (!session?.abort) {
+        await showToast({
+            client: input.client,
+            message: "Stop-tool abort unavailable: session.abort capability is missing.",
+            variant: "error",
+        });
+        throw new SessionControlCommandHandledError();
+    }
+    if (sessionCandidate.type === "none") {
+        await showToast({
+            client: input.client,
+            message: "No running/pending tool found.",
+            variant: "warning",
+        });
+        throw new SessionControlCommandHandledError();
+    }
+    if (sessionCandidate.type === "multiple") {
+        await showToast({
+            client: input.client,
+            message: "Found multiple running/pending tools; abort a single tool only.",
+            variant: "warning",
+        });
+        throw new SessionControlCommandHandledError();
+    }
+    const callID = sessionCandidate.candidate.callID;
+    const targetAssistantID = sessionCandidate.candidate.assistantID;
+    try {
+        await session.abort({
+            path: {
+                id: input.sessionID,
+            },
+            callID,
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        await showToast({
+            client: input.client,
+            message: `Stop-tool abort failed: ${message}`,
+            variant: "error",
+        });
+        throw new SessionControlCommandHandledError();
+    }
+    const settled = await waitForToolToStop({
+        session,
+        sessionID: input.sessionID,
+        callID,
+        targetAssistantID,
+    });
+    if (settled.type === "timeout") {
+        await showToast({
+            client: input.client,
+            message: "Stop-tool failed: tool part state remained unstable and hit timeout.",
+            variant: "error",
+        });
+        throw new SessionControlCommandHandledError();
+    }
+    if (settled.type !== "settled") {
+        await showToast({
+            client: input.client,
+            message: "Stop-tool failed: tool part was not available for transcript patch.",
+            variant: "error",
+        });
+        throw new SessionControlCommandHandledError();
+    }
+    try {
+        await patchStoppedToolTranscript({
+            client: input.client,
+            sessionID: input.sessionID,
+            messageID: settled.messageID,
+            part: settled.part,
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        await showToast({
+            client: input.client,
+            message: `Stop-tool transcript patch failed: ${message}`,
+            variant: "error",
+        });
+        throw new SessionControlCommandHandledError();
+    }
+    try {
+        if (!session?.promptAsync) {
+            throw new Error("promptAsync unavailable");
+        }
+        await session.promptAsync({
+            sessionID: input.sessionID,
+            synthetic: true,
+            parts: [{
+                    type: "text",
+                    text: "The previous tool call was interrupted at the user's request. Treat its result as partial evidence. Do not resume that same tool call automatically unless the user explicitly asks for it.",
+                }],
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        await showToast({
+            client: input.client,
+            message: `Stop-tool recovery failed: ${message}`,
+            variant: "error",
+        });
+    }
+    throw new SessionControlCommandHandledError();
+}

package/dist/status-command.js

@@ -24,12 +24,12 @@ function truncateMiddle(value, maxWidth) {
         return "";
     if (value.length <= maxWidth)
         return value;
-    if (maxWidth <= 3)
-        return ".".repeat(maxWidth);
-    const visibleWidth = maxWidth - 3;
+    if (maxWidth === 1)
+        return "…";
+    const visibleWidth = maxWidth - 1;
     const leftWidth = Math.ceil(visibleWidth / 2);
     const rightWidth = Math.floor(visibleWidth / 2);
-    return `${value.slice(0, leftWidth)}...${value.slice(value.length - rightWidth)}`;
+    return `${value.slice(0, leftWidth)}…${value.slice(value.length - rightWidth)}`;
 }
 function renderAccountCell(name, quotaText) {
     if (quotaText.length >= ACCOUNT_CELL_WIDTH) {
@@ -59,25 +59,6 @@ function renderAccountGrid(cells) {
     }
     return rows;
 }
-function formatActiveGroup(store) {
-    const names = Array.isArray(store.activeAccountNames) ? store.activeAccountNames : [];
-    if (names.length > 0)
-        return names.join(", ");
-    return "none";
-}
-function formatRoutingGroup(store) {
-    const assignments = store.modelAccountAssignments ?? {};
-    const modelIDs = Object.keys(assignments).sort((a, b) => a.localeCompare(b));
-    const mapped = modelIDs
-        .map((modelID) => {
-        const names = assignments[modelID] ?? [];
-        if (names.length === 0)
-            return undefined;
-        return `${modelID} -> ${names.join(", ")}`;
-    })
-        .filter((line) => Boolean(line));
-    return mapped.length > 0 ? mapped.join("; ") : "none";
-}
 function buildSuccessMessage(store, _name) {
     const defaultNames = Array.isArray(store.activeAccountNames) && store.activeAccountNames.length > 0
         ? store.activeAccountNames
@@ -110,8 +91,6 @@ function buildSuccessMessage(store, _name) {
         lines.push("[routes]");
         lines.push("(none)");
     }
-    lines.push(`活跃组: ${formatActiveGroup(store)}`);
-    lines.push(`路由组: ${formatRoutingGroup(store)}`);
     return lines.join("\n");
 }
 function buildMissingActiveMessage() {

package/dist/ui/menu.js

@@ -27,7 +27,7 @@ export function getMenuCopy(language = "zh") {
             policyScopeHint: "Choose whether Guided Loop Safety applies only to Copilot by default or to all models",
             experimentalSlashCommandsOn: "Experimental slash commands: On",
             experimentalSlashCommandsOff: "Experimental slash commands: Off",
-            experimentalSlashCommandsHint: "Controls whether /copilot-status, /copilot-inject, and /copilot-policy-all-models are registered",
+            experimentalSlashCommandsHint: "Controls whether /copilot-status, /copilot-compact, /copilot-stop-tool, /copilot-inject, and /copilot-policy-all-models are registered",
             retryOn: "Copilot Network Retry: On",
             retryOff: "Copilot Network Retry: Off",
             retryHint: "Helps recover some requests after account switches or malformed retries",
@@ -63,7 +63,7 @@ export function getMenuCopy(language = "zh") {
         policyScopeHint: "决定 Guided Loop Safety 默认只作用于 Copilot，还是扩展到所有模型",
         experimentalSlashCommandsOn: "实验性 Slash Commands：已开启",
         experimentalSlashCommandsOff: "实验性 Slash Commands：已关闭",
-        experimentalSlashCommandsHint: "控制 /copilot-status、/copilot-inject、/copilot-policy-all-models 是否注册",
+        experimentalSlashCommandsHint: "控制 /copilot-status、/copilot-compact、/copilot-stop-tool、/copilot-inject、/copilot-policy-all-models 是否注册",
         retryOn: "Copilot Network Retry：已开启",
         retryOff: "Copilot Network Retry：已关闭",
         retryHint: "账号切换后若出现请求异常，可自动重试并修复部分请求",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-copilot-account-switcher",
-  "version": "0.10.12",
+  "version": "0.11.1",
   "description": "GitHub Copilot account switcher plugin for OpenCode",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",