import * as react from 'react';
import react__default, { ReactNode, PropsWithChildren, JSX, ReactElement } from 'react';
import * as _tutti_os_ui_i18n_runtime from '@tutti-os/ui-i18n-runtime';
import { I18nRuntime } from '@tutti-os/ui-i18n-runtime';
import * as _tutti_os_agent_activity_core from '@tutti-os/agent-activity-core';
import { AgentActivitySession, AgentActivityCreateSessionInput, AgentActivitySendInput, AgentActivityRailPlacement, AgentActivitySessionSettings, AgentActivityMessageOrder, AgentActivityMessage, AgentActivityDeleteSessionInput, AgentActivityDeleteSessionResult, AgentActivityComposerOptions, AgentActivitySnapshot, AgentSessionEngine, AgentActivityMessagePage, AgentActivityRenameSessionInput, AgentActivitySetCollaborationAdoptionInput, AgentActivityCollaborationRun, AgentActivitySnapshotListener, AgentActivityMessageSemantics, AgentActivityGoalControlAction, AgentActivityTurn, AgentActivitySlashCommandPolicy, SessionRuntimeAvailability, AgentActivityComposerOptionsLoadStatus, AgentActivityUsage, CanonicalAgentSession, AgentActivityEphemeralConversationProjection, AgentActivitySubmitSettingsPatch, AgentActivityComposerSettingOption, AgentSessionEngineState, PendingActivationCommandOutcome, PendingActivationLastObservedStage, PendingActivationSnapshotOutcome } from '@tutti-os/agent-activity-core';
export { AgentActivityAdapter, AgentActivityMessage, AgentActivityNeedsAttentionItem, AgentActivitySnapshot, selectNeedsAttentionCount, selectNeedsAttentionItems } from '@tutti-os/agent-activity-core';
import { WorkspaceUserProjectService, WorkspaceUserProject, WorkspaceUserProjectApi } from '@tutti-os/workspace-user-project/contracts';
import { WorkspaceFileReference, WorkspaceFileReferenceAdapter, ReferenceProvenanceCatalog, ReferenceLocateTarget } from '@tutti-os/workspace-file-reference/contracts';
export { ReferenceProvenanceCatalog as AgentGUIReferenceProvenanceFilterCatalog } from '@tutti-os/workspace-file-reference/contracts';
import { Editor, Range } from '@tiptap/core';
import { WorkspaceFileEntry } from '@tutti-os/workspace-file-manager/services';
import { ReferenceSourceAggregator } from '@tutti-os/workspace-file-reference/core';
import { ReferenceSourcePickerProps } from '@tutti-os/workspace-file-reference/ui';
import { WorkspaceUserProjectSelectChangeAction, WorkspaceUserProjectSelectProps } from '@tutti-os/workspace-user-project/ui';
import { WorkspaceIssueMentionMode } from '@tutti-os/workspace-issue-manager/core';
import { WorkspaceUserProjectI18nRuntime } from '@tutti-os/workspace-user-project/i18n';
import { ReferenceProvenanceFilterSnapshot, ReferenceProvenanceFilterController } from '@tutti-os/workspace-file-reference/react';
import { RichTextMentionService } from '@tutti-os/ui-rich-text/service';
import { AgentSideUpdatedPayloadV1 } from '@tutti-os/event-protocol';
import { RichTextTriggerProvider, RichTextTriggerQueryInput } from '@tutti-os/ui-rich-text/types';
import { TuttiExternalAtProviderId } from '@tutti-os/workspace-external-core/contracts';

interface AgentCustomMentionIdentity {
    entityId: string;
    label: string;
    scope?: Readonly<Record<string, string>>;
}
interface AgentCustomMentionPresentation {
    /** chip 第一行(缺省用链接 label)。 */
    name: string;
    /** chip 第二行(可选,通用双行卡的次要文案)。 */
    summary?: string;
    /** 所属 workspace(可选;custom kind 的 scope 键由注册方约定)。 */
    workspaceId?: string;
}
interface AgentCustomMentionChipContext {
    href: string;
    name: string;
    summary?: string;
    isEditable: boolean;
    /** 可编辑态的移除按钮,由 NodeView 注入;自定义渲染需自行摆放。 */
    removeAction?: ReactNode;
}
interface AgentCustomMentionKindDefinition {
    /** mention://<kind>/... 的 providerId(URL hostname,小写)。 */
    kind: string;
    /**
     * 从 canonical mention 链接提取展示字段;返回 null 表示链接无效,
     * 退化为普通链接/字面文本。
     */
    present(mention: AgentCustomMentionIdentity, href: string): AgentCustomMentionPresentation | null;
    /**
     * Materializes this mention into provider-visible prompt text immediately
     * before the runtime send boundary. The canonical mention remains the
     * display prompt used by the composer and conversation timeline.
     */
    materializePromptText?(mention: AgentCustomMentionIdentity, href: string): string | null;
    /** 自定义 chip 渲染;缺省用包内通用双行卡(name + summary)。 */
    renderChip?(context: AgentCustomMentionChipContext): ReactNode;
    /** 点击是否上抛 open-custom-mention 链接动作;缺省 false(chip 只展示)。 */
    clickable?: boolean;
}
declare function registerAgentCustomMentionKind(definition: AgentCustomMentionKindDefinition): void;
declare function getAgentCustomMentionKind(kind: string): AgentCustomMentionKindDefinition | undefined;
declare function resetAgentCustomMentionKindsForTests(): void;

declare const AGENT_PASTED_TEXT_BLOCK_KIND = "pasted-text";
declare const AGENT_PASTED_TEXT_MENTION_KIND = "pasted-text";

declare const APP_ERROR_CODES: readonly ["common.invalid_input", "common.approved_path_required", "common.unavailable", "common.unexpected", "session.not_found", "control_surface.unauthorized", "workspace.select_directory_failed", "workspace.select_files_failed", "workspace.ensure_directory_failed", "workspace.import_files_failed", "workspace.read_file_failed", "workspace.write_file_failed", "workspace.export_file_failed", "workspace.copy_path_failed", "workspace.host_unsupported", "workspace.runtime_artifact_unavailable", "runtime.guest_agent_lane_unavailable", "workspace.room_full", "workspace.room_delete_forbidden", "workspace.room_delete_not_found", "filesystem.create_directory_failed", "filesystem.read_file_bytes_failed", "filesystem.read_file_text_failed", "filesystem.write_file_text_failed", "filesystem.copy_entry_failed", "filesystem.move_entry_failed", "filesystem.rename_entry_failed", "filesystem.delete_entry_failed", "filesystem.read_directory_failed", "filesystem.stat_failed", "terminal.spawn_failed", "terminal.write_failed", "terminal.resize_failed", "terminal.close_failed", "terminal.attach_failed", "terminal.detach_failed", "terminal.snapshot_failed", "agent.list_models_failed", "agent.launch_failed", "agent.read_last_message_failed", "agent.provider_session_not_found", "agent.resume_session_not_local", "agent.resume_session_resolve_failed", "agent.settings_require_new_session", "task.suggest_title_failed", "persistence.unavailable", "persistence.quota_exceeded", "persistence.payload_too_large", "persistence.io_failed", "persistence.invalid_state", "persistence.invalid_node_id", "update.get_state_failed", "update.configure_failed", "update.check_failed", "update.download_failed", "update.install_failed", "PACKAGE_DOWNLOAD_INTERRUPTED", "PACKAGE_DOWNLOAD_HTTP_STATUS", "PACKAGE_DOWNLOAD_INVALID", "PACKAGE_DOWNLOAD_DISK_ERROR"];
type AppErrorCode = (typeof APP_ERROR_CODES)[number];
type AppErrorParamValue = boolean | number | string | null;
type AppErrorParams = Record<string, AppErrorParamValue>;
interface AppErrorDescriptor {
    code: AppErrorCode;
    params?: AppErrorParams;
    debugMessage?: string;
}

type AgentHostAgentSessionPermissionModeSemantic = "ask-before-write" | "accept-edits" | "locked-down" | "auto" | "full-access" | "unconfigurable";
type AgentHostAgentSessionReasoningEffort = "minimal" | "low" | "medium" | "high" | "xhigh" | string;
type AgentHostAgentSessionSpeed = "standard" | "fast" | string;
interface AgentHostAgentSessionPermissionModeOption {
    id: string;
    label?: string;
    description?: string;
    semantic: AgentHostAgentSessionPermissionModeSemantic;
}
interface AgentHostAgentSessionPermissionConfig {
    configurable: boolean;
    defaultValue?: string | null;
    modes: AgentHostAgentSessionPermissionModeOption[];
}
interface AgentHostAgentSessionComposerSettings {
    codexSaverMode?: boolean;
    model?: string | null;
    modelPlanId?: string | null;
    reasoningEffort?: AgentHostAgentSessionReasoningEffort | null;
    speed?: AgentHostAgentSessionSpeed | null;
    planMode?: boolean;
    browserUse?: boolean;
    computerUse?: boolean;
    permissionModeId?: string | null;
}
interface AgentPromptContentBlock {
    type: "text" | "image" | "file" | "skill" | "mention" | "connector";
    text?: string;
    mimeType?: "image/png" | "image/jpeg" | "image/webp" | string;
    data?: string;
    url?: string;
    attachmentId?: string;
    name?: string;
    path?: string;
    connectorKey?: string;
    uri?: string;
    hostPath?: string;
    uploadStatus?: string;
    assetId?: string;
    kind?: string;
    sizeBytes?: number;
}
interface AgentHostAgentSessionCommand {
    name: string;
    description?: string;
    inputHint?: string;
}

type AgentAvailabilityStatus = "available" | "unavailable" | "unknown";
type AgentQuotaType = "session" | "weekly" | "monthly" | "daily" | "model" | "credits" | "cost";
interface AgentAvailabilityCheck {
    name: string;
    passed: boolean;
    detail?: string;
}
interface AgentAvailability {
    status: AgentAvailabilityStatus;
    detailsVisible: boolean;
    checks?: AgentAvailabilityCheck[];
}
interface AgentUsageQuota {
    quotaType: AgentQuotaType;
    percentRemaining?: number;
    /** Exact provider-neutral balance when percent alone loses useful detail. */
    amountRemaining?: number;
    amountLimit?: number;
    amountUnit?: "credits";
    resetsAtUnixMs?: number;
    resetText?: string;
    dollarRemaining?: number;
    modelName?: string;
}
interface AgentCostUsage {
    dollarUsed: number;
    dollarLimit?: number;
}
interface AgentUsageSnapshot {
    quotas?: AgentUsageQuota[];
    accountTier?: string;
    /** Provider-neutral billing mode used when an account has no quota rows. */
    billingMode?: "subscription" | "api" | "coding_plan" | "provider_account";
    /** Whether quota rows are complete, unavailable, or not applicable. */
    quotaState?: "complete" | "unavailable" | "not_applicable";
    costUsage?: AgentCostUsage;
    capturedAtUnixMs: number;
}
interface AgentProbeAttempt {
    strategy: string;
    success: boolean;
    errorCode?: string;
    errorMessage?: string;
}
interface AgentProbeError {
    code: string;
    message?: string;
}
interface AgentProbeProvider {
    /** Exact Agent Target identity that produced this result. */
    agentTargetId?: string;
    provider: string;
    availability: AgentAvailability;
    usage?: AgentUsageSnapshot;
    attempts?: AgentProbeAttempt[];
    lastError?: AgentProbeError;
}
interface AgentProbeSnapshot {
    workspaceId: string;
    roomId?: string;
    capturedAtUnixMs: number;
    providers: AgentProbeProvider[];
}
interface AgentHostListWorkspaceAgentProbesInput {
    workspaceId: string;
    /** Compatibility input while carried call sites finish migrating from TSH room naming. */
    roomId?: string;
    /** Preferred exact identity. Provider-only requests remain compatibility input. */
    agentTargetIds?: string[];
    providers?: string[];
    includeUsage?: boolean;
    refresh?: boolean;
}
type AgentHostWorkspaceAgentProbesResult = AgentProbeSnapshot;

type PersistWriteLevel = "full" | "no_scrollback" | "settings_only";
type PersistWriteFailureReason = "unavailable" | "quota" | "payload_too_large" | "io" | "unknown";
type PersistWriteResult = {
    ok: true;
    level: PersistWriteLevel;
    bytes: number;
    revision?: number;
} | {
    ok: false;
    reason: PersistWriteFailureReason;
    error: AppErrorDescriptor;
};
type WorkspaceAgentReadStateKind = "completed" | "failed";
interface WorkspaceAgentReadStateBucket {
    readIds: string[];
    unreadIds: string[];
}
interface WorkspaceAgentReadStateSnapshot {
    completed: WorkspaceAgentReadStateBucket;
    failed: WorkspaceAgentReadStateBucket;
}
interface ReadWorkspaceAgentReadStateInput {
    roomId: string;
    userId: string;
}
interface WriteWorkspaceAgentReadStateInput extends ReadWorkspaceAgentReadStateInput {
    kind: WorkspaceAgentReadStateKind;
    readIds: string[];
    unreadIds: string[];
}

interface AgentHostUserInfo {
    userId: string;
    email?: string;
    avatar?: string;
    avatarObjectKey?: string;
    name?: string;
}
interface AgentHostBatchUserInfoInput {
    userIds: string[];
}
interface AgentHostBatchUserInfoResult {
    users: AgentHostUserInfo[];
}

declare const APP_UPDATE_POLICIES: readonly ["off", "prompt", "auto"];
type AppUpdatePolicy = (typeof APP_UPDATE_POLICIES)[number];

interface ReadWorkspaceFileResult {
    bytes: Uint8Array;
}

interface AgentConversationRailUserProject {
    createdAtUnixMs: number;
    id: string;
    label: string;
    lastUsedAtUnixMs?: number;
    path: string;
    pinnedAtUnixMs: number;
    sectionKey: string;
    updatedAtUnixMs: number;
}
interface AgentConversationRailSessionPage {
    hasMore: boolean;
    nextCursor?: string;
    sessions: AgentActivitySession[];
    totalCount: number;
}
interface AgentConversationRailSessionSection extends AgentConversationRailSessionPage {
    kind: "conversations" | "project";
    sectionKey: string;
    userProject?: AgentConversationRailUserProject;
}
interface AgentConversationRailSessionSectionsResult {
    pinned?: AgentConversationRailSessionPage;
    sections: AgentConversationRailSessionSection[];
    workspaceId: string;
}
interface AgentConversationRailListSessionsPageInput {
    agentTargetId?: string | null;
    cursor?: string;
    limit?: number;
    searchQuery?: string;
    signal?: AbortSignal;
    workspaceId: string;
}
interface AgentConversationRailSessionsPageResult {
    hasMore: boolean;
    nextCursor?: string;
    sessions: AgentActivitySession[];
    workspaceId: string;
}
interface AgentConversationRailListSessionSectionsInput {
    agentTargetId?: string | null;
    limitPerSection?: number;
    signal?: AbortSignal;
    workspaceId: string;
}
interface AgentConversationRailListSessionSectionPageInput {
    agentTargetId?: string | null;
    cursor?: string;
    limit?: number;
    sectionKey: string;
    signal?: AbortSignal;
    workspaceId: string;
}
type AgentConversationRailListPinnedSessionsPageInput = Omit<AgentConversationRailListSessionSectionPageInput, "sectionKey">;
interface AgentConversationRailSessionSectionScopeInput {
    agentTargetId?: string | null;
    excludePinned?: boolean;
    sectionKey: string;
    signal?: AbortSignal;
    workspaceId: string;
}
interface AgentConversationRailSessionSectionDeletionCandidates {
    agentTargetId?: string | null;
    excludePinned: boolean;
    sectionKey: string;
    sessionIds: string[];
    workspaceId: string;
}
interface AgentConversationRailDeleteSessionsBatchInput {
    sessionIds: string[];
    signal?: AbortSignal;
    workspaceId: string;
}
interface AgentConversationRailDeleteSessionsBatchResult {
    cleanupFailedSessionIds: string[];
    removedMessages: number;
    removedSessionIds: string[];
    removedSessions: number;
}

type AgentActivitySessionMessages = Readonly<Record<string, readonly AgentActivityMessage[]>>;
interface AgentActivityRuntimeUpdateSessionSettingsResult {
    agentSessionId: string;
    settings: AgentHostAgentSessionComposerSettings;
    session: AgentActivitySession;
}
interface AgentActivityRuntimeListSessionMessagesInput {
    afterVersion?: number;
    beforeVersion?: number;
    cache?: boolean;
    agentSessionId: string;
    limit?: number;
    order?: AgentActivityMessageOrder;
    signal?: AbortSignal;
    workspaceId: string;
}
interface AgentActivityRuntimeListGeneratedFilesInput {
    agentTargetIds?: readonly string[];
    cursor?: string;
    limit?: number;
    query?: string;
    sectionKey: string;
    signal?: AbortSignal;
    workspaceId: string;
}
type AgentActivityRuntimeListSessionsPageInput = AgentConversationRailListSessionsPageInput;
type AgentActivityRuntimeSessionPageResult = AgentConversationRailSessionsPageResult;
type AgentActivityRuntimeListSessionSectionsInput = AgentConversationRailListSessionSectionsInput;
type AgentActivityRuntimeListSessionSectionPageInput = AgentConversationRailListSessionSectionPageInput;
type AgentActivityRuntimeListPinnedSessionsPageInput = AgentConversationRailListPinnedSessionsPageInput;
type AgentActivityRuntimeSessionSection = AgentConversationRailSessionSection;
type AgentActivityRuntimeSessionPage = AgentConversationRailSessionPage;
type AgentActivityRuntimeSessionSectionsResult = AgentConversationRailSessionSectionsResult;
interface AgentActivityRuntimeGeneratedFile {
    label: string;
    path: string;
}
interface AgentActivityRuntimeGeneratedFileList {
    entries: AgentActivityRuntimeGeneratedFile[];
    hasMore?: boolean;
    nextCursor?: string;
    workspaceId: string;
}
interface AgentActivityRuntimeEnsureSessionSynchronizedInput {
    afterVersion?: number;
    agentSessionId: string;
    onError?: (error: unknown) => void;
    workspaceId: string;
}
interface AgentActivityRuntimeSetSessionPinnedInput {
    agentSessionId: string;
    pinned: boolean;
    workspaceId: string;
}
interface AgentActivityRuntimeTrackSettingsProjectChangeInput {
    action: "clear" | "create_new" | "import_directory" | "select_existing";
    agentSessionId: string | null;
    provider?: string | null;
    workspaceId: string;
}
interface AgentActivityRuntimeGetComposerOptionsInput {
    agentSessionId?: string | null;
    agentTargetId: string;
    cwd?: string | null;
    force?: boolean;
    waitForFreshModelCatalog?: boolean;
    provider?: string;
    section?: "full" | "core" | "capabilities" | "connectors";
    settings?: AgentHostAgentSessionComposerSettings | null;
    workspaceId: string;
}
interface AgentActivityRuntimeUpdateSessionSettingsInput {
    agentSessionId: string;
    signal?: AbortSignal;
    settings: AgentHostAgentSessionComposerSettings;
    workspaceId: string;
}
interface AgentActivityRuntimeTrackDraftComposerSettingsChangeInput {
    nextSettings: AgentHostAgentSessionComposerSettings;
    previousSettings: AgentHostAgentSessionComposerSettings;
    provider: string;
    workspaceId: string;
}
interface AgentActivityRuntimeDiagnosticInput {
    details?: Record<string, unknown>;
    event: string;
    level?: "debug" | "info" | "warn" | "error";
    source?: string;
    workspaceId?: string | null;
}
interface AgentActivityRuntimeActivateSessionInputBase {
    activationId: string;
    agentSessionId: string;
    capabilityRefs?: AgentActivityCreateSessionInput["capabilityRefs"];
    cwd?: string;
    initialContent?: AgentActivitySendInput["content"];
    /** 仅展示用首轮文本(bundle 折叠成一个 chip);initialContent 仍带展开后的文件。 */
    initialDisplayPrompt?: string | null;
    isolation?: AgentActivityCreateSessionInput["isolation"];
    modelExplicit?: boolean;
    railPlacement?: AgentActivityRailPlacement;
    reasoningEffortExplicit?: boolean;
    submitDiagnostics?: AgentActivitySendInput["submitDiagnostics"];
    settings?: AgentActivitySessionSettings;
    title?: string;
    visible?: boolean;
    workspaceId: string;
    signal?: AbortSignal;
}
type AgentActivityRuntimeActivateSessionInput = (AgentActivityRuntimeActivateSessionInputBase & {
    agentTargetId: string;
    clientSubmitId: string;
    initialGoalControl?: AgentActivityCreateSessionInput["initialGoalControl"];
    initialTuttiModeActivation?: AgentActivityCreateSessionInput["initialTuttiModeActivation"];
    mode: "new";
}) | (AgentActivityRuntimeActivateSessionInputBase & {
    agentTargetId?: string | null;
    clientSubmitId?: never;
    mode: "existing";
});
interface AgentActivityRuntimeUnactivateSessionInput {
    agentSessionId: string;
    workspaceId: string;
}
interface AgentActivityRuntimeReadSessionAttachmentInput {
    agentSessionId: string;
    attachmentId: string;
    workspaceId: string;
}
interface AgentActivityRuntimeReadPromptAssetInput {
    agentSessionId?: string | null;
    assetId?: string | null;
    hostPath?: string | null;
    kind?: string | null;
    mimeType: string;
    name?: string | null;
    path?: string | null;
    sha256?: string | null;
    uploadStatus?: string | null;
    uri?: string | null;
    workspaceId: string;
}
type AgentActivityRuntimePromptContentBlock = AgentActivitySendInput["content"][number] & {
    assetId?: string;
    hostPath?: string;
    kind?: string;
    path?: string;
    sizeBytes?: number;
    uploadStatus?: string;
    uri?: string;
};
interface AgentActivityRuntimeUploadPromptContentInput {
    content: AgentActivityRuntimePromptContentBlock[];
    workspaceId: string;
}
interface AgentActivityRuntimeUploadPromptContentResult {
    content: AgentActivityRuntimePromptContentBlock[];
}
/**
 * Dedicated host boundary for turning an in-memory text paste into a prepared
 * prompt asset. The runtime owns persistence and returns one provider-readable
 * locator; AgentGUI must not infer this capability from generic file-upload
 * support.
 */
interface AgentActivityRuntimeStagePastedTextInput {
    name: string;
    text: string;
    workspaceId: string;
}
/**
 * A prepared long-text asset. Local hosts return a path; remote/shared hosts
 * return the same URL-backed attachment metadata used by ordinary prompt-file
 * upload. Exactly one of `path` and `url` must be present.
 */
type AgentActivityRuntimeStagePastedTextResult = {
    name: string;
    path: string;
    url?: never;
    assetId?: never;
    mimeType?: string;
    sizeBytes: number;
    uploadStatus?: never;
    uri?: never;
} | {
    name: string;
    path?: never;
    url: string;
    assetId?: string;
    mimeType?: string;
    sizeBytes: number;
    uploadStatus?: string;
    uri?: string;
};
type AgentActivityRuntimeSessionSectionScopeInput = AgentConversationRailSessionSectionScopeInput;
type AgentActivityRuntimeSessionSectionDeletionCandidates = AgentConversationRailSessionSectionDeletionCandidates;
type AgentActivityRuntimeDeleteSessionsBatchInput = AgentConversationRailDeleteSessionsBatchInput;
type AgentActivityRuntimeDeleteSessionsBatchResult = AgentConversationRailDeleteSessionsBatchResult;
interface AgentActivityRuntimeSessionAttachment {
    attachmentId: string;
    mimeType: string;
    name?: string;
    data: string;
}
interface AgentActivityRuntimePromptAsset {
    assetId?: string;
    hostPath?: string;
    kind?: string;
    mimeType: string;
    name?: string;
    path: string;
    uploadStatus?: string;
    uri?: string;
    data: string;
}
/**
 * Host runtime surface consumed by AgentGUI. Session lifecycle writes are
 * owned by the workspace {@link AgentSessionEngine}; this boundary contains
 * only the reads, metadata actions, uploads, diagnostics, and subscriptions
 * that remain host-owned.
 */
interface AgentGUIRuntime {
    /**
     * Stable identity of this runtime instance (e.g. a local origin vs a
     * shared/room origin). The runtime owns one session engine per workspace and
     * that engine verifies this origin as part of its injected identity. Runtime
     * consumers resolve only through the nearest React provider; module-global
     * runtime lookup and last-mounted fallback are forbidden. An absent origin
     * means the canonical local origin.
     */
    origin?: string;
    /**
     * Enables the Codex-aligned in-memory conversation Activity View. Missing or
     * false fails closed so external hosts opt in explicitly.
     */
    conversationActivityViewEnabled?: boolean;
    /**
     * Host query limits for the Conversation Rail. Omit when the backend accepts
     * AgentGUI's default limits.
     */
    conversationRailQueryLimits?: {
        sectionRefreshLimitMax: number;
    };
    /**
     * The session cwd is not resolvable on the local filesystem (e.g. a
     * shared/cloud sandbox not mounted locally), so AgentGUI must not run its
     * local stat-based "working directory missing" existence check — it would
     * always false-positive. Absent/false (default) => local, legacy behaviour.
     * Only that one guard is gated; project selection/listing is unaffected.
     */
    projectPathIsRemote?: boolean;
    promptContentUploadSupport?: {
        file?: boolean;
        image?: boolean;
    };
    /** Set false to suppress AgentGUI diagnostics in development consoles. */
    devDiagnosticConsoleSink?: boolean;
    deleteSession(input: AgentActivityDeleteSessionInput): Promise<AgentActivityDeleteSessionResult>;
    getSession(workspaceId: string, agentSessionId: string): Promise<AgentActivitySession>;
    getComposerOptions(input: AgentActivityRuntimeGetComposerOptionsInput): Promise<AgentActivityComposerOptions>;
    getSnapshot(workspaceId: string): AgentActivitySnapshot;
    getSessionEngine(workspaceId: string): AgentSessionEngine;
    listSessionMessages(input: AgentActivityRuntimeListSessionMessagesInput): Promise<AgentActivityMessagePage>;
    listAgentGeneratedFiles?(input: AgentActivityRuntimeListGeneratedFilesInput): Promise<AgentActivityRuntimeGeneratedFileList>;
    listSessionsPage?(input: AgentActivityRuntimeListSessionsPageInput): Promise<AgentActivityRuntimeSessionPageResult>;
    listSessionSections?(input: AgentActivityRuntimeListSessionSectionsInput): Promise<AgentActivityRuntimeSessionSectionsResult>;
    listSessionSectionPage?(input: AgentActivityRuntimeListSessionSectionPageInput): Promise<AgentActivityRuntimeSessionSection>;
    listSessionSectionDeletionCandidates?(input: AgentActivityRuntimeSessionSectionScopeInput): Promise<AgentActivityRuntimeSessionSectionDeletionCandidates>;
    deleteSessionsBatch?(input: AgentActivityRuntimeDeleteSessionsBatchInput): Promise<AgentActivityRuntimeDeleteSessionsBatchResult>;
    listPinnedSessionsPage?(input: AgentActivityRuntimeListPinnedSessionsPageInput): Promise<AgentActivityRuntimeSessionPage>;
    load(workspaceId: string, signal?: AbortSignal): Promise<AgentActivitySnapshot>;
    ensureSessionSynchronized?(input: AgentActivityRuntimeEnsureSessionSynchronizedInput): () => void;
    uploadPromptContent?(input: AgentActivityRuntimeUploadPromptContentInput): Promise<AgentActivityRuntimeUploadPromptContentResult>;
    stagePastedText?(input: AgentActivityRuntimeStagePastedTextInput): Promise<AgentActivityRuntimeStagePastedTextResult>;
    readSessionAttachment?(input: AgentActivityRuntimeReadSessionAttachmentInput): Promise<AgentActivityRuntimeSessionAttachment>;
    readPromptAsset?(input: AgentActivityRuntimeReadPromptAssetInput): Promise<AgentActivityRuntimePromptAsset>;
    renameSession(input: AgentActivityRenameSessionInput): Promise<AgentActivitySession>;
    /**
     * Record whether a collaboration outcome was adopted.
     * Optional; hosts without support omit it and adoption controls stay hidden.
     */
    setCollaborationAdoption?(input: AgentActivitySetCollaborationAdoptionInput): Promise<AgentActivityCollaborationRun>;
    setSessionPinned(input: AgentActivityRuntimeSetSessionPinnedInput): Promise<AgentActivitySession>;
    trackSettingsProjectChange?(input: AgentActivityRuntimeTrackSettingsProjectChangeInput): Promise<void>;
    trackDraftComposerSettingsChange?(input: AgentActivityRuntimeTrackDraftComposerSettingsChangeInput): Promise<void>;
    reportDiagnostic?(input: AgentActivityRuntimeDiagnosticInput): Promise<void> | void;
    subscribeSessionEvents(workspaceId: string, listener: (event: unknown) => void): () => void;
    subscribe(workspaceId: string, listener: AgentActivitySnapshotListener): () => void;
}
interface AgentGUIRuntimeProviderProps extends PropsWithChildren {
    runtime?: AgentGUIRuntime | null;
}
declare function AgentGUIRuntimeProvider({ children, runtime }: AgentGUIRuntimeProviderProps): JSX.Element;
declare function useAgentGUIRuntime(): AgentGUIRuntime;
declare function useOptionalAgentGUIRuntime(): AgentGUIRuntime | null;
declare function useAgentActivitySnapshot(workspaceId: string): AgentActivitySnapshot;
declare function useAgentActivitySessionMessages(workspaceId: string, agentSessionIds: readonly (string | null | undefined)[]): AgentActivitySessionMessages;
declare function resetAgentGUIRuntimeForTests(): void;
declare function setAgentGUIRuntimeForTests(runtime: AgentGUIRuntime | null): void;

type AgentHostAsyncResult<T = any> = Promise<T>;
type AgentHostRecord = Record<string, unknown>;
type AgentHostUnsubscribe = () => void;
type AgentHostClipboardApi = {
    writeImage?: (input: {
        data: string;
        mimeType: "image/png";
    }) => AgentHostAsyncResult<void>;
    writeText: (text: string) => AgentHostAsyncResult<void>;
};
type AgentHostTerminalLoginHandle = {
    close: () => void;
    completion: Promise<"ready" | "timed_out" | "unavailable">;
};
type AgentHostTerminalStartupAction = {
    type: "slash_command";
    commandName: string;
    readyText: string;
};
type AgentHostTerminalLoginApi = {
    supportedStartupActionTypes?: readonly AgentHostTerminalStartupAction["type"][];
    run: (input: {
        agentTargetId: string;
        command: string;
        cwd?: string;
        startupAction?: AgentHostTerminalStartupAction;
    }) => AgentHostAsyncResult<AgentHostTerminalLoginHandle | void>;
};
type AgentHostDebugApi = {
    logRuntimeDiagnostics: (payload: unknown) => AgentHostAsyncResult<void> | void;
    logTerminalDiagnostics?: (payload: unknown) => AgentHostAsyncResult<void> | void;
};
type AgentHostFilesystemApi = AgentHostRecord & {
    readFileText: (payload: {
        path?: string;
        uri?: string;
    }) => AgentHostAsyncResult<{
        content: string;
        name?: string;
        path?: string;
    }>;
};
type AgentHostMetaApi = AgentHostRecord & {
    appVersion?: string | null;
    isPackaged?: boolean;
    isTest?: boolean;
    mainPid?: number | null;
    platform?: string;
    workspaceId?: string;
};
type AgentHostEnvironmentApi = AgentHostRecord & {
    getBaseUrl?: () => AgentHostAsyncResult<string>;
};
interface AgentHostQuickPrompt {
    id: string;
    title: string;
    content: string;
    version: number;
    createdAtUnixMs: number;
    updatedAtUnixMs: number;
}
interface AgentHostQuickPromptSnapshot {
    enabled: boolean;
    status: "idle" | "loading" | "ready" | "error";
    prompts: readonly AgentHostQuickPrompt[];
    error: string | null;
    revision: number;
    pendingMutationIds: readonly string[];
    orderMutationPending?: boolean;
}
interface AgentHostQuickPromptsApi {
    ensureLoaded: (input?: {
        force?: boolean;
    }) => AgentHostAsyncResult<void>;
    getSnapshot: () => AgentHostQuickPromptSnapshot;
    subscribe: (listener: (snapshot: AgentHostQuickPromptSnapshot) => void) => AgentHostUnsubscribe;
    create: (input: {
        title: string;
        content: string;
    }) => AgentHostAsyncResult<AgentHostQuickPrompt>;
    update: (input: {
        id: string;
        title: string;
        content: string;
        expectedVersion: number;
    }) => AgentHostAsyncResult<AgentHostQuickPrompt>;
    remove: (input: {
        id: string;
        expectedVersion: number;
    }) => AgentHostAsyncResult<void>;
    move?: (input: {
        promptId: string;
        beforePromptId: string | null;
        expectedVersion: number;
    }) => AgentHostAsyncResult<readonly AgentHostQuickPrompt[]>;
}
type AgentHostPersistenceApi = AgentHostRecord & {
    readWorkspaceAgentReadState: (input: ReadWorkspaceAgentReadStateInput) => AgentHostAsyncResult<WorkspaceAgentReadStateSnapshot>;
    writeWorkspaceAgentReadState: (input: WriteWorkspaceAgentReadStateInput) => AgentHostAsyncResult<PersistWriteResult>;
};
type AgentHostToastHandle = {
    /** Settles the toast to a neutral, non-error, non-success tone. */
    info: (title: string, description?: string) => void;
    /** Settles the toast to the destructive tone. */
    reject: (title: string, description?: string) => void;
    /** Settles the toast to the success tone. */
    resolve: (title: string, description?: string) => void;
};
type AgentHostToastApi = AgentHostRecord & {
    error: (title: string, description?: string) => void;
    info?: (title: string, description?: string) => void;
    /**
     * Opens one toast that stays mounted across async work: it shows busy
     * (spinner, no auto-dismiss) until the returned handle settles it in
     * place, at which point it starts auto-dismissing like any other toast.
     */
    loading?: (title: string) => AgentHostToastHandle;
    success?: (title: string, description?: string) => void;
};
interface AgentHostSelectedFile {
    name?: string;
    path: string;
}
interface AgentHostSelectFilesInput {
    allowDirectories?: boolean;
}
interface AgentHostApplyWorkspaceGitPatchInput {
    allowBinary?: boolean;
    atomic?: boolean;
    cwd: string;
    diff: string;
    revert?: boolean;
    target?: "unstaged" | "staged" | "staged-and-unstaged";
}
interface AgentHostApplyWorkspaceGitPatchResult {
    status: "success" | "partial-success" | "error";
    appliedPaths: string[];
    skippedPaths: string[];
    conflictedPaths: string[];
    errorCode?: "not-git-repo" | string;
    execOutput?: {
        command: string;
        stdout: string;
        stderr: string;
    };
}
interface AgentHostResolveWorkspaceGitPatchSupportInput {
    cwd: string;
}
interface AgentHostResolveWorkspaceGitPatchSupportResult {
    supported: boolean;
    root?: string;
    errorCode?: "not-git-repo" | string;
}
interface AgentHostResolveSessionWorktreeSupportInput {
    agentTargetId: string;
    cwd: string;
}
interface AgentHostResolveSessionWorktreeSupportResult {
    supported: boolean;
    root?: string;
    errorCode?: "git-unavailable" | "not-git-repo" | "unsupported-repo-layout" | string;
}
type AgentHostWorkspaceApi = AgentHostRecord & {
    applyGitPatch?: (input: AgentHostApplyWorkspaceGitPatchInput) => AgentHostAsyncResult<AgentHostApplyWorkspaceGitPatchResult>;
    resolveGitPatchSupport?: (input: AgentHostResolveWorkspaceGitPatchSupportInput) => AgentHostAsyncResult<AgentHostResolveWorkspaceGitPatchSupportResult>;
    resolveSessionWorktreeSupport?: (input: AgentHostResolveSessionWorktreeSupportInput) => AgentHostAsyncResult<AgentHostResolveSessionWorktreeSupportResult>;
    copyPath?: (input: {
        path: string;
    }) => AgentHostAsyncResult<void>;
    ensureDirectory: (input: {
        path: string;
    }) => AgentHostAsyncResult<void>;
    readFile: (input: {
        path: string;
    }) => AgentHostAsyncResult<ReadWorkspaceFileResult>;
    selectContextEntries?: () => AgentHostAsyncResult<{
        entries: unknown[];
    }>;
    selectDirectory: () => AgentHostAsyncResult<{
        path: string;
    } | null>;
    selectFiles: (input?: AgentHostSelectFilesInput) => AgentHostAsyncResult<AgentHostSelectedFile[]>;
    writeFileText: (input: {
        content: string;
        path: string;
    }) => AgentHostAsyncResult<unknown>;
};
interface AgentHostInputApi {
    account?: AgentHostAccountApi;
    agentTargetSetup?: AgentHostAgentTargetSetupApi;
    clipboard: AgentHostClipboardApi;
    debug?: AgentHostDebugApi;
    filesystem: AgentHostFilesystemApi;
    meta?: AgentHostMetaApi;
    onHostEvent?: (listener: (event: any) => void) => AgentHostUnsubscribe;
    persistence?: AgentHostPersistenceApi;
    quickPrompts?: AgentHostQuickPromptsApi;
    runtime?: AgentHostEnvironmentApi;
    terminalLogin?: AgentHostTerminalLoginApi;
    toast?: AgentHostToastApi;
    userProjects?: AgentHostUserProjectsApi;
    workspace: AgentHostWorkspaceApi;
    workspaceAgentProbes?: AgentHostWorkspaceAgentProbesApi;
}
type AgentHostApi = AgentHostInputApi;
type AgentHostAccountApi = AgentHostRecord & {
    batchGetUserInfo: (input: AgentHostBatchUserInfoInput) => AgentHostAsyncResult<AgentHostBatchUserInfoResult>;
    ensureProfiles?: (input: any) => AgentHostAsyncResult<any>;
};
type AgentHostWorkspaceAgentProbesApi = AgentHostRecord & {
    list: (input: AgentHostListWorkspaceAgentProbesInput) => AgentHostAsyncResult<AgentHostWorkspaceAgentProbesResult>;
};
interface AgentHostAgentTargetInstallPlan {
    packageName: string;
    packageVersion: string;
    runner: "npm" | "pnpm" | "uv" | "binary";
    planDigest: string;
    installRoot: string;
}
interface AgentHostAgentTargetSetupAction {
    actionId: string;
    clientActionId: string;
    kind: "install" | "authenticate";
    status: "queued" | "running" | "succeeded" | "failed" | "interrupted";
    phase: "preparing" | "installing" | "verifying" | "probing" | "activating" | "authenticating" | "complete";
    errorCode: string | null;
    errorMessage: string | null;
}
interface AgentHostAgentTargetSetupSnapshot {
    agentTargetId: string;
    status: "ready" | "auth_required" | "not_installed" | "installing" | "authenticating" | "failed";
    runtimeSource: "local" | "managed" | null;
    runtimeVersion: string | null;
    reason: string | null;
    authMethods: AgentHostAgentTargetAuthMethod[];
    account: AgentHostAgentTargetAuthenticatedAccount | null;
    plan: AgentHostAgentTargetInstallPlan | null;
    action: AgentHostAgentTargetSetupAction | null;
}
interface AgentHostAgentTargetAuthenticatedAccount {
    id: string;
    displayName: string;
    authMethodId: string;
    organization: string | null;
}
interface AgentHostAgentTargetAuthMethod {
    id: string;
    name: string;
    description?: string | null;
    /** Provider-declared method kind (for example "terminal"). */
    type?: string | null;
    /** Ready-to-run interactive sign-in launch command for terminal-type methods. */
    terminalCommand?: string | null;
    /** Optional typed action submitted after the terminal runtime is ready. */
    terminalStartupAction?: AgentHostTerminalStartupAction | null;
}
interface AgentHostAgentTargetSetupState {
    snapshot: AgentHostAgentTargetSetupSnapshot | null;
    loading: boolean;
    failed: boolean;
}
interface AgentHostAgentTargetSetupWatch {
    getSnapshot: () => AgentHostAgentTargetSetupState;
    subscribe: (listener: (state: AgentHostAgentTargetSetupState) => void) => AgentHostUnsubscribe;
    install: (input: {
        planDigest: string;
        clientActionId: string;
    }) => AgentHostAsyncResult<void>;
    authenticate: (input: {
        methodId: string;
        clientActionId: string;
    }) => AgentHostAsyncResult<void>;
    refresh: () => AgentHostAsyncResult<void>;
}
type AgentHostAgentTargetSetupApi = AgentHostRecord & {
    watch: (input: {
        agentTargetId: string;
    }) => AgentHostAgentTargetSetupWatch;
};
type AgentProviderProbeListInput = AgentHostListWorkspaceAgentProbesInput;
type AgentProviderProbeListResult = AgentHostWorkspaceAgentProbesResult;
interface AgentHostUserProject {
    id: string;
    path: string;
    label: string;
    pinnedAtUnixMs: number;
    sectionKey?: string;
    createdAtUnixMs?: number;
    updatedAtUnixMs?: number;
    lastUsedAtUnixMs?: number;
}
type AgentHostUserProjectsApi = AgentHostRecord & {
    service?: WorkspaceUserProjectService;
    checkPath?: (input: {
        path: string;
    }) => AgentHostAsyncResult<{
        exists: boolean;
        isDirectory: boolean;
        path: string;
    }>;
    create?: (input: {
        name: string;
    }) => AgentHostAsyncResult<AgentHostUserProject>;
    getDefaultSelection?: () => AgentHostAsyncResult<{
        path: string | null;
    } | null>;
    list: () => AgentHostAsyncResult<{
        projects: AgentHostUserProject[];
    }>;
    move?: (input: {
        beforeProjectId: string | null;
        projectId: string;
    }) => AgentHostAsyncResult<void>;
    pin: (input: {
        pinned: boolean;
        projectId: string;
    }) => AgentHostAsyncResult<void>;
    subscribe?: (listener: () => void) => AgentHostUnsubscribe;
    prepareSelection?: (input: {
        projectLocked: boolean;
        selectedPath: string | null;
    }) => AgentHostAsyncResult<{
        isSelectedPathMissing: boolean;
        projects: AgentHostUserProject[];
        selection: {
            kind: "clear";
            suppressedPath: string;
        } | {
            kind: "none";
        } | {
            kind: "select";
            path: string;
        };
    }>;
    remove?: (input: {
        path: string;
    }) => AgentHostAsyncResult<void>;
    isNoProjectPath?: (input: {
        path: string;
    }) => boolean;
    rememberDefaultSelection?: (input: {
        path: string | null;
    }) => AgentHostAsyncResult<void>;
    use: (input: {
        path: string;
    }) => AgentHostAsyncResult<AgentHostUserProject>;
};
interface AgentHostRuntimeApi {
    account?: AgentHostAccountApi;
    agentTargetSetup?: AgentHostAgentTargetSetupApi;
    clipboard: AgentHostClipboardApi;
    debug?: AgentHostDebugApi;
    filesystem: AgentHostFilesystemApi;
    meta?: AgentHostMetaApi;
    onHostEvent?: (listener: (event: any) => void) => AgentHostUnsubscribe;
    persistence?: AgentHostPersistenceApi;
    quickPrompts?: AgentHostQuickPromptsApi;
    runtime?: AgentHostEnvironmentApi;
    terminalLogin?: AgentHostTerminalLoginApi;
    toast?: AgentHostToastApi;
    userProjects?: AgentHostUserProjectsApi;
    workspace: AgentHostWorkspaceApi;
    workspaceAgentProbes?: AgentHostWorkspaceAgentProbesApi;
}

type AgentCustomModelEnabledByProvider<TProvider extends string> = Record<TProvider, boolean>;
type AgentCustomModelByProvider<TProvider extends string> = Record<TProvider, string>;
type AgentCustomModelOptionsByProvider<TProvider extends string> = Record<TProvider, string[]>;

declare const AGENT_PROVIDERS: readonly ["claude-code", "codex", "cursor", "tutti-agent", "nexight", "opencode", "openclaw"];
type AgentProvider = (typeof AGENT_PROVIDERS)[number];

type FocusNodeTargetZoom = number;

declare const UI_LANGUAGES: readonly ["en", "zh-CN"];
type UiLanguage = (typeof UI_LANGUAGES)[number];
declare const UI_THEMES: readonly ["system", "light", "dark"];
type UiTheme = (typeof UI_THEMES)[number];

declare const COMMAND_IDS: readonly ["commandCenter.toggle", "app.togglePrimarySidebar", "workspaceCanvas.createTerminal"];
type CommandId = (typeof COMMAND_IDS)[number];
type KeyChord = {
    code: string;
    altKey: boolean;
    ctrlKey: boolean;
    metaKey: boolean;
    shiftKey: boolean;
};
type KeybindingOverrides = Partial<Record<CommandId, KeyChord | null>>;

declare const CANVAS_INPUT_MODES: readonly ["auto", "mouse", "trackpad"];
type CanvasInputMode = (typeof CANVAS_INPUT_MODES)[number];
declare const CANVAS_WHEEL_BEHAVIORS: readonly ["zoom", "pan"];
type CanvasWheelBehavior = (typeof CANVAS_WHEEL_BEHAVIORS)[number];
declare const CANVAS_WHEEL_ZOOM_MODIFIERS: readonly ["primary", "ctrl", "alt"];
type CanvasWheelZoomModifier = (typeof CANVAS_WHEEL_ZOOM_MODIFIERS)[number];
declare const STANDARD_WINDOW_SIZE_BUCKETS: readonly ["compact", "regular", "large"];
type StandardWindowSizeBucket = (typeof STANDARD_WINDOW_SIZE_BUCKETS)[number];

type QuickCommand = {
    id: string;
    title: string;
    kind: "terminal";
    command: string;
    enabled: boolean;
    pinned: boolean;
} | {
    id: string;
    title: string;
    kind: "url";
    url: string;
    enabled: boolean;
    pinned: boolean;
};

type QuickPhrase = {
    id: string;
    title: string;
    content: string;
    enabled: boolean;
};

type AgentEnvRow = {
    id: string;
    key: string;
    value: string;
    enabled: boolean;
};
type AgentEnvByProvider = Record<AgentProvider, AgentEnvRow[]>;

type TerminalProfileId = string | null;
interface AgentSettings {
    language: UiLanguage;
    uiTheme: UiTheme;
    isPrimarySidebarCollapsed: boolean;
    defaultProvider: AgentProvider;
    agentProviderOrder: AgentProvider[];
    agentFullAccess: boolean;
    defaultTerminalProfileId: TerminalProfileId;
    customModelEnabledByProvider: AgentCustomModelEnabledByProvider<AgentProvider>;
    customModelByProvider: AgentCustomModelByProvider<AgentProvider>;
    customModelOptionsByProvider: AgentCustomModelOptionsByProvider<AgentProvider>;
    quickCommands: QuickCommand[];
    quickPhrases: QuickPhrase[];
    agentEnvByProvider: AgentEnvByProvider;
    focusNodeOnClick: boolean;
    focusNodeTargetZoom: FocusNodeTargetZoom;
    focusNodeUseVisibleCanvasCenter: boolean;
    standbyBannerEnabled: boolean;
    standbyBannerShowTask: boolean;
    standbyBannerShowSpace: boolean;
    standbyBannerShowBranch: boolean;
    disableAppShortcutsWhenTerminalFocused: boolean;
    keybindings: KeybindingOverrides;
    canvasInputMode: CanvasInputMode;
    canvasWheelBehavior: CanvasWheelBehavior;
    canvasWheelZoomModifier: CanvasWheelZoomModifier;
    standardWindowSizeBucket: StandardWindowSizeBucket;
    defaultTerminalWindowScalePercent: number;
    terminalFontSize: number;
    terminalFontFamily: string | null;
    uiFontSize: number;
    avoidGroupingEdits: boolean;
    updatePolicy: AppUpdatePolicy;
    hideWorktreeMismatchDropWarning: boolean;
}

interface WorkspaceAgentActivityFileChange {
    path: string;
    change?: "added" | "modified" | "deleted" | "moved" | string;
    tools?: string[];
}
interface WorkspaceAgentActivityFileChanges {
    coverage?: string;
    files?: WorkspaceAgentActivityFileChange[];
}
interface WorkspaceAgentActivityTimelineItem {
    id: number;
    workspaceId?: string;
    agentSessionId: string;
    seq?: number;
    turnId?: string;
    eventSource?: string;
    eventId: string;
    actorType: string;
    actorId: string;
    itemType: "message" | "call" | "event" | "error" | "lifecycle" | string;
    role?: string;
    callType?: "tool" | "skill" | "subagent" | "approval" | "workflow" | string;
    callId?: string;
    name?: string;
    status?: string | null;
    messageSemantics?: AgentActivityMessageSemantics;
    content?: string;
    payload?: Record<string, unknown> & {
        content?: unknown;
        text?: unknown;
        fileChanges?: WorkspaceAgentActivityFileChanges;
    };
    occurredAtUnixMs?: number;
    createdAtUnixMs?: number;
}

type ToolCallStatusKind = "working" | "completed" | "failed" | "canceled" | "waiting";
interface WorkspaceAgentToolCallDisplay {
    id: string;
    name: string;
    status: string | null;
    statusKind: ToolCallStatusKind | null;
    detail?: string;
}

type WorkspaceAgentLatestActivityStatus = "working" | "waiting" | "idle" | "completed" | "canceled" | "failed";
interface WorkspaceAgentConversationPreviewLine {
    actorName: string;
    summary: string;
}

type WorkspaceAgentActivityStatus = WorkspaceAgentLatestActivityStatus;
interface WorkspaceAgentChangedFile {
    path: string;
    label: string;
}
interface WorkspaceAgentActivityCard {
    id: string;
    sessionId: string;
    userId: string | null;
    userName: string;
    userAvatarUrl?: string;
    agentProvider: string;
    agentName: string;
    title: string;
    status: WorkspaceAgentActivityStatus;
    latestActivitySummary: string;
    /** User prompt + latest agent reply for task/issue execution cards; room status list uses single-line summary only. */
    conversationPreview?: WorkspaceAgentConversationPreviewLine[];
    latestActivityActorName?: string;
    toolCalls?: WorkspaceAgentToolCallDisplay[];
    changedFiles: WorkspaceAgentChangedFile[];
    sortTimeUnixMs: number;
    readTimeUnixMs?: number;
}

interface WorkspaceAgentSessionDetailMessage {
    id: string;
    body: string;
    status?: string | null;
    statusKind?: ToolCallStatusKind | null;
    turnId?: string;
    occurredAtUnixMs?: number | null;
    sourceTimelineItems?: WorkspaceAgentActivityTimelineItem[];
    visibleError?: {
        code: string | null;
        phase: string | null;
        provider: string | null;
        origin?: string | null;
        detail: string | null;
        detailAvailable?: boolean;
        retryable: boolean | null;
    } | null;
    systemNotice?: {
        noticeKind: string | null;
        semanticKind?: "context-handoff-required" | null;
        severity: string | null;
        source?: string | null;
        command?: AgentActivityMessageSemantics["noticeCommand"] | null;
        commandStatus?: AgentActivityMessageSemantics["noticeCommandStatus"] | null;
        title: string | null;
        detail: string | null;
        retryable: boolean | null;
    } | null;
}
interface WorkspaceAgentSessionDetailThinking {
    id: string;
    body: string;
    statusKind?: ToolCallStatusKind | null;
    turnId?: string;
    occurredAtUnixMs?: number | null;
    sourceTimelineItems?: WorkspaceAgentActivityTimelineItem[];
}
interface WorkspaceAgentSessionDetailGoalControl {
    id: string;
    action: AgentActivityGoalControlAction;
    body: string;
    occurredAtUnixMs?: number | null;
    sourceTimelineItems?: WorkspaceAgentActivityTimelineItem[];
}
interface WorkspaceAgentSessionDetailToolCall {
    id: string;
    name: string;
    toolName: string | null;
    callType: string | null;
    status: string | null;
    statusKind: ToolCallStatusKind | null;
    summary: string;
    payload: Record<string, unknown> | null;
    turnId?: string;
    compactSummary?: string | null;
    occurredAtUnixMs?: number | null;
    sourceTimelineItems?: WorkspaceAgentActivityTimelineItem[];
}
type WorkspaceAgentSessionDetailToolGroupEntry = {
    kind: "thinking";
    thinking: WorkspaceAgentSessionDetailThinking;
} | {
    kind: "tool-call";
    call: WorkspaceAgentSessionDetailToolCall;
};
type WorkspaceAgentSessionDetailAgentItem = {
    kind: "message";
    message: WorkspaceAgentSessionDetailMessage;
} | {
    kind: "thinking";
    thinking: WorkspaceAgentSessionDetailThinking;
} | {
    kind: "tool-calls";
    id: string;
    toolCalls: WorkspaceAgentSessionDetailToolCall[];
    toolCallCount: number;
    hasFailedToolCall: boolean;
    summary?: string | null;
    groupEntries?: WorkspaceAgentSessionDetailToolGroupEntry[];
};
interface WorkspaceAgentSessionDetailTurn {
    id: string;
    userMessage: WorkspaceAgentSessionDetailMessage | null;
    userMessages: WorkspaceAgentSessionDetailMessage[];
    agentMessages: WorkspaceAgentSessionDetailMessage[];
    toolCalls: WorkspaceAgentSessionDetailToolCall[];
    toolCallCount: number;
    hasFailedToolCall: boolean;
    rawAgentItems?: WorkspaceAgentSessionDetailAgentItem[];
    agentItems: WorkspaceAgentSessionDetailAgentItem[];
}
interface WorkspaceAgentSessionDetailViewModel {
    activity: WorkspaceAgentActivityCard;
    session: AgentActivitySession;
    cwd: string;
    workspaceRoot: string | null;
    goalControls?: WorkspaceAgentSessionDetailGoalControl[];
    turns: WorkspaceAgentSessionDetailTurn[];
    sessionTurns?: readonly AgentActivityTurn[];
    showProcessingIndicator?: boolean;
}

type AgentApprovalPurpose = "edit-files";

interface AgentApprovalOptionVM {
    id: string;
    label: string;
    kind: string;
    description?: string;
}
interface AgentApprovalItemVM {
    kind: "approval";
    id: string;
    agentSessionId?: string;
    turnId: string;
    requestId: string;
    callId: string;
    approvalPurpose?: AgentApprovalPurpose;
    title: string;
    toolName: string | null;
    status: string | null;
    input: Record<string, unknown> | null;
    options: AgentApprovalOptionVM[];
    output?: Record<string, unknown> | null;
    occurredAtUnixMs: number | null;
}

interface AgentAskUserQuestionOptionVM {
    /** Provider-owned durable identity used by interaction automation when present. */
    id?: string;
    label: string;
    description: string;
}
interface AgentAskUserQuestionVM {
    id: string;
    header: string;
    question: string;
    options: AgentAskUserQuestionOptionVM[];
    multiSelect: boolean;
    allowFreeText?: boolean;
    answer?: string | string[] | null;
}
interface AgentAskUserQuestionItemVM {
    kind: "ask-user";
    id: string;
    turnId: string;
    requestId: string;
    title: string;
    status: string | null;
    questions: AgentAskUserQuestionVM[];
    occurredAtUnixMs: number | null;
}

interface AgentGeneratedImageRowVM {
    kind: "generated-image";
    id: string;
    turnId: string;
    sourceCallId: string;
    uri: string;
    mimeType: string | null;
    prompt: string | null;
    occurredAtUnixMs: number | null;
}

interface AgentGoalControlRowVM {
    kind: "goal-control";
    id: string;
    turnId: null;
    action: AgentActivityGoalControlAction;
    body: string;
    occurredAtUnixMs: number | null;
    sourceTimelineItems?: WorkspaceAgentActivityTimelineItem[];
}

type AgentTranscriptPresentationKind = "content" | "specific-progress" | "turn-boundary";

interface AgentCollaborationUsageVM {
    inputTokens: number;
    outputTokens: number;
}
/**
 * Typed projection of one durable "collaboration" timeline message (the
 * daemon projects each collaboration run into the source session transcript
 * with messageId `collab:<runId>`; status transitions update the same message
 * in place). Pure data — rendering and adoption actions live in
 * `AgentCollaborationRow`.
 */
interface AgentCollaborationVM {
    kind: "collaboration";
    runId: string;
    /** Session identity of the source transcript row, for adoption commands. */
    workspaceId: string | null;
    agentSessionId: string | null;
    mode: "consult" | "fork" | "delegate" | "handoff" | (string & {});
    status: "running" | "completed" | "failed" | "canceled" | (string & {});
    triggerSource: "user" | "agent" | "policy" | (string & {});
    triggerReason: string | null;
    targetSessionId: string | null;
    targetAgentTargetId: string | null;
    modelPlanId: string | null;
    /** Optional display name when the daemon payload carries it. */
    modelPlanName: string | null;
    model: string | null;
    contextScope: string | null;
    resultText: string | null;
    failureReason: string | null;
    durationMs: number | null;
    usage: AgentCollaborationUsageVM | null;
    adoption: "pending" | "adopted" | "rejected" | "not_applicable" | (string & {});
}

type AgentPlanModeKind = "enter" | "exit";
interface AgentPlanModeItemVM {
    itemKind: "plan-mode";
    id: string;
    turnId: string;
    requestId?: string;
    kind: AgentPlanModeKind;
    title: string;
    plan?: string | null;
    status: string | null;
    filePath?: string | null;
    options?: AgentApprovalOptionVM[];
    keepPlanningOptionId?: string;
    occurredAtUnixMs: number | null;
}

type AgentTaskSubAgentStatus = "running" | "completed" | "failed" | "canceled";
type AgentTaskSubAgentActivityKind = "message" | "reasoning" | "tool";
interface AgentTaskSubAgentActivityVM {
    kind: AgentTaskSubAgentActivityKind;
    text: string;
    atUnixMs: number | null;
}
interface AgentTaskSubAgentVM {
    childSessionId: string;
    parentToolCallId: string;
    status: AgentTaskSubAgentStatus;
    name: string | null;
    task: string | null;
    laneIndex: number;
    laneCount: number;
    latestActivity: string | null;
    latestActivityKind: AgentTaskSubAgentActivityKind | null;
    assistantMarkdown?: string | null;
    activityLog: readonly AgentTaskSubAgentActivityVM[];
    activityOmittedCount: number;
    queued?: boolean;
    failureDetail: string | null;
    startedAtUnixMs: number | null;
    latestActivityAtUnixMs: number | null;
    terminalAtUnixMs: number | null;
    childSessions: readonly AgentTaskSubAgentVM[];
}
interface AgentTaskStepVM {
    id: string;
    turnId: string;
    name: string;
    toolName: string | null;
    status: string | null;
    summary: string;
    payload: Record<string, unknown> | null;
    tool: AgentToolCallVM | null;
    occurredAtUnixMs: number | null;
}
interface AgentTaskItemVM {
    kind: "task";
    id: string;
    turnId: string;
    title: string;
    status: string | null;
    prompt?: string | null;
    delegateSessionId?: string | null;
    steps: AgentTaskStepVM[];
    subAgents?: AgentTaskSubAgentVM[];
    result?: string | null;
    resultMarkdown?: string | null;
    durationMs?: number | null;
    occurredAtUnixMs: number | null;
}

type AgentToolRendererKind = "default" | "approval" | "plan-enter" | "plan-exit" | "ask-user" | "task" | "read" | "write" | "edit" | "bash" | "search" | "web-search" | "web-fetch" | "image-generation" | "todo-write" | "tool-search" | "skill" | "mcp";
interface AgentToolCallVM {
    kind: "tool-call";
    id: string;
    turnId: string;
    name: string;
    toolName: string | null;
    callType: string | null;
    status: string | null;
    statusKind: ToolCallStatusKind | null;
    summary: string;
    compactSummary: string | null;
    payload: Record<string, unknown> | null;
    input: Record<string, unknown> | null;
    output: Record<string, unknown> | null;
    error: Record<string, unknown> | null;
    metadata: Record<string, unknown> | null;
    locations: unknown[] | null;
    rendererKind: AgentToolRendererKind;
    approval: AgentApprovalItemVM | null;
    planMode: AgentPlanModeItemVM | null;
    askUserQuestion: AgentAskUserQuestionItemVM | null;
    task: AgentTaskItemVM | null;
    occurredAtUnixMs: number | null;
    sourceTimelineItems?: WorkspaceAgentActivityTimelineItem[];
}

type AgentToolGroupEntryVM = {
    kind: "thinking";
    thinking: AgentThinkingContentVM;
} | {
    kind: "tool-call";
    call: AgentToolCallVM;
};
interface AgentToolGroupRowVM {
    kind: "tool-group";
    id: string;
    expansionKey?: string;
    turnId: string;
    grouped: boolean;
    calls: AgentToolCallVM[];
    summary?: string | null;
    entries: AgentToolGroupEntryVM[];
    occurredAtUnixMs: number | null;
}

type AgentMessageContentKind = "text" | "image-grid" | "plan" | "collaboration" | "tutti-checkpoint-wake" | "tutti-plan-issue-link" | "selected-text";
interface AgentMessageContentVM {
    kind: "message-content";
    id: string;
    turnId: string;
    body: string;
    presentationKind: AgentTranscriptPresentationKind;
    copyText?: string | null;
    statusKind?: ToolCallStatusKind | null;
    contentKind?: AgentMessageContentKind;
    isTurnFinalText?: true;
    /** Typed payload for `contentKind: "collaboration"` rows. */
    collaboration?: AgentCollaborationVM | null;
    /**
     * Typed payload for `contentKind: "tutti-checkpoint-wake"` rows: a daemon
     * checkpoint-wake prompt injected into the source agent. `body` carries the
     * full prompt (minus the sentinel line) for the expand-to-full affordance.
     */
    checkpointWake?: AgentTuttiModeCheckpointWakeVM | null;
    /**
     * Typed payload for `contentKind: "tutti-plan-issue-link"` rows: the durable
     * plan→Issue reverse link the daemon writes when the user accepts a Tutti
     * Mode plan (messageId "plan-issue:<issueID>").
     */
    planIssueLink?: AgentTuttiPlanIssueLinkVM | null;
    /** Typed payload for `contentKind: "selected-text"` rows. */
    selectedText?: AgentSelectedTextVM | null;
    images?: AgentMessageImageVM[];
    occurredAtUnixMs: number | null;
    visibleError?: {
        code: string | null;
        phase: string | null;
        provider: string | null;
        origin?: string | null;
        detail: string | null;
        detailAvailable?: boolean;
        retryable: boolean | null;
    } | null;
    systemNotice?: {
        noticeKind: string | null;
        semanticKind?: "context-handoff-required" | null;
        severity: string | null;
        source?: string | null;
        command?: AgentActivityMessageSemantics["noticeCommand"] | null;
        commandStatus?: AgentActivityMessageSemantics["noticeCommandStatus"] | null;
        title: string | null;
        detail: string | null;
        retryable: boolean | null;
    } | null;
    sourceTimelineItems?: WorkspaceAgentActivityTimelineItem[];
}
interface AgentSelectedTextVM {
    count: number;
    texts: readonly string[];
}
interface AgentTuttiModeCheckpointWakeVM {
    /** Wire kind, e.g. "task_settled" | "task_failed" | "all_tasks_terminal". */
    kind: string;
    issueId: string;
    checkpointId: string;
    graphRevision: number | null;
}
interface AgentTuttiPlanIssueLinkVM {
    issueId: string;
    /** Issue title with markdown escapes removed; falls back to the issue id. */
    title: string;
    /** The original single-mention markdown, rendered as the issue chip. */
    mentionMarkdown: string;
}
interface AgentMessageImageVM {
    id: string;
    workspaceId?: string | null;
    agentSessionId: string;
    attachmentId?: string | null;
    mimeType: string;
    name?: string | null;
    data?: string | null;
    url?: string | null;
    path?: string | null;
}
interface AgentThinkingContentVM {
    kind: "thinking-content";
    id: string;
    turnId: string;
    body: string;
    statusKind?: ToolCallStatusKind | null;
    occurredAtUnixMs: number | null;
    sourceTimelineItems?: WorkspaceAgentActivityTimelineItem[];
}
interface AgentMessageRowVM {
    kind: "message";
    id: string;
    turnId: string;
    speaker: "user" | "assistant";
    /**
     * Exact first text block from the submitted structured content. Editing must
     * not recover this value from displayPrompt, copy text, or rendered Markdown.
     */
    rawFirstTextBlock?: string | null;
    messages: AgentMessageContentVM[];
    thinking: AgentThinkingContentVM[];
    /**
     * Tool-group rows that happened right before this message and are rendered
     * inside this message's block (under the participant header, above the
     * content) instead of as standalone transcript rows. Populated only for the
     * participant-header presentation (e.g. the Agent board session detail).
     */
    leadingToolRows?: AgentToolGroupRowVM[];
    occurredAtUnixMs: number | null;
}

interface AgentProcessingRowVM {
    kind: "processing";
    id: string;
    turnId: string | null;
    label?: string | null;
    occurredAtUnixMs: number | null;
}

interface AgentTurnSummaryFileVM {
    label: string;
    path: string;
    fileName: string;
    directory: string | null;
    changeType: "modified" | "created" | "deleted";
    toolName: string | null;
    messageId: string;
    unifiedDiff?: string | null;
    oldString?: string | null;
    newString?: string | null;
    content?: string | null;
    occurredAtUnixMs: number | null;
}
interface AgentTurnSummaryPatchChangeVM {
    path: string;
    changeType: "modified" | "created" | "deleted";
    unifiedDiff?: string | null;
    oldString?: string | null;
    newString?: string | null;
    content?: string | null;
}
interface AgentTurnSummaryPatchBatchVM {
    cwd: string | null;
    toolCallId: string;
    changes: AgentTurnSummaryPatchChangeVM[];
}
interface AgentTurnSummaryRowVM {
    kind: "turn-summary";
    id: string;
    turnId: string;
    files: AgentTurnSummaryFileVM[];
    patchBatches?: AgentTurnSummaryPatchBatchVM[];
    fileCount: number;
    modifiedCount: number;
    createdCount: number;
    occurredAtUnixMs: number | null;
}

type AgentTranscriptRowVM = AgentGeneratedImageRowVM | AgentGoalControlRowVM | AgentMessageRowVM | AgentToolGroupRowVM | AgentTurnSummaryRowVM | AgentProcessingRowVM;

interface AgentInteractionResponseInput {
    agentSessionId?: string;
    turnId?: string;
    requestId: string;
    action?: string;
    optionId?: string;
    payload?: Record<string, unknown>;
}
type AgentConversationPromptVM = AgentApprovalItemVM | {
    kind: "ask-user";
    agentSessionId?: string;
    turnId?: string;
    requestId: string;
    title: string;
    questions: AgentAskUserQuestionVM[];
} | {
    kind: "exit-plan";
    agentSessionId?: string;
    turnId?: string;
    requestId: string;
    title: string;
    options: AgentApprovalOptionVM[];
    keepPlanningOptionId?: string;
} | {
    kind: "plan-implementation";
    requestId: string;
    title: string;
};
interface AgentConversationVM {
    activity: WorkspaceAgentActivityCard;
    workspaceRoot: string | null;
    sourceDetail: WorkspaceAgentSessionDetailViewModel;
    rows: AgentTranscriptRowVM[];
}

declare const PLAN_IMPLEMENTATION_ACTION_IMPLEMENT = "implement";
declare const PLAN_IMPLEMENTATION_ACTION_FEEDBACK = "feedback";
declare const PLAN_IMPLEMENTATION_ACTION_SKIP = "skip";
interface PlanIssueExecutionProfile {
    reasoningIntensity: number;
    orchestrationIntensity: number;
}
interface PlanIssueBudget {
    mode: "auto" | "fixed";
    tokenLimit: number;
    quotaWaterlinePercent: number;
}
/**
 * Remembered planning defaults chosen before a Plan turn is submitted. The
 * generated plan can still provide explicit values; otherwise these values
 * seed the mandatory Issue-decomposition review.
 */
interface PlanIssueBudgetPreset {
    executionProfile: PlanIssueExecutionProfile;
    budget: PlanIssueBudget;
}

interface AgentGUINodeData {
    provider: AgentGUIProvider;
    agentTargetId?: string | null;
    lastActiveAgentSessionId: string | null;
    lastActiveAgentSessionIdByAgentTargetId?: Record<string, string> | null;
    conversationCount?: number | null;
    conversationRailWidthPx?: number | null;
    conversationRailCollapsed?: boolean | null;
    composerOverrides?: AgentHostAgentSessionComposerSettings | null;
    composerOverridesByAgentTargetId?: Record<string, AgentHostAgentSessionComposerSettings | null> | null;
    composerOverridesByProvider?: Partial<Record<AgentGUIProvider, AgentHostAgentSessionComposerSettings | null>> | null;
    /** Remembered defaults for provider Plan decomposition review. */
    planIssueBudgetPreset?: PlanIssueBudgetPreset | null;
}
/**
 * Open runtime metadata reported by an Agent Target.
 *
 * Built-in providers still use AgentProvider, while externally installed ACP
 * extensions use namespaced values such as `acp:gemini`.
 */
type AgentGUIProvider = string;
/**
 * Stable identifiers for the starter entries shown below the empty new-session
 * composer. Hosts can pass these values to `AgentGUI.disabled` to hide entries
 * that should not be available in their integration.
 */
type AgentGUIHomeSuggestionId = "meet-tutti" | "clone-github-repository" | "task-breakdown" | "quality-review" | "agent-interaction" | "import-session";
type AgentGUIAgentAvailabilityStatus = "ready" | "checking" | "coming_soon" | "not_installed" | "auth_required" | "unavailable";
type AgentGUIAgentAvailabilityAction = "install" | "login" | "refresh";
interface AgentGUIAgentAvailability {
    status: AgentGUIAgentAvailabilityStatus;
    reason?: string | null;
    pendingAction?: AgentGUIAgentAvailabilityAction | null;
}
interface AgentGUIAgentOwner {
    userId?: string | null;
    name?: string | null;
    avatarUrl?: string | null;
}
/** Host-authoritative ownership classification for Agent directory entries. */
type AgentGUIAgentOwnership = "self" | "shared";
interface AgentGUISharedAgentQuota {
    unit: "runs" | "tokens";
    remaining: number;
    limit?: number;
    resetAt?: string | null;
}
interface AgentGUISharedAgentConcurrency {
    active: number;
    limit: number;
}
interface AgentGUISharedAgentCostQuota {
    currency: string;
    remainingMicros: number;
    limitMicros?: number;
}
interface AgentGUISharedAgentAllowedModel {
    modelPlanId?: string | null;
    model: string;
}
interface AgentGUISharedAgentPolicyPermissions {
    consult: boolean;
    review: boolean;
    delegate: boolean;
    upgrade: boolean;
}
/** Credential-free access snapshot supplied by the shared-Agent control plane. */
interface AgentGUISharedAgentAccess {
    grantId: string;
    ownerUserId: string;
    ownerOnline: boolean;
    auditRequired: boolean;
    quota?: AgentGUISharedAgentQuota | null;
    concurrency?: AgentGUISharedAgentConcurrency | null;
    costQuota?: AgentGUISharedAgentCostQuota | null;
    allowedModels?: readonly AgentGUISharedAgentAllowedModel[] | null;
    policyPermissions?: AgentGUISharedAgentPolicyPermissions | null;
}
/**
 * Host-projected entry from the workspace `/agents` directory.
 *
 * `agentTargetId` is the only UI and launch identity. `provider` remains
 * execution metadata for provider-native composer/runtime policy and must not
 * be used to group, deduplicate, name, or select entries.
 */
interface AgentGUIAgent {
    agentTargetId: string;
    name: string;
    iconUrl: string;
    /** Single-color artwork rendered through the conversation rail CSS mask. */
    maskIconUrl?: string | null;
    heroImageUrl?: string | null;
    description?: string | null;
    /** Host-resolved display name of the device that owns this Agent target. */
    ownerDeviceLabel?: string | null;
    owner?: AgentGUIAgentOwner | null;
    ownership?: AgentGUIAgentOwnership | null;
    sharedAccess?: AgentGUISharedAgentAccess | null;
    availability: AgentGUIAgentAvailability;
    provider: AgentGUIProvider;
    /**
     * False when this exact target routes model access through a Host-owned
     * Model Plan, so the Runtime provider's native account usage is unrelated.
     * Omitted values preserve the ordinary provider account-usage behavior.
     */
    providerAccountUsageApplicable?: boolean;
    setupKind?: "target_runtime" | null;
}
type AgentGUIAgentDirectoryStatus = "idle" | "loading" | "ready" | "error";
interface AgentGUIAgentDirectorySnapshot {
    agents: readonly AgentGUIAgent[];
    capturedAtUnixMs: number | null;
    error: string | null;
    status: AgentGUIAgentDirectoryStatus;
}
interface AgentGUIAgentDirectoryPort {
    getSnapshot(): AgentGUIAgentDirectorySnapshot;
    subscribe(listener: () => void): () => void;
}
interface AgentGUIAllAgentsPresentation {
    iconUrl?: string | null;
}
interface AgentGUIAgentTargetRef {
    kind: string;
    provider: AgentGUIProvider;
    [key: string]: unknown;
}
interface AgentGUIAgentTargetBadge {
    iconUrl: string;
    label?: string;
}
interface AgentGUIAgentTarget {
    targetId: string;
    agentTargetId?: string | null;
    provider: AgentGUIProvider;
    ref: AgentGUIAgentTargetRef;
    label: string;
    description?: string;
    iconUrl?: string | null;
    maskIconUrl?: string | null;
    heroImageUrl?: string | null;
    badge?: AgentGUIAgentTargetBadge | null;
    ownerLabel?: string;
    ownerDeviceLabel?: string;
    ownership?: AgentGUIAgentOwnership;
    availability?: AgentGUIAgentAvailability;
    /** Host projection of whether provider-native account usage applies here. */
    providerAccountUsageApplicable?: boolean;
    disabled?: boolean;
    unavailableReason?: string;
}
/**
 * Product-neutral surfaces where a Host may enrich an exact Agent target.
 * AgentGUI owns the trigger, positioning, and interaction behavior; the Host
 * owns only the rendered information.
 */
type AgentGUIAgentTargetInfoSurface = "provider-rail" | "conversation-rail" | "workbench-header";
interface AgentGUIAgentTargetInfoRenderContext {
    surface: AgentGUIAgentTargetInfoSurface;
    target: AgentGUIAgentTarget;
}
/**
 * Renders Host-owned presentation for an exact Agent target.
 *
 * AgentGUI invokes this renderer lazily only while its tooltip content is
 * mounted. Returning null preserves the built-in target-label fallback.
 */
type AgentGUIAgentTargetInfoRenderer = (context: AgentGUIAgentTargetInfoRenderContext) => ReactElement | null;
type AgentGUITargetConnectionStatus = "connected" | "connecting" | "unavailable";
interface AgentGUITargetConnectionState {
    status: AgentGUITargetConnectionStatus;
    retryAttempt: number;
}
/**
 * Host-owned, ephemeral device transport state keyed by exact Agent target.
 *
 * This capability gates new-conversation and ordinary Composer writes. When an
 * Interaction-readiness source is present for the displayed prompt, that exact
 * readiness result has precedence over this target-level state for Interaction
 * presentation and admission.
 */
interface AgentGUITargetConnectionSource {
    getConnectionState(agentTargetId: string): AgentGUITargetConnectionState | null;
    subscribe(listener: () => void): () => void;
}
/**
 * Caller-side presentation gap for one exact Session Turn.
 *
 * The canonical Turn remains authoritative and active. Hosts expose this only
 * while their projection may be stale so AgentGUI can pause live presentation
 * until the exact Turn has caught up again.
 */
interface AgentGUIObservationGap {
    startedAtUnixMs: number;
    /**
     * Optional Host-owned presentation classification. Older Hosts may omit it
     * and retain the frozen-duration fallback.
     */
    presentationState?: "peer-offline" | "synchronizing";
}
interface AgentGUIObservationGapSource {
    getObservationGap(agentSessionId: string, turnId: string): AgentGUIObservationGap | null;
    subscribe(listener: () => void): () => void;
}
/** Exact canonical Interaction identity used for Host write admission. */
interface AgentGUIInteractionReadinessIdentity {
    workspaceId: string;
    agentSessionId: string;
    turnId: string;
    requestId: string;
}
type AgentGUIInteractionReadinessReason = "synchronizing" | "owner_offline" | "binding_revoked";
type AgentGUIInteractionReadiness = {
    status: "ready";
} | {
    status: "blocked";
    reason: AgentGUIInteractionReadinessReason;
};
/**
 * Host-owned, ephemeral write readiness for an exact pending Interaction.
 *
 * When this capability is supplied, a missing exact record is unresolved and
 * consumers fail closed as `blocked(synchronizing)`. Omit the whole source to
 * preserve the default local-host admission behavior. For a displayed exact
 * pending Interaction, this source is the sole transport-presentation and
 * early-admission authority; target connection and Turn observation gaps must
 * not override it.
 */
interface AgentGUIInteractionReadinessSource {
    getInteractionReadiness(identity: AgentGUIInteractionReadinessIdentity): AgentGUIInteractionReadiness | null;
    subscribe(listener: () => void): () => void;
}
interface AgentGUIProviderRailAllPresentation {
    iconUrl?: string | null;
}
/**
 * How the provider rail composes the target list.
 * - "catalog" (default): host-provided targets are augmented with the static
 *   local provider catalog, disabled placeholders (nexight/hermes/openclaw),
 *   and coming-soon markers. When no targets are provided, the full local
 *   catalog is shown.
 * - "exact": the rail renders exactly the provided targets — no static catalog
 *   fallback, no disabled placeholders, no coming-soon injection. When the list
 *   is empty (and not loading) the host-provided empty renderer is shown. Use
 *   this when the list is fully orchestrated externally (e.g. shared agents,
 *   custom /agents).
 */
type AgentGUIProviderRailMode = "catalog" | "exact";
type AgentGUIProviderReadinessGateStatus = "checking" | "coming_soon" | "not_installed" | "auth_required" | "runtime_selection" | "unavailable";
type AgentGUIProviderReadinessGateAction = "install" | "login" | "refresh" | "choose";
interface AgentGUIProviderReadinessGate {
    status: AgentGUIProviderReadinessGateStatus;
    pendingAction?: AgentGUIProviderReadinessGateAction | null;
    /**
     * Opens the host-owned model-plan setup route for this blocked provider.
     * Absent stays hidden; non-Tutti hosts should omit the capability.
     */
    onModelPlanSetup?: () => void;
    onAction?: (provider: AgentGUIProvider, action: AgentGUIProviderReadinessGateAction) => void;
}
interface Size {
    width: number;
    height: number;
}
interface Point {
    x: number;
    y: number;
}
interface NodeFrame {
    position: Point;
    size: Size;
}

interface AgentGuiWorkbenchCommandBridge {
    instanceId: string;
    onConversationRailToggle?(conversationRailCollapsed: boolean): void;
}

type WorkspaceLinkActionSource = "agent-markdown" | "agent-file-change" | string;
interface OpenWorkspaceUrlLinkAction {
    type: "open-url";
    url: string;
    source: WorkspaceLinkActionSource;
}
interface OpenAgentSessionLinkAction {
    type: "open-agent-session";
    workspaceId: string;
    agentSessionId: string;
    agentTargetId?: string | null;
    source: WorkspaceLinkActionSource;
}

interface OpenWorkspaceFileLinkAction {
    type: "open-workspace-file";
    mode?: "select" | "open";
    path: string;
    directoryPath: string;
    workspaceRoot: string;
    source: WorkspaceLinkActionSource;
    prefetchedDirectoryListing?: WorkspaceFileLinkDirectoryListing | null;
}
interface OpenLocalAssetPreviewLinkAction {
    type: "open-local-asset-preview";
    path: string;
    name: string;
    source: WorkspaceLinkActionSource;
}
interface WorkspaceFileLinkDirectoryEntry {
    path: string;
    name: string;
    kind: "file" | "directory" | "unknown";
    hasChildren: boolean | null;
    sizeBytes: number | null;
    mtimeMs: number | null;
}
interface WorkspaceFileLinkDirectoryListing {
    workspaceId: string;
    root: string;
    directoryPath: string;
    entries: WorkspaceFileLinkDirectoryEntry[];
}
interface OpenWorkspaceIssueLinkAction {
    type: "open-workspace-issue";
    workspaceId: string;
    issueId: string | null;
    mode?: WorkspaceIssueMentionMode;
    outputDir?: string | null;
    runId?: string | null;
    taskId?: string | null;
    topicId?: string | null;
    source: WorkspaceLinkActionSource;
}
interface OpenWorkspaceAppLinkAction {
    type: "open-workspace-app";
    workspaceId: string;
    appId: string;
    conversationId?: string | null;
    messageId?: string | null;
    summaryTaskId?: string | null;
    source: WorkspaceLinkActionSource;
}
interface OpenCustomMentionLinkAction {
    type: "open-custom-mention";
    /** 注册表里的 kind(= mention:// providerId)。 */
    kind: string;
    href: string;
    source: WorkspaceLinkActionSource;
}
type WorkspaceLinkAction = OpenWorkspaceFileLinkAction | OpenLocalAssetPreviewLinkAction | OpenWorkspaceUrlLinkAction | OpenAgentSessionLinkAction | OpenWorkspaceIssueLinkAction | OpenWorkspaceAppLinkAction | OpenCustomMentionLinkAction;

interface AgentMessageMarkdownWorkspaceAppIcon {
    appId: string;
    iconUrl: string | null;
    workspaceId?: string | null;
}

type AgentSessionCommand = AgentHostAgentSessionCommand;
type AgentSessionComposerSettings = AgentHostAgentSessionComposerSettings;
type AgentSessionPermissionConfig = AgentHostAgentSessionPermissionConfig;
type AgentSessionReasoningEffort = AgentHostAgentSessionReasoningEffort;
type AgentSessionSpeed = AgentHostAgentSessionSpeed;

type AgentGUIResolvedProvider = AgentGUIProvider | "unknown";
type AgentGUIConversationTitleFallback = "untitled-conversation" | null;
type AgentGUIConversationTitleLeadingMentionKind = "agent" | "app" | "file" | "session" | "task";

interface AgentGUIConversationProjectSummary {
    id: string;
    path: string;
    label: string;
    sectionKey?: string;
    createdAtUnixMs?: number;
    updatedAtUnixMs?: number;
    lastUsedAtUnixMs?: number;
    pinnedAtUnixMs: number;
}
type AgentGUIConversationUserProject = Pick<AgentHostUserProject, "id" | "path" | "label" | "sectionKey" | "createdAtUnixMs" | "updatedAtUnixMs" | "lastUsedAtUnixMs" | "pinnedAtUnixMs">;

type AgentGUIConversationFilter = {
    kind: "all";
} | {
    kind: "agentTarget";
    agentTargetId: string;
};

interface AgentGUIConversationSummary {
    id: string;
    userId?: string;
    agentTargetId?: string | null;
    provider: AgentGUIResolvedProvider;
    resumable?: boolean;
    title: string;
    titleLeadingMentionKind?: AgentGUIConversationTitleLeadingMentionKind | null;
    titleFallback?: AgentGUIConversationTitleFallback;
    status: AgentGUIConversationStatus;
    cwd: string;
    isolation?: AgentActivitySession["isolation"];
    railSectionKey?: string;
    project?: AgentGUIConversationProjectSummary | null;
    pinnedAtUnixMs?: number | null;
    sortTimeUnixMs?: number;
    updatedAtUnixMs: number;
    hasUnreadCompletion?: boolean;
    unreadCompletionKey?: string | null;
    needsUserAction?: boolean;
    hiddenFromRail?: boolean;
    isTransient?: boolean;
    projectionSource?: "pending_activation" | "runtime_overlay";
    isImported?: boolean;
    activeTurn?: AgentActivitySession["activeTurn"];
}
type AgentGUIConversationStatus = "working" | "waiting" | "ready" | "completed" | "failed" | "canceled";
type AgentGUIApprovalRequest = AgentApprovalItemVM;
interface AgentGUIInteractiveQuestion extends AgentAskUserQuestionVM {
    isOther?: boolean;
}
type AgentGUIInteractivePrompt = AgentGUIApprovalRequest | {
    kind: "ask-user";
    agentSessionId?: string;
    turnId?: string;
    requestId: string;
    title: string;
    questions: AgentGUIInteractiveQuestion[];
} | Extract<AgentConversationPromptVM, {
    kind: "exit-plan";
}> | Extract<AgentConversationPromptVM, {
    kind: "plan-implementation";
}>;

type AgentGUIConversationRailRevealReason = "created" | "external-open";
interface AgentGUIConversationRailRevealRequest {
    agentSessionId: string;
    reason: AgentGUIConversationRailRevealReason;
    revision: number;
}

type AgentCapabilityUse = "browserUse" | "computerUse";

interface AgentSlashCommandCapability {
    aliases?: readonly string[];
    capability: AgentCapabilityUse | "tutti";
    kind: "capability";
    name: string;
}
type AgentSlashCommandPolicy = AgentActivitySlashCommandPolicy;

interface AgentGUISessionChrome {
    auth: {
        message: string;
    } | null;
    approval: AgentGUIApprovalRequest | null;
    recovery: {
        kind: "activating" | "failed" | "warning" | "agent-sharing-revoked" | "transport-connecting" | "transport-unavailable";
        message: string;
        canRetry?: boolean;
        followupAction?: never;
        /**
         * The recovery only gates the currently displayed interaction. Keep
         * that prompt visible while rendering the recovery as inline chrome.
         */
        interactionScoped?: boolean;
    } | {
        kind: "resume-unavailable";
        message: string;
        followupAction: "continue-in-new-conversation";
        canRetry?: never;
    } | null;
    rawState: (Pick<CanonicalAgentSession, "agentSessionId" | "goal"> & {
        goalControlStatus: "idle" | "pending_create" | "pending" | "accepted" | "succeeded" | "failed" | "unknown";
        goalIsOptimistic: boolean;
    }) | null;
}
interface AgentGUIInlineNotice {
    id: string;
    message: string;
    tone: "warning" | "error";
    autoDismissMs: number | null;
}
interface AgentGUIProjectConversationDeleteTarget {
    conversationCount: number;
    label: string;
    path: string;
}
interface AgentGUIComposerSettingOption {
    value: string;
    label: string;
    description?: string;
    consumptionMultiplier?: string;
    supportsImageInput?: boolean;
    /** Bound plan identity for options aggregated from model access plans. */
    modelPlanId?: string | null;
    /** Display name of the plan (or provider) the option originates from. */
    sourceName?: string;
    /** When the option takes effect after selection. */
    effect?: "new_session" | "next_call";
}
interface AgentGUIComposerModelCatalogTestimonyVM {
    /** Only an authoritative catalog may retire a remembered recent model. */
    authoritative: boolean;
    /** Provider-native model discovery is still in flight. */
    loading: boolean;
    /** Effective selected model used to recognize selected-only bootstrap echoes. */
    effectiveModel: string | null;
    /** Narrow catalog provenance needed by local recent-model reconciliation. */
    models: readonly {
        value: string;
        requested?: boolean;
    }[];
}
interface AgentGUIComposerModelChoiceHistoryVM {
    /** Exact Agent Target identity; null fails closed and disables persistence. */
    targetId: string | null;
    /** Null until the composer has any provider-native catalog testimony. */
    catalog: AgentGUIComposerModelCatalogTestimonyVM | null;
}
interface AgentGUIProviderSkillOption {
    name: string;
    trigger: string;
    /** Stable daemon connector key used for host-owned setup navigation. */
    connectorKey?: string;
    /** Presentation icon projected by the connector catalog. */
    iconUrl?: string;
    /** Successful installation time used only for stable composer ordering. */
    installedAtUnixMs?: number;
    /** Daemon-issued invocation contract; never infer this from provider id. */
    invocation?: "promptItem" | "textTrigger";
    sourceKind: "project" | "personal" | "bundled" | "plugin" | "system" | "tutti-injected" | "connector";
    description?: string;
    pluginName?: string;
    path?: string;
    kind?: "skill" | "connector";
    status?: "available" | "disabled" | "authRequired" | "setupRequired" | "unsupported";
}
interface AgentComposerTextBlock {
    type: "text";
    text: string;
}
interface AgentComposerImageBlock {
    type: "image";
    id: string;
    name: string;
    mimeType: "image/png" | "image/jpeg" | "image/webp";
    attachmentId?: string;
    data?: string;
    url?: string;
    path?: string;
    previewUrl: string;
    uploading?: boolean;
    uploadError?: string;
}
interface AgentComposerFileBlockBase {
    type: "file";
    id: string;
    name: string;
    mimeType?: string;
    path?: string;
    hostPath?: string;
    url?: string;
    uri?: string;
    assetId?: string;
    uploadStatus?: string;
    sizeBytes?: number;
    uploading?: boolean;
    uploadError?: string;
    uploadErrorCode?: string;
    uploadRetryable?: boolean;
}
interface AgentComposerRegularFileBlock extends AgentComposerFileBlockBase {
    kind: "file";
    text?: never;
}
interface AgentComposerPastedTextBlock extends AgentComposerFileBlockBase {
    kind: typeof AGENT_PASTED_TEXT_BLOCK_KIND;
    /** Empty only when a queued pasted-text attachment is restored by path. */
    text: string;
}
/** Transcript text retained as visible, unsent composer context. */
interface AgentComposerQuoteBlock {
    type: "quote";
    id: string;
    text: string;
}
type AgentComposerFileBlock = AgentComposerRegularFileBlock | AgentComposerPastedTextBlock;
type AgentComposerAttachmentBlock = AgentComposerImageBlock | AgentComposerFileBlock;
interface AgentComposerConnectorBlock {
    type: "connector";
    connectorKey: string;
}
type AgentComposerSupplementaryBlock = AgentComposerAttachmentBlock | AgentComposerQuoteBlock | AgentComposerConnectorBlock;
type AgentComposerDraftContent = [
    AgentComposerTextBlock,
    ...AgentComposerSupplementaryBlock[]
];
/** One atomic, unsent composer message. */
type AgentComposerDraft = AgentComposerDraftContent;
type AgentComposerDraftFile = Omit<AgentComposerRegularFileBlock, "type" | "kind">;
interface AgentGUIComposerModelPlanVM {
    id: string;
    name: string;
    protocol?: string | null;
}
interface AgentGUIComposerSettingsVM {
    sessionSettings: AgentSessionComposerSettings | null;
    draftSettings: {
        codexSaverMode?: boolean;
        model: string | null;
        reasoningEffort: AgentSessionReasoningEffort | null;
        speed: AgentSessionSpeed | null;
        planMode: boolean;
        browserUse?: boolean;
        computerUse?: boolean;
        permissionModeId?: string | null;
    };
    supportsModel: boolean;
    supportsCodexSaverMode?: boolean;
    supportsReasoningEffort: boolean;
    supportsSpeed: boolean;
    supportsPermissionMode?: boolean;
    supportsPlanMode: boolean;
    planExclusiveWithPermissionMode?: boolean;
    supportsBrowser?: boolean;
    supportsComputerUse?: boolean;
    permissionModeChangeDuringTurn?: boolean;
    slashCommandPolicy?: AgentSlashCommandPolicy | null;
    isSettingsLoading: boolean;
    /** Terminal composer-options failure with no cached catalog to render. */
    composerOptionsError?: boolean;
    /** Activity-core request lifecycle for the target-scoped options catalog. */
    composerOptionsLoadStatus?: AgentActivityComposerOptionsLoadStatus;
    /** Initial slash command and capability catalog request is in flight. */
    isCapabilityOptionsLoading?: boolean;
    /** Local Connector Market projection is being loaded or refreshed. */
    isConnectorOptionsLoading?: boolean;
    isModelOptionsLoading?: boolean;
    /** Device-local model recents/favorites identity and catalog testimony. */
    modelChoiceHistory?: AgentGUIComposerModelChoiceHistoryVM;
    modelUnavailable: boolean;
    reasoningUnavailable: boolean;
    speedUnavailable: boolean;
    permissionModeUnavailable?: boolean;
    selectedModelValue?: string | null;
    /** Actual provider-resolved model while selectedModelValue remains inherited. */
    effectiveModelValue?: string | null;
    selectedReasoningEffortValue?: AgentSessionReasoningEffort | null;
    selectedSpeedValue?: AgentSessionSpeed | null;
    selectedPermissionModeValue?: string | null;
    permissionConfig?: AgentSessionPermissionConfig | null;
    selectedProjectPath?: string | null;
    /** Persisted rail membership used to scope Agent-generated file mentions. */
    selectedProjectSectionKey?: string | null;
    /** Resolve the durable default only before the home project intent is known. */
    shouldApplyPreparedProjectSelection?: boolean;
    projectLocked?: boolean;
    projectPathIsRemote?: boolean;
    collapseModelOptionsToLatest?: boolean;
    modelPlan?: AgentGUIComposerModelPlanVM | null;
    modelSwitchTakesEffectNextTurn?: boolean;
    availableModels: AgentGUIComposerSettingOption[];
    availableReasoningEfforts: AgentGUIComposerSettingOption[];
    availableSpeeds: AgentGUIComposerSettingOption[];
    availablePermissionModes?: AgentGUIComposerSettingOption[];
}
interface AgentGUIQueuedPromptVM {
    id: string;
    content: AgentPromptContentBlock[];
    /** 仅展示用文本(bundle 折叠成一个 chip);content 仍带展开后的文件。 */
    displayPrompt?: string;
    createdAtUnixMs: number;
}
type AgentGUIQueueStatus = "active" | "paused_by_user";
interface AgentGUIShellViewModel {
    nodeId?: string | null;
    workspaceId: string;
    workspacePath?: string | null;
    currentUserId?: string | null;
    data: AgentGUINodeData;
}
interface AgentGUIRailViewModel {
    selectedAgentTarget: AgentGUIAgentTarget;
    agentTargets: readonly AgentGUIAgentTarget[];
    agentTargetsLoading: boolean;
    /** How the rail composes its list — "exact" renders targets verbatim with no static injection. */
    providerRailMode: AgentGUIProviderRailMode;
    /** Providers gated by the host (feature-gated) — rail renders coming-soon placeholders. */
    comingSoonProviders: readonly AgentGUIProvider[];
    conversationFilter: AgentGUIConversationFilter;
    conversations: AgentGUIConversationSummary[];
    userProjects: AgentGUIConversationUserProject[];
    activeConversation: AgentGUIConversationSummary | null;
    activeConversationId: string | null;
    revealRequest: AgentGUIConversationRailRevealRequest | null;
    isLoadingConversations: boolean;
    listError: string | null;
}
interface AgentGUIDetailViewModel {
    availability: "loading" | "ready" | "not_found" | "error";
    isLoadingMessages: boolean;
    isLoadingOlderMessages: boolean;
    hasOlderMessages: boolean;
    usage: AgentActivityUsage | null;
    hasSentUserMessage: boolean;
    avoidGroupingEdits: boolean;
    conversation?: AgentConversationVM | null;
    conversationDetail: WorkspaceAgentSessionDetailViewModel | null;
}
type AgentGUIRuntimeBlockedReason = Extract<SessionRuntimeAvailability, {
    state: "blocked";
}>["reason"];
type AgentGUIComposerRuntimeGate = {
    status: "ready";
    reason: null;
    sessionRuntimeReason: null;
} | {
    status: "blocked";
    reason: "target_connection";
    sessionRuntimeReason: null;
} | {
    status: "blocked";
    reason: "session_runtime";
    sessionRuntimeReason: AgentGUIRuntimeBlockedReason;
};
type AgentGUIComposerEditorBlockedReason = "collaborator_read_only" | "creating_conversation" | "interrupting" | "non_retryable_recovery" | "pending_approval" | "pending_interactive_prompt" | "provider_readiness" | "runtime_blocked" | "submitting";
type AgentGUIComposerSubmissionBlockedReason = AgentGUIComposerEditorBlockedReason | "activation_failed" | "activation_pending" | "agent_targets_loading" | "authentication_required" | "conversation_busy" | "resume_unavailable" | "settings_update_pending";
interface AgentGUIComposerGate {
    /** Canonical busy projection captured with the same gate snapshot. */
    conversationBusy: boolean;
    /** A submitted prompt is waiting for its canonical Turn to appear. */
    isAwaitingTurnStart?: boolean;
    /**
     * Runtime-dependent command availability used by Composer-adjacent
     * controls such as Stop and interactive responses.
     */
    runtime: AgentGUIComposerRuntimeGate;
    editor: {
        status: "editable";
        reason: null;
    } | {
        status: "blocked";
        reason: AgentGUIComposerEditorBlockedReason;
    };
    submission: {
        status: "ready";
        reason: null;
    } | {
        status: "queue";
        reason: "conversation_busy";
    } | {
        status: "blocked";
        reason: AgentGUIComposerSubmissionBlockedReason;
    };
}
interface AgentGUIComposerViewModel {
    handoffAgentTargets: readonly AgentGUIAgentTarget[];
    availableCommands: AgentSessionCommand[];
    availableSkills: AgentGUIProviderSkillOption[];
    draftPrompt: string;
    draftContent: AgentComposerDraft;
    isCreatingConversation: boolean;
    isSubmitting: boolean;
    isInterrupting: boolean;
    isCancelPending: boolean;
    /** The Engine can stop a pending prompt before its Turn is visible. */
    hasPendingSubmitStopTarget?: boolean;
    promptImagesSupported: boolean;
    compactSupported: boolean | null;
    /** Provider goal exposes a real paused state and pause/resume controls. */
    goalPauseSupported: boolean;
    gate: AgentGUIComposerGate;
    isTuttiModeActive: boolean;
    isTuttiModeUpdating: boolean;
    /** Effective Tutti outcome-quality and completion-speed preferences. */
    tuttiModeEffect: number;
    tuttiModeSpeed: number;
    tuttiModeUpdateStatus: "idle" | "pending_create" | "updating" | "failed" | "uncertain";
    composerSettings: AgentGUIComposerSettingsVM;
    queuedPrompts: AgentGUIQueuedPromptVM[];
    queueStatus: AgentGUIQueueStatus;
    drainingQueuedPromptId: string | null;
}
interface AgentGUIInteractionViewModel {
    approvalDisabledReason: string | null;
    /** The visible prompt is the one exact pending question Composer can answer. */
    canAnswerPendingInteractivePromptFromComposer?: boolean;
    interactivePromptDisabledReason: string | null;
    isRespondingApproval: boolean;
    isRespondingInteractivePrompt: boolean;
    pendingApproval: AgentGUIApprovalRequest | null;
    pendingInteractivePrompt: AgentGUIInteractivePrompt | null;
    sessionChrome: AgentGUISessionChrome;
    inlineNotice: AgentGUIInlineNotice | null;
}
interface AgentGUIReadinessViewModel {
    activeLiveState: "inactive" | "activating" | "active" | "failed";
    activationError: string | null;
    providerReadinessGate: AgentGUIProviderReadinessGate | null;
}
interface AgentGUIOperationsViewModel {
    forkThroughTurnPendingTurnIds: readonly string[];
    goalClearNoticeSequence: number;
    isDeletingConversation: boolean;
    isDeletingProjectConversations: boolean;
    isUserProjectMutationPending: boolean;
    pendingDeleteConversation: AgentGUIConversationSummary | null;
    pendingDeleteProjectConversations: AgentGUIProjectConversationDeleteTarget | null;
}
interface AgentGUINodeViewModel {
    shell: AgentGUIShellViewModel;
    rail: AgentGUIRailViewModel;
    detail: AgentGUIDetailViewModel;
    composer: AgentGUIComposerViewModel;
    interaction: AgentGUIInteractionViewModel;
    readiness: AgentGUIReadinessViewModel;
    operations: AgentGUIOperationsViewModel;
}

interface AgentProjectPathChangeMetadata {
    action: WorkspaceUserProjectSelectChangeAction;
    project?: WorkspaceUserProject;
}
type AgentProjectDropdownOptions = Pick<WorkspaceUserProjectSelectProps, "labels" | "menuActions" | "showKnownProjectOptions"> & {
    /** Optional Host-owned import flow. Absent by default, so existing Hosts are unchanged. */
    importDirectory?: WorkspaceUserProjectApi["importDirectory"];
};

type AgentFileMentionKind = "file" | "directory" | "unknown";
type AgentMentionFileNavigationAction = "agent-generated-folder" | "agent-generated-folder-back" | "workspace-folder" | "workspace-folder-back";
type AgentMentionScope = "my_sessions" | "collab_sessions";
type AgentMentionReferenceSource = "app" | "task";
interface AgentMentionFileItem {
    kind: "file";
    path: string;
    href: string;
    name: string;
    entryKind: AgentFileMentionKind;
    directoryPath: string;
    /** Present only for a regular file attached from the local composer. */
    attachmentId?: string;
    attachmentStatus?: AgentComposerFileMentionStatus;
    attachmentErrorCode?: string;
    score?: number;
    thumbnailUrl?: string | null;
    mentionNavigation?: AgentMentionFileNavigationAction;
    childCount?: number;
    /** Ephemeral picker-only relative path and owning-workspace presentation. */
    contextLabel?: string;
}
type AgentComposerFileMentionStatus = "uploading" | "ready" | "error";
interface AgentMentionSessionItem {
    kind: "session";
    href: string;
    workspaceId: string;
    targetId: string;
    agentTargetId?: string;
    name: string;
    title: string;
    scope: AgentMentionScope;
    initiatorUserId?: string;
    initiatorName: string;
    initiatorAvatarUrl?: string;
    agentName: string;
    /** Structured owner segment from the matching provenance Agent option. */
    agentOwnerLabel?: string;
    /** Structured Agent segment from the matching provenance Agent option. */
    agentLabel?: string;
    agentIconUrl?: string;
    status?: string;
    inputPreview?: string;
    summaryPreview?: string;
    updatedAtUnixMs?: number;
}
interface AgentMentionWorkspaceIssueItem {
    kind: "workspace-issue";
    href: string;
    workspaceId: string;
    targetId: string;
    topicId?: string;
    name: string;
    title: string;
    creatorName?: string;
    iconUrl?: string;
    status?: string;
    contentPreview?: string;
    updatedAtUnixMs?: number;
}
interface AgentMentionWorkspaceAppItem {
    kind: "workspace-app";
    href: string;
    workspaceId: string;
    targetId: string;
    appId: string;
    name: string;
    description?: string;
    iconUrl?: string;
    /** 应用是否能够提供产物文件(reference),决定 @ 面板行末尾是否展示「查看产物」入口。 */
    referencesListSupported?: boolean;
}
interface AgentMentionAgentTargetItem {
    kind: "agent-target";
    href: string;
    workspaceId: string;
    targetId: string;
    name: string;
    description?: string;
    agentProviderId?: string;
    iconUrl?: string;
    availabilityStatus?: string;
}
interface AgentMentionWorkspaceReferenceItem {
    kind: "workspace-reference";
    href: string;
    workspaceId: string;
    /** URI path id:source=app 时为 appId,source=task 时为 topicId。 */
    targetId: string;
    source: AgentMentionReferenceSource;
    /** 子级 id:app 子分组 / issueId。缺省表示整个 app / topic。 */
    groupId?: string;
    name: string;
    iconUrl?: string;
    /** 展示用文件数(来自 picker 节点 childCount);序列化不再展开文件。 */
    fileCount: number;
}
interface AgentMentionWorkspaceAppFactoryItem {
    kind: "workspace-app-factory";
    href: string;
    workspaceId: string;
    targetId: string;
    jobId: string;
    name: string;
    action?: string;
    contextPath?: string;
}
interface AgentMentionCustomItem {
    kind: "custom";
    /** 注册表里的 kind(= mention:// providerId)。 */
    customKind: string;
    href: string;
    workspaceId: string;
    targetId: string;
    /** Canonical Markdown label, kept separate from the host's chip presentation. */
    sourceLabel: string;
    /** chip 第一行。 */
    name: string;
    /** chip 第二行(通用双行卡)。 */
    summary?: string;
}
type AgentContextMentionItem = AgentMentionFileItem | AgentMentionAgentTargetItem | AgentMentionSessionItem | AgentMentionWorkspaceAppItem | AgentMentionWorkspaceReferenceItem | AgentMentionWorkspaceAppFactoryItem | AgentMentionWorkspaceIssueItem | AgentMentionCustomItem;
interface AgentMentionSuggestionState {
    editor: Editor;
    range: Range;
    query: string;
    text: string;
    command: (item: AgentContextMentionItem) => void;
    clientRect?: (() => DOMRect | null) | null;
}
type AgentFileMentionSuggestionState = AgentMentionSuggestionState;

interface CreateAgentSessionMarkdownLinkInput {
    agentSessionId: string;
    agentTargetId?: string | null;
    label: string;
    workspaceId: string;
    withAtPrefix: boolean;
}
declare function createAgentSessionMarkdownLink(input: CreateAgentSessionMarkdownLinkInput): string;
interface CreateAgentSessionHandoffPromptInput {
    agentSessionId: string;
    agentTargetId?: string | null;
    label: string;
    workspaceId: string;
}
/**
 * Builds the canonical composer draft for handing a complete Agent session to
 * another Agent. The trailing space is the editable caret anchor used by the
 * rich-text composer after the atomic session mention.
 */
declare function createAgentSessionHandoffPrompt(input: CreateAgentSessionHandoffPromptInput): string;

interface AgentCapabilityTokenOption {
    capability: string;
    label: string;
    name: string;
    trigger: string;
}

interface AgentRichTextPromptImage {
    name: string;
    mimeType: "image/png" | "image/jpeg" | "image/webp";
    data: string;
}

type AgentGUIComposerFocusMethod = "keyboard" | "pointer" | "programmatic";
type AgentGUIComposerContentType = "image" | "large_text" | "text";
type AgentGUIQuickPromptType = "saved" | "recommended_template";
interface AgentGUIEngagementContext {
    agentSessionId: string | null;
    agentTargetId: string | null;
    composerReady: boolean;
    conversationState: "existing" | "new";
    provider: string;
}
interface AgentGUIEngagementEventBase extends AgentGUIEngagementContext {
    panelVisitId: string;
}
type AgentGUIEngagementEvent = (AgentGUIEngagementEventBase & {
    type: "panel_exposed";
}) | (AgentGUIEngagementEventBase & {
    type: "composer_focused";
    focusMethod: AgentGUIComposerFocusMethod;
}) | (AgentGUIEngagementEventBase & {
    type: "composer_content_entered";
    contentType: AgentGUIComposerContentType;
    hadPrefill: boolean;
}) | (AgentGUIEngagementEventBase & {
    source: "composer_input";
    type: "quick_prompt_panel_opened";
}) | (AgentGUIEngagementEventBase & {
    promptType: AgentGUIQuickPromptType;
    source: "composer_input";
    type: "quick_prompt_used";
});
interface AgentGUIComposerEngagement {
    contentEntered(input: {
        contentType: AgentGUIComposerContentType;
        hadPrefill: boolean;
    }): void;
    focused(focusMethod: AgentGUIComposerFocusMethod): void;
    quickPromptPanelOpened?(): void;
    quickPromptUsed?(promptType: AgentGUIQuickPromptType): void;
}
type AgentGUIEngagementEventSink = (event: AgentGUIEngagementEvent) => Promise<void> | void;

interface AgentRichTextEditorProps {
    value: string;
    /** Stable owner of the controlled draft, such as a session draft scope. */
    contentScopeKey?: string;
    disabled: boolean;
    placeholder: string;
    removeMentionLabel?: string;
    className?: string;
    testId?: string;
    onChange: (value: string) => void;
    onContentLayoutInvalidated?: () => void;
    onFocus?: (method: AgentGUIComposerFocusMethod) => void;
    onUserContentChange?: (value: string) => void;
    onSubmit: () => void;
    onSubmitGuidance?: () => void;
    availableSkills?: readonly AgentGUIProviderSkillOption[];
    availableCapabilities?: readonly AgentCapabilityTokenOption[];
    submitOnEnter?: boolean;
    enableFileMentionSuggestions?: boolean;
    onKeyDownForPalette?: (event: KeyboardEvent) => boolean;
    onHistoryNavigation?: (direction: "older" | "newer") => boolean;
    onFileMentionSuggestionChange?: (state: AgentFileMentionSuggestionState | null) => void;
    onFileMentionSuggestionKeyDown?: (event: KeyboardEvent) => boolean;
    onLinkClick?: (href: string) => void;
    promptImagesSupported?: boolean;
    onPromptImagesUnsupported?: () => void;
    onPasteImages?: (images: AgentRichTextPastedImage[]) => void;
    onPasteLargeText?: (text: string) => void;
    onPasteFiles?: (files: readonly File[]) => void;
    onDropFiles?: (files: readonly File[]) => void;
    /**
     * Host-owned absolute-path paste resolution. Returning a reference inserts a
     * file/directory mention; returning null falls back to plain text.
     */
    onResolvePastedPath?: (text: string) => Promise<WorkspaceFileReference | null>;
}
type AgentRichTextPastedImage = AgentRichTextPromptImage;

type AgentExternalPromptEntryResolution = {
    disposition: "reference";
    reference: WorkspaceFileReference;
    sourceIndex: number;
} | {
    disposition: "prepare";
    sourceIndex: number;
};
type AgentExternalPromptEntryResolver = (files: readonly File[]) => readonly AgentExternalPromptEntryResolution[];

interface AgentPreparedExternalPromptFileMetadata {
    assetId?: string;
    mimeType?: string;
    name: string;
    sizeBytes?: number;
    uploadStatus?: string;
    uri?: string;
}
type AgentPreparedExternalPromptFile = AgentPreparedExternalPromptFileMetadata & ({
    path: string;
    url?: string;
} | {
    path?: string;
    url: string;
});
type AgentExternalPromptFilePreparationErrorCode = "file_too_large" | "folder_unsupported" | "preparation_failed";
type AgentExternalPromptFilePreparationResult = {
    sourceIndex: number;
    status: "prepared";
    file: AgentPreparedExternalPromptFile;
} | {
    sourceIndex: number;
    status: "error";
    errorCode: AgentExternalPromptFilePreparationErrorCode;
    retryable?: boolean;
};
type AgentExternalPromptFilePreparer = (files: readonly File[]) => Promise<readonly AgentExternalPromptFilePreparationResult[]>;

interface DesktopSize {
    width: number;
    height: number;
    bottomInset?: number;
}

interface AgentGUIComposerDefaults {
    codexSaverMode?: boolean;
    model?: string | null;
    permissionModeId?: string | null;
    reasoningEffort?: string | null;
    speed?: string | null;
}
interface AgentGUIRememberComposerDefaultsInput {
    agentTargetId: string | null;
    provider: AgentGUINodeData["provider"];
    defaults: AgentGUIComposerDefaults | null;
}
declare const rememberComposerDefaultsFields: readonly ["codexSaverMode", "model", "permissionModeId", "reasoningEffort", "speed"];
type AgentGUIComposerDefaultsField = (typeof rememberComposerDefaultsFields)[number];
interface AgentGUIRememberComposerDefaultsResult {
    acknowledgedFields: AgentGUIComposerDefaultsField[];
    supersededFields: AgentGUIComposerDefaultsField[];
}

type AgentGUIComposerAppendRequest = {
    agentSessionId?: string;
    connectorKey: string;
    files?: never;
    prompt?: never;
    sequence: number;
} | {
    agentSessionId?: string;
    connectorKey?: never;
    files: readonly AgentComposerDraftFile[];
    prompt?: string;
    sequence: number;
} | {
    agentSessionId?: string;
    connectorKey?: never;
    files?: never;
    prompt: string;
    sequence: number;
};

interface AgentGUIPrefillPromptRequest {
    agentTargetId?: string | null;
    autoSubmit?: boolean;
    draftPrompt: string;
    model?: string | null;
    modelPlanId?: string | null;
    provider?: AgentGUIProvider;
    sequence: number;
    userProjectPath?: string | null;
}

interface AgentGUIOpenSessionRequest {
    agentSessionId: string;
    sequence: number;
}

type AgentStatusSectionState = "available" | "unavailable" | "error";
type AgentStatusRequestReason = "slash-status" | "agent-info" | "agent-config";
interface AgentStatusQuery {
    /** Exact host-owned execution target identity. AgentGUI treats it as opaque. */
    scopeKey: string;
    agentSessionId?: string | null;
    reason: AgentStatusRequestReason;
    forceRefresh?: boolean;
}
interface AgentStatusValue {
    agentSessionId?: string | null;
    /** Host-projected account or billing label for the active provider mode. */
    accountLabel?: string | null;
    contextWindow?: {
        usedTokens?: number | null;
        totalTokens?: number | null;
    } | null;
    contextState: AgentStatusSectionState;
    quotas: readonly AgentUsageQuota[];
    limitsState: AgentStatusSectionState;
    /** Stable host error code for the limits section. Raw provider text is forbidden. */
    limitsErrorCode?: string | null;
    limitsCapturedAtUnixMs?: number | null;
    limitsStale?: boolean;
}
interface AgentStatusFrame {
    kind: "snapshot" | "refreshed";
    value: AgentStatusValue;
}
interface AgentStatusStreamObserver {
    onFrame(frame: AgentStatusFrame): void;
    onError(error: AgentStatusSourceError): void;
    onComplete(): void;
}
interface AgentStatusSourceError {
    /** Structured host error code. Raw provider errors must not cross this port. */
    code: string;
}
interface AgentStatusSource {
    open(query: AgentStatusQuery, observer: AgentStatusStreamObserver): () => void;
}
type AgentStatusRequestPhase = "idle" | "loading" | "ready" | "error";
interface AgentStatusControllerSnapshot {
    query: AgentStatusQuery | null;
    value: AgentStatusValue | null;
    phase: AgentStatusRequestPhase;
    isRefreshing: boolean;
    errorCode: string | null;
}
interface AgentStatusController {
    getSnapshot(): AgentStatusControllerSnapshot;
    subscribe(listener: () => void): () => void;
    open(query: AgentStatusQuery): void;
    close(): void;
    invalidate(scopeKey?: string): void;
}
interface AgentStatusControllerOptions {
    source: AgentStatusSource;
    now?: () => number;
    requestTimeoutMs?: number;
    retainedSnapshotMs?: number;
    forcedRefreshDebounceMs?: number;
}
interface AgentStatusSelectionKey {
    scopeKey: string;
    agentSessionId?: string | null;
    reasons?: readonly AgentStatusRequestReason[];
}
/** Selects status only for the exact target and caller-visible Session. */
declare function selectAgentStatusControllerSnapshot(snapshot: AgentStatusControllerSnapshot, key: AgentStatusSelectionKey): AgentStatusControllerSnapshot;
/**
 * Creates the shared AgentGUI interaction controller for bounded status reads.
 * The host owns transport, authorization and provider probing. The controller
 * owns only request visibility, a bounded presentation snapshot, timeout and
 * stale-response fencing.
 */
declare function createAgentStatusController(options: AgentStatusControllerOptions): AgentStatusController;

/** Setup section requested by an AgentGUI remediation action. */
type AgentEnvPanelFocus = "detect" | "install" | "repair" | "upgrade" | "auth" | "network" | "registry";
interface OpenAgentEnvPanelInput {
    provider?: string | null;
    focus?: AgentEnvPanelFocus | null;
}

/**
 * Run-failure codes actually emitted by the daemon runtime classifier
 * (packages/agent/daemon/runtime/visible_error.go `visibleFailureCode`). These
 * are the codes the conversation error card really receives — unlike the
 * aspirational `CODEX_*` codes, which the run pipeline never produces.
 *
 * Keep this union aligned with the Go switch in `visibleFailureCode`.
 */
type AgentRunErrorCode = "auth_required" | "account_not_allowed" | "billing_error" | "cli_not_found" | "cli_version_unsupported" | "network_error" | "runtime_unavailable" | "request_timed_out" | "provider_config_timeout" | "provider_stream_disconnected" | "provider_empty_response" | "provider_concurrency_limit" | "provider_unavailable" | "invalid_request" | "model_not_available" | "max_output_tokens" | "insufficient_credits" | "model_not_allowed" | "plugin_unavailable" | "quota_or_rate_limit" | "session_interrupted" | "subscription_required" | "process_exited" | "provider_error" | "unknown";
/**
 * Identifies who can remediate a visible error in the current AgentGUI view.
 * This is presentation-only host context; it does not alter canonical Turns
 * or provider error data.
 */
type AgentVisibleErrorPresentationScope = "local_owner" | "shared_caller";
interface AgentVisibleErrorOverride {
    message: string;
    /** Provider ids for which this product-owned override is valid. */
    providers: readonly string[];
    action?: {
        label: string;
        url: string;
    } | null;
}
/**
 * Product-owned structured errors whose copy may be supplied by a Host.
 * Environment/runtime errors remain canonical AgentGUI policy.
 */
type AgentVisibleErrorOverrideCode = "insufficient_credits";
type AgentVisibleErrorOverrides = Partial<Record<AgentVisibleErrorOverrideCode, AgentVisibleErrorOverride>>;

type AgentGUISessionLaunchMode = "local" | "worktree";

interface AgentSideCapabilities {
    supported: boolean;
    /** Provider can snapshot a source while its Turn is active. */
    activeSourceTurn: boolean;
    ephemeral: boolean;
    hideInheritedTurns: boolean;
    modelBoundaryInjected: boolean;
}
interface AgentSideInteractionAction {
    id: string;
    label: string;
    semantic: string;
}
interface AgentSideInteraction {
    requestId: string;
    turnId: string;
    kind: "approval" | "plan" | "question";
    toolName: string | null;
    input: Record<string, unknown>;
    actions: readonly AgentSideInteractionAction[];
}
interface AgentSideConversationState {
    workspaceId: string;
    sourceAgentSessionId: string;
    sideAgentSessionId: string;
    status: "idle" | "opening" | "running" | "closing" | "expired" | "error";
    activeTurnId: string | null;
    projection: AgentActivityEphemeralConversationProjection;
    pendingInteraction: AgentSideInteraction | null;
    error: string | null;
    sequence: number;
}
interface AgentSideConversationSnapshot {
    workspaceId: string;
    active: AgentSideConversationState | null;
}
interface AgentSideConversationOpenInput {
    workspaceId: string;
    sourceAgentSessionId: string;
    provider?: string | null;
    cwd?: string | null;
}
interface AgentSideConversationSendInput {
    workspaceId: string;
    sideAgentSessionId: string;
    content: readonly AgentPromptContentBlock[];
    displayPrompt?: string;
}
interface AgentSideConversationRuntime {
    resolveCapabilities(input: AgentSideConversationOpenInput): Promise<AgentSideCapabilities>;
    open(input: AgentSideConversationOpenInput): Promise<AgentSideConversationState>;
    send(input: AgentSideConversationSendInput): Promise<void>;
    cancel(input: {
        workspaceId: string;
        sideAgentSessionId: string;
        turnId: string;
    }): Promise<void>;
    respond(input: {
        workspaceId: string;
        sideAgentSessionId: string;
        turnId: string;
        requestId: string;
        action?: string;
        optionId?: string;
        payload?: Record<string, unknown>;
    }): Promise<void>;
    close(input: {
        workspaceId: string;
        sideAgentSessionId: string;
    }): Promise<void>;
    getSnapshot(workspaceId: string): AgentSideConversationSnapshot;
    subscribe(workspaceId: string, listener: () => void): () => void;
    subscribeConnectionState(listener: (state: "connected" | "connecting" | "disconnected" | "disposed") => void): () => void;
    dispose?(): void;
}
declare function AgentSideConversationRuntimeProvider({ children, runtime }: PropsWithChildren<{
    runtime?: AgentSideConversationRuntime | null;
}>): React.JSX.Element;
declare function useOptionalAgentSideConversationRuntime(): AgentSideConversationRuntime | null;
declare function useAgentSideConversationSnapshot(workspaceId: string): AgentSideConversationSnapshot;

interface AgentSideConversationViewState extends AgentSideConversationState {
    conversation: AgentConversationVM | null;
}

interface AgentGUISideConversationPaneProps {
    active: AgentSideConversationViewState;
    availableSkills: readonly AgentGUIProviderSkillOption[];
    composerProps: AgentComposerProps;
    conversationFlowLabels: {
        thinkingLabel: string;
        toolCallsLabel: (count: number) => string;
        processing: string;
        turnSummary: string;
        userMessageLocator: string;
    };
    isVisible: boolean;
    loadingLabel: string;
    workspaceAppIcons: readonly AgentMessageMarkdownWorkspaceAppIcon[];
    onClose(): void | Promise<void>;
    onFocusChange(focused: boolean): void;
    onLinkAction?: (action: WorkspaceLinkAction) => void;
}
type AgentGUISideConversationSurfaceProps = Omit<AgentGUISideConversationPaneProps, "onClose">;
declare function AgentGUISideConversationSurface({ active, availableSkills, composerProps, conversationFlowLabels, isVisible, loadingLabel, workspaceAppIcons, onFocusChange, onLinkAction }: AgentGUISideConversationSurfaceProps): React.JSX.Element;

interface AgentGUISideConversationProjection {
    sideAgentSessionId: string;
    sourceAgentSessionId: string;
    surfaceProps: AgentGUISideConversationSurfaceProps;
    close(): Promise<void>;
}
interface AgentGUISideConversationIdentity {
    sideAgentSessionId: string;
    sourceAgentSessionId: string;
}
interface AgentGUISideConversationPresentation {
    getSnapshot(): AgentGUISideConversationProjection | null;
    getIdentitySnapshot(): AgentGUISideConversationIdentity | null;
    publish(projection: AgentGUISideConversationProjection | null): void;
    subscribe(listener: () => void): () => void;
    subscribeIdentity(listener: () => void): () => void;
}
declare function createAgentGUISideConversationPresentation(): AgentGUISideConversationPresentation;

interface AgentGUINodeIdentity {
    nodeId: string;
    workspaceId: string;
    currentUserId?: string | null;
    title: string;
}
interface AgentGUINodeWorkspace {
    path: string;
    fileReferenceAdapter?: WorkspaceFileReferenceAdapter | null;
    onRequestGitBranches?: AgentComposerGitBranchLoader | null;
    selectProjectDirectory?: () => Promise<{
        path: string;
    } | null>;
    resolveExternalPromptEntries?: AgentComposerProps["resolveExternalPromptEntries"];
    prepareExternalPromptFiles?: AgentComposerProps["prepareExternalPromptFiles"];
    resolvePastedPath?: AgentComposerProps["resolvePastedPath"];
    promptAssetLimit?: number | null;
    projectDirectorySourceAggregator?: ReferenceSourceAggregator | null;
    referenceSourceAggregator?: ReferenceSourceAggregator | null;
    resolveReferenceContentErrorAction?: ReferenceSourcePickerProps["resolveContentErrorAction"];
    resolveReferenceEntryIconUrl?: (entry: WorkspaceFileEntry) => Promise<string | null | undefined>;
    resolveMentionReferenceTarget?: AgentMentionReferenceTargetResolver | null;
    resolveReferenceInitialTarget?: AgentWorkspaceReferenceInitialTargetResolver | null;
    onFileReferencesAdded?: (input: {
        provider: AgentGUIProvider;
        references: readonly WorkspaceFileReference[];
    }) => void | Promise<void>;
    agentSettings: Pick<AgentSettings, "avoidGroupingEdits">;
}
interface AgentGUINodeFrameLayout {
    position: Point;
    width: number;
    height: number;
    desktopSize: DesktopSize;
    isMaximized?: boolean;
    isActive: boolean;
    /** Host-projected presentation visibility. Independent from node focus. */
    isVisible?: boolean;
    embedded?: boolean;
    /**
     * Standalone windows preserve the middle conversation width and collapse
     * the conversation Rail before it can be compressed. Other surfaces retain
     * the default responsive policy.
     */
    conversationRailAutoCollapseMode?: "preserve-middle-content";
}
interface AgentGUINodeRuntimeRequests {
    composerAppend?: AgentGUIComposerAppendRequest | null;
    composerFocusSequence?: number | null;
    workbench?: AgentGuiWorkbenchCommandBridge | null;
    openSession?: AgentGUIOpenSessionRequest | null;
    prefillPrompt?: AgentGUIPrefillPromptRequest | null;
    /** On-demand status capability. Transport and owner resolution stay host-owned. */
    agentStatusController?: AgentStatusController | null;
}
interface AgentGUINodeHostCapabilities {
    /**
     * Complete host-owned catalog for reference provenance filtering. Supplying
     * it explicitly opts the host into the dimensions declared by the catalog.
     * Omit it to keep filtering disabled unless the legacy Agent-only flag is
     * enabled.
     */
    referenceProvenanceFilterCatalog?: ReferenceProvenanceCatalog | null;
    /** Legacy Tutti Agent-only opt-in. Prefer an explicit catalog in new hosts. */
    referenceProvenanceFilterEnabled?: boolean;
    /** Host-owned experimental opt-in for current-Session composer history. */
    sessionInputHistoryEnabled?: boolean;
    /** Host-owned experimental opt-in for Side and transcript selection actions. */
    sideConversationEnabled?: boolean;
    /** Optional presentation-only bridge for rendering Side outside AgentGUI. */
    sideConversationPresentation?: AgentGUISideConversationPresentation | null;
    /** Host-owned opt-in for launching self-owned local Sessions in git worktrees. */
    sessionWorktreeEnabled?: boolean;
    /** Host-owned durable launch preference projection for this workspace. */
    sessionLaunchModesByProjectSectionKey?: Readonly<Record<string, AgentGUISessionLaunchMode>>;
    /** Host-owned experimental opt-in for the Codex saver-mode composer entry. */
    codexSaverModeEntryEnabled?: boolean;
    capabilityMenuState?: AgentComposerCapabilityMenuState;
    /**
     * Keeps owner-supported Browser/Computer capability entries visible while
     * preventing this host from mutating device-owned capability settings.
     */
    capabilityControlsReadOnly?: boolean;
    /**
     * Host-owned product copy and external action for structured run errors.
     * AgentGUI owns the generic card; product domains own product semantics.
     */
    visibleErrorPresentationOverrides?: AgentVisibleErrorOverrides | null;
    /**
     * Presentation-only remediation authority for visible errors. Omission
     * retains local-owner behavior for backwards compatibility.
     */
    visibleErrorPresentationScope?: AgentVisibleErrorPresentationScope;
    agentTargets?: readonly AgentGUIAgentTarget[];
    agentTargetsLoading?: boolean;
    /** Complete presentation-only catalog for resolving Agent mention identity. */
    mentionAgentTargets?: readonly AgentGUIAgentTarget[];
    /** Launch-only targets for active-conversation handoff. */
    handoffAgentTargets?: readonly AgentGUIAgentTarget[];
    handoffAgentTargetsLoading?: boolean;
    /** Hidden by default; hosts may opt into ownership copy for collaborative products. */
    showHandoffTargetOwnershipLabels?: boolean;
    providerRailAllPresentation?: AgentGUIProviderRailAllPresentation | null;
    providerRailMode?: AgentGUIProviderRailMode;
    comingSoonProviders?: readonly AgentGUIProvider[];
    providerReadinessGates?: Partial<Record<AgentGUIProvider, AgentGUIProviderReadinessGate | null>> | null;
    /** Tutti-only presentation opt-in for placing usage refresh in the limits header. */
    accountUsageRefreshInline?: boolean;
    /** Target-level connection for new-conversation and ordinary Composer admission. */
    targetConnectionSource?: AgentGUITargetConnectionSource | null;
    /**
     * Host-owned write readiness keyed by exact pending Interaction identity.
     * When present for the displayed prompt, it takes precedence over target
     * connection and exact-Turn observation-gap presentation.
     */
    interactionReadinessSource?: AgentGUIInteractionReadinessSource | null;
    /** Host-owned, ephemeral projection gap keyed by exact Session and Turn. */
    observationGapSource?: AgentGUIObservationGapSource | null;
    defaultAgentTargetId?: string | null;
    providerAuthAccountLabels?: Partial<Record<string, string>>;
    mentionService?: RichTextMentionService;
    workspaceAppIcons?: readonly AgentMessageMarkdownWorkspaceAppIcon[];
    disabledHomeSuggestions?: readonly AgentGUIHomeSuggestionId[];
}
interface AgentGUINodeHostActions {
    /** Confirms that AgentGUI applied one host-issued composer append request. */
    onComposerAppendHandled?: (sequence: number) => void;
    onLinkAction?: (action: WorkspaceLinkAction) => void;
    onHandoffConversation?: (input: {
        agentTargetId?: string | null;
        draftPrompt: string;
        provider: AgentGUIProvider;
        sourceAgentSessionId: string;
        userProjectPath?: string | null;
    }) => void | Promise<void>;
    onCapabilitySettingsRequest?: (capability: AgentComposerCapabilitySettingsTarget) => void | Promise<void>;
    onAgentProviderLogin?: (provider: AgentGUIProvider) => void;
    onAgentEnvPanelOpen?: (input?: OpenAgentEnvPanelInput) => void;
    /**
     * Notifies the Host when the exact target's config menu opens. Account and
     * Commerce refreshes remain Host-owned and must not enter Agent status.
     */
    onAgentConfigMenuOpen?: (context: AgentGUIAgentConfigMenuContext) => void;
    onOpenConversationWindow?: (agentSessionId: string) => void;
    onClose: () => void;
    onResize: (frame: NodeFrame) => void;
    onUpdateNode: (updater: (current: AgentGUINodeData) => AgentGUINodeData) => void;
    onRememberComposerDefaults?: (input: AgentGUIRememberComposerDefaultsInput) => void | Promise<AgentGUIRememberComposerDefaultsResult>;
    onSessionLaunchModePreferenceChange?: (input: {
        mode: AgentGUISessionLaunchMode;
        projectSectionKey: string;
    }) => void | Promise<void>;
    isMuted?: boolean;
    onMinimize?: () => void;
    onToggleMaximize?: () => void;
    onShowMessage?: (message: string, tone?: "info" | "warning" | "error") => void;
    onEngagementEvent?: AgentGUIEngagementEventSink;
    /**
     * Reports live left-side rail layout width while the conversation rail is
     * being resized. Hosts with external chrome aligned to the rail can consume
     * this instead of observing package DOM/style mutations.
     */
    onConversationRailLayoutChange?: (layout: AgentGUIConversationRailLayout) => void;
}
interface AgentGUIAgentConfigMenuContext {
    agentTargetId: string;
    provider: AgentGUIProvider;
    label: string;
    ownership?: AgentGUIAgentOwnership;
    /** The Host must render interactive account controls as ui-system menu items. */
    presentation: "menu";
}
interface AgentGUIConfigMenuPresentationContext {
    /** Interactive slot content must use ui-system DropdownMenuItem/Sub primitives. */
    presentation: "menu";
}
interface AgentGUINodeRenderSlots {
    /** Host-owned controls appended to the composer footer. */
    composerFooterAccessory?: AgentGUIComposerFooterAccessoryRenderer;
    /**
     * Optional Host-owned information for an exact Agent target. AgentGUI owns
     * tooltip mechanics and invokes this renderer lazily for supported surfaces.
     */
    agentTargetInfo?: AgentGUIAgentTargetInfoRenderer;
    /**
     * Optional Host chrome for the exact target's account/Commerce presentation.
     * Returning null preserves AgentGUI's provider account and quota content.
     * Interactive content must honor the supplied menu presentation contract.
     */
    agentConfigAccount?: (context: AgentGUIAgentConfigMenuContext) => ReactNode;
    /**
     * Optional Host-owned system actions appended to the Agent config menu.
     * Actions must be ui-system DropdownMenuItem/Sub primitives.
     */
    agentConfigSystemActions?: (context: AgentGUIConfigMenuPresentationContext) => ReactNode;
    projectDirectoryPickerHeaderActions?: ReferenceSourcePickerProps["renderHeaderActions"];
    projectSelectOptions?: AgentProjectDropdownOptions;
    referencePickerSidebarActions?: (context: Parameters<NonNullable<ReferenceSourcePickerProps["renderSidebarActions"]>>[0] & {
        purpose: "directory" | "reference";
    }) => ReactNode;
    providerRailEmpty?: AgentGUIAgentsEmptyRenderer;
    sidebarFooter?: (ctx: AgentGUISidebarFooterContext) => ReactNode;
}
interface AgentGUINodeProps {
    identity: AgentGUINodeIdentity;
    workspace: AgentGUINodeWorkspace;
    frame: AgentGUINodeFrameLayout;
    state: AgentGUINodeData;
    runtimeRequests: AgentGUINodeRuntimeRequests;
    hostCapabilities: AgentGUINodeHostCapabilities;
    hostActions: AgentGUINodeHostActions;
    renderSlots: AgentGUINodeRenderSlots;
}

interface WorkspaceReferencePickResult {
    files: readonly WorkspaceFileReference[];
    mentionItems: readonly AgentContextMentionItem[];
}

type AgentGuiI18nLocale = "en" | "zh-CN";

declare const agentGuiI18nResources: {
    readonly en: {
        readonly common: {
            readonly add: "Add";
            readonly cancel: "Cancel";
            readonly clear: "Clear";
            readonly close: "Close";
            readonly confirm: "Confirm";
            readonly copy: "Copy";
            readonly copying: "Copying...";
            readonly copyFailed: "Copy failed";
            readonly create: "Create";
            readonly cut: "Cut";
            readonly delete: "Delete";
            readonly deleting: "Deleting...";
            readonly download: "Download";
            readonly copyImage: "Copy image";
            readonly downloadImage: "Download image";
            readonly expandImage: "Zoom image";
            readonly imageZoomPercent: "Image zoom {{percent}}%";
            readonly error: "Error";
            readonly generateByAi: "Generate by AI";
            readonly generating: "Generating...";
            readonly info: "Info";
            readonly loading: "Loading...";
            readonly maximize: "Maximize";
            readonly minimize: "Minimize";
            readonly minimizeImage: "Minimize image";
            readonly resetImageZoom: "Reset image zoom";
            readonly refresh: "Refresh";
            readonly remove: "Remove";
            readonly removing: "Removing...";
            readonly restore: "Restore";
            readonly zoomInImage: "Zoom in image";
            readonly zoomOutImage: "Zoom out image";
            readonly resetToDefault: "Reset to Default";
            readonly save: "Save";
            readonly saving: "Saving...";
            readonly settings: "Settings";
            readonly warning: "Warning";
            readonly defaultFollowCli: "Default (Follow CLI)";
            readonly defaultModel: "default model";
            readonly followCliDefault: "Follow CLI default";
            readonly unknownError: "Unknown error";
            readonly notAvailable: "N/A";
            readonly paste: "Paste";
            readonly percentUnit: "%";
            readonly pixelUnit: "px";
            readonly minuteUnit: "min";
        };
        readonly workspaceWindowLayout: {
            readonly trigger: "Window layout";
            readonly moveAndResize: "Move & Resize";
            readonly left: "Move to left quarter";
            readonly right: "Move to right quarter";
            readonly top: "Move to top half";
            readonly bottom: "Move to bottom half";
            readonly fullscreen: "Full Screen";
            readonly restore: "Restore";
        };
        readonly sidebar: {
            readonly defaultAgent: "Default Agent";
            readonly persistence: "Persistence";
            readonly settings: "Settings";
            readonly fallbackAgentLabel: "Agent";
            readonly status: {
                readonly working: "Working";
                readonly standby: "Standby";
            };
            readonly terminals_one: "{{count}} terminal";
            readonly terminals_other: "{{count}} terminals";
            readonly agents_one: "{{count}} agent";
            readonly agents_other: "{{count}} agents";
            readonly tasks_one: "{{count}} task";
            readonly tasks_other: "{{count}} tasks";
        };
        readonly appHeader: {
            readonly togglePrimarySidebar: "Toggle Primary Sidebar";
            readonly commandCenter: "Command Center";
            readonly commandCenterHint: "Command Center ({{shortcut}})";
            readonly commandCenterFallbackTitle: "Search";
            readonly enterFullscreen: "Enter Full Screen";
            readonly exitFullscreen: "Exit Full Screen";
            readonly updateAvailableShort: "Update";
            readonly updateAvailableTitle: "Version {{version}} is available";
            readonly updateAvailableDetail: "Download the latest build when you are ready.";
            readonly updateLater: "Later";
            readonly updateDownloadNow: "Download Update";
            readonly updateDownloadingTitle: "Downloading version {{version}} ({{percent}})";
            readonly updateDownloadingShort: "Downloading update";
            readonly updateDownloadProgress: "{{downloaded}} / {{total}}";
            readonly updateMinimize: "Minimize";
            readonly restartToUpdateShort: "Restart";
            readonly restartToUpdateTitle: "Version {{version}} is ready to install";
            readonly updateReadyDetail: "Restart the app to finish installing this update.";
            readonly updateRestartLater: "Later";
            readonly updateInstallNow: "Restart and Install";
        };
        readonly controlCenter: {
            readonly open: "Control Center";
            readonly title: "Control Center";
            readonly sidebar: "Sidebar";
            readonly theme: "Theme";
            readonly agentStandbyBanner: "Agent standby banner";
            readonly on: "On";
            readonly off: "Off";
        };
        readonly debugWindow: {
            readonly title: "IPC Inspector";
            readonly subtitle: "Hidden diagnostics window for renderer-to-main IPC tracing.";
            readonly loading: "Loading IPC records…";
            readonly unavailable: "Debug window bridge is unavailable.";
            readonly searchPlaceholder: "Search channel, payload, result, or error";
            readonly countLabel: "{{count}} records";
            readonly empty: "No IPC records captured yet.";
            readonly noSelection: "Select a record to inspect its details.";
            readonly actions: {
                readonly pin: "Pin";
                readonly unpin: "Unpin";
                readonly clear: "Clear Records";
                readonly export: "Export JSON";
                readonly copySelected: "Copy Selected";
            };
            readonly filters: {
                readonly kindLabel: "Kind";
                readonly kindAll: "All";
                readonly kindInvoke: "Invoke";
                readonly kindSend: "Send";
                readonly statusLabel: "Status";
                readonly statusAll: "All";
                readonly statusOk: "OK";
                readonly statusError: "Error";
                readonly statusSent: "Sent";
            };
            readonly detail: {
                readonly summary: "Summary";
                readonly payload: "Payload";
                readonly result: "Result";
                readonly error: "Error";
                readonly channel: "Channel";
                readonly kind: "Kind";
                readonly status: "Status";
                readonly startedAt: "Started At";
                readonly completedAt: "Completed At";
                readonly duration: "Duration";
                readonly durationValue: "{{duration}} ms";
            };
        };
        readonly commandCenter: {
            readonly title: "Command Center";
            readonly placeholder: "Search rooms and commands…";
            readonly empty: "No results.";
            readonly metaEsc: "Esc";
            readonly sections: {
                readonly commands: "Commands";
            };
            readonly commands: {
                readonly openSettings: "Settings";
                readonly openSettingsHint: "Open Settings";
                readonly showPrimarySidebar: "Show Sidebar";
                readonly hidePrimarySidebar: "Hide Sidebar";
                readonly togglePrimarySidebarHint: "Toggle Primary Sidebar";
            };
        };
        readonly workspaceEmptyState: {
            readonly title: "Create a room to start";
            readonly description: "Each room has its own collaborative canvas and terminals.";
            readonly action: "Create Room";
        };
        readonly appMessage: {
            readonly info: "Info";
            readonly warning: "Warning";
            readonly error: "Error";
        };
        readonly errorBoundary: {
            readonly title: "Something went wrong";
            readonly description: "The renderer hit an unrecoverable error. Your room data is safe.";
            readonly reload: "Reload";
            readonly dismiss: "Dismiss";
        };
        readonly agentRuntime: {
            readonly working: "Working";
            readonly standby: "Standby";
            readonly exited: "Exited";
            readonly failed: "Failed";
            readonly stopped: "Stopped";
            readonly restoring: "Starting";
        };
        readonly persistence: {
            readonly savedWithoutScrollback: "Storage quota reached; saved without terminal history.";
            readonly savedSettingsOnly: "Storage quota reached; saved settings only.";
            readonly unavailable: "Storage is unavailable; changes will not be saved.";
            readonly limitExceeded: "Storage limit exceeded; unable to persist room state.";
            readonly ioFailed: "Persistence I/O failed: {{message}}";
            readonly failed: "Persistence failed: {{message}}";
            readonly recoveryCorruptDb: "Persistence database was corrupted and has been reset.";
            readonly recoveryMigrationFailed: "Persistence migration failed and has been reset.";
        };
        readonly agentHost: {
            readonly workspaceAgentProbeQuotaCredits: "Credits";
            readonly workspaceAgentProbeQuotaCreditsRemaining: "{{amount}} Credits remaining";
            readonly workspaceAgentProbeQuotaDollarRemaining: "${{amount}} remaining";
            readonly workspaceAgentProbeQuotaRemaining: "{{percent}}% remaining";
            readonly backToHome: "Back to Home";
            readonly shellHostWindow: {
                readonly windowControls: "Window controls";
            };
            readonly changeWallpaper: "Change wallpaper";
            readonly wallpaperPanelTitle: "Wallpaper";
            readonly wallpaperOptionDefault: "Default";
            readonly wallpaperOptionOcean: "Ocean";
            readonly wallpaperOptionGalaxy: "Galaxy";
            readonly wallpaperOptionSky: "Sky";
            readonly wallpaperOptionPeaks: "Mountain night";
            readonly wallpaperOptionOrbit: "Earth at night";
            readonly wallpaperOptionSand: "Sand ripples";
            readonly wallpaperOptionDunes: "Starry dunes";
            readonly signOut: "Sign Out";
            readonly loggedOut: "Signed out.";
            readonly sessionExpired: "Your session expired. Please sign in again.";
            readonly authenticating: "Processing…";
            readonly loginTitle: "Sign in to continue";
            readonly loginSectionTitle: "Continue with your account";
            readonly loginDescription: "Choose a provider, complete login in the browser, then return to Tutti.";
            readonly loginBrowserHint: "Choose a provider, complete login in the browser, then return to Tutti.";
            readonly loginOpeningBrowser: "Opening Browser...";
            readonly loginContinueWithGoogle: "Continue With Google";
            readonly loginContinueWithGitHub: "Continue With GitHub";
            readonly loginGitHubHint: "GitHub may directly reuse the browser account you already signed in with.";
            readonly emailLoginTitle: "Or use email verification";
            readonly loginDividerOr: "Or email";
            readonly loginAltMethodsAria: "More sign-in options";
            readonly loginAltTabEmail: "Email code";
            readonly loginAltTabLoginCode: "Access code";
            readonly loginCodeTitle: "Or use an access code";
            readonly loginCodeHint: "Enter a long-lived access code directly to sign in on this device.";
            readonly loginCodePlaceholder: "Paste your access code";
            readonly verifyLoginCode: "Confirm";
            readonly loginCodeCompleted: "Access-code sign-in complete.";
            readonly loginCodeRequired: "Access code is required.";
            readonly emailPlaceholder: "name@example.com";
            readonly emailCodePlaceholder: "6-digit code";
            readonly emailCodeDialogTitle: "Enter the verification code";
            readonly emailCodeDialogLead: "Verification code sent to {{email}}";
            readonly emailCodeDigitAria: "Verification code digit {{index}}";
            readonly emailCodeResendPrefix: "Didn't receive the verification code?";
            readonly emailCodeResendAction: "Resend";
            readonly sendEmailCode: "Send Code";
            readonly sendEmailCodeSending: "Sending...";
            readonly verifyEmailCode: "Verify Code";
            readonly emailCodeSent: "Verification code sent.";
            readonly emailLoginCompleted: "Email login complete.";
            readonly emailRequired: "Email is required.";
            readonly emailCodeRequired: "Verification code is required.";
            readonly desktopAuthBridgeStale: "Desktop auth bridge is out of date. Restart Tutti and try again.";
            readonly desktopActionErrorGeneric: "Something went wrong. Please try again.";
            readonly desktopActionErrorGenericShort: "Something went wrong";
            readonly desktopActionErrorUnavailable: "This feature is unavailable.";
            readonly desktopActionErrorLoginTimedOut: "Login timed out. Return to Tutti and try again.";
            readonly desktopActionErrorDesktopApiUnavailable: "Desktop service is still updating. Restart Tutti and try again.";
            readonly desktopActionErrorPackageDownloadInterrupted: "The agent package download was interrupted. Check your network connection and retry.";
            readonly desktopActionErrorPackageDownloadHTTPStatus: "The package server rejected the download. Retry later or contact support.";
            readonly desktopActionErrorPackageDownloadInvalid: "The downloaded package failed integrity checks. Retry the download.";
            readonly desktopActionErrorPackageDownloadDisk: "Unable to write the package cache. Check disk permissions and free space.";
            readonly productNameCanvas: "Tutti";
            readonly applications: {
                readonly eyebrow: "Agent OS apps";
                readonly title: "Applications";
                readonly description: "Open the core room apps and preview common Agent OS workflows from one place";
                readonly launchHint: "Mock apps can be opened after you enter a room";
                readonly launchMockUnavailable: "Enter a room to open this mock application";
                readonly categoryBasic: "Basic";
                readonly categoryOffice: "Office";
                readonly categoryCreation: "Creation";
                readonly installAction: "Install";
                readonly comingSoonAction: "Coming soon";
                readonly installedAction: "Installed";
                readonly issueTitle: "Tasks";
                readonly issueDescription: "Create, assign, run, and review room tasks with agents";
                readonly vibeDesignTitle: "Vibe design";
                readonly vibeDesignDescription: "Draft product screens, interaction states, and visual directions";
                readonly vibeVideoTitle: "Video creating";
                readonly vibeVideoDescription: "Shape scripts, storyboards, edits, and final video direction";
                readonly imageGenerationTitle: "Image generation";
                readonly imageGenerationDescription: "Create visual concepts, generated assets, and prompt-driven image drafts";
                readonly textEditorTitle: "Document";
                readonly textEditorDescription: "Write and revise room notes, prompts, and lightweight documents";
                readonly pptTitle: "PPT";
                readonly pptDescription: "Create presentation outlines, slide drafts, and review-ready decks";
                readonly sheetTitle: "Sheet";
                readonly sheetDescription: "Track structured data, tables, calculations, and room planning lists";
                readonly calendarTitle: "Calendar";
                readonly calendarDescription: "Plan room milestones, follow-ups, reviews, and shared schedules";
                readonly systemMonitorTitle: "System Monitor";
                readonly systemMonitorDescription: "Inspect runtime health, resource signals, and workspace activity";
                readonly codeEditorTitle: "Code Editor";
                readonly codeEditorDescription: "Open source files, review changes, and prepare implementation notes";
                readonly chatTitle: "Chat";
                readonly chatDescription: "Coordinate room sessions, agent handoffs, and quick decisions";
                readonly mockWindowStatus: "Mock application";
                readonly mockWindowReady: "Ready for future integration";
                readonly mockDesignPreviewTitle: "Design board";
                readonly mockDesignPreviewBody: "Layout references, component states, and review notes will appear here";
                readonly mockVideoPreviewTitle: "Video timeline";
                readonly mockVideoPreviewBody: "Scenes, clips, narration, and export status will appear here";
                readonly mockImageGenerationPreviewTitle: "Image studio";
                readonly mockImageGenerationPreviewBody: "Prompts, generated previews, variations, and export history will appear here";
                readonly mockEditorPreviewTitle: "Draft document";
                readonly mockEditorPreviewBody: "Start writing room notes and agent prompts in this placeholder editor";
                readonly mockPresentationPreviewTitle: "Slide deck";
                readonly mockPresentationPreviewBody: "Slide outlines, narrative beats, and review notes will appear here";
                readonly mockSheetPreviewTitle: "Data sheet";
                readonly mockSheetPreviewBody: "Tables, calculations, filters, and room planning data will appear here";
                readonly mockCalendarPreviewTitle: "Room calendar";
                readonly mockCalendarPreviewBody: "Milestones, meetings, follow-ups, and shared schedule blocks will appear here";
                readonly mockMonitorPreviewTitle: "Runtime signals";
                readonly mockMonitorPreviewBody: "CPU, memory, network, and workspace activity signals will appear here";
                readonly mockCodePreviewTitle: "Source workspace";
                readonly mockCodePreviewBody: "Files, diffs, symbols, and implementation notes will appear here";
                readonly mockChatPreviewTitle: "Room chat";
                readonly mockChatPreviewBody: "Session threads, agent replies, and shared decisions will appear here";
            };
            readonly workspaceTerminalsBadge_one: "{{count}} TERMINAL";
            readonly workspaceTerminalsBadge_other: "{{count}} TERMINALS";
            readonly workspaceCenterSearchAria: "Open room search";
            readonly workspaceCenterSearchTitle: "Search nodes, partitions, and notes in this room";
            readonly agentGui: {
                readonly codexSaverModeLabel: "Codex saver mode";
                readonly codexSaverModeDescription: "Keep the selected main model. Suitable self-contained subtasks use Luna Max at roughly one-tenth the current quota cost of Sol High. Quality and speed vary by task.";
                readonly planModeLabel: "Plan Mode";
                readonly normalModeLabel: "Normal";
                readonly normalModeDescription: "Execute the request directly";
                readonly tuttiModeLabel: "Tutti Mode";
                readonly tuttiModeDescription: "Type what you want done — Tutti plans it, splits the tasks, and assigns each to the right agent and model";
                readonly tuttiModeRemove: "Turn off Tutti mode";
                readonly tuttiBudgetTitle: "Tutti preferences";
                readonly tuttiBudgetEffectLabel: "Effect";
                readonly tuttiBudgetSpeedLabel: "Speed";
                readonly tuttiBudgetPreviewHint: "Actual parallelism depends on task dependencies.";
                readonly tuttiBudgetPreviewCost: "Economical";
                readonly tuttiBudgetPreviewBalance: "Balanced";
                readonly tuttiBudgetPreviewPowerful: "Powerful";
                readonly tuttiBudgetModelPreferenceLabel: "Model strategy";
                readonly tuttiBudgetModelPreferenceCost: "Economical";
                readonly tuttiBudgetModelPreferenceBalance: "Balanced";
                readonly tuttiBudgetModelPreferencePowerful: "Most capable";
                readonly tuttiBudgetParallelismLabel: "Parallel target";
                readonly tuttiBudgetParallelismValue: "Up to {{count}} agents";
                readonly tuttiBudgetParallelismValue_one: "{{count}} agent";
                readonly tuttiBudgetParallelismValue_other: "Up to {{count}} agents";
                readonly tuttiModeUpdateFailed: "Tutti mode couldn't be updated. Try again.";
                readonly tuttiModeUpdateUncertain: "Tutti mode is still being reconciled. Try again after it finishes.";
                readonly tuttiModePlan: {
                    readonly taskReview: "Plan review";
                    readonly cancel: "Cancel plan";
                    readonly reviewHint: "Awaiting review";
                    readonly reviewHintReplan: "Preferences changed";
                    readonly materializingTitle: "Creating tasks";
                    readonly switchToSelfReview: "Switch to self review";
                    readonly switchingToSelfReview: "Switching to self review";
                    readonly selfReviewEnabled: "Self review enabled";
                    readonly selfReviewFailed: "Couldn't enable self review";
                    readonly materializingHint: "Turning the accepted plan into executable tasks";
                    readonly errorTitle: "Workflow unavailable";
                    readonly expand: "Expand workflow";
                    readonly collapse: "Collapse workflow";
                    readonly sendAccept: "Accept";
                    readonly sendRequestChanges: "Request changes";
                    readonly replanFeedback: "Preferences changed from effect {{fromEffect}} / speed {{fromSpeed}} to effect {{toEffect}} / speed {{toSpeed}}. Re-plan the model choices and effect-scaled task verification.";
                    readonly replanFeedbackSuffix: " (Preferences are now effect {{effect}} / speed {{speed}}; re-plan model choices and task verification accordingly.)";
                    readonly tasks: "Tasks";
                    readonly priority: "Priority";
                    readonly priorityHigh: "High";
                    readonly priorityMedium: "Medium";
                    readonly priorityLow: "Low";
                    readonly agentTarget: "Agent";
                    readonly model: "Model";
                    readonly permissionMode: "Permission mode";
                    readonly reasoningEffort: "Reasoning effort";
                    readonly parallelizable: "Parallel";
                    readonly autoAccept: "Auto-accept";
                    readonly assignmentOptionsLoading: "Loading options...";
                    readonly notSpecified: "Not specified";
                    readonly loadFailed: "Tutti mode plans could not be loaded";
                    readonly retry: "Try again";
                    readonly issueOpen: "Open Issue";
                    readonly issueListView: "List";
                    readonly issueBoardView: "Board";
                    readonly issueSummary: "{{done}}/{{total}} done · {{running}} running";
                    readonly issueDependencies: "Depends";
                    readonly issueAccept: "Accept";
                    readonly issueRework: "Rework";
                    readonly issueAcceptPrompt: "Review and accept {{reference}} in the current Tutti Mode plan. Verify its result and evidence, then continue the plan from the current execution state.";
                    readonly issueReworkPrompt: "Rework {{reference}} in the current Tutti Mode plan. Inspect the current execution and failure or acceptance evidence, preserve the original task history, then create a replacement task or a new follow-up execution as appropriate and continue scheduling.";
                    readonly issueStageParallel: "Stage {{index}} · parallel ×{{count}}";
                    readonly issueStageSequential: "Stage {{index}} · sequential";
                    readonly issueStatusNotStarted: "Todo";
                    readonly issueStatusRunning: "Running";
                    readonly issueStatusPendingAcceptance: "In review";
                    readonly issueStatusCompleted: "Done";
                    readonly issueStatusFailed: "Failed";
                    readonly issueStatusCanceled: "Canceled";
                    readonly issueStripRunning: "{{count}} subtasks running";
                    readonly issueStripPending: "{{count}} awaiting acceptance";
                    readonly issueStripFailed: "{{count}} failed";
                    readonly issueStripDone: "{{done}}/{{total}} done";
                    readonly issueCreateFailed: "The approved plan could not create its Issue: {{message}}. Ask the Agent to revise the plan.";
                };
                readonly planModeDescription: "Plan first, then implement or break down into an Issue";
                readonly planModeOnLabel: "On";
                readonly planModeOffLabel: "Off";
                readonly planUnavailable: "Plan unavailable";
                readonly addContentResourcePanel: "Resource panel";
                readonly addContentConnectors: "Connectors";
                readonly addContentConnectorConnected: "Authorized";
                readonly addContentConnectorSelected: "Selected";
                readonly addContentConnectorConnect: "Connect";
                readonly addContentConnectorAuthorize: "Authorize";
                readonly addContentConnectorEmpty: "No connectors available";
                readonly addContentConnectorMore: "View more connectors";
                readonly conversationFilterCodex: "Codex";
                readonly conversationFilterClaudeCode: "Claude Code";
                readonly conversationFilterOpenCode: "OpenCode";
                readonly conversationFilterTutti: "Tutti";
                readonly conversationFilterCursor: "Cursor";
                readonly conversationFilterNexight: "Nexight";
                readonly conversationFilterHermes: "Hermes Agent";
                readonly conversationFilterOpenClaw: "OpenClaw";
                readonly manageAgents: "Agent Sidebar Display Settings";
                readonly manageAgentsTitle: "Agent Sidebar Display Settings";
                readonly manageAgentsDescription: "Drag to reorder or move agents between the available and disabled groups. Press and hold an agent to edit.";
                readonly manageAgentsAvailable: "Available Agents";
                readonly manageAgentsDisabled: "Disabled Agents";
                readonly manageAgentsNoAvailable: "Add an agent from the disabled list below.";
                readonly manageAgentsNoDisabled: "Drag agents you don’t want to show in the sidebar here.";
                readonly manageAgentsKeepOneAvailable: "Keep at least one agent available.";
                readonly manageAgentsRunningBlocked: "{{agent}} is running and can't be disabled. Wait for it to finish and try again.";
                readonly removeAgentFromSidebar: "Remove {{agent}} from sidebar";
                readonly addAgentToSidebar: "Add {{agent}} to sidebar";
                readonly dragAgentToReorder: "Drag {{agent}} to reorder";
                readonly directoryPicker: {
                    readonly confirm: "Select folder";
                    readonly emptySearch: "No matching folders";
                    readonly searchPlaceholder: "Search folders";
                    readonly title: "Select project folder";
                };
                readonly referencePicker: {
                    readonly clearFilter: "Clear filter";
                    readonly confirm: "Use references";
                    readonly emptyDirectory: "This folder is empty.";
                    readonly emptyPreview: "Select a file to see details";
                    readonly emptySearch: "No matching files or folders.";
                    readonly fileTypeAll: "All types";
                    readonly fileTypeDocument: "Documents";
                    readonly fileTypeImage: "Images";
                    readonly fileTypeOther: "Other";
                    readonly fileTypeSeparator: ", ";
                    readonly fileTypeVideo: "Videos";
                    readonly fileTypeWebpage: "Web pages";
                    readonly loadMore: "Load more";
                    readonly loadMoreGroups: "Load more";
                    readonly loading: "Loading...";
                    readonly loadError: "Couldn't load this content. Try again later.";
                    readonly previewBinary: "This file looks like binary content.";
                    readonly previewDecodeFailed: "This file couldn't be decoded as UTF-8 text.";
                    readonly previewError: "Couldn't load a preview.";
                    readonly previewFileTooLarge: "This file is larger than {{maxSize}}.";
                    readonly previewFolder: "Folder preview is not available.";
                    readonly previewHierarchy: "Location";
                    readonly previewLoading: "Loading preview...";
                    readonly previewModified: "Produced at";
                    readonly previewSize: "Size";
                    readonly previewSource: "Source";
                    readonly previewTextTooLarge: "This text file is larger than {{maxSize}}.";
                    readonly previewTooLarge: "This file is too large to preview.";
                    readonly previewUnavailable: "Preview is not available in this workspace.";
                    readonly previewUnsupported: "This file type can't be previewed here.";
                    readonly searchPlaceholder: "Search files and folders";
                    readonly selectGroupHint: "Select a folder on the left";
                    readonly selectedCount: "{{count}} selected";
                    readonly sourceColumn: "Category";
                    readonly title: "Pick workspace references";
                };
                readonly visibleErrorStartFailed: "{{provider}} failed to start";
                readonly visibleErrorRequestFailed: "{{provider}} request failed";
                readonly visibleErrorAuthRequired: "{{provider}} needs authentication or configuration";
                readonly visibleErrorAuthRequiredLocalAgentHint: "Please sign in to local {{provider}}, then retry.";
                readonly visibleErrorSharedCallerHint: "Contact the person who shared this Agent, then try again.";
                readonly visibleErrorRequestTimedOut: "{{provider}} request timed out";
                readonly visibleErrorRuntimeUnavailable: "{{provider}} could not start because the runtime is unavailable";
                readonly visibleErrorQuotaOrRateLimit: "{{provider}} request failed because a quota or rate limit was reached";
                readonly visibleErrorSubscriptionRequired: "{{provider}} requires an active subscription or an eligible plan for this request";
                readonly visibleErrorModelNotAllowed: "{{provider}} cannot use the selected model with the current account";
                readonly visibleErrorPluginUnavailable: "{{provider}} could not use an optional integration that is currently unavailable";
                readonly visibleErrorSessionInterrupted: "{{provider}} stopped unexpectedly before it finished. Try again.";
                readonly visibleErrorDetails: "View details";
                readonly visibleErrorRawDetails: "Raw error";
                readonly visibleErrorCliNotFound: "{{provider}} CLI wasn't found, so it couldn't run. Set it up to continue.";
                readonly visibleErrorVersionUnsupported: "{{provider}}'s installed version is unsupported for this request. Upgrade to continue.";
                readonly visibleErrorNetwork: "{{provider}} couldn't reach the network to complete this request.";
                readonly visibleErrorConfigTimeout: "{{provider}} couldn't apply session settings before the request timed out. Try again in a moment.";
                readonly visibleErrorStreamDisconnected: "{{provider}}'s response was interrupted before it completed. Try again in a moment.";
                readonly visibleErrorEmptyResponse: "{{provider}} returned no response. Check the provider settings or try again.";
                readonly visibleErrorConcurrencyLimit: "{{provider}} is handling too many requests right now. Try again after another task finishes.";
                readonly visibleErrorInsufficientCreditsUnknown: "{{provider}} has insufficient credits or account balance to continue";
                readonly visibleErrorActionInstall: "Connect";
                readonly visibleErrorActionUpgrade: "Upgrade";
                readonly visibleErrorActionRelogin: "Sign in";
                readonly visibleErrorActionCheckNetwork: "Check network";
                readonly visibleErrorActionDetect: "Open setup";
                readonly systemNoticeTransportRetry: "Agent connection interrupted. Reconnecting...";
                readonly systemNoticeTransportFallback: "Agent switched to HTTPS transport";
                readonly systemNoticePlanImplementationPendingConfirmation: "Plan implementation is awaiting confirmation";
                readonly systemNoticePlanImplementationCompleted: "Plan implementation started";
                readonly systemNoticeWarning: "Agent warning";
                readonly systemNoticeDefault: "Agent notice";
                readonly contextCompactionInProgress: "Compacting context";
                readonly contextCompactionCompleted: "Context compacted.";
                readonly contextCompactionInterrupted: "Context compaction interrupted.";
                readonly contextHandoffRequired: "This conversation has reached its context limit";
                readonly contextHandoffRequiredDetail: "This conversation can't continue. Start a new conversation and @mention this conversation to hand off its context.";
                readonly sharedDeviceLabel: "shared device";
                readonly agentSharingRevoked: "{{owner}} stopped sharing this agent";
                readonly runtimeConnecting: "Connecting to {{device}}…";
                readonly runtimeReconnectingAttempt: "Reconnecting to {{device}} · Retry {{attempt}}…";
                readonly runtimeUnavailable: "Connection to {{device}} was lost. The system will retry automatically.";
                readonly runtimeUnavailableActive: "Connection to {{device}} was lost. Sending and stopping are temporarily unavailable; the task may still be running on the device.";
                readonly runtimeSynchronizingProgress: "Synchronizing the latest task progress…";
                readonly interactionSynchronizing: "The shared Agent state is synchronizing. Try again in a moment.";
                readonly interactionOwnerOffline: "The shared Agent owner is offline";
                readonly interactionBindingRevoked: "The shared Agent is no longer available";
                readonly slashCommandPalette: "Slash commands";
                readonly skillPickerPalette: "Skills";
                readonly slashPaletteCommandsGroup: "Commands";
                readonly slashPaletteCapabilitiesGroup: "Capabilities";
                readonly slashPaletteCapabilitiesLoading: "Loading capabilities…";
                readonly slashPaletteSkillsGroup: "Skills";
                readonly slashPalettePluginsGroup: "Plugins";
                readonly slashPaletteConnectorsGroup: "Connectors";
                readonly slashPaletteConnectorConnected: "Authorized";
                readonly slashPaletteConnectorNotConnected: "Connect";
                readonly slashPaletteConnectorUnsupported: "Unsupported";
                readonly slashPaletteMcpGroup: "MCP";
                readonly moreSessionActions: string;
                readonly copiedToClipboard: string;
                readonly copyFailed: string;
                readonly copyAsMarkdown: string;
                readonly copyAsReference: string;
                readonly markSessionUnread: string;
                readonly retryConversations: string;
                readonly conversationCopyImage: string;
                readonly conversationCopyMentionPrefix: string;
                readonly conversationCopyFile: string;
                readonly conversationCopyPreviousMessages: string;
                readonly conversationCopyImagesOmitted: string;
                readonly conversationCopyInProgress: string;
                readonly sessionActionUnavailable: string;
                readonly collaborationModeConsult: "Consult";
                readonly collaborationModeFork: "Fork";
                readonly collaborationModeDelegate: "Delegate";
                readonly collaborationModeHandoff: "Handoff";
                readonly collaborationTriggerUser: "Manual";
                readonly collaborationTriggerAgent: "Agent";
                readonly collaborationTriggerPolicy: "Policy";
                readonly collaborationStatusRunning: "Running";
                readonly collaborationStatusCompleted: "Completed";
                readonly collaborationStatusFailed: "Failed";
                readonly collaborationStatusCanceled: "Canceled";
                readonly collaborationPlanLabel: "Plan: {{name}}";
                readonly collaborationUsageTokens: "Tokens: {{input}} in · {{output}} out";
                readonly collaborationFailureReason: "Failure: {{reason}}";
                readonly collaborationResultShow: "Show result";
                readonly collaborationResultHide: "Hide result";
                readonly collaborationAdopt: "Adopt";
                readonly collaborationReject: "Reject";
                readonly collaborationAdopted: "Adopted";
                readonly collaborationRejected: "Not adopted";
                readonly collaborationAdoptionFailed: "Failed to record the adoption decision.";
                readonly composerModelPlanBadge: "Plan: {{name}}";
                readonly composerModelSearchPlaceholder: "Search models";
                readonly composerModelSearchEmpty: "No matching models";
                readonly composerModelFavoritesGroup: "Favorites";
                readonly composerModelRecentsGroup: "Recently used";
                readonly composerModelSwitchNextTurnHint: "Applies from the next request";
                readonly composerModelFavoriteAdd: "Add to favorites";
                readonly composerModelFavoriteRemove: "Remove from favorites";
                readonly consultEntryLabel: "Consult model";
                readonly consultDialogTitle: "Consult a model";
                readonly consultPlanLabel: "Plan";
                readonly consultModelLabel: "Model";
                readonly consultQuestionLabel: "Question";
                readonly consultQuestionPlaceholder: "Ask another model for advice...";
                readonly consultIncludeContextLabel: "Attach the latest assistant reply as context";
                readonly consultSubmit: "Consult";
                readonly consultSubmitting: "Consulting...";
                readonly mentionFilterCollab: "Collaboration";
                readonly mentionGroupCollabSessions: "Collaboration sessions";
                readonly mentionEmptyCollabSessions: "No collaboration sessions yet";
                readonly mentionCollaboratorFallback: "Collaborator";
                readonly slashStatusTitle: "Status";
                readonly slashStatusSession: "Session";
                readonly slashStatusBaseUrl: "Base URL";
                readonly slashStatusContext: "Context";
                readonly slashStatusLimits: "Usage Limits";
                readonly slashStatusAccount: "Account";
                readonly slashStatusProviderAccount: "{{provider}} Account";
                readonly slashStatusClose: "Close";
                readonly slashStatusFiveHourLimit: "5h limit";
                readonly slashStatusWeeklyLimit: "7d limit";
                readonly slashStatusLimitPercentLeft: "{{percent}}% left";
                readonly slashStatusLimitReset: "resets {{reset}}";
                readonly slashStatusContextValue: "{{percentLeft}}% left ({{usedTokens}} used / {{totalTokens}})";
                readonly slashStatusContextUnavailable: "Context usage unavailable";
                readonly slashStatusLimitsUnavailable: "Account quota is currently unavailable";
                readonly slashStatusEmptyValue: "—";
                readonly slashStatusUsageJustUpdated: "Updated just now";
                readonly slashStatusUsageMinutesAgo: "Updated {{count}}m ago";
                readonly slashStatusUsageHoursAgo: "Updated {{count}}h ago";
                readonly slashStatusUsageUpdating: "Updating…";
                readonly slashStatusUsageRefreshFailed: "Refresh failed";
                readonly slashStatusUsageRefreshAria: "Refresh usage";
                readonly slashStatusUsageAuthRequired: "Configure an API key or sign in to continue";
                readonly slashStatusUsageSessionExpired: "Your sign-in expired. Sign in again";
                readonly slashStatusUsageSubscriptionRequired: "A Coding Plan or subscription is required";
                readonly slashStatusUsageQuotaExhausted: "Account balance or usage quota is exhausted";
                readonly slashStatusUsageParseFailed: "Unable to parse account status";
                readonly slashStatusUsageError: "Unable to load account status";
                readonly usageChipLabel: "Context {{percent}}%";
                readonly usageTooltipLabel: "Context usage";
                readonly usagePopoverTitle: "Context Usage";
                readonly usageContextWindowLabel: "Context window";
                readonly usageTokensLabel: "Tokens";
                readonly usageLimitsLabel: "Limits";
                readonly usageCompactAction: "Compact";
                readonly loadingOptions: string;
                readonly composerOptionsLoadFailed: string;
                readonly composerOptionsRetry: string;
                readonly composerOptionsRetryTooltip: string;
                readonly sendFailed: string;
                readonly returnToConversation: string;
                readonly continueAnswering: string;
                readonly inheritedUnavailable: string;
                readonly modelConsumptionSpeedLabel: string;
                readonly modelConsumptionMultiplierSuffix: string;
                readonly projectLocked: string;
                readonly projectMissingDescription: string;
                readonly sessionLaunchModeLabel: string;
                readonly sessionLaunchModeLocal: string;
                readonly sessionLaunchModeWorktree: string;
                readonly sideCommandDescription: "Open a temporary conversation from the current live context";
                readonly sidePanelTitle: "Side conversation";
                readonly sideEmptyTitle: "Side conversation";
                readonly sideEmptyDescription: "Side conversations are temporary and disappear when you close the app.";
                readonly sideInputPlaceholder: "Ask a related question";
                readonly sideResize: "Resize Side conversation";
                readonly sideCollapse: "Collapse Side conversation";
                readonly selectionAddToConversation: "Add to conversation";
                readonly selectionAskInSide: "Ask in Side chat";
                readonly selectionReferenceCountOne: "1 selected file snippet";
                readonly selectionReferenceCountMany: "{{count}} selected file snippets";
                readonly sideInteractionTitle: "Side needs your response";
                readonly sideContentUnsupported: "This attachment type is not supported in a Side conversation yet.";
                readonly sideOperationFailed: "The Side conversation could not complete that operation. Close it and try again.";
                readonly homeSuggestionsClose: "Close suggestions";
                readonly homeSuggestions: {
                    readonly about: {
                        readonly title: "Meet Tutti";
                        readonly prompt: "Tell me what Tutti can help me do";
                    };
                    readonly cloneGithubRepository: {
                        readonly title: "Clone GitHub repository";
                        readonly prompt: "Help me clone the GitHub repository { repository URL }, then tell me its local directory";
                    };
                    readonly breakdown: {
                        readonly title: "Task breakdown";
                        readonly taskCenterLabel: "Task management";
                        readonly prompt: "Use {{taskCenterMention}} to help me break down the task, topic { enter here }";
                    };
                    readonly review: {
                        readonly title: "Quality review";
                        readonly prompt: "Have { @agent } review the output quality of { @agent session }";
                    };
                    readonly interaction: {
                        readonly title: "Agent interaction";
                        readonly prompt: "Have { @agent } and { @agent } work together to { do something }, topic { enter here }";
                    };
                    readonly import: {
                        readonly title: "Import session";
                    };
                };
                readonly imageDownloaded: "Image downloaded";
                readonly imageLoadFailed: "Image failed to load";
                readonly imageTemporarilyUnavailable: "Image temporarily unavailable";
                readonly retryImage: "Retry";
                readonly initialPlaceholder: "Type @ to reference sessions, files, tasks, and apps";
                readonly followupPlaceholder: "Request follow-up changes from {{provider}}";
                readonly installRequiredPlaceholder: "Connect {{provider}} to send messages";
                readonly installRequiredAction: "Connect";
                readonly providerGateCheckingTitle: "Checking your agent";
                readonly providerGateCheckingDescription: "One moment while we check whether {{provider}} is ready.";
                readonly providerGateCheckingAgentsDescription: "One moment while we check whether agents are ready.";
                readonly providerGateInstallTitle: "Connect {{provider}} first";
                readonly providerGateInstallDescription: "{{provider}} needs to be connected before you can start a new chat here.";
                readonly providerGateInstallAction: "Connect";
                readonly providerGateLoginTitle: "Log in to {{provider}}";
                readonly providerGateLoginDescription: "Log in with your account to start chatting with {{provider}}.";
                readonly providerGateLoginAction: "Log in";
                readonly providerGateModelPlanAction: "Use your own model";
                readonly providerGateComingSoonTitle: "{{provider}} is coming soon";
                readonly providerGateComingSoonDescription: "{{provider}} is not available yet. We will enable this agent when it is ready.";
                readonly providerGateComingSoonAction: "coming soon";
                readonly providerGateUnavailableTitle: "{{provider}} is not ready yet";
                readonly providerGateUnavailableDescription: "We could not confirm that {{provider}} is ready. Try checking again.";
                readonly providerGateRetryAction: "Check again";
                readonly providerGateRuntimeSelectionTitle: "Choose which {{provider}} to use";
                readonly providerGateRuntimeSelectionDescription: "Multiple {{provider}} installations were found — pick one to continue.";
                readonly providerGateRuntimeSelectionAction: "Choose";
                readonly providerGatePendingInstall: "Connecting…";
                readonly providerGatePendingLogin: "Opening sign in…";
                readonly providerGatePendingRefresh: "Checking…";
                readonly targetSetupTitle: "Set up {{provider}}";
                readonly targetSetupDescription: "Already have {{provider}} installed? Tutti can use it — or set it up for you.";
                readonly targetSetupAuthRequired: "Runtime is installed and responds over ACP, but authentication is required.";
                readonly targetSetupReady: "Runtime detected. You can check it again or sign in again.";
                readonly targetSetupOpen: "Open setup";
                readonly targetSetupRemaining: "Complete the remaining steps to use {{provider}}.";
                readonly targetSetupComplete: "{{provider}} is ready.";
                readonly targetSetupLoggedInAccount: "Signed-in account";
                readonly targetSetupStage: {
                    readonly detect: "Detect runtime";
                    readonly install: "Install runtime";
                    readonly login: "Sign in";
                };
                readonly targetSetupChecking: "Checking local and Tutti-managed runtimes…";
                readonly targetSetupInstall: "Install runtime";
                readonly targetSetupReinstall: "Reinstall runtime";
                readonly targetSetupStarting: "Starting installation…";
                readonly targetSetupAuthMethod: "Sign-in method";
                readonly targetSetupAuthenticate: "Continue to sign in";
                readonly targetSetupReauthenticate: "Sign in again";
                readonly targetSetupAuthStarting: "Opening sign in…";
                readonly targetSetupAuthFailed: "Authentication did not complete";
                readonly targetSetupNoAuthMethods: "No supported sign-in method was reported. Check the runtime again.";
                readonly targetSetupTerminalAuthHint: "This sign-in method must be completed in a terminal. Run the command below, finish the sign-in flow, then come back and check again.";
                readonly targetSetupCopyCommand: "Copy command";
                readonly targetSetupCommandCopied: "Copied";
                readonly targetSetupTerminalLoginStart: "Start sign in";
                readonly targetSetupTerminalLoginWaiting: "A terminal has been opened in the workspace. Finish signing in there; this page checks the status automatically.";
                readonly targetSetupTerminalLoginCancel: "Cancel";
                readonly targetSetupTerminalLoginTimedOut: "Timed out waiting for sign in to finish. Try again.";
                readonly targetSetupTerminalLoginUnavailable: "A terminal could not be opened in this window. Copy the command and run it in your own terminal.";
                readonly targetSetupRetry: "Check again";
                readonly targetSetupFailed: "Runtime setup failed";
                readonly targetSetupPhase: {
                    readonly preparing: "Preparing installation…";
                    readonly installing: "Installing pinned runtime…";
                    readonly verifying: "Verifying runtime version…";
                    readonly probing: "Checking ACP compatibility…";
                    readonly activating: "Activating managed runtime…";
                    readonly authenticating: "Waiting for authentication…";
                    readonly complete: "Installation complete";
                };
                readonly collaboratorSessionReadOnlyPlaceholder: "This session belongs to another user and cannot be replied to directly";
                readonly send: "Send";
                readonly modelLabel: "Model";
                readonly modelSelectionLabel: "Model selection";
                readonly defaultModel: "Default model";
                readonly reasoningLabel: "Reasoning";
                readonly reasoningDegreeLabel: "Reasoning level";
                readonly reasoningOptionDefault: "Default";
                readonly reasoningOptionMinimal: "Minimal";
                readonly reasoningOptionLow: "Low";
                readonly reasoningOptionMedium: "Medium";
                readonly reasoningOptionHigh: "High";
                readonly reasoningOptionXHigh: "X-High";
                readonly reasoningOptionMax: "Max";
                readonly reasoningOptionUltra: "Ultra";
                readonly speedLabel: "Speed";
                readonly speedSelectionLabel: "Speed";
                readonly speedOptionStandard: "Standard";
                readonly speedOptionStandardDescription: "Standard speed";
                readonly speedOptionFast: "Fast";
                readonly speedOptionFastDescription: "1.5x speed, increased usage";
                readonly permissionModeReadOnly: "Ask for approval";
                readonly permissionModeAuto: "Approve for me";
                readonly permissionModeFullAccess: "Full access";
                readonly permissionModeChangeUnavailableDuringTurn: "Permissions can’t be changed while a conversation is running";
                readonly fullAccessWarning: {
                    readonly title: "Enable full access?";
                    readonly description: "Full access lets Codex act on your computer without asking for approval.";
                    readonly filesTitle: "Files and folders";
                    readonly filesDescription: "Read, create, modify, or delete files anywhere on this computer.";
                    readonly commandsTitle: "Terminal commands";
                    readonly commandsDescription: "Run commands and change system settings.";
                    readonly internetTitle: "Internet access";
                    readonly internetDescription: "Access websites and send data over the internet.";
                    readonly riskDescription: "Recent Codex releases, especially when using GPT-5.6 models, may go beyond your intent and accidentally delete or overwrite files. Only continue if you understand and accept this risk.";
                    readonly learnMore: "Learn more";
                    readonly cancel: "Cancel";
                    readonly confirm: "Enable full access";
                };
                readonly fullAccessRestoredWarning: {
                    readonly title: "Full access is on";
                    readonly description: "Codex can run commands, use the internet, and create, modify, upload, or delete files anywhere on this computer without asking. This can cause data loss and expose you to prompt-injection attacks.";
                    readonly dontShowAgain: "Don't show again";
                    readonly dismissLabel: "Dismiss full access warning";
                };
                readonly permissionSemantics: {
                    readonly "ask-before-write": {
                        readonly label: "Ask for approval";
                        readonly description: "Always ask to edit external files and use the internet";
                    };
                    readonly "accept-edits": {
                        readonly label: "Accept edits";
                        readonly description: "Allows file edits, but still asks before higher-risk actions";
                    };
                    readonly "locked-down": {
                        readonly label: "Don't ask";
                        readonly description: "Won't prompt. Unapproved actions are rejected";
                    };
                    readonly auto: {
                        readonly label: "Approve for me";
                        readonly description: "Only ask for actions detected as potentially unsafe";
                    };
                    readonly "full-access": {
                        readonly label: "Full access";
                        readonly description: "Unrestricted access to the internet and any file on your computer";
                    };
                    readonly unconfigurable: {
                        readonly label: "Fixed mode";
                        readonly description: "This provider does not support changing permission mode here";
                    };
                };
                readonly permissionModes: {
                    readonly codex: {
                        readonly "read-only": {
                            readonly label: "Ask for approval";
                            readonly description: "Always ask to edit external files and use the internet";
                        };
                        readonly auto: {
                            readonly label: "Approve for me";
                            readonly description: "Only ask for actions detected as potentially unsafe";
                        };
                        readonly "full-access": {
                            readonly label: "Full access";
                            readonly description: "Unrestricted access to the internet and any file on your computer";
                        };
                    };
                    readonly cursor: {
                        readonly "read-only": {
                            readonly label: "Read-only";
                            readonly description: "Cursor plans and reads only. Proposes changes without making them.";
                        };
                        readonly agent: {
                            readonly label: "Ask for approval";
                            readonly description: "Full tool access. Cursor asks before running commands or other risky actions.";
                        };
                        readonly "full-access": {
                            readonly label: "Full access";
                            readonly description: "Runs commands without asking, unless explicitly denied by your Cursor permission rules.";
                        };
                    };
                    readonly opencode: {
                        readonly "read-only": {
                            readonly label: "Read-only";
                            readonly description: "Reads and searches the local project, but denies edits, commands, network access, and other approval-gated actions.";
                        };
                        readonly ask: {
                            readonly label: "Ask";
                            readonly description: "Reads and searches directly, then asks before edits, commands, network access, and other gated actions.";
                        };
                        readonly "full-access": {
                            readonly label: "Full access";
                            readonly description: "Automatically allows gated actions without changing OpenCode's separate Plan mode restrictions.";
                        };
                    };
                    readonly nexight: {
                        readonly "read-only": {
                            readonly label: "Ask for approval";
                            readonly description: "Always ask to edit external files and use the internet";
                        };
                        readonly auto: {
                            readonly label: "Approve for me";
                            readonly description: "Only ask for actions detected as potentially unsafe";
                        };
                        readonly "full-access": {
                            readonly label: "Full access";
                            readonly description: "Unrestricted access to the internet and any file on your computer";
                        };
                    };
                    readonly "claude-code": {
                        readonly default: {
                            readonly label: "Default";
                            readonly description: "Starts conservative. Asks before edits or higher-risk actions.";
                        };
                        readonly acceptEdits: {
                            readonly label: "Accept edits";
                            readonly description: "Allows direct file edits. Still asks before higher-risk actions.";
                        };
                        readonly dontAsk: {
                            readonly label: "Don't ask";
                            readonly description: "Won't prompt for approval. Actions not already allowed are rejected.";
                        };
                        readonly bypassPermissions: {
                            readonly label: "Bypass permissions";
                            readonly description: "Minimizes permission checks. Best for trusted tasks that need uninterrupted execution.";
                        };
                    };
                    readonly hermes: {
                        readonly yolo: {
                            readonly label: "Fixed mode";
                            readonly description: "This provider doesn't support changing permission mode here.";
                        };
                    };
                };
                readonly modelContextWindowSuffix: "context window";
                readonly modelTooltipVersionLabel: "Version";
                readonly modelDescriptions: {
                    readonly frontierComplexCoding: "Frontier model for complex coding, research, and real-world work";
                    readonly everydayCoding: "Strong model for everyday coding";
                    readonly smallFastCostEfficient: "Small, fast, and cost-efficient model for simpler coding tasks";
                    readonly codingOptimized: "Coding-optimized model";
                    readonly ultraFastCoding: "Ultra-fast coding model";
                    readonly professionalLongRunning: "Optimized for professional work and long-running agents";
                };
                readonly permissionLabel: "Run permissions";
                readonly queuedLabel: "Queued";
                readonly queuePausedByUserLabel: "The queue is paused because you interrupted the current response.";
                readonly sendQueuedPromptNext: "Send next";
                readonly editQueuedPrompt: "Edit";
                readonly deleteQueuedPrompt: "Delete";
                readonly queuedPromptMoreActions: "More queued prompt actions";
                readonly stop: "Stop";
                readonly stopping: "Stopping...";
                readonly planCardTitle: "Plan";
                readonly planCardCopy: "Copy plan";
                readonly copyCode: "Copy code";
                readonly mermaidLoading: "Rendering Mermaid diagram";
                readonly mermaidRenderFailed: "Unable to render Mermaid diagram";
                readonly mermaidExpand: "Expand Mermaid diagram";
                readonly mermaidViewer: "Mermaid diagram viewer";
                readonly mermaidPanHint: "Hold Space and drag to pan";
                readonly mermaidZoomIn: "Zoom in";
                readonly mermaidZoomOut: "Zoom out";
                readonly mermaidResetZoom: "Reset view";
                readonly mermaidZoomPercent: "Diagram zoom {{percent}}%";
                readonly mermaidCloseViewer: "Close diagram viewer";
                readonly planCardExpand: "Expand plan";
                readonly planCardCollapse: "Collapse plan";
                readonly planImplementationLead: "Implement this plan?";
                readonly planImplementationConfirm: "Yes, implement this plan";
                readonly planImplementationFeedbackPlaceholder: "No — tell the agent how to adjust the approach";
                readonly planImplementationSend: "Send";
                readonly planImplementationSkip: "Stay in Plan Mode";
                readonly noRunningResponse: "No running response to stop.";
                readonly composerTextMenu: "Composer text actions";
                readonly pastedTextFilesHeader: "Referenced pasted text files:";
                readonly pastedTextFileLine: '- pasted text file "{{preview}}": {{path}}. Read this file before continuing.';
                readonly pastedTextAttachmentTitle: "Pasted text";
                readonly pastedTextAttachmentFailed: "Pasted text couldn't be saved";
                readonly pastedTextRestoreToComposer: "Show in text field";
                readonly copyMessage: "Copy message";
                readonly selectedTextFragment: "1 selected text fragment";
                readonly selectedTextFragments: "{{count}} selected text fragments";
                readonly forkThroughTurn: "Fork through this turn";
                readonly forkThroughTurnPending: "Forking through this turn";
                readonly continuedFromTask: "Continued from task";
                readonly sourceConversationNotFound: "Original conversation not found";
                readonly copyImage: "Copy image";
                readonly editRetryEditMessage: "Edit message";
                readonly editRetryCancel: "Cancel";
                readonly editRetrySubmit: "Save and retry";
                readonly editRetryProcessing: "Updating conversation history and retrying…";
                readonly editRetryNeedsAction: "Conversation history was updated, but the edited message still needs recovery";
                readonly editRetryReconcile: "Reconcile";
                readonly editRetryRetryReplacement: "Retry message";
                readonly messageCopied: "Copied";
                readonly promptTipsPrefix: "Tips: ";
                readonly reviewPicker: {
                    readonly title: "Code review";
                    readonly targetLabel: "What to review";
                    readonly searchPlaceholder: "Search";
                    readonly noResults: "No matches";
                    readonly uncommitted: "Uncommitted changes";
                    readonly baseBranch: "Compare against a branch";
                    readonly commit: "A specific commit";
                    readonly custom: "Custom instructions";
                    readonly branchLabel: "Base branch";
                    readonly branchPlaceholder: "Select a branch";
                    readonly branchLoading: "Loading branches…";
                    readonly branchEmpty: "No branches found";
                    readonly commitPlaceholder: "Commit SHA";
                    readonly customPlaceholder: "Describe what to review";
                    readonly submit: "Start review";
                    readonly cancel: "Cancel";
                };
                readonly promptTips: {
                    readonly setWorkspace: {
                        readonly label: "Set the workspace";
                        readonly prompt: "Let the Agent know where to read files, run commands, and understand code.";
                    };
                    readonly useIssue: {
                        readonly label: "Use Tasks well";
                        readonly prompt: "Put requirements, constraints, and acceptance criteria in a Task so the Agent can work toward a clear target.";
                    };
                    readonly mapCurrentState: {
                        readonly label: "Map the current state";
                        readonly prompt: "When the next step is unclear, ask the Agent to summarize status, risks, and what to do next.";
                    };
                    readonly continueRecentSession: {
                        readonly label: "Continue recent work";
                        readonly prompt: "When resuming, have the Agent recap recent progress, unfinished work, and blockers first.";
                    };
                    readonly referenceOtherAgents: {
                        readonly label: "Reference other Agent conversations";
                        readonly prompt: "Make context handoffs more complete and reduce lost details.";
                    };
                    readonly controlPermissions: {
                        readonly label: "Control permissions";
                        readonly prompt: "Use Ask for approval when you want caution, then switch to higher access once file changes are expected.";
                    };
                };
                readonly empty: "What can {{provider}} help you with?";
                readonly conversations: "Sessions";
                readonly newConversation: "New session";
                readonly agentConfig: "Check & Settings";
                readonly agentSettingsMenu: "Settings";
                readonly agentEnvSetup: "Environment Check";
                readonly noConversations: "No sessions yet";
                readonly emptyProjectConversations: "No chats yet";
                readonly agentsEmpty: "No agents are available";
                readonly conversationFilterAll: "All";
                readonly providerSwitchLabel: "Switch provider";
                readonly sharedAgentOwnerSeparator: "'s ";
                readonly handoffConversation: "Handoff";
                readonly handoffConversationTooltip: "Hand off to another agent";
                readonly handoffConversationMenu: "Choose an agent for handoff";
                readonly handoffTargetDeviceSource: "From {{device}}";
                readonly handoffTargetSelf: "My Agent";
                readonly handoffTargetShared: "Shared Agent";
                readonly startConversation: "Start session";
                readonly selectConversation: "Select a session";
                readonly loadingConversations: "Loading sessions...";
                readonly conversationsLoadFailed: "Could not load sessions";
                readonly loadingConversation: "Loading session...";
                readonly scrollToBottom: "Scroll to bottom";
                readonly searchNoConversations: "No related sessions";
                readonly searchFailed: "Could not search sessions";
                readonly retrySearch: "Retry search";
                readonly activityPriority: "Priority";
                readonly activityNothingNeedsAttention: "Nothing needs attention";
                readonly activityToday: "Today";
                readonly activityYesterday: "Yesterday";
                readonly activityConversationSource: "Conversation";
                readonly activityStatusFailed: "Failed";
                readonly activityStatusRecentlyActive: "Recently active";
                readonly activityStatusUnread: "Unread result";
                readonly activityStatusWaiting: "Waiting for you";
                readonly activityStatusWorking: "Working";
                readonly viewActivity: "View activity";
                readonly viewActivityNeedsAttention: "View activity, attention needed";
                readonly turnOffActivityView: "Turn off activity view";
                readonly conversationUnavailable: "Session unavailable.";
                readonly contextPickerBrowseHint: "Search workspace files based on your input";
                readonly contextPickerBrowseFileHint: "No opened or Agent-generated files yet. Type a file name to search your computer.";
                readonly contextPickerBrowseAgentHint: "Type to search agents";
                readonly contextPickerBrowseAppHint: "Type to search apps";
                readonly contextPickerBrowseSessionHint: "Type to search agent sessions that I started";
                readonly contextPickerBrowseCollabHint: "Type to search teammate and agent sessions";
                readonly contextPickerBrowseIssueHint: "Type to search tasks in the current room";
                readonly workspaceAppFactoryMentionFallback: "Create app";
                readonly contextPickerExpandMore: "Show {{count}} more";
                readonly contextPickerLoadMoreLoading: "Loading…";
                readonly contextPickerLoadMoreRetry: "Load failed. Retry";
                readonly contextPickerCategoryFileDescription: "Search Files and folders";
                readonly contextPickerCategorySessionDescription: "Find agent sessions that I started";
                readonly contextPickerCategoryCollabDescription: "Browse sessions between teammates and agents";
                readonly contextPickerCategoryTaskDescription: "Find tasks in the current room";
                readonly searchPlaceholder: "Search sessions";
                readonly sectionPinned: "Pinned";
                readonly sectionConversations: "Chats";
                readonly sectionToday: "Today";
                readonly sectionYesterday: "Yesterday";
                readonly sectionEarlier: "Earlier";
                readonly projectSectionEdit: "New session";
                readonly projectSectionMoreActions: "Project actions";
                readonly projectSectionViewFiles: "Open folder";
                readonly pinProject: "Pin project";
                readonly unpinProject: "Unpin project";
                readonly pinnedProjectAccessibleName: "Pinned project: {{project}}";
                readonly projectRailCreateProject: "New project";
                readonly projectRailLinkExistingProject: "Link existing project folder";
                readonly removeProject: "Remove";
                readonly removeProjectConfirmDescription: "This will remove “{{project}}” and all its sessions from this list. Local files are not deleted. Continue?";
                readonly removeProjectConfirmTitle: "Remove project?";
                readonly batchDeleteProjectSessions: "Batch delete sessions";
                readonly batchDeleteProjectSessionsTitle: "Delete project sessions?";
                readonly batchDeleteProjectSessionsBody: "This will delete {{count}} sessions in “{{project}}”. Deleted sessions cannot be recovered.";
                readonly batchDeleteProjectSessionsConfirm: "Delete sessions";
                readonly conversationsSectionMoreActions: "Conversation actions";
                readonly batchDeleteConversations: "Batch delete conversations";
                readonly batchDeleteConversationsTitle: "Delete conversations?";
                readonly batchDeleteConversationsBody: "This will delete {{count}} conversations. Deleted conversations cannot be recovered.";
                readonly batchDeleteConversationsConfirm: "Delete conversations";
                readonly runtimeSessionOnly: "Only runtime sessions appear here.";
                readonly approvalRequired: "{{provider}} requests your authorization.";
                readonly fileChangeApprovalRequired: "{{provider}} requests your authorization to edit files.";
                readonly approvalUnavailable: "No choices are available.";
                readonly approvalOptions: {
                    readonly allowOnce: "Yes, proceed";
                    readonly allowForSession: "Yes, for this session";
                    readonly allowAlways: "Yes, and don't ask again";
                    readonly allowAlwaysForCommandPrefix: "Yes, and don't ask again for commands that start with `{{command}}`";
                    readonly allowAlwaysForCommandPrefixLead: "Yes, and don't ask again for commands that start with";
                    readonly allowAlwaysForScope: "Yes, and don't ask again for {{scope}}";
                    readonly alwaysAllowScope: "Always allow {{scope}}";
                    readonly bypassPermissions: "Yes, and bypass permissions";
                    readonly autoMode: 'Yes, and use "auto" mode';
                    readonly acceptEdits: "Yes, and auto-accept edits";
                    readonly manualApproval: "Yes, and manually approve edits";
                    readonly rejectOnce: "No, don't run";
                    readonly rejectAlways: "No, and don't ask again";
                    readonly rejectWithFollowUp: "No, then send new instructions";
                };
                readonly authRequired: "Authentication required";
                readonly authLogin: "Sign in";
                readonly activatingSession: "Connecting session...";
                readonly cancellingSession: "Cancelling...";
                readonly retryActivation: "Retry";
                readonly continueInNewConversation: "New session";
                readonly goalLabel: "Goal";
                readonly goalTitleActive: "Active goal";
                readonly goalTitlePaused: "Paused goal";
                readonly goalTitleBlocked: "Blocked goal";
                readonly goalTitleUsageLimited: "Usage-limited goal";
                readonly goalTitleBudgetLimited: "Budget-limited goal";
                readonly goalTitleComplete: "Completed goal";
                readonly goalBudgetUsage: "{{used}}/{{budget}} tokens";
                readonly goalClearHint: "Type /goal clear to clear";
                readonly goalEditAction: "Edit goal";
                readonly goalPauseAction: "Pause goal";
                readonly goalResumeAction: "Resume goal";
                readonly goalClearAction: "Delete goal";
                readonly goalRemoved: "Goal removed";
                readonly processing: "Planning next moves";
                readonly turnProcessedSeconds: "Processed for {{seconds}}s";
                readonly turnProcessedMinutes: "Processed for {{minutes}}m";
                readonly turnProcessedMinutesSeconds: "Processed for {{minutes}}m {{seconds}}s";
                readonly turnPeerDeviceOfflinePendingSync: "Other device offline · Progress pending sync";
                readonly turnPeerDeviceProgressSynchronizing: "Synchronizing progress from other device…";
                readonly turnTotalSeconds: "Total {{seconds}}s";
                readonly turnTotalMinutes: "Total {{minutes}}m";
                readonly turnTotalMinutesSeconds: "Total {{minutes}}m {{seconds}}s";
                readonly expandTurnWork: "Expand task details";
                readonly collapseTurnWork: "Collapse task details";
                readonly agentTargetRequired: "Select an available agent target before starting a session.";
                readonly sessionActivationFailed: "The agent session could not be started.";
                readonly goalControlFailed: "The goal change could not be applied.";
                readonly sessionNoLongerAvailable: "The previous agent session is no longer available.";
                readonly promptImagesUnsupported: "This agent does not support image input with the current model.";
                readonly tuttiModeCheckpointWakeTaskSettled: "A task finished — review needed";
                readonly tuttiModeCheckpointWakeTaskFailed: "A task failed — review needed";
                readonly tuttiModeCheckpointWakeTaskCanceled: "A task was canceled — review needed";
                readonly tuttiModeCheckpointWakeGoalReview: "Final goal review needed";
                readonly tuttiModeCheckpointWakeInitialSchedule: "Ready to schedule the next tasks";
                readonly tuttiModeCheckpointWakeDefault: "Execution checkpoint needs your review";
                readonly tuttiModeCheckpointWakeIssue: "Issue {{issue}}";
                readonly tuttiModeCheckpointWakeExpand: "Show full prompt";
                readonly tuttiModeCheckpointWakeCollapse: "Hide full prompt";
                readonly tuttiModePlanIssueLinkCreated: "Issue created from this plan";
                readonly turnSummary: "Changed files";
                readonly userMessageLocator: "User messages";
                readonly turnSummaryFilesChanged: "{{count}} files changed";
                readonly turnSummaryModified: "{{count}} modified";
                readonly turnSummaryCreated: "{{count}} new";
                readonly turnSummaryModifiedTag: "Modified";
                readonly turnSummaryCreatedTag: "New";
                readonly turnSummaryViaTool: "via {{tool}}";
                readonly turnSummaryBefore: "Before";
                readonly turnSummaryAfter: "After";
                readonly codeBlockEmptyContent: "(empty)";
                readonly turnSummaryOpenFile: "Open";
                readonly turnSummaryUndo: "Undo";
                readonly turnSummaryReapply: "Reapply";
                readonly turnSummaryCheckingGit: "Checking Git repository...";
                readonly turnSummaryGitRequired: "This directory is not a Git repository";
                readonly turnSummaryPatchUnavailable: "No reversible patch data is available for this change";
                readonly turnSummaryInvalidPatch: "The recorded patch is invalid and cannot be safely applied";
                readonly turnSummaryPatchDoesNotApply: "The file changed after this edit and cannot be safely restored";
                readonly turnSummaryUndoFailed: "Failed to undo changes";
                readonly turnSummaryReapplyFailed: "Failed to reapply changes";
                readonly turnSummaryShowMoreFiles: "Show {{count}} more file";
                readonly turnSummaryShowFewerFiles: "Show fewer files";
                readonly planLead: "Exit planning and start implementing. How should permissions work?";
                readonly planModes: {
                    readonly acceptEdits: {
                        readonly label: "Accept edits";
                        readonly description: "Auto-approve file edits";
                    };
                    readonly askFirst: {
                        readonly label: "Ask for approval";
                        readonly description: "Prompt before each tool";
                    };
                    readonly allowAll: {
                        readonly label: "Allow all";
                        readonly description: "Do not prompt for tools";
                    };
                    readonly auto: {
                        readonly label: "Auto";
                        readonly description: "Let the agent choose when to ask";
                    };
                };
                readonly stayInPlan: "Keep planning";
                readonly sendFeedback: "Send feedback and keep planning";
                readonly feedbackPlaceholder: "Give feedback to refine the plan...";
                readonly previousQuestion: "Back";
                readonly nextQuestion: "Next";
                readonly submitAnswers: "Submit answers";
                readonly answerPlaceholder: "Add details for the agent...";
                readonly waitingForAnswer: "Waiting for your answer...";
                readonly shortcutEnter: "Enter";
                readonly shortcutCmdEnter: "Cmd + Enter";
                readonly shortcutCtrEnter: "Ctr + Enter";
                readonly openConversationWindow: "Open session in new window";
                readonly showMoreConversations: "Show more";
                readonly showLessConversations: "Show less";
                readonly deleteSession: "Delete session";
                readonly pinSession: "Pin session";
                readonly renameSession: "Rename session";
                readonly renameSessionTitle: "Rename conversation";
                readonly renameSessionDescription: "Keep it short and easy to recognize.";
                readonly renameSessionPlaceholder: "Conversation title";
                readonly renameSessionSave: "Save";
                readonly unpinSession: "Unpin session";
                readonly deleteSessionTitle: "Delete session?";
                readonly deleteSessionBody: "This session cannot be recovered after deletion. It will no longer appear in the session list, session timeline, room timeline, or room status.";
                readonly deleteSessionConfirm: "Delete session";
                readonly conversationRailResizeAria: "Resize session list";
                readonly collapseConversationRail: "Hide sidebar";
                readonly expandConversationRail: "Show sidebar";
                readonly relativeTimeJustNow: "just now";
                readonly relativeTimeMinutes: "{{count}} min";
                readonly relativeTimeHours: "{{count}} h";
                readonly relativeTimeDays: "{{count}} d";
                readonly relativeTimeMonths: "{{count}} mo";
                readonly relativeTimeYears: "{{count}} y";
                readonly slashCommandCompactLabel: "compact";
                readonly slashCommandContextLabel: "context";
                readonly slashCommandFastLabel: "fast";
                readonly slashCommandGoalLabel: "goal";
                readonly slashCommandInitLabel: "init";
                readonly slashCommandPlanLabel: "plan";
                readonly slashCommandReviewLabel: "review";
                readonly slashCommandStatusLabel: "status";
                readonly slashCommandUsageLabel: "usage";
                readonly slashCommandCompactDescription: "Compact the conversation context.";
                readonly slashCommandContextDescription: "Show the current context snapshot.";
                readonly slashCommandFastDescription: "Toggle fast response mode.";
                readonly slashCommandGoalDescription: "Set, inspect, or clear the current goal.";
                readonly slashCommandInitDescription: "Initialize repository guidance files.";
                readonly slashCommandPlanDescription: "Toggle plan mode.";
                readonly slashCommandReviewDescription: "Run a code review.";
                readonly slashCommandStatusDescription: "Show session status and context usage.";
                readonly slashCommandUsageDescription: "Show context and quota usage.";
                readonly browserUseCapabilityLabel: "Browser";
                readonly browserUseCapabilityDescription: "Let the agent use a browser.";
                readonly browserUseCapabilityDescriptionAutoConnect: "Current mode: reuse your signed-in Chrome.";
                readonly browserUseCapabilityDescriptionIsolated: "Current mode: use an isolated browser.";
                readonly browserUseCapabilitySettingsLabel: "Browser settings";
                readonly browserUseCapabilitySettingsDescription: "Configure the browser the agent can use.";
                readonly capabilityInlineSettingsLabel: "Settings";
                readonly computerUseCapabilityLabel: "Computer";
                readonly computerUseCapabilityDescription: "Let the agent control the macOS desktop.";
                readonly computerUseCapabilitySetupRequiredDescription: "Not installed. Press Enter to open setup.";
                readonly computerUseCapabilityAuthorizationRequiredDescription: "Authorization required. Press Enter to open setup.";
                readonly computerUseCapabilityAuthorizationUnknownDescription: "Authorization status unknown. Press Enter to open setup.";
                readonly computerUseCapabilitySettingsLabel: "Computer use setup";
                readonly computerUseCapabilitySettingsDescription: "Install, remove, or grant computer access.";
                readonly fileMentionPalette: "Files";
                readonly fileMentionLoading: "Searching...";
                readonly fileMentionEmpty: "Search workspace files based on your input";
                readonly fileMentionError: "Unable to search Files.";
                readonly fileMentionTabHint: "Tab switch category | ←→ enter/leave folder | ↑↓ switch selection";
                readonly fileDropHint: "Drop files to add them to the session";
                readonly composerFileFolderUnsupported: "Folders cannot be attached here";
                readonly composerFileTooLarge: "File is too large";
                readonly composerFilePreparationFailed: "File preparation failed";
                readonly composerFileStillPreparing: "This attachment is still being prepared. Open it after preparation finishes.";
                readonly composerFileOpenFailed: "This attachment failed to prepare. Remove it and add the file again.";
                readonly composerFileOpenUnavailable: "This attachment has no openable path yet. Remove it and add the file again.";
                readonly mentionPalette: "Reference or Invoke";
                readonly addReference: "Add reference";
                readonly addContent: "Add files and more";
                readonly quickPrompts: {
                    readonly add: "New prompt";
                    readonly conflict: "This prompt changed in another window. Refresh it and review your draft before saving again.";
                    readonly contentLabel: "Prompt";
                    readonly contentPlaceholder: "Write the reusable prompt text";
                    readonly contentTooLarge: "Prompt text must be 32 KiB or less";
                    readonly createTitle: "New quick prompt";
                    readonly createFromTemplate: "Recommended templates";
                    readonly delete: "Delete";
                    readonly deleteConfirm: "Delete prompt";
                    readonly deleteDescription: 'Delete "{{title}}"? This cannot be undone.';
                    readonly deleteTitle: "Delete quick prompt?";
                    readonly deleting: "Deleting…";
                    readonly dragCancel: 'Sorting canceled. "{{title}}" returned to position {{position}} of {{total}}.';
                    readonly dragDrop: '"{{title}}" was placed at position {{position}} of {{total}}.';
                    readonly dragHandle: 'Reorder "{{title}}"';
                    readonly dragInstructions: "Press Space or Enter to pick up, use arrow keys to move, then press Space or Enter to drop. Press Escape to cancel.";
                    readonly dragMove: '"{{title}}" is moving to position {{position}} of {{total}}.';
                    readonly dragStart: 'Picked up "{{title}}", position {{position}} of {{total}}.';
                    readonly edit: "Edit";
                    readonly editTitle: "Edit quick prompt";
                    readonly empty: "No quick prompts yet";
                    readonly finishSorting: "Done";
                    readonly insertionError: "Could not insert into the Composer. Try again from the quick prompt list.";
                    readonly loadError: "Quick prompts could not be loaded";
                    readonly loading: "Loading quick prompts…";
                    readonly moreActions: "More prompt actions";
                    readonly mutationError: "The prompt could not be saved. Try again.";
                    readonly noResults: "No matching quick prompts";
                    readonly required: "Title and prompt text are required";
                    readonly reorderConflict: "The prompt order changed in another window. Refresh and drag again.";
                    readonly reorderDisabledMinimum: "At least two quick prompts are required to adjust their order";
                    readonly reorderDisabledPending: "Wait for the current quick prompt change to finish";
                    readonly reorderDisabledSearch: "Clear the search to adjust prompt order";
                    readonly reorderDisabledUnsupported: "This host does not support prompt reordering";
                    readonly reorderError: "The prompt order could not be saved. Try dragging again.";
                    readonly retry: "Try again";
                    readonly recommendedTemplates: {
                        readonly summaryCommonPrompts: {
                            readonly title: "Summarize common prompts";
                            readonly description: "Find important insights and repeated work patterns from conversation history";
                            readonly content: "Please scan and read all available conversation history and memory.\n\n1. What important insight have you discovered that I may not be aware of, and that could significantly change my decisions and work?\n2. What work do I repeat? Identify the prompts I use most often, and explain why they matter and when to use them.\n\nClearly state the accessible scope and distinguish facts, inferences, and unconfirmed items. Do not present assumptions as facts.";
                        };
                        readonly understandContext: {
                            readonly title: "Understand the situation";
                            readonly description: "Summarize context, constraints, risks, and next steps";
                            readonly content: "First summarize the current context, confirmed facts, constraints, risks, and open questions. Separate facts from assumptions, then recommend the smallest useful next step.";
                        };
                        readonly createActionPlan: {
                            readonly title: "Create an action plan";
                            readonly description: "Break a goal into prioritized, verifiable steps";
                            readonly content: "Break this goal into prioritized, verifiable steps. Identify dependencies, risks, and acceptance criteria for each step, then recommend the best place to begin.";
                        };
                        readonly reviewAndImprove: {
                            readonly title: "Review and improve";
                            readonly description: "Find gaps, risks, and practical improvements";
                            readonly content: "Review the following work. Identify what is good, what is missing, the important risks, and practical improvements. Prioritize the recommendations by impact and effort.";
                        };
                        readonly draftClearUpdate: {
                            readonly title: "Draft a clear update";
                            readonly description: "Write a concise explanation for the intended audience";
                            readonly content: "Draft a concise update for the intended audience. State the key message first, include only the necessary context, make the requested decision or next action explicit, and use clear language.";
                        };
                    };
                    readonly recommendedTemplatesDescription: "Choose one to prefill the editor. Saving adds it as a quick prompt and inserts it into the Composer.";
                    readonly recommendedTemplatesTitle: "Recommended templates";
                    readonly returnToPrompts: "My prompts";
                    readonly save: "Save";
                    readonly saving: "Saving…";
                    readonly searchPlaceholder: "Search quick prompts";
                    readonly startSorting: "Reorder";
                    readonly title: "Quick prompts";
                    readonly titleLabel: "Title";
                    readonly titlePlaceholder: "Give this prompt a short name";
                    readonly titleTooLong: "Title must be 80 characters or less";
                    readonly trigger: "Prompts";
                    readonly triggerTooltip: "Choose a quick prompt";
                    readonly useTemplate: "Use template";
                };
                readonly referenceWorkspaceFiles: "Reference workspace files";
                readonly fileMentionEnterFolder: "Enter folder";
                readonly fileMentionSwitchCategory: "Switch category";
                readonly fileMentionNavigateHierarchy: "Enter/leave folder";
                readonly fileMentionSwitchSelection: "Switch selection";
                readonly mentionFilterFile: "Files";
                readonly mentionFilterApp: "Apps";
                readonly mentionFilterAgent: "Agents";
                readonly provenanceFilterAllAgents: "All agents";
                readonly provenanceFilterAllMembers: "All members";
                readonly provenanceFilterAllSources: "All sources";
                readonly provenanceFilterAgents: "Agents";
                readonly provenanceFilterFilteredSources: "Filtered sources";
                readonly provenanceFilterMembers: "Members";
                readonly mentionFilterSession: "Sessions";
                readonly mentionFilterIssue: "Tasks";
                readonly mentionKindAgent: "Agent";
                readonly mentionKindApp: "App";
                readonly mentionKindAppFactory: "App Factory";
                readonly mentionKindFile: "File";
                readonly mentionKindIssue: "Task";
                readonly mentionKindReference: "Reference";
                readonly mentionKindSession: "Session";
                readonly mentionGroupFiles: "Files";
                readonly mentionGroupOpenedFiles: "Files I opened";
                readonly mentionGroupAgentGeneratedFiles: "Recent files generated by Agent";
                readonly mentionGroupApps: "Apps";
                readonly mentionGroupAgents: "Agents";
                readonly mentionGroupMySessions: "My sessions";
                readonly mentionGroupIssues: "Tasks";
                readonly mentionEmptyMySessions: "No sessions yet";
                readonly mentionEmptyApps: "No apps yet";
                readonly mentionEmptyAgents: "No agents available";
                readonly mentionEmptyIssues: "No tasks yet";
                readonly mentionEmptyDockFiles: "No open files in the dock yet. Type to search workspace files.";
                readonly mentionEmptyAgentGeneratedFiles: "No files generated by Agent yet";
                readonly mentionFolderBack: "Back";
                readonly mentionFolderChildCount: "Contains {{count}} items";
                readonly mentionAgentTargetAvailable: "Available";
                readonly mentionAgentTargetUnavailable: "Unavailable";
                readonly mentionNoMatchingFiles: "No matching files";
                readonly mentionOpenReferences: "View output";
                readonly issueRunPrompt: {
                    readonly currentWorkingDirectoryLabel: "Current working directory";
                    readonly executionRequirementsLabel: "Execution requirements";
                    readonly intro: "You are handling a task.";
                    readonly issueContentLabel: "Task content";
                    readonly issueTitleLabel: "Task title";
                    readonly missingContent: "(No additional content)";
                    readonly noReferences: "- (No references)";
                    readonly referencesLabel: "References";
                    readonly requirementNoOtherOutputDir: "3. Do not write final deliverables to any other directory.";
                    readonly requirementStayInWorkspace: "1. Work under {{workspaceRoot}}; do not switch to unrelated directories.";
                    readonly requirementSummaryOutput: "2. Unless the user specifies another location, write at least docs/tutti/task_summary_{{issueId}}.md with the result, changes, and conclusion.";
                    readonly taskContentLabel: "Task content";
                    readonly taskTitleLabel: "Task title";
                };
                readonly syncPending: "Saved locally, syncing to cloud";
                readonly syncSynced: "Synced to cloud";
                readonly syncFailed: "Cloud sync failed";
            };
            readonly workspaceInsights: {
                readonly runtimeTitle: "Runtime";
                readonly live: "LIVE";
                readonly treeTitle: "Tree";
                readonly treeLead: "Runtime-visible room structure.";
                readonly root: "root:";
                readonly sandbox: "sandbox:";
                readonly sessions: "sessions:";
                readonly provider: "provider:";
            };
            readonly workspaceFileManager: {
                readonly breadcrumbsAria: "Breadcrumb";
                readonly breadcrumbRoot: "Home";
                readonly scrollBreadcrumbsLeft: "Scroll breadcrumbs left";
                readonly scrollBreadcrumbsRight: "Scroll breadcrumbs right";
                readonly previewPaneResizeAria: "Resize preview pane";
                readonly name: "Name";
                readonly modified: "Modified";
                readonly size: "Size";
                readonly empty: "This folder is empty";
                readonly open: "Open";
                readonly view: "View";
                readonly openInBrowser: "Open in browser";
                readonly newFile: "New file";
                readonly newFolder: "New folder";
                readonly upload: "Upload";
                readonly uploadHere: "Upload here";
                readonly downloadFile: "Download file";
                readonly downloadArchive: "Download archive";
                readonly delete: "Delete";
                readonly deleting: "Deleting…";
                readonly back: "Back";
                readonly forward: "Forward";
                readonly refresh: "Refresh";
                readonly retry: "Retry";
                readonly refreshed: "Files refreshed.";
                readonly uploaded: "Uploaded {{count}} item(s).";
                readonly uploadNoSelection: "No local files selected.";
                readonly uploadFilteredSymlinks: "Uploaded available items; symbolic links were filtered.";
                readonly uploadOnlySymlinks: "Upload canceled because the selected items were symbolic links.";
                readonly uploadFilteredIgnored: "Uploaded after filtering ignored files.";
                readonly uploadOnlyIgnored: "Upload canceled because filtering left no uploadable files.";
                readonly uploadFilterTitle: "Detected .gitignore";
                readonly uploadFilterBody: "Ignored files and common dependency, build, and cache folders will be filtered by default. Symbolic links are always filtered.";
                readonly uploadFilterAdvanced: "Advanced settings";
                readonly uploadFilterIncludeIgnored: "Upload files ignored by .gitignore";
                readonly uploadFilterIncludeIgnoredHint: "This may include dependencies, build output, and cache files, increasing upload size and workspace storage usage.";
                readonly uploadFilterSubmit: "Start upload";
                readonly uploadConflictTitle: "Upload conflicts detected";
                readonly uploadConflictBody: "Continuing will overwrite same-name files. Same-name folders will be merged, files with the same relative path will be overwritten, and other existing files will be kept.";
                readonly uploadConflictMore: "+ {{count}} more";
                readonly uploadConflictSubmit: "Continue upload";
                readonly downloaded: "Download complete.";
                readonly downloadCanceled: "Download canceled.";
                readonly deleted: "Deleted {{name}}.";
                readonly createdFile: "Created {{name}}.";
                readonly createdFolder: "Created {{name}}.";
                readonly createNameRequired: "Enter a name to create this item.";
                readonly createNameInvalid: "Names cannot contain slashes.";
                readonly copyPath: "Copy path";
                readonly pathCopied: "Path copied.";
                readonly copyPathFailed: "Unable to copy path: {{message}}";
                readonly unsupportedViewTitle: "Can't preview this file";
                readonly unsupportedViewBody: "Download {{name}} to open it locally.";
                readonly operationFailed: "{{message}}";
                readonly filePlaceholder: "notes.md";
                readonly folderPlaceholder: "folder-name";
                readonly cancel: "Cancel";
                readonly create: "Create";
                readonly deleteConfirm: "Delete {{name}}? This cannot be undone.";
                readonly dropToUpload: "Drop to upload to {{path}}";
                readonly dropToMove: "Drop to move to {{path}}";
                readonly previewEmpty: "Select a file or folder to view details";
                readonly previewDirectory: "Double-click the folder on the left to open the next level.";
                readonly previewUnsupported: "Preview is not available for this file.";
                readonly previewLoading: "Loading preview...";
                readonly previewReadFailed: "Unable to load preview: {{message}}";
                readonly previewTooLarge: "This file is too large to preview. Max {{maxSize}}.";
                readonly previewBinary: "This file looks binary and cannot be previewed here.";
                readonly previewDecodeFailed: "This file is not valid UTF-8.";
                readonly minimize: "Minimize";
                readonly maximize: "Maximize";
                readonly restore: "Restore";
                readonly close: "Close";
            };
            readonly workspaceFileNode: {
                readonly loading: "Loading file...";
                readonly readFailed: "Unable to read file: {{message}}";
                readonly unsupportedImage: "Unsupported image type.";
                readonly tooLarge: "This file is too large to edit here. Max {{maxSize}}.";
                readonly binary: "This file looks binary and cannot be edited here.";
                readonly decodeFailed: "This file is not valid UTF-8.";
                readonly save: "Save";
                readonly saving: "Saving...";
                readonly saved: "Saved";
                readonly dirty: "Unsaved changes";
                readonly saveFailed: "Save failed: {{message}}";
                readonly closeUnsavedTitle: "Save changes before closing?";
                readonly closeUnsavedBody: "{{name}} has unsaved changes.";
                readonly saveAndClose: "Save and close";
                readonly discard: "Discard";
                readonly cancel: "Cancel";
            };
            readonly workspaceRenameHint: "Click to rename room";
            readonly workspaceRenameLabel: "Room name";
            readonly workspaceBack: "Back";
            readonly workspaceAgentMessageCenterTitle: "Agent messages";
            readonly workspaceAgentMessageCenterOpenAria: "Open agent messages";
            readonly workspaceAgentMessageCenterWaitingCount_one: "{{count}} waiting";
            readonly workspaceAgentMessageCenterWaitingCount_other: "{{count}} waiting";
            readonly workspaceAgentMessageCenterFilterAll: "All";
            readonly workspaceAgentMessageCenterFilterWaiting: "Waiting";
            readonly workspaceAgentMessageCenterFilterWorking: "Running";
            readonly workspaceAgentMessageCenterFilterCompleted: "Completed";
            readonly workspaceAgentMessageCenterFilterFailed: "Error";
            readonly workspaceAgentMessageCenterViewOptions: "View options";
            readonly workspaceAgentMessageCenterViewSummary: "Grouped by {{group}} · {{filters}}";
            readonly workspaceAgentMessageCenterSummaryCount: "{{count}} messages";
            readonly workspaceAgentMessageCenterSummaryWaiting: "{{count}} messages · {{waiting}} need attention";
            readonly workspaceAgentMessageCenterSummaryCompleted: "{{count}} messages · {{completed}} completed";
            readonly workspaceAgentMessageCenterSummaryFiltered: "Filtered · {{count}} of {{total}}";
            readonly workspaceAgentMessageCenterFilterActive: "Filters active";
            readonly workspaceAgentMessageCenterGroupBy: "Group by";
            readonly workspaceAgentMessageCenterGroupPriority: "Importance";
            readonly workspaceAgentMessageCenterGroupStatus: "Status";
            readonly workspaceAgentMessageCenterGroupAgent: "Agent";
            readonly workspaceAgentMessageCenterGroupTime: "Time";
            readonly workspaceAgentMessageCenterGroupNeedsAttention: "Needs attention";
            readonly workspaceAgentMessageCenterGroupRecentlyCompleted: "Recently completed";
            readonly workspaceAgentMessageCenterGroupToday: "Today";
            readonly workspaceAgentMessageCenterGroupYesterday: "Yesterday";
            readonly workspaceAgentMessageCenterGroupPreviousSevenDays: "Previous 7 days";
            readonly workspaceAgentMessageCenterGroupOlder: "Older";
            readonly workspaceAgentMessageCenterFilterStatus: "Filter status";
            readonly workspaceAgentMessageCenterFilterAgent: "Filter agent";
            readonly workspaceAgentMessageCenterClearFilters: "Clear filters";
            readonly workspaceAgentMessageCenterStatusQuickFilterAria: "Show {{status}} messages ({{count}})";
            readonly workspaceAgentMessageCenterExpandStackAria: "Expand {{count}} collapsed messages";
            readonly workspaceAgentMessageCenterCollapseStackAria: "Collapse expanded messages";
            readonly workspaceAgentMessageCenterStackSummaryCount: "{{count}} messages";
            readonly workspaceAgentMessageCenterFilteredEmpty: "No messages match the current filters";
            readonly workspaceAgentMessageCenterEmpty: "No agent messages yet";
            readonly workspaceAgentMessageCenterNoSummary: "No agent message yet";
            readonly workspaceAgentMessageCenterOpenChat: "Open session";
            readonly workspaceAgentsNoSessions: "No sessions";
            readonly workspaceAgentsNoActivities: "No current activity";
            readonly workspaceAgentsUntitledConversation: "Untitled conversation";
            readonly workspaceAgentsGenericAgentName: "Agent";
            readonly workspaceAgentsSessionCount_one: "{{count}} session";
            readonly workspaceAgentsSessionCount_other: "{{count}} sessions";
            readonly workspaceAgentsMemberCount_one: "{{count}} member";
            readonly workspaceAgentsMemberCount_other: "{{count}} members";
            readonly workspaceAgentsSummaryWorking: "working";
            readonly workspaceAgentsSummaryNeedsAttention: "needs attention";
            readonly workspaceAgentsSummaryOffDuty: "off duty";
            readonly workspaceAgentsSummaryRowAria: "Member count, working, and needs attention";
            readonly workspaceAgentsParallelSessions_one: "{{count}} in parallel";
            readonly workspaceAgentsParallelSessions_other: "{{count}} in parallel";
            readonly workspaceAgentStatusWorking: "Running";
            readonly workspaceAgentStatusPaused: "Paused";
            readonly workspaceAgentStatusWaiting: "Waiting";
            readonly workspaceAgentStatusReady: "Ready";
            readonly workspaceAgentStatusCompleted: "Completed";
            readonly workspaceAgentStatusFailed: "Failed";
            readonly workspaceAgentStatusCanceled: "Canceled";
            readonly workspaceParticipantsTitle: "Human in this room";
            readonly workspaceParticipantsTopbarAria: "Workspace participants";
            readonly workspaceParticipantsInviteAria: "Invite members";
            readonly workspaceParticipantsInviteDisabled: "You’re not the creator of this room, so you can’t send invites.";
            readonly workspaceParticipantsInvitedCount_one: "{{count}} invited member";
            readonly workspaceParticipantsInvitedCount_other: "{{count}} invited members";
            readonly workspaceParticipantsOwnerBadge: "Owner";
            readonly workspaceParticipantsNoAgents: "No agent has been used yet";
            readonly workspaceParticipantsAgentCount_one: "{{count}} agent type used";
            readonly workspaceParticipantsAgentCount_other: "{{count}} agent types used";
            readonly workspaceParticipantsOnlineSummary_one: "{{count}} human or agent online";
            readonly workspaceParticipantsOnlineSummary_other: "{{count}} humans and agents online";
            readonly workspaceParticipantsOverflowAria: "More workspace participants";
            readonly workspaceXagentsCollab: "xagents collaboration";
            readonly workspaceThemeHint: "Theme & appearance";
            readonly loadingTutti: "Loading Tutti…";
            readonly runtimeArtifactStatus: {
                readonly startupTitle: "Preparing the workspace runtime";
                readonly startupDescription: "Tutti is preparing the local workspace runtime before login or workspace entry. This one-time setup may take a few minutes on the first launch.";
                readonly startupProgressHint: "Checking local runtime files and preparing downloads.";
                readonly downloadedOfTotal: "{{downloaded}} of {{total}}";
                readonly progressAria: "Workspace runtime download progress";
                readonly checking: "Preparing workspace environment…";
                readonly downloading: "Downloading workspace environment…";
                readonly downloadingPercent: "Downloading workspace environment… {{percent}}%";
                readonly verifying: "Finalizing workspace setup…";
                readonly error: "Workspace environment setup failed";
                readonly retry: "Retry setup";
                readonly retrying: "Retrying…";
                readonly backgroundHint: "You can keep using the app. The workspace environment will be ready before you enter a workspace.";
                readonly retryHint: "Open the workspace again to retry.";
            };
            readonly workspaceEnterStatus: {
                readonly enterStarted: "Connecting to workspace…";
                readonly prepareSandbox: "Preparing sandbox…";
                readonly prepareToolchain: "Preparing toolchain…";
                readonly ensureRuntime: "Starting workspace environment…";
                readonly preAttachToolchain: "Installing required tools…";
                readonly attachRuntime: "Loading workspace…";
                readonly applyProjections: "Applying Files…";
                readonly applyConfigOverlays: "Applying configuration…";
                readonly syncWorkspacePatch: "Syncing workspace state…";
                readonly enterSucceeded: "Workspace ready";
                readonly enterFailed: "Workspace enter failed";
                readonly resolvingCanvas: "Restoring workspace canvas…";
                readonly finalizingWorkspace: "Finalizing workspace…";
            };
            readonly roomRenameHint: "Click to rename room";
            readonly roomRenameLabel: "Room name";
            readonly roomBack: "Back";
            readonly roomExitActiveAgentTitle: "Leave this room?";
            readonly roomExitActiveAgentLead: "An agent is still working in this room. Leaving will stop the agent process and mark the task as interrupted.";
            readonly roomExitActiveAgentConfirm: "Leave and interrupt";
            readonly workspaceAgentSessionDetailToolCalls: "{{count}} tool calls";
            readonly workspaceAgentSessionDetailThinking: "Thinking";
            readonly workspaceAgentSessionDetailWorking: "Running...";
            readonly workspaceClosingBanner: "This workspace is closing. Your connection will end soon.";
            readonly workspaceClosingStatus: "Workspace shutdown in progress";
            readonly workspaceAgentMessageExpand: "Show all";
            readonly workspaceAgentActivityStatusWorking: "Running";
            readonly workspaceAgentActivityStatusWaiting: "Waiting";
            readonly workspaceAgentActivityStatusIdle: "Completed";
            readonly workspaceAgentActivityStatusEnd: "Completed";
            readonly workspaceAgentActivityStatusCompleted: "Completed";
            readonly workspaceAgentActivityStatusCanceled: "Canceled";
            readonly workspaceAgentActivityStatusFailed: "Error";
            readonly workspaceAgentSessionDetailEmptyWithTimeline: "There are no displayable session messages yet.";
            readonly workspaceAgentSessionDetailEmptyNoTimeline: "No session details yet.";
            readonly workspaceAgentSessionDetailOpenFile: "Open {{path}}";
            readonly shareJoin: {
                readonly status: {
                    readonly checkingTitle: "Checking invite";
                    readonly checkingDescription: "Validating the invite code and opening the room.";
                    readonly successTitle: "Joined room";
                    readonly successDescription: "The workspace list has been refreshed and the room is opening.";
                    readonly fullTitle: "Room is full";
                    readonly fullDescription: "This workspace has no collaborator seats remaining.";
                    readonly usedTitle: "Invite link expired";
                    readonly usedDescription: "This invite code has already been used.";
                    readonly revokedTitle: "Invite link expired";
                    readonly revokedDescription: "This invite code has been revoked by the owner.";
                    readonly invalidTitle: "Could not join room";
                    readonly invalidDescription: "Check whether the link is complete, or ask the owner to generate a new invite.";
                    readonly authRequiredTitle: "Sign in required";
                    readonly authRequiredDescription: "Please sign in first, then reopen the invite link to continue joining.";
                    readonly defaultTitle: "Could not join room";
                    readonly defaultDescription: "Check whether the link is complete, or ask the owner to generate a new invite.";
                };
                readonly modal: {
                    readonly eyebrow: "Workspace Share";
                    readonly title: "Join as collaborator";
                    readonly recognizedRoom: "Recognized room";
                    readonly inviteCodePlaceholder: "Enter invite code";
                    readonly submit: "Enter room with invite code";
                    readonly submitting: "Entering...";
                };
            };
            readonly datePicker: {
                readonly placeholder: "Year / Month / Day";
                readonly displayValue: "{{year}} / {{month}} / {{day}}";
                readonly monthLabel: "{{month}} / {{year}}";
                readonly previousMonth: "Previous month";
                readonly nextMonth: "Next month";
                readonly clear: "Clear";
                readonly today: "Today";
                readonly weekdaySun: "Sun";
                readonly weekdayMon: "Mon";
                readonly weekdayTue: "Tue";
                readonly weekdayWed: "Wed";
                readonly weekdayThu: "Thu";
                readonly weekdayFri: "Fri";
                readonly weekdaySat: "Sat";
            };
            readonly collabResult: {
                readonly title: "Collaboration result";
                readonly actorFallback: "Collaborator";
                readonly unread: "{{name}} marked the task as complete. Check the latest result.";
                readonly read: "{{name}} marked the task as complete.";
            };
            readonly agentTool: {
                readonly fallbackName: "Use tool";
                readonly statusWorking: "Running";
                readonly statusCompleted: "Completed";
                readonly statusFailed: "Failed";
                readonly statusCanceled: "Canceled";
                readonly statusWaiting: "Waiting";
                readonly details: {
                    readonly summary: "Summary";
                    readonly input: "Input";
                    readonly output: "Output";
                    readonly error: "Error";
                    readonly command: "Command";
                    readonly prompt: "Prompt";
                    readonly path: "Path";
                    readonly content: "Content";
                    readonly patch: "Patch";
                    readonly questions: "Questions";
                    readonly steps: "Steps";
                    readonly query: "Query";
                    readonly scope: "Scope";
                    readonly results: "Results";
                    readonly url: "URL";
                    readonly todos: "Todos";
                    readonly skill: "Skill";
                    readonly mcp: "MCP";
                    readonly mcpServer: "Server";
                    readonly mcpTool: "Tool";
                    readonly mcpItem: "Item {{index}}";
                    readonly mcpDoc: "Doc {{index}}";
                    readonly approvalOptions: "Approval options";
                    readonly answerPrefix: "Answer: {{answer}}";
                    readonly waitingForAnswer: "Waiting for answer…";
                    readonly questionFallback: "Question";
                    readonly delegateSession: "Delegate session";
                    readonly subAgents: "Sub-agents";
                    readonly subAgentStarting: "Starting…";
                    readonly subAgentQueued: "Queued — waiting for an agent slot…";
                    readonly subAgentFallbackName: "Sub-agent";
                    readonly subAgentEarlierOmitted: "{{count}} earlier steps omitted";
                    readonly subAgentTask: "TASK";
                    readonly subAgentProgress: "PROGRESS";
                    readonly missingFailureDetails: "The provider reported failure without details.";
                    readonly noMatches: "No matches";
                    readonly stepLabel: "Step {{index}}";
                    readonly noMatchingTools: "No matching tools";
                    readonly loadedAvailable: "{{loaded}} loaded · {{available}} available";
                    readonly contentTruncated: "Content truncated";
                    readonly summaryTruncated: "Summary truncated";
                    readonly rawPayload: "Raw payload";
                    readonly loadingDiff: "Loading diff…";
                    readonly imagePreviewAlt: "Image generation preview";
                    readonly showFullContent: "Show full content ({{count}} lines)";
                    readonly collapseContent: "Collapse content";
                    readonly showFullDiff: "Show full diff ({{count}} lines)";
                };
                readonly labels: {
                    readonly runCommand: "Run command";
                    readonly readFile: "Read file";
                    readonly writeFile: "Write file";
                    readonly editFile: "Edit file";
                    readonly listFiles: "List files";
                    readonly searchFiles: "Search files";
                    readonly webSearch: "Search web";
                    readonly webFetch: "Read web page";
                    readonly applyPatch: "Apply patch";
                    readonly useTool: "Use tool";
                    readonly findFiles: "Find files";
                    readonly readCommandOutput: "Read command output";
                    readonly stopCommand: "Stop command";
                    readonly readNotebook: "Read notebook";
                    readonly editNotebook: "Edit notebook";
                    readonly updateTodos: "Update todos";
                    readonly delegateAgent: "Delegate agent";
                    readonly closeAgent: "End agent";
                    readonly waitAgent: "Wait for agent";
                    readonly currentIssue: "Current task";
                    readonly thinking: "Thinking";
                    readonly responding: "Responding";
                    readonly notification: "Notification";
                };
            };
            readonly workspaceAgentProbeAvailableAria: "Available";
            readonly workspaceAgentProbeUnavailableAria: "Unavailable";
            readonly workspaceAgentProbeUnknownAria: "Status unknown";
            readonly workspaceAgentProbeDockChecking: "Checking availability…";
            readonly workspaceAgentProbeDockNoData: "No availability data for this room yet";
            readonly workspaceAgentProbeDockAvailable: "Available";
            readonly workspaceAgentProbeDetailStatus: "Status";
            readonly workspaceAgentProbeDetailQuota: "Quota";
            readonly workspaceAgentProbeUsageUnsupported: "Usage data not available";
            readonly workspaceAgentProbeQuotaResetTimeLabel: "{{label}} reset time";
            readonly workspaceAgentProbeLoadingUsage: "Loading usage…";
            readonly workspaceAgentProbeScrollListRight: "Show more agents";
            readonly workspaceAgentProbeScrollListLeft: "Show previous agents";
            readonly workspaceAgentProbeAgentUsage: "Usage";
            readonly workspaceAgentProbeQuotaSession: "Session";
            readonly workspaceAgentProbeQuotaWeekly: "Weekly";
            readonly workspaceAgentProbeQuotaMonthly: "Monthly";
            readonly workspaceAgentProbeQuotaDaily: "Daily";
            readonly workspaceAgentProbeQuotaCost: "Cost";
            readonly workspaceAgentProbeErrorAuthRequired: "Sign in required";
            readonly workspaceAgentProbeErrorSessionExpired: "Session expired";
            readonly workspaceAgentProbeErrorSubscriptionRequired: "Subscription required";
            readonly workspaceAgentProbeErrorParseFailed: "Usage output could not be parsed";
            readonly workspaceAgentProbeErrorNoData: "No usage data yet";
            readonly workspaceAgentProbeErrorTimeout: "Usage probe timed out";
            readonly workspaceAgentProbeErrorUnavailable: "Usage probe failed";
            readonly roomParticipantsTitle: "Human in this room";
            readonly roomParticipantsTopbarAria: "Room participants";
            readonly roomParticipantsInviteAria: "Invite members";
            readonly roomParticipantsInviteDisabled: "You’re not the creator of this room, so you can’t send invites.";
            readonly roomParticipantsInviteOwnerOnlyTooltip: "Only room owners can invite members";
            readonly roomParticipantsLeaveRoom: "Leave room";
            readonly roomParticipantsInvitedCount_one: "{{count}} invited member";
            readonly roomParticipantsInvitedCount_other: "{{count}} invited members";
            readonly roomParticipantsOwnerBadge: "Owner";
            readonly roomParticipantsNoAgents: "No agent has been used yet";
            readonly roomParticipantsAgentCount_one: "{{count}} agent type used";
            readonly roomParticipantsAgentCount_other: "{{count}} agent types used";
            readonly roomParticipantsOnlineSummary_one: "{{count}} human or agent online";
            readonly roomParticipantsOnlineSummary_other: "{{count}} humans and agents online";
            readonly roomParticipantsOverflowAria: "More room participants";
            readonly roomConnecting: "Preparing room…";
            readonly roomCanvasLoadErrorTitle: "Room canvas data failed to load";
            readonly roomCanvasLoadErrorDescription: "The current room canvas data could not be loaded. Refresh to try again.";
            readonly roomCanvasLoadRetry: "Refresh";
            readonly roomCanvasLoadRetrying: "Refreshing…";
            readonly roomRecoveryRenderFailed: "Room restored from backend but failed to render workspace. Please reload.";
            readonly runtimeConnectionLostTitle: "Runtime connection lost";
            readonly runtimeConnectionLostSummary: "The managed runtime connection could not recover quickly. Restart the app to continue.";
            readonly runtimeConnectionLostLead: "The app will relaunch and start a fresh local runtime.";
            readonly runtimeConnectionRefresh: "Restart app";
            readonly runtimeConnectionRefreshing: "Restarting…";
            readonly runtimeConnectionRefreshSucceeded: "App restart requested.";
            readonly roomEntryDiscarded: "Could not finish opening the workspace. It may have been replaced by a newer action—please try again.";
            readonly roomEnterStatus: {
                readonly enterStarted: "Connecting to room…";
                readonly prepareSandbox: "Preparing sandbox…";
                readonly prepareToolchain: "Preparing toolchain…";
                readonly ensureRuntime: "Starting workspace environment…";
                readonly runTemplateHook: "Running application setup…";
                readonly preAttachToolchain: "Installing required tools…";
                readonly attachRuntime: "Loading workspace…";
                readonly applyProjections: "Applying files…";
                readonly applyConfigOverlays: "Applying configuration…";
                readonly syncWorkspacePatch: "Syncing room state…";
                readonly enterSucceeded: "Room ready";
                readonly enterFailed: "Room enter failed";
                readonly resolvingCanvas: "Restoring room canvas…";
                readonly finalizingWorkspace: "Finalizing room…";
            };
            readonly simpleMode: {
                readonly pageHeadline: "Collaborate with partners and Agents in one shared room";
                readonly fusedButton: {
                    readonly main: "Create collaboration room";
                    readonly hint: "Drop files or folders to use as the starting point partners can work on together";
                    readonly hintActive: "Release to create a collaboration room with this content";
                };
                readonly note: {
                    readonly label: "Note";
                    readonly placeholder: "What is this room for? (Optional)";
                };
                readonly overlayStatus: {
                    readonly creating: "Preparing your shared room…";
                    readonly generatingInvite: "Room is ready. Generating the invite link…";
                    readonly done: "Entering the room…";
                    readonly error: "Something went wrong";
                };
                readonly overlayActions: {
                    readonly retry: "Retry";
                    readonly dismiss: "Back";
                };
                readonly inviteModal: {
                    readonly title: "Send this link to your partners";
                    readonly body: "Anyone who opens the link can join the same room and work with the content you just added.";
                    readonly linkLabel: "Invite link";
                    readonly copy: "Copy";
                    readonly copied: "Copied";
                    readonly primary: "Done";
                    readonly secondary: "Share later";
                };
            };
            readonly workspaceConnecting: "Preparing your room…";
            readonly unknownProvider: "Unknown provider";
            readonly messages: {
                readonly roomOpened: "Room opened";
                readonly roomOpenedIssue: "Room opened. Preparing to focus the task.";
                readonly issueTitleRequired: "Enter a task title first";
                readonly issueCreated: "Task created";
                readonly issueUpdated: "Task updated";
                readonly issueShareLinkCopied: "Task share link copied";
                readonly issueShareFallbackRoomFull: "This room is full. Copied a task link that only current room members can open.";
                readonly issueShareFallbackInviteFull: "Invite link capacity is full. Copied a task link that only current room members can open.";
                readonly issueWorkspaceNotReady: "The current room workspace is not ready yet. Please try again soon.";
                readonly issueRunSessionUnavailable: "This run is not linked to a replayable session";
                readonly issueDetailRequiredBeforeRun: "Open the task details before starting the run";
                readonly issueNoAvailableAgent: "There is no available Agent right now";
                readonly issueRunStarted: "Sent to {{provider}}. Adjust before running.";
                readonly issueStatusUpdated: "Task status updated";
                readonly issueDeleteForbidden: "Only the task creator can delete this task";
                readonly issueNotFoundOrDeleted: "The task does not exist or has already been deleted";
                readonly issueDeleted: "Task deleted";
                readonly issueContextAdded: "Reference files added";
                readonly issueContextRemoved: "Reference file removed";
                readonly issuePendingUploadAdded: "Added {{count}} pending upload file(s)";
                readonly issueUploaded: "Uploaded {{count}} file(s)";
                readonly issueDirectInstallUnsupported: "Installing Agents is not supported here yet";
                readonly collabCompleted: "This collaboration task is complete";
                readonly githubLoginCompleted: "GitHub sign-in complete";
                readonly googleLoginCompleted: "Google sign-in complete";
            };
            readonly issue: {
                readonly sidebarEyebrow: "Task center";
                readonly sidebarTitle: "Tasks";
                readonly sidebarHint: "Everyone in the room can review tasks and jump to collaboration work quickly.";
                readonly sidebarResizeAria: "Resize task list";
                readonly create: "Create task";
                readonly loading: "Loading tasks...";
                readonly empty: "There are no tasks yet. Create one to start collaborating.";
                readonly metaPriority: "Priority {{value}}";
                readonly metaDue: "Due {{value}}";
                readonly stageEyebrow: "Task flow";
                readonly stageTitle: "Use tasks to connect context, execution, and outputs in one flow.";
                readonly stageDescription: "Create a task in the room, attach Files for context, then let a collaborator run it manually with their own Agent.";
                readonly shareThisIssue: "Share this task";
                readonly flowList: "Browse tasks";
                readonly flowCreate: "Create task";
                readonly flowContext: "Reference Files";
                readonly flowDetail: "Review details";
                readonly flowRun: "Choose how to run";
                readonly flowOutput: "Review outputs";
                readonly currentFocusTitle: "Current focus";
                readonly currentFocusSubtle: "The selected task is summarized here so you can move to the next step quickly.";
                readonly currentFocusEmpty: "Select a task from the left, or create a new one to start the run flow.";
                readonly defaultDescription: "Add background, symptoms, and expected outcomes so collaborators can pick this up more easily.";
                readonly metricReferences: "References";
                readonly metricRunHistory: "Run history";
                readonly metricOutputs: "Latest outputs";
                readonly countFiles: "{{count}} file(s)";
                readonly countRuns: "{{count}} run(s)";
                readonly executionModeTitle: "How to run";
                readonly executionModeSubtle: "V1 uses one path: open the shared task, then run it manually with your own Agent.";
                readonly executionMyAgentTag: "My Agent";
                readonly executionMyAgentDescription: "Start a run directly from the detail view and write results back into Files.";
                readonly executionShareTag: "Share link";
                readonly executionShareDescription: "Bring collaborators to the same task so they can click run themselves. V1 does not auto-run for others.";
                readonly outputsTitle: "Outputs";
                readonly outputsSubtle: "After a run finishes, the summary, recent runs, and Files complete the loop.";
                readonly outputsEmpty: "No execution outputs yet.";
                readonly fileFallback: "file";
                readonly detailEyebrow: "Task detail";
                readonly collapse: "Collapse";
                readonly detailLoading: "Loading details…";
                readonly overviewTitle: "Overview";
                readonly overviewSubtle: "After creation, open the detail view, attach references, and decide who should run it.";
                readonly runWithMyAgent: "Run with my Agent";
                readonly rerunWithMyAgent: "Run again with my Agent";
                readonly summaryPriority: "Priority";
                readonly summaryDueDate: "Due date";
                readonly summaryReferences: "References";
                readonly summaryRunHistory: "Run history";
                readonly noDescription: "No description yet";
                readonly shareTipCanInvite: "You can share this with collaborators inside or outside the room. The first open will jump into this task automatically.";
                readonly shareTipRoomFull: "This room is full, so only current room members can open this task from the link.";
                readonly referencesTitle: "Reference files";
                readonly referencesSubtle: "Choose context files from the Room Workspace and attach them to this task.";
                readonly addReferences: "Reference Files";
                readonly referencesEmpty: "There are no reference files yet. Add context before running.";
                readonly runResultTitle: "Run result";
                readonly prepareRunTitle: "Prepare to run";
                readonly runResultSubtle: "Review the latest run, outputs, and run history, and start another run if needed.";
                readonly prepareRunSubtle: "After creation, finish adding references here, then decide how to run it.";
                readonly runHeroTitle: "My Agent · Run {{runId}}";
                readonly runSummaryEmpty: "No run result yet";
                readonly runStatusRunning: "Run in progress. Waiting for the latest update.";
                readonly runStatusCompleted: "The run finished without a returned summary yet.";
                readonly runStatusFailed: "The run failed without an error summary yet.";
                readonly runDetailsLoading: "Loading run details…";
                readonly runOutputsEmpty: "Output files will appear in Files shortly.";
                readonly prerunEmpty: "There are no run records yet. Add reference files first, then click “Run with my Agent”.";
                readonly shareWithCollaborator: "Share link with collaborator";
                readonly historyTitle: "Run history";
                readonly historyHint: "Click to switch to that run result";
                readonly currentRunOutputsTitle: "Outputs from this run";
                readonly currentRunOutputsSubtle: "Run outputs are written back into Files so you can preview and reuse them.";
                readonly currentRunOutputsEmpty: "There are no output files for this run yet.";
                readonly directoryViewTitle: "Directory view";
                readonly directoryViewSubtle: "If a run produces a directory, the files under that directory will appear here.";
                readonly directoryViewEmpty: "There is no output directory to mirror yet.";
                readonly directoryKind: "DIR";
                readonly fileKind: "FILE";
                readonly createTitle: "Create task";
                readonly createSubtle: "Describe the request so the task is ready to run.";
                readonly fieldTitle: "Title";
                readonly titlePlaceholder: "Enter a task title";
                readonly fieldDescription: "Description";
                readonly descriptionPlaceholder: "Add background, symptoms, impact, and the expected result";
                readonly descriptionPlaceholderLegacy: "Describe the background, symptoms, and expected result.";
                readonly fieldPriority: "Priority";
                readonly priorityOptionMedium: "Medium";
                readonly priorityOptionHigh: "High";
                readonly priorityOptionLow: "Low";
                readonly fieldDueDate: "Due date";
                readonly attachmentsOptional: "References (optional)";
                readonly attachmentsEmpty: "No references added yet";
                readonly createReferencesTitle: "Reference Files";
                readonly createReferencesSubtle: "Choose context files from the Room Workspace and attach them to this task.";
                readonly selectReferences: "Select references";
                readonly selectionNone: "No files selected";
                readonly selectionCount: "{{count}} file(s) selected";
                readonly selectionEmpty: "No references selected yet.";
                readonly saveIssue: "Save task";
                readonly contextPickerCreateTitle: "Reference Files";
                readonly contextPickerDetailTitle: "Add reference files";
                readonly contextPickerSubtle: "Choose execution context files from the Room Workspace.";
                readonly contextPickerEmpty: "No files selected yet.";
                readonly completeReferences: "Finish selecting";
                readonly addToIssue: "Add to task";
                readonly addingToIssue: "Adding...";
                readonly dueDateUnset: "Not set";
                readonly runTimeJustNow: "Just now";
                readonly createdJustNow: "Just created";
                readonly searchPlaceholder: "Search tasks...";
                readonly sidebarEmpty: "Tasks from this room will appear here";
                readonly sidebarCategoryEmpty: "There are no tasks in this category";
                readonly searchEmptyTitle: "No matching tasks";
                readonly searchEmptyDescription: "Try a different keyword.";
                readonly defaultEmptyTitle: "No tasks yet";
                readonly defaultEmptyDescription: "Create a task, add requirements and related files, then ask a collaborator or your own Agent to run it.";
                readonly defaultSelectTitle: "Choose a task";
                readonly defaultSelectDescription: "Open a detail view from the list on the left, or create a new collaboration task.";
                readonly editTitle: "Edit task";
                readonly uploadFile: "Upload file";
                readonly uploadFolder: "Upload folder";
                readonly referenceWorkspaceFiles: "Reference Files";
                readonly pendingUploadArchiveHint: "After the task is created, this will be archived into the references folder";
                readonly latestExecutionTitle: "Latest run status";
                readonly executionRecordsTitle: "Run history";
                readonly viewDetails: "View details";
                readonly copyLink: "Copy link";
                readonly copyingLink: "Copying...";
                readonly inviteCollaborator: "Invite collaboration";
                readonly shareWithCollaboratorHint: "Share it with a collaborator so they can run it with their own Agent.";
                readonly summaryTitle: "Summary";
                readonly outputsTitleLegacy: "Outputs";
                readonly filePickerTitle: "Choose references to add to the task";
                readonly searchRoomFilesPlaceholder: "Search Files...";
                readonly noReferenceFiles: "No reference files available";
                readonly selectReferenceRequired: "Select at least one file to reference";
                readonly expandItem: "Expand {{label}}";
                readonly collapseItem: "Collapse {{label}}";
                readonly toggleSelection: "Toggle selection for {{label}}";
                readonly selectionCountShort: "{{count}} selected";
                readonly currentPreview: "Current preview";
                readonly previewPrompt: "Choose a reference on the left to preview it";
                readonly previewPromptCompact: "Choose a reference above to preview it";
                readonly filePickerDirectoryPreview: "Choose another file on the left to preview it";
                readonly filePickerDirectoryPreviewCompact: "Choose another file above to preview it";
                readonly contextEmpty: "No reference files yet";
                readonly openReference: "Open reference {{label}}";
                readonly outputsEmptyCompact: "No outputs yet";
                readonly openOutput: "Open output {{label}}";
                readonly scrollFiltersLeft: "Scroll task categories left";
                readonly scrollFiltersRight: "Scroll task categories right";
                readonly edit: "Edit";
                readonly runStarting: "Starting...";
                readonly runtimeUnavailable: "The current runtime is unavailable";
                readonly unavailable: "Unavailable";
                readonly install: "Install";
                readonly installing: "Installing...";
                readonly sync: "Sync";
                readonly syncing: "Syncing...";
                readonly filterAll: "All";
                readonly statusAriaLabel: "Task status";
                readonly priorityAriaLabel: "Task priority";
                readonly metaCreator: "Creator {{value}}";
                readonly metaCreatedAt: "Created {{value}}";
                readonly metaDueAt: "Due {{value}}";
                readonly metaCompletedAt: "Completed {{value}}";
                readonly requesterFallback: "User";
                readonly agentCodex: "Codex";
                readonly agentClaudeCode: "Claude Code";
                readonly agentTutti: "Tutti";
                readonly agentHermes: "Hermes";
                readonly agentOpenClaw: "OpenClaw";
                readonly statusNotStarted: "To run";
                readonly statusRunning: "Running";
                readonly statusPendingAcceptance: "Pending acceptance";
                readonly statusCompleted: "Completed";
                readonly statusFailed: "Run failed";
                readonly statusCanceled: "Canceled";
                readonly priorityHigh: "High";
                readonly priorityMedium: "Medium";
                readonly priorityLow: "Low";
            };
            readonly roomIssueNode: {
                readonly statusTabAll: "All";
                readonly statusTabNotStarted: "To run";
                readonly statusTabRunning: "Running";
                readonly statusTabPendingAcceptance: "Pending acceptance";
                readonly statusTabCompleted: "Completed";
                readonly emptyContent: "No content yet";
                readonly taskCount_one: "{{count}} sub-task";
                readonly taskCount_other: "{{count}} sub-tasks";
                readonly taskCountEmpty: "No sub-tasks";
                readonly taskRunningCount: "{{count}} running";
                readonly taskPendingAcceptanceCount: "{{count}} pending acceptance";
                readonly taskCompletedCount: "{{count}} completed";
                readonly issueStatusNotStarted: "Todo";
                readonly issueStatusRunning: "Running";
                readonly issueStatusInProgress: "Running";
                readonly issueStatusPendingAcceptance: "In review";
                readonly issueStatusCompleted: "Done";
                readonly issueStatusFailed: "Failed";
                readonly issueStatusCanceled: "Canceled";
                readonly issueStatusUnknown: "Unknown status";
                readonly runStatusRunning: "Running";
                readonly runStatusCompleted: "Completed";
                readonly runStatusFailed: "Failed";
                readonly runStatusCanceled: "Canceled";
                readonly runStatusIdle: "Idle";
                readonly issueTitleRequired: "Enter a task title";
                readonly taskTitleRequired: "Enter a task title";
                readonly selectTaskFirst: "Select a task first";
                readonly deleteTaskDialogTitle: "Delete task";
                readonly deleteTaskConfirm: "Delete task “{{title}}”?";
                readonly deleteIssueDialogTitle: "Delete task";
                readonly deleteIssueConfirm: "Delete task “{{title}}”?";
                readonly issueTaskUnavailable: "This task is missing its parent task. The action is unavailable right now.";
                readonly shareCopied: "Invite link copied";
                readonly outputOpenUnavailable: "There is no output to open right now";
                readonly sessionUnavailable: "There is no session to open right now";
                readonly editTask: "Edit task";
                readonly createTask: "New task";
                readonly taskEditorLead: "Add a task title and description so execution can continue.";
                readonly taskTitlePlaceholder: "Enter a task title";
                readonly taskContentPlaceholder: "Add the background, goal, and acceptance criteria";
                readonly saveTask: "Save task";
                readonly cancel: "Cancel";
                readonly noTaskTitle: "No tasks yet";
                readonly noTaskDescription: "Create a task, add requirements and related files, then ask a collaborator or your own Agent to run it";
                readonly favoriteTask: "Favorite task";
                readonly creator: "Created by";
                readonly createdAt: "Created at";
                readonly edit: "Edit";
                readonly delete: "Delete";
                readonly description: "Description";
                readonly emptyTaskContent: "No task description yet";
                readonly emptyIssueContent: "No task description yet";
                readonly references: "Reference files";
                readonly emptyReferences: "No reference files yet";
                readonly editIssue: "Edit task";
                readonly createIssue: "Add task";
                readonly issueTitlePlaceholder: "Enter a task title";
                readonly issueContentPlaceholder: "Add the task goal, execution method, and acceptance criteria";
                readonly saveIssue: "Save task";
                readonly issueSelectionHint: "Select a task to view its details and Agent execution state.";
                readonly timeLabel: "Time {{value}}";
                readonly updatedAtLabel: "Updated at";
                readonly runNotStarted: "No execution records yet.";
                readonly issueDetailsLoading: "Loading task details…";
                readonly agentExecution: "Agent execution";
                readonly noIssuesTitle: "There are no tasks yet";
                readonly noIssuesTaskShellDescription: "You can continue adding sub-tasks around the current task theme";
                readonly taskExecutionTitle: "Task execution in progress";
                readonly taskExecutionDescription: "Current progress appears here. Add a task any time you need to supplement a new direction.";
                readonly deleteIssue: "Delete task";
                readonly searchPlaceholder: "Search tasks";
                readonly refreshTasksAria: "Refresh task list";
                readonly collapseTaskList: "Collapse task list";
                readonly expandTaskList: "Expand task list";
                readonly noTasksForFilterTitle: "No tasks match the current filters.";
                readonly noTasksForFilterBody: "Try another filter, or create a new task.";
                readonly loadMore: "Load more";
                readonly issuesSection: "Sub-tasks";
                readonly createSubtask: "Add";
                readonly createSubtaskTitle: "Add sub-task";
                readonly editSubtask: "Edit sub-task";
                readonly saveSubtask: "Save sub-task";
                readonly issueTableTitle: "Title";
                readonly issueTableDescription: "Description";
                readonly issueTableStatus: "Status";
                readonly issueTableOwner: "Owner";
                readonly issueTableTime: "Time";
                readonly issueTableActions: "Actions";
                readonly unassigned: "Unassigned";
                readonly view: "View";
                readonly share: "Share";
                readonly run: "Run";
                readonly inviteCollaborator: "Invite collaboration";
                readonly askAgentToRun: "Send to Agent";
                readonly moreActions: "More actions";
                readonly closeIssueDrawerAria: "Close task details drawer";
                readonly runWithProvider: "Run with {{provider}}";
                readonly noIssues: "There are no sub-tasks for this task yet.";
                readonly noManualIssues: "Add a sub-task to track follow-up work here.";
                readonly currentMember: "Me";
                readonly closeWindowAria: "Close {{title}}";
            };
            readonly workspaceSidebarRuntimeTitle: "Runtime";
            readonly workspaceSidebarRuntimeDescription: "Live context for the current canvas.";
            readonly workspaceSidebarLiveBadge: "Live";
            readonly workspaceSidebarRootPrefix: "Root:";
            readonly workspaceSidebarSandboxPrefix: "Sandbox:";
            readonly workspaceSidebarSessionsPrefix: "Sessions:";
            readonly workspaceSidebarProviderPrefix: "Provider:";
            readonly workspaceSidebarTreeTitle: "Directory tree";
            readonly workspaceSidebarTreeDescription: "Runtime-visible room structure.";
            readonly workspaceSidebarTreeKindDir: "Directory";
            readonly workspaceSidebarTreeKindFile: "File";
            readonly workspaceSidebarProfileMe: "Me";
            readonly profile: {
                readonly openMenu: "Open account menu";
                readonly accountSettings: "User info";
                readonly accountSettingsTitle: "User info";
                readonly accountSettingsLead: "Update how your name and avatar appear across rooms.";
                readonly accountSettingsNameLabel: "Display name";
                readonly accountSettingsNamePlaceholder: "Enter your display name";
                readonly accountSettingsAvatarLabel: "Avatar";
                readonly accountSettingsUpload: "Upload image";
                readonly accountSettingsDefaultAvatars: "Default avatars";
                readonly accountSettingsInvalidImage: "Choose a valid image file.";
                readonly accountSettingsImageTooLarge: "Image must be 2 MB or smaller.";
                readonly accountSettingsCropTitle: "Crop avatar";
                readonly accountSettingsCropZoom: "Zoom";
                readonly accountSettingsCropRotation: "Rotate";
                readonly accountSettingsCropCancel: "Cancel crop";
                readonly accountSettingsCropApply: "Use image";
                readonly accountSettingsSaved: "Account settings saved.";
                readonly themeSystem: "Match system";
                readonly themeLight: "Light";
                readonly themeDark: "Dark";
                readonly language: "Language";
                readonly logout: "Sign out";
                readonly logoutDone: "Signed out of the local demo account";
                readonly labTitle: "Lab";
                readonly labDirectVMTerminalTitle: "VM Terminal";
                readonly labDirectVMTerminalDescription: "Show a launcher entry that opens a shell directly inside the managed Linux VM";
                readonly labDebugTerminalTitle: "Debug Terminal";
                readonly labDebugTerminalDescription: "Show the workspace-bound debug terminal in room dock";
            };
            readonly launch: {
                readonly navLaunch: "Start";
                readonly navTemplates: "Templates";
                readonly navManageAgents: "Manage agents";
                readonly navConnectors: "Connectors";
                readonly navVMTerminal: "VM Terminal";
                readonly vmTerminalStarting: "Starting VM...";
                readonly vmTerminalRetry: "Retry";
                readonly vmTerminalSessionLost: "VM terminal session was lost.";
                readonly vmTerminalProcessExited: "[process exited with code {{exitCode}}]";
                readonly manageAgentsTitle: "Agents";
                readonly dock: {
                    readonly agentNotInstalled: "No local settings found. Sync after local setup.";
                    readonly agentNotSynced: "Local settings found. Sync now?";
                };
                readonly manageAgentsGuideLead: "Syncing or removing only affects Tutti; agents on your computer are unchanged.";
                readonly manageAgentsColumnAgent: "Agent";
                readonly manageAgentsColumnRun: "Runs in";
                readonly manageAgentsColumnInstallStatus: "Status";
                readonly manageAgentsColumnSettings: "Settings";
                readonly manageAgentActionInstall: "Sync";
                readonly manageAgentActionSync: "Sync";
                readonly manageAgentActionSyncTooltip: "Your local settings will be synced automatically";
                readonly manageAgentRuntimeArtifactPreparingTooltip: "Workspace environment is still preparing. Sync will be available after it finishes.";
                readonly manageAgentActionUninstall: "Remove";
                readonly manageAgentActionInstalling: "Syncing...";
                readonly manageAgentActionSyncing: "Syncing...";
                readonly manageAgentActionRetry: "Retry";
                readonly manageAgentActionUninstalling: "Removing...";
                readonly manageAgentActionUninstallWaiting: "Waiting...";
                readonly manageAgentUninstallConfirm: "This only removes {{name}} from Tutti. Apps, sign-in, and settings outside Tutti are not changed.";
                readonly manageAgentCellRunsLocal: "Tutti local";
                readonly manageAgentCellInstalled: "Synced";
                readonly manageAgentCellNotInstalled: "Not synced";
                readonly manageAgentUninstallWaiting: "Waiting to remove";
                readonly manageAgentUninstallRemoving: "Removing";
                readonly manageAgentDownloadDownloading: "Downloading {{agent}} · {{percent}}";
                readonly manageAgentDownloadRetrying: "Retrying download · {{attempt}}/{{max}}";
                readonly manageAgentDownloadFailed: "Download failed";
                readonly manageAgentDownloadWaitingInstall: "Waiting to install";
                readonly manageAgentDownloadInstalling: "Installing";
                readonly manageAgentConfigWillUse: "Local settings found";
                readonly manageAgentConfigWillSyncFrom: "After sync, Tutti will use {{agent}} settings from {{device}}";
                readonly manageAgentConfigSynced: "Synced · {{time}}";
                readonly manageAgentConfigSyncedNoTime: "Synced";
                readonly manageAgentConfigSyncedFrom: "Synced from {{device}} to Tutti · {{time}}";
                readonly manageAgentConfigSyncedFromNoTime: "Synced from {{device}} to Tutti";
                readonly manageAgentConfigNone: "No settings";
                readonly manageAgentConfigNotDetected: "No local settings found";
                readonly manageAgentMissingHostConfigTooltip: "{{agent}} depends on your local installation. Finish local setup before syncing.";
                readonly manageAgentTuttiDefaultConfig: "Tutti default settings";
                readonly manageAgentHostDeviceFallback: "this computer";
                readonly manageAgentSyncTimeJustNow: "just now";
                readonly manageAgentSyncTimeMinutesAgo: "{{count}} minutes ago";
                readonly manageAgentSyncTimeHoursAgo: "{{count}} hours ago";
                readonly manageAgentSyncTimeDaysAgo: "{{count}} days ago";
                readonly manageAgentsOpenclawHint: "To use OpenClaw in rooms, sync OpenClaw from Manage Agents.";
                readonly kicker: "Tutti · Desktop";
                readonly promoBadge: "You currently have {{count}} available agents, you can use them inside rooms.";
                readonly promoBadgeNavigateAria: "Go to Manage agents—you currently have {{count}} available agents";
                readonly heroTitle: "Real-Time Collaborative OS for Humans and Agents";
                readonly updateAction: "Update";
                readonly updateInstallingAction: "Relaunch to Update";
                readonly updateDownloadingAction: "Updating {{percent}}";
                readonly updateCardAvailableTitle: "Version {{version}} is available";
                readonly updateCardAvailableDetail: "Download the latest build whenever you are ready.";
                readonly updateCardDownloadingTitle: "Downloading {{version}}";
                readonly updateCardDownloadingDetail: "The update package is downloading in the background.";
                readonly updateCardDownloadedTitle: "Update is ready to install";
                readonly updateCardDownloadedDetail: "Restart Tutti to finish installing version {{version}}.";
                readonly updateCardDownloadAction: "Download Update";
                readonly updateCardInstallAction: "Restart and Install";
                readonly sectionSpacesTitle: "Rooms";
                readonly sectionAgentsTitle: "Agents";
                readonly sectionAgentsAction: "Manage";
                readonly sectionAgentsEmpty: "You do not have any available Agents yet";
                readonly sectionAgentsInstallAction: "Install now";
                readonly viewAllRooms: "View all";
                readonly roomsExpand: "Show {{count}} more";
                readonly roomsCollapse: "Show less";
                readonly roomsLoadMore: "Load more";
                readonly roomsEmptyPlaceholder: "No rooms created or joined yet";
                readonly recommendedTemplatesTitle: "Scenario templates";
                readonly recommendedTemplatesViewMore: "More";
                readonly topRailOpenCreateAria: "Create a new room—enter the name in the dialog";
                readonly topRailOpenJoinAria: "Join an existing room—paste the share link in the dialog";
                readonly roomCardStatusActive: "In progress";
                readonly roomCardStatusIdle: "Idle";
                readonly roomCardStatusFailed: "Failed";
                readonly roomCardPreviewActorUser: "User";
                readonly roomCardPreviewPlaceholder: "No latest status in this room";
                readonly roomCardSnapshotAria: "Latest visible room state for {{name}}";
                readonly roomCardHumansCount_one: "{{count}} human";
                readonly roomCardHumansCount_other: "{{count}} humans";
                readonly roomCardAgentsCount_one: "{{count}} agent";
                readonly roomCardAgentsCount_other: "{{count}} agents";
                readonly roomCardOnline: "online";
                readonly roomCardAgentFallback: "Agent";
                readonly roomCardAgentsAria: "{{count}} active agents in {{name}}";
                readonly roomCardOpenRoomAria: "Open room {{name}}";
                readonly roomCardMoreActions: "Room actions";
                readonly roomCardRenameWorkspace: "Rename";
                readonly roomRenameDialogTitle: "Rename room";
                readonly roomRenameDialogLead: "Enter a new display name for this room.";
                readonly roomRenamePlaceholder: "Room name";
                readonly roomCardAvatarsAria: "Participant avatars for {{name}}";
                readonly roomsDirectoryLead: "Browse and open every room you have joined.";
                readonly roomsDirectoryEmpty: "No rooms yet. Create or join a room from the Start page.";
                readonly sectionTemplatesTitle: "Agent arena";
                readonly sectionOfficeSpaceTitle: "Office";
                readonly officeScenario1Title: "OPC one-person team";
                readonly officeScenario1Description: "Command multiple agents from one place to power through complex work efficiently";
                readonly officeScenario2Title: "Collaborative delegation";
                readonly officeScenario2Description: "Send tasks to agents on a friend's machine and tackle reimbursements, filing, and other chores together—with optional direct physical-terminal connections for stronger security.";
                readonly taskCenterTitle: "Collaborative delegation";
                readonly taskCenterDescription: "Start a fresh room and jump into a shared task board to sort, assign, and track work together.";
                readonly officeScenario3Title: "Organization-wide collaboration";
                readonly officeScenario3Description: "Many people and many agents collaborate in real time—process and outcomes shared across the organization";
                readonly sectionCollaborateSpaceTitle: "Development & delivery";
                readonly sectionContentCreationSpaceTitle: "Content creation";
                readonly sectionMore: "More";
                readonly sectionMoreAriaComingSoon: "More, coming soon";
                readonly sectionMoreComingSoonHint: "Coming soon";
                readonly betaGateCheckingTitle: "Checking beta access";
                readonly betaGateCheckingBody: "We are confirming whether this account already has access to Tutti beta.";
                readonly betaGateBlockedTitle: "This account does not have beta access yet";
                readonly betaGateBlockedBody: "Enter your invite code to unlock the Tutti desktop beta.";
                readonly betaGateInviteCodeLabel: "Invite code";
                readonly betaGateInviteCodePlaceholder: "Enter invite code";
                readonly betaGateInviteCodeRequired: "Enter an invite code before continuing.";
                readonly betaGateRetry: "Recheck";
                readonly betaGateSubmit: "Verify invite code";
                readonly betaGateBackToLogin: "Sign out";
                readonly betaGateSubmitting: "Verifying…";
                readonly betaGateSubmitSuccess: "Invite code accepted";
                readonly betaGateSubmitFailed: "Failed to verify invite code.";
                readonly betaGateLoadFailed: "Failed to load beta access status.";
                readonly scenarioCloneUseHint: "Clone and use scenario templates";
                readonly contentScenario1Title: "Product prototypes";
                readonly contentScenario1Description: "Product managers, designers, and intelligent agents work in sync to quickly deliver prototypes that closely match requirements.";
                readonly contentScenario2Title: "Slide decks";
                readonly contentScenario2Description: "Multiple intelligent agents collaborate—from outline and design to layout—for polished results in one flow.";
                readonly contentScenario3Title: "Video creation";
                readonly contentScenario3Description: "Different agents work together, generating scripts, storyboards, and edits in real time to ship high-quality video fast.";
                readonly templatesLoading: "Loading scenario templates…";
                readonly templatesLoadFailed: "Failed to load scenario templates.";
                readonly templatesRetry: "Retry";
                readonly templatesEmpty: "No scenario templates available right now.";
                readonly templatePlayCta: "Try it";
                readonly collaborateSlotHoverCta: "Coming soon";
                readonly scenarioBadgeCollaborate: "Collaborate";
                readonly scenarioBadgeGame: "Game";
                readonly templateVersion: "Version {{version}}";
                readonly templatePlaceholderTitle: "Scenario template";
                readonly templatePlaceholderHint: "Coming soon";
                readonly templateGomokuTitle: "Gomoku match";
                readonly templateGomokuDescription: "AI helps you decide and refine every move—push your mental edge in sharp tactical play.";
                readonly templateTexasHoldemTitle: "Texas Hold'em poker";
                readonly templateTexasHoldemDescription: "AI fights alongside you, analyzing and adjusting strategy in real time—poker smarts and mind games on full display.";
                readonly templateChineseChessTitle: "Chinese chess match";
                readonly templateChineseChessDescription: "Deep AI strategy guidance and human-like play—full human-vs-machine matchup.";
                readonly collaborateDemoBuildTitle: "Daily development";
                readonly collaborateDemoBuildDescription: "A unified collaborative environment for the entire team—tasks and context flow naturally";
                readonly collaborateDevAcceptanceTitle: "Automated testing & acceptance";
                readonly collaborateDevAcceptanceDescription: "Automatically provisions a test environment so the room can run tests and acceptance quickly";
                readonly collaborateUnifiedWorkbenchTitle: "Unified workbench";
                readonly collaborateUnifiedWorkbenchDescription: "Integrate apps and agents to orchestrate and execute tasks from one place";
                readonly intentCreateTitle: "Create a New Room";
                readonly intentCreateBody: "Invite partners and their AI agents to collaborate";
                readonly intentLocalDirTitle: "Join an Existing Room";
                readonly intentLocalDirBody: "Paste the shared link to access the room";
                readonly intentCreateSecondaryCta: "Create";
                readonly intentJoinSecondaryCta: "Join with link";
                readonly agentToolNameOpenclaw: "OpenClaw";
                readonly agentToolNameClaudeCodeRouter: "Claude Code Router";
                readonly openclawBlockTitle: "Need OpenClaw?";
                readonly openclawBlockBody: "One click enables it and saves. The next time you use Create & enter on the Start page, we install and wire it in. If it is already installed, we will keep it on for new rooms by default.";
                readonly openclawOneClickCta: "Enable OpenClaw";
                readonly openclawEnabledHint: "On — will be included for new rooms";
                readonly openclawOneClickSaveDone: "OpenClaw enabled and saved";
                readonly headline: "Start from a room canvas";
                readonly lead: "Spin up an isolated runtime for terminals and agents. Name your room to open the canvas, connect to an existing ID, or resume from recents.";
                readonly step1: "Create a room to get an isolated runtime and sandbox directory.";
                readonly step2: "Arrange terminals, tasks, and docs on the canvas; organize by partition.";
                readonly step3: "Open the canvas to run terminals and agents in your room.";
                readonly cardTitle: "Create a room";
                readonly cardHint: "Pick a name you’ll recognize in history and when collaborating.";
                readonly namePlaceholder: "e.g. acme-web-refactor";
                readonly creating: "Creating…";
                readonly createCta: "Create & open canvas";
                readonly recentTitle: "Recent";
                readonly joinWorkspaceCancel: "Cancel";
                readonly joinLinkPlaceholder: "Paste share link";
                readonly joinLinkSubmit: "Enter Now";
                readonly joinLinkParseError: "We could not read that. Paste a valid link.";
                readonly joinInviteCodeNextHint: "Room recognized. Enter the invite code to join.";
                readonly runtimeEntryNamePlaceholder: "Enter room name";
                readonly runtimeEntryCreating: "Working…";
                readonly intentEntryModalConfirm: "Confirm";
                readonly runtimeEntryCheckingBetaAccess: "Checking beta access";
                readonly runtimeEntryCreateSubmit: "Start Now";
                readonly sidebarWorkspace: "My rooms";
                readonly sidebarRecents: "Recents";
                readonly sidebarNoRecents: "No recent rooms yet.";
                readonly ownedWorkspaces: "My rooms";
                readonly sharedWorkspaces: "Shared with me";
                readonly recentWorkspaces: "Recent rooms";
                readonly unnamedWorkspace: "Untitled Room";
                readonly workspaceRoleOwner: "Owner";
                readonly workspaceRoleCollaborator: "Collaborator";
                readonly sidebarSearchPlaceholder: "Search…";
                readonly sidebarNewWorkspace: "New room";
                readonly resizeSidebar: "Resize sidebar";
                readonly sidebarDeleteWorkspace: "Delete room";
                readonly sidebarDeleteWorkspaceConfirmTitle: "Delete this room?";
                readonly sidebarDeleteWorkspaceConfirm: "“{{name}}” will be deleted for everyone in this room. This action cannot be undone.";
                readonly sidebarDeleteWorkspaceSuccess: "Room deleted.";
                readonly sidebarDeleteWorkspaceForbidden: "Only the room owner can delete this room.";
                readonly sidebarDeleteWorkspaceNotFound: "This room no longer exists.";
                readonly sidebarLeaveWorkspace: "Leave room";
                readonly sidebarLeaveWorkspaceConfirmTitle: "Leave this room?";
                readonly sidebarLeaveWorkspaceConfirm: "You will leave “{{name}}”. You can rejoin later if you still have access.";
                readonly sidebarWorkspaceAgents_one: "{{count}} agent";
                readonly sidebarWorkspaceAgents_other: "{{count}} agents";
                readonly sidebarWorkspaceDemoOnly: "Demo";
                readonly createWorkspacePaneTitle: "Create a room";
                readonly createWorkspacePaneLead: "A room is where local agents collaborate.";
                readonly createWorkspaceNameLabel: "Enter room name";
                readonly createWorkspaceSourceDirectory: "Source directory";
                readonly createWorkspaceSourceBrowse: "Browse…";
                readonly createWorkspaceSourceHint: "Agents will have read + write access to this folder.";
                readonly createWorkspaceVisibility: "Visibility";
                readonly createWorkspaceVisibilityPrivate: "Private";
                readonly createWorkspaceVisibilityPrivateHint: "Only you. No invites.";
                readonly createWorkspaceVisibilityTeam: "Team";
                readonly createWorkspaceVisibilityTeamHint: "Invite specific people.";
                readonly createWorkspaceVisibilityPublic: "Public";
                readonly createWorkspaceVisibilityPublicHint: "Anyone with the link can request to join.";
                readonly createFormCancel: "Cancel";
                readonly createFormSubmit: "Create room";
            };
            readonly connector: {
                readonly title: "Connectors";
                readonly vmManaged: "VM managed";
                readonly tabsAria: "Connector tabs";
                readonly tabMcpServers: "MCP Servers";
                readonly tabSkills: "Skills";
                readonly registryReadError: "Could not read host MCP registry: {{detail}}";
                readonly statusApplyingRuntime: "Applying MCP runtime configuration…";
                readonly statusMcpEnabledRuntimeErrors: "MCP enabled with runtime errors";
                readonly installFailedForServer: "{{serverId}} install failed";
                readonly statusMcpRuntimeConfigured: "MCP runtime configured";
                readonly statusMcpRegistrySaved: "MCP registry saved";
                readonly statusSkippedUntilSignedIn: "; skipped until signed in: {{servers}}";
                readonly statusOpeningFigmaSignIn: "Opening Figma sign-in…";
                readonly statusFigmaConnected: "Figma connected";
                readonly statusFigmaDisconnected: "Figma disconnected and removed from agents";
                readonly statusOpeningGoogleSignIn: "Opening Google sign-in…";
                readonly statusGoogleConnected: "Google connected";
                readonly statusGoogleDisconnected: "Google connector disconnected and removed from agents";
                readonly statusOpeningNotionSignIn: "Opening Notion sign-in…";
                readonly statusNotionConnected: "Notion connected";
                readonly statusNotionDisconnected: "Notion disconnected and removed from agents";
                readonly builtinSectionTitle: "Built-in MCP";
                readonly builtinSectionSubtitle: "Enable shipped servers once; tsh injects them for every agent.";
                readonly enabledCountBadge: "{{count}} enabled";
                readonly toggleApplying: "Applying…";
                readonly toggleEnabled: "Enabled";
                readonly toggleEnable: "Enable";
                readonly builtinFigmaInProgressSuffix: "(connecting)";
                readonly builtinFigmaToggleUnavailable: "Connecting";
                readonly installStatusFailed: "Install failed";
                readonly installStatusRemoteMcp: "Remote MCP";
                readonly installStatusReadyInVm: "Ready in VM";
                readonly authSignedIn: "Signed in";
                readonly authSignInRequired: "Sign-in required";
                readonly disconnect: "Disconnect";
                readonly signIn: "Sign in";
                readonly customServersHeader: "{{count}} custom servers";
                readonly addServerTitle: "Add server";
                readonly serverUntitled: "Untitled server";
                readonly detailStdioCommand: "stdio command";
                readonly detailTransportEndpoint: "{{transport}} endpoint";
                readonly emptyNoCustomServers: "No custom MCP servers yet.";
                readonly addServerCta: "Add server";
                readonly editorNewServerTitle: "New MCP server";
                readonly editorSubtitle: "Custom servers are also available to every agent.";
                readonly deleteServerTitle: "Delete server";
                readonly fieldId: "ID";
                readonly fieldName: "Name";
                readonly fieldTransport: "Transport";
                readonly fieldCommand: "Command";
                readonly fieldArgs: "Args";
                readonly fieldUrl: "URL";
                readonly placeholderServerId: "github";
                readonly placeholderServerName: "GitHub";
                readonly placeholderCommand: "npx";
                readonly placeholderArgs: "-y @modelcontextprotocol/server-github";
                readonly placeholderUrl: "https://example.com/mcp";
                readonly editorEmptyTitle: "No server selected";
                readonly skillSourceBuiltin: "Built-in";
                readonly skillSourceCustom: "Custom";
                readonly noSkillsFound: "No skills found.";
            };
        };
        readonly settingsPanel: {
            title: string;
            nav: {
                general: string;
                developer: string;
                diagnostics: string;
                agent: string;
                experimental: string;
                sectionsLabel: string;
            };
            workspace: {
                navSubtitle: string;
                navBasic: string;
                spaceNameLabel: string;
                dangerLabel: string;
                deleteAction: string;
                deleteHelp: string;
                leaveAction: string;
                leaveHelp: string;
                agentTitle: string;
                defaultAgentHelp: string;
                noEnabledAgents: string;
                noEnabledAgentsHelp: string;
                agentNotInstalledBadge: string;
                permissionLabel: string;
                permissionPreset: string;
                permissionAutoReview: string;
                permissionFullAccess: string;
                personalizationTitle: string;
            };
            general: {
                title: string;
                languageLabel: string;
                uiThemeLabel: string;
                wallpaperLabel: string;
                sshAgentForwardingTitle: string;
                sshAgentForwardingDescription: string;
                uiTheme: {
                    system: string;
                    light: string;
                    dark: string;
                };
                logs: {
                    title: string;
                    sizeLabel: string;
                    sizeValue: string;
                    summaryError: string;
                    actionsLabel: string;
                    export: string;
                    exporting: string;
                    clear: string;
                    clearing: string;
                    cleared: string;
                    saved: string;
                    copyAgentPrompt: string;
                    copiedAgentPrompt: string;
                    error: string;
                    clearError: string;
                };
            };
            agent: {
                title: string;
                defaultAgentLabel: string;
                defaultAgentHelp: string;
                moveUp: string;
                moveDown: string;
                fullAccessLabel: string;
                fullAccessHelp: string;
            };
            developer: {
                title: string;
                versionLabel: string;
                agentPresentationTitle: string;
                agentPresentationTerminal: string;
                agentPresentationGui: string;
                experimentalTitle: string;
                installDoctorTitle: string;
                installDoctorDescription: string;
                installDoctorInstall: string;
                installDoctorRepair: string;
                installDoctorInstalling: string;
                installDoctorInstalledButton: string;
                installDoctorInstalled: string;
                installDoctorError: string;
                agentGUIBatchRunnerTitle: string;
                agentGUIBatchRunnerDescription: string;
            };
            experimental: {
                title: string;
            };
        };
        readonly websiteNode: {
            back: string;
            coldStatus: string;
            forward: string;
            reload: string;
            close: string;
            urlPlaceholder: string;
            loadFailed: string;
        };
        readonly terminalNode: {
            readonly resizeWidth: "Resize terminal width";
            readonly resizeHeight: "Resize terminal height";
        };
        readonly terminalCloseGuard: {
            readonly title: "Close this terminal?";
            readonly body: "A process is still running in this terminal. Closing it will stop the session.";
            readonly cancel: "Cancel";
            readonly confirm: "Close terminal";
        };
        readonly terminalFind: {
            readonly placeholder: "Find…";
            readonly previous: "Previous match";
            readonly next: "Next match";
            readonly close: "Close";
            readonly caseSensitive: "Match case";
            readonly useRegex: "Use regular expression";
        };
        readonly terminalNodeHeader: {
            readonly directoryMismatch: "DIR MISMATCH";
            readonly directoryMismatchTitle: "Bound directory: {{executionDirectory}}\nCurrent directory: {{expectedDirectory}}";
        };
        readonly nodeDeleteDialog: {
            readonly deleteNodes_one: "Delete {{count}} node?";
            readonly deleteNodes_other: "Delete {{count}} nodes?";
            readonly deleteTask: "Delete Task?";
            readonly deleteNode: "Delete Node?";
            readonly multipleDescription: "This will permanently remove {{count}} selected nodes.";
            readonly taskDescriptionPrefix: "This will permanently remove";
            readonly nodeDescriptionPrefix: "This will permanently remove this {{kind}}:";
        };
        readonly workspaceContextMenu: {
            readonly newTerminal: "New Terminal";
            readonly newWebsite: "New Website";
            readonly newTask: "New Task";
            readonly runAgent: "Run Agent";
            readonly runAgentBlank: "Blank";
            readonly runAgentProviderSubmenu: "Choose agent provider";
            readonly convertToTask: "Convert to Task";
            readonly clearSelection: "Clear Selection";
            readonly editSelectedTask: "Edit task…";
        };
        readonly workspaceCanvas: {
            readonly selectionHint_one: "Selected {{count}} window.";
            readonly selectionHint_other: "Selected {{count}} windows.";
            readonly labelColorFilterAll: "Show all";
            readonly clearLabelColorFilter: "Clear label filter";
            readonly chatPillLabel: "#general";
            readonly chatPanelTitle: "Session";
            readonly chatOpenPanel: "Open session panel";
            readonly chatPlaceholder: "Room session is not connected yet.";
            readonly composerStatusMessage: "No agent is running in this room.";
            readonly composerUnreadCompletedPrompt: "Sessions finished — open to review.";
            readonly composerUnreadFailedPrompt: "A session needs attention — open to review.";
            readonly composerWorkingAgentsMessage_one: "{{count}} agent currently running";
            readonly composerWorkingAgentsMessage_other: "{{count}} agents currently running";
            readonly composerWaitingAgentsMessage_one: "{{count}} agent waiting for you";
            readonly composerWaitingAgentsMessage_other: "{{count}} agents waiting for you";
            readonly composerRoomWaitingAgentsMessage_one: "{{count}} agent waiting in this room";
            readonly composerRoomWaitingAgentsMessage_other: "{{count}} agents waiting in this room";
            readonly composerMessageAriaLabel: "Agent progress status";
            readonly idleDisconnectOverlay: {
                readonly title: "Room paused while idle";
                readonly description: "The sandbox was disconnected to save resources. Re-enter to continue working.";
                readonly reenter: "Re-enter room";
                readonly reconnecting: "Re-entering…";
                readonly reentered: "Room re-entered";
            };
            readonly agentActivityConversationSummaryLoadingAria: "Loading session summary";
            readonly newWindow: "New window";
            readonly closeWindowAria: "Close {{title}}";
            readonly websiteWindowTitle: "Website";
            readonly minimizedWindows: "Minimized windows";
            readonly nodeDockToolbarAriaLabel: "Workspace panes — quick add Files, terminal, browser, task, or agent; click focuses an open window or creates one if none exists; right-click is New only";
            readonly nodeDockLabel: {
                readonly terminal: "Terminal";
                readonly debugTerminal: "Debug Terminal";
                readonly website: "Browser";
                readonly task: "Task";
                readonly files: "Files";
                readonly agent: "Agent";
                readonly openclaw: "OpenClaw";
                readonly claudeCode: "Claude";
                readonly codex: "Codex";
                readonly nexightAgent: "Tutti Agent";
            };
            readonly dockPopupAgentAvailabilitySectionAria: "Availability status for {{name}}";
            readonly nodeDockContextNew: {
                readonly files: "New room file session";
                readonly terminal: "New terminal";
                readonly debugTerminal: "New debug terminal";
                readonly website: "New browser";
                readonly task: "New task";
                readonly agent: "New agent";
            };
            readonly zoomPercentInputAria: "Canvas zoom: enter a percent (e.g. 91 or 91%) or a ratio between 0 and 1; press Enter to apply";
            readonly zoomPercentInputTitle: "Double-click to reset to 100%";
            readonly runtimeStatusPanel: {
                readonly title: "Room runtime";
                readonly openComposerAria: "Open room runtime status";
                readonly close: "Close";
                readonly refresh: "Refresh status";
                readonly workspaceConnection: "Room";
                readonly runtimeConnection: "Workspace environment";
                readonly connected: "Connected";
                readonly disconnected: "Disconnected";
                readonly reconnecting: "Reconnecting…";
                readonly state: "State";
                readonly statusMessage: "Message";
                readonly workspaceRoot: "Room root";
                readonly linuxUser: "Linux user";
                readonly provider: "Provider";
                readonly sandboxId: "Sandbox";
                readonly sandboxSession: "Sandbox session";
                readonly terminals: "Terminal sessions";
                readonly runtimeId: "Runtime ID";
                readonly vsockRelay: "Vsock relay";
                readonly noData: "Status is not available.";
            };
            readonly runtimeWorkspaceDebug: {
                readonly title: "Runtime workspace debug";
                readonly close: "Close";
                readonly refresh: "Refresh";
                readonly connected: "Connected";
                readonly disconnected: "Disconnected";
                readonly vmTab: "VM";
                readonly vmOverview: "VM overview";
                readonly runtimeTrace: "VM trace";
                readonly workspaceOverview: "Workspace overview";
                readonly workspaceTrace: "Workspace trace";
                readonly vmBootPhases: "VM boot phases";
                readonly workspaceEnterTraces: "Workspace enter traces";
                readonly workspaceAttachments: "Workspace attachments";
                readonly connection: "Connection";
                readonly state: "State";
                readonly healthState: "Health state";
                readonly imageBootSource: "Image boot source";
                readonly statusMessage: "Status message";
                readonly diagnosticsStatusMessage: "Diagnostics status";
                readonly elapsed: "Elapsed";
                readonly totalElapsed: "Total elapsed";
                readonly attempt: "Attempt";
                readonly sandboxSession: "Sandbox session";
                readonly attachment: "Attachment";
                readonly attached: "Attached";
                readonly detached: "Detached";
                readonly noRuntimeTrace: "No VM trace recorded.";
                readonly noVmBootPhases: "No VM boot phases recorded.";
                readonly noWorkspaceEnters: "No workspace enter traces.";
                readonly noWorkspaceEnterPhases: "No workspace enter phases recorded.";
                readonly noWorkspaceTrace: "No workspace trace recorded.";
                readonly noWorkspaces: "No runtime workspaces.";
                readonly workspaceId: "Workspace ID";
                readonly roomName: "Room name";
                readonly mountState: "Mount state";
                readonly mountPoint: "Mount point";
                readonly sandboxId: "Sandbox ID";
                readonly websocketState: "WebSocket";
                readonly createdAt: "Created";
                readonly lastConnectedAt: "Last connected";
                readonly lastDisconnectedAt: "Last disconnected";
                readonly reconnectCount: "Reconnects";
                readonly lastError: "Last error";
                readonly vmRestartCount: "VM restarts";
            };
            readonly sandboxSessionBanner: {
                readonly reconnecting: "Sandbox reconnecting…";
                readonly disconnected: "Sandbox disconnected";
            };
            readonly applications: {
                readonly eyebrow: "Agent OS apps";
                readonly title: "Applications";
                readonly description: "Open the core room apps and preview common Agent OS workflows from one place";
                readonly launchHint: "Mock apps can be opened after you enter a room";
                readonly launchMockUnavailable: "Enter a room to open this mock application";
                readonly categoryBasic: "Basic";
                readonly categoryOffice: "Office";
                readonly categoryCreation: "Creation";
                readonly installAction: "Install";
                readonly comingSoonAction: "Coming soon";
                readonly installedAction: "Installed";
                readonly issueTitle: "Tasks";
                readonly issueDescription: "Create, assign, run, and review room tasks with agents";
                readonly vibeDesignTitle: "Vibe design";
                readonly vibeDesignDescription: "Draft product screens, interaction states, and visual directions";
                readonly vibeVideoTitle: "Video creating";
                readonly vibeVideoDescription: "Shape scripts, storyboards, edits, and final video direction";
                readonly imageGenerationTitle: "Image generation";
                readonly imageGenerationDescription: "Create visual concepts, generated assets, and prompt-driven image drafts";
                readonly textEditorTitle: "Document";
                readonly textEditorDescription: "Write and revise room notes, prompts, and lightweight documents";
                readonly pptTitle: "PPT";
                readonly pptDescription: "Create presentation outlines, slide drafts, and review-ready decks";
                readonly sheetTitle: "Sheet";
                readonly sheetDescription: "Track structured data, tables, calculations, and room planning lists";
                readonly calendarTitle: "Calendar";
                readonly calendarDescription: "Plan room milestones, follow-ups, reviews, and shared schedules";
                readonly systemMonitorTitle: "System Monitor";
                readonly systemMonitorDescription: "Inspect runtime health, resource signals, and workspace activity";
                readonly codeEditorTitle: "Code Editor";
                readonly codeEditorDescription: "Open source files, review changes, and prepare implementation notes";
                readonly chatTitle: "Chat";
                readonly chatDescription: "Coordinate room sessions, agent handoffs, and quick decisions";
                readonly mockWindowStatus: "Mock application";
                readonly mockWindowReady: "Ready for future integration";
                readonly mockDesignPreviewTitle: "Design board";
                readonly mockDesignPreviewBody: "Layout references, component states, and review notes will appear here";
                readonly mockVideoPreviewTitle: "Video timeline";
                readonly mockVideoPreviewBody: "Scenes, clips, narration, and export status will appear here";
                readonly mockImageGenerationPreviewTitle: "Image studio";
                readonly mockImageGenerationPreviewBody: "Prompts, generated previews, variations, and export history will appear here";
                readonly mockEditorPreviewTitle: "Draft document";
                readonly mockEditorPreviewBody: "Start writing room notes and agent prompts in this placeholder editor";
                readonly mockPresentationPreviewTitle: "Slide deck";
                readonly mockPresentationPreviewBody: "Slide outlines, narrative beats, and review notes will appear here";
                readonly mockSheetPreviewTitle: "Data sheet";
                readonly mockSheetPreviewBody: "Tables, calculations, filters, and room planning data will appear here";
                readonly mockCalendarPreviewTitle: "Room calendar";
                readonly mockCalendarPreviewBody: "Milestones, meetings, follow-ups, and shared schedule blocks will appear here";
                readonly mockMonitorPreviewTitle: "Runtime signals";
                readonly mockMonitorPreviewBody: "CPU, memory, network, and workspace activity signals will appear here";
                readonly mockCodePreviewTitle: "Source workspace";
                readonly mockCodePreviewBody: "Files, diffs, symbols, and implementation notes will appear here";
                readonly mockChatPreviewTitle: "Room chat";
                readonly mockChatPreviewBody: "Session threads, agent replies, and shared decisions will appear here";
            };
            readonly vmStatusIndicator: {
                readonly healthy: "VM is running and healthy";
                readonly pending: "VM is running, checking health";
                readonly unhealthy: "VM failed or health check failed";
            };
        };
        readonly labelColors: {
            readonly title: "Label Color";
            readonly autoInherit: "Auto (inherit partition)";
            readonly none: "None";
            readonly gray: "Gray";
            readonly red: "Red";
            readonly orange: "Orange";
            readonly yellow: "Yellow";
            readonly green: "Green";
            readonly blue: "Blue";
            readonly purple: "Purple";
        };
        readonly messages: {
            readonly agentLaunchFailed: "Agent launch failed: {{message}}";
            readonly agentResumeFailed: "Agent resume failed: {{message}}";
            readonly agentProviderSessionNotFound: "This session history is still available, but the underlying provider session can no longer be restored.";
            readonly agentTargetRemoved: "This agent no longer exists or has been removed. Its conversation history stays available to read.";
            readonly agentResumeSessionNotLocal: "This session cannot be resumed on this device. Start a new session and @this session to keep going.";
            readonly agentImportedSessionResumeUnavailable: "This conversation was imported successfully. Start a new session and @this conversation to keep going.";
            readonly agentSessionReconnecting: "Reconnecting to the live agent session…";
            readonly agentSettingsRequireNewSession: "This model can only be used in a new session to preserve context.";
            readonly agentProcessCleanupPending: "The previous Agent process is still shutting down. To avoid starting a duplicate process, this request was stopped. Try again shortly.";
            readonly agentConfigDependencyUnavailable: "{{provider}} configuration references a file that is unavailable. Check its local configuration and try again.";
            readonly agentSessionTitleTooLong: "Session title must be {{maxCharacters}} characters or fewer.";
            readonly agentSessionTitleTooLongWithoutLimit: "Session title is too long.";
            readonly agentPermissionModeAppliesNextTurn: "Permission mode will apply starting with your next message.";
            readonly agentThisSessionMentionLabel: "this session";
            readonly terminalLaunchFailed: "Terminal launch failed: {{message}}";
            readonly fallbackTerminalFailed: "Fallback terminal launch also failed: {{message}}";
            readonly agentPromptRequired: "Agent prompt cannot be empty.";
            readonly resumeSessionMissing: "This agent does not have a verified resumeSessionId yet.";
            readonly noTerminalSlotNearby: "No room nearby in the current view. Move or close some terminal windows first.";
            readonly noWindowSlotOnRight: "No room to the right of the current agent. Move or close some windows first.";
            readonly noWindowSlotNearby: "No room nearby in the current view. Move or close some windows first.";
            readonly agentManageSyncSuccess: "Sync success";
            readonly agentManageInstallSuccess: "Install success";
        };
    };
    readonly "zh-CN": {
        readonly common: {
            readonly add: "添加";
            readonly cancel: "取消";
            readonly clear: "清除";
            readonly close: "关闭";
            readonly confirm: "确认";
            readonly copy: "复制";
            readonly copying: "复制中...";
            readonly copyFailed: "复制失败";
            readonly create: "创建";
            readonly cut: "剪切";
            readonly delete: "删除";
            readonly deleting: "删除中...";
            readonly download: "下载";
            readonly copyImage: "复制图片";
            readonly downloadImage: "下载图片";
            readonly expandImage: "放大图片";
            readonly imageZoomPercent: "图片缩放 {{percent}}%";
            readonly error: "错误";
            readonly generateByAi: "AI 生成";
            readonly generating: "生成中...";
            readonly info: "提示";
            readonly loading: "加载中...";
            readonly maximize: "最大化";
            readonly minimize: "最小化";
            readonly minimizeImage: "缩小图片";
            readonly resetImageZoom: "重置图片缩放";
            readonly refresh: "刷新";
            readonly remove: "移除";
            readonly removing: "移除中...";
            readonly restore: "还原";
            readonly zoomInImage: "放大图片内容";
            readonly zoomOutImage: "缩小图片内容";
            readonly resetToDefault: "恢复默认";
            readonly save: "保存";
            readonly saving: "保存中...";
            readonly settings: "设置";
            readonly warning: "警告";
            readonly defaultFollowCli: "默认值（跟随 CLI）";
            readonly defaultModel: "默认模型";
            readonly followCliDefault: "跟随 CLI 默认值";
            readonly unknownError: "未知错误";
            readonly notAvailable: "无";
            readonly paste: "粘贴";
            readonly percentUnit: "%";
            readonly pixelUnit: "px";
            readonly minuteUnit: "分钟";
        };
        readonly workspaceWindowLayout: {
            readonly trigger: "窗口布局";
            readonly moveAndResize: "布局";
            readonly left: "左对齐";
            readonly right: "右对齐";
            readonly top: "上对齐";
            readonly bottom: "下对齐";
            readonly fullscreen: "全屏幕";
            readonly restore: "还原";
        };
        readonly sidebar: {
            readonly defaultAgent: "默认 Agent";
            readonly persistence: "持久化";
            readonly settings: "设置";
            readonly fallbackAgentLabel: "Agent";
            readonly status: {
                readonly working: "运行中";
                readonly standby: "待命";
            };
            readonly terminals_one: "{{count}} 个终端";
            readonly terminals_other: "{{count}} 个终端";
            readonly agents_one: "{{count}} 个 Agent";
            readonly agents_other: "{{count}} 个 Agent";
            readonly tasks_one: "{{count}} 个任务";
            readonly tasks_other: "{{count}} 个任务";
        };
        readonly appHeader: {
            readonly togglePrimarySidebar: "切换主侧边栏";
            readonly commandCenter: "命令中心";
            readonly commandCenterHint: "命令中心（{{shortcut}}）";
            readonly commandCenterFallbackTitle: "搜索";
            readonly enterFullscreen: "进入全屏";
            readonly exitFullscreen: "退出全屏";
            readonly updateAvailableShort: "更新";
            readonly updateAvailableTitle: "发现新版本 {{version}}";
            readonly updateAvailableDetail: "准备好时再开始下载，不会打断当前使用。";
            readonly updateLater: "稍后";
            readonly updateDownloadNow: "下载更新";
            readonly updateDownloadingTitle: "正在下载 {{version}}（{{percent}}）";
            readonly updateDownloadingShort: "下载更新";
            readonly updateDownloadProgress: "{{downloaded}} / {{total}}";
            readonly updateMinimize: "最小化";
            readonly restartToUpdateShort: "重启更新";
            readonly restartToUpdateTitle: "版本 {{version}} 已准备好安装";
            readonly updateReadyDetail: "重启应用后即可完成本次更新安装。";
            readonly updateRestartLater: "稍后重启";
            readonly updateInstallNow: "重启并安装";
        };
        readonly controlCenter: {
            readonly open: "控制中心";
            readonly title: "控制中心";
            readonly sidebar: "侧边栏";
            readonly theme: "主题";
            readonly agentStandbyBanner: "Agent 完成提醒";
            readonly on: "已开启";
            readonly off: "已关闭";
        };
        readonly debugWindow: {
            readonly title: "IPC 检查器";
            readonly subtitle: "用于查看渲染进程到主进程 IPC trace 的隐藏诊断窗口。";
            readonly loading: "正在加载 IPC 记录…";
            readonly unavailable: "调试窗口 bridge 不可用。";
            readonly searchPlaceholder: "搜索 channel、payload、result 或 error";
            readonly countLabel: "{{count}} 条记录";
            readonly empty: "还没有捕获到 IPC 记录。";
            readonly noSelection: "选择一条记录以查看详情。";
            readonly actions: {
                readonly pin: "置顶";
                readonly unpin: "取消置顶";
                readonly clear: "清空记录";
                readonly export: "导出 JSON";
                readonly copySelected: "复制当前记录";
            };
            readonly filters: {
                readonly kindLabel: "类型";
                readonly kindAll: "全部";
                readonly kindInvoke: "Invoke";
                readonly kindSend: "Send";
                readonly statusLabel: "状态";
                readonly statusAll: "全部";
                readonly statusOk: "成功";
                readonly statusError: "错误";
                readonly statusSent: "已发送";
            };
            readonly detail: {
                readonly summary: "摘要";
                readonly payload: "Payload";
                readonly result: "Result";
                readonly error: "Error";
                readonly channel: "Channel";
                readonly kind: "类型";
                readonly status: "状态";
                readonly startedAt: "开始时间";
                readonly completedAt: "结束时间";
                readonly duration: "耗时";
                readonly durationValue: "{{duration}} 毫秒";
            };
        };
        readonly commandCenter: {
            readonly title: "命令中心";
            readonly placeholder: "搜索房间和命令…";
            readonly empty: "没有结果。";
            readonly metaEsc: "Esc";
            readonly sections: {
                readonly commands: "命令";
            };
            readonly commands: {
                readonly openSettings: "设置";
                readonly openSettingsHint: "打开设置";
                readonly showPrimarySidebar: "显示侧边栏";
                readonly hidePrimarySidebar: "隐藏侧边栏";
                readonly togglePrimarySidebarHint: "切换主侧边栏";
            };
        };
        readonly workspaceEmptyState: {
            readonly title: "创建一个房间开始使用";
            readonly description: "每个房间都有自己的协作画布和终端。";
            readonly action: "创建房间";
        };
        readonly appMessage: {
            readonly info: "提示";
            readonly warning: "警告";
            readonly error: "错误";
        };
        readonly errorBoundary: {
            readonly title: "出现异常";
            readonly description: "渲染进程遇到了不可恢复的错误。你的房间数据仍然安全。";
            readonly reload: "重新加载";
            readonly dismiss: "忽略";
        };
        readonly agentRuntime: {
            readonly working: "运行中";
            readonly standby: "待命";
            readonly exited: "已退出";
            readonly failed: "失败";
            readonly stopped: "已停止";
            readonly restoring: "启动中";
        };
        readonly persistence: {
            readonly savedWithoutScrollback: "存储配额已达上限；已保存，但未包含终端历史。";
            readonly savedSettingsOnly: "存储配额已达上限；仅保存了设置。";
            readonly unavailable: "存储不可用；更改将不会被保存。";
            readonly limitExceeded: "超出存储限制；无法持久化房间状态。";
            readonly ioFailed: "持久化 I/O 失败：{{message}}";
            readonly failed: "持久化失败：{{message}}";
            readonly recoveryCorruptDb: "持久化数据库已损坏，现已重置。";
            readonly recoveryMigrationFailed: "持久化迁移失败，现已重置。";
        };
        readonly agentHost: {
            readonly workspaceAgentProbeQuotaCredits: "积分";
            readonly workspaceAgentProbeQuotaCreditsRemaining: "剩余 {{amount}} Credits";
            readonly workspaceAgentProbeQuotaDollarRemaining: "剩余 ${{amount}}";
            readonly workspaceAgentProbeQuotaRemaining: "剩余 {{percent}}%";
            readonly backToHome: "返回首页";
            readonly shellHostWindow: {
                readonly windowControls: "窗口控制";
            };
            readonly changeWallpaper: "更换壁纸";
            readonly wallpaperPanelTitle: "壁纸";
            readonly wallpaperOptionDefault: "默认";
            readonly wallpaperOptionOcean: "海面";
            readonly wallpaperOptionGalaxy: "星系";
            readonly wallpaperOptionSky: "云层";
            readonly wallpaperOptionPeaks: "雪峰夜空";
            readonly wallpaperOptionOrbit: "地球夜景";
            readonly wallpaperOptionSand: "流沙纹理";
            readonly wallpaperOptionDunes: "星夜沙丘";
            readonly signOut: "退出登录";
            readonly loggedOut: "已退出登录。";
            readonly sessionExpired: "登录已失效，请重新登录。";
            readonly authenticating: "处理中…";
            readonly loginTitle: "登录以继续";
            readonly loginSectionTitle: "使用你的账号继续";
            readonly loginDescription: "选择一种登录方式，在浏览器完成登录后，再返回 Tutti。";
            readonly loginBrowserHint: "选择一种登录方式，在浏览器完成认证后，再返回 Tutti。";
            readonly loginOpeningBrowser: "正在打开浏览器...";
            readonly loginContinueWithGoogle: "使用 Google 继续";
            readonly loginContinueWithGitHub: "使用 GitHub 继续";
            readonly loginGitHubHint: "GitHub 可能会直接复用浏览器里已经登录的账号，不一定会出现选账号页面。";
            readonly emailLoginTitle: "或者使用邮箱验证码";
            readonly loginDividerOr: "或邮箱";
            readonly loginAltMethodsAria: "更多登录方式";
            readonly loginAltTabEmail: "邮箱验证码";
            readonly loginAltTabLoginCode: "访问码";
            readonly loginCodeTitle: "或使用访问码";
            readonly loginCodeHint: "直接输入长期有效的访问码，即可在当前设备完成登录。";
            readonly loginCodePlaceholder: "请输入访问码";
            readonly verifyLoginCode: "确认";
            readonly loginCodeCompleted: "访问码登录完成。";
            readonly loginCodeRequired: "请输入访问码。";
            readonly emailPlaceholder: "name@example.com";
            readonly emailCodePlaceholder: "6 位验证码";
            readonly emailCodeDialogTitle: "输入验证码";
            readonly emailCodeDialogLead: "验证码已发送至 {{email}}";
            readonly emailCodeDigitAria: "验证码第 {{index}} 位";
            readonly emailCodeResendPrefix: "没有收到验证码？";
            readonly emailCodeResendAction: "重新发送";
            readonly sendEmailCode: "发送验证码";
            readonly sendEmailCodeSending: "发送中...";
            readonly verifyEmailCode: "验证并登录";
            readonly emailCodeSent: "验证码已发送。";
            readonly emailLoginCompleted: "邮箱登录完成。";
            readonly emailRequired: "请输入邮箱地址。";
            readonly emailCodeRequired: "请输入验证码。";
            readonly desktopAuthBridgeStale: "桌面端认证桥接已过期，请重启 Tutti 后重试。";
            readonly desktopActionErrorGeneric: "出错了，请稍后重试。";
            readonly desktopActionErrorGenericShort: "出错了";
            readonly desktopActionErrorUnavailable: "该功能暂不可用。";
            readonly desktopActionErrorLoginTimedOut: "登录已超时，请返回 Tutti 后重试。";
            readonly desktopActionErrorDesktopApiUnavailable: "桌面端服务正在更新，请重启 Tutti 后重试。";
            readonly desktopActionErrorPackageDownloadInterrupted: "智能体安装包下载中断。请检查网络后点击重试。";
            readonly desktopActionErrorPackageDownloadHTTPStatus: "安装包服务拒绝了下载请求。请稍后重试，或联系支持人员。";
            readonly desktopActionErrorPackageDownloadInvalid: "下载的安装包未通过完整性校验。请重新下载。";
            readonly desktopActionErrorPackageDownloadDisk: "无法写入安装包缓存。请检查磁盘空间和目录权限。";
            readonly productNameCanvas: "Tutti";
            readonly applications: {
                readonly eyebrow: "Agent OS 应用";
                readonly title: "应用中心";
                readonly description: "从一个入口打开房间关键应用，并预览 Agent OS 常用工作流";
                readonly launchHint: "Mock 应用进入房间后即可打开";
                readonly launchMockUnavailable: "进入房间后可以打开这个 Mock 应用";
                readonly categoryBasic: "基础";
                readonly categoryOffice: "办公";
                readonly categoryCreation: "创作";
                readonly installAction: "安装";
                readonly comingSoonAction: "即将上线";
                readonly installedAction: "已安装";
                readonly issueTitle: "任务中心";
                readonly issueDescription: "创建、分派、运行并验收房间内的任务";
                readonly vibeDesignTitle: "Vibe 设计";
                readonly vibeDesignDescription: "生成产品界面、交互状态和视觉方向草案";
                readonly vibeVideoTitle: "视频创作";
                readonly vibeVideoDescription: "组织脚本、分镜、剪辑和最终视频方向";
                readonly imageGenerationTitle: "图片生成";
                readonly imageGenerationDescription: "创建视觉概念稿、生成图片素材";
                readonly textEditorTitle: "文档";
                readonly textEditorDescription: "编写和整理房间笔记、提示词与轻量文档";
                readonly pptTitle: "PPT";
                readonly pptDescription: "创建演示大纲、幻灯片草稿";
                readonly sheetTitle: "表格";
                readonly sheetDescription: "整理结构化数据、表格、计算和房间计划清单";
                readonly calendarTitle: "日程";
                readonly calendarDescription: "规划房间里程碑、跟进任务、评审和共享日程";
                readonly systemMonitorTitle: "系统监控";
                readonly systemMonitorDescription: "查看运行时健康度、资源信号和工作区活动";
                readonly codeEditorTitle: "代码编辑器";
                readonly codeEditorDescription: "打开源码文件、审阅变更并整理实现备注";
                readonly chatTitle: "聊天";
                readonly chatDescription: "协同房间对话、Agent 交接和快速决策";
                readonly mockWindowStatus: "Mock 应用";
                readonly mockWindowReady: "等待后续接入";
                readonly mockDesignPreviewTitle: "设计看板";
                readonly mockDesignPreviewBody: "这里将展示布局参考、组件状态和评审备注";
                readonly mockVideoPreviewTitle: "视频时间线";
                readonly mockVideoPreviewBody: "这里将展示场景、片段、旁白和导出状态";
                readonly mockImageGenerationPreviewTitle: "图片工作室";
                readonly mockImageGenerationPreviewBody: "这里将展示提示词、生成预览、变体和导出记录";
                readonly mockEditorPreviewTitle: "草稿文档";
                readonly mockEditorPreviewBody: "可以在这个占位编辑器里组织房间笔记和 Agent 提示词";
                readonly mockPresentationPreviewTitle: "幻灯片 Deck";
                readonly mockPresentationPreviewBody: "这里将展示幻灯片大纲、叙事节奏和评审备注";
                readonly mockSheetPreviewTitle: "数据表格";
                readonly mockSheetPreviewBody: "这里将展示表格、计算、筛选和房间计划数据";
                readonly mockCalendarPreviewTitle: "房间日历";
                readonly mockCalendarPreviewBody: "这里将展示里程碑、会议、跟进任务和共享日程块";
                readonly mockMonitorPreviewTitle: "运行时信号";
                readonly mockMonitorPreviewBody: "这里将展示 CPU、内存、网络和工作区活动信号";
                readonly mockCodePreviewTitle: "源码工作区";
                readonly mockCodePreviewBody: "这里将展示文件、Diff、符号和实现备注";
                readonly mockChatPreviewTitle: "房间聊天";
                readonly mockChatPreviewBody: "这里将展示对话线程、Agent 回复和共享决策";
            };
            readonly workspaceTerminalsBadge_one: "{{count}} 个终端";
            readonly workspaceTerminalsBadge_other: "{{count}} 个终端";
            readonly workspaceCenterSearchAria: "打开房间搜索";
            readonly workspaceCenterSearchTitle: "在当前房间搜索节点、分区与便签";
            readonly agentGui: {
                readonly conversationFilterCodex: "Codex";
                readonly conversationFilterClaudeCode: "Claude Code";
                readonly conversationFilterOpenCode: "OpenCode";
                readonly conversationFilterTutti: "Tutti";
                readonly conversationFilterCursor: "Cursor";
                readonly conversationFilterNexight: "Nexight";
                readonly conversationFilterHermes: "Hermes Agent";
                readonly conversationFilterOpenClaw: "OpenClaw";
                readonly manageAgents: "Agent 栏展示设置";
                readonly manageAgentsTitle: "Agent 栏展示设置";
                readonly manageAgentsDescription: "拖拽调整顺序或在可用与停用分组间移动，长按 Agent 可进入编辑。";
                readonly manageAgentsAvailable: "可用 Agent";
                readonly manageAgentsDisabled: "停用 Agent";
                readonly manageAgentsNoAvailable: "可从下方停用列表添加 Agent。";
                readonly manageAgentsNoDisabled: "可以把不希望展示在侧边栏的agent拖到这里";
                readonly manageAgentsKeepOneAvailable: "至少保留一个可用 Agent。";
                readonly manageAgentsRunningBlocked: "{{agent}} 正在运行，暂时无法停用。请等待任务结束后再试。";
                readonly removeAgentFromSidebar: "从左侧栏移除 {{agent}}";
                readonly addAgentToSidebar: "将 {{agent}} 添加到左侧栏";
                readonly dragAgentToReorder: "拖拽 {{agent}} 调整顺序";
                readonly addContentResourcePanel: "资源面板";
                readonly addContentConnectors: "连接器";
                readonly addContentConnectorConnected: "已授权";
                readonly addContentConnectorSelected: "已选中";
                readonly addContentConnectorConnect: "安装";
                readonly addContentConnectorAuthorize: "授权";
                readonly addContentConnectorEmpty: "暂无连接器";
                readonly addContentConnectorMore: "查看更多连接器";
                readonly composerFileStillPreparing: "附件还在准备中，完成后才能打开。";
                readonly composerFileOpenFailed: "这个附件准备失败了，请删除后重新添加。";
                readonly composerFileOpenUnavailable: "这个附件还没有可打开的路径，请删除后重新添加。";
                readonly directoryPicker: {
                    readonly confirm: "选择目录";
                    readonly emptySearch: "没有匹配的目录";
                    readonly searchPlaceholder: "搜索目录";
                    readonly title: "选择项目目录";
                };
                readonly referencePicker: {
                    readonly clearFilter: "清除筛选";
                    readonly confirm: "引用文件";
                    readonly emptyDirectory: "当前目录为空";
                    readonly emptyPreview: "选择一个文件查看详情";
                    readonly emptySearch: "没有匹配的文件或文件夹";
                    readonly fileTypeAll: "全部类型";
                    readonly fileTypeDocument: "文档";
                    readonly fileTypeImage: "图片";
                    readonly fileTypeOther: "其他";
                    readonly fileTypeSeparator: "、";
                    readonly fileTypeVideo: "视频";
                    readonly fileTypeWebpage: "网页";
                    readonly loadMore: "加载更多";
                    readonly loadMoreGroups: "拉取更多";
                    readonly loading: "正在加载";
                    readonly loadError: "加载内容失败，请稍后重试";
                    readonly previewBinary: "这个文件更像二进制内容";
                    readonly previewDecodeFailed: "暂时无法按 UTF-8 文本解码这个文件";
                    readonly previewError: "加载预览失败";
                    readonly previewFileTooLarge: "这个文件超过了 {{maxSize}}";
                    readonly previewFolder: "暂不支持预览文件夹";
                    readonly previewHierarchy: "所属层级";
                    readonly previewLoading: "正在加载预览";
                    readonly previewModified: "产出时间";
                    readonly previewSize: "文件大小";
                    readonly previewSource: "产出来源";
                    readonly previewTextTooLarge: "这个文本文件超过了 {{maxSize}}";
                    readonly previewTooLarge: "文件过大，无法预览";
                    readonly previewUnavailable: "当前工作区无法预览文件";
                    readonly previewUnsupported: "暂不支持预览这种文件类型";
                    readonly searchPlaceholder: "搜索文件和文件夹";
                    readonly selectGroupHint: "从左侧选择一个目录";
                    readonly selectedCount: "已选择 {{count}} 项";
                    readonly title: "选择工作区引用";
                    readonly sourceColumn: "分类";
                };
                readonly visibleErrorStartFailed: "{{provider}} 启动失败";
                readonly visibleErrorRequestFailed: "{{provider}} 请求失败";
                readonly visibleErrorAuthRequired: "{{provider}} 需要认证或配置";
                readonly visibleErrorAuthRequiredLocalAgentHint: "请在本地登录 {{provider}}，然后重试。";
                readonly visibleErrorSharedCallerHint: "请联系分享者完成处理后再试。";
                readonly visibleErrorRequestTimedOut: "{{provider}} 请求超时";
                readonly visibleErrorRuntimeUnavailable: "{{provider}} 因运行环境不可用而无法启动";
                readonly visibleErrorQuotaOrRateLimit: "{{provider}} 请求失败：额度或频率限制已触发";
                readonly visibleErrorSubscriptionRequired: "{{provider}} 需要有效订阅，或当前套餐不支持此请求";
                readonly visibleErrorModelNotAllowed: "{{provider}} 当前账号无法使用所选模型";
                readonly visibleErrorPluginUnavailable: "{{provider}} 暂时无法使用可选集成";
                readonly visibleErrorSessionInterrupted: "{{provider}} 在完成前意外停止，请重试";
                readonly visibleErrorDetails: "查看详情";
                readonly visibleErrorRawDetails: "原始错误";
                readonly visibleErrorCliNotFound: "未检测到 {{provider}} CLI，无法运行。请先完成安装。";
                readonly visibleErrorVersionUnsupported: "当前 {{provider}} 版本过旧，不支持此请求。请先升级。";
                readonly visibleErrorNetwork: "{{provider}} 无法连接网络以完成此请求。";
                readonly visibleErrorConfigTimeout: "{{provider}} 在请求超时前未能应用会话设置。请稍后重试。";
                readonly visibleErrorStreamDisconnected: "{{provider}} 的响应在完成前被中断。请稍后重试。";
                readonly visibleErrorEmptyResponse: "{{provider}} 没有返回响应，请检查提供商设置或重试";
                readonly visibleErrorConcurrencyLimit: "{{provider}} 当前处理的请求过多。请在其他任务完成后再试。";
                readonly visibleErrorInsufficientCreditsUnknown: "{{provider}} 的积分或账户余额不足，无法继续";
                readonly visibleErrorActionInstall: "去连接";
                readonly visibleErrorActionUpgrade: "去升级";
                readonly visibleErrorActionRelogin: "登录";
                readonly visibleErrorActionCheckNetwork: "检测网络";
                readonly visibleErrorActionDetect: "打开检测";
                readonly systemNoticeTransportRetry: "Agent 连接中断，正在重连";
                readonly systemNoticeTransportFallback: "Agent 已切换到 HTTPS 传输";
                readonly systemNoticePlanImplementationPendingConfirmation: "计划实现正在等待确认";
                readonly systemNoticePlanImplementationCompleted: "计划实现已开始";
                readonly systemNoticeWarning: "Agent 警告";
                readonly systemNoticeDefault: "Agent 通知";
                readonly contextCompactionInProgress: "正在压缩上下文";
                readonly contextCompactionCompleted: "已压缩上下文";
                readonly contextCompactionInterrupted: "上下文压缩已中断";
                readonly contextHandoffRequired: "当前对话已达到上下文上限";
                readonly contextHandoffRequiredDetail: "当前对话无法继续，请新建对话，并在新对话中 @当前对话 以交接上下文";
                readonly sharedDeviceLabel: "共享设备";
                readonly agentSharingRevoked: "{{owner}} 已取消共享该智能体";
                readonly runtimeConnecting: "正在连接 {{device}}…";
                readonly runtimeReconnectingAttempt: "正在重新连接 {{device}} · 第 {{attempt}} 次重试…";
                readonly runtimeUnavailable: "与 {{device}} 的连接已断开，系统将自动重试";
                readonly runtimeUnavailableActive: "与 {{device}} 的连接已断开，暂时无法发送或停止；任务可能仍在设备上运行";
                readonly runtimeSynchronizingProgress: "正在同步最新任务进度…";
                readonly interactionSynchronizing: "正在同步共享 Agent 状态，请稍后重试";
                readonly interactionOwnerOffline: "共享 Agent 的 Owner 当前离线";
                readonly interactionBindingRevoked: "共享 Agent 已失效，暂不可操作";
                readonly slashCommandPalette: "斜杠菜单";
                readonly skillPickerPalette: "技能";
                readonly slashPaletteCommandsGroup: "命令";
                readonly slashPaletteCapabilitiesGroup: "能力";
                readonly slashPaletteCapabilitiesLoading: "能力加载中…";
                readonly slashPaletteSkillsGroup: "技能";
                readonly slashPalettePluginsGroup: "插件";
                readonly slashPaletteConnectorsGroup: "连接器";
                readonly slashPaletteConnectorConnected: "已授权";
                readonly slashPaletteConnectorNotConnected: "安装";
                readonly slashPaletteConnectorUnsupported: "不支持";
                readonly slashPaletteMcpGroup: "MCP";
                readonly moreSessionActions: string;
                readonly copiedToClipboard: string;
                readonly copyFailed: string;
                readonly copyAsMarkdown: string;
                readonly copyAsReference: string;
                readonly markSessionUnread: string;
                readonly retryConversations: string;
                readonly conversationCopyImage: string;
                readonly conversationCopyMentionPrefix: string;
                readonly conversationCopyFile: string;
                readonly conversationCopyPreviousMessages: string;
                readonly conversationCopyImagesOmitted: string;
                readonly conversationCopyInProgress: string;
                readonly sessionActionUnavailable: string;
                readonly collaborationModeConsult: "咨询";
                readonly collaborationModeFork: "Fork";
                readonly collaborationModeDelegate: "委派";
                readonly collaborationModeHandoff: "Handoff";
                readonly collaborationTriggerUser: "手动";
                readonly collaborationTriggerAgent: "Agent";
                readonly collaborationTriggerPolicy: "策略";
                readonly collaborationStatusRunning: "进行中";
                readonly collaborationStatusCompleted: "已完成";
                readonly collaborationStatusFailed: "失败";
                readonly collaborationStatusCanceled: "已取消";
                readonly collaborationPlanLabel: "方案：{{name}}";
                readonly collaborationUsageTokens: "Tokens：输入 {{input}} · 输出 {{output}}";
                readonly collaborationFailureReason: "失败原因：{{reason}}";
                readonly collaborationResultShow: "查看结果";
                readonly collaborationResultHide: "收起结果";
                readonly collaborationAdopt: "采纳";
                readonly collaborationReject: "不采纳";
                readonly collaborationAdopted: "已采纳";
                readonly collaborationRejected: "未采纳";
                readonly collaborationAdoptionFailed: "记录采纳状态失败";
                readonly composerModelPlanBadge: "方案：{{name}}";
                readonly composerModelSearchPlaceholder: "搜索模型";
                readonly composerModelSearchEmpty: "没有匹配的模型";
                readonly composerModelFavoritesGroup: "收藏";
                readonly composerModelRecentsGroup: "最近使用";
                readonly composerModelSwitchNextTurnHint: "下一次调用生效";
                readonly composerModelFavoriteAdd: "添加到收藏";
                readonly composerModelFavoriteRemove: "取消收藏";
                readonly consultEntryLabel: "咨询模型";
                readonly consultDialogTitle: "咨询模型";
                readonly consultPlanLabel: "方案";
                readonly consultModelLabel: "模型";
                readonly consultQuestionLabel: "问题";
                readonly consultQuestionPlaceholder: "向其他模型咨询建议…";
                readonly consultIncludeContextLabel: "附带当前会话最后回复作为上下文";
                readonly consultSubmit: "发起咨询";
                readonly consultSubmitting: "咨询中…";
                readonly mentionFilterCollab: "协作";
                readonly mentionGroupCollabSessions: "协作会话";
                readonly mentionEmptyCollabSessions: "暂无协作会话";
                readonly mentionCollaboratorFallback: "协作者";
                readonly loadingOptions: string;
                readonly composerOptionsLoadFailed: string;
                readonly composerOptionsRetry: string;
                readonly composerOptionsRetryTooltip: string;
                readonly sendFailed: string;
                readonly returnToConversation: string;
                readonly continueAnswering: string;
                readonly inheritedUnavailable: string;
                readonly modelConsumptionSpeedLabel: string;
                readonly modelConsumptionMultiplierSuffix: string;
                readonly projectLocked: string;
                readonly projectMissingDescription: string;
                readonly sessionLaunchModeLabel: string;
                readonly sessionLaunchModeLocal: string;
                readonly sessionLaunchModeWorktree: string;
                readonly sideCommandDescription: "从当前实时上下文打开一个临时会话";
                readonly sidePanelTitle: "Side 临时会话";
                readonly sideEmptyTitle: "Side 临时会话";
                readonly sideEmptyDescription: "Side 会话为临时内容，关闭应用后将消失";
                readonly sideInputPlaceholder: "追问一个相关问题";
                readonly sideResize: "调整 Side 会话宽度";
                readonly sideCollapse: "收起 Side 会话";
                readonly selectionAddToConversation: "添加到对话";
                readonly selectionAskInSide: "在侧边聊天中提问";
                readonly selectionReferenceCountOne: "1 个已选文件片段";
                readonly selectionReferenceCountMany: "{{count}} 个已选文件片段";
                readonly sideInteractionTitle: "Side 需要你的响应";
                readonly sideContentUnsupported: "Side 临时会话暂不支持这种附件类型";
                readonly sideOperationFailed: "Side 会话未能完成该操作，请关闭后重试";
                readonly homeSuggestionsClose: "收起建议";
                readonly homeSuggestions: {
                    readonly about: {
                        readonly title: "认识 Tutti";
                        readonly prompt: "介绍一下 Tutti 能帮我做些什么";
                    };
                    readonly cloneGithubRepository: {
                        readonly title: "克隆 GitHub 仓库";
                        readonly prompt: "帮我克隆 GitHub 仓库 { 仓库地址 }，完成后告诉我仓库目录";
                    };
                    readonly breakdown: {
                        readonly title: "任务拆解";
                        readonly taskCenterLabel: "任务管理";
                        readonly prompt: "使用 {{taskCenterMention}} 帮我拆解任务，任务主题 { 请输入 }";
                    };
                    readonly review: {
                        readonly title: "质量审查";
                        readonly prompt: "让 { @agent } 审查 { @agent 会话 } 的产物质量";
                    };
                    readonly interaction: {
                        readonly title: "Agent 互动";
                        readonly prompt: "让 { @agent } 和 { @agent } 一起 { 做些什么 }，主题 { 请输入 }";
                    };
                    readonly import: {
                        readonly title: "导入会话";
                    };
                };
                readonly imageDownloaded: "图片已下载";
                readonly imageLoadFailed: "图片加载失败";
                readonly imageTemporarilyUnavailable: "图片暂时无法查看";
                readonly retryImage: "重试";
                readonly codexSaverModeLabel: "Codex 省额度模式";
                readonly codexSaverModeDescription: "主模型保持不变；合适的独立子任务改用 Luna Max，按当前额度口径约为 Sol High 的 1/10。实际效果与速度因任务而异。";
                readonly initialPlaceholder: "输入 @ 引用会话、文件、任务和应用";
                readonly followupPlaceholder: "要求 {{provider}} 继续后续变更";
                readonly installRequiredPlaceholder: "请先连接 {{provider}}，然后再发送消息";
                readonly installRequiredAction: "安装";
                readonly providerGateCheckingTitle: "正在检查 Agent";
                readonly providerGateCheckingDescription: "稍等一下，我们正在确认 {{provider}} 是否已经可用。";
                readonly providerGateCheckingAgentsDescription: "稍等一下，我们正在确认 agents 是否已经可用。";
                readonly providerGateInstallTitle: "先连接 {{provider}}";
                readonly providerGateInstallDescription: "需要先连接 {{provider}}，才能在这里开始新的对话。";
                readonly providerGateInstallAction: "安装";
                readonly providerGateLoginTitle: "登录 {{provider}}";
                readonly providerGateLoginDescription: "使用账号登录后即可开始使用 {{provider}} 对话";
                readonly providerGateLoginAction: "登录";
                readonly providerGateModelPlanAction: "使用自己的模型";
                readonly providerGateComingSoonTitle: "{{provider}} 即将上线";
                readonly providerGateComingSoonDescription: "{{provider}} 暂未开放。准备好后即可在这里使用这个 Agent。";
                readonly providerGateComingSoonAction: "coming soon";
                readonly providerGateUnavailableTitle: "{{provider}} 暂时还不可用";
                readonly providerGateUnavailableDescription: "我们还不能确认 {{provider}} 已准备好，可以再检测一次。";
                readonly providerGateRetryAction: "重新检测";
                readonly providerGateRuntimeSelectionTitle: "选择要使用的 {{provider}}";
                readonly providerGateRuntimeSelectionDescription: "检测到多个 {{provider}}，选择其中一个即可继续使用。";
                readonly providerGateRuntimeSelectionAction: "去选择";
                readonly providerGatePendingInstall: "正在连接…";
                readonly providerGatePendingLogin: "正在打开登录…";
                readonly providerGatePendingRefresh: "正在检测…";
                readonly targetSetupTitle: "设置 {{provider}}";
                readonly targetSetupDescription: "已经安装了 {{provider}}？Tutti 可以直接使用，也可以为你安装";
                readonly targetSetupAuthRequired: "运行时已安装并通过 ACP 检测，但仍需完成登录";
                readonly targetSetupReady: "已检测到运行时，可重新检测或重新登录";
                readonly targetSetupOpen: "打开设置";
                readonly targetSetupRemaining: "完成以下步骤后即可使用 {{provider}}";
                readonly targetSetupComplete: "{{provider}} 已就绪";
                readonly targetSetupLoggedInAccount: "已登录账号";
                readonly targetSetupStage: {
                    readonly detect: "检测运行时";
                    readonly install: "安装运行时";
                    readonly login: "登录";
                };
                readonly targetSetupChecking: "正在检测本地和 Tutti 托管运行时…";
                readonly targetSetupInstall: "安装运行时";
                readonly targetSetupReinstall: "重新安装运行时";
                readonly targetSetupStarting: "正在启动安装…";
                readonly targetSetupAuthMethod: "登录方式";
                readonly targetSetupAuthenticate: "继续登录";
                readonly targetSetupReauthenticate: "重新登录";
                readonly targetSetupAuthStarting: "正在打开登录…";
                readonly targetSetupAuthFailed: "登录未完成";
                readonly targetSetupNoAuthMethods: "运行时未返回支持的登录方式，请重新检测";
                readonly targetSetupTerminalAuthHint: "该登录方式需要在终端中完成。在终端运行以下命令，按提示完成登录后，回到这里点击「重新检测」";
                readonly targetSetupCopyCommand: "复制命令";
                readonly targetSetupCommandCopied: "已复制";
                readonly targetSetupTerminalLoginStart: "开始登录";
                readonly targetSetupTerminalLoginWaiting: "已在工作台中打开终端，请在终端中按提示完成登录，这里会自动检测登录状态";
                readonly targetSetupTerminalLoginCancel: "取消";
                readonly targetSetupTerminalLoginTimedOut: "等待登录完成超时，请重试";
                readonly targetSetupTerminalLoginUnavailable: "无法在此窗口打开终端，请复制命令后在自己的终端中执行";
                readonly targetSetupRetry: "重新检测";
                readonly targetSetupFailed: "运行时设置失败";
                readonly targetSetupPhase: {
                    readonly preparing: "正在准备安装…";
                    readonly installing: "正在安装固定版本…";
                    readonly verifying: "正在验证运行时版本…";
                    readonly probing: "正在检测 ACP 兼容性…";
                    readonly activating: "正在启用托管运行时…";
                    readonly authenticating: "正在等待登录完成…";
                    readonly complete: "安装完成";
                };
                readonly collaboratorSessionReadOnlyPlaceholder: "非当前用户会话，不可直接对话";
                readonly send: "发送";
                readonly modelLabel: "模型";
                readonly modelSelectionLabel: "模型选择";
                readonly defaultModel: "默认模型";
                readonly reasoningLabel: "推理强度";
                readonly reasoningDegreeLabel: "推理程度";
                readonly reasoningOptionDefault: "默认";
                readonly reasoningOptionMinimal: "最低";
                readonly reasoningOptionLow: "低";
                readonly reasoningOptionMedium: "中";
                readonly reasoningOptionHigh: "高";
                readonly reasoningOptionXHigh: "超高";
                readonly reasoningOptionMax: "最高";
                readonly reasoningOptionUltra: "极致";
                readonly speedLabel: "速度";
                readonly speedSelectionLabel: "速度";
                readonly speedOptionStandard: "标准";
                readonly speedOptionStandardDescription: "标准速度";
                readonly speedOptionFast: "快速";
                readonly speedOptionFastDescription: "1.5 倍速度，用量增加";
                readonly permissionModeReadOnly: "请求批准";
                readonly permissionModeAuto: "替我审批";
                readonly permissionModeFullAccess: "完全访问权限";
                readonly permissionModeChangeUnavailableDuringTurn: "无法在运行过程中切换权限";
                readonly fullAccessWarning: {
                    readonly title: "确定启用完全访问权限吗？";
                    readonly description: "完全访问权限允许 Codex 无需你的批准即可操作这台电脑。";
                    readonly filesTitle: "文件和文件夹";
                    readonly filesDescription: "读取、创建、修改或删除这台电脑上任意位置的文件。";
                    readonly commandsTitle: "终端命令";
                    readonly commandsDescription: "运行命令并更改系统设置。";
                    readonly internetTitle: "互联网访问";
                    readonly internetDescription: "访问网站并通过互联网发送数据。";
                    readonly riskDescription: "近期版本的 Codex，尤其在使用 GPT-5.6 系列模型时，可能会超出你的意图，误删或覆盖文件。仅在你理解并接受此风险时继续。";
                    readonly learnMore: "了解详情";
                    readonly cancel: "取消";
                    readonly confirm: "启用完全访问权限";
                };
                readonly fullAccessRestoredWarning: {
                    readonly title: "完全访问权限已开启";
                    readonly description: "Codex 可以在未经你同意的情况下运行命令、使用互联网，以及在这台电脑的任意位置创建、修改、上传或删除文件。这可能导致数据丢失，也会带来提示词注入风险。";
                    readonly dontShowAgain: "不再显示";
                    readonly dismissLabel: "关闭完全访问权限警告";
                };
                readonly permissionSemantics: {
                    readonly "ask-before-write": {
                        readonly label: "请求批准";
                        readonly description: "编辑外部文件和使用互联网时始终询问";
                    };
                    readonly "accept-edits": {
                        readonly label: "接受编辑";
                        readonly description: "允许直接编辑文件，但更高风险操作仍会先询问你";
                    };
                    readonly "locked-down": {
                        readonly label: "不再询问";
                        readonly description: "不会弹出确认；未获允许的操作会被直接拒绝";
                    };
                    readonly auto: {
                        readonly label: "替我审批";
                        readonly description: "仅对检测到的风险操作请求批准";
                    };
                    readonly "full-access": {
                        readonly label: "完全访问权限";
                        readonly description: "可不受限制地访问互联网和您电脑上的任何文件";
                    };
                    readonly unconfigurable: {
                        readonly label: "固定模式";
                        readonly description: "这个 provider 当前不支持在这里调整权限模式";
                    };
                };
                readonly permissionModes: {
                    readonly codex: {
                        readonly "read-only": {
                            readonly label: "请求批准";
                            readonly description: "编辑外部文件和使用互联网时始终询问";
                        };
                        readonly auto: {
                            readonly label: "替我审批";
                            readonly description: "仅对检测到的风险操作请求批准";
                        };
                        readonly "full-access": {
                            readonly label: "完全访问权限";
                            readonly description: "可不受限制地访问互联网和您电脑上的任何文件";
                        };
                    };
                    readonly cursor: {
                        readonly "read-only": {
                            readonly label: "只读";
                            readonly description: "Cursor 只读取和规划，提出修改建议但不做任何更改。";
                        };
                        readonly agent: {
                            readonly label: "请求批准";
                            readonly description: "完整工具权限；Cursor 在运行命令等高风险操作前会先询问你。";
                        };
                        readonly "full-access": {
                            readonly label: "完全访问";
                            readonly description: "无需询问直接运行命令，除非被你的 Cursor 权限规则明确拒绝。";
                        };
                    };
                    readonly opencode: {
                        readonly "read-only": {
                            readonly label: "只读";
                            readonly description: "允许读取和搜索本地项目，拒绝修改、命令、网络及其他需授权操作";
                        };
                        readonly ask: {
                            readonly label: "询问";
                            readonly description: "读取和搜索直接执行，修改、命令、网络及其他操作会先询问你";
                        };
                        readonly "full-access": {
                            readonly label: "完全访问";
                            readonly description: "自动允许需授权操作，但不会改变 OpenCode 独立的 Plan 模式限制";
                        };
                    };
                    readonly nexight: {
                        readonly "read-only": {
                            readonly label: "请求批准";
                            readonly description: "编辑外部文件或使用互联网前始终询问你";
                        };
                        readonly auto: {
                            readonly label: "替我审批";
                            readonly description: "仅在检测到可能不安全的操作时询问你";
                        };
                        readonly "full-access": {
                            readonly label: "完全访问";
                            readonly description: "可不受限制地访问互联网和你电脑上的任何文件";
                        };
                    };
                    readonly "claude-code": {
                        readonly default: {
                            readonly label: "默认权限";
                            readonly description: "默认较保守；需要执行修改或高风险操作时会先询问你。";
                        };
                        readonly acceptEdits: {
                            readonly label: "接受编辑";
                            readonly description: "允许直接修改文件；遇到更高风险操作时仍会先询问你。";
                        };
                        readonly dontAsk: {
                            readonly label: "不再询问";
                            readonly description: "不会弹出确认；未预先允许的操作会被直接拒绝。";
                        };
                        readonly bypassPermissions: {
                            readonly label: "绕过权限";
                            readonly description: "尽量不做权限拦截，适合需要连续执行且你完全信任的任务。";
                        };
                    };
                    readonly hermes: {
                        readonly yolo: {
                            readonly label: "固定模式";
                            readonly description: "当前 provider 不支持在这里调整权限模式。";
                        };
                    };
                };
                readonly modelContextWindowSuffix: "上下文窗口";
                readonly modelTooltipVersionLabel: "版本";
                readonly modelDescriptions: {
                    readonly frontierComplexCoding: "适合复杂编码、研究和真实工作场景的前沿模型";
                    readonly everydayCoding: "适合日常编码的强力模型";
                    readonly smallFastCostEfficient: "小型、快速且成本高效，适合较简单的编码任务";
                    readonly codingOptimized: "面向编码优化的模型";
                    readonly ultraFastCoding: "超快编码模型";
                    readonly professionalLongRunning: "针对专业工作和长时间运行的 Agent 优化";
                };
                readonly permissionLabel: "运行权限";
                readonly planModeLabel: "计划模式";
                readonly normalModeLabel: "普通";
                readonly normalModeDescription: "直接执行请求";
                readonly tuttiModeLabel: "Tutti Mode";
                readonly tuttiModeDescription: "输入你想做的，Tutti 会规划、拆分任务，并分派给合适的 Agent 和模型";
                readonly tuttiModeRemove: "关闭 Tutti mode";
                readonly tuttiBudgetTitle: "Tutti 偏好";
                readonly tuttiBudgetEffectLabel: "效果";
                readonly tuttiBudgetSpeedLabel: "速度";
                readonly tuttiBudgetPreviewHint: "实际并行数量取决于任务依赖";
                readonly tuttiBudgetPreviewCost: "经济型";
                readonly tuttiBudgetPreviewBalance: "均衡型";
                readonly tuttiBudgetPreviewPowerful: "强劲型";
                readonly tuttiBudgetModelPreferenceLabel: "模型策略";
                readonly tuttiBudgetModelPreferenceCost: "经济模型";
                readonly tuttiBudgetModelPreferenceBalance: "均衡模型";
                readonly tuttiBudgetModelPreferencePowerful: "最强模型";
                readonly tuttiBudgetParallelismLabel: "并行目标";
                readonly tuttiBudgetParallelismValue: "最多 {{count}} 个 Agent";
                readonly tuttiBudgetParallelismValue_one: "{{count}} 个 Agent";
                readonly tuttiBudgetParallelismValue_other: "最多 {{count}} 个 Agent";
                readonly tuttiModeUpdateFailed: "Tutti 模式更新失败，请重试";
                readonly tuttiModeUpdateUncertain: "Tutti 模式状态仍在确认中，请稍后重试";
                readonly tuttiModePlan: {
                    readonly taskReview: "计划确认";
                    readonly cancel: "取消计划";
                    readonly reviewHint: "等待确认";
                    readonly reviewHintReplan: "偏好有变";
                    readonly materializingTitle: "正在创建任务";
                    readonly switchToSelfReview: "切换为自主审核";
                    readonly switchingToSelfReview: "正在切换为自主审核";
                    readonly selfReviewEnabled: "已启用自主审核";
                    readonly selfReviewFailed: "启用自主审核失败";
                    readonly materializingHint: "正在将已接受的计划转换为可执行任务";
                    readonly errorTitle: "工作流暂不可用";
                    readonly expand: "展开工作流";
                    readonly collapse: "收起工作流";
                    readonly sendAccept: "接受";
                    readonly sendRequestChanges: "请求修改";
                    readonly replanFeedback: "偏好已从效果 {{fromEffect}} / 速度 {{fromSpeed}} 调整为效果 {{toEffect}} / 速度 {{toSpeed}}。请重新规划模型选择和随效果变化的任务验证";
                    readonly replanFeedbackSuffix: "（当前偏好为效果 {{effect}} / 速度 {{speed}}，请一并重新规划模型选择和任务验证）";
                    readonly tasks: "任务";
                    readonly priority: "优先级";
                    readonly priorityHigh: "高";
                    readonly priorityMedium: "中";
                    readonly priorityLow: "低";
                    readonly agentTarget: "Agent";
                    readonly model: "模型";
                    readonly permissionMode: "权限模式";
                    readonly reasoningEffort: "推理强度";
                    readonly parallelizable: "可并行";
                    readonly autoAccept: "自动验收";
                    readonly assignmentOptionsLoading: "选项加载中...";
                    readonly notSpecified: "未指定";
                    readonly loadFailed: "无法加载 Tutti mode plan";
                    readonly retry: "重试";
                    readonly issueOpen: "打开 Issue";
                    readonly issueListView: "列表";
                    readonly issueBoardView: "看板";
                    readonly issueSummary: "{{done}}/{{total}} 已完成 · {{running}} 运行中";
                    readonly issueDependencies: "依赖";
                    readonly issueAccept: "验收";
                    readonly issueRework: "重做";
                    readonly issueAcceptPrompt: "请在当前 Tutti Mode 计划中验收 {{reference}}，核对任务结果与验证证据，并根据当前 execution 状态继续推进计划";
                    readonly issueReworkPrompt: "请在当前 Tutti Mode 计划中重做 {{reference}}，先检查当前 execution 与失败或验收证据，保留原任务历史，并根据当前状态创建替代任务或新的后续执行后继续调度";
                    readonly issueStageParallel: "阶段 {{index}} · 并行 ×{{count}}";
                    readonly issueStageSequential: "阶段 {{index}} · 串行";
                    readonly issueStatusNotStarted: "待开始";
                    readonly issueStatusRunning: "运行中";
                    readonly issueStatusPendingAcceptance: "待验收";
                    readonly issueStatusCompleted: "已完成";
                    readonly issueStatusFailed: "失败";
                    readonly issueStatusCanceled: "已取消";
                    readonly issueStripRunning: "{{count}} 个子任务进行中";
                    readonly issueStripPending: "{{count}} 待验收";
                    readonly issueStripFailed: "{{count}} 失败";
                    readonly issueStripDone: "{{done}}/{{total}} 已完成";
                    readonly issueCreateFailed: "已核准的计划未能创建 Issue：{{message}}。请让 Agent 修订计划";
                };
                readonly planModeDescription: "先生成计划，再实施或拆解为 Issue";
                readonly planModeOnLabel: "开启";
                readonly planModeOffLabel: "关闭";
                readonly planUnavailable: "规划模式不可用";
                readonly queuedLabel: "排队中";
                readonly queuePausedByUserLabel: "由于你中断了当前响应，队列已暂停";
                readonly sendQueuedPromptNext: "直接发送";
                readonly editQueuedPrompt: "编辑";
                readonly deleteQueuedPrompt: "删除";
                readonly queuedPromptMoreActions: "更多排队操作";
                readonly stop: "停止回复";
                readonly stopping: "正在停止...";
                readonly slashStatusTitle: "状态";
                readonly slashStatusSession: "会话";
                readonly slashStatusBaseUrl: "Base URL";
                readonly slashStatusContext: "上下文";
                readonly slashStatusLimits: "限制";
                readonly slashStatusAccount: "账户";
                readonly slashStatusProviderAccount: "{{provider}} 账户";
                readonly slashStatusClose: "关闭";
                readonly slashStatusFiveHourLimit: "5h limit";
                readonly slashStatusWeeklyLimit: "7d limit";
                readonly slashStatusLimitPercentLeft: "{{percent}}% left";
                readonly slashStatusLimitReset: "resets {{reset}}";
                readonly slashStatusContextValue: "{{percentLeft}}% 剩余（已用 {{usedTokens}} / {{totalTokens}}）";
                readonly slashStatusContextUnavailable: "—";
                readonly slashStatusLimitsUnavailable: "账户额度暂不可用";
                readonly slashStatusEmptyValue: "—";
                readonly slashStatusUsageJustUpdated: "刚刚更新";
                readonly slashStatusUsageMinutesAgo: "{{count}} 分钟前更新";
                readonly slashStatusUsageHoursAgo: "{{count}} 小时前更新";
                readonly slashStatusUsageUpdating: "更新中…";
                readonly slashStatusUsageRefreshFailed: "刷新失败";
                readonly slashStatusUsageRefreshAria: "刷新额度用量";
                readonly slashStatusUsageAuthRequired: "需要配置 API Key 或登录后才能继续";
                readonly slashStatusUsageSessionExpired: "登录已过期，请重新登录";
                readonly slashStatusUsageSubscriptionRequired: "需要开通 Coding Plan 或订阅";
                readonly slashStatusUsageQuotaExhausted: "账户余额或使用额度已用尽";
                readonly slashStatusUsageParseFailed: "无法解析账户状态";
                readonly slashStatusUsageError: "无法加载账户状态";
                readonly usageChipLabel: "上下文 {{percent}}%";
                readonly usageTooltipLabel: "上下文用量";
                readonly usagePopoverTitle: "上下文用量";
                readonly usageContextWindowLabel: "上下文窗口";
                readonly usageTokensLabel: "Token 用量";
                readonly usageLimitsLabel: "限额";
                readonly usageCompactAction: "压缩";
                readonly planCardTitle: "计划";
                readonly planCardCopy: "复制计划";
                readonly copyCode: "复制代码";
                readonly mermaidLoading: "正在渲染 Mermaid 图表";
                readonly mermaidRenderFailed: "无法渲染 Mermaid 图表";
                readonly mermaidExpand: "放大 Mermaid 图表";
                readonly mermaidViewer: "Mermaid 图表查看器";
                readonly mermaidPanHint: "按住空格并拖拽";
                readonly mermaidZoomIn: "放大";
                readonly mermaidZoomOut: "缩小";
                readonly mermaidResetZoom: "重置视图";
                readonly mermaidZoomPercent: "图表缩放 {{percent}}%";
                readonly mermaidCloseViewer: "关闭图表查看器";
                readonly planCardExpand: "展开方案";
                readonly planCardCollapse: "收起方案";
                readonly planImplementationLead: "是否实作此方案？";
                readonly planImplementationConfirm: "是的，实作此方案";
                readonly planImplementationFeedbackPlaceholder: "否，请告知应如何调整执行方式";
                readonly planImplementationSend: "送出";
                readonly planImplementationSkip: "留在计划模式";
                readonly noRunningResponse: "当前没有正在运行的回复。";
                readonly composerTextMenu: "输入框文本操作";
                readonly pastedTextFilesHeader: "引用的粘贴文本文件：";
                readonly pastedTextFileLine: '- 粘贴的文本文件 "{{preview}}"：{{path}}，继续前请先阅读此文件。';
                readonly pastedTextAttachmentTitle: "粘贴的文本";
                readonly pastedTextAttachmentFailed: "无法保存粘贴的文本";
                readonly pastedTextRestoreToComposer: "在文本框中显示";
                readonly copyMessage: "复制消息";
                readonly selectedTextFragment: "1 个已选文本片段";
                readonly selectedTextFragments: "{{count}} 个已选文本片段";
                readonly forkThroughTurn: "从此轮进行会话 Fork";
                readonly forkThroughTurnPending: "正在进行会话 Fork";
                readonly continuedFromTask: "接续自任务";
                readonly sourceConversationNotFound: "原会话无法找到";
                readonly copyImage: "复制图片";
                readonly editRetryEditMessage: "编辑消息";
                readonly editRetryCancel: "取消";
                readonly editRetrySubmit: "保存并重试";
                readonly editRetryProcessing: "正在更新会话历史并重试…";
                readonly editRetryNeedsAction: "会话历史已更新，但编辑后的消息仍需恢复";
                readonly editRetryReconcile: "核对状态";
                readonly editRetryRetryReplacement: "重试消息";
                readonly messageCopied: "已复制";
                readonly promptTipsPrefix: "Tips：";
                readonly reviewPicker: {
                    readonly title: "代码审查";
                    readonly targetLabel: "审查范围";
                    readonly searchPlaceholder: "搜索";
                    readonly noResults: "无匹配结果";
                    readonly uncommitted: "未提交的更改";
                    readonly baseBranch: "与分支比较";
                    readonly commit: "指定提交";
                    readonly custom: "自定义说明";
                    readonly branchLabel: "基准分支";
                    readonly branchPlaceholder: "选择分支";
                    readonly branchLoading: "正在加载分支…";
                    readonly branchEmpty: "未找到分支";
                    readonly commitPlaceholder: "提交 SHA";
                    readonly customPlaceholder: "描述要审查的内容";
                    readonly submit: "开始审查";
                    readonly cancel: "取消";
                };
                readonly promptTips: {
                    readonly setWorkspace: {
                        readonly label: "指定工作区";
                        readonly prompt: "让 Agent 知道在哪里读文件、运行命令和理解代码";
                    };
                    readonly useIssue: {
                        readonly label: "善用任务";
                        readonly prompt: "把需求、约束和验收标准写进任务，Agent 更容易按目标推进";
                    };
                    readonly mapCurrentState: {
                        readonly label: "先梳理现状";
                        readonly prompt: "不确定怎么下手时，让 Agent 先总结当前状态、风险和下一步";
                    };
                    readonly continueRecentSession: {
                        readonly label: "接力最近会话";
                        readonly prompt: "延续工作时让 Agent 先回顾最近进展、未完成任务和阻塞点";
                    };
                    readonly referenceOtherAgents: {
                        readonly label: "引用其他 Agent 对话历史";
                        readonly prompt: "让上下文接力更完整，减少关键信息丢失";
                    };
                    readonly controlPermissions: {
                        readonly label: "控制执行权限";
                        readonly prompt: "需要稳妥时使用「请求批准」，确认可改文件后再切到更高权限";
                    };
                };
                readonly empty: "需要 {{provider}} 帮你做些什么？";
                readonly conversations: "会话";
                readonly newConversation: "新建会话";
                readonly agentConfig: "检测与设置";
                readonly agentSettingsMenu: "设置";
                readonly agentEnvSetup: "环境检测";
                readonly noConversations: "还没有会话";
                readonly emptyProjectConversations: "暂无对话";
                readonly agentsEmpty: "暂无可用 Agent";
                readonly conversationFilterAll: "全部";
                readonly providerSwitchLabel: "切换 Provider";
                readonly sharedAgentOwnerSeparator: " 的 ";
                readonly handoffConversation: "Handoff";
                readonly handoffConversationTooltip: "交接给其他 Agent";
                readonly handoffConversationMenu: "选择要交接的 Agent";
                readonly handoffTargetDeviceSource: "来自 {{device}}";
                readonly handoffTargetSelf: "我的 Agent";
                readonly handoffTargetShared: "共享 Agent";
                readonly startConversation: "开始会话";
                readonly selectConversation: "选择一个会话";
                readonly loadingConversations: "正在加载会话...";
                readonly conversationsLoadFailed: "无法加载会话";
                readonly loadingConversation: "正在加载会话...";
                readonly scrollToBottom: "滚动至底部";
                readonly searchNoConversations: "暂无相关会话";
                readonly searchFailed: "无法搜索会话";
                readonly retrySearch: "重试搜索";
                readonly activityPriority: "优先处理";
                readonly activityNothingNeedsAttention: "暂无需要你关注的会话";
                readonly activityToday: "今天";
                readonly activityYesterday: "昨天";
                readonly activityConversationSource: "对话";
                readonly activityStatusFailed: "执行失败";
                readonly activityStatusRecentlyActive: "最近活跃";
                readonly activityStatusUnread: "有未读结果";
                readonly activityStatusWaiting: "等待你处理";
                readonly activityStatusWorking: "正在运行";
                readonly viewActivity: "查看活动";
                readonly viewActivityNeedsAttention: "查看活动，有会话需要关注";
                readonly turnOffActivityView: "关闭活动视图";
                readonly conversationUnavailable: "会话不可用。";
                readonly contextPickerBrowseHint: "根据你输入的内容搜索工作区文件";
                readonly contextPickerBrowseFileHint: "暂无已打开或 Agent 生成的文件，继续输入文件名可搜索本机文件";
                readonly contextPickerBrowseAgentHint: "输入内容以搜索 Agent";
                readonly contextPickerBrowseAppHint: "输入内容以搜索应用";
                readonly contextPickerBrowseSessionHint: "输入内容以搜索我发起的 Agent 会话";
                readonly contextPickerBrowseCollabHint: "输入内容以搜索其他人和 Agent 的会话";
                readonly contextPickerBrowseIssueHint: "输入内容以搜索当前房间内的任务";
                readonly workspaceAppFactoryMentionFallback: "创建应用";
                readonly contextPickerExpandMore: "展开更多 {{count}} 条";
                readonly contextPickerLoadMoreLoading: "正在加载";
                readonly contextPickerLoadMoreRetry: "加载失败，重试";
                readonly contextPickerCategoryFileDescription: "搜索工作区文件和目录";
                readonly contextPickerCategorySessionDescription: "查找我发起的 Agent 会话";
                readonly contextPickerCategoryCollabDescription: "查看其他人和 Agent 的会话";
                readonly contextPickerCategoryTaskDescription: "查找当前房间内的任务";
                readonly searchPlaceholder: "搜索会话";
                readonly sectionPinned: "置顶";
                readonly sectionConversations: "对话";
                readonly sectionToday: "今天";
                readonly sectionYesterday: "昨天";
                readonly sectionEarlier: "更早";
                readonly projectSectionEdit: "新建会话";
                readonly projectSectionMoreActions: "项目操作";
                readonly projectSectionViewFiles: "打开文件夹";
                readonly pinProject: "置顶项目";
                readonly unpinProject: "取消置顶项目";
                readonly pinnedProjectAccessibleName: "已置顶项目：{{project}}";
                readonly projectRailCreateProject: "新建项目";
                readonly projectRailLinkExistingProject: "关联已有项目文件";
                readonly removeProject: "移除";
                readonly removeProjectConfirmDescription: "将会从列表中移除「{{project}}」及项目下全部会话，不会删除本地文件，是否确认移除？";
                readonly removeProjectConfirmTitle: "移除项目？";
                readonly batchDeleteProjectSessions: "批量删除会话";
                readonly batchDeleteProjectSessionsTitle: "删除项目会话？";
                readonly batchDeleteProjectSessionsBody: "将删除「{{project}}」下的 {{count}} 个会话。删除后无法恢复。";
                readonly batchDeleteProjectSessionsConfirm: "删除会话";
                readonly conversationsSectionMoreActions: "对话操作";
                readonly batchDeleteConversations: "批量删除对话";
                readonly batchDeleteConversationsTitle: "删除对话？";
                readonly batchDeleteConversationsBody: "将删除 {{count}} 个对话。删除后无法恢复。";
                readonly batchDeleteConversationsConfirm: "删除对话";
                readonly runtimeSessionOnly: "这里只显示 runtime 会话。";
                readonly approvalRequired: "{{provider}} 请求你的授权。";
                readonly fileChangeApprovalRequired: "{{provider}} 请求编辑文件的授权";
                readonly approvalUnavailable: "没有可用选项。";
                readonly approvalOptions: {
                    readonly allowOnce: "允许执行";
                    readonly allowForSession: "本次会话允许";
                    readonly allowAlways: "允许，并且不再询问";
                    readonly allowAlwaysForCommandPrefix: "允许，并且不再询问以 `{{command}}` 开头的命令";
                    readonly allowAlwaysForCommandPrefixLead: "允许，并且不再询问以下列内容开头的命令";
                    readonly allowAlwaysForScope: "允许，并且不再询问：{{scope}}";
                    readonly alwaysAllowScope: "始终允许 {{scope}}";
                    readonly bypassPermissions: "允许，并绕过权限";
                    readonly autoMode: "允许，并使用自动模式";
                    readonly acceptEdits: "允许，并自动接受编辑";
                    readonly manualApproval: "允许，并手动确认编辑";
                    readonly rejectOnce: "拒绝执行";
                    readonly rejectAlways: "拒绝，并且不再询问";
                    readonly rejectWithFollowUp: "拒绝，然后发送新的指令";
                };
                readonly authRequired: "需要认证";
                readonly authLogin: "登录";
                readonly activatingSession: "正在连接会话...";
                readonly cancellingSession: "正在取消中...";
                readonly retryActivation: "重试";
                readonly continueInNewConversation: "去新会话";
                readonly goalLabel: "目标";
                readonly goalTitleActive: "进行中的目标";
                readonly goalTitlePaused: "已暂停的目标";
                readonly goalTitleBlocked: "已阻塞的目标";
                readonly goalTitleUsageLimited: "用量受限的目标";
                readonly goalTitleBudgetLimited: "预算受限的目标";
                readonly goalTitleComplete: "已完成的目标";
                readonly goalBudgetUsage: "{{used}}/{{budget}} tokens";
                readonly goalClearHint: "输入 /goal clear 清除";
                readonly goalEditAction: "编辑目标";
                readonly goalPauseAction: "暂停目标";
                readonly goalResumeAction: "继续目标";
                readonly goalClearAction: "删除目标";
                readonly goalRemoved: "目标已移除";
                readonly processing: "正在规划下一步";
                readonly turnProcessedSeconds: "已处理 {{seconds}} 秒";
                readonly turnProcessedMinutes: "已处理 {{minutes}} 分钟";
                readonly turnProcessedMinutesSeconds: "已处理 {{minutes}} 分 {{seconds}} 秒";
                readonly turnPeerDeviceOfflinePendingSync: "对方设备离线 · 进度待同步";
                readonly turnPeerDeviceProgressSynchronizing: "正在同步对方设备进度…";
                readonly turnTotalSeconds: "总用时 {{seconds}} 秒";
                readonly turnTotalMinutes: "总用时 {{minutes}} 分钟";
                readonly turnTotalMinutesSeconds: "总用时 {{minutes}} 分 {{seconds}} 秒";
                readonly expandTurnWork: "展开任务详情";
                readonly collapseTurnWork: "收起任务详情";
                readonly agentTargetRequired: "请先选择可用的 Agent 目标。";
                readonly sessionActivationFailed: "Agent 会话启动失败。";
                readonly goalControlFailed: "目标变更未能应用";
                readonly sessionNoLongerAvailable: "之前的 Agent 会话已不可用";
                readonly promptImagesUnsupported: "当前模型不支持图片输入。";
                readonly tuttiModeCheckpointWakeTaskSettled: "某任务已完成，待审查";
                readonly tuttiModeCheckpointWakeTaskFailed: "某任务失败，待审查";
                readonly tuttiModeCheckpointWakeTaskCanceled: "某任务已取消，待审查";
                readonly tuttiModeCheckpointWakeGoalReview: "待进行最终目标审查";
                readonly tuttiModeCheckpointWakeInitialSchedule: "可以调度下一批任务了";
                readonly tuttiModeCheckpointWakeDefault: "执行检查点待你审查";
                readonly tuttiModeCheckpointWakeIssue: "Issue {{issue}}";
                readonly tuttiModeCheckpointWakeExpand: "查看完整提示";
                readonly tuttiModeCheckpointWakeCollapse: "收起完整提示";
                readonly tuttiModePlanIssueLinkCreated: "已根据该计划创建 Issue";
                readonly turnSummary: "已变更文件";
                readonly userMessageLocator: "用户消息";
                readonly turnSummaryFilesChanged: "变更了 {{count}} 个文件";
                readonly turnSummaryModified: "{{count}} 个修改";
                readonly turnSummaryCreated: "{{count}} 个新增";
                readonly turnSummaryModifiedTag: "修改";
                readonly turnSummaryCreatedTag: "新增";
                readonly turnSummaryViaTool: "通过 {{tool}}";
                readonly turnSummaryBefore: "变更前";
                readonly turnSummaryAfter: "变更后";
                readonly codeBlockEmptyContent: "(empty)";
                readonly turnSummaryOpenFile: "打开";
                readonly turnSummaryUndo: "撤销";
                readonly turnSummaryReapply: "重新应用";
                readonly turnSummaryCheckingGit: "正在检查 Git 仓库...";
                readonly turnSummaryGitRequired: "当前目录不是 Git 仓库，无法撤销变更";
                readonly turnSummaryPatchUnavailable: "当前变更缺少可撤销的补丁数据";
                readonly turnSummaryInvalidPatch: "变更记录中的补丁格式无效，无法安全撤销";
                readonly turnSummaryPatchDoesNotApply: "文件在此次变更后已发生变化，无法安全撤销";
                readonly turnSummaryUndoFailed: "撤销变更失败";
                readonly turnSummaryReapplyFailed: "重新应用变更失败";
                readonly turnSummaryShowMoreFiles: "再显示 {{count}} 个文件";
                readonly turnSummaryShowFewerFiles: "收起多余文件";
                readonly planLead: "结束规划并开始实施。你希望权限如何工作？";
                readonly planModes: {
                    readonly acceptEdits: {
                        readonly label: "接受编辑";
                        readonly description: "自动批准文件编辑";
                    };
                    readonly askFirst: {
                        readonly label: "逐次确认";
                        readonly description: "每次工具调用前都询问";
                    };
                    readonly allowAll: {
                        readonly label: "全部允许";
                        readonly description: "不再弹出工具确认";
                    };
                    readonly auto: {
                        readonly label: "自动";
                        readonly description: "由智能体自行决定何时询问";
                    };
                };
                readonly stayInPlan: "继续规划";
                readonly sendFeedback: "发送反馈并继续规划";
                readonly feedbackPlaceholder: "补充反馈，继续完善计划...";
                readonly previousQuestion: "上一步";
                readonly nextQuestion: "下一步";
                readonly submitAnswers: "提交回答";
                readonly answerPlaceholder: "补充更多细节...";
                readonly waitingForAnswer: "等待你的回答...";
                readonly shortcutEnter: "Enter";
                readonly shortcutCmdEnter: "Cmd + Enter";
                readonly shortcutCtrEnter: "Ctr + Enter";
                readonly openConversationWindow: "在新窗口打开会话";
                readonly showMoreConversations: "显示更多";
                readonly showLessConversations: "收起";
                readonly deleteSession: "删除会话";
                readonly pinSession: "置顶会话";
                readonly renameSession: "重命名会话";
                readonly renameSessionTitle: "重命名对话";
                readonly renameSessionDescription: "保持简短且易于识别。";
                readonly renameSessionPlaceholder: "对话标题";
                readonly renameSessionSave: "保存";
                readonly unpinSession: "取消置顶";
                readonly deleteSessionTitle: "删除会话？";
                readonly deleteSessionBody: "删除后无法恢复。该会话将不再出现在会话列表、会话时间线、房间时间线或房间状态中。";
                readonly deleteSessionConfirm: "删除会话";
                readonly conversationRailResizeAria: "调整会话列表宽度";
                readonly collapseConversationRail: "隐藏侧边栏";
                readonly expandConversationRail: "显示侧边栏";
                readonly relativeTimeJustNow: "刚刚";
                readonly relativeTimeMinutes: "{{count}} 分钟";
                readonly relativeTimeHours: "{{count}} 小时";
                readonly relativeTimeDays: "{{count}} 天";
                readonly relativeTimeMonths: "{{count}} 个月";
                readonly relativeTimeYears: "{{count}} 年";
                readonly slashCommandCompactLabel: "压缩";
                readonly slashCommandContextLabel: "上下文";
                readonly slashCommandFastLabel: "快速";
                readonly slashCommandGoalLabel: "目标";
                readonly slashCommandInitLabel: "初始化";
                readonly slashCommandPlanLabel: "计划";
                readonly slashCommandReviewLabel: "审查";
                readonly slashCommandStatusLabel: "状态";
                readonly slashCommandUsageLabel: "用量";
                readonly slashCommandCompactDescription: "压缩当前对话上下文。";
                readonly slashCommandContextDescription: "查看当前上下文快照。";
                readonly slashCommandFastDescription: "切换快速响应模式。";
                readonly slashCommandGoalDescription: "设置、查看或清除当前目标。";
                readonly slashCommandInitDescription: "初始化仓库说明文件。";
                readonly slashCommandPlanDescription: "切换计划模式。";
                readonly slashCommandReviewDescription: "发起代码审查。";
                readonly slashCommandStatusDescription: "查看会话状态和上下文用量。";
                readonly slashCommandUsageDescription: "查看上下文和额度用量。";
                readonly browserUseCapabilityLabel: "浏览器";
                readonly browserUseCapabilityDescription: "让 Agent 使用浏览器。";
                readonly browserUseCapabilityDescriptionAutoConnect: "当前配置：复用已登录的 Chrome。";
                readonly browserUseCapabilityDescriptionIsolated: "当前配置：使用独立浏览器。";
                readonly browserUseCapabilitySettingsLabel: "浏览器设置";
                readonly browserUseCapabilitySettingsDescription: "配置 Agent 使用的浏览器。";
                readonly capabilityInlineSettingsLabel: "设置";
                readonly computerUseCapabilityLabel: "电脑控制";
                readonly computerUseCapabilityDescription: "让 Agent 控制 macOS 桌面。";
                readonly computerUseCapabilitySetupRequiredDescription: "未安装。按 Enter 打开设置。";
                readonly computerUseCapabilityAuthorizationRequiredDescription: "需要授权。按 Enter 打开设置。";
                readonly computerUseCapabilityAuthorizationUnknownDescription: "无法确认授权状态。按 Enter 打开设置。";
                readonly computerUseCapabilitySettingsLabel: "电脑控制设置";
                readonly computerUseCapabilitySettingsDescription: "安装、移除或授权电脑控制。";
                readonly fileMentionPalette: "工作区文件";
                readonly fileMentionLoading: "正在搜索工作区...";
                readonly fileMentionEmpty: "根据你输入的内容搜索工作区文件";
                readonly fileMentionError: "无法搜索工作区文件。";
                readonly fileMentionTabHint: "Tab 切换分类 ｜ ←→ 进入/返回文件夹 ｜ ↑↓ 切换选中";
                readonly fileDropHint: "拖放文件以添加到会话";
                readonly composerFileFolderUnsupported: "暂不支持在这里附加文件夹";
                readonly composerFileTooLarge: "文件过大";
                readonly composerFilePreparationFailed: "文件处理失败";
                readonly mentionPalette: "引用或调用";
                readonly addReference: "添加引用";
                readonly addContent: "添加文件等内容";
                readonly quickPrompts: {
                    readonly add: "新增提示词";
                    readonly conflict: "该提示词已在其他窗口发生变化，请刷新后检查草稿再保存";
                    readonly contentLabel: "提示词";
                    readonly contentPlaceholder: "输入可重复使用的提示词内容";
                    readonly contentTooLarge: "提示词内容不能超过 32 KiB";
                    readonly createTitle: "新增快捷提示词";
                    readonly createFromTemplate: "推荐模板";
                    readonly delete: "删除";
                    readonly deleteConfirm: "删除提示词";
                    readonly deleteDescription: "确定删除「{{title}}」吗？删除后无法恢复";
                    readonly deleteTitle: "删除快捷提示词？";
                    readonly deleting: "正在删除…";
                    readonly dragCancel: "已取消排序，「{{title}}」返回第 {{position}} 项，共 {{total}} 项";
                    readonly dragDrop: "已将「{{title}}」放到第 {{position}} 项，共 {{total}} 项";
                    readonly dragHandle: "调整「{{title}}」的顺序";
                    readonly dragInstructions: "按空格键或回车键开始拖拽，使用方向键移动，再按空格键或回车键放下，按 Esc 键取消";
                    readonly dragMove: "正在把「{{title}}」移动到第 {{position}} 项，共 {{total}} 项";
                    readonly dragStart: "已选中「{{title}}」，当前第 {{position}} 项，共 {{total}} 项";
                    readonly edit: "编辑";
                    readonly editTitle: "编辑快捷提示词";
                    readonly empty: "暂无快捷提示词";
                    readonly finishSorting: "完成";
                    readonly insertionError: "未能填入输入框，请从快捷提示词列表中重试";
                    readonly loadError: "快捷提示词加载失败";
                    readonly loading: "正在加载快捷提示词…";
                    readonly moreActions: "更多提示词操作";
                    readonly mutationError: "提示词保存失败，请重试";
                    readonly noResults: "没有匹配的快捷提示词";
                    readonly required: "标题和提示词内容不能为空";
                    readonly reorderConflict: "提示词顺序已在其他窗口发生变化，请刷新后重新拖拽";
                    readonly reorderDisabledMinimum: "至少需要两个快捷提示词才能调整顺序";
                    readonly reorderDisabledPending: "请等待当前提示词操作完成后再调整顺序";
                    readonly reorderDisabledSearch: "清空搜索内容后才能调整提示词顺序";
                    readonly reorderDisabledUnsupported: "当前宿主不支持调整提示词顺序";
                    readonly reorderError: "提示词顺序保存失败，请重新拖拽";
                    readonly retry: "重试";
                    readonly recommendedTemplates: {
                        readonly summaryCommonPrompts: {
                            readonly title: "总结常用提示词";
                            readonly description: "从历史对话中发现关键洞察和重复工作模式";
                            readonly content: "请扫描、读取所有可访问的历史对话信息以及记忆。\n\n1. 有什么东西是你发现了但我完全没有意识到的关键点？而且这个关键点会对我的决策和工作带来巨大的改变。\n2. 我有哪些重复的工作内容？从里面挑出我常用的提示词给我，并且说明原因和使用场景。\n\n请明确说明实际可访问范围，区分事实、推断和待确认内容，不要把推测当成事实";
                        };
                        readonly understandContext: {
                            readonly title: "梳理现状";
                            readonly description: "总结上下文、约束、风险与下一步";
                            readonly content: "请先总结当前上下文、已确认的事实、约束、风险和待确认问题，区分事实与假设，再给出最小且有价值的下一步建议";
                        };
                        readonly createActionPlan: {
                            readonly title: "制定行动计划";
                            readonly description: "拆分优先级、依赖与验收标准";
                            readonly content: "请把这个目标拆成按优先级排序且可验证的步骤，列出每一步的依赖、风险和验收标准，并建议从哪里开始";
                        };
                        readonly reviewAndImprove: {
                            readonly title: "审阅与改进";
                            readonly description: "找出缺口、风险和可执行的优化建议";
                            readonly content: "请审阅以下内容，说明做得好的部分、缺失的信息、重要风险和可执行的改进建议，并按影响与投入排序";
                        };
                        readonly draftClearUpdate: {
                            readonly title: "生成清晰说明";
                            readonly description: "面向目标受众生成简洁表达";
                            readonly content: "请为目标受众生成一段简洁说明，先表达核心信息，只补充必要上下文，明确需要对方做出的决策或下一步行动，并使用清晰直接的语言";
                        };
                    };
                    readonly recommendedTemplatesDescription: "选择后会预填到编辑窗口，保存时会添加为快捷提示词并填入输入框";
                    readonly recommendedTemplatesTitle: "推荐模板";
                    readonly returnToPrompts: "我的提示词";
                    readonly save: "保存";
                    readonly saving: "正在保存…";
                    readonly searchPlaceholder: "搜索快捷提示词";
                    readonly startSorting: "调整顺序";
                    readonly title: "快捷提示词";
                    readonly titleLabel: "标题";
                    readonly titlePlaceholder: "输入简短易识别的名称";
                    readonly titleTooLong: "标题不能超过 80 个字符";
                    readonly trigger: "提示词";
                    readonly triggerTooltip: "选择快捷提示词";
                    readonly useTemplate: "使用模板";
                };
                readonly referenceWorkspaceFiles: "引用空间文件";
                readonly fileMentionEnterFolder: "进入文件夹";
                readonly fileMentionSwitchCategory: "切换分类";
                readonly fileMentionNavigateHierarchy: "进入/返回文件夹";
                readonly fileMentionSwitchSelection: "切换选中";
                readonly mentionFilterFile: "文件";
                readonly mentionFilterApp: "应用";
                readonly mentionFilterAgent: "智能体";
                readonly provenanceFilterAllAgents: "全部智能体";
                readonly provenanceFilterAllMembers: "全部成员";
                readonly provenanceFilterAllSources: "全部来源";
                readonly provenanceFilterAgents: "智能体";
                readonly provenanceFilterFilteredSources: "已筛选来源";
                readonly provenanceFilterMembers: "成员";
                readonly mentionFilterSession: "会话";
                readonly mentionFilterIssue: "任务";
                readonly mentionKindAgent: "智能体";
                readonly mentionKindApp: "应用";
                readonly mentionKindAppFactory: "应用工厂";
                readonly mentionKindFile: "文件";
                readonly mentionKindIssue: "任务";
                readonly mentionKindReference: "引用";
                readonly mentionKindSession: "会话";
                readonly mentionGroupFiles: "文件";
                readonly mentionGroupOpenedFiles: "我打开的文件";
                readonly mentionGroupAgentGeneratedFiles: "近期 Agent 生成的文件";
                readonly mentionGroupApps: "应用";
                readonly mentionGroupAgents: "智能体";
                readonly mentionGroupMySessions: "我的会话";
                readonly mentionGroupIssues: "任务";
                readonly mentionEmptyMySessions: "暂无会话";
                readonly mentionEmptyApps: "暂无应用";
                readonly mentionEmptyAgents: "暂无可用智能体";
                readonly mentionEmptyIssues: "暂无任务";
                readonly mentionEmptyDockFiles: "Dock 栏暂无已打开文件，输入关键词可搜索工作区文件";
                readonly mentionEmptyAgentGeneratedFiles: "暂无 Agent 生成的文件";
                readonly mentionFolderBack: "返回";
                readonly mentionFolderChildCount: "包含 {{count}} 个子项";
                readonly mentionAgentTargetAvailable: "可用";
                readonly mentionAgentTargetUnavailable: "不可用";
                readonly mentionNoMatchingFiles: "没有匹配到文件";
                readonly mentionOpenReferences: "查看产物";
                readonly issueRunPrompt: {
                    readonly currentWorkingDirectoryLabel: "当前工作目录";
                    readonly executionRequirementsLabel: "执行要求";
                    readonly intro: "你正在处理一个任务。";
                    readonly issueContentLabel: "任务内容";
                    readonly issueTitleLabel: "任务标题";
                    readonly missingContent: "（无补充内容）";
                    readonly noReferences: "- （无引用资料）";
                    readonly referencesLabel: "引用资料";
                    readonly requirementNoOtherOutputDir: "3. 不要把最终产物写到其他目录。";
                    readonly requirementStayInWorkspace: "1. 在 {{workspaceRoot}} 下工作，不要切换到其他无关目录。";
                    readonly requirementSummaryOutput: "2. 如果用户没有另行指定位置，至少输出 docs/tutti/task_summary_{{issueId}}.md，说明处理结果、改动与结论。";
                    readonly taskContentLabel: "任务内容";
                    readonly taskTitleLabel: "任务标题";
                };
                readonly syncPending: "已保存到本地，正在同步到云端";
                readonly syncSynced: "已同步到云端";
                readonly syncFailed: "云端同步失败";
            };
            readonly workspaceInsights: {
                readonly runtimeTitle: "运行时";
                readonly live: "运行中";
                readonly treeTitle: "目录树";
                readonly treeLead: "与运行时一致的可见房间结构。";
                readonly root: "根路径：";
                readonly sandbox: "沙箱：";
                readonly sessions: "会话：";
                readonly provider: "提供方：";
            };
            readonly workspaceFileManager: {
                readonly breadcrumbsAria: "面包屑导航";
                readonly breadcrumbRoot: "首页";
                readonly scrollBreadcrumbsLeft: "向左滚动面包屑";
                readonly scrollBreadcrumbsRight: "向右滚动面包屑";
                readonly previewPaneResizeAria: "调整预览面板宽度";
                readonly name: "名称";
                readonly modified: "修改时间";
                readonly size: "大小";
                readonly empty: "当前文件夹为空";
                readonly open: "打开";
                readonly view: "查看";
                readonly openInBrowser: "在浏览器中打开";
                readonly newFile: "新建文件";
                readonly newFolder: "新建文件夹";
                readonly upload: "上传";
                readonly uploadHere: "上传到这里";
                readonly downloadFile: "下载文件";
                readonly downloadArchive: "下载压缩包";
                readonly delete: "删除";
                readonly deleting: "正在删除…";
                readonly back: "后退";
                readonly forward: "前进";
                readonly refresh: "刷新";
                readonly retry: "重试";
                readonly refreshed: "文件列表已刷新。";
                readonly uploaded: "已上传 {{count}} 项。";
                readonly uploadNoSelection: "未选择本地文件。";
                readonly uploadFilteredSymlinks: "已上传可用内容，符号链接已过滤。";
                readonly uploadOnlySymlinks: "选择的内容均为符号链接，上传已取消。";
                readonly uploadFilteredIgnored: "已过滤忽略内容后上传。";
                readonly uploadOnlyIgnored: "过滤后没有可上传文件，上传已取消。";
                readonly uploadFilterTitle: "检测到 .gitignore";
                readonly uploadFilterBody: "默认会过滤被忽略的文件，以及常见依赖、构建产物和缓存目录。符号链接始终会被过滤。";
                readonly uploadFilterAdvanced: "高级设置";
                readonly uploadFilterIncludeIgnored: "上传 .gitignore 忽略的文件";
                readonly uploadFilterIncludeIgnoredHint: "这可能包含依赖、构建产物和缓存文件，上传体积和工作区空间占用会增加。";
                readonly uploadFilterSubmit: "开始上传";
                readonly uploadConflictTitle: "检测到同名项目";
                readonly uploadConflictBody: "继续上传会覆盖同名文件。同名文件夹会合并，相同相对路径的文件会被覆盖，其他已有内容会保留。";
                readonly uploadConflictMore: "另有 {{count}} 项";
                readonly uploadConflictSubmit: "继续上传";
                readonly downloaded: "下载完成。";
                readonly downloadCanceled: "已取消下载。";
                readonly deleted: "已删除 {{name}}。";
                readonly createdFile: "已创建 {{name}}。";
                readonly createdFolder: "已创建 {{name}}。";
                readonly createNameRequired: "请输入名称后再创建。";
                readonly createNameInvalid: "名称不能包含斜杠。";
                readonly copyPath: "复制地址";
                readonly pathCopied: "路径已复制。";
                readonly copyPathFailed: "复制路径失败：{{message}}";
                readonly unsupportedViewTitle: "暂不支持预览";
                readonly unsupportedViewBody: "下载 {{name}} 后可在本地打开。";
                readonly operationFailed: "{{message}}";
                readonly filePlaceholder: "notes.md";
                readonly folderPlaceholder: "folder-name";
                readonly cancel: "取消";
                readonly create: "创建";
                readonly deleteConfirm: "确定删除 {{name}}？此操作不可撤销。";
                readonly dropToUpload: "拖放以上传到 {{path}}";
                readonly dropToMove: "松手以移动到 {{path}}";
                readonly previewEmpty: "选择文件或文件夹查看详情";
                readonly previewDirectory: "双击左侧文件夹进入下一级";
                readonly previewUnsupported: "此文件暂不支持预览。";
                readonly previewLoading: "正在加载预览...";
                readonly previewReadFailed: "无法加载预览：{{message}}";
                readonly previewTooLarge: "这个文件太大，无法预览。最大 {{maxSize}}。";
                readonly previewBinary: "这个文件看起来是二进制文件，无法在这里预览。";
                readonly previewDecodeFailed: "这个文件不是有效的 UTF-8。";
                readonly minimize: "最小化";
                readonly maximize: "最大化";
                readonly restore: "还原";
                readonly close: "关闭";
            };
            readonly workspaceFileNode: {
                readonly loading: "正在加载文件...";
                readonly readFailed: "无法读取文件：{{message}}";
                readonly unsupportedImage: "不支持的图片格式。";
                readonly tooLarge: "这个文件太大，无法在这里编辑。最大 {{maxSize}}。";
                readonly binary: "这个文件看起来是二进制文件，无法在这里编辑。";
                readonly decodeFailed: "这个文件不是有效的 UTF-8。";
                readonly save: "保存";
                readonly saving: "正在保存...";
                readonly saved: "已保存";
                readonly dirty: "有未保存更改";
                readonly saveFailed: "保存失败：{{message}}";
                readonly closeUnsavedTitle: "关闭前保存更改？";
                readonly closeUnsavedBody: "{{name}} 有未保存更改。";
                readonly saveAndClose: "保存并关闭";
                readonly discard: "放弃";
                readonly cancel: "取消";
            };
            readonly workspaceRenameHint: "点击修改房间名称";
            readonly workspaceRenameLabel: "房间名称";
            readonly workspaceBack: "返回";
            readonly workspaceAgentMessageCenterTitle: "Agent 消息";
            readonly workspaceAgentMessageCenterOpenAria: "打开 Agent 消息";
            readonly workspaceAgentMessageCenterWaitingCount_one: "{{count}} 个等待中";
            readonly workspaceAgentMessageCenterWaitingCount_other: "{{count}} 个等待中";
            readonly workspaceAgentMessageCenterFilterAll: "全部";
            readonly workspaceAgentMessageCenterFilterWaiting: "等待中";
            readonly workspaceAgentMessageCenterFilterWorking: "运行中";
            readonly workspaceAgentMessageCenterFilterCompleted: "已完成";
            readonly workspaceAgentMessageCenterFilterFailed: "错误";
            readonly workspaceAgentMessageCenterViewOptions: "视图选项";
            readonly workspaceAgentMessageCenterViewSummary: "按{{group}}分组 · {{filters}}";
            readonly workspaceAgentMessageCenterSummaryCount: "{{count}} 条消息";
            readonly workspaceAgentMessageCenterSummaryWaiting: "{{count}} 条 · {{waiting}} 待处理";
            readonly workspaceAgentMessageCenterSummaryCompleted: "{{count}} 条 · {{completed}} 已完成";
            readonly workspaceAgentMessageCenterSummaryFiltered: "已筛选 · {{count}}/{{total}} 条";
            readonly workspaceAgentMessageCenterFilterActive: "已启用筛选";
            readonly workspaceAgentMessageCenterGroupBy: "分组方式";
            readonly workspaceAgentMessageCenterGroupPriority: "重要性";
            readonly workspaceAgentMessageCenterGroupStatus: "状态";
            readonly workspaceAgentMessageCenterGroupAgent: "智能体";
            readonly workspaceAgentMessageCenterGroupTime: "时间";
            readonly workspaceAgentMessageCenterGroupNeedsAttention: "需关注";
            readonly workspaceAgentMessageCenterGroupRecentlyCompleted: "最近完成";
            readonly workspaceAgentMessageCenterGroupToday: "今天";
            readonly workspaceAgentMessageCenterGroupYesterday: "昨天";
            readonly workspaceAgentMessageCenterGroupPreviousSevenDays: "过去 7 天";
            readonly workspaceAgentMessageCenterGroupOlder: "更早";
            readonly workspaceAgentMessageCenterFilterStatus: "筛选状态";
            readonly workspaceAgentMessageCenterFilterAgent: "筛选智能体";
            readonly workspaceAgentMessageCenterClearFilters: "清除筛选";
            readonly workspaceAgentMessageCenterStatusQuickFilterAria: "查看{{status}}消息（{{count}}）";
            readonly workspaceAgentMessageCenterExpandStackAria: "展开 {{count}} 条折叠消息";
            readonly workspaceAgentMessageCenterCollapseStackAria: "收起已展开的消息";
            readonly workspaceAgentMessageCenterStackSummaryCount: "{{count}} 条消息";
            readonly workspaceAgentMessageCenterFilteredEmpty: "没有符合筛选条件的消息";
            readonly workspaceAgentMessageCenterEmpty: "暂无 Agent 消息";
            readonly workspaceAgentMessageCenterNoSummary: "暂无 Agent 消息";
            readonly workspaceAgentMessageCenterOpenChat: "打开会话";
            readonly workspaceAgentsNoSessions: "暂无会话";
            readonly workspaceAgentsNoActivities: "暂无进行中的操作";
            readonly workspaceAgentsUntitledConversation: "未命名对话";
            readonly workspaceAgentsGenericAgentName: "智能体";
            readonly workspaceAgentsSessionCount_one: "{{count}} 个会话";
            readonly workspaceAgentsSessionCount_other: "{{count}} 个会话";
            readonly workspaceAgentsMemberCount_one: "{{count}} 位成员";
            readonly workspaceAgentsMemberCount_other: "{{count}} 位成员";
            readonly workspaceAgentsSummaryWorking: "工作中";
            readonly workspaceAgentsSummaryNeedsAttention: "需关注";
            readonly workspaceAgentsSummaryOffDuty: "离线";
            readonly workspaceAgentsSummaryRowAria: "成员数、工作中与需关注";
            readonly workspaceAgentsParallelSessions_one: "{{count}} 个并行";
            readonly workspaceAgentsParallelSessions_other: "{{count}} 个并行";
            readonly workspaceAgentStatusWorking: "工作中";
            readonly workspaceAgentStatusPaused: "已暂停";
            readonly workspaceAgentStatusWaiting: "等待中";
            readonly workspaceAgentStatusReady: "就绪";
            readonly workspaceAgentStatusCompleted: "已完成";
            readonly workspaceAgentStatusFailed: "失败";
            readonly workspaceAgentStatusCanceled: "已取消";
            readonly workspaceParticipantsTitle: "房间内的人类";
            readonly workspaceParticipantsTopbarAria: "Workspace 成员";
            readonly workspaceParticipantsInviteAria: "邀请成员";
            readonly workspaceParticipantsInviteDisabled: "你不是这个房间的创建者，无法发起邀请哦";
            readonly workspaceParticipantsInvitedCount_one: "已邀请 {{count}} 位成员";
            readonly workspaceParticipantsInvitedCount_other: "已邀请 {{count}} 位成员";
            readonly workspaceParticipantsOwnerBadge: "房主";
            readonly workspaceParticipantsNoAgents: "暂未使用 Agent";
            readonly workspaceParticipantsAgentCount_one: "使用过 {{count}} 种 Agent";
            readonly workspaceParticipantsAgentCount_other: "使用过 {{count}} 种 Agent";
            readonly workspaceParticipantsOnlineSummary_one: "{{count}} 人类和智能体在线";
            readonly workspaceParticipantsOnlineSummary_other: "{{count}} 人类和智能体在线";
            readonly workspaceParticipantsOverflowAria: "更多 Workspace 成员";
            readonly workspaceXagentsCollab: "xagents 协同";
            readonly workspaceThemeHint: "主题与外观";
            readonly loadingTutti: "正在加载 Tutti…";
            readonly runtimeArtifactStatus: {
                readonly startupTitle: "正在准备 Workspace 运行环境";
                readonly startupDescription: "Tutti 正在准备本机 Workspace 运行环境，完成后会进入登录页或首页。首次启动可能需要几分钟。";
                readonly startupProgressHint: "正在检查本地运行环境文件并准备下载。";
                readonly downloadedOfTotal: "{{downloaded}} / {{total}}";
                readonly progressAria: "Workspace 运行环境下载进度";
                readonly checking: "正在准备工作区环境…";
                readonly downloading: "正在下载工作区环境…";
                readonly downloadingPercent: "正在下载工作区环境… {{percent}}%";
                readonly verifying: "正在完成环境准备…";
                readonly error: "工作区环境准备失败";
                readonly retry: "重试准备";
                readonly retrying: "正在重试…";
                readonly backgroundHint: "你可以先继续使用应用；进入工作区前会自动完成准备。";
                readonly retryHint: "再次进入工作区时会自动重试。";
            };
            readonly workspaceConnecting: "正在准备工作区…";
            readonly workspaceEnterStatus: {
                readonly enterStarted: "正在连接工作区…";
                readonly prepareSandbox: "正在准备沙箱…";
                readonly prepareToolchain: "正在准备工具链…";
                readonly ensureRuntime: "正在启动工作区环境…";
                readonly preAttachToolchain: "正在安装必需工具…";
                readonly attachRuntime: "正在加载工作区…";
                readonly applyProjections: "正在应用工作区文件…";
                readonly applyConfigOverlays: "正在应用配置…";
                readonly syncWorkspacePatch: "正在同步工作区状态…";
                readonly enterSucceeded: "工作区已就绪";
                readonly enterFailed: "进入工作区失败";
                readonly resolvingCanvas: "正在恢复工作区画布…";
                readonly finalizingWorkspace: "正在完成最后准备…";
            };
            readonly roomRenameHint: "点击修改房间名称";
            readonly roomRenameLabel: "房间名称";
            readonly roomBack: "返回";
            readonly roomExitActiveAgentTitle: "离开这个房间？";
            readonly roomExitActiveAgentLead: "这个房间里仍有 Agent 在工作。离开会停止 Agent 进程，并将任务标记为已中断。";
            readonly roomExitActiveAgentConfirm: "离开并中断";
            readonly workspaceAgentSessionDetailToolCalls: "{{count}} 次工具调用";
            readonly workspaceAgentSessionDetailThinking: "思考";
            readonly workspaceAgentSessionDetailWorking: "工作中...";
            readonly workspaceClosingBanner: "这个工作区正在关闭，连接即将断开。";
            readonly workspaceClosingStatus: "工作区关闭中";
            readonly workspaceAgentMessageExpand: "展开全部";
            readonly workspaceAgentActivityStatusWorking: "运行中";
            readonly workspaceAgentActivityStatusWaiting: "等待中";
            readonly workspaceAgentActivityStatusIdle: "已完成";
            readonly workspaceAgentActivityStatusEnd: "已完成";
            readonly workspaceAgentActivityStatusCompleted: "已完成";
            readonly workspaceAgentActivityStatusCanceled: "已取消";
            readonly workspaceAgentActivityStatusFailed: "错误";
            readonly workspaceAgentSessionDetailEmptyWithTimeline: "当前没有可展示的 session 消息。";
            readonly workspaceAgentSessionDetailEmptyNoTimeline: "暂无 session 详情。";
            readonly workspaceAgentSessionDetailOpenFile: "打开 {{path}}";
            readonly shareJoin: {
                readonly status: {
                    readonly checkingTitle: "正在检查邀请";
                    readonly checkingDescription: "正在校验邀请码并进入画布。";
                    readonly successTitle: "已加入房间";
                    readonly successDescription: "工作台列表已刷新，正在打开对应画布。";
                    readonly fullTitle: "房间人数已满";
                    readonly fullDescription: "这个 workspace 的协作者席位已经用完。";
                    readonly usedTitle: "邀请链接已失效";
                    readonly usedDescription: "这个邀请码已经被使用过。";
                    readonly revokedTitle: "邀请链接已失效";
                    readonly revokedDescription: "这个邀请码已经被 owner 作废。";
                    readonly invalidTitle: "无法加入房间";
                    readonly invalidDescription: "请确认链接是否完整，或让 owner 重新生成邀请。";
                    readonly authRequiredTitle: "需要登录";
                    readonly authRequiredDescription: "请先登录，登录后可以重新打开邀请链接继续加入。";
                    readonly defaultTitle: "无法加入房间";
                    readonly defaultDescription: "请确认链接是否完整，或让 owner 重新生成邀请。";
                };
                readonly modal: {
                    readonly eyebrow: "Workspace Share";
                    readonly title: "协作者加入";
                    readonly recognizedRoom: "识别到房间";
                    readonly inviteCodePlaceholder: "输入邀请码";
                    readonly submit: "输入邀请码进入画布";
                    readonly submitting: "进入中…";
                };
            };
            readonly datePicker: {
                readonly placeholder: "年 / 月 / 日";
                readonly displayValue: "{{year}} / {{month}} / {{day}}";
                readonly monthLabel: "{{year}}年{{month}}月";
                readonly previousMonth: "上个月";
                readonly nextMonth: "下个月";
                readonly clear: "清除";
                readonly today: "今天";
                readonly weekdaySun: "日";
                readonly weekdayMon: "一";
                readonly weekdayTue: "二";
                readonly weekdayWed: "三";
                readonly weekdayThu: "四";
                readonly weekdayFri: "五";
                readonly weekdaySat: "六";
            };
            readonly collabResult: {
                readonly title: "协作结果";
                readonly actorFallback: "协作者";
                readonly unread: "{{name}} 已标记任务完成，请查看最新结果。";
                readonly read: "{{name}} 已标记任务完成。";
            };
            readonly agentTool: {
                readonly fallbackName: "使用工具";
                readonly statusWorking: "进行中";
                readonly statusCompleted: "已完成";
                readonly statusFailed: "失败";
                readonly statusCanceled: "已取消";
                readonly statusWaiting: "等待中";
                readonly details: {
                    readonly summary: "摘要";
                    readonly input: "输入";
                    readonly output: "输出";
                    readonly error: "错误";
                    readonly command: "命令";
                    readonly prompt: "任务提示";
                    readonly path: "路径";
                    readonly content: "内容";
                    readonly patch: "补丁";
                    readonly questions: "问题";
                    readonly steps: "步骤";
                    readonly query: "查询";
                    readonly scope: "范围";
                    readonly results: "结果";
                    readonly url: "链接";
                    readonly todos: "待办";
                    readonly skill: "技能";
                    readonly mcp: "MCP";
                    readonly mcpServer: "服务器";
                    readonly mcpTool: "工具";
                    readonly mcpItem: "条目 {{index}}";
                    readonly mcpDoc: "文档 {{index}}";
                    readonly approvalOptions: "审批选项";
                    readonly answerPrefix: "回答：{{answer}}";
                    readonly waitingForAnswer: "等待用户回答…";
                    readonly questionFallback: "问题";
                    readonly delegateSession: "委托会话";
                    readonly subAgents: "子智能体";
                    readonly subAgentStarting: "正在启动…";
                    readonly subAgentQueued: "排队中——等待可用执行槽…";
                    readonly subAgentFallbackName: "子智能体";
                    readonly subAgentEarlierOmitted: "已省略较早的 {{count}} 步";
                    readonly subAgentTask: "任务";
                    readonly subAgentProgress: "进展";
                    readonly missingFailureDetails: "Provider 报告失败，但没有返回失败详情。";
                    readonly noMatches: "没有匹配结果";
                    readonly stepLabel: "步骤 {{index}}";
                    readonly noMatchingTools: "没有匹配的工具";
                    readonly loadedAvailable: "已加载 {{loaded}} 个 · 共 {{available}} 个";
                    readonly contentTruncated: "内容已截断";
                    readonly summaryTruncated: "摘要已截断";
                    readonly rawPayload: "原始载荷";
                    readonly loadingDiff: "正在加载差异…";
                    readonly imagePreviewAlt: "图片生成预览";
                    readonly showFullContent: "展开完整内容（{{count}} 行）";
                    readonly collapseContent: "收起内容";
                    readonly showFullDiff: "展开完整差异（{{count}} 行）";
                };
                readonly labels: {
                    readonly runCommand: "执行命令";
                    readonly readFile: "读取文件";
                    readonly writeFile: "写入文件";
                    readonly editFile: "编辑文件";
                    readonly listFiles: "查看文件";
                    readonly searchFiles: "搜索文件";
                    readonly webSearch: "搜索网页";
                    readonly webFetch: "读取网页";
                    readonly applyPatch: "应用修改";
                    readonly useTool: "使用工具";
                    readonly findFiles: "查找文件";
                    readonly readCommandOutput: "读取命令输出";
                    readonly stopCommand: "停止命令";
                    readonly readNotebook: "读取 Notebook";
                    readonly editNotebook: "编辑 Notebook";
                    readonly updateTodos: "更新待办";
                    readonly delegateAgent: "委托 Agent";
                    readonly closeAgent: "结束 Agent";
                    readonly waitAgent: "等待 Agent";
                    readonly currentIssue: "当前任务";
                    readonly thinking: "思考";
                    readonly responding: "回复";
                    readonly notification: "通知";
                };
            };
            readonly workspaceAgentProbeAvailableAria: "可用";
            readonly workspaceAgentProbeUnavailableAria: "不可用";
            readonly workspaceAgentProbeUnknownAria: "状态未知";
            readonly workspaceAgentProbeDockChecking: "正在检测可用性…";
            readonly workspaceAgentProbeDockNoData: "暂无该房间的探测数据";
            readonly workspaceAgentProbeDockAvailable: "可用";
            readonly workspaceAgentProbeDetailStatus: "状态";
            readonly workspaceAgentProbeDetailQuota: "额度";
            readonly workspaceAgentProbeUsageUnsupported: "暂未接入用量";
            readonly workspaceAgentProbeQuotaResetTimeLabel: "{{label}}重置时间";
            readonly workspaceAgentProbeLoadingUsage: "加载用量中...";
            readonly workspaceAgentProbeScrollListRight: "向右查看更多 Agent";
            readonly workspaceAgentProbeScrollListLeft: "向左查看前面的 Agent";
            readonly workspaceAgentProbeAgentUsage: "用量";
            readonly workspaceAgentProbeQuotaSession: "会话";
            readonly workspaceAgentProbeQuotaWeekly: "每周";
            readonly workspaceAgentProbeQuotaMonthly: "每月";
            readonly workspaceAgentProbeQuotaDaily: "每日";
            readonly workspaceAgentProbeQuotaCost: "费用";
            readonly workspaceAgentProbeErrorAuthRequired: "需要登录";
            readonly workspaceAgentProbeErrorSessionExpired: "会话已过期";
            readonly workspaceAgentProbeErrorSubscriptionRequired: "需要订阅";
            readonly workspaceAgentProbeErrorParseFailed: "无法解析用量输出";
            readonly workspaceAgentProbeErrorNoData: "暂无用量数据";
            readonly workspaceAgentProbeErrorTimeout: "用量探测超时";
            readonly workspaceAgentProbeErrorUnavailable: "用量探测失败";
            readonly roomParticipantsTitle: "房间内的人类";
            readonly roomParticipantsTopbarAria: "Room 成员";
            readonly roomParticipantsInviteAria: "邀请成员";
            readonly roomParticipantsInviteDisabled: "你不是这个房间的创建者，无法发起邀请哦";
            readonly roomParticipantsInviteOwnerOnlyTooltip: "仅支持房主发起邀请";
            readonly roomParticipantsLeaveRoom: "退出房间";
            readonly roomParticipantsInvitedCount_one: "已邀请 {{count}} 位成员";
            readonly roomParticipantsInvitedCount_other: "已邀请 {{count}} 位成员";
            readonly roomParticipantsOwnerBadge: "房主";
            readonly roomParticipantsNoAgents: "暂未使用 Agent";
            readonly roomParticipantsAgentCount_one: "使用过 {{count}} 种 Agent";
            readonly roomParticipantsAgentCount_other: "使用过 {{count}} 种 Agent";
            readonly roomParticipantsOnlineSummary_one: "{{count}} 人类和智能体在线";
            readonly roomParticipantsOnlineSummary_other: "{{count}} 人类和智能体在线";
            readonly roomParticipantsOverflowAria: "更多 Room 成员";
            readonly roomConnecting: "正在准备房间…";
            readonly roomCanvasLoadErrorTitle: "当前房间画布数据加载异常";
            readonly roomCanvasLoadErrorDescription: "未能加载当前房间的画布数据。请刷新后重试。";
            readonly roomCanvasLoadRetry: "刷新";
            readonly roomCanvasLoadRetrying: "刷新中…";
            readonly roomRecoveryRenderFailed: "后端已恢复房间，但未能渲染工作区。请重新加载。";
            readonly runtimeConnectionLostTitle: "运行时连接异常";
            readonly runtimeConnectionLostSummary: "运行时连接未能快速恢复。请重启应用后继续。";
            readonly runtimeConnectionLostLead: "应用会重新启动，并拉起一个新的本机运行时。";
            readonly runtimeConnectionRefresh: "重启应用";
            readonly runtimeConnectionRefreshing: "重启中…";
            readonly runtimeConnectionRefreshSucceeded: "已请求重启应用。";
            readonly roomEntryDiscarded: "未能完成进入房间（可能被新的操作打断），请再试一次。";
            readonly roomEnterStatus: {
                readonly enterStarted: "正在连接房间…";
                readonly prepareSandbox: "正在准备沙箱…";
                readonly prepareToolchain: "正在准备工具链…";
                readonly ensureRuntime: "正在启动工作区环境…";
                readonly runTemplateHook: "正在执行应用初始化…";
                readonly preAttachToolchain: "正在安装必需工具…";
                readonly attachRuntime: "正在加载工作区…";
                readonly applyProjections: "正在应用房间文件…";
                readonly applyConfigOverlays: "正在应用配置…";
                readonly syncWorkspacePatch: "正在同步房间状态…";
                readonly enterSucceeded: "房间已就绪";
                readonly enterFailed: "进入房间失败";
                readonly resolvingCanvas: "正在恢复房间画布…";
                readonly finalizingWorkspace: "正在完成最后准备…";
            };
            readonly simpleMode: {
                readonly pageHeadline: "和伙伴、Agent 一起，在同一个房间里协作";
                readonly fusedButton: {
                    readonly main: "创建协作房间";
                    readonly hint: "拖入文件或文件夹作为起点，伙伴进入后可以一起操作";
                    readonly hintActive: "松开即可用这些内容创建协作房间";
                };
                readonly note: {
                    readonly label: "备注";
                    readonly placeholder: "这个房间是做什么的？（选填）";
                };
                readonly overlayStatus: {
                    readonly creating: "正在准备你们的房间…";
                    readonly generatingInvite: "房间准备好了，正在生成邀请链接…";
                    readonly done: "即将进入房间…";
                    readonly error: "刚刚出了点问题";
                };
                readonly overlayActions: {
                    readonly retry: "重试";
                    readonly dismiss: "回到上一步";
                };
                readonly inviteModal: {
                    readonly title: "把这条链接发给你的伙伴";
                    readonly body: "对方点击链接就能进入同一个房间，你们可以在这里共同操作刚刚拖进来的内容。";
                    readonly linkLabel: "邀请链接";
                    readonly copy: "复制";
                    readonly copied: "已复制";
                    readonly primary: "完成";
                    readonly secondary: "稍后再分享";
                };
            };
            readonly unknownProvider: "未知提供方";
            readonly messages: {
                readonly roomOpened: "已打开房间";
                readonly roomOpenedIssue: "已打开房间，准备定位到对应任务";
                readonly issueTitleRequired: "请先填写任务标题";
                readonly issueCreated: "任务已创建";
                readonly issueUpdated: "任务已更新";
                readonly issueShareLinkCopied: "任务分享链接已复制";
                readonly issueShareFallbackRoomFull: "当前房间已满，已复制仅房间成员可打开的任务链接";
                readonly issueShareFallbackInviteFull: "邀请链接名额已满，已复制仅房间成员可打开的任务链接";
                readonly issueWorkspaceNotReady: "当前 Room Workspace 尚未就绪，请稍后重试";
                readonly issueRunSessionUnavailable: "该次执行未关联可回放 session";
                readonly issueDetailRequiredBeforeRun: "请先打开对应任务详情后再执行";
                readonly issueNoAvailableAgent: "当前没有可用的 Agent";
                readonly issueRunStarted: "已发送到 {{provider}}，可调整后执行";
                readonly issueStatusUpdated: "任务状态已更新";
                readonly issueDeleteForbidden: "仅任务创建者可以删除";
                readonly issueNotFoundOrDeleted: "任务不存在或已被删除";
                readonly issueDeleted: "任务已删除";
                readonly issueContextAdded: "已补充引用资料";
                readonly issueContextRemoved: "已移除引用资料";
                readonly issuePendingUploadAdded: "已加入 {{count}} 项待上传资料";
                readonly issueUploaded: "已上传 {{count}} 项资料";
                readonly issueDirectInstallUnsupported: "当前不支持在这里直接安装 Agent";
                readonly collabCompleted: "该协作任务已完成";
                readonly githubLoginCompleted: "GitHub 登录完成";
                readonly googleLoginCompleted: "Google 登录完成";
            };
            readonly issue: {
                readonly sidebarEyebrow: "任务中心";
                readonly sidebarTitle: "任务列表";
                readonly sidebarHint: "房间成员都能查看任务，快速定位到协作任务。";
                readonly sidebarResizeAria: "调整任务列表宽度";
                readonly create: "新建任务";
                readonly loading: "正在加载任务...";
                readonly empty: "还没有任务，先创建一条来开始协作。";
                readonly metaPriority: "优先级 {{value}}";
                readonly metaDue: "截止 {{value}}";
                readonly stageEyebrow: "任务中心全流程";
                readonly stageTitle: "以任务为中心，把上下文、执行与产物串成一条完整链路。";
                readonly stageDescription: "房间里先建立任务对象，再引用 Files 补充资料，最后由协作者手动使用自己的 Agent 发起执行。";
                readonly shareThisIssue: "分享这个任务";
                readonly flowList: "查看任务";
                readonly flowCreate: "新建任务";
                readonly flowContext: "引用 Files";
                readonly flowDetail: "查看详情";
                readonly flowRun: "决定执行方式";
                readonly flowOutput: "查看产物";
                readonly currentFocusTitle: "当前 Focus";
                readonly currentFocusSubtle: "当前选中的任务会在这里浓缩展示，帮助你快速进入下一步。";
                readonly currentFocusEmpty: "先从左侧选择任务，或创建一个新的任务来开启执行流程。";
                readonly defaultDescription: "补充背景、现象与期望结果，让这个任务更容易被协作者接手。";
                readonly metricReferences: "引用资料";
                readonly metricRunHistory: "执行历史";
                readonly metricOutputs: "最新产物";
                readonly countFiles: "{{count}} 个";
                readonly countRuns: "{{count}} 次";
                readonly executionModeTitle: "执行方式";
                readonly executionModeSubtle: "V1 统一采用“分享链接进入任务，再手动用自己的 Agent 执行”。";
                readonly executionMyAgentTag: "我的 Agent";
                readonly executionMyAgentDescription: "在详情页直接发起一次 Run，执行结果回写到 Files。";
                readonly executionShareTag: "分享链接";
                readonly executionShareDescription: "把协作者带到同一个任务，再由对方手动点击执行，避免 V1 做自动代跑。";
                readonly outputsTitle: "执行产物";
                readonly outputsSubtle: "执行完成后，摘要、最近 Run 与 Files 会形成闭环。";
                readonly outputsEmpty: "暂无执行产物";
                readonly fileFallback: "file";
                readonly detailEyebrow: "任务详情";
                readonly collapse: "收起";
                readonly detailLoading: "正在加载详情…";
                readonly overviewTitle: "概览";
                readonly overviewSubtle: "创建后进入详情页，补充资料并决定由谁执行。";
                readonly runWithMyAgent: "用我的 Agent 执行";
                readonly rerunWithMyAgent: "再次用我的 Agent 执行";
                readonly summaryPriority: "优先级";
                readonly summaryDueDate: "截止时间";
                readonly summaryReferences: "引用资料";
                readonly summaryRunHistory: "执行历史";
                readonly noDescription: "暂无描述";
                readonly shareTipCanInvite: "可分享给房间内外协作者，首次打开将自动进入该任务。";
                readonly shareTipRoomFull: "当前房间已满，仅房间内成员可通过该链接打开此任务。";
                readonly referencesTitle: "引用资料";
                readonly referencesSubtle: "从 Room Workspace 中选择上下文文件，添加为任务资料。";
                readonly addReferences: "引用 Files";
                readonly referencesEmpty: "暂无引用资料，建议先补充执行上下文。";
                readonly runResultTitle: "执行结果";
                readonly prepareRunTitle: "准备执行";
                readonly runResultSubtle: "查看最新执行结果、产物与历史 Run，并支持再次发起执行。";
                readonly prepareRunSubtle: "创建后进入详情页，完成资料补充，再决定执行方式。";
                readonly runHeroTitle: "我的 Agent · Run {{runId}}";
                readonly runSummaryEmpty: "暂无执行结果";
                readonly runStatusRunning: "执行中，正在等待最新进展";
                readonly runStatusCompleted: "执行已结束，暂未返回摘要";
                readonly runStatusFailed: "执行失败，暂未返回错误摘要";
                readonly runDetailsLoading: "正在加载该次 Run 的执行明细…";
                readonly runOutputsEmpty: "产物稍后会出现在 Files 中。";
                readonly prerunEmpty: "还没有执行记录。建议先补充引用资料，再点击“用我的 Agent 执行”。";
                readonly shareWithCollaborator: "分享链接给协作者";
                readonly historyTitle: "执行历史";
                readonly historyHint: "点击切换到对应 Run 结果";
                readonly currentRunOutputsTitle: "本次 Run 产物";
                readonly currentRunOutputsSubtle: "执行产物会写回 Room，可预览并继续复用。";
                readonly currentRunOutputsEmpty: "当前 Run 暂无产物文件。";
                readonly directoryViewTitle: "目录视图";
                readonly directoryViewSubtle: "如果 Run 产出一个目录，这里会联动展示目录下文件。";
                readonly directoryViewEmpty: "还没有可联动展示的产物目录。";
                readonly directoryKind: "DIR";
                readonly fileKind: "FILE";
                readonly createTitle: "新建任务";
                readonly createSubtle: "填写需求与描述，让任务进入可执行状态。";
                readonly fieldTitle: "标题";
                readonly titlePlaceholder: "请输入任务标题";
                readonly fieldDescription: "需求描述";
                readonly descriptionPlaceholder: "补充背景、现象、影响范围与期望结果";
                readonly descriptionPlaceholderLegacy: "描述任务背景、目标和期望结果。";
                readonly fieldPriority: "优先级";
                readonly priorityOptionMedium: "中";
                readonly priorityOptionHigh: "高";
                readonly priorityOptionLow: "低";
                readonly fieldDueDate: "截止时间";
                readonly attachmentsOptional: "资料（可选）";
                readonly attachmentsEmpty: "还没有加入任何资料";
                readonly createReferencesTitle: "引用 Files";
                readonly createReferencesSubtle: "从房间 Workspace 中选择上下文文件，沉淀为任务资料。";
                readonly selectReferences: "选择引用";
                readonly selectionNone: "暂未选择文件";
                readonly selectionCount: "已选择 {{count}} 个文件";
                readonly selectionEmpty: "暂未选择资料。";
                readonly saveIssue: "保存任务";
                readonly contextPickerCreateTitle: "引用 Files";
                readonly contextPickerDetailTitle: "补充引用资料";
                readonly contextPickerSubtle: "从 Room Workspace 选择执行上下文文件。";
                readonly contextPickerEmpty: "还没有选中的文件。";
                readonly completeReferences: "完成引用";
                readonly addToIssue: "添加到任务";
                readonly addingToIssue: "添加中...";
                readonly dueDateUnset: "未设置";
                readonly runTimeJustNow: "刚刚";
                readonly createdJustNow: "刚刚创建";
                readonly searchPlaceholder: "搜索任务";
                readonly sidebarEmpty: "这里将呈现房间的任务";
                readonly sidebarCategoryEmpty: "此分类下暂无任务";
                readonly searchEmptyTitle: "没有匹配的任务";
                readonly searchEmptyDescription: "换个关键词再试试。";
                readonly defaultEmptyTitle: "还没有任务";
                readonly defaultEmptyDescription: "新建任务，补充需求描述和相关文件，即可委托他人或自己的 Agent 执行任务";
                readonly defaultSelectTitle: "选择一个任务";
                readonly defaultSelectDescription: "从左侧列表进入详情，或者新建一个新的协作任务。";
                readonly editTitle: "编辑任务";
                readonly uploadFile: "上传文件";
                readonly uploadFolder: "上传文件夹";
                readonly referenceWorkspaceFiles: "引用空间文件";
                readonly pendingUploadArchiveHint: "创建任务后自动归档到资料目录";
                readonly latestExecutionTitle: "最新执行状态";
                readonly executionRecordsTitle: "执行记录";
                readonly viewDetails: "查看详情";
                readonly copyLink: "复制链接";
                readonly copyingLink: "复制中...";
                readonly inviteCollaborator: "邀请协作";
                readonly shareWithCollaboratorHint: "发给协作者，对方可用 Agent 帮你执行";
                readonly summaryTitle: "需求摘要";
                readonly outputsTitleLegacy: "产物";
                readonly filePickerTitle: "选择要加入任务的资料";
                readonly searchRoomFilesPlaceholder: "搜索 Files...";
                readonly noReferenceFiles: "暂无可引用文件";
                readonly selectReferenceRequired: "必须选择一个进行引用";
                readonly expandItem: "展开 {{label}}";
                readonly collapseItem: "收起 {{label}}";
                readonly toggleSelection: "切换选择 {{label}}";
                readonly selectionCountShort: "已选择 {{count}} 项";
                readonly currentPreview: "当前预览";
                readonly previewPrompt: "选择左侧资料即可预览内容";
                readonly previewPromptCompact: "选择上方资料即可预览内容";
                readonly filePickerDirectoryPreview: "选择左侧其他文件即可切换预览";
                readonly filePickerDirectoryPreviewCompact: "选择上方其他文件即可切换预览";
                readonly contextEmpty: "暂未引用资料";
                readonly openReference: "打开引用资料 {{label}}";
                readonly outputsEmptyCompact: "暂无产物";
                readonly openOutput: "打开产物 {{label}}";
                readonly scrollFiltersLeft: "向左滚动任务分类";
                readonly scrollFiltersRight: "向右滚动任务分类";
                readonly edit: "编辑";
                readonly runStarting: "发起中...";
                readonly runtimeUnavailable: "当前 runtime 不可用";
                readonly unavailable: "不可用";
                readonly install: "安装";
                readonly installing: "安装中…";
                readonly sync: "同步";
                readonly syncing: "同步中…";
                readonly filterAll: "全部";
                readonly statusAriaLabel: "任务状态";
                readonly priorityAriaLabel: "任务优先级";
                readonly metaCreator: "创建者 {{value}}";
                readonly metaCreatedAt: "创建时间 {{value}}";
                readonly metaDueAt: "截止时间 {{value}}";
                readonly metaCompletedAt: "完成时间 {{value}}";
                readonly requesterFallback: "用户";
                readonly agentCodex: "Codex";
                readonly agentClaudeCode: "Claude Code";
                readonly agentTutti: "Tutti";
                readonly agentHermes: "Hermes";
                readonly agentOpenClaw: "OpenClaw";
                readonly statusNotStarted: "待执行";
                readonly statusRunning: "执行中";
                readonly statusPendingAcceptance: "待验收";
                readonly statusCompleted: "已完成";
                readonly statusFailed: "执行失败";
                readonly statusCanceled: "已取消";
                readonly priorityHigh: "高优";
                readonly priorityMedium: "中等";
                readonly priorityLow: "低优";
            };
            readonly roomIssueNode: {
                readonly statusTabAll: "全部";
                readonly statusTabNotStarted: "未启动";
                readonly statusTabRunning: "执行中";
                readonly statusTabPendingAcceptance: "待验收";
                readonly statusTabCompleted: "已完成";
                readonly emptyContent: "暂无内容";
                readonly taskCount_one: "{{count}} 个子任务";
                readonly taskCount_other: "{{count}} 个子任务";
                readonly taskCountEmpty: "暂无子任务";
                readonly taskRunningCount: "{{count}} 个执行中";
                readonly taskPendingAcceptanceCount: "{{count}} 个待验收";
                readonly taskCompletedCount: "{{count}} 个已完成";
                readonly issueStatusNotStarted: "待开始";
                readonly issueStatusRunning: "执行中";
                readonly issueStatusInProgress: "执行中";
                readonly issueStatusPendingAcceptance: "待验收";
                readonly issueStatusCompleted: "已完成";
                readonly issueStatusFailed: "失败";
                readonly issueStatusCanceled: "已取消";
                readonly issueStatusUnknown: "未知状态";
                readonly runStatusRunning: "执行中";
                readonly runStatusCompleted: "已完成";
                readonly runStatusFailed: "失败";
                readonly runStatusCanceled: "已取消";
                readonly runStatusIdle: "未开始";
                readonly issueTitleRequired: "请输入任务标题";
                readonly taskTitleRequired: "请输入任务标题";
                readonly selectTaskFirst: "请先选择一个任务";
                readonly deleteTaskDialogTitle: "删除任务";
                readonly deleteTaskConfirm: "确认删除任务「{{title}}」吗？";
                readonly deleteIssueDialogTitle: "删除子任务";
                readonly deleteIssueConfirm: "确认删除子任务「{{title}}」吗？";
                readonly issueTaskUnavailable: "当前任务缺少所属任务，暂时无法继续操作";
                readonly shareCopied: "邀请链接已复制";
                readonly outputOpenUnavailable: "当前没有可打开的产物";
                readonly sessionUnavailable: "当前没有可打开的会话";
                readonly editTask: "编辑任务";
                readonly createTask: "新建任务";
                readonly taskEditorLead: "补充任务标题和描述，方便继续推进执行。";
                readonly taskTitlePlaceholder: "请输入任务标题";
                readonly taskContentPlaceholder: "补充任务背景、目标和验收预期";
                readonly saveTask: "保存任务";
                readonly cancel: "取消";
                readonly noTaskTitle: "还没有任务";
                readonly noTaskDescription: "新建任务，补充需求描述和相关文件，即可委托他人或自己的 Agent 执行任务";
                readonly favoriteTask: "收藏任务";
                readonly creator: "创建者";
                readonly createdAt: "创建时间";
                readonly edit: "编辑";
                readonly delete: "删除";
                readonly description: "描述";
                readonly emptyTaskContent: "暂未补充任务描述";
                readonly emptyIssueContent: "暂未补充子任务描述";
                readonly references: "引用文件";
                readonly emptyReferences: "暂未引用文件";
                readonly editIssue: "编辑子任务";
                readonly createIssue: "新增子任务";
                readonly issueTitlePlaceholder: "请输入子任务标题";
                readonly issueContentPlaceholder: "补充子任务目标、执行方式和验收标准";
                readonly saveIssue: "保存子任务";
                readonly issueSelectionHint: "选择一个任务后，这里会展示任务详情与 Agent 执行状态";
                readonly timeLabel: "时间 {{value}}";
                readonly updatedAtLabel: "更新时间";
                readonly runNotStarted: "暂无执行记录";
                readonly issueDetailsLoading: "正在加载任务详情…";
                readonly agentExecution: "Agent 执行";
                readonly noIssuesTitle: "还没有任务";
                readonly noIssuesTaskShellDescription: "你可以围绕当前任务继续添加子任务";
                readonly taskExecutionTitle: "任务执行中";
                readonly taskExecutionDescription: "当前进展会显示在这里，需要补充新的方向时，可继续新增子任务";
                readonly deleteIssue: "删除子任务";
                readonly searchPlaceholder: "搜索任务";
                readonly refreshTasksAria: "刷新任务列表";
                readonly collapseTaskList: "收起任务列表";
                readonly expandTaskList: "展开任务列表";
                readonly noTasksForFilterTitle: "当前筛选条件下暂无任务";
                readonly noTasksForFilterBody: "试试切换筛选条件，或者新建一个任务";
                readonly loadMore: "加载更多";
                readonly issuesSection: "子任务";
                readonly createSubtask: "添加";
                readonly createSubtaskTitle: "添加子任务";
                readonly editSubtask: "编辑子任务";
                readonly saveSubtask: "保存子任务";
                readonly issueTableTitle: "标题";
                readonly issueTableDescription: "描述";
                readonly issueTableStatus: "状态";
                readonly issueTableOwner: "执行者";
                readonly issueTableTime: "时间";
                readonly issueTableActions: "操作";
                readonly unassigned: "待分配";
                readonly view: "查看";
                readonly share: "分享";
                readonly run: "启动";
                readonly inviteCollaborator: "邀请协作";
                readonly askAgentToRun: "发送给 Agent";
                readonly moreActions: "更多操作";
                readonly closeIssueDrawerAria: "关闭任务详情抽屉";
                readonly runWithProvider: "用 {{provider}} 执行";
                readonly noIssues: "当前任务下暂无子任务。";
                readonly noManualIssues: "新增子任务后，这里会展示后续跟进内容。";
                readonly currentMember: "我";
                readonly closeWindowAria: "关闭 {{title}}";
            };
            readonly workspaceSidebarRuntimeTitle: "运行时";
            readonly workspaceSidebarRuntimeDescription: "当前画布的实时上下文。";
            readonly workspaceSidebarLiveBadge: "在线";
            readonly workspaceSidebarRootPrefix: "根目录：";
            readonly workspaceSidebarSandboxPrefix: "沙箱：";
            readonly workspaceSidebarSessionsPrefix: "会话：";
            readonly workspaceSidebarProviderPrefix: "提供方：";
            readonly workspaceSidebarTreeTitle: "目录树";
            readonly workspaceSidebarTreeDescription: "运行时可见的房间结构。";
            readonly workspaceSidebarTreeKindDir: "目录";
            readonly workspaceSidebarTreeKindFile: "文件";
            readonly workspaceSidebarProfileMe: "我";
            readonly profile: {
                readonly openMenu: "打开用户菜单";
                readonly accountSettings: "用户信息";
                readonly accountSettingsTitle: "用户信息";
                readonly accountSettingsLead: "更新你在各房间中显示的用户名和头像。";
                readonly accountSettingsNameLabel: "用户名";
                readonly accountSettingsNamePlaceholder: "输入用户名";
                readonly accountSettingsAvatarLabel: "头像";
                readonly accountSettingsUpload: "上传图片";
                readonly accountSettingsDefaultAvatars: "默认头像";
                readonly accountSettingsInvalidImage: "请选择有效的图片文件。";
                readonly accountSettingsImageTooLarge: "图片大小不能超过 2 MB。";
                readonly accountSettingsCropTitle: "裁剪头像";
                readonly accountSettingsCropZoom: "缩放";
                readonly accountSettingsCropRotation: "旋转";
                readonly accountSettingsCropCancel: "取消裁剪";
                readonly accountSettingsCropApply: "使用图片";
                readonly accountSettingsSaved: "账户设置已保存。";
                readonly themeSystem: "跟随系统";
                readonly themeLight: "浅色";
                readonly themeDark: "深色";
                readonly language: "语言";
                readonly logout: "退出登录";
                readonly logoutDone: "退出登陆成功";
                readonly labTitle: "实验室";
                readonly labDirectVMTerminalTitle: "VM 终端";
                readonly labDirectVMTerminalDescription: "在启动页显示一个入口，直接打开托管 Linux VM 内的 shell";
                readonly labDebugTerminalTitle: "调试终端";
                readonly labDebugTerminalDescription: "在房间 dock 中显示绑定工作区的调试终端";
            };
            readonly launch: {
                readonly navLaunch: "开始";
                readonly navTemplates: "场景模板";
                readonly navManageAgents: "管理智能体";
                readonly navConnectors: "连接器";
                readonly navVMTerminal: "VM 终端";
                readonly vmTerminalStarting: "正在启动 VM...";
                readonly vmTerminalRetry: "重试";
                readonly vmTerminalSessionLost: "VM 终端会话已断开。";
                readonly vmTerminalProcessExited: "[进程已退出，退出码 {{exitCode}}]";
                readonly manageAgentsTitle: "管理智能体";
                readonly dock: {
                    readonly agentNotInstalled: "未检测到本机配置，请完成本地安装后再同步。";
                    readonly agentNotSynced: "检测到本机配置，是否立即同步？";
                };
                readonly manageAgentsGuideLead: "同步或移除只影响 Tutti，不会改动你电脑上的智能体。";
                readonly manageAgentsColumnAgent: "智能体";
                readonly manageAgentsColumnRun: "运行在";
                readonly manageAgentsColumnInstallStatus: "同步状态";
                readonly manageAgentsColumnSettings: "配置";
                readonly manageAgentActionInstall: "同步";
                readonly manageAgentActionSync: "同步";
                readonly manageAgentActionSyncTooltip: "将自动同步你的本机配置";
                readonly manageAgentRuntimeArtifactPreparingTooltip: "工作区环境仍在准备中，完成后即可同步。";
                readonly manageAgentActionUninstall: "移除";
                readonly manageAgentActionInstalling: "正在同步…";
                readonly manageAgentActionSyncing: "正在同步…";
                readonly manageAgentActionRetry: "重试";
                readonly manageAgentActionUninstalling: "正在移除…";
                readonly manageAgentActionUninstallWaiting: "等待移除…";
                readonly manageAgentUninstallConfirm: "只会从 Tutti 中移除 {{name}}，不会影响 Tutti 以外的应用、登录状态或配置。";
                readonly manageAgentCellRunsLocal: "Tutti 本地";
                readonly manageAgentCellInstalled: "已同步";
                readonly manageAgentCellNotInstalled: "未同步";
                readonly manageAgentUninstallWaiting: "等待移除";
                readonly manageAgentUninstallRemoving: "正在移除";
                readonly manageAgentDownloadDownloading: "正在下载 {{agent}} · {{percent}}";
                readonly manageAgentDownloadRetrying: "正在重试下载 · {{attempt}}/{{max}}";
                readonly manageAgentDownloadFailed: "下载失败";
                readonly manageAgentDownloadWaitingInstall: "等待安装";
                readonly manageAgentDownloadInstalling: "正在安装";
                readonly manageAgentConfigWillUse: "检测到本机配置";
                readonly manageAgentConfigWillSyncFrom: "同步后会沿用 {{device}} 上的 {{agent}} 配置";
                readonly manageAgentConfigSynced: "已同步 · {{time}}";
                readonly manageAgentConfigSyncedNoTime: "已同步";
                readonly manageAgentConfigSyncedFrom: "已从 {{device}} 同步到 Tutti · {{time}}";
                readonly manageAgentConfigSyncedFromNoTime: "已从 {{device}} 同步到 Tutti";
                readonly manageAgentConfigNone: "未发现配置";
                readonly manageAgentConfigNotDetected: "未检测到本机配置";
                readonly manageAgentMissingHostConfigTooltip: "{{agent}} 依赖你的本地安装，请先完成本地安装再进行同步";
                readonly manageAgentTuttiDefaultConfig: "Tutti 默认配置";
                readonly manageAgentHostDeviceFallback: "这台电脑";
                readonly manageAgentSyncTimeJustNow: "刚刚";
                readonly manageAgentSyncTimeMinutesAgo: "{{count}} 分钟前";
                readonly manageAgentSyncTimeHoursAgo: "{{count}} 小时前";
                readonly manageAgentSyncTimeDaysAgo: "{{count}} 天前";
                readonly manageAgentsOpenclawHint: "若要在房间内使用 OpenClaw，请前往管理智能体同步 OpenClaw。";
                readonly kicker: "Tutti · 桌面工作台";
                readonly promoBadge: "你目前有 {{count}} 个可用 agents，可以在房间内使用它们。";
                readonly promoBadgeNavigateAria: "前往管理智能体，你目前有 {{count}} 个可用 agents";
                readonly heroTitle: "首个多人与多 agent 实时协作 OS";
                readonly updateAction: "更新";
                readonly updateInstallingAction: "重启更新";
                readonly updateDownloadingAction: "更新中 {{percent}}";
                readonly updateCardAvailableTitle: "版本 {{version}} 可用";
                readonly updateCardAvailableDetail: "准备好时再开始下载，不会打断当前操作。";
                readonly updateCardDownloadingTitle: "正在下载 {{version}}";
                readonly updateCardDownloadingDetail: "更新包正在后台下载。";
                readonly updateCardDownloadedTitle: "更新已准备就绪";
                readonly updateCardDownloadedDetail: "重启 Tutti 后即可完成 {{version}} 的安装。";
                readonly updateCardDownloadAction: "下载更新";
                readonly updateCardInstallAction: "重启并安装";
                readonly sectionSpacesTitle: "房间";
                readonly sectionAgentsTitle: "Agents";
                readonly sectionAgentsAction: "管理";
                readonly sectionAgentsEmpty: "你暂无任何可用 Agents";
                readonly sectionAgentsInstallAction: "立即装载";
                readonly viewAllRooms: "查看全部";
                readonly roomsExpand: "展开更多 ({{count}})";
                readonly roomsCollapse: "收起";
                readonly roomsLoadMore: "加载更多";
                readonly roomsEmptyPlaceholder: "暂未创建或加入房间";
                readonly recommendedTemplatesTitle: "场景模板";
                readonly recommendedTemplatesViewMore: "更多";
                readonly topRailOpenCreateAria: "创建新房间，在弹窗中输入房间名称";
                readonly topRailOpenJoinAria: "加入已有房间，在弹窗中粘贴分享链接";
                readonly roomCardStatusActive: "进行中";
                readonly roomCardStatusIdle: "空闲";
                readonly roomCardStatusFailed: "失败";
                readonly roomCardPreviewActorUser: "用户";
                readonly roomCardPreviewPlaceholder: "房间内暂无最新状态";
                readonly roomCardSnapshotAria: "「{{name}}」最近可视状态";
                readonly roomCardHumansCount_one: "{{count}} 人";
                readonly roomCardHumansCount_other: "{{count}} 人";
                readonly roomCardAgentsCount_one: "{{count}} 个 Agent";
                readonly roomCardAgentsCount_other: "{{count}} 个 Agent";
                readonly roomCardOnline: "在线";
                readonly roomCardAgentFallback: "Agent";
                readonly roomCardAgentsAria: "「{{name}}」中 {{count}} 个活跃 Agent";
                readonly roomCardOpenRoomAria: "进入房间 {{name}}";
                readonly roomCardMoreActions: "房间操作菜单";
                readonly roomCardRenameWorkspace: "重命名";
                readonly roomRenameDialogTitle: "重命名房间";
                readonly roomRenameDialogLead: "请输入该房间的新显示名称。";
                readonly roomRenamePlaceholder: "房间名称";
                readonly roomCardAvatarsAria: "「{{name}}」参与者头像";
                readonly roomsDirectoryLead: "浏览并进入你参与过的所有房间。";
                readonly roomsDirectoryEmpty: "暂无房间记录。你可以在「开始」页创建或加入房间。";
                readonly sectionTemplatesTitle: "agent竞技场";
                readonly sectionOfficeSpaceTitle: "办公";
                readonly officeScenario1Title: "OPC一人团队";
                readonly officeScenario1Description: "一人掌控多个 Agent，高效完成复杂任务";
                readonly officeScenario2Title: "协同代办";
                readonly officeScenario2Description: "将任务发给朋友电脑里的 agent，协同完成报销、整理等事务，可通过物理终端直连，安全性高";
                readonly taskCenterTitle: "协同代办";
                readonly taskCenterDescription: "新建一个协作房间，马上开始整理任务、分派成员和跟进进度。";
                readonly officeScenario3Title: "组织协作";
                readonly officeScenario3Description: "多人多 Agent 实时协同，过程与成果全局共享";
                readonly sectionCollaborateSpaceTitle: "开发与交付";
                readonly sectionContentCreationSpaceTitle: "内容创作";
                readonly sectionMore: "更多";
                readonly sectionMoreAriaComingSoon: "更多，即将推出";
                readonly sectionMoreComingSoonHint: "即将推出";
                readonly betaGateCheckingTitle: "正在检查内测权限";
                readonly betaGateCheckingBody: "我们正在确认当前账号是否已经拥有 Tutti 内测资格";
                readonly betaGateBlockedTitle: "当前账号暂未获得内测资格";
                readonly betaGateBlockedBody: "输入邀请码以解锁 Tutti 桌面端内测";
                readonly betaGateInviteCodeLabel: "邀请码";
                readonly betaGateInviteCodePlaceholder: "输入邀请码";
                readonly betaGateInviteCodeRequired: "请先输入邀请码。";
                readonly betaGateRetry: "重新检测";
                readonly betaGateSubmit: "验证邀请码";
                readonly betaGateBackToLogin: "退出登录";
                readonly betaGateSubmitting: "验证中…";
                readonly betaGateSubmitSuccess: "邀请码已通过";
                readonly betaGateSubmitFailed: "验证邀请码失败。";
                readonly betaGateLoadFailed: "加载内测状态失败。";
                readonly scenarioCloneUseHint: "克隆并使用场景模板";
                readonly contentScenario1Title: "产品原型";
                readonly contentScenario1Description: "产品经理、设计师与智能Agent同步工作，快速生成高度匹配需求的原型方案。";
                readonly contentScenario2Title: "PPT制作";
                readonly contentScenario2Description: "多个智能Agent协作，从内容框架、设计到排版，美化一气呵成。";
                readonly contentScenario3Title: "视频创作";
                readonly contentScenario3Description: "不同Agent协同操作，实时生成脚本、分镜与剪辑，极速产出高质量视频。";
                readonly templatesLoading: "正在加载场景模板…";
                readonly templatesLoadFailed: "场景模板加载失败。";
                readonly templatesRetry: "重试";
                readonly templatesEmpty: "当前暂无可用场景模板。";
                readonly templatePlayCta: "玩一玩";
                readonly collaborateSlotHoverCta: "即将推出";
                readonly scenarioBadgeCollaborate: "协同";
                readonly scenarioBadgeGame: "游戏";
                readonly templateVersion: "版本 {{version}}";
                readonly templatePlaceholderTitle: "场景模板";
                readonly templatePlaceholderHint: "即将接入";
                readonly templateGomokuTitle: "五子棋对局";
                readonly templateGomokuDescription: "AI协助决策，优化每一步棋局布局，挑战极限智力对抗。";
                readonly templateTexasHoldemTitle: "德州扑克博弈";
                readonly templateTexasHoldemDescription: "实时分析和调整策略，比拼你的agent智能程度。";
                readonly templateChineseChessTitle: "象棋对弈";
                readonly templateChineseChessDescription: "AI深度策略引导，模拟真人对弈，享受人机对抗的极致体验。";
                readonly collaborateDemoBuildTitle: "日常开发";
                readonly collaborateDemoBuildDescription: "为团队全体成员提供统一的协同开发环境，任务与上下文自然流转";
                readonly collaborateDevAcceptanceTitle: "自动化测试验收";
                readonly collaborateDevAcceptanceDescription: "自动搭建测试环境，让房间快速执行测试和验收";
                readonly collaborateUnifiedWorkbenchTitle: "一站式工作台";
                readonly collaborateUnifiedWorkbenchDescription: "集成各类应用与 Agent，统一编排与执行任务";
                readonly intentCreateTitle: "创建新房间";
                readonly intentCreateBody: "邀请伙伴及其 AI 智能体一起协作";
                readonly intentLocalDirTitle: "加入已有房间";
                readonly intentLocalDirBody: "粘贴分享链接即可进入房间";
                readonly intentCreateSecondaryCta: "创建";
                readonly intentJoinSecondaryCta: "通过链接加入";
                readonly agentToolNameOpenclaw: "OpenClaw";
                readonly agentToolNameClaudeCodeRouter: "Claude Code Router";
                readonly openclawBlockTitle: "需要 OpenClaw？";
                readonly openclawBlockBody: "可一键开启：保存后，在「开始」里「创建并进入」新房间时会按官方流程安装并接入；若已装过，也会标记为之后新房间默认使用。";
                readonly openclawOneClickCta: "一键启用 OpenClaw";
                readonly openclawEnabledHint: "已启用，新房间将默认接入";
                readonly openclawOneClickSaveDone: "已启用 OpenClaw 并保存";
                readonly headline: "从一块房间画布开始";
                readonly lead: "为运行时、终端与 Agent 建立独立分区。命名并创建房间即可进入画布；也可以连接已有环境，或从最近记录一键继续。";
                readonly step1: "创建房间，获得隔离的运行时与沙箱目录。";
                readonly step2: "在画布上编排终端、任务与文档，用分区区隔不同工作流。";
                readonly step3: "进入画布，在房间内运行终端与 Agent。";
                readonly cardTitle: "创建房间";
                readonly cardHint: "使用能区分任务或迭代的名称，便于在历史与协作中识别。";
                readonly namePlaceholder: "例如：acme-web-refactor";
                readonly creating: "创建中…";
                readonly createCta: "创建并进入画布";
                readonly recentTitle: "最近使用";
                readonly joinWorkspaceCancel: "取消";
                readonly joinLinkPlaceholder: "粘贴分享链接";
                readonly joinLinkSubmit: "立即进入";
                readonly joinLinkParseError: "无法识别该内容，请粘贴有效链接";
                readonly joinInviteCodeNextHint: "已识别房间，请输入邀请码加入";
                readonly runtimeEntryNamePlaceholder: "输入房间名称";
                readonly runtimeEntryCreating: "处理中…";
                readonly intentEntryModalConfirm: "确认";
                readonly runtimeEntryCheckingBetaAccess: "检测内测资格中";
                readonly runtimeEntryCreateSubmit: "立即开始";
                readonly sidebarWorkspace: "我的房间";
                readonly sidebarRecents: "最近";
                readonly sidebarNoRecents: "暂无最近房间。";
                readonly ownedWorkspaces: "我的房间";
                readonly sharedWorkspaces: "与我共享";
                readonly recentWorkspaces: "最近房间";
                readonly unnamedWorkspace: "未命名房间";
                readonly workspaceRoleOwner: "管理者";
                readonly workspaceRoleCollaborator: "协作者";
                readonly sidebarSearchPlaceholder: "搜索…";
                readonly sidebarNewWorkspace: "新建房间";
                readonly resizeSidebar: "调整侧边栏宽度";
                readonly sidebarDeleteWorkspace: "删除房间";
                readonly sidebarDeleteWorkspaceConfirmTitle: "删除这个房间？";
                readonly sidebarDeleteWorkspaceConfirm: "“{{name}}” 会被对这个房间里的所有人删除，而且无法恢复。";
                readonly sidebarDeleteWorkspaceSuccess: "房间已删除。";
                readonly sidebarDeleteWorkspaceForbidden: "只有房间所有者可以删除这个房间。";
                readonly sidebarDeleteWorkspaceNotFound: "这个房间不存在，或已经被删除。";
                readonly sidebarLeaveWorkspace: "退出房间";
                readonly sidebarLeaveWorkspaceConfirmTitle: "退出这个房间？";
                readonly sidebarLeaveWorkspaceConfirm: "你将退出“{{name}}”。若仍有权限，之后可以再次进入。";
                readonly sidebarWorkspaceAgents_one: "{{count}} 个智能体";
                readonly sidebarWorkspaceAgents_other: "{{count}} 个智能体";
                readonly sidebarWorkspaceDemoOnly: "演示";
                readonly createWorkspacePaneTitle: "创建房间";
                readonly createWorkspacePaneLead: "房间是本地 Agent 协同的场所。";
                readonly createWorkspaceNameLabel: "输入房间名称";
                readonly createWorkspaceSourceDirectory: "源目录";
                readonly createWorkspaceSourceBrowse: "浏览…";
                readonly createWorkspaceSourceHint: "Agent 将对此文件夹拥有读 + 写权限。";
                readonly createWorkspaceVisibility: "可见范围";
                readonly createWorkspaceVisibilityPrivate: "私有";
                readonly createWorkspaceVisibilityPrivateHint: "仅你本人，不邀请他人。";
                readonly createWorkspaceVisibilityTeam: "团队";
                readonly createWorkspaceVisibilityTeamHint: "邀请指定成员。";
                readonly createWorkspaceVisibilityPublic: "公开";
                readonly createWorkspaceVisibilityPublicHint: "持有链接的用户可申请加入。";
                readonly createFormCancel: "取消";
                readonly createFormSubmit: "创建房间";
            };
            readonly connector: {
                readonly title: "连接器";
                readonly vmManaged: "由 VM 托管";
                readonly tabsAria: "连接器分区";
                readonly tabMcpServers: "MCP Servers";
                readonly tabSkills: "Skills";
                readonly registryReadError: "无法读取本机 MCP 注册表：{{detail}}";
                readonly statusApplyingRuntime: "正在应用 MCP 运行时配置…";
                readonly statusMcpEnabledRuntimeErrors: "MCP 已启用，但运行时出现错误";
                readonly installFailedForServer: "{{serverId}} 安装失败";
                readonly statusMcpRuntimeConfigured: "MCP 运行时配置已更新";
                readonly statusMcpRegistrySaved: "MCP 注册表已保存";
                readonly statusSkippedUntilSignedIn: "；需登录后才启用：{{servers}}";
                readonly statusOpeningFigmaSignIn: "正在打开 Figma 登录…";
                readonly statusFigmaConnected: "Figma 已连接";
                readonly statusFigmaDisconnected: "已断开 Figma，并从 Agent 中移除";
                readonly statusOpeningGoogleSignIn: "正在打开 Google 登录…";
                readonly statusGoogleConnected: "Google 已连接";
                readonly statusGoogleDisconnected: "已断开 Google 连接器，并从 Agent 中移除";
                readonly statusOpeningNotionSignIn: "正在打开 Notion 登录…";
                readonly statusNotionConnected: "Notion 已连接";
                readonly statusNotionDisconnected: "已断开 Notion，并从 Agent 中移除";
                readonly builtinSectionTitle: "Built-in MCP";
                readonly builtinSectionSubtitle: "启用内置 MCP Server 一次后，tsh 会为每个 Agent 自动注入。";
                readonly enabledCountBadge: "已启用 {{count}} 个";
                readonly toggleApplying: "应用中…";
                readonly toggleEnabled: "已启用";
                readonly toggleEnable: "启用";
                readonly builtinFigmaInProgressSuffix: "（接入中）";
                readonly builtinFigmaToggleUnavailable: "接入中";
                readonly installStatusFailed: "安装失败";
                readonly installStatusRemoteMcp: "Remote MCP";
                readonly installStatusReadyInVm: "已在 VM 中就绪";
                readonly authSignedIn: "已登录";
                readonly authSignInRequired: "需要登录";
                readonly disconnect: "断开";
                readonly signIn: "登录";
                readonly customServersHeader: "{{count}} 个自定义 MCP Server";
                readonly addServerTitle: "添加 MCP Server";
                readonly serverUntitled: "未命名 MCP Server";
                readonly detailStdioCommand: "stdio 命令";
                readonly detailTransportEndpoint: "{{transport}} 端点";
                readonly emptyNoCustomServers: "暂无自定义 MCP Server。";
                readonly addServerCta: "添加 MCP Server";
                readonly editorNewServerTitle: "新建 MCP Server";
                readonly editorSubtitle: "自定义 MCP Server 对所有 Agent 可用。";
                readonly deleteServerTitle: "删除 MCP Server";
                readonly fieldId: "ID";
                readonly fieldName: "名称";
                readonly fieldTransport: "Transport";
                readonly fieldCommand: "命令";
                readonly fieldArgs: "参数";
                readonly fieldUrl: "URL";
                readonly placeholderServerId: "github";
                readonly placeholderServerName: "GitHub";
                readonly placeholderCommand: "npx";
                readonly placeholderArgs: "-y @modelcontextprotocol/server-github";
                readonly placeholderUrl: "https://example.com/mcp";
                readonly editorEmptyTitle: "未选择 MCP Server";
                readonly skillSourceBuiltin: "内置";
                readonly skillSourceCustom: "自定义";
                readonly noSkillsFound: "未找到 Skill。";
            };
        };
        readonly settingsPanel: {
            title: string;
            nav: {
                general: string;
                developer: string;
                diagnostics: string;
                agent: string;
                experimental: string;
                sectionsLabel: string;
            };
            workspace: {
                navSubtitle: string;
                navBasic: string;
                spaceNameLabel: string;
                dangerLabel: string;
                deleteAction: string;
                deleteHelp: string;
                leaveAction: string;
                leaveHelp: string;
                agentTitle: string;
                defaultAgentHelp: string;
                noEnabledAgents: string;
                noEnabledAgentsHelp: string;
                agentNotInstalledBadge: string;
                permissionLabel: string;
                permissionPreset: string;
                permissionAutoReview: string;
                permissionFullAccess: string;
                personalizationTitle: string;
            };
            general: {
                title: string;
                languageLabel: string;
                uiThemeLabel: string;
                wallpaperLabel: string;
                sshAgentForwardingTitle: string;
                sshAgentForwardingDescription: string;
                uiTheme: {
                    system: string;
                    light: string;
                    dark: string;
                };
                logs: {
                    title: string;
                    sizeLabel: string;
                    sizeValue: string;
                    summaryError: string;
                    actionsLabel: string;
                    export: string;
                    exporting: string;
                    clear: string;
                    clearing: string;
                    cleared: string;
                    saved: string;
                    copyAgentPrompt: string;
                    copiedAgentPrompt: string;
                    error: string;
                    clearError: string;
                };
            };
            agent: {
                title: string;
                defaultAgentLabel: string;
                defaultAgentHelp: string;
                moveUp: string;
                moveDown: string;
                fullAccessLabel: string;
                fullAccessHelp: string;
            };
            developer: {
                title: string;
                versionLabel: string;
                agentPresentationTitle: string;
                agentPresentationTerminal: string;
                agentPresentationGui: string;
                experimentalTitle: string;
                installDoctorTitle: string;
                installDoctorDescription: string;
                installDoctorInstall: string;
                installDoctorRepair: string;
                installDoctorInstalling: string;
                installDoctorInstalledButton: string;
                installDoctorInstalled: string;
                installDoctorError: string;
                agentGUIBatchRunnerTitle: string;
                agentGUIBatchRunnerDescription: string;
            };
            experimental: {
                title: string;
            };
        };
        readonly websiteNode: {
            back: string;
            coldStatus: string;
            forward: string;
            reload: string;
            close: string;
            urlPlaceholder: string;
            loadFailed: string;
        };
        readonly terminalNode: {
            readonly resizeWidth: "调整终端宽度";
            readonly resizeHeight: "调整终端高度";
        };
        readonly terminalCloseGuard: {
            readonly title: "关闭这个终端？";
            readonly body: "这个终端中仍有进程在运行。关闭后会停止该会话。";
            readonly cancel: "取消";
            readonly confirm: "关闭终端";
        };
        readonly terminalFind: {
            readonly placeholder: "查找…";
            readonly previous: "上一个匹配";
            readonly next: "下一个匹配";
            readonly close: "关闭";
            readonly caseSensitive: "区分大小写";
            readonly useRegex: "使用正则表达式";
        };
        readonly terminalNodeHeader: {
            readonly directoryMismatch: "目录不匹配";
            readonly directoryMismatchTitle: "绑定目录：{{executionDirectory}}\n原目录：{{expectedDirectory}}";
        };
        readonly nodeDeleteDialog: {
            readonly deleteNodes_one: "删除 {{count}} 个节点？";
            readonly deleteNodes_other: "删除 {{count}} 个节点？";
            readonly deleteTask: "删除任务？";
            readonly deleteNode: "删除节点？";
            readonly multipleDescription: "这会永久删除所选的 {{count}} 个节点。";
            readonly taskDescriptionPrefix: "这会永久删除";
            readonly nodeDescriptionPrefix: "这会永久删除这个 {{kind}}：";
        };
        readonly workspaceContextMenu: {
            readonly newTerminal: "新建终端";
            readonly newWebsite: "新建网页窗口";
            readonly newTask: "新建任务";
            readonly runAgent: "运行 Agent";
            readonly runAgentBlank: "空白";
            readonly runAgentProviderSubmenu: "选择 Agent 提供商";
            readonly convertToTask: "转换为任务";
            readonly clearSelection: "清除选择";
            readonly editSelectedTask: "编辑任务…";
        };
        readonly workspaceCanvas: {
            readonly selectionHint_one: "已选中 {{count}} 个窗口。";
            readonly selectionHint_other: "已选中 {{count}} 个窗口。";
            readonly labelColorFilterAll: "显示全部";
            readonly clearLabelColorFilter: "清除颜色过滤";
            readonly chatPillLabel: "#general";
            readonly chatPanelTitle: "会话";
            readonly chatOpenPanel: "打开会话面板";
            readonly chatPlaceholder: "房间会话尚未接入此入口，后续可接入真实会话。";
            readonly composerStatusMessage: "房间内暂无 agent 在运行";
            readonly composerUnreadCompletedPrompt: "有会话已完成，请查阅";
            readonly composerUnreadFailedPrompt: "有会话需要处理，请查阅";
            readonly composerWorkingAgentsMessage_one: "当前 {{count}} 个 agent 运行中";
            readonly composerWorkingAgentsMessage_other: "当前 {{count}} 个 agent 运行中";
            readonly composerWaitingAgentsMessage_one: "当前 {{count}} 个 agent 等待你处理";
            readonly composerWaitingAgentsMessage_other: "当前 {{count}} 个 agent 等待你处理";
            readonly composerRoomWaitingAgentsMessage_one: "房间内 {{count}} 个 agent 等待处理";
            readonly composerRoomWaitingAgentsMessage_other: "房间内 {{count}} 个 agent 等待处理";
            readonly composerMessageAriaLabel: "智能体进展播报";
            readonly idleDisconnectOverlay: {
                readonly title: "房间已因空闲暂停";
                readonly description: "沙箱已自动断开以节省资源。重新进入后即可继续使用。";
                readonly reenter: "重新进入房间";
                readonly reconnecting: "正在重新进入…";
                readonly reentered: "已重新进入房间";
            };
            readonly agentActivityConversationSummaryLoadingAria: "正在加载对话流摘要";
            readonly newWindow: "新建窗口";
            readonly closeWindowAria: "关闭 {{title}}";
            readonly websiteWindowTitle: "网页";
            readonly minimizedWindows: "最小化窗口";
            readonly nodeDockToolbarAriaLabel: "房间窗格：左键打开已有窗格或新建；右键菜单仅新建";
            readonly nodeDockLabel: {
                readonly terminal: "终端";
                readonly debugTerminal: "调试终端";
                readonly website: "浏览器";
                readonly task: "任务";
                readonly files: "文件";
                readonly agent: "智能体";
                readonly openclaw: "OpenClaw";
                readonly claudeCode: "Claude";
                readonly codex: "Codex";
                readonly nexightAgent: "Tutti 智能体";
            };
            readonly dockPopupAgentAvailabilitySectionAria: "{{name}} 的可用性状态";
            readonly nodeDockContextNew: {
                readonly files: "新建房间文件会话";
                readonly terminal: "新建终端";
                readonly debugTerminal: "新建调试终端";
                readonly website: "新建浏览器";
                readonly task: "新建任务";
                readonly agent: "新建智能体";
            };
            readonly zoomPercentInputAria: "画布缩放：输入百分比（如 91、91%）或 0–1 之间的小数比例，按 Enter 应用";
            readonly zoomPercentInputTitle: "双击恢复为 100%";
            readonly runtimeStatusPanel: {
                readonly title: "房间运行状态";
                readonly openComposerAria: "打开房间运行状态";
                readonly close: "关闭";
                readonly refresh: "刷新状态";
                readonly workspaceConnection: "房间连接";
                readonly runtimeConnection: "工作区环境";
                readonly connected: "已连接";
                readonly disconnected: "未连接";
                readonly reconnecting: "重连中…";
                readonly state: "状态";
                readonly statusMessage: "说明";
                readonly workspaceRoot: "房间根目录";
                readonly linuxUser: "Linux 用户";
                readonly provider: "提供方";
                readonly sandboxId: "沙箱 ID";
                readonly sandboxSession: "沙箱会话";
                readonly terminals: "终端会话数";
                readonly runtimeId: "运行时 ID";
                readonly vsockRelay: "Vsock 中继";
                readonly noData: "暂无可用的运行状态。";
            };
            readonly runtimeWorkspaceDebug: {
                readonly title: "运行时工作区调试";
                readonly close: "关闭";
                readonly refresh: "刷新";
                readonly connected: "已连接";
                readonly disconnected: "未连接";
                readonly vmTab: "VM";
                readonly vmOverview: "VM 概览";
                readonly runtimeTrace: "VM 轨迹";
                readonly workspaceOverview: "工作区概览";
                readonly workspaceTrace: "工作区轨迹";
                readonly vmBootPhases: "VM 启动阶段";
                readonly workspaceEnterTraces: "工作区进入轨迹";
                readonly workspaceAttachments: "工作区挂载";
                readonly connection: "连接状态";
                readonly state: "状态";
                readonly healthState: "健康状态";
                readonly imageBootSource: "启动镜像来源";
                readonly statusMessage: "状态消息";
                readonly diagnosticsStatusMessage: "诊断状态";
                readonly elapsed: "阶段耗时";
                readonly totalElapsed: "累计耗时";
                readonly attempt: "尝试次数";
                readonly sandboxSession: "沙箱会话";
                readonly attachment: "挂载关系";
                readonly attached: "已挂载";
                readonly detached: "已分离";
                readonly noRuntimeTrace: "暂无 VM 轨迹记录。";
                readonly noVmBootPhases: "暂无 VM 启动阶段记录。";
                readonly noWorkspaceEnters: "暂无工作区进入轨迹。";
                readonly noWorkspaceEnterPhases: "暂无工作区进入阶段记录。";
                readonly noWorkspaceTrace: "暂无工作区轨迹记录。";
                readonly noWorkspaces: "暂无运行时工作区。";
                readonly workspaceId: "工作区 ID";
                readonly roomName: "房间名";
                readonly mountState: "挂载状态";
                readonly mountPoint: "挂载点";
                readonly sandboxId: "沙箱 ID";
                readonly websocketState: "WebSocket";
                readonly createdAt: "创建时间";
                readonly lastConnectedAt: "最近连接";
                readonly lastDisconnectedAt: "最近断开";
                readonly reconnectCount: "重连次数";
                readonly lastError: "最近错误";
                readonly vmRestartCount: "VM 重启次数";
            };
            readonly sandboxSessionBanner: {
                readonly reconnecting: "沙箱重连中…";
                readonly disconnected: "沙箱已断开";
            };
            readonly applications: {
                readonly eyebrow: "Agent OS 应用";
                readonly title: "应用中心";
                readonly description: "从一个入口打开房间关键应用，并预览 Agent OS 常用工作流";
                readonly launchHint: "Mock 应用进入房间后即可打开";
                readonly launchMockUnavailable: "进入房间后可以打开这个 Mock 应用";
                readonly categoryBasic: "基础";
                readonly categoryOffice: "办公";
                readonly categoryCreation: "创作";
                readonly installAction: "安装";
                readonly comingSoonAction: "即将上线";
                readonly installedAction: "已安装";
                readonly issueTitle: "任务中心";
                readonly issueDescription: "创建、分派、运行并验收房间内的任务";
                readonly vibeDesignTitle: "Vibe 设计";
                readonly vibeDesignDescription: "生成产品界面、交互状态和视觉方向草案";
                readonly vibeVideoTitle: "视频创作";
                readonly vibeVideoDescription: "组织脚本、分镜、剪辑和最终视频方向";
                readonly imageGenerationTitle: "图片生成";
                readonly imageGenerationDescription: "创建视觉概念稿、生成图片素材";
                readonly textEditorTitle: "文档";
                readonly textEditorDescription: "编写和整理房间笔记、提示词与轻量文档";
                readonly pptTitle: "PPT";
                readonly pptDescription: "创建演示大纲、幻灯片草稿";
                readonly sheetTitle: "表格";
                readonly sheetDescription: "整理结构化数据、表格、计算和房间计划清单";
                readonly calendarTitle: "日程";
                readonly calendarDescription: "规划房间里程碑、跟进任务、评审和共享日程";
                readonly systemMonitorTitle: "系统监控";
                readonly systemMonitorDescription: "查看运行时健康度、资源信号和工作区活动";
                readonly codeEditorTitle: "代码编辑器";
                readonly codeEditorDescription: "打开源码文件、审阅变更并整理实现备注";
                readonly chatTitle: "聊天";
                readonly chatDescription: "协同房间对话、Agent 交接和快速决策";
                readonly mockWindowStatus: "Mock 应用";
                readonly mockWindowReady: "等待后续接入";
                readonly mockDesignPreviewTitle: "设计看板";
                readonly mockDesignPreviewBody: "这里将展示布局参考、组件状态和评审备注";
                readonly mockVideoPreviewTitle: "视频时间线";
                readonly mockVideoPreviewBody: "这里将展示场景、片段、旁白和导出状态";
                readonly mockImageGenerationPreviewTitle: "图片工作室";
                readonly mockImageGenerationPreviewBody: "这里将展示提示词、生成预览、变体和导出记录";
                readonly mockEditorPreviewTitle: "草稿文档";
                readonly mockEditorPreviewBody: "可以在这个占位编辑器里组织房间笔记和 Agent 提示词";
                readonly mockPresentationPreviewTitle: "幻灯片 Deck";
                readonly mockPresentationPreviewBody: "这里将展示幻灯片大纲、叙事节奏和评审备注";
                readonly mockSheetPreviewTitle: "数据表格";
                readonly mockSheetPreviewBody: "这里将展示表格、计算、筛选和房间计划数据";
                readonly mockCalendarPreviewTitle: "房间日历";
                readonly mockCalendarPreviewBody: "这里将展示里程碑、会议、跟进任务和共享日程块";
                readonly mockMonitorPreviewTitle: "运行时信号";
                readonly mockMonitorPreviewBody: "这里将展示 CPU、内存、网络和工作区活动信号";
                readonly mockCodePreviewTitle: "源码工作区";
                readonly mockCodePreviewBody: "这里将展示文件、Diff、符号和实现备注";
                readonly mockChatPreviewTitle: "房间聊天";
                readonly mockChatPreviewBody: "这里将展示对话线程、Agent 回复和共享决策";
            };
            readonly vmStatusIndicator: {
                readonly healthy: "VM 已启动且健康检测正常";
                readonly pending: "VM 已启动，正在健康检测";
                readonly unhealthy: "VM 启动失败或健康检测失败";
            };
        };
        readonly labelColors: {
            readonly title: "颜色标注";
            readonly autoInherit: "自动（跟随分区）";
            readonly none: "无";
            readonly gray: "灰色";
            readonly red: "红色";
            readonly orange: "橙色";
            readonly yellow: "黄色";
            readonly green: "绿色";
            readonly blue: "蓝色";
            readonly purple: "紫色";
        };
        readonly messages: {
            readonly agentLaunchFailed: "Agent 启动失败：{{message}}";
            readonly agentResumeFailed: "Agent 继续失败：{{message}}";
            readonly agentProviderSessionNotFound: "这条会话历史仍可查看，但底层 Provider 会话已经无法恢复。";
            readonly agentTargetRemoved: "该 agent 不存在或已被移除，历史会话记录仍可查看。";
            readonly agentResumeSessionNotLocal: "这个会话没法在当前设备里直接恢复，你可以在新会话里 @这段对话，接着继续聊。";
            readonly agentImportedSessionResumeUnavailable: "这段对话已导入成功，新开会话并 @ 这段对话，接着继续聊。";
            readonly agentSessionReconnecting: "正在重新连接 Agent 会话…";
            readonly agentSettingsRequireNewSession: "为了保留上下文，这个模型只能在新会话中使用";
            readonly agentProcessCleanupPending: "上一个 Agent 进程仍在退出。为避免重复启动，本次操作已停止，请稍后重试";
            readonly agentConfigDependencyUnavailable: "{{provider}} 的配置引用了当前不可用的文件，请检查本机配置后重试";
            readonly agentSessionTitleTooLong: "会话标题不能超过 {{maxCharacters}} 个字符。";
            readonly agentSessionTitleTooLongWithoutLimit: "会话标题过长。";
            readonly agentPermissionModeAppliesNextTurn: "权限模式将从你的下一条消息开始生效。";
            readonly agentThisSessionMentionLabel: "本 session";
            readonly terminalLaunchFailed: "终端启动失败：{{message}}";
            readonly fallbackTerminalFailed: "兜底终端启动也失败了：{{message}}";
            readonly agentPromptRequired: "Agent 提示词不能为空。";
            readonly resumeSessionMissing: "该 Agent 还没有已验证的 resumeSessionId。";
            readonly noTerminalSlotNearby: "当前视图附近没有可用空位，请先移动或关闭部分终端窗口。";
            readonly noWindowSlotOnRight: "当前 Agent 右侧没有可用空位，请先移动或关闭部分窗口。";
            readonly noWindowSlotNearby: "当前视图附近没有可用空位，请先移动或关闭部分窗口。";
            readonly agentManageSyncSuccess: "同步成功";
            readonly agentManageInstallSuccess: "安装成功";
        };
    };
};
declare const agentGuiI18nModule: _tutti_os_ui_i18n_runtime.LocaleObjectI18nModuleManifest;
declare function AgentGuiI18nProvider({ children, locale, runtime }: {
    children: ReactNode;
    locale?: AgentGuiI18nLocale;
    runtime?: I18nRuntime<string> | null;
}): react__default.ReactElement;

interface AgentQuickPromptTemplate {
    content: string;
    description: string;
    id: "summary-common-prompts" | "understand-context" | "create-action-plan" | "review-and-improve" | "draft-clear-update";
    title: string;
}
interface AgentQuickPromptLabels {
    add: string;
    cancel: string;
    conflict: string;
    contentLabel: string;
    contentPlaceholder: string;
    createTitle: string;
    createFromTemplate: string;
    delete: string;
    deleteConfirm: string;
    deleteDescription: (title: string) => string;
    deleteTitle: string;
    deleting: string;
    dragCancel: (title: string, position: number, total: number) => string;
    dragDrop: (title: string, position: number, total: number) => string;
    dragHandle: (title: string) => string;
    dragInstructions: string;
    dragMove: (title: string, position: number, total: number) => string;
    dragStart: (title: string, position: number, total: number) => string;
    edit: string;
    editTitle: string;
    empty: string;
    finishSorting: string;
    insertionError: string;
    loadError: string;
    loading: string;
    moreActions: string;
    mutationError: string;
    noResults: string;
    required: string;
    reorderConflict: string;
    reorderDisabledMinimum: string;
    reorderDisabledPending: string;
    reorderDisabledSearch: string;
    reorderDisabledUnsupported: string;
    reorderError: string;
    retry: string;
    save: string;
    saving: string;
    searchPlaceholder: string;
    startSorting: string;
    recommendedTemplates: readonly AgentQuickPromptTemplate[];
    recommendedTemplatesDescription: string;
    recommendedTemplatesTitle: string;
    returnToPrompts: string;
    title: string;
    titleLabel: string;
    titlePlaceholder: string;
    titleTooLong: string;
    contentTooLarge: string;
    trigger: string;
    triggerTooltip: string;
    useTemplate: string;
}

declare const AGENT_CONTEXT_MENTION_PROVIDER_IDS: {
    readonly agentGeneratedFile: "agent-generated-file";
    readonly agentSession: "agent-session";
    readonly agentTarget: "agent-target";
    readonly file: "file";
    readonly workspaceApp: "workspace-app";
    readonly workspaceIssue: "workspace-issue";
};
type AgentContextMentionProviderId = TuttiExternalAtProviderId;
type AgentContextMentionQueryInput = RichTextTriggerQueryInput & {
    trigger: "@";
};
interface AgentContextMentionDirectoryDescriptor {
    /** Canonical provider-owned directory path used for child queries. */
    path: string;
    /** Number of direct children when the provider can determine it. */
    childCount?: number | null;
}
type AgentContextMentionDirectoryQueryInput = AgentContextMentionQueryInput & {
    directoryPath: string;
};
type AgentContextMentionProvider<TItem = any> = Omit<RichTextTriggerProvider<TItem>, "trigger"> & {
    trigger: "@";
    /** Optional hierarchy contract for file providers. */
    getItemDirectory?(item: TItem): AgentContextMentionDirectoryDescriptor | null | undefined;
    /** Lists the direct children of one directory without overloading keyword search. */
    queryDirectory?(input: AgentContextMentionDirectoryQueryInput): Promise<readonly TItem[]> | readonly TItem[];
};

declare function preloadAgentMentionBrowse(input: {
    workspaceId: string;
    currentUserId?: string | null;
    sectionKey?: string | null;
    sessionCwd?: string | null;
    contextMentionProviders?: readonly AgentContextMentionProvider[];
    filter?: AgentMentionFilterId;
}): void;

type AgentMentionFilterId = "session" | "file" | "issue" | "agent" | "app";

interface AgentComposerInputHistoryEntry {
    id: string;
    draft: AgentComposerDraft;
}

interface AgentComposerReferenceProvenanceFilter {
    snapshot: ReferenceProvenanceFilterSnapshot;
    controller: Pick<ReferenceProvenanceFilterController, "reset" | "toggle" | "toggleAll">;
}
interface AgentComposerReferenceProvenanceFilters {
    byFilter: Record<AgentMentionFilterId, AgentComposerReferenceProvenanceFilter>;
}
interface AgentComposerSubmitOptions {
    /** Exact draft captured by the Composer for conditional post-submit clearing. */
    submittedDraft?: AgentComposerDraft;
    isolation?: "worktree";
    requiredSettingsPatch?: AgentActivitySubmitSettingsPatch;
    capabilityRefs?: readonly AgentComposerCapabilityReference[];
    /** Exact canonical active Turn captured for native guidance. */
    targetTurnId?: string;
    /**
     * Immutable Tutti presentation captured by the composer that initiated the
     * submit. An explicit inactive snapshot is authoritative over stale draft
     * state while a new conversation is being created.
     */
    tuttiMode?: AgentComposerTuttiModeSubmitSnapshot;
}
interface AgentComposerTuttiModeSubmitSnapshot {
    active: boolean;
    effect?: number;
    speed?: number;
}
interface AgentComposerCapabilityReference {
    capability: "tutti";
    source: "slash_command";
}
interface AgentComposerProps {
    workspaceId: string;
    agentSessionId?: string | null;
    workspacePath?: string | null;
    currentUserId?: string | null;
    provider: string;
    slashStatus?: AgentComposerSlashStatus | null;
    usage?: AgentComposerUsage | null;
    draftContent: AgentComposerDraft;
    engagement?: AgentGUIComposerEngagement;
    /** Stable project/session owner for async draft attachment work. */
    draftScopeKey?: string;
    inputHistory?: readonly AgentComposerInputHistoryEntry[];
    inputHistoryHasOlderPage?: boolean;
    inputHistoryIsLoadingOlderPage?: boolean;
    onRequestOlderInputHistoryPage?: () => void;
    availableCommands: readonly AgentSessionCommand[];
    hasCompactableContext?: boolean;
    compactSupported?: boolean | null;
    availableSkills?: readonly AgentGUIProviderSkillOption[];
    gate: AgentGUIComposerGate;
    /** View-local lock that does not redefine canonical Composer readiness. */
    presentationEditorDisabled: boolean;
    disabledReason?: string | null;
    /** Draft-independent view-local submission lock. */
    presentationSubmitDisabled: boolean;
    /** Canonical engine projection of the independent TuttiModeActivation. */
    tuttiModeActive?: boolean;
    /** Blocks submission/removal while activation CAS or creation is unresolved. */
    tuttiModeUpdating?: boolean;
    /** Effective Tutti outcome-quality and completion-speed preferences. */
    tuttiModeEffect?: number;
    tuttiModeSpeed?: number;
    placeholder: string;
    composerSettings: AgentGUIComposerSettingsVM;
    queueStatus?: AgentGUIQueueStatus;
    queuedPrompts: readonly AgentGUIQueuedPromptVM[];
    drainingQueuedPromptId: string | null;
    workspaceAppIcons?: readonly AgentMessageMarkdownWorkspaceAppIcon[];
    selectedAgentTarget?: AgentGUIAgentTarget | null;
    sessionWorktreeEnabled?: boolean;
    sessionLaunchMode?: AgentGUISessionLaunchMode;
    onSessionLaunchModeChange?: (mode: AgentGUISessionLaunchMode) => void | Promise<void>;
    /** Content rendered immediately before the primary non-hero action. */
    composerActionAccessory?: ReactNode;
    /** Places the primary action cluster in the prompt row or Composer footer. */
    composerActionPlacement?: "input" | "footer";
    /** Shows the canonical new-Session project selector in a non-hero footer. */
    showProjectSelectorInFooter?: boolean;
    footerAccessory?: ReactNode;
    agentTargets?: readonly AgentGUIAgentTarget[];
    handoffAgentTargets?: readonly AgentGUIAgentTarget[];
    showHandoffTargetOwnershipLabels?: boolean;
    providerSelectReadonly?: boolean;
    onProviderSelect?: (input: {
        provider: AgentGUIProvider;
        agentTargetId?: string | null;
    }) => void;
    onHandoffConversation?: (target: AgentGUIAgentTarget) => void;
    showStopButton: boolean;
    /** Canonical active Turn; distinct from a cancellable session activation. */
    activeTurnId?: string | null;
    /** Lets typed input replace an aggregate-work Stop control with Send. */
    draftOverridesStopButton?: boolean;
    stopDisabled: boolean;
    activePrompt: AgentConversationPromptVM | null;
    /** Host readiness reason for the active prompt's disabled controls. */
    activePromptDisabledReason?: string | null;
    activePromptKeyboardShortcutsEnabled?: boolean;
    promptTips?: readonly AgentComposerPromptTip[];
    isInterrupting: boolean;
    isSendingTurn: boolean;
    isSubmittingPrompt: boolean;
    /** Whether the active session is authoritative enough to probe its cwd. */
    projectMissingProbeEnabled?: boolean;
    uiLanguage?: UiLanguage;
    isActive?: boolean;
    workspaceReferencePickerOpen?: boolean;
    promptImagesSupported?: boolean;
    canGoalControl?: boolean;
    canUploadAttachment?: boolean;
    composerFocusRequestSequence?: number | null;
    /**
     * `dock` overhangs growing drafts above a conversation timeline, `hero`
     * presents the home composer, and `embedded` keeps all draft content in
     * normal flow for compact host surfaces.
     */
    layoutMode?: "dock" | "embedded" | "hero";
    /** Lets an embedded composer consume a height explicitly owned by its host. */
    fillAvailableHeight?: boolean;
    /** Host chrome inset that portaled menus must not overlap. */
    menuViewportTopInset?: number;
    providerSelectLabel?: string;
    handoffLabel?: string;
    handoffMenuLabel?: string;
    labels: {
        /** Capability plus copy for returning to a Composer that answers the prompt. */
        conversationReturn?: {
            continueAnswering: string;
            returnToConversation: string;
        };
        send: string;
        /**
         * Plan-review send copy: with an empty-send override active the send
         * button reads sendAccept on an empty draft and sendRequestChanges once
         * feedback is typed, so the composer decision semantics stay legible.
         */
        sendAccept?: string;
        sendRequestChanges?: string;
        modelLabel: string;
        modelSelectionLabel: string;
        modelContextWindowSuffix: string;
        modelTooltipVersionLabel: string;
        defaultModel: string;
        loadingOptions: string;
        composerOptionsLoadFailed?: string;
        retry?: string;
        composerOptionsRetryTooltip?: string;
        inheritedUnavailable: string;
        loadingConversation: string;
        reasoningLabel: string;
        reasoningDegreeLabel: string;
        reasoningOptionDefault: string;
        reasoningOptionMinimal: string;
        reasoningOptionLow: string;
        reasoningOptionMedium: string;
        reasoningOptionHigh: string;
        reasoningOptionXHigh: string;
        reasoningOptionMax: string;
        reasoningOptionUltra: string;
        speedLabel: string;
        speedSelectionLabel: string;
        speedOptionStandard: string;
        speedOptionStandardDescription: string;
        speedOptionFast: string;
        speedOptionFastDescription: string;
        permissionLabel: string;
        permissionModeReadOnly: string;
        permissionModeAuto: string;
        permissionModeFullAccess: string;
        permissionModeChangeUnavailableDuringTurn: string;
        modelDescriptions: {
            frontierComplexCoding: string;
            everydayCoding: string;
            smallFastCostEfficient: string;
            codingOptimized: string;
            ultraFastCoding: string;
            professionalLongRunning: string;
        };
        planModeLabel: string;
        codexSaverModeLabel: string;
        codexSaverModeDescription: string;
        tuttiModeLabel: string;
        tuttiModeDescription: string;
        tuttiModeRemove: string;
        tuttiBudgetTitle: string;
        tuttiBudgetEffectLabel: string;
        tuttiBudgetSpeedLabel: string;
        tuttiBudgetPreviewHint: string;
        tuttiBudgetPreviewCost: string;
        tuttiBudgetPreviewBalance: string;
        tuttiBudgetPreviewPowerful: string;
        tuttiBudgetModelPreferenceLabel: string;
        tuttiBudgetModelPreferenceCost: string;
        tuttiBudgetModelPreferenceBalance: string;
        tuttiBudgetModelPreferencePowerful: string;
        tuttiBudgetParallelismLabel: string;
        tuttiBudgetParallelismValue: (count: number) => string;
        planModeDescription?: string;
        planModeOnLabel: string;
        planModeOffLabel: string;
        planUnavailable: string;
        goalLabel: string;
        browserUseCapabilityLabel: string;
        browserUseCapabilityDescription: string;
        browserUseCapabilityDescriptionAutoConnect: string;
        browserUseCapabilityDescriptionIsolated: string;
        browserUseCapabilitySettingsLabel: string;
        browserUseCapabilitySettingsDescription: string;
        capabilityInlineSettingsLabel: string;
        computerUseCapabilityLabel: string;
        computerUseCapabilityDescription: string;
        computerUseCapabilitySetupRequiredDescription: string;
        computerUseCapabilityAuthorizationRequiredDescription: string;
        computerUseCapabilityAuthorizationUnknownDescription: string;
        computerUseCapabilitySettingsLabel: string;
        computerUseCapabilitySettingsDescription: string;
        queuedLabel: string;
        queuePausedByUserLabel: string;
        sendQueuedPromptNext: string;
        editQueuedPrompt: string;
        deleteQueuedPrompt: string;
        queuedPromptMoreActions: string;
        stop: string;
        stopping: string;
        slashCommandPalette: string;
        skillPickerPalette: string;
        slashPaletteCommandsGroup: string;
        slashPaletteCapabilitiesGroup: string;
        slashPaletteCapabilitiesLoading: string;
        slashPaletteSkillsGroup: string;
        slashPalettePluginsGroup: string;
        slashPaletteConnectorsGroup: string;
        slashPaletteConnectorConnected: string;
        slashPaletteConnectorNotConnected: string;
        slashPaletteConnectorUnsupported: string;
        slashPaletteMcpGroup: string;
        slashCommandCompactLabel: string;
        slashCommandContextLabel: string;
        slashCommandFastLabel: string;
        slashCommandGoalLabel: string;
        slashCommandInitLabel: string;
        slashCommandPlanLabel: string;
        slashCommandReviewLabel: string;
        slashCommandStatusLabel: string;
        slashCommandUsageLabel: string;
        slashCommandCompactDescription: string;
        slashCommandContextDescription: string;
        slashCommandFastDescription: string;
        slashCommandGoalDescription: string;
        slashCommandInitDescription: string;
        slashCommandPlanDescription: string;
        slashCommandReviewDescription: string;
        slashCommandStatusDescription: string;
        slashCommandUsageDescription: string;
        slashStatusTitle: string;
        slashStatusSession: string;
        slashStatusBaseUrl: string;
        slashStatusContext: string;
        slashStatusLimits: string;
        slashStatusClose: string;
        slashStatusContextValue: (input: {
            percentLeft: number;
            usedTokens: string;
            totalTokens: string;
        }) => string;
        slashStatusContextUnavailable: string;
        slashStatusLimitsUnavailable: string;
        slashStatusEmptyValue: string;
        slashStatusUsageJustUpdated: string;
        slashStatusUsageMinutesAgo: (count: number) => string;
        slashStatusUsageHoursAgo: (count: number) => string;
        slashStatusUsageUpdating: string;
        slashStatusUsageRefreshFailed: string;
        slashStatusUsageRefreshAria: string;
        slashStatusUsageAuthRequired: string;
        slashStatusUsageSessionExpired: string;
        slashStatusUsageSubscriptionRequired: string;
        slashStatusUsageQuotaExhausted: string;
        slashStatusUsageParseFailed: string;
        slashStatusUsageError: string;
        usageChipLabel: (input: {
            percent: number;
        }) => string;
        usageTooltipLabel: string;
        usagePopoverTitle: string;
        usageContextWindowLabel: string;
        usageTokensLabel: string;
        usageLimitsLabel: string;
        usageCompactAction: string;
        approvalLead: string;
        fileChangeApprovalLead: string;
        planLead: string;
        planModes: Array<{
            id: string;
            label: string;
            description: string;
        }>;
        stayInPlan: string;
        sendFeedback: string;
        feedbackPlaceholder: string;
        previousQuestion: string;
        nextQuestion: string;
        submitAnswers: string;
        answerPlaceholder: string;
        waitingForAnswer: string;
        planImplementationLead: string;
        planImplementationConfirm: string;
        planImplementationFeedbackPlaceholder: string;
        planImplementationSend: string;
        planImplementationSkip: string;
        fileMentionPalette: string;
        fileMentionLoading: string;
        fileMentionEmpty: string;
        fileMentionError: string;
        fileMentionTabHint: string;
        fileDropHint: string;
        mentionPalette: string;
        removeMention: string;
        addReference: string;
        addContent: string;
        addContentResourcePanel: string;
        addContentConnectors: string;
        addContentConnectorConnected: string;
        addContentConnectorConnect: string;
        addContentConnectorAuthorize: string;
        addContentConnectorEmpty: string;
        addContentConnectorLoading: string;
        addContentConnectorMore: string;
        addContentConnectorSelected: string;
        referenceWorkspaceFiles: string;
        handoffConversation: string;
        handoffConversationTooltip: string;
        handoffConversationMenu: string;
        handoffTargetDeviceSource: (deviceLabel: string) => string;
        handoffTargetSelf: string;
        handoffTargetShared: string;
        providerSwitchLabel: string;
        projectLocked: string;
        sessionLaunchModeLabel?: string;
        sessionLaunchModeLocal?: string;
        sessionLaunchModeWorktree?: string;
        projectMissingDescription: string;
        promptTipsPrefix: string;
        reviewPicker: {
            title: string;
            targetLabel: string;
            searchPlaceholder: string;
            noResults: string;
            uncommitted: string;
            baseBranch: string;
            commit: string;
            custom: string;
            branchLabel: string;
            branchPlaceholder: string;
            branchLoading: string;
            branchEmpty: string;
            commitPlaceholder: string;
            customPlaceholder: string;
            submit: string;
            cancel: string;
        };
        quickPrompts: AgentQuickPromptLabels;
    };
    workspaceUserProjectI18n: WorkspaceUserProjectI18nRuntime;
    onDraftContentChange: (draftContent: AgentComposerDraft, sourceScopeKey?: string) => void;
    onProjectPathChange?: (path: string | null, metadata?: AgentProjectPathChangeMetadata) => void;
    onSettingsChange: (settings: {
        codexSaverMode?: boolean;
        model?: string | null;
        reasoningEffort?: string | null;
        speed?: string | null;
        planMode?: boolean;
        browserUse?: boolean;
        computerUse?: boolean;
        permissionModeId?: string | null;
    }) => void;
    /** Retries or explicitly refreshes the target-scoped composer options. */
    onRetryComposerOptions?: (options?: {
        force?: boolean;
        section?: "core" | "capabilities" | "connectors";
        waitForFreshModelCatalog?: boolean;
    }) => void;
    onTuttiModeChange?: (active: boolean) => void;
    onTuttiModeEffectChange?: (value: number) => void;
    onTuttiModeSpeedChange?: (value: number) => void;
    capabilityMenuState?: AgentComposerCapabilityMenuState;
    capabilityControlsReadOnly?: boolean;
    onCapabilitySettingsRequest?: (capability: AgentComposerCapabilitySettingsTarget) => void | Promise<void>;
    onSlashStatusOpen?: () => void;
    onSlashStatusClose?: () => void;
    onSlashStatusRefresh?: () => void;
    onSubmit: (content: AgentPromptContentBlock[], displayPrompt?: string, options?: AgentComposerSubmitOptions) => void;
    /**
     * When set, an empty-draft send is enabled and routed here instead of being
     * blocked (e.g. Tutti plan review: empty send = accept). Typed sends keep
     * flowing through onSubmit.
     */
    onSubmitEmpty?: () => void;
    /**
     * Overrides the empty-draft send button copy while the empty-send override
     * is active. Falls back to labels.sendAccept.
     */
    emptySubmitLabel?: string;
    onSubmitGuidance?: (content: AgentPromptContentBlock[], displayPrompt?: string, options?: AgentComposerSubmitOptions) => void;
    onSendQueuedPromptNext: (queuedPromptId: string) => void;
    onRemoveQueuedPrompt: (queuedPromptId: string) => void;
    onEditQueuedPrompt: (queuedPromptId: string) => void;
    onInterruptCurrentTurn: () => void;
    onPromptImagesUnsupported?: () => void;
    onSubmitInteractivePrompt: (input: AgentInteractionResponseInput) => boolean;
    onLinkAction?: (action: WorkspaceLinkAction) => void;
    onRequestWorkspaceReferences?: ((entity?: AgentContextMentionItem | null) => Promise<WorkspaceReferencePickResult>) | null;
    resolveExternalPromptEntries?: AgentExternalPromptEntryResolver | null;
    prepareExternalPromptFiles?: AgentExternalPromptFilePreparer | null;
    resolvePastedPath?: AgentRichTextEditorProps["onResolvePastedPath"] | null;
    promptAssetLimit?: number | null;
    selectProjectDirectory?: () => Promise<{
        path: string;
    } | null>;
    projectSelectOptions?: AgentProjectDropdownOptions;
    /** Explicit project capability for lifecycle-free Composer embeddings. */
    userProjectApi?: WorkspaceUserProjectApi | null;
    onRequestGitBranches?: AgentComposerGitBranchLoader | null;
    referenceProvenanceFilters?: AgentComposerReferenceProvenanceFilters | null;
}
type AgentComposerCapabilitySettingsTarget = Exclude<AgentSlashCommandCapability["capability"], "tutti"> | {
    kind: "connector";
    connectorKey: string;
    action?: "install" | "open";
} | {
    kind: "connector";
    connectorKey: string;
    action: "set_runtime_enabled";
    enabled: boolean;
};
interface AgentComposerCapabilityMenuState {
    browserUse?: {
        connectionMode?: "autoConnect" | "isolated" | null;
    };
    computerUse?: {
        authorization?: AgentComposerComputerUseAuthorizationState | null;
        installed?: boolean | null;
        /** Host can present the computer-use setup surface. Fail closed. */
        presentationSupported?: boolean | null;
    };
    /**
     * Host-owned connector visibility override. Missing preserves the existing
     * catalog behavior for hosts that have not adopted this optional field.
     */
    connectors?: {
        enabled?: boolean | null;
        /** Catalog remains inspectable but cannot select, authorize, install, or manage. */
        readOnly?: boolean | null;
        /** Controls the host management footer independently from catalog visibility. */
        showViewMore?: boolean | null;
    };
    tuttiMode?: {
        enabled?: boolean | null;
    };
}
type AgentComposerComputerUseAuthorizationState = "authorized" | "needs-authorization" | "unknown";
interface AgentComposerGitBranches {
    branches: readonly string[];
    currentBranch?: string | null;
}
type AgentComposerGitBranchLoader = (input: {
    agentSessionId?: string | null;
    workingDirectory?: string | null;
}) => Promise<AgentComposerGitBranches>;
interface AgentComposerPromptTip {
    id: string;
    label: string;
    prompt: string;
}
interface AgentComposerSlashStatus {
    agentSessionId?: string | null;
    baseUrl?: string | null;
    contextWindow?: {
        usedTokens?: number | null;
        totalTokens?: number | null;
    } | null;
    limits?: readonly AgentComposerSlashStatusLimit[];
    limitsLoading?: boolean;
    limitsUnavailable?: boolean;
    limitsResolvedEmpty?: boolean;
    limitsCapturedAtUnixMs?: number | null;
    limitsErrorMessage?: string | null;
    refreshFailed?: boolean;
    isRefreshing?: boolean;
}
interface AgentComposerSlashStatusLimit {
    id: string;
    label: string;
    percentRemaining?: number | null;
    value: string;
    reset?: string | null;
}
interface AgentComposerUsage {
    percentUsed: number | null;
    usedTokens: number | null;
    totalTokens: number | null;
}

type TuttiModePlanWorkflowStatus = "pending_review" | "in_progress" | "accepted" | "rejected" | "completed" | "failed" | "canceled";
type TuttiModePlanCheckpointKind = "configuration_review" | "task_review";
type TuttiModePlanCheckpointStatus = "pending" | "accepted" | "rejected" | "superseded" | "canceled";
interface TuttiModePlanReviewSnapshot {
    workflow: TuttiModePlanWorkflow;
    revisions: TuttiModePlanRevision[];
    checkpoints: TuttiModePlanCheckpoint[];
}
interface TuttiModePlanWorkflow {
    id: string;
    workspaceId: string;
    type: string;
    owner: string;
    triggerKind: string;
    sourceSessionId: string;
    sourceTurnId?: string | null;
    sourceToolCallId?: string | null;
    status: TuttiModePlanWorkflowStatus;
    currentRevisionId: string;
}
interface TuttiModePlanRevision {
    id: string;
    workflowId: string;
    sequence: number;
    schemaVersion: string;
    documentPath: string;
    sha256: string;
    producedByTurnId?: string | null;
    createdAtUnixMs: number;
    document: TuttiModePlanDocument;
}
interface TuttiModePlanDocument {
    schema: string;
    phase: "configuration" | "task_graph";
    title: string;
    topicId: string;
    markdownBody: string;
    execution: TuttiModePlanExecution;
    budget: TuttiModePlanBudget;
    tasks: TuttiModePlanTask[];
}
interface TuttiModePlanExecution {
    mode: "sequential" | "parallel";
    reasoningIntensity: number;
    orchestrationIntensity: number;
    effect?: number | null;
    speed?: number | null;
}
interface TuttiModePlanBudget {
    mode: "auto" | "fixed";
    tokenLimit: number;
    quotaWaterlinePercent: number;
}
interface TuttiModePlanTask {
    id: string;
    title: string;
    content: string;
    priority: "high" | "medium" | "low";
    agentTargetId?: string | null;
    modelPlanId?: string | null;
    model?: string | null;
    permissionModeId?: string | null;
    reasoningEffort?: string | null;
    executionDirectory?: string | null;
    dependsOn: string[];
    parallelizable?: boolean;
    autoAccept?: boolean;
}
interface TuttiModePlanCheckpoint {
    id: string;
    workflowId: string;
    kind: TuttiModePlanCheckpointKind;
    revisionId: string;
    status: TuttiModePlanCheckpointStatus;
    decidedBy?: string | null;
    decisionReason?: string | null;
    createdAtUnixMs: number;
    updatedAtUnixMs: number;
    decidedAtUnixMs?: number | null;
}

interface TuttiModePlanReviewUpdate {
    kind: "workflow_updated";
    workspaceId: string;
    workflowId: string;
    sourceSessionId: string;
    checkpointId: string;
    changeKind: "proposal_created" | "revision_created" | "checkpoint_decided" | "operation_updated";
}
interface TuttiModePlanReviewConnectionRestored {
    kind: "connection_restored";
    workspaceId: string;
}
/**
 * A root turn of the source session settled. The host derives this from the
 * daemon's canonical turn fan-out and relays it as a read-repair trigger: a
 * plan proposed mid-turn announces itself through one workflow event, and if
 * that single event is lost no later workflow signal re-reads review state.
 */
interface TuttiModePlanReviewSessionSettled {
    kind: "session_settled";
    workspaceId: string;
    sourceSessionId: string;
}
/** Cached assignment catalogs changed for exact Agent Targets. */
interface TuttiModePlanAssignmentOptionsInvalidated {
    kind: "assignment_options_invalidated";
    workspaceId: string;
    agentTargetIds: readonly string[];
}
type TuttiModePlanReviewInvalidation = TuttiModePlanReviewUpdate | TuttiModePlanReviewConnectionRestored | TuttiModePlanReviewSessionSettled | TuttiModePlanAssignmentOptionsInvalidated;
interface TuttiModePlanTaskAssignmentInput {
    taskId: string;
    agentTargetId?: string | null;
    modelPlanId?: string | null;
    model?: string | null;
    permissionModeId?: string | null;
    reasoningEffort?: string | null;
    parallelizable?: boolean | null;
    autoAccept?: boolean | null;
}
interface TuttiModePlanReviewDecisionInput {
    workspaceId: string;
    workflowId: string;
    checkpointId: string;
    decision: "accepted" | "rejected" | "canceled";
    decidedBy: string;
    reason?: string | null;
    /** Per-task overrides; only meaningful with an accepted task review. */
    taskAssignments?: readonly TuttiModePlanTaskAssignmentInput[];
}
interface TuttiModePlanAssignmentAgentOption {
    agentTargetId: string;
    label: string;
}
interface TuttiModePlanAssignmentAgentDetail {
    /** Provider-native models usable without a model plan. */
    models: readonly AgentActivityComposerSettingOption[];
    modelPlans: readonly {
        modelPlanId: string;
        label: string;
        models: readonly AgentActivityComposerSettingOption[];
    }[];
    permissionModes: readonly {
        id: string;
        label: string;
    }[];
    reasoningEfforts: readonly AgentActivityComposerSettingOption[];
}
interface TuttiPlanIssueTaskSnapshot {
    taskId: string;
    title: string;
    content: string;
    status: string;
    sortIndex: number;
    parallelizable: boolean;
    autoAccept: boolean;
    dependencyTaskIds: string[];
}
/** Read-only snapshot of the Issue a session's accepted plan materialized. */
interface TuttiPlanIssueSnapshot {
    workflowId: string;
    sourceTurnId: string | null;
    issueId: string;
    topicId: string;
    title: string;
    /** Durable Issue execution gate; paused graphs are not active work. */
    dispatchPaused: boolean;
    tasks: TuttiPlanIssueTaskSnapshot[];
}
/**
 * An accepted plan whose create_issue operation durably failed. The
 * conversation must surface this instead of rendering nothing: there is no
 * pending checkpoint (the review panel is gone) and no Issue (the issue panel
 * never appears), so silence would hide the failure entirely.
 */
interface TuttiPlanIssueMaterializationFailure {
    workflowId: string;
    sourceTurnId: string | null;
    errorMessage: string | null;
}
type TuttiPlanIssueQueryResult = {
    kind: "issue";
    issue: TuttiPlanIssueSnapshot;
} | ({
    kind: "materialization_failed";
} & TuttiPlanIssueMaterializationFailure) | null;
/**
 * Source for the embedded plan-issue panel in the conversation.
 * The host resolves "the Issue this session's accepted plan created", relays
 * live issue updates, and exposes only daemon-owned product commands. Task
 * accept/rework actions remain source-Agent prompts rather than generic Issue
 * mutations.
 */
interface TuttiPlanIssueSource {
    getSessionPlanIssue(input: {
        workspaceId: string;
        sourceSessionId: string;
    }): Promise<TuttiPlanIssueQueryResult>;
    subscribeIssueUpdates(workspaceId: string, listener: (update: {
        issueId: string;
    }) => void): () => void;
    /**
     * Stops the Issue's execution: pauses future dispatch and cancels every
     * running task run. Idempotent; the daemon owns the cascade.
     */
    cancelExecution(input: {
        workspaceId: string;
        issueId: string;
    }): Promise<void>;
    /**
     * Resolves the delegate agent session that ran (or is running) a task's
     * latest run, so a task card can jump straight into that conversation.
     * Null when the task has not launched yet.
     */
    resolveTaskSession(input: {
        workspaceId: string;
        issueId: string;
        taskId: string;
    }): Promise<{
        agentSessionId: string;
    } | null>;
}
/**
 * Option catalogs for per-task assignment editing. The desktop host reuses
 * its agent directory and composer capability catalogs; the panel never
 * hardcodes providers or modes.
 */
interface TuttiModePlanAssignmentOptionsSource {
    /**
     * Returns the last successful workspace directory, including stale data.
     * Hosts may omit this when they do not retain a query cache.
     */
    readAgents?(input: {
        workspaceId: string;
    }): readonly TuttiModePlanAssignmentAgentOption[] | null;
    listAgents(input: {
        workspaceId: string;
    }): Promise<readonly TuttiModePlanAssignmentAgentOption[]>;
    /**
     * Returns the last successful target catalog, including stale data, so a
     * refresh never replaces usable selectors with a loading placeholder.
     */
    readAgentOptions?(input: {
        workspaceId: string;
        agentTargetId: string;
    }): TuttiModePlanAssignmentAgentDetail | null;
    loadAgentOptions(input: {
        workspaceId: string;
        agentTargetId: string;
    }): Promise<TuttiModePlanAssignmentAgentDetail>;
}
interface TuttiModePlanReviewRuntime {
    listPending(input: {
        workspaceId: string;
        sourceSessionId: string;
    }): Promise<readonly TuttiModePlanReviewSnapshot[]>;
    decide(input: TuttiModePlanReviewDecisionInput): Promise<void>;
    subscribe(workspaceId: string, listener: (update: TuttiModePlanReviewInvalidation) => void): () => void;
    /** Optional; the panel degrades to read-only assignment display without it. */
    assignmentOptions?: TuttiModePlanAssignmentOptionsSource;
    /** Optional; without it the embedded plan-issue panel never renders. */
    planIssues?: TuttiPlanIssueSource;
}

type AgentGUIComposerFooterAccessoryContext = Pick<AgentComposerProps, "agentSessionId" | "isActive" | "isSendingTurn" | "isSubmittingPrompt" | "composerSettings" | "selectedAgentTarget">;
type AgentGUIComposerFooterAccessoryRenderer = (context: AgentGUIComposerFooterAccessoryContext) => ReactNode;

type AgentMentionReferenceTargetResolver = (item: AgentContextMentionItem) => ReferenceLocateTarget | null;
interface AgentWorkspaceReferenceInitialTargetInput {
    activeConversation: AgentGUINodeViewModel["rail"]["activeConversation"];
    composerSelectedProjectPath: string | null;
    userProjects: AgentGUINodeViewModel["rail"]["userProjects"];
}
type AgentWorkspaceReferenceInitialTargetResolver = (input: AgentWorkspaceReferenceInitialTargetInput) => ReferenceLocateTarget | null;
interface AgentGUIConversationRailLayout {
    providerRailWidthPx: number;
    conversationRailWidthPx: number;
    leftPanelWidthPx: number;
    resizing: boolean;
}
interface AgentGUISidebarFooterContext {
    currentUserId?: string | null;
    activeConversation: AgentGUINodeViewModel["rail"]["activeConversation"];
}
type AgentGUISidebarFooterRenderer = (ctx: AgentGUISidebarFooterContext) => ReactNode;
/** Renders the host-owned empty state for an exact provider rail. */
type AgentGUIAgentsEmptyRenderer = () => ReactNode;

type AgentGUIPublicHostCapabilities = Omit<AgentGUINodeProps["hostCapabilities"], "agentTargets" | "agentTargetsLoading" | "mentionAgentTargets" | "handoffAgentTargets" | "handoffAgentTargetsLoading" | "providerRailAllPresentation" | "providerRailMode" | "disabledHomeSuggestions">;
type AgentGUIPublicRenderSlots = Omit<AgentGUINodeProps["renderSlots"], "providerRailEmpty">;
interface AgentGUIProps extends Omit<AgentGUINodeProps, "hostCapabilities" | "renderSlots"> {
    agentDirectory: AgentGUIAgentDirectorySnapshot;
    /**
     * Complete host-owned identity catalog for rendered Agent mentions. Unlike
     * handoff, this directory may include unavailable targets because it does
     * not grant launch capability.
     */
    mentionAgentDirectory?: AgentGUIAgentDirectorySnapshot;
    /**
     * Host-owned launch catalog for conversation handoff. When omitted, handoff
     * uses `agentDirectory`, preserving the single-runtime host contract.
     */
    handoffAgentDirectory?: AgentGUIAgentDirectorySnapshot;
    allAgentsPresentation?: AgentGUIAllAgentsPresentation | null;
    renderAgentsEmpty?: AgentGUIAgentsEmptyRenderer;
    agentActivityRuntime: AgentGUIRuntime;
    agentSideConversationRuntime?: AgentSideConversationRuntime | null;
    agentHostApi?: AgentHostInputApi | null;
    tuttiModePlanReviewRuntime?: TuttiModePlanReviewRuntime | null;
    /** Starter entries to hide below the empty new-session composer. */
    disabled?: readonly AgentGUIHomeSuggestionId[];
    i18n?: I18nRuntime<string> | null;
    locale?: AgentGuiI18nLocale;
    hostCapabilities: AgentGUIPublicHostCapabilities;
    renderSlots: AgentGUIPublicRenderSlots;
}
declare const AgentGUI: react.MemoExoticComponent<({ agentActivityRuntime, agentSideConversationRuntime, agentHostApi, tuttiModePlanReviewRuntime, agentDirectory, mentionAgentDirectory, handoffAgentDirectory, allAgentsPresentation, renderAgentsEmpty, disabled, i18n, locale, ...props }: AgentGUIProps) => JSX.Element>;

interface AgentSideConversationTransport {
    resolveCapabilities(workspaceId: string, sourceAgentSessionId: string): Promise<AgentSideCapabilities>;
    open(input: {
        workspaceId: string;
        sourceAgentSessionId: string;
        sideAgentSessionId: string;
        requestId: string;
    }): Promise<{
        status: string;
    }>;
    send(input: {
        workspaceId: string;
        sideAgentSessionId: string;
        turnId: string;
        clientSubmitId: string;
        content: Parameters<AgentSideConversationRuntime["send"]>[0]["content"];
        displayPrompt?: string;
    }): Promise<void>;
    cancel(input: {
        workspaceId: string;
        sideAgentSessionId: string;
        turnId: string;
    }): Promise<void>;
    respond(input: Parameters<AgentSideConversationRuntime["respond"]>[0]): Promise<void>;
    close(input: {
        workspaceId: string;
        sideAgentSessionId: string;
    }): Promise<void>;
    subscribe(listener: (event: AgentSideConversationStreamEvent) => void): () => void;
    subscribeConnectionState(listener: (state: "connected" | "connecting" | "disconnected" | "disposed") => void): () => void;
    getConnectionState(): "connected" | "connecting" | "disconnected" | "disposed";
}
type AgentSideConversationStreamEvent = AgentSideUpdatedPayloadV1;
declare function createAgentSideConversationRuntime(transport: AgentSideConversationTransport): AgentSideConversationRuntime & {
    dispose(): void;
};

declare function AgentGUIConfigAccountFallbackSuppressed(): null;

interface AgentHandoffMenuLabels {
    action: string;
    deviceSource?: (deviceLabel: string) => string;
    menu: string;
    self: string;
    shared: string;
    tooltip: string;
}
interface AgentHandoffMenuProps {
    align?: "center" | "end" | "start";
    contentClassName?: string;
    disabled?: boolean;
    iconOnly?: boolean;
    isolateTriggerEvents?: boolean;
    labels: AgentHandoffMenuLabels;
    onSelect: (target: AgentGUIAgentTarget) => void;
    showOwnershipLabels?: boolean;
    targets: readonly AgentGUIAgentTarget[];
    testId?: string;
    triggerClassName?: string;
    triggerLabel?: string;
}
/**
 * Provider-neutral handoff target menu shared by AgentGUI and host surfaces.
 * The host owns the authoritative target list and launch behavior; this
 * component owns only temporary menu disclosure, presentation, and icon motion.
 */
declare function AgentHandoffMenu({ align, contentClassName, disabled, iconOnly, isolateTriggerEvents, labels, onSelect, showOwnershipLabels, targets, testId, triggerClassName, triggerLabel }: AgentHandoffMenuProps): JSX.Element;

declare function normalizeAgentGUIAgents(agents: readonly AgentGUIAgent[] | null | undefined): AgentGUIAgent[];
declare function agentGUIAgentIsReady(agent: AgentGUIAgent): boolean;
declare function resolveAgentGUISelectedDirectoryAgent(input: {
    agents: readonly AgentGUIAgent[];
    agentTargetId?: string | null;
    defaultAgentTargetId?: string | null;
}): AgentGUIAgent | null;
/** Projects the canonical Agent directory into target rows for selection menus. */
declare function projectAgentGUIAgentsToTargets(agents: readonly AgentGUIAgent[]): AgentGUIAgentTarget[];

declare const agentGUIDefaultTargetProviders: readonly AgentGUIProvider[];
declare function createLocalAgentGUIAgentTarget(provider: AgentGUIProvider): AgentGUIAgentTarget;
declare function createSharedAgentGUIAgentTarget(input: {
    provider: AgentGUIProvider;
    sharedAgentId: string;
    label: string;
    agentTargetId?: string | null;
    badge?: AgentGUIAgentTargetBadge | null;
    ownerLabel?: string | null;
    ownerDeviceLabel?: string | null;
    iconUrl?: string | null;
    maskIconUrl?: string | null;
    unavailableReason?: string | null;
    disabled?: boolean;
    ref?: Record<string, unknown> | null;
}): AgentGUIAgentTarget;
declare function createLocalAgentGUIAgentTargets(providers?: readonly AgentGUIProvider[]): AgentGUIAgentTarget[];
declare function localAgentGUIAgentTargetId(provider: AgentGUIProvider): string;
declare function normalizeAgentGUIAgentTargets(targets: readonly AgentGUIAgentTarget[] | null | undefined, options?: {
    includeDisabledPlaceholders?: boolean;
    useStaticCatalog?: boolean;
}): AgentGUIAgentTarget[];
declare function resolveAgentGUIAgentTarget(input: {
    agentTargetId?: string | null;
    defaultAgentTargetId?: string | null;
    provider: AgentGUIProvider;
    agentTargets: readonly AgentGUIAgentTarget[];
    useStaticCatalog?: boolean;
}): AgentGUIAgentTarget | null;

declare const agentGuiDockIconUrls: Record<string, string>;
declare const agentGuiDockIconUrl: string | undefined;

declare const AGENT_GUI_DETAIL_MIN_WIDTH_PX = 220;
declare const AGENT_GUI_COLLAPSED_MIN_WIDTH_PX = 460;
declare const AGENT_GUI_STANDALONE_MIDDLE_CONTENT_MIN_WIDTH_PX: number;
declare const AGENT_GUI_EXPANDED_TARGET_WIDTH_PX = 800;
interface AgentGUIConversationRailPresentation {
    conversationRailWidthPx: number;
    isAutoCollapsed: boolean;
    isCollapsed: boolean;
}
type AgentGUIConversationRailAutoCollapseMode = "default" | "preserve-middle-content";
interface AgentGUIExpandedWindowFrameInput {
    position: {
        x: number;
        y: number;
    };
    width: number;
    height: number;
    desktopSize: {
        width: number;
        height: number;
    };
    conversationRailWidthPx: number | null | undefined;
}
declare function shouldAutoCollapseAgentGUIConversationRail(containerWidthPx: number, options?: {
    mode?: AgentGUIConversationRailAutoCollapseMode;
    conversationRailWidthPx?: number | null;
}): boolean;
declare function resolveAgentGUIConversationRailPresentation(input: {
    autoCollapseMode?: AgentGUIConversationRailAutoCollapseMode;
    containerWidthPx: number;
    conversationRailCollapsed?: boolean | null;
    conversationRailWidthPx?: number | null;
}): AgentGUIConversationRailPresentation;
declare function resolveStandaloneAgentGUIViewportMinimumWidthPx(input: {
    conversationRailCollapsed?: boolean | null;
    conversationRailWidthPx?: number | null;
}): number;
declare function resolveAgentGUIExpandedWindowFrame(input: AgentGUIExpandedWindowFrameInput): {
    position: {
        x: number;
        y: number;
    };
    size: {
        width: number;
        height: number;
    };
};

interface AgentGUIActivityHostProviderProps extends PropsWithChildren {
    agentActivityRuntime?: AgentGUIRuntime | null;
    agentHostApi?: AgentHostInputApi | null;
}
declare function AgentGUIActivityHostProvider({ agentActivityRuntime, agentHostApi, children }: AgentGUIActivityHostProviderProps): JSX.Element;

/**
 * Structural surface the binding needs from an engine instance. Matches
 * AgentSessionEngine from @tutti-os/agent-activity-core, but stays structural
 * so focused tests and future engine slices can bind without the full engine.
 *
 * Contract: `subscribe` and `getSnapshot` must be stable, this-free function
 * references for the lifetime of the instance (the engine factory returns
 * closures, satisfying this by construction). A fresh `subscribe` identity per
 * render would force useSyncExternalStore to resubscribe on every render.
 */
interface EngineStateStore<TState> {
    getSnapshot(): TState;
    subscribe(listener: () => void): () => void;
}
declare function useEngineSelector<TState, TSelected>(engine: EngineStateStore<TState>, selector: (state: TState) => TSelected, isEqual?: (a: TSelected, b: TSelected) => boolean): TSelected;

type AgentPlanPromptAction = typeof PLAN_IMPLEMENTATION_ACTION_IMPLEMENT | typeof PLAN_IMPLEMENTATION_ACTION_FEEDBACK | typeof PLAN_IMPLEMENTATION_ACTION_SKIP;
declare function selectAgentPlanPromptTurn(state: AgentSessionEngineState, agentSessionId: string, requestId: string): _tutti_os_agent_activity_core.AgentActivityTurn | null;
declare function dispatchAgentPlanPromptAction(input: {
    action: AgentPlanPromptAction;
    agentSessionId: string;
    engine: AgentSessionEngine;
    feedbackText?: string;
    nowUnixMs?: () => number;
    requestId: string;
    workspaceId: string;
}): boolean;

type AgentGUIPerformanceDurationBucket = "lt_1s" | "1s_to_3s" | "3s_to_10s" | "10s_to_30s" | "30s_to_60s" | "gte_60s";
type AgentGUIFirstTokenKind = "other" | "plan" | "reasoning" | "text";
type AgentGUIComposerOptionsLoadSource = "runtime" | "session-engine";
type AgentGUIPerformanceFailureStage = "options_load" | "session_activation" | "prompt_admission" | "turn_settlement" | "unknown";
interface AgentGUIPerformanceEventBase {
    agentSessionId: string;
    durationBucket: AgentGUIPerformanceDurationBucket;
    durationMs: number;
    observedAtUnixMs: number;
    operationId: string;
    provider: string;
    startedAtUnixMs: number;
    workspaceId: string;
}
type AgentGUIPerformanceEvent = (AgentGUIPerformanceEventBase & {
    commandDurationMs?: number;
    commandOutcome: PendingActivationCommandOutcome;
    errorCategory?: string;
    errorCode?: string;
    failureStage?: AgentGUIPerformanceFailureStage;
    hasInitialPrompt: boolean;
    lastObservedStage: PendingActivationLastObservedStage;
    mode: "existing" | "new";
    outcome: "confirmed" | "failed";
    snapshotDurationMs?: number;
    snapshotOutcome: PendingActivationSnapshotOutcome;
    type: "session_activation_settled";
}) | (AgentGUIPerformanceEventBase & {
    errorCategory?: string;
    errorCode?: string;
    failureStage?: AgentGUIPerformanceFailureStage;
    outcome: "accepted" | "failed";
    queued: boolean;
    source: "activation" | "submit";
    turnId: string | null;
    type: "prompt_admission_settled";
}) | (AgentGUIPerformanceEventBase & {
    firstTokenKind: AgentGUIFirstTokenKind;
    queued: boolean;
    source: "activation" | "submit";
    turnId: string;
    type: "prompt_first_token_received";
}) | (AgentGUIPerformanceEventBase & {
    errorCategory?: string;
    errorCode?: string;
    failureStage?: AgentGUIPerformanceFailureStage;
    outcome: "canceled" | "completed" | "failed" | "interrupted";
    source: "activation" | "submit";
    turnId: string;
    type: "turn_settled";
}) | {
    agentTargetId: string;
    force: boolean;
    hasDirectory: boolean;
    observedAtUnixMs: number;
    operationId: string;
    provider: string;
    source: AgentGUIComposerOptionsLoadSource;
    startedAtUnixMs: number;
    type: "composer_options_load_started";
    workspaceId: string;
} | {
    agentTargetId: string;
    durationBucket: AgentGUIPerformanceDurationBucket;
    durationMs: number;
    errorCategory?: string;
    errorCode?: string;
    failureStage?: AgentGUIPerformanceFailureStage;
    force: boolean;
    hasDirectory: boolean;
    modelCount?: number;
    modelNames?: string[];
    observedAtUnixMs: number;
    operationId: string;
    outcome: "completed" | "failed";
    provider: string;
    source: AgentGUIComposerOptionsLoadSource;
    startedAtUnixMs: number;
    type: "composer_options_load_settled";
    workspaceId: string;
} | {
    agentTargetId: string;
    force: boolean;
    hasDirectory: boolean;
    observedAtUnixMs: number;
    operationId: string;
    provider: string;
    section: string;
    source: AgentGUIComposerOptionsLoadSource;
    stage: string;
    startedAtUnixMs: number;
    type: "composer_options_stage_started";
    workspaceId: string;
} | {
    agentTargetId: string;
    durationBucket: AgentGUIPerformanceDurationBucket;
    durationMs: number;
    errorCategory?: string;
    errorCode?: string;
    failureStage?: AgentGUIPerformanceFailureStage;
    force: boolean;
    hasDirectory: boolean;
    modelNames?: string[];
    observedAtUnixMs: number;
    operationId: string;
    outcome: "completed" | "failed";
    provider: string;
    section: string;
    source: AgentGUIComposerOptionsLoadSource;
    stage: string;
    startedAtUnixMs: number;
    type: "composer_options_stage_settled";
    workspaceId: string;
};
type AgentGUIComposerOptionsPerformanceEvent = Extract<AgentGUIPerformanceEvent, {
    type: "composer_options_load_settled" | "composer_options_load_started" | "composer_options_stage_settled" | "composer_options_stage_started";
}>;

interface AgentGUIComposerOptionsLoadInput {
    agentTargetId: string;
    cwd?: string | null;
    force?: boolean;
    load: () => Promise<AgentActivityComposerOptions>;
    section?: string | null;
    stage?: string | null;
    provider?: string | null;
    source: AgentGUIComposerOptionsLoadSource;
}
interface AgentGUIComposerOptionsPerformanceTrackerInput extends AgentGUIComposerOptionsLoadInput {
    createOperationId?: () => string;
    nowUnixMs?: () => number;
    onEvent: (event: AgentGUIComposerOptionsPerformanceEvent) => void;
    workspaceId: string;
}
declare function trackAgentGUIComposerOptionsLoad(input: AgentGUIComposerOptionsPerformanceTrackerInput): Promise<AgentActivityComposerOptions>;
declare function agentGUIPerformanceDuration(durationMs: number): {
    durationBucket: AgentGUIPerformanceDurationBucket;
    durationMs: number;
};

interface AgentGUIPerformanceMonitor {
    dispose(): void;
    trackComposerOptionsLoad(input: AgentGUIComposerOptionsLoadInput): Promise<AgentActivityComposerOptions>;
}
declare function createAgentGUIPerformanceMonitor(input: {
    createOperationId?: () => string;
    engine: AgentSessionEngine;
    nowUnixMs?: () => number;
    onEvent: (event: AgentGUIPerformanceEvent) => void;
    subscribeSessionEvents: (listener: (event: unknown) => void) => () => void;
}): AgentGUIPerformanceMonitor;

export { AGENT_CONTEXT_MENTION_PROVIDER_IDS, AGENT_GUI_COLLAPSED_MIN_WIDTH_PX, AGENT_GUI_DETAIL_MIN_WIDTH_PX, AGENT_GUI_EXPANDED_TARGET_WIDTH_PX, AGENT_GUI_STANDALONE_MIDDLE_CONTENT_MIN_WIDTH_PX, AGENT_PASTED_TEXT_BLOCK_KIND, AGENT_PASTED_TEXT_MENTION_KIND, type AgentActivityRuntimeActivateSessionInput, type AgentActivityRuntimeDeleteSessionsBatchInput, type AgentActivityRuntimeDeleteSessionsBatchResult, type AgentActivityRuntimeListSessionMessagesInput, type AgentActivityRuntimePromptContentBlock, type AgentActivityRuntimeSessionSectionDeletionCandidates, type AgentActivityRuntimeSessionSectionScopeInput, type AgentActivityRuntimeSetSessionPinnedInput, type AgentActivityRuntimeUnactivateSessionInput, type AgentActivityRuntimeUpdateSessionSettingsInput, type AgentActivityRuntimeUpdateSessionSettingsResult, type AgentActivityRuntimeUploadPromptContentInput, type AgentActivityRuntimeUploadPromptContentResult, type AgentActivitySessionMessages, type AgentComposerDraftFile, type AgentContextMentionProvider, type AgentContextMentionProviderId, type AgentCustomMentionChipContext, type AgentCustomMentionIdentity, type AgentCustomMentionKindDefinition, type AgentCustomMentionPresentation, type AgentExternalPromptEntryResolution, type AgentExternalPromptEntryResolver, type AgentExternalPromptFilePreparationErrorCode, type AgentExternalPromptFilePreparationResult, type AgentExternalPromptFilePreparer, AgentGUI, AgentGUIActivityHostProvider, type AgentGUIActivityHostProviderProps, type AgentGUIAgent, type AgentGUIAgentAvailability, type AgentGUIAgentAvailabilityAction, type AgentGUIAgentAvailabilityStatus, type AgentGUIAgentConfigMenuContext, type AgentGUIAgentDirectoryPort, type AgentGUIAgentDirectorySnapshot, type AgentGUIAgentDirectoryStatus, type AgentGUIAgentOwner, type AgentGUIAgentOwnership, type AgentGUIAgentTarget, type AgentGUIAgentTargetBadge, type AgentGUIAgentTargetInfoRenderContext, type AgentGUIAgentTargetInfoRenderer, type AgentGUIAgentTargetInfoSurface, type AgentGUIAgentTargetRef, type AgentGUIAgentsEmptyRenderer, type AgentGUIAllAgentsPresentation, type AgentGUIComposerAppendRequest, type AgentGUIComposerContentType, type AgentGUIComposerFocusMethod, type AgentGUIComposerOptionsLoadInput, type AgentGUIComposerOptionsLoadSource, type AgentGUIComposerOptionsPerformanceEvent, type AgentGUIComposerOptionsPerformanceTrackerInput, AgentGUIConfigAccountFallbackSuppressed, type AgentGUIConversationRailAutoCollapseMode, type AgentGUIConversationRailLayout, type AgentGUIConversationRailPresentation, type AgentGUIEngagementContext, type AgentGUIEngagementEvent, type AgentGUIEngagementEventSink, type AgentGUIFirstTokenKind, type AgentGUIHomeSuggestionId, type AgentGUIInteractionReadiness, type AgentGUIInteractionReadinessIdentity, type AgentGUIInteractionReadinessReason, type AgentGUIInteractionReadinessSource, type AgentGUIObservationGap, type AgentGUIObservationGapSource, type AgentGUIPerformanceDurationBucket, type AgentGUIPerformanceEvent, type AgentGUIPerformanceFailureStage, type AgentGUIPerformanceMonitor, type AgentGUIProps, type AgentGUIProvider, type AgentGUIProviderRailAllPresentation, type AgentGUIProviderRailMode, type AgentGUIProviderReadinessGate, type AgentGUIProviderReadinessGateAction, type AgentGUIProviderReadinessGateStatus, type AgentGUIQuickPromptType, type AgentGUIRuntime, AgentGUIRuntimeProvider, type AgentGUIRuntimeProviderProps, type AgentGUISessionLaunchMode, type AgentGUISideConversationIdentity, type AgentGUISideConversationPresentation, type AgentGUISideConversationProjection, AgentGUISideConversationSurface, type AgentGUISideConversationSurfaceProps, type AgentGUISidebarFooterContext, type AgentGUISidebarFooterRenderer, type AgentGUITargetConnectionSource, type AgentGUITargetConnectionState, type AgentGUITargetConnectionStatus, type AgentGuiI18nLocale, AgentGuiI18nProvider, AgentHandoffMenu, type AgentHandoffMenuLabels, type AgentHandoffMenuProps, type AgentHostAgentTargetAuthenticatedAccount, type AgentHostAgentTargetSetupSnapshot, type AgentHostAgentTargetSetupState, type AgentHostAgentTargetSetupWatch, type AgentHostApi, type AgentHostApplyWorkspaceGitPatchInput, type AgentHostInputApi, type AgentHostQuickPrompt, type AgentHostQuickPromptSnapshot, type AgentHostQuickPromptsApi, type AgentHostResolveSessionWorktreeSupportInput, type AgentHostResolveSessionWorktreeSupportResult, type AgentHostRuntimeApi, type AgentHostSelectFilesInput, type AgentHostTerminalStartupAction, type AgentHostUserProject, type AgentPlanPromptAction, type AgentPreparedExternalPromptFile, type AgentProbeProvider, type AgentProbeSnapshot, type AgentProviderProbeListInput, type AgentProviderProbeListResult, type AgentRunErrorCode, type AgentSideCapabilities, type AgentSideConversationRuntime, AgentSideConversationRuntimeProvider, type AgentSideConversationSnapshot, type AgentSideConversationState, type AgentSideConversationStreamEvent, type AgentSideConversationTransport, type AgentSideInteraction, type AgentSideInteractionAction, type AgentStatusController, type AgentStatusControllerOptions, type AgentStatusControllerSnapshot, type AgentStatusFrame, type AgentStatusQuery, type AgentStatusRequestPhase, type AgentStatusRequestReason, type AgentStatusSectionState, type AgentStatusSelectionKey, type AgentStatusSource, type AgentStatusSourceError, type AgentStatusStreamObserver, type AgentStatusValue, type AgentUsageQuota, type AgentUsageSnapshot, type AgentVisibleErrorOverride, type AgentVisibleErrorOverrideCode, type AgentVisibleErrorOverrides, type AgentVisibleErrorPresentationScope, type CreateAgentSessionHandoffPromptInput, type CreateAgentSessionMarkdownLinkInput, type EngineStateStore, type PersistWriteResult, type ReadWorkspaceAgentReadStateInput, type TuttiModePlanAssignmentAgentDetail, type TuttiModePlanAssignmentAgentOption, type TuttiModePlanAssignmentOptionsSource, type TuttiModePlanReviewRuntime, type TuttiModePlanReviewSnapshot, type TuttiModePlanTaskAssignmentInput, type TuttiPlanIssueMaterializationFailure, type TuttiPlanIssueQueryResult, type TuttiPlanIssueSnapshot, type TuttiPlanIssueSource, type TuttiPlanIssueTaskSnapshot, type WorkspaceAgentReadStateSnapshot, type WriteWorkspaceAgentReadStateInput, agentGUIAgentIsReady, agentGUIDefaultTargetProviders, agentGUIPerformanceDuration, agentGuiDockIconUrl, agentGuiDockIconUrls, agentGuiI18nModule, agentGuiI18nResources, createAgentGUIPerformanceMonitor, createAgentGUISideConversationPresentation, createAgentSessionHandoffPrompt, createAgentSessionMarkdownLink, createAgentSideConversationRuntime, createAgentStatusController, createLocalAgentGUIAgentTarget, createLocalAgentGUIAgentTargets, createSharedAgentGUIAgentTarget, dispatchAgentPlanPromptAction, getAgentCustomMentionKind, localAgentGUIAgentTargetId, normalizeAgentGUIAgentTargets, normalizeAgentGUIAgents, preloadAgentMentionBrowse, projectAgentGUIAgentsToTargets, registerAgentCustomMentionKind, resetAgentCustomMentionKindsForTests, resetAgentGUIRuntimeForTests, resolveAgentGUIAgentTarget, resolveAgentGUIConversationRailPresentation, resolveAgentGUIExpandedWindowFrame, resolveAgentGUISelectedDirectoryAgent, resolveStandaloneAgentGUIViewportMinimumWidthPx, selectAgentPlanPromptTurn, selectAgentStatusControllerSnapshot, setAgentGUIRuntimeForTests, shouldAutoCollapseAgentGUIConversationRail, trackAgentGUIComposerOptionsLoad, useAgentActivitySessionMessages, useAgentActivitySnapshot, useAgentGUIRuntime, useAgentSideConversationSnapshot, useEngineSelector, useOptionalAgentGUIRuntime, useOptionalAgentSideConversationRuntime };