{
  "ACCOUNT_SETTINGS$LOGOUT": "Logout",
  "ACCOUNT_SETTINGS$SETTINGS": "Settings",
  "ACCOUNT_SETTINGS_MODAL$CLOSE": "Close",
  "ACCOUNT_SETTINGS_MODAL$DISCONNECT": "Disconnect",
  "ACCOUNT_SETTINGS_MODAL$GITHUB_TOKEN_INVALID": "GitHub token is invalid. Please try again.",
  "ACCOUNT_SETTINGS_MODAL$SAVE": "Save",
  "ACTION$CONFIRM": "Confirm action",
  "ACTION$CONFIRM_CLOSE": "Confirm Close",
  "ACTION$CONFIRM_DELETE": "Confirm Delete",
  "ACTION$CONFIRM_STOP": "Confirm Stop",
  "ACTION$CONFIRM_UPDATE": "Confirm Update",
  "ACTION$PUSH_CHANGES_TO_PR": "Push changes to PR",
  "ACTION$PUSH_CREATE_PR": "Push & Create PR",
  "ACTION$PUSH_TO_BRANCH": "Push to Branch",
  "ACTION$REJECT": "Reject action",
  "ACTION_BUTTON$RESUME": "Resume the agent task",
  "ACTION_MESSAGE$ACP_EDIT": "Editing <cmd>{{title}}</cmd>",
  "ACTION_MESSAGE$ACP_FETCH": "Fetching <cmd>{{title}}</cmd>",
  "ACTION_MESSAGE$ACP_READ": "Reading <cmd>{{title}}</cmd>",
  "ACTION_MESSAGE$ACP_RUN": "Running <cmd>{{title}}</cmd>",
  "ACTION_MESSAGE$ACP_TOOL": "<cmd>{{title}}</cmd>",
  "ACTION_MESSAGE$BROWSE": "Browsing the web",
  "ACTION_MESSAGE$BROWSE_INTERACTIVE": "Interactive browsing in progress...",
  "ACTION_MESSAGE$CALL_TOOL_MCP": "Calling MCP Tool: {{mcp_tool_name}}",
  "ACTION_MESSAGE$CONDENSATION": "Condensation",
  "ACTION_MESSAGE$EDIT": "Editing <path>{{path}}</path>",
  "ACTION_MESSAGE$GLOB": "Search files: <cmd>{{pattern}}</cmd>",
  "ACTION_MESSAGE$GREP": "Search in files: <cmd>{{pattern}}</cmd>",
  "ACTION_MESSAGE$INVOKE_SKILL": "Invoking skill <cmd>{{name}}</cmd>",
  "ACTION_MESSAGE$READ": "Reading <path>{{path}}</path>",
  "ACTION_MESSAGE$RUN": "Running <cmd>{{command}}</cmd>",
  "ACTION_MESSAGE$RUN_IPYTHON": "Running a Python command",
  "ACTION_MESSAGE$SYSTEM": "System Message",
  "ACTION_MESSAGE$TASK": "Running subagent <cmd>{{name}}</cmd>",
  "ACTION_MESSAGE$TASK_TRACKING": "Managing tasks",
  "ACTION_MESSAGE$THINK": "Thinking",
  "ACTION_MESSAGE$WRITE": "Writing to <path>{{path}}</path>",
  "AGENT$CLAUDE_CODE_DESCRIPTION": "Anthropic's Claude Code agent.",
  "AGENT$CODEX_DESCRIPTION": "OpenAI's Codex agent.",
  "AGENT$GEMINI_CLI_DESCRIPTION": "Google's Gemini CLI agent.",
  "AGENT$PAUSE_TASK": "Pause the current task",
  "AGENT$RESUME_TASK": "Resume the agent task",
  "AGENT_ERROR$ACTION_TIMEOUT": "Action timed out.",
  "AGENT_ERROR$BAD_ACTION": "Agent tried to execute a malformed action.",
  "AGENT_ERROR$ERROR_ACTION_NOT_EXECUTED_ERROR": "The action has not been executed due to a runtime error. The runtime system may have crashed and restarted due to resource constraints. Any previously established system state, dependencies, or environment variables may have been lost.",
  "AGENT_ERROR$ERROR_ACTION_NOT_EXECUTED_STOPPED": "Pause button pressed. Agent is stopped. The action has not been executed.",
  "AGENT_ERROR$TOO_MANY_CONVERSATIONS": "Too many conversations at once.",
  "AGENT_STATUS$AGENT_STOPPED": "Agent stopped",
  "AGENT_STATUS$ERROR_OCCURRED": "Error",
  "AGENT_STATUS$INITIALIZING": "Initializing agent...",
  "AGENT_STATUS$RUNNING_TASK": "Running",
  "AGENT_STATUS$WAITING_FOR_TASK": "Ready",
  "AGENT_STATUS$WAITING_FOR_USER_CONFIRMATION": "User needed",
  "AI_SETTINGS$TITLE": "AI Provider Configuration",
  "ALERT$APP_UPDATED_DISMISS": "Dismiss update notice",
  "ALERT$APP_UPDATED_MESSAGE": "A new version of Pilot is available. Refresh when you are ready — this page keeps working until then.",
  "ALERT$APP_UPDATED_REFRESH": "Refresh",
  "ALERT$FAULTY_MODELS_MESSAGE": "The following models are currently reporting errors:",
  "ALERT$MODULE_LOAD_FAILED": "This part of the app could not be loaded because the app was updated.",
  "API$DONT_KNOW_KEY": "Don't know your API key?",
  "API$KEY": "API Key",
  "API$NO_KEY_AVAILABLE": "No API key available",
  "API$TAVILY_KEY_EXAMPLE": "tvly-dev-...",
  "API$TVLY_KEY_EXAMPLE": "tvly-...",
  "APP$TITLE": "App",
  "ARCHITECTURE$ADDITIONAL_ALL_FEATURES_LINK": "See all OpenHands key features",
  "ARCHITECTURE$ADDITIONAL_GITHUB_DESCRIPTION": "OpenHands can respond to GitHub issues and pull requests through mentions or labels, allowing agent work to start without opening the web product.",
  "ARCHITECTURE$ADDITIONAL_GITHUB_LINK": "GitHub integration guide",
  "ARCHITECTURE$ADDITIONAL_GITHUB_TITLE": "GitHub-triggered agents",
  "ARCHITECTURE$ADDITIONAL_MCP_LINK": "OpenHands MCP guide",
  "ARCHITECTURE$ADDITIONAL_MODELS_DESCRIPTION": "The cloud deployment supplies one OpenRouter-backed LLM configuration from the server environment, and each role model defaults to it. A member may instead connect their own ChatGPT subscription and point individual role models at it; that connection is stored per user, and its tokens never reach the browser. The browser still does not add providers, store API keys, or override the organization runtime model.",
  "ARCHITECTURE$ADDITIONAL_MODELS_LINK": "OpenRouter model documentation",
  "ARCHITECTURE$ADDITIONAL_MODELS_TITLE": "Environment-managed OpenRouter model and per-user ChatGPT subscription",
  "ARCHITECTURE$ADDITIONAL_NEW_PROJECT_DESCRIPTION": "The underlying workspace can create a repository and build a new application from scratch, similar to Replit. This entry path is intentionally disabled in the current internal product while connected-repository workflows are prioritized.",
  "ARCHITECTURE$ADDITIONAL_NEW_PROJECT_TITLE": "Build a new project",
  "ARCHITECTURE$ADDITIONAL_SKILLS_LINK": "OpenHands Skills guide",
  "ARCHITECTURE$ADDITIONAL_SKILLS_MCP_DESCRIPTION": "User, organization, and repository skills add reusable instructions and domain knowledge. Organization skill bundles can be uploaded or imported from GitHub, stored in PostgreSQL, and materialized with their scripts, references, and assets inside each sandbox. A bundle containing .mcp.json requires an administrator warning confirmation before its MCP servers are merged into the sandbox agent tool loop.",
  "ARCHITECTURE$ADDITIONAL_SKILLS_MCP_TITLE": "Skills and MCP integrations",
  "ARCHITECTURE$ADDITIONAL_TITLE": "5. Additional features",
  "ARCHITECTURE$ADDITIONAL_TUTORIALS_LINK": "OpenHands tutorials",
  "ARCHITECTURE$AGENT_CLASSIFIER_DESCRIPTION": "Uses general_agent_model to choose Ask or Execution, reading a repository directory of one-line summaries and aliases rather than repository names alone, so a request naming a product resolves to the repository that owns it. Inspecting an existing public deployment stays in Ask and may use the isolated control browser; validating repository changes, local applications, or previews needs an execution environment, which the control turn itself activates and whose preview its browser then opens. Execution also requires a named change target; a change request whose location is not yet established stays in Ask, where the control agent reads first and activates execution itself. Invalid or missing execution repository scope fails safely back to Ask instead of guessing or starting an empty workspace. A repository the classifier cannot identify is handed to the control agent, which reads the directory before asking, rather than returned to the user as a question.",
  "ARCHITECTURE$AGENT_CLASSIFIER_TITLE": "Structured request classifier",
  "ARCHITECTURE$AGENT_CONTEXT_RUNTIME_DESCRIPTION": "Combines the server-owned LLM, system policies, repository scope, memory setting, tools, MCP, hooks, skills, plugins, secrets, and runtime service metadata into one serialized StartConversationRequest. Pilot removes the inherited generic AI-disclosure instruction at this source boundary, so agents do not append an on-behalf-of user signature to answers or external-service content. The SDK condenser compacts only the LLM-facing view while durable events remain intact; an idle live execution can request compaction through the authenticated App Server, which resolves the private Agent Server and its session key. Across idle eviction or an Agent Server process restart, base_state.json is the sole durable source for runtime Agent state; meta.json excludes the launch-only agent and top-level agent_profile_id so it cannot become a second Agent source. Rehydration restores the persisted Agent, LLM, and tools, so the first resumed model request keeps its model, tools, prompt-cache key and retention, and cacheable message prefix; explicit runtime model changes persist in the same base state. Rebuilt control history carries no encrypted reasoning at all. A provider binds an encrypted payload to the exact endpoint that produced it, and a control conversation's history is not one endpoint's: the control agent's events sit beside the execution agent's, imported from the sandbox under the coding model. Every replayed event drops its reasoning item; durable events and their visible reasoning summaries are unchanged.",
  "ARCHITECTURE$AGENT_CONTEXT_RUNTIME_TITLE": "Agent context assembly",
  "ARCHITECTURE$AGENT_DETAIL_INTRO": "The accuracy path is a sequence of complementary layers. No single layer gives the model the entire system; each layer narrows the search space or verifies the evidence produced by the previous one.",
  "ARCHITECTURE$AGENT_DETAIL_TITLE": "3. Agent system in detail",
  "ARCHITECTURE$AGENT_HANDOFF_BODY": "Direct Execution routing starts from the durable user request and selected repositories without copying control evidence. When an Ask turn explicitly activates execution, the run starts from the task stated in the activation action rather than the latest user message, so a request answered across several turns still reaches the sandbox, and the App Server stores a private control handoff capped at 12,000 characters on the durable start task. Startup consumes the first ready snapshot, so later control updates are durable but are not guaranteed to enter an already-created execution prompt.",
  "ARCHITECTURE$AGENT_LOOP_BODY": "Pilot keeps the inherited OpenHands execution harness as the basic loop, then adds repository intelligence, evidence evaluation, and bounded delegation around it. These layers improve tool selection and factual grounding without replacing the SDK's typed action-observation event model.",
  "ARCHITECTURE$AGENT_LOOP_TITLE": "7. Agent loop & intelligence",
  "ARCHITECTURE$AGENT_MODEL_POLICY_BODY": "The request classifier uses general_agent_model. In the current implementation, sandbox-free Ask control turns and sandbox execution resolve code_agent_model unless an explicit model or Agent Profile overrides them. Automatic GitHub pull-request reviews and Automations resolve automation_agent_model unless an explicit model or Agent Profile overrides them. A pull request whose diff is classified high-risk uses the Organization's optional high_risk_review_model for the review. The independent verifier resolves review_verifier_model when set, then high_risk_review_model on a high-risk diff, then automation_agent_model. Production credentials and endpoints remain server-owned. Session titles use session_title_model in the App Server to summarize the first human request in its language. System messages, machine senders and background feedback never enter the title input. Generated titles stay stable; manual renames take precedence.",
  "ARCHITECTURE$AGENT_RUNTIME_BODY": "Every AUTO turn is first persisted by the App Server. A structured router classifies the original request as Ask or Execution and validates an explicit or connected repository scope. Ask runs in the control plane with bounded repository, database, and integration tools. Execution creates or resumes a private Agent Server conversation beside the selected workspace, where the OpenHands SDK runs the model-action-observation loop.",
  "ARCHITECTURE$AGENT_RUNTIME_TITLE": "5. Agent runtime",
  "ARCHITECTURE$ARTIFACT_DOWNLOAD_DESCRIPTION": "The control plane downloads the named artifact from the authorized Agent Server. The sandbox sends a reference and never receives the optional encrypted GitHub browser session.",
  "ARCHITECTURE$ARTIFACT_DOWNLOAD_TITLE": "Server-side retrieval",
  "ARCHITECTURE$ARTIFACT_MCP_DESCRIPTION": "The Agent calls one sandbox-scoped MCP tool for repository visual evidence. It authenticates to the control plane and resolves the DB-proven conversation, owner, organization, and repository before creating both the timeline artifact and PR URL record.",
  "ARCHITECTURE$ARTIFACT_MCP_TITLE": "Authenticated MCP request",
  "ARCHITECTURE$ARTIFACT_RENDERING_DESCRIPTION": "cm_pilot tables store repository-scoped native or fallback URL records for PR rendering. The same publication stores the private Pilot timeline artifact in S3 for 90 days; a successful native URL remains durable independently of that retention window.",
  "ARCHITECTURE$ARTIFACT_RENDERING_TITLE": "Two durable views",
  "ARCHITECTURE$ARTIFACT_VALIDATION_DESCRIPTION": "The control plane enforces bounded size and verifies the declared screenshot or video media type against the file signature before S3 storage or GitHub upload.",
  "ARCHITECTURE$ARTIFACT_VALIDATION_TITLE": "Media validation",
  "ARCHITECTURE$ASK_ROUTE_DESCRIPTION": "Read-only questions retain durable history, bounded indexed code chunks, data tools, Discover-Reconcile-Answer evaluation, and lock-backed interruption recovery. The control agent does not fetch whole repository files or publish repository changes.",
  "ARCHITECTURE$ASK_ROUTE_TITLE": "Ask: evidence LSM",
  "ARCHITECTURE$AST_DESCRIPTION": "tree-sitter parses supported source files into classes, functions, methods, interfaces, enums, structs, and type declarations. Chunks retain symbol names and line ranges, producing more meaningful retrieval units than arbitrary text windows.",
  "ARCHITECTURE$AST_TITLE": "Structure-aware code understanding",
  "ARCHITECTURE$ATTACHMENT_STORAGE_DESCRIPTION": "Slack files are copied into private encrypted S3 storage, indexed by conversation and source message in SQL, and rendered with short-lived signed URLs.",
  "ARCHITECTURE$ATTACHMENT_STORAGE_TITLE": "Durable attachments",
  "ARCHITECTURE$BACKEND_LABEL": "Backend",
  "ARCHITECTURE$BROWSER_SECRET_ENTRY_DESCRIPTION": "SDKBrowserToolSet exposes native SDK tool names and schemas. Ordinary search text needs no registered account. Browser observations report credential lookup history, not authentication state: Dev mode or an existing session may already grant access, so the requested surface is checked before reporting a login blocker. An attached sandbox executes browser actions with its repository-scoped LookupSecret registry; account values are not copied into RPC arguments. Credential references are accepted only on the bound Preview; sandbox credential-bearing sequences require individual calls so origin is rechecked; raw secret lookup and browser storage tools are filtered and refused at dispatch, including batch steps. Values must not enter messages, terminal commands, or retained artifacts. Native screenshot bytes go through image verification and automatic publication; there is no separate capture-publication tool. One generic broker forwards the SDK catalog and native calls; per-action App Server tools and the separate design-proposal renderer are removed. The sandbox-free worker and viewer share the SDK runtime.",
  "ARCHITECTURE$BROWSER_SECRET_ENTRY_TITLE": "Browser-safe field entry",
  "ARCHITECTURE$CANVAS_FOUNDATION_DESCRIPTION": "OpenHands Agent Canvas is the UI and design-system source of truth. Pilot adapts its React routes, typed client services, conversation surfaces, settings, files, browser, and app panels instead of restoring the legacy frontend.",
  "ARCHITECTURE$CANVAS_FOUNDATION_TITLE": "Agent Canvas foundation",
  "ARCHITECTURE$CONTEXT_BODY": "The model does not have direct access to product state or a repository. AgentContext and the conversation view deliberately assemble the smallest useful model input from durable events and explicit knowledge sources. A web message beginning with /aside is stored as durable context without starting an agent turn. A BTW question uses a fixed durable history snapshot and an independent read-only side agent, so it cannot steer or block the active turn.",
  "ARCHITECTURE$CONTEXT_CONDENSER": "When token pressure grows, the condenser summarizes a valid atomic range. Original events remain durable; only the LLM-facing view is compacted.",
  "ARCHITECTURE$CONTEXT_INSTRUCTIONS": "System instructions combine product behavior, repository guidance such as AGENTS.md, and always-active user, team, organization, or project skills.",
  "ARCHITECTURE$CONTEXT_OBSERVATIONS": "File content, search matches, command output, browser state, and MCP results enter context only after an explicit tool action produces an observation.",
  "ARCHITECTURE$CONTEXT_TITLE": "Context construction and memory",
  "ARCHITECTURE$CONTROL_AGENT_RUNTIME_DESCRIPTION": "Runs a 16-iteration SDK worker -- 20 for an automatic pull-request review, whose last four iterations are reserved for posting it, so investigation cannot spend the budget the review itself needs -- in a temporary server workspace with indexed code search, bounded exact-file reads, schema and SQL tools, integrations, Organization Skills, and execution activation. Activation is bounded to the organization's connected repositories, whose exact names the control prompt carries: a name outside that set is refused at the call, with the connected list, so a guessed name is corrected in the same turn instead of ending it. When configured, a dedicated authenticated control-browser worker observes existing public deployments without a sandbox: isolated per-Organization and per-conversation SDK browser processes serialize actions within each session, cap capacity, and never receive the App Server's database, GitHub, Slack, or LLM credentials. The control agent receives indexed elements, bounded rendered text, and captured images, and may open any public HTTPS page, vendor documentation included. Typing and form-filling are offered but put a credential into exactly one kind of page: the conversation's own preview address, served by the execution environment the turn activated; on any other page the executor refuses and names that address, so the property is held by the page's owner instead of by a deployment-wide host. The Browser tab streams ephemeral frames through an authenticated same-origin App Server WebSocket. A signed-in Organization member may take the session control lock for MFA or passkeys, and agent actions pause until control is returned. This browser runs no repository code itself. Once the turn has activated an execution environment whose repository declares a runtime, the workspace serves the application from its working tree at the conversation's own preview address; every run_in_execution_environment result reports that address and whether it is serving, a browser observation of any other host says it cannot show the change, a signed-out observation names the registered test accounts for the workspace, a screenshot obligation cannot be released while that preview is up and unvisited, and native screenshot observations automatically publish verified evidence. Once a sandbox is attached, native actions and captures use that sandbox's browser API, never the control browser, without starting another reasoning loop. Beyond the operations an integration declares, it can read that integration's own API by path, GET-only and with the credential never leaving the App Server, so a question no manifest anticipated does not require new backend code. An interactive conversation gets the read-only GitHub pull-request diff tool only when its structured PR URL, number, and selected repository match; the review-posting tool remains restricted to server-authorized automatic reviews. Up to three tool calls run concurrently, and it can delegate one bounded read-only investigation to a separate sub-agent that returns only its report; that sub-agent receives the read-only tools alone, with no write, activation, or further delegation tool. It receives no browser either. It also delivers code without a sandbox: commit to a non-default branch, publish or synchronize that branch's pull request, and merge it, all through the provider API with no checkout, so a conversation that never started an execution environment or has already closed one can still deliver a change. A write to a default branch is refused, only connected repositories are writable, and neither an automatic review nor a delegated sub-agent receives these tools. A turn that has already activated an execution environment does not receive them either: the execution agent delivers that request, and publishing from the control side as well opened a second pull request for the same work. It still has no terminal or file editor, and a change delivered this way carries no build, test, or run evidence. Creating a repository is the one repository write with no existing target to check, so it is gated on a person: preview_repository_creation validates the owner against the accounts the organization already reaches, records a durable approval row, and creates nothing, while execute_confirmed_repository_creation refuses until an organization administrator presses Approve or sends the exact confirmation phrase. A declined request can never be created, an approval is claimed once, and the same gate applies to the sandbox-facing create_repository tool. See repository_creation_approval_service.py. The sdk_browser_tool_set catalog preserves native schemas, and the control_browser_sdk transport event retains original capture provenance.",
  "ARCHITECTURE$CONTROL_AGENT_RUNTIME_TITLE": "Sandbox-free control agent",
  "ARCHITECTURE$CONTROL_WORKER_REVISIONS_DESCRIPTION": "The web tier persists control requests but does not execute them. Blue/green control-worker slots register a code revision plus a slot instance; only the atomically active revision and that instance may claim new queue or recovery leases. Activation marks the previous revision draining, and deployment keeps it alive until its owner-fenced leases reach zero before retirement. Expired claims enter durable crash recovery instead of blocking the queue. Stop and Interrupt serialize against enqueue and recovery ownership, then mark only the current claimed turn without discarding later messages. The owning worker polls that durable intent and removes it only after acknowledgment, so cancellation survives a listener reconnect and interrupts routing, control-agent setup, and the active model loop. Stop intent is monotonic: a later Interrupt cannot weaken it. Stop and Interrupt both cancel a still-pending sandbox start so its embedded request cannot run later; Interrupt leaves an already assigned sandbox running. Singleton schedulers run separately in background-worker. Sandbox Agent Servers are outside this control-plane cutover, so active execution and /goal loops continue while clients reconnect to durable state.",
  "ARCHITECTURE$CONTROL_WORKER_REVISIONS_TITLE": "Revision-drained control workers",
  "ARCHITECTURE$CORE_CONTEXT_DESCRIPTION": "The static prompt defines identity, behavior, and security policy. Before a sandbox exists, the control agent can search indexed code across every connected repository, read exact GitHub blobs, and publish bounded text changes to its own draft PR with optimistic SHA checks; credentials stay server-side. Requests requiring commands, generated files, runtime feedback, or unsupported providers activate the sandbox execution agent with one to six explicitly selected relevant repositories, never every connected repository by default. Pull and fetch requests use the same repository routing. Source: openhands/app_server/app_conversation/live_status_app_conversation_service.py and openhands/app_server/repository_publication/service.py.",
  "ARCHITECTURE$CORE_CONTEXT_TITLE": "AgentContext and prompt",
  "ARCHITECTURE$CORE_EVENTS_DESCRIPTION": "System prompts, messages, actions, observations, errors, state updates, and condensations are durable events. Agent Server stores the primary append-only trajectory and streams it over a per-conversation WebSocket; token deltas remain transient. Authenticated webhooks also mirror completed events into the App Server database for product history, callbacks, and recovery after the sandbox lifecycle changes.",
  "ARCHITECTURE$CORE_EVENTS_TITLE": "Events, streaming, and recovery",
  "ARCHITECTURE$CORE_LLM_DESCRIPTION": "The SDK LLM abstraction normalizes model configuration, Chat Completions or Responses APIs, native and emulated tool calling, retries, streaming, vision input, prompt caching, capability detection, token usage, cost metrics, and provider errors. The product supplies the selected model, endpoint, credential source, reasoning effort, and usage identifier without coupling the agent loop to one vendor.",
  "ARCHITECTURE$CORE_LLM_TITLE": "Provider-neutral LLM layer",
  "ARCHITECTURE$CORE_STATE_DESCRIPTION": "ConversationState keeps the append-only event log, execution status, active branch, policies, metrics, activated skills, and persistent agent state. The model does not receive that entire record. A View projects only the active branch into valid LLM messages and preserves action/observation pairing. When context grows, a condenser summarizes a safe event range while the original events remain stored.",
  "ARCHITECTURE$CORE_STATE_TITLE": "Conversation state and memory",
  "ARCHITECTURE$CORE_TOOLS_DESCRIPTION": "Terminal, file editor, browser, planning, Git, task, and MCP capabilities are exposed as typed action schemas. A model tool call must pass schema validation, lifecycle hooks, security analysis, and confirmation policy before its executor runs. The bounded result becomes a typed ObservationEvent correlated with the original action, so the model never executes arbitrary product code directly.",
  "ARCHITECTURE$CORE_TOOLS_TITLE": "Actions, policy, and tools",
  "ARCHITECTURE$CURRENT_STACK_NOTE": "This page describes the current V1 product path: React → App Server → sandbox-hosted Agent Server → Software Agent SDK → model provider.",
  "ARCHITECTURE$CUSTOM_LAYERS_BODY": "The custom layers adapt two OpenHands paths without keyword or regular-expression routing. Before a sandbox exists, the App Server always uses the configured code-agent model with repository, database, and integration tools under one source-neutral evidence contract. A turn the router recorded as asking for a repository change keeps the request: activation provisions the workspace and creates the sandbox conversation but hands it no task, so no second agent runs there and the same turn edits, runs commands, and delivers under the delivery policy and the publication gate. Routed execution, which has no control turn behind it, still starts a sandbox agent and receives the durable context.",
  "ARCHITECTURE$CUSTOM_LAYERS_TITLE": "How the Chartmetric layers wrap OpenHands",
  "ARCHITECTURE$DELEGATED_INVESTIGATION_DESCRIPTION": "The control agent can run up to three tools concurrently and delegate one read-only investigation to a separate SDK conversation. The sub-agent receives no write, execution-activation, or delegation tool and returns one report to the parent's evidence path.",
  "ARCHITECTURE$DELEGATED_INVESTIGATION_TITLE": "Bounded delegation",
  "ARCHITECTURE$DELIVERY_AFFECTED_E2E_DESCRIPTION": "PR paths map to Mock-LLM feature directories plus regressions; cross-cutting or unmapped source changes fail closed to the full suite. Lightweight detector jobs complete required checks when heavy E2E is irrelevant. Chartmetric Docker E2E builds the selected source on main or manual runs because the AWS role trusts main only.",
  "ARCHITECTURE$DELIVERY_AFFECTED_E2E_TITLE": "Affected E2E selection",
  "ARCHITECTURE$DELIVERY_BODY": "Delivery is trunk-based and commit-addressed. Pull requests prove source contracts and affected full-stack behavior. Merged main commits produce immutable images. Production deployment accepts only merged main ancestry, authenticates to AWS without stored cloud keys, and keeps one non-cancelling production cutover at a time.",
  "ARCHITECTURE$DELIVERY_DEPLOY_DESCRIPTION": "GitHub Actions obtains AWS credentials through AWS OIDC, logs into private ECR, pushes the immutable image, rechecks that main still contains the built SHA, and deploys through repository-owned scripts. Production concurrency is one and cancel-in-progress is disabled so a cutover cannot be abandoned halfway.",
  "ARCHITECTURE$DELIVERY_DEPLOY_TITLE": "Production cutover",
  "ARCHITECTURE$DELIVERY_DISCIPLINE_BODY": "Migration and release discipline: additive Alembic migrations must merge to main before any deployment can run them; production deploys from a full main SHA; DB_SCHEMA remains public; configuration staging is treated as production configuration; and SDK repository, commit, Python dependencies, launcher reinstall path, Docker inputs, and image tag stay synchronized.",
  "ARCHITECTURE$DELIVERY_MAIN_ARTIFACT_DESCRIPTION": "After backend CI succeeds on main, deployment resolves a current main descendant, reruns frontend build, translation completeness and SDK pin contracts, verifies the private Agent Server image has amd64 and arm64 manifests, then builds the Pilot image tagged by the full commit SHA.",
  "ARCHITECTURE$DELIVERY_MAIN_ARTIFACT_TITLE": "Pinned main artifact",
  "ARCHITECTURE$DELIVERY_PR_GATES_DESCRIPTION": "Frontend CI runs lint, unit tests, app build, library build and package inspection on Linux, plus build coverage on Windows. Backend CI runs lint and tests and requires a single Alembic head.",
  "ARCHITECTURE$DELIVERY_PR_GATES_TITLE": "PR source gates",
  "ARCHITECTURE$DELIVERY_TITLE": "4. CI/CD and upstream maintenance",
  "ARCHITECTURE$DELIVERY_UPSTREAM_DESCRIPTION": "Future synchronization remains merge-based: fetch and merge upstream/main for Agent Canvas, then fetch and merge sandbox-server/main for backend ancestry. Conflicts preserve Pilot-owned evidence, control-plane and deployment invariants while inherited UI follows Agent Canvas. The histories must not be squashed, rebased away, or replaced with synthetic ours merges.",
  "ARCHITECTURE$DELIVERY_UPSTREAM_TITLE": "Merge-based upstream sync",
  "ARCHITECTURE$DEPLOYMENT_CONTROL_PLANE": "Control plane: Caddy and App Server run on one t3.medium EC2 host by default. The host serves UI and APIs, runs background workers, and orchestrates sandboxes; the template has no load balancer, Auto Scaling group, or multi-AZ application replica.",
  "ARCHITECTURE$DEPLOYMENT_LAYOUT_TITLE": "Where components run",
  "ARCHITECTURE$DEPLOYMENT_PROXY": "Preview path: authenticated HTTP/WebSocket routes reach the worker's fixed Agent Server, DESKTOP, VS Code, WORKER_1, and WORKER_2 ports. With OH_PREVIEW_DOMAIN configured, DNS-compatible EC2 sandboxes expose WORKER_1 and WORKER_2 at sandbox-specific wildcard origins whose hostnames carry a truncated HMAC-SHA256 capability derived from the private session key; the App panel is framed at the conversation's stable capability address rather than at that sandbox-scoped one. PreviewSubdomainMiddleware verifies the capability before forwarding HTTP or WebSocket traffic at the origin root, validates WebSocket and credentialed CORS origins against the same sandbox capability, strips Pilot credentials including X-Org-Id and unsafe frame headers, and removes upstream cookie domains so cookies remain host-only. The previewed app's own Authorization header is forwarded on these origins together with its raw cookies, because the hostname capability is the only credential this path reads; the capability-path fallback still strips Authorization. The cross-origin App iframe remains sandboxed and referrer-free but receives allow-same-origin, so root-relative assets, redirects, application authentication, and HMR work without static rewriting or access to Pilot storage. Remote orchestrators and IDs that cannot fit a valid DNS label retain the session-derived SHA-256 capability path; that opaque-origin fallback namespaces cookies and injects bounded storage, Fetch, XMLHttpRequest, and History bridges. Proxy metadata lookups use short isolated database sessions and a short scope-aware cache, while lifecycle changes invalidate the cache. Older Agent Server images without app discovery are checked through private worker targets with a two-second deadline per target. Workers have public IPs, but Security Group ingress restricts their service ports to the control plane.",
  "ARCHITECTURE$DEPLOYMENT_STORAGE": "Storage: external PostgreSQL stores production metadata, tasks, indexed chunks, events, and artifact digests. EC2 workers bind sandbox-specific encrypted EFS directories into /workspace plus organization-scoped Git-mirror and prepared-artifact directories. Ordinary working trees persist on EFS; new warm-preferred Preview working copies live under worker-local /tmp and are rebuilt after worker replacement.",
  "ARCHITECTURE$DEPLOYMENT_WORKER": "Execution workers: two m7i.2xlarge hosts form the always-on EC2 pool. Each host offers eight placement slots and runs multiple bridge-networked Agent Server containers with cgroup limits, disjoint published port blocks, persistent EFS workspaces, worker-local ephemeral Preview storage, terminal/browser tools, Chromium, VS Code, and two fixed preview routes. Small sandboxes consume one slot and medium sandboxes consume two; demand beyond host capacity uses a dedicated per-VM cold start, while the control plane enforces the global active-sandbox limit. Reconciliation reschedules containers whose host is missing, restarts an unresponsive container on a running host while cooling that host for new placements, retires detached containers, and drains obsolete organization-warm VMs.",
  "ARCHITECTURE$DOCKER_ISOLATION": "Container and managed bridge network",
  "ARCHITECTURE$DOCKER_PERSISTENCE": "Container writable layer or configured volume",
  "ARCHITECTURE$DOCUMENT_DESCRIPTION": "Engineering reference for how Chartmetric Pilot was assembled from OpenHands, evolved through product-owned vertical slices, verified, delivered, and operated today.",
  "ARCHITECTURE$DURABLE_EVENTS_RUNTIME_DESCRIPTION": "Agent Server owns the live execution trajectory; authenticated callbacks upsert it into App Server SQL. Control events are written directly to SQL. SQL-backed REST and WebSocket history plus a separate summary outbox provide product recovery and reconnect reconciliation. History recognizes MCP tools by their stable suffix whether or not the event carries a configured server prefix, so durable pull-request publications survive reload; if a turn fails after publishing, those links remain visible beside its terminal error instead of requiring an agent finish message. When a routed sandbox agent disappears before answering, control recovery detaches that agent and continues the original request from durable history; an already-running control turn is left alone. One multiplexed WebSocket per browser tab carries every live stream as a named channel — conversation summaries, a conversation’s events, preview-app discovery, and the sandbox sockets the App Server relays — and it is accepted before it is authenticated, so a slow database delays a channel instead of failing the handshake. A transport drop remains a reconnecting state while the shared socket retries and resumes each channel from its latest cursor; it is not reported as a closed conversation. When live Agent Server status is unavailable, conversation reads fall back to the latest SQL execution status. The frontend retains each streamed execution-status event's original timestamp, so replayed RUNNING history cannot restart its freshness window after refresh.",
  "ARCHITECTURE$DURABLE_EVENTS_RUNTIME_TITLE": "Dual durable event path",
  "ARCHITECTURE$EC2_ISOLATION": "Worker VM and Security Group; Agent Server uses host networking",
  "ARCHITECTURE$EC2_PERSISTENCE": "Sandbox directory on one shared encrypted EFS filesystem",
  "ARCHITECTURE$EVENT_MODEL_BODY_ONE": "The Agent Server keeps the primary append-only conversation log. Messages, actions, observations, state changes, errors, and condensations are durable semantic events. The App Server persists those events in SQL and sets conversation activity to the latest user message or agent FinishAction, capping future event times at the control-plane clock. Unread metadata advances only for FinishAction; intermediate agent messages and ThinkAction events do not move either timestamp. Streaming token deltas are transient and are not written to history. Before Event model validation, SQL persistence copies the stored payload dict so validation cannot mutate the ORM-backed JSON value. Source: openhands/app_server/event/sql_event_service.py.",
  "ARCHITECTURE$EVENT_MODEL_BODY_TWO": "The App Server returns sandbox connection metadata without waiting for an Agent Server status round trip. SQL history revalidates the newest 100-event page whenever a conversation opens. A cached recent page can render immediately, a fresh recent page reveals the chat without waiting for older pages, and the remaining history loads in the background. Each open conversation has an Agent Server event WebSocket for detailed events and inclusive replay; separately, the App Server exposes an authenticated user/organization-scoped summary WebSocket for conversation-list updates. SQL and REST remain authoritative, so reconnect reconciliation refetches them; event IDs remove replay overlap, while full replay remains the empty-history or error fallback. The frontend stores canonical raw events sorted by timestamp and reprojects UI events after out-of-order history insertion. Source: src/stores/use-event-store.ts. Control-plane turns replace the generated placeholder title after a successful response and retry while that placeholder remains, regardless of existing event history.",
  "ARCHITECTURE$EVENT_MODEL_TITLE": "Event persistence and live updates",
  "ARCHITECTURE$EVIDENCE_POLICY_DESCRIPTION": "Interactive control turns wrap the SDK worker in the obligation loop. What counts is what the server recorded: a fact is a quote that appears verbatim in a tool result, a test is a command that exited zero, a screenshot is an attributed capture, a delivery is a published pull request. Nothing reads the answer's prose to decide whether to keep going. Code changes use executable delivery_plan checks and require a recorded PR; releasing a research item cannot complete the change. The final answer includes the recorded PR URL. A serving preview requires a successful post-change screenshot publication or recorded API response; declared or released checks do not count. Before control publication, the shared verifier compares recorded response values with the requested outcome and PR claim. A wrong result or unavailable required verdict returns a correction to the agent. Only accepted verification is recorded, and new API evidence invalidates the cache. Screenshot receipts include frame_verified and the vision model's observed fields and values. Only an explicit visual pass counts; uploaded images with missing, unavailable, or malformed vision verdicts remain unverified. Control-owned captures must use their own Preview, and the capture tool returns the artifact URL for delivery. Control-browser observations retain original screenshot bytes and record capture provenance in the same transaction as the event; later frameless clicks invalidate that capture. Execution owners receive publish_response_evidence even without a browser, using the shared sandbox runtime recorder. Replacing a SQL status filter with another field's condition also requires counter-case checks. API-only checklists can complete with a verified actual response and an open published PR. Declared screenshots cannot be removed, replaced by an API check, or completed by a release reason; they require a verified capture linked in the PR. A bounded condition/test patch lets the verifier check behavioral counter-cases and preservation of previously accepted cases. Successful artifact receipts carry verified_statement when the exact image passed the existing visual judge against that declared statement. That bound verdict can prove an absence claim without requiring the absent words on screen; otherwise the observed-page-text fallback applies. Publication tools report outstanding checks immediately. Publication readiness and finish use a shared evidence assessment, including recorded `/` responses. A Draft or explicitly unverified PR preserves delivery but does not bypass remaining obligation and verification checks. Published API responses appear with the assistant answer as response code blocks alongside screenshots, not as expanded tool cards. Native SDK post-action page state includes the original screenshot except while typing a registered secret; form-batch screenshot restrictions remain unchanged. If an ending has no draft, the same agent gets a final writing pass from its recorded progress. If writing also fails, a factual receipt reports recorded delivery links and API statuses with incomplete verification, never a generic uncertainty answer. Exhaustion remains exhaustion. Optional data checks use a server-returned query key bound to the database, SQL and parameters. A complete successful execute_read_query result can discharge a later data declaration and answer a widened-condition check without a shell SQL client; it does not substitute for a test, API response or screenshot. Source-file reads do not count. Combined Perl in-place flags such as -0pi are recognized as source writes by the shared edit detector. PR verification warnings stay concise; detailed corrective instructions remain in the agent tool result. Execution owners use their ready checkout for focused, batched reads and implement the change themselves; they are not told to hand it to another agent. Read-only turns keep their original instruction, and the shared database, browser and safety policy is unchanged. Execution owners resolve the coding role for both model and reasoning effort; read-only exploration and automated review roles are unchanged.",
  "ARCHITECTURE$EVIDENCE_POLICY_TITLE": "Evidence policy",
  "ARCHITECTURE$EVOLUTION_BODY": "The previous Pilot implementation was treated as a feature donor. Its capabilities were ported as independently testable vertical slices rather than replaying the old commit sequence. Each slice joined backend behavior, Canvas adapters and UI, migrations where needed, regression tests, and architecture documentation before the next boundary was widened.",
  "ARCHITECTURE$EVOLUTION_CONVERSATIONS_DESCRIPTION": "Made App Server SQL authoritative for control conversations, start tasks, summaries, recovery, pending delivery and Git snapshots while retaining Agent Server's execution trajectory.",
  "ARCHITECTURE$EVOLUTION_CONVERSATIONS_TITLE": "Conversation authority",
  "ARCHITECTURE$EVOLUTION_EVIDENCE_DESCRIPTION": "Ported the protected LSM/evidence loop, structured Ask versus Execution routing, tree-sitter indexing, source tracing, bounded control tools, delegated read-only investigation, and role-specific model policy.",
  "ARCHITECTURE$EVOLUTION_EVIDENCE_TITLE": "Agent and evidence layer",
  "ARCHITECTURE$EVOLUTION_EXPERIENCE_DESCRIPTION": "Integrated App preview, the agent browser screencast and takeover controls, durable progress and errors, Changes and Commits after teardown, visual artifact publication, PR contracts, usage, and cost accounting.",
  "ARCHITECTURE$EVOLUTION_EXPERIENCE_TITLE": "Execution experience",
  "ARCHITECTURE$EVOLUTION_INTEGRATIONS_DESCRIPTION": "Added scoped repository indexing and selection, GitHub App and pull-request automation, Slack threads, data tools, native integrations, MCP, Organization Skills, Plugins, and lazy credential lookup.",
  "ARCHITECTURE$EVOLUTION_INTEGRATIONS_TITLE": "Repositories and integrations",
  "ARCHITECTURE$EVOLUTION_PERSISTENCE_DESCRIPTION": "Established Google authentication, signed sessions, Organization membership and permissions, cm_pilot_* SQL state, settings, secrets, repositories, and additive Alembic migrations.",
  "ARCHITECTURE$EVOLUTION_PERSISTENCE_TITLE": "Identity and persistence",
  "ARCHITECTURE$EVOLUTION_PRINCIPLE_BODY": "The recurring commit themes are product authority, correctness, isolation, evidence, and operability: move state to Organization-scoped SQL, keep private execution behind one proxy, preserve verified source coverage, make recovery durable, and pin every runtime artifact to what was tested.",
  "ARCHITECTURE$EVOLUTION_SANDBOX_DESCRIPTION": "Ported EC2 orchestration, private service proxying, resource profiles, prewarm claims, local prepared artifacts, lifecycle reconciliation, deployment scope, bounded drain, and private ECR distribution.",
  "ARCHITECTURE$EVOLUTION_SANDBOX_TITLE": "Sandbox and deployment",
  "ARCHITECTURE$EVOLUTION_TITLE": "2. Engineering evolution",
  "ARCHITECTURE$EXECUTION_AGENT_RUNTIME_DESCRIPTION": "Runs inside the private Agent Server with the selected repositories, terminal, browser, Git, MCP, hooks, skills, plugins, runtime guidance, and lazy secrets. Browser state includes a semantic outline of rendered headings and landmarks, and browser_find locates visible rendered text anywhere in the current document without changing its scroll position; deferred content must be mounted before absence is concluded. There is no file editor tool: the shell is the whole execution plane, so an edit shares a command string with the lint and type-check that prove it instead of costing a separate round trip. Publication and validation policies are appended by the App Server. Chartmetric PR guidance leaves Attribution to the server, which adds Main author only as a verified GitHub mention. A repository the change turns out to need is attached mid-run through attach_repository, which clones it through the organization git mirror, pins the commit its work is measured from, and installs the credential helper a hand-rolled clone leaves out. The workspace root then widens to the directory holding every checkout, so both repositories stay reachable; the scope can widen while the sandbox runs but never narrow, because a checkout still on disk would fall outside the root. Optimization policy attributes the critical path across browser work, chunks and assets, transport and CDN behavior, first-party API and datastore work, and third-party services; it preserves cold and warm measurements separately, uses identical scoped cache resets or warm-up sequences against the real waterfall dependencies rather than health endpoints, restarts the selected multi-repository runtime after changes, and publishes cache-equivalent numeric before-and-after evidence with same-condition browser video. A routed sandbox agent receives the background launch verdict as internal feedback with run=false, including its own browser and restart tools; a control-owned workspace receives no sandbox-agent message.",
  "ARCHITECTURE$EXECUTION_AGENT_RUNTIME_TITLE": "Sandbox execution agent",
  "ARCHITECTURE$EXECUTION_ROUTE_DESCRIPTION": "Code-changing work bypasses the LSM and starts the coding agent in a sandbox with the unchanged user request and repository scope. There is no control-plane publication fallback; when sandbox capacity is unavailable, the user can retry later.",
  "ARCHITECTURE$EXECUTION_ROUTE_TITLE": "Execution: clean sandbox",
  "ARCHITECTURE$EYEBROW": "Inside the system",
  "ARCHITECTURE$FEATURES_TITLE": "2. Key features",
  "ARCHITECTURE$FOUNDATION_BODY": "Pilot's permanent integration baseline was created on July 30, 2026. Its first parent is OpenHands Agent Canvas commit 7fbc01824a48105ae4b7b17605f00ef3b8e73043; its second parent is OpenHands Sandbox Server commit a2f54eeff3155418ba37a056b1a274e7177230cd. Merge anchor 20d2a57e518c6d5aa61d282d427d666efec2099a preserves both real histories. This was not a squash or a replay of the previous Pilot branch: Agent Canvas became the UI base, Sandbox Server supplied the standalone backend lineage, and selected Pilot capabilities were ported onto that composition.",
  "ARCHITECTURE$FOUNDATION_BOUNDARY_BODY": "Ownership boundary: upstream Agent Canvas remains the source of truth for inherited UI and design-system behavior. Pilot owns authentication, Organization-scoped SQL persistence, request routing, integrations, repository intelligence, sandbox orchestration, evidence policy, validation, artifacts, and production deployment. Separately licensed OpenHands Enterprise source is not part of this repository.",
  "ARCHITECTURE$FOUNDATION_TITLE": "1. Foundation and permanent lineage",
  "ARCHITECTURE$GITHUB_ARTIFACT_FLOW_DESCRIPTION": "The Agent calls one authenticated visual-publication MCP. The control plane retrieves and validates the media, stores the Pilot timeline artifact in S3, and then attempts native GitHub publication with the optional encrypted organization browser session. If that session is absent, expired, or rejected, the repository-scoped record uses the signed Pilot URL. Sources: openhands/server/routes/mcp.py, openhands/app_server/visual_artifact/service.py, openhands/app_server/git/github_attachment_uploader.py, and openhands/app_server/git/github_visual_artifact_service.py.",
  "ARCHITECTURE$GITHUB_ARTIFACT_FLOW_TITLE": "GitHub media publication boundary",
  "ARCHITECTURE$GITHUB_ATTACHMENT_DESCRIPTION": "The control plane fetches the repository upload token, requests GitHub's multipart upload policy, sends the validated bytes to the returned S3 target, and finalizes the asset. Hosts, paths, response sizes, media, and final user-attachments URL are validated; any failure selects the existing Pilot evidence link.",
  "ARCHITECTURE$GITHUB_ATTACHMENT_TITLE": "Bounded native upload",
  "ARCHITECTURE$GITHUB_AUTOMATION_DESCRIPTION": "Signed webhooks enqueue automatic pull-request reviews for enabled indexed repositories when a non-draft pull request opens, becomes ready, or receives a new head. Each delivery binds its repository, pull request, and head commit to a sandbox-free control conversation that treats PR content as untrusted input and cannot modify code. The review method and the shape of the review body are server-owned prompt text rather than a skill, because a control conversation loads skills only from the organization's own table. The review contract requires direct observations for claimed compiler, linter, test, build, and runtime outcomes. Risk classification may select the Organization's optional high_risk_review_model for the review. An independent bounded verifier, which the Organization may disable or point at its own model, checks the proposed verdict and findings before the review is posted. A review concludes as APPROVE, COMMENT, or REQUEST_CHANGES, and the verifier accepts REQUEST_CHANGES only when a supported finding would have to be fixed before merge; the verdict is advisory guidance for the author. A Pilot-authored pull request is reviewed like any other, and the review is posted by the separate review-only GitHub App when one is deployed, so APPROVE and REQUEST_CHANGES are reachable; without that identity GitHub refuses both from the pull request’s own author and the review is posted as COMMENT. The reader renders source patches ahead of generated, vendored, and lock-file patches under one shared budget, so a noisy pull request cannot starve the code under review, and it replays the reviewer's own earlier reviews on that pull request so a re-review reports what changed instead of restating itself. The same review is reachable without a webhook: review_pull_request in an ordinary control conversation reads the pull request, hands the agent that identical method, posting contract, and repository review guide, and binds the repository, pull request, and head commit so the posting tool accepts a review no delivery created. It runs on the conversation's own model rather than the high-risk one. An execution agent reaches the identical pair over MCP, which additionally refuses the pull request that conversation itself published, because approving your own change is not a review. The verifier judges against three sources: the changed-file patches, evidence entries whose quotes the server reads out of the named file at the reviewed commit and matches verbatim before verification, and the provider’s own check-run outcomes for that commit. It received only the patches until a live review rejected a correct finding twice because the pin it rested on sat in a file the pull request never touched. A patch is a window on its file rather than the file, so absence from a patch is not evidence of absence from the file: the verifier may not assert what unchanged code contains and may not turn such an inference into a defect, and a claim about file contents is settled by an evidence quote rather than by the diff. A finding names the path that reaches the failure and the strongest case against itself; a blocking finding that names no path is returned as COMMENT rather than discarded, so verification lowers a verdict and never loses a finding. Both the control tool and the MCP tool compose one refusal text that names the individual findings that failed and the remedy.",
  "ARCHITECTURE$GITHUB_AUTOMATION_TITLE": "GitHub automation",
  "ARCHITECTURE$GITHUB_CREDENTIALS_DESCRIPTION": "Each organization stores its Root Git OAuth authorization and GitHub App installation for repository access. Commits created in a sandbox receive the Pilot bot identity in every checkout before and after repository setup; setup stops if that identity cannot be applied. Sandbox-free GitHub API commits explicitly set the same Pilot bot as both author and committer, so neither path inherits a human engineer's Git identity. Native attachments are optional because GitHub exposes no token-authenticated attachment API. A one-time downloaded helper can read only the matching GitHub session cookies from an existing local browser profile and pair them over HTTPS; the encrypted session never enters a sandbox. Sources: openhands/app_server/app_conversation/app_conversation_service_base.py, openhands/app_server/git/control_git_service.py, and openhands/app_server/integrations/github/service/git_data.py.",
  "ARCHITECTURE$GITHUB_CREDENTIALS_TITLE": "Organization GitHub authorization",
  "ARCHITECTURE$GITHUB_SKILL_LINK": "OpenHands code-review Skill",
  "ARCHITECTURE$GITHUB_SKILL_PREFIX": "The bundled",
  "ARCHITECTURE$GITHUB_SKILL_SUFFIX": " defines the same finding-verification rules for ordinary /codereview use. Automatic webhook reviews enforce those rules directly in the generated request and GitHub review tool contract because the sandbox-free control path does not load repository skill files.",
  "ARCHITECTURE$HARNESS_AGENT_DESCRIPTION": "Converts the active event branch into model messages and tool schemas, then interprets the response.",
  "ARCHITECTURE$HARNESS_AGENT_TITLE": "SDK agent step",
  "ARCHITECTURE$HARNESS_CONTEXT_DESCRIPTION": "System instructions, skills, conversation events, summaries, and selected tool observations.",
  "ARCHITECTURE$HARNESS_CONTEXT_TITLE": "Context view",
  "ARCHITECTURE$HARNESS_DESCRIPTION": "The model proposes the next step; the harness owns context, policy, tool execution, event history, retries, and the decision to continue or stop.",
  "ARCHITECTURE$HARNESS_EVENTS_DESCRIPTION": "Durable semantic events update context and the UI. Control turns stream attributed user requests and structured actions immediately while policy-gated answers wait for evaluation; planning copies and internal policy or model-correction messages remain internal instead of appearing as user turns. Durable execution status returns to idle even if the HTTP request is cancelled after an answer streams. When a turn resumes from stored history, the control plane repairs gaps such as dangling parent links and sandbox-only output paths, so a lost event never permanently blocks a conversation.",
  "ARCHITECTURE$HARNESS_EVENTS_TITLE": "Event log and stream",
  "ARCHITECTURE$HARNESS_EYEBROW": "01 · LLM harness",
  "ARCHITECTURE$HARNESS_FACT_CONTEXT_DESCRIPTION": "A condenser summarizes older atomic event ranges while preserving the complete durable history.",
  "ARCHITECTURE$HARNESS_FACT_CONTEXT_TITLE": "Context stays bounded",
  "ARCHITECTURE$HARNESS_FACT_EVENTS_DESCRIPTION": "Messages, actions, observations, state changes, and condensations are persisted and replayable.",
  "ARCHITECTURE$HARNESS_FACT_EVENTS_TITLE": "Events are the source of truth",
  "ARCHITECTURE$HARNESS_FACT_POLICY_DESCRIPTION": "Structured actions pass through schemas, confirmation policy, security analysis, and tool executors.",
  "ARCHITECTURE$HARNESS_FACT_POLICY_TITLE": "The model does not execute directly",
  "ARCHITECTURE$HARNESS_LLM_DESCRIPTION": "Handles model capabilities, retries, function calling, streaming, prompt caching, usage, and cost telemetry.",
  "ARCHITECTURE$HARNESS_LLM_TITLE": "Provider-neutral LLM",
  "ARCHITECTURE$HARNESS_LOOP_LABEL": "tool call → observation → next turn",
  "ARCHITECTURE$HARNESS_OBSERVATION_DESCRIPTION": "Bounded command output, file content, browser state, or an error is correlated to its action.",
  "ARCHITECTURE$HARNESS_OBSERVATION_TITLE": "Observation",
  "ARCHITECTURE$HARNESS_POLICY_DESCRIPTION": "One source-neutral evidence contract covers control and execution agents. For read-only current-state lookups, agents locate the effective-value resolver first and use its branches for bounded direct-source queries instead of broad metadata discovery. A successful bounded read-only control-tool observation is already direct runtime evidence and is not repeated in a sandbox; source-only behavior claims still require execution. Tool execution does not pause for per-action user confirmation; lifecycle hooks enforce completion and publication gates instead. The publication check is an evaluator, not a block: it never refuses a finish. It reports its verdict, and the server queues the remedy back into the conversation as a turn the agent acts on, bounded so a delivery it cannot fix is not asked for forever. Blocking was removed because refusing a Stop hands nobody a turn -- the run went IDLE instead. A verdict the run then acted on is not shown in the transcript: it is machine-facing text about internal enforcement on a run that succeeded. A verdict that really ends the run is shown, because it is then the only account of why nothing was delivered. Hook telemetry appears as compact tool activity, and older repeated Stop cycles are folded with their agent explanations into one expandable group. Observable web and API changes require test-account-backed E2E evidence; user-visible UI changes also require a published screenshot of the final changed state. A second evaluator judges whether the evidence a run gathered is about the change it made -- whether the control the change put on screen was operated, and whether the request that flow issues answered -- and queues its correction through the same bounded path under a budget of its own. It fails open: a judgement it cannot reach leaves a record and no correction.",
  "ARCHITECTURE$HARNESS_POLICY_TITLE": "Policy and hooks",
  "ARCHITECTURE$HARNESS_TEST_DETAIL_DESCRIPTION": "Execution agents run only the smallest tests directly related to the current changes. In every edited repository, before committing or pushing and again after later edits, they must lint changed TypeScript files and type-check those files with the repository configuration and ambient declarations. Whole-project lint, lint-staged, typecheck, compilation, build, and test-suite commands are prohibited even when requested by the user. This non-overridable execution-safety boundary prevents shared sandbox resource exhaustion and execution-environment termination. Commits and local merges use --no-verify while remote CI and branch protection remain authoritative. Test file names, paths, cases, boundaries, and assertions stay internal unless requested. Only after a requested repository change is complete and browser-verified does the final report include the control-plane Preview URLs; Slack uses the Preview as its primary completion action instead of the pull-request button. Internal sandbox addresses remain hidden.",
  "ARCHITECTURE$HARNESS_TEST_DETAIL_TITLE": "Focused local validation",
  "ARCHITECTURE$HARNESS_TITLE": "A stateful loop around a stateless model call",
  "ARCHITECTURE$HARNESS_TOOLS_DESCRIPTION": "Control agents can read exact GitHub blobs and, without a sandbox, commit bounded text changes to a non-default branch, publish or synchronize that pull request, and merge it; the evidence loop accepts a published or merged pull request as the requested change having happened, while a commit alone is not delivered work. Once a conversation has an execution environment, control agents can also run one shell command in it per call and read back stdout, stderr, and the exit code, so a behaviour claim is settled by what the workspace printed instead of being handed to a second agent; each call is a single blocking request rather than a polled one, and waits a bounded time for a sandbox that is still starting. Execution agents retain terminal, editor, Git, MCP, and browser automation for commands, generated files, local preview, and visual QA. Sandbox and control-layer browser form tools can fill multiple fields and optionally submit in one tool round trip, return one final DOM state, and omit screenshots unless requested; registered secrets resolve only at execution time and never enter model context. Sandbox MCP publication authenticates with the sandbox-scoped session and resolves the DB-proven conversation owner, team, and repository. Code and PR operations use a short-lived team GitHub App token. One visual-evidence tool stores the Pilot timeline artifact in S3 and then prefers a native GitHub attachment when an optional encrypted team browser session is usable; otherwise it returns the signed Pilot link. Neither credential enters the Agent sandbox. Source: software-agent-sdk/openhands-tools/openhands/tools/browser_use, openhands/app_server/app_conversation/control_tools.py, openhands/app_server/app_conversation/execution_worker.py, openhands/app_server/control_browser/worker.py, openhands/app_server/git/control_git_service.py, openhands/server/routes/mcp.py, and openhands/app_server/app_conversation/live_status_app_conversation_service.py.",
  "ARCHITECTURE$HARNESS_TOOLS_TITLE": "Workspace tools",
  "ARCHITECTURE$INDEX_CHECKOUT_DESCRIPTION": "The index worker shallow-fetches the exact default-branch commit into a temporary checkout.",
  "ARCHITECTURE$INDEX_CHECKOUT_TITLE": "Immutable checkout",
  "ARCHITECTURE$INDEX_CONNECT_DESCRIPTION": "The control plane stores the organization Root Git OAuth token encrypted at rest and records the organization GitHub App installation. Repository operations prefer short-lived installation tokens and use the Root Git credential when required.",
  "ARCHITECTURE$INDEX_CONNECT_TITLE": "GitHub connection",
  "ARCHITECTURE$INDEX_DESCRIPTION": "Team-scoped, symbol-aware full-text search for investigation before or during execution. Indexed blob metadata also keeps cited source files readable after a sandbox stops.",
  "ARCHITECTURE$INDEX_FILE_DESCRIPTION": "A chat file-and-line reference opens the live workspace copy when available, or the immutable indexed Git blob in the Code panel when no sandbox is connected.",
  "ARCHITECTURE$INDEX_FILE_TITLE": "Cited source file",
  "ARCHITECTURE$INDEX_LABEL": "Read-only path",
  "ARCHITECTURE$INDEX_PARSE_DESCRIPTION": "Tree-sitter extracts symbols and bounded chunks; changed blob SHAs are updated incrementally in SQL.",
  "ARCHITECTURE$INDEX_PARSE_TITLE": "Parse and publish",
  "ARCHITECTURE$INDEX_PIPELINE_BODY": "The indexing worker checks out the exact Git revision into a temporary directory. tree-sitter turns supported declarations into bounded chunks with path and line metadata; plain text and parser failures use line-based chunks. Blob SHAs make refreshes incremental. PostgreSQL full-text ranking covers symbol and content, while exact scoring and non-PostgreSQL fallback also consider path. This is lexical, structure-aware retrieval, not a vector index.",
  "ARCHITECTURE$INDEX_PIPELINE_TITLE": "Repository indexing pipeline",
  "ARCHITECTURE$INDEX_SEARCH_DESCRIPTION": "Unscoped searches diversify lexical code candidates across repositories before a scoped identifier search. PostgreSQL full-text search covers symbol and content; exact symbol and path matches boost a result. Path substring fallback applies only outside PostgreSQL. No vector embeddings are used.",
  "ARCHITECTURE$INDEX_SEARCH_TITLE": "Lexical retrieval",
  "ARCHITECTURE$INDEX_TITLE": "Central repository index",
  "ARCHITECTURE$INTEGRATIONS_BODY": "Pilot connects external systems through protocol-level adapters rather than one tool per service: a first-class Slack subsystem, native and cloud read-only control adapters, declarative HTTP APIs, MCP and Plugin connectors inside execution, and signed GitHub webhook workflows.",
  "ARCHITECTURE$INTEGRATIONS_TITLE": "9. Integrations",
  "ARCHITECTURE$INTERNAL_CASE_BODY": "For an account-access question, a Claude-based Devin run stopped at the latest web login and Stripe records. The DeepSeek-based internal agent continued through activity history and mobile/IAP-related sources, found a later iOS artist-page access, and separated 'latest login' from 'latest product activity.' This is the type of source-tracing failure the added layers are designed to prevent.",
  "ARCHITECTURE$INTERNAL_CASE_CAVEAT": "This is a representative internal case, not a statistically complete benchmark. The claim is about the benefit of broader evidence coverage, not universal superiority of one model.",
  "ARCHITECTURE$INTERNAL_CASE_TITLE": "Observed internal comparison",
  "ARCHITECTURE$INTRODUCTION": "A technical map of the LLM agent harness, isolated execution environments, and the two paths that deliver repository context to the model.",
  "ARCHITECTURE$ISOLATION_LABEL": "Isolation model",
  "ARCHITECTURE$LAYER_AGENT_DESCRIPTION": "Builds context, calls the LLM, validates tool actions, executes them, and records observations.",
  "ARCHITECTURE$LAYER_AGENT_TITLE": "Agent harness",
  "ARCHITECTURE$LAYER_CONTROL_DESCRIPTION": "Owns identity, settings, start tasks, repository access, sandbox orchestration, and durable metadata.",
  "ARCHITECTURE$LAYER_CONTROL_TITLE": "App Server control plane",
  "ARCHITECTURE$LAYER_EXPERIENCE_DESCRIPTION": "Chat, plans, approvals, terminal output, browser previews, and live progress.",
  "ARCHITECTURE$LAYER_EXPERIENCE_TITLE": "Product experience",
  "ARCHITECTURE$LAYER_MODEL_DESCRIPTION": "The configured reasoning model returns text or structured tool calls through a provider-neutral LLM layer.",
  "ARCHITECTURE$LAYER_MODEL_TITLE": "Model provider",
  "ARCHITECTURE$LAYER_SANDBOX_DESCRIPTION": "An isolated workspace with cloned code, services, terminal, browser, tools, and an Agent Server.",
  "ARCHITECTURE$LAYER_SANDBOX_TITLE": "Execution sandbox",
  "ARCHITECTURE$LIMIT_CONTROL_PLANE": "The default control plane is a single EC2/Docker Compose deployment. Host or Availability Zone failure interrupts the web/API tier until it is recovered.",
  "ARCHITECTURE$LIMIT_PERSISTENCE": "SQL events, canonical EFS artifacts, and ordinary EFS workspaces improve recovery but do not make active execution highly available. A new warm-preferred Preview working copy is intentionally ephemeral worker-local state and is rebuilt after container, image, or worker replacement. Running processes, in-memory LSM progress, and transient token streams are also not preserved.",
  "ARCHITECTURE$LIMIT_PREVIEW": "Preview is limited to two fixed worker routes and a sandboxed iframe. Frame headers, authentication assumptions, browser permissions, or process-liveness failures can prevent a running service from appearing in the App tab.",
  "ARCHITECTURE$LIMIT_WARM_SANDBOX": "A claimed prewarm slot becomes one conversation's sandbox and keeps its own container and process boundary, workspace, session key, and port block. The EC2 kernel and host capacity are still shared with other tenant containers; cgroup limits and the authenticated proxy reduce noisy-neighbor and network exposure, but workloads requiring host-level isolation must use a dedicated per-VM runtime.",
  "ARCHITECTURE$LLM_LOOP_FEATURE_BODY": "The core execution loop comes from the OpenHands Software Agent SDK. It converts conversation state into model context, accepts text or structured tool calls, applies confirmation and security policy, executes terminal, file, browser, Git, and MCP tools, and feeds the resulting observations into the next turn until the task completes.",
  "ARCHITECTURE$LLM_LOOP_FEATURE_TITLE": "OpenHands LLM loop",
  "ARCHITECTURE$LSM_ANSWER_DESCRIPTION": "The answer that ships is the agent's own text, signed once by the loop: an approved turn takes the draft of the round that discharged the ledger, and a turn that ends with something still owed takes the draft that states the most of what was proven rather than its last message. The answer to the first ask leads, in the words of the person who asked. The register refusals still run, with regular expressions: schema artifacts are sent back for restatement and a dropped value is asked for once, and an answer that says a thing twice or runs past what a question needs is sent back once to be said shorter, with its cited values and every link as the floor. State verified facts directly from tool observations; do not reframe them as earlier reported values or claims that still need confirmation. A code-delivery answer must include the recorded PR URL; a missing link gets one answer-only correction, with the recorded delivery receipt as fallback if no usable linked answer is produced.",
  "ARCHITECTURE$LSM_ANSWER_TITLE": "Answer",
  "ARCHITECTURE$LSM_DESCRIPTION": "Every interactive control turn runs one loop, chosen by the router's recorded answer. A turn asked to change a repository owns its execution and is judged by the delivery policy: activation does not end it, a publication counts only once a command ran, and a completion is held until the publication gate agrees the change reached the remote. Every other turn ends on activation, because a sandbox agent speaks next. The loop asks no model whether the answer is good enough. The turn owes a ledger -- the asks the router read out of the request, seeded first, plus what the run declares before it acts -- and the server discharges each item from evidence it recorded itself. The turn ends when nothing is owed and the answer is written, re-entering with the list of what is still owed; a round counts against the four-round bound only when it added nothing, and eight re-entries is the ceiling. Automatic GitHub pull-request reviews and Automations run no loop. Every round the loop decides -- the attempt, the directive, what ended it, what was owed, discharged and released, and whether the answer was suppressed -- is written to cm_pilot_loop_round and readable per conversation, so why a turn ended is a record rather than a reconstruction. The iteration cap is per round, and the agent is warned once per round before it hits it, so a round ends on an answer rather than on its last tool call. Code-change turns use a shorter delivery_plan instruction instead of a separate research ledger. A requested repository change cannot complete without a recorded publication, even if its delivery obligation was released.",
  "ARCHITECTURE$LSM_DISCOVER_DESCRIPTION": "The ledger is what the turn owes. The router's asks -- what the writer wants answered, the named case first, then cause and remedy when a malfunction is reported -- are seeded as fact obligations before the run acts. The run adds, with the obligations tool, only a fact those do not name or a thing the change must make true: a fact, a test, a response, a screenshot, a delivery. A declaration is additive; an item leaves the ledger only by discharge or by a release whose reason the reader is shown.",
  "ARCHITECTURE$LSM_DISCOVER_TITLE": "Owe",
  "ARCHITECTURE$LSM_INTEGRATION_BODY": "The loop does not create a second tool runtime and runs only after the request router selects Ask or records a change request. Control-agent reasoning is capped at medium and each SDK run is bounded to 16 iterations; a turn re-enters at most four times, each time with the list of what is still owed, so a run that cannot discharge something is told so a bounded number of times and then answers, naming the gap. Text-only requests for repetition, transformation, formatting, or an exact response token use the supplied request as complete evidence and need no tool investigation. A turn whose execution environment never ran a command is held open until a command runs, or deferred to the execution queue with its checks when the environment has stopped coming. Normal actions and observations persist as product events. The SDK goal driver remains outside this inner run, so goal audits, interruption, and resume continue to work across completed runs.",
  "ARCHITECTURE$LSM_PHASES_TITLE": "Loop steps",
  "ARCHITECTURE$LSM_RECONCILE_DESCRIPTION": "The server discharges each item from what it recorded: a fact by a quote that appears verbatim in a read tool's result together with the value the answer will state, a test by a command that exited zero, a response by a recorded route answer, a screenshot by a published capture attributed to the item, a delivery by a published or merged pull request. Cited is not stated: the cited value must reach the final text. A release is provisional until a read follows it, so one failed query is not grounds to drop a fact. Native captures also satisfy screenshot criteria by their exact verified statement, without sharing delivery-plan numbers. The existing image judge must accept the original capture.",
  "ARCHITECTURE$LSM_RECONCILE_TITLE": "Discharge",
  "ARCHITECTURE$LSM_RUNTIME_TITLE": "3. Obligation loop",
  "ARCHITECTURE$LSM_TITLE": "Obligation loop",
  "ARCHITECTURE$LST_DESCRIPTION": "The investigation policy traces a business claim across producer and consumer code, database schema and rows, mappings, history, and connected external services. It distinguishes direct values from effective or user-facing values and requires the exact source of a difference.",
  "ARCHITECTURE$LST_TITLE": "LST source-tracing policy",
  "ARCHITECTURE$MCP_INTEGRATIONS_DESCRIPTION": "Grafana, Airflow, and Sentry are configured as managed MCP or Plugin connectors for sandbox execution, alongside arbitrary custom servers. Their capabilities come from the installed connector; they are not native control-plane adapters.",
  "ARCHITECTURE$MCP_INTEGRATIONS_TITLE": "MCP and Plugin connectors",
  "ARCHITECTURE$NATIVE_INTEGRATIONS_DESCRIPTION": "Capability manifests and Organization secret bindings gate every operation, and the read-only and write control tools dispatch on the manifest's read_only flag. Notion and Stripe have hand-written native adapters; declarative http_api integrations describe method, path, and argument mappings as data. A provider-neutral cloud gateway contract separates location discovery and traceable invocation from provider adapters, so external infrastructure does not require one tool per service. A single AWS connection derives services, service-specific regions, allowed operations, and input schemas from AWS SDK service models. Every observation keeps provider, operation, location, redacted request parameters, and result together. Bounded reads use either an Organization secret access-key pair or temporary credentials obtained through STS AssumeRole. The gateway verifies identity through STS and rejects mutations and credential-returning reads before AWS IAM applies the final authorization boundary. Credentials remain in the App Server, and HTTP manifest base URLs must be public HTTPS.",
  "ARCHITECTURE$NATIVE_INTEGRATIONS_TITLE": "Native and cloud read APIs",
  "ARCHITECTURE$NAV_ADDITIONAL": "5. Additional features",
  "ARCHITECTURE$NAV_AGENT_DETAIL": "3. Agent system",
  "ARCHITECTURE$NAV_AGENT_LOOP": "Agent loop & intelligence",
  "ARCHITECTURE$NAV_AGENT_RUNTIME": "Agent runtime",
  "ARCHITECTURE$NAV_CONTEXT": "Context construction",
  "ARCHITECTURE$NAV_DELIVERY": "CI/CD and upstream",
  "ARCHITECTURE$NAV_EVENTS": "Event model",
  "ARCHITECTURE$NAV_EVOLUTION": "Engineering evolution",
  "ARCHITECTURE$NAV_FEATURES": "2. Key features",
  "ARCHITECTURE$NAV_FOUNDATION": "Foundation and lineage",
  "ARCHITECTURE$NAV_HARNESS": "LLM agent harness",
  "ARCHITECTURE$NAV_INTEGRATIONS": "Integrations",
  "ARCHITECTURE$NAV_LABEL": "Architecture document sections",
  "ARCHITECTURE$NAV_LLM_LOOP": "2.2 LLM loop",
  "ARCHITECTURE$NAV_LSM_RUNTIME": "LSM evidence loop",
  "ARCHITECTURE$NAV_OVERVIEW": "System overview",
  "ARCHITECTURE$NAV_PLUGINS_RUNTIME": "Plugin loading",
  "ARCHITECTURE$NAV_PRECISION_AGENT": "2.1 Precision agent",
  "ARCHITECTURE$NAV_PRODUCT": "1. Product overview",
  "ARCHITECTURE$NAV_REPOSITORY": "Repository context",
  "ARCHITECTURE$NAV_SANDBOX": "Execution environments",
  "ARCHITECTURE$NAV_SANDBOX_DETAIL": "4. Sandbox architecture",
  "ARCHITECTURE$NAV_SANDBOX_E2E": "2.3 Sandbox E2E",
  "ARCHITECTURE$NAV_SANDBOX_RUNTIME": "Sandbox runtime",
  "ARCHITECTURE$NAV_SECURITY": "Security boundaries",
  "ARCHITECTURE$NAV_SECURITY_RUNTIME": "Security",
  "ARCHITECTURE$NAV_SKILLS_RUNTIME": "Skill loading",
  "ARCHITECTURE$NAV_TITLE": "Technical architecture",
  "ARCHITECTURE$NAV_UTILITIES": "Utilities",
  "ARCHITECTURE$NAV_VERIFICATION": "Verification model",
  "ARCHITECTURE$OPENHANDS_ARCH_LINK": "OpenHands SDK architecture",
  "ARCHITECTURE$OPENHANDS_CORE_BODY": "AST indexing, source tracing, and LSM do not replace the OpenHands agent. The base system is already a complete stateful software-agent harness. The App Server configures an SDK Agent and sends it to the Agent Server beside the workspace. That agent builds model context from conversation state, calls the selected LLM with structured tool schemas, executes approved actions, records observations, and repeats until it finishes, pauses, or reaches a policy limit.",
  "ARCHITECTURE$OPENHANDS_CORE_TITLE": "The OpenHands core agent comes first",
  "ARCHITECTURE$OPENHANDS_HARNESS_DESCRIPTION": "The pinned SDK projects the active event branch into model messages, validates typed tool calls, executes tools through lifecycle and security hooks, records correlated observations, and repeats until finish, stop, error, interruption, or an iteration boundary.",
  "ARCHITECTURE$OPENHANDS_HARNESS_TITLE": "OpenHands harness",
  "ARCHITECTURE$OPENHANDS_PROJECT_NAME": "OpenHands",
  "ARCHITECTURE$OPENHANDS_REFERENCE_PREFIX": "Foundation and upstream project:",
  "ARCHITECTURE$OPERATING_CONTEXT_DESCRIPTION": "The LLM sees curated messages and observations; durable events connect the product UI, agent state, execution results, and replayable history.",
  "ARCHITECTURE$OPERATING_CONTEXT_TITLE": "Move context by events",
  "ARCHITECTURE$OPERATING_CONTROL_DESCRIPTION": "Identity, authorization, credentials, durable tasks, metadata, and repository policy stay in the App Server and database.",
  "ARCHITECTURE$OPERATING_CONTROL_TITLE": "Centralize control",
  "ARCHITECTURE$OPERATING_EXECUTION_DESCRIPTION": "Code, commands, browsers, development services, and agent tools run beside the workspace inside the selected sandbox boundary.",
  "ARCHITECTURE$OPERATING_EXECUTION_TITLE": "Isolate execution",
  "ARCHITECTURE$OPERATING_MODEL_TITLE": "The operating model in three principles",
  "ARCHITECTURE$OPERATIONAL_LIMITS_TITLE": "Operational boundaries and limitations",
  "ARCHITECTURE$OPTIMIZATION_CACHE": "A organization-scoped authenticated bare Git mirror cache is shared by warm and dedicated EC2 workers, avoiding full-history downloads for every sandbox while keeping working trees isolated; blob-SHA incremental indexing separately avoids reparsing unchanged files.",
  "ARCHITECTURE$OPTIMIZATION_LIFECYCLE": "Lifecycle workers normally reclaim idle nonpersistent sandboxes after two hours. Under EC2 start-queue capacity pressure, they may reclaim the oldest dedicated sandbox after 10 idle minutes. SQL event ingestion commits conversation activity with the event rows, so reconciliation cannot observe a terminal event while still treating its sandbox as stale. Agent Server recovery requires three failed health probes and persisted obsolete specs converge to the current image. A healthy host-placed container with no live occupancy or active attached conversation is reclaimed after 30 minutes; archived conversations do not keep detached containers alive, while ready repository-prewarm slots remain exempt. Deleting an EC2 sandbox also removes its prewarm metadata.",
  "ARCHITECTURE$OPTIMIZATION_SPOT": "EC2 workers use persistent Spot capacity and stop-on-interruption behavior to reduce execution cost while allowing reconciliation and resume. Resume tolerates the Spot request's disabled-to-startable transition for up to five minutes before reporting failure.",
  "ARCHITECTURE$OPTIMIZATION_WARM": "Sandboxes run as containers on a shared multi-tenant EC2 host pool. The warmer keeps one ready slot for the default runtime and one for each named variant, but only for a repository whose runtime graph comes up — one whose own profile or a dependency declares a preview; a repository that serves no browsable application gets no slot, so it holds no host placement capacity. Each slot already has its complete dependency checkout, and runs setup and dev servers for that preview (prewarmed_sandbox_warmer.py). A claim is accepted only when deployment scope, backend, sandbox spec, runtime manifest, variant, health, authentication, and sandbox resource profile satisfy the request. The consumer refreshes every marked Git checkout in place and the runtime launcher's pid-file guard adopts the running services instead of restarting them. This removes clone and service-start work from the warm path, but the approximately 20-second target remains a deployment measurement rather than a guaranteed bound. The warmer replaces claimed slots and retires stale or invalid slots; active ready slots are exempt from detached-container reclamation.",
  "ARCHITECTURE$OVERVIEW_BODY_ONE": "The product separates control from execution. The App Server authenticates users, applies organization policy, resolves credentials, persists conversation metadata, and coordinates work. Code execution happens in a sandbox that hosts the workspace and Agent Server.",
  "ARCHITECTURE$OVERVIEW_BODY_TWO": "The Agent Server runs the Software Agent SDK conversation loop beside the checked-out repositories. It converts model responses into structured actions, executes approved tools, and emits observations and state changes as events that can be streamed and replayed.",
  "ARCHITECTURE$OVERVIEW_TITLE": "System overview",
  "ARCHITECTURE$PAGE_TITLE": "Technical Architecture",
  "ARCHITECTURE$PERSISTENCE_LABEL": "Workspace persistence",
  "ARCHITECTURE$PILOT_CONTROL_PLANE_DESCRIPTION": "The Pilot-owned FastAPI App Server is the product authority for identity, Organization data, durable conversations, routing, repositories, integrations, secrets, usage, sandbox lifecycle, evidence, and publication.",
  "ARCHITECTURE$PILOT_CONTROL_PLANE_TITLE": "Pilot-owned control plane",
  "ARCHITECTURE$PLUGINS_RUNTIME_BODY": "A Plugin is a runtime bundle rather than a single prompt. Its manifest may contribute skills, command-derived skills, MCP servers, lifecycle hooks, and file-based subagents. Pilot composes marketplace registrations, resolves Git coordinates, indexes metadata, and supplies explicit or auto-loaded Plugin sources while the SDK performs lazy runtime materialization before agent initialization.",
  "ARCHITECTURE$PLUGINS_RUNTIME_TITLE": "5. Plugin loading and optimization",
  "ARCHITECTURE$PLUGIN_COMPOSITION_DESCRIPTION": "Instance defaults and personal registrations compose by name. Personal entries cannot shadow inherited names; only auto_load registrations enter conversation-start loading. ENABLE_MARKETPLACE_PLUGIN_LOADING is the operator kill switch.",
  "ARCHITECTURE$PLUGIN_COMPOSITION_TITLE": "Marketplace composition",
  "ARCHITECTURE$PLUGIN_INDEX_DESCRIPTION": "cm_pilot_marketplace_catalog stores credential-scoped global, Organization, or user payloads and head SHAs. Reads use a 15-minute freshness window and stale-while-revalidate; Redis locks deduplicate refreshes, failed refreshes preserve the last usable payload, and a worker sweeps shared rows.",
  "ARCHITECTURE$PLUGIN_INDEX_TITLE": "Persisted catalog index",
  "ARCHITECTURE$PLUGIN_LIMITATIONS_BODY": "Current boundaries: marketplace registration is personal persistence; Organization marketplace composition is modeled but the active store returns none. Cloud registration does not install one Plugin into Organization storage. Explicit remote Plugins are pinned to a commit after resolution, while ambient filesystem Plugins can drift across resume. Plugin parameters are appended to the user message and are not a secret transport. Source validation and trust confirmation exist, but no signature, publisher registry, malware scan, or hook/MCP policy scanner is enforced.",
  "ARCHITECTURE$PLUGIN_OPTIMIZATION_DESCRIPTION": "The frontend cache uses the same 15-minute freshness window as the server, prefetches the catalog at app-shell startup, and renders installed or local rows without waiting for catalog completion. Server reads avoid cloning while the SQL index is fresh, revalidate remote heads in the background, bound clone concurrency and timeouts, and degrade to ordinary loading when optional caches miss. The S3 clone archive is best effort and is not currently proven to materialize automatically into execution sandboxes.",
  "ARCHITECTURE$PLUGIN_OPTIMIZATION_TITLE": "Read-path optimization",
  "ARCHITECTURE$PLUGIN_RESOLUTION_DESCRIPTION": "Provider-matched credentials are used only for bounded no-shell clone, fetch, checkout, or ls-remote operations. Persisted previews reject credential-bearing URLs. Explicit Plugin refs resolve to immutable commit coordinates for resume; ambient user, installed, and project Plugins remain current filesystem state.",
  "ARCHITECTURE$PLUGIN_RESOLUTION_TITLE": "Git and version resolution",
  "ARCHITECTURE$PLUGIN_RUNTIME_ASSEMBLY_DESCRIPTION": "Before agent initialization the SDK loads the manifest, merges Plugin skills and command skills, resolves MCP secret references through the conversation secret registry, concatenates hooks, and registers file-based subagents. Later Plugin contributions override earlier same-name skills or MCP servers.",
  "ARCHITECTURE$PLUGIN_RUNTIME_ASSEMBLY_TITLE": "Lazy runtime assembly",
  "ARCHITECTURE$PRECISION_AGENT_BODY": "AST-aware parsing, LST source tracing, centralized repository indexing, and an LSM evaluation loop are layered above the base OpenHands agent. These layers reduce premature answers and make the agent inspect the code, data source, mapping, history, and user-facing result before accepting a conclusion. This allows lower-cost models such as DeepSeek to remain useful for integrated internal investigations where source coverage matters more than model size alone.",
  "ARCHITECTURE$PRECISION_AGENT_TITLE": "Precision-oriented agent system",
  "ARCHITECTURE$PROCESS_ISOLATION": "No security isolation; development only",
  "ARCHITECTURE$PROCESS_PERSISTENCE": "Host directory managed by the local process",
  "ARCHITECTURE$PRODUCT_BODY_ONE": "This product is Chartmetric's internal AI software engineer, customized on top of OpenHands and inspired by the operating model of Devin. It connects the company's repositories, databases, integrations, and execution infrastructure so one agent can investigate data, modify code, run tests, and verify the resulting application.",
  "ARCHITECTURE$PRODUCT_BODY_TWO": "The main customization is not a new chat interface. It is an evidence-oriented agent layer built for Chartmetric's integrated environment: code structure is indexed, business meaning is traced across sources, conclusions are evaluated before delivery, and implementation work is executed in an isolated cloud workspace.",
  "ARCHITECTURE$PRODUCT_TITLE": "1. Product overview",
  "ARCHITECTURE$READ_DOCUMENTATION": "Read the product documentation",
  "ARCHITECTURE$REMOTE_ISOLATION": "Defined by the external runtime provider",
  "ARCHITECTURE$REMOTE_PERSISTENCE": "Defined by the external runtime provider",
  "ARCHITECTURE$REPOSITORY_DESCRIPTION": "Fast read-only discovery uses a centralized lexical index. Engineering work uses an authenticated clone inside the sandbox. Both expose only selected results to the model, never the entire repository at once.",
  "ARCHITECTURE$REPOSITORY_EYEBROW": "03 · Repository context",
  "ARCHITECTURE$REPOSITORY_INTELLIGENCE_DESCRIPTION": "Organization-scoped indexing refreshes only changed Git blob SHA values and creates tree-sitter structural chunks with bounded symbol references. The installed PostgreSQL full-text GIN index continues to generate symbol-and-content candidates, while exact identifier variants use the symbol index. The persisted chunk schema requires lexical sidecars; Python reranks at most 100 SQL candidates, prefers distinct files, and applies bounded symbol-reference graph rank only when its revision matches the published repository revision. Startup and reconciliation run neither search-index DDL nor an automatic corpus-wide sidecar backfill. Retrieval remains lexical and structure-aware before bounded exact-source reads, not a vector index. Each indexed repository also carries a wiki generated from that index — a compact summary and aliases small enough to show for every repository at once during routing, plus longer details, external systems, and secret prefixes read one repository at a time. Human-authored corrections are stored apart from generated fields and survive regeneration. That directory is also the join behind data work: a concept naming a product resolves through it to the repository that owns it, the external systems that repository declares, and the connected integrations whose own name refers to it, so a name found in none of the configured databases still reports where its data does live rather than reading as absent. The Wiki editor preserves multiword aliases between # markers or commas and saves only human additions, so names such as Admin Tool remain one routing alias. For a change that still needs investigation, initial workspace preparation prefers explicit selections, then one unambiguous registered name, then the classifier's inference; this does not determine the eventual fix location.",
  "ARCHITECTURE$REPOSITORY_INTELLIGENCE_TITLE": "Repository intelligence",
  "ARCHITECTURE$REPOSITORY_PRINCIPLE_DESCRIPTION": "The model never receives a raw repository dump. Search results, file reads, diffs, and command outputs become traceable observations, keeping context relevant and bounded.",
  "ARCHITECTURE$REPOSITORY_PRINCIPLE_TITLE": "Retrieval is explicit and incremental",
  "ARCHITECTURE$REPOSITORY_SCOPE_DESCRIPTION": "Persists an optional user repository-and-branch override or the router's automatic repository selection so activation, checkout, preview startup, and later turns reuse the same scope. Repositories without an explicit branch use their remote default.",
  "ARCHITECTURE$REPOSITORY_SCOPE_TITLE": "Durable repository scope",
  "ARCHITECTURE$REPOSITORY_TITLE": "Two paths from GitHub to the model",
  "ARCHITECTURE$REPO_INDEX_LAYER_DESCRIPTION": "Connected GitHub repositories are shallow-fetched at an exact commit, parsed incrementally by blob SHA, and published to organization-scoped SQL chunks. PostgreSQL full-text ranking searches symbol and content, while exact full-path equality provides an additional boost without loading the whole repository into the prompt.",
  "ARCHITECTURE$REPO_INDEX_LAYER_TITLE": "Centralized repository retrieval",
  "ARCHITECTURE$REQUEST_LIFECYCLE_TITLE": "Request lifecycle",
  "ARCHITECTURE$REQUEST_ROUTER_DESCRIPTION": "Classifies the original request as Ask or Execution, records explicit preview lifecycle and repository-change intent, and selects at most six directly relevant connected repositories. Starting or reopening a preview is Execution even when no repository file changes, but a mixed preview-and-change request still requires a concrete change target. A runtime symptom such as a slow page remains Ask until bounded ownership discovery maps its first-party dependency path, so execution starts once with the complete first-party repository set instead of assuming the visible surface owns the cost. Both independent routing passes must agree on both intents.",
  "ARCHITECTURE$REQUEST_ROUTER_TITLE": "Structured request router",
  "ARCHITECTURE$REQUEST_ROUTING_BODY": "Before a sandbox-free turn starts, the V1 service classifies the original request with a structured, source-neutral decision. Read-only questions enter the evidence LSM and hold a PostgreSQL advisory lock for the turn. When status is read after an app-server replacement, a running sandbox-free turn with no lock owner is marked interrupted instead of remaining stuck. Repository mutation, commands, tests, application execution, browser validation, deployment, checkout refresh, and pull-request work first persist the original request as a durable user event, then activate the execution sandbox with that request and the selected repositories only. An optional user override and the router's automatic selection use the same canonical repository scope: zero repositories leaves selection to the router, one uses the primary repository field, and multiple repositories are persisted in cm_pilot_conversation_metadata. If an Ask evaluation later requires execution and no repository scope was resolved from durable history, it activates an empty workspace instead of guessing among connected repositories. That durable scope is reused by activation and preview startup and preserved through Agent Server callbacks. The execution callback suppresses its duplicate copy of the initial message, and the mutation route does not copy control-agent evidence into coding context. See request_routing.py, live_status_app_conversation_service.py, sql_app_conversation_info_service.py, and webhook_router.py.",
  "ARCHITECTURE$REQUEST_ROUTING_TITLE": "Request routing before the agent loop",
  "ARCHITECTURE$REQUEST_STEP_FIVE": "The observation is correlated with its action, persisted in the event log, streamed to the product UI, and included in the next agent turn when relevant.",
  "ARCHITECTURE$REQUEST_STEP_FOUR": "Approved tools operate against the sandbox workspace, browser, terminal, Git providers, or MCP servers and return a bounded observation.",
  "ARCHITECTURE$REQUEST_STEP_ONE": "The active event branch is projected into a bounded context view containing system instructions, skills, messages, summaries, and relevant observations.",
  "ARCHITECTURE$REQUEST_STEP_THREE": "Text can be returned to the user directly. Structured tool calls become action events and pass through hooks, confirmation policy, and security analysis.",
  "ARCHITECTURE$REQUEST_STEP_TWO": "The SDK agent serializes that view with available tool schemas and calls the configured model through the provider-neutral LLM layer.",
  "ARCHITECTURE$RUNTIME_ACTIVATION_DESCRIPTION": "Slash triggers become TaskTriggers, keywords become KeywordTriggers, and triggerless skills stay always-on. The SDK lazily materializes Plugin manifests and later same-name Plugin skills or MCP servers replace earlier contributions.",
  "ARCHITECTURE$RUNTIME_ACTIVATION_TITLE": "Runtime activation",
  "ARCHITECTURE$SANDBOX_APP_BACKEND_DESCRIPTION": "App-facing sandbox lifecycle calls forward authenticated actor and organization context over HTTP only. Local app processes have no AWS credentials; production provider duties currently share the production process.",
  "ARCHITECTURE$SANDBOX_APP_BACKEND_TITLE": "App Backend",
  "ARCHITECTURE$SANDBOX_APP_SERVER_RUNTIME_DESCRIPTION": "SQL tasks use renewable 300-second leases, up to three attempts, and parallel start workers. They persist repository scope, sandbox allocation, readiness, setup, runtime-service, handoff, and conversation-creation state.",
  "ARCHITECTURE$SANDBOX_APP_SERVER_RUNTIME_TITLE": "Durable start task",
  "ARCHITECTURE$SANDBOX_BACKENDS_TITLE": "Sandbox backends",
  "ARCHITECTURE$SANDBOX_BOUNDARY_DESCRIPTION": "Docker isolates with a container and managed network; EC2 can retain workspace state on encrypted EFS; the development-only process backend runs with host permissions and is not a security boundary.",
  "ARCHITECTURE$SANDBOX_BOUNDARY_TITLE": "Isolation follows the selected backend",
  "ARCHITECTURE$SANDBOX_BROWSER_RUNTIME_DESCRIPTION": "The React UI uses same-origin App Server APIs and authenticated HTTP/WebSocket sandbox proxy paths. It never connects directly to private Agent Server, VS Code, desktop, or preview-worker ports. Its realtime traffic is one multiplexed socket to the App Server: sandbox event, terminal, and preview discovery streams are relayed as channels, so the sandbox session key stays server-side and the browser does not poll worker discovery endpoints. With an open sandbox, native browser tools execute in that sandbox and the Agent tab shows its browser, regardless of control_owns_execution. A failed sandbox browser call never falls back to the control browser. Sandbox-free turns may use the isolated control browser. Native browser_get_state captures supply original screenshot bytes to the existing image verifier and artifact publisher. A new browser observation can retry a missing stream once; healthy streams are not reconnected and no polling is added.",
  "ARCHITECTURE$SANDBOX_BROWSER_RUNTIME_TITLE": "Browser client",
  "ARCHITECTURE$SANDBOX_CONTAINER_RUNTIME_DESCRIPTION": "The least-loaded fitting host receives a bridge-networked container with cgroup CPU/memory limits and a disjoint five-port block for Agent Server, VS Code, desktop, and two worker services. Dedicated Spot VMs handle overflow.",
  "ARCHITECTURE$SANDBOX_CONTAINER_RUNTIME_TITLE": "EC2 host and container",
  "ARCHITECTURE$SANDBOX_DESCRIPTION": "Conversation startup is a durable workflow that acquires capacity, prepares repositories and services, then starts the agent beside the code it can operate on.",
  "ARCHITECTURE$SANDBOX_DETAIL_BODY": "App-facing sandbox lifecycle calls use one authenticated HTTP Sandbox Orchestrator boundary in local and production environments. Local app processes hold no AWS or SSM access; the production provider currently shares the production process and owns EC2 lifecycle, capacity, occupancy signals, and reconciliation. Its sandbox proxy is the only route to private Agent Server, VS Code, and preview ports. A start task prepares repositories and starts the execution agent beside the workspace. Production places sandbox containers on a shared multi-tenant EC2 host pool. A repository prewarm slot is a whole ready container claimed by one conversation; when no host has room, the same start path falls back to a dedicated EC2 worker. Rescheduled runtimes retain their existing session key, while resumed runtimes rotate it; both verify Agent Server readiness before publishing the runtime as running.",
  "ARCHITECTURE$SANDBOX_DETAIL_TITLE": "4. Sandbox architecture",
  "ARCHITECTURE$SANDBOX_E2E_BODY": "Like Replit or Devin, the product provides a cloud workspace where the agent can run the repository, start development services, use a browser, and expose the running web application back to the product UI. User-visible UI changes capture and publish the final changed screen, so the result can be checked as an application and durable visual evidence, not only as a code diff.",
  "ARCHITECTURE$SANDBOX_E2E_TITLE": "Sandbox-based E2E verification",
  "ARCHITECTURE$SANDBOX_EC2_DESCRIPTION": "Run isolated workspaces behind private ports reachable only through the orchestrator. Worker images provide swap headroom so concurrent builds and preview servers cannot starve the Agent Server and SSM control path.",
  "ARCHITECTURE$SANDBOX_EC2_TITLE": "Shared EC2 workers",
  "ARCHITECTURE$SANDBOX_EYEBROW": "02 · Execution environment",
  "ARCHITECTURE$SANDBOX_HANDOFF_DESCRIPTION": "The control agent accumulates indexed read-only analysis before and during provisioning. Infrastructure metadata and implementation notes such as file-by-file findings, placement recommendations, and test strategy stay in the private handoff instead of user-visible messages unless explicitly requested. As soon as the activation task exists, the agent publishes the DB-backed handoff, then refreshes it with the most recent 12,000 characters through turn completion. A barrier waits only before Agent Server creation and adds the findings to execution system context without another user-visible message.",
  "ARCHITECTURE$SANDBOX_HANDOFF_TITLE": "Private analysis handoff",
  "ARCHITECTURE$SANDBOX_LINEAGE_DESCRIPTION": "The real second parent retains the standalone FastAPI and sandbox-service ancestry. Keeping it as merge history makes future backend integrations ordinary Git merges rather than untraceable copied code.",
  "ARCHITECTURE$SANDBOX_LINEAGE_TITLE": "Sandbox Server ancestry",
  "ARCHITECTURE$SANDBOX_OPTIMIZATION_TITLE": "Cost and startup optimizations",
  "ARCHITECTURE$SANDBOX_ORCHESTRATOR_DESCRIPTION": "Uses hashed client credentials and persisted scopes to authorize tenants, then owns lifecycle, capacity, reconciliation, and private-service proxying. Lifecycle and list operations remain client-scoped; the trusted public proxy can resolve a sandbox across scopes only with its exact session capability key.",
  "ARCHITECTURE$SANDBOX_ORCHESTRATOR_RUNTIME_DESCRIPTION": "Hashed client credentials map requests to deployment scope and forward actor, Organization, and admin context. Provider operations remain scoped and reconciliation runs under a PostgreSQL advisory lock.",
  "ARCHITECTURE$SANDBOX_ORCHESTRATOR_RUNTIME_TITLE": "Authenticated orchestrator",
  "ARCHITECTURE$SANDBOX_ORCHESTRATOR_TITLE": "Sandbox Orchestrator",
  "ARCHITECTURE$SANDBOX_PREPARE_DESCRIPTION": "Refresh organization-scoped Git mirrors with a temporary server-provided askpass helper, create sandbox-isolated checkouts whose origin URL stays credential-free, run setup scripts and Git hooks, load skills, and launch repository services. Each checkout is configured with a Git credential helper so the agent's own fetch and push authenticate against origin without constructing a token URL. Later network Git commands name the registered token so the SDK injects it only into a non-interactive temporary askpass command. Every runtime service binds the endpoint the App Server allocated it: PORT carries that port, a port pinned in the start command is moved onto it, and a command naming two ports is refused rather than guessed at, so launch, restart, the readiness probe, the loopback URL a dependent repository is published under, and the sandbox's own served-app discovery all name one port and nothing relays in front of an application. Each endpoint is first reclaimed from whatever the container's service-state directory recorded on it, by process group, so a prewarm slot's or an earlier conversation's process cannot keep serving it.",
  "ARCHITECTURE$SANDBOX_PREPARE_TITLE": "Prepare workspace",
  "ARCHITECTURE$SANDBOX_PREVIEW_DESCRIPTION": "Conversation start tasks own sandbox launch and bind the resulting runtime to durable metadata. A repository prewarm slot is claimed atomically only when organization, resource profile, runtime manifest, variant, backend, deployment scope, and exact Agent Server spec match; otherwise the same flow uses a cold container. EC2 WORKER_1 and WORKER_2 served apps use dedicated per-sandbox wildcard origins only when the provider supplies an exact configured URL carrying a session-key-derived hostname capability; remote orchestrators and IDs that cannot fit a valid DNS label retain the authenticated capability-path fallback. Browser observations use the Agent browser tool instead of a desktop or VNC stream. Operation-owned claims prevent concurrent warm reservations, and lifecycle reconciliation expires stale claims.",
  "ARCHITECTURE$SANDBOX_PREVIEW_RUNTIME_DESCRIPTION": "A conversation's preview is served by its own execution sandbox and by nothing else. The capability token is written to the preview runtime row at execution start, so the opaque address exists before anything serves on it and stays the same across every sandbox that conversation has. The proxy resolves that hostname to the live sandbox, admits only the two preview workers so the token cannot reach VS Code, the desktop or the agent server, and answers a reclaimed address with a page whose POST — never a GET — starts the workspace again. While one browser channel is subscribed, the App Server sends one snapshot built from its own records — the conversation's capability address, the stored sandbox status, and the runtime launch record — and sends another only when a write to those records wakes the stream through PostgreSQL LISTEN/NOTIFY; nothing probes the sandbox for what is listening, and a dev server restarting mid-run is answered by the proxy per request rather than reported to the panel. Capability rotation rejects old links immediately; revocation rotates the token without stopping the sandbox, which the agent may still be working in. The address is reached from the conversation, in the App panel of the web console, and is published nowhere else: no pull request body and no Slack message carries one, and the execution policy asks the agent for none in a user-visible answer. A preview is the running sandbox someone comes and looks at, not a deployment with a shareable URL.",
  "ARCHITECTURE$SANDBOX_PREVIEW_RUNTIME_TITLE": "Preview runtime",
  "ARCHITECTURE$SANDBOX_PREVIEW_TITLE": "Preview activation and routing",
  "ARCHITECTURE$SANDBOX_PREWARM_DESCRIPTION": "Deployment-scoped workers keep prepared repository slots on the shared EC2 host pool. A conversation atomically claims a slot only when organization, runtime manifest, variant, backend, deployment scope, and exact Agent Server spec all match; otherwise it safely falls back to a cold container start.",
  "ARCHITECTURE$SANDBOX_PREWARM_RUNTIME_DESCRIPTION": "The warmer keeps one ready container for a repository configuration's default runtime and one for each named variant, and only for a repository whose runtime graph comes up: one that serves no browsable application gets no slot and holds no host placement capacity. Before a slot becomes claimable, its preview compiles the shared entry routes within a bounded budget; after claim, message-specific routes warm first with limited concurrency. Multi-repository claims use the repository that owns the selected variant, and the workspace marker must match that repository and variant before Pilot reuses the serving graph. Atomic claims require matching Organization, repository, manifest, backend, spec, deployment scope, variant, profile, auth, and readiness. Idle ordinary sandboxes are reclaimed after 30 minutes, or three minutes under pressure.",
  "ARCHITECTURE$SANDBOX_PREWARM_RUNTIME_TITLE": "Prewarm and lifecycle",
  "ARCHITECTURE$SANDBOX_PREWARM_TITLE": "Repository prewarm pool",
  "ARCHITECTURE$SANDBOX_PROVISION_DESCRIPTION": "A backend selects local Docker, a remote runtime, or an EC2 worker and waits for Agent Server health. Explicit unknown specs are rejected. Repository prewarm claims also require the stored slot and backing sandbox to match the requested spec exactly, preventing an obsolete Agent Server image from serving a new conversation after an image rotation. Batch EC2 status reads use short-lived database sessions and persist refreshed instance addresses after provider checks.",
  "ARCHITECTURE$SANDBOX_PROVISION_TITLE": "Provision or resume",
  "ARCHITECTURE$SANDBOX_PROXY_RUNTIME_DESCRIPTION": "All Agent Server, VS Code, desktop, and served-app HTTP/WebSocket traffic crosses the proxy. It strips Pilot credentials, injects only the sandbox key upstream, namespaces cookies, rewrites root-relative URLs, and issues service-scoped preview capability paths. On per-sandbox preview origins it forwards the previewed app's own Authorization header with its raw cookies, since the hostname capability is the only credential that path reads; on the capability path it still strips Authorization and namespaces cookies.",
  "ARCHITECTURE$SANDBOX_PROXY_RUNTIME_TITLE": "Authenticated service proxy",
  "ARCHITECTURE$SANDBOX_REQUEST_DESCRIPTION": "The App Server persists conversation metadata and queues startup as durable work before returning. A deployment-scoped start worker leases and retries that task, while the lifecycle worker reconciles interrupted starts and stale sandboxes. An activation action queues startup immediately when it appears, so provisioning overlaps the remaining control analysis; the collected handoff then reaches the execution agent. The start task remains the readiness authority until Agent Server creation completes. Stopping the conversation while it waits cancels that start task, so the sandbox being provisioned is released instead of finishing an activation nobody is waiting for. After the initial REST snapshot, authenticated server-sent events push each committed status change to the browser; PostgreSQL LISTEN/NOTIFY wakes subscribers, which re-read the scoped SQL record as the authority. The client reconstructs the provisional user bubble from that persisted request after refresh or navigation. Clients reconnect after transient failures, and listener recovery plus heartbeat re-reads close notification gaps.",
  "ARCHITECTURE$SANDBOX_REQUEST_TITLE": "Durable start task",
  "ARCHITECTURE$SANDBOX_RUNTIME_BODY": "The App Server persists a leased start task and calls one authenticated Sandbox Orchestrator HTTP boundary. In production the same control-plane process serves the orchestrator provider, which places isolated Agent Server containers on a two-host EC2 Spot pool and falls back to a dedicated Spot VM when no shared slot fits. That same sandbox serves the conversation preview: its opaque capability URL is stable for the life of the conversation, stops answering when the sandbox is reclaimed after 30 idle minutes, and can be rotated or revoked without exposing private worker ports. Following a reclaimed address offers to start the workspace again rather than returning a dead link; nothing is built or kept running behind it.",
  "ARCHITECTURE$SANDBOX_RUNTIME_TITLE": "6. Sandbox runtime",
  "ARCHITECTURE$SANDBOX_SECURITY_BODY": "Sandbox session keys are random capabilities encrypted with KMS and bound to the sandbox. Provider and test-account values normally enter the agent as scoped LookupSecrets and resolve only through authenticated sandbox endpoints. Runtime env/file secrets are materialized server-side with mode 600; ACP conversations are the explicit static-secret exception.",
  "ARCHITECTURE$SANDBOX_SERVER_DESCRIPTION": "After the private handoff is terminal, the control plane sends the serialized agent, LLM, tools, workspace, hooks, secrets, execution system context, and original user message. Later authenticated user messages are forwarded with an explicit run request so they start the existing agent loop. Docker sandboxes resolve scoped secrets and MCP calls through an internal callback to the same issuing App Server, while remote backends use its configured public URL. Repository-scoped test accounts remain lazy JSON LookupSecret entries: the execution context advertises their names, and credential-dependent terminal commands resolve their values instead of searching for .env.e2e. Execution sandboxes expose browser observations through the Agent browser tool and served applications through authenticated preview routes; the authenticated DESKTOP proxy route exists, but the pinned image carries no desktop behind it. Only after completing the requested repository change and verifying its resulting application does the execution agent include the control-plane Preview URL used for verification in its final answer; progress and non-change answers omit it, while internal hosts, ports, worker URLs, and loopback addresses remain hidden. The spec keeps OH_ENABLE_VNC off: the pinned agent-server image is built from the minimal target with no VNC stack, and with it on the browser tool launches Chromium headed into no X server, so no evidence screenshot could be taken. NOVNC_PORT stays pinned to the port the orchestrator publishes for the day a desktop image is pinned. Sandbox specs merge configurable environment values first, then force ANONYMIZED_TELEMETRY=false and BROWSER_USE_CLOUD_SYNC=false so runtime overrides cannot enable third-party telemetry or browser cloud sync. Sources: openhands/app_server/sandbox/sandbox_spec_service.py, openhands/app_server/app_conversation/execution_agent_policy.py, openhands/app_server/slack/callback_processor.py, and the docker_sandbox_spec_service.py, process_sandbox_spec_service.py, preset_sandbox_spec_service.py, remote_sandbox_spec_service.py, and dynamic_remote_sandbox_spec_service.py implementations.",
  "ARCHITECTURE$SANDBOX_SERVER_TITLE": "Start Agent Server",
  "ARCHITECTURE$SANDBOX_SNAPSHOT_RUNTIME_DESCRIPTION": "Repository warm capacity is an immutable Firecracker memory snapshot rather than a live slot. A builder boots a microVM, clones the repository, runs setup, launches the runtime graph and warms the shared entry routes at limited concurrency for the repository that owns the selected variant, writes a workspace marker so activation skips relaunching a runtime that is already serving, and only then sanitises the guest and captures it. Publication is refused unless a credential scan finds nothing, and the scan must first prove it can see planted sentinels. Snapshot identity folds in the repository, exact commit, runtime manifest digest, Agent Server spec, guest kernel, root filesystem and host CPU, and is Organization-scoped and deployment-fenced. Restore clones the template into a new guest with a fresh session key and callback identity, verifies the requested commit, and falls back to the existing start path on any miss or failure within a bounded budget. A template is never consumed, so any number of conversations restore from one concurrently. Selected per repository by the Quick open setting.",
  "ARCHITECTURE$SANDBOX_SNAPSHOT_RUNTIME_TITLE": "Memory snapshot lifecycle",
  "ARCHITECTURE$SANDBOX_STORAGE_BODY": "Encrypted EFS stores organization Git mirrors and prepared artifact archives. Repository-backed EC2 coding workspaces run from worker-local XFS under /local-preview. Prepared artifacts are extracted to a host-local base and copied with reflink copy-on-write; a bounded number of generations per family is retained so an open whose exact archive is still building reflinks the one behind it, and a per-family rebuild floor keeps a burst of commits from minting a builder each. Cache misses clone into the same local workspace. Before an explicit stop or automatic reclaim, Pilot stores a bounded organization-scoped Changes snapshot in SQL, holding the change list, its diffs and the commit list; the Git APIs prefer live runtime state and fall back to that snapshot whenever the sandbox is gone or its agent server stops answering.",
  "ARCHITECTURE$SANDBOX_STREAM_DESCRIPTION": "Two authenticated realtime paths keep the UI current: each open cloud conversation receives detailed events from the App Server event log whether or not a sandbox is attached, while an App Server user/organization-scoped summary channel updates conversation-list metadata. The same SQL log backs live conversation events and history, REST responses remain authoritative, and reconnect reconciliation refetches them. REST history reconciliation runs every 1 second while runtime creation is pending, every 3 seconds for an established runtime while the main WebSocket is disconnected, and stops while that WebSocket is open. Source: src/hooks/query/use-conversation-history.ts. Browser observations and screenshots come from the current Agent browser tool; served applications use the authenticated preview proxy without a desktop or VNC transport. For EC2 sandboxes, the authenticated service proxy resolves the authorized private target directly. Visual publication stores private AES256 timeline evidence with PostgreSQL metadata until retention expiry, then records the repository-scoped native GitHub URL or signed fallback URL used for PR rendering.",
  "ARCHITECTURE$SANDBOX_STREAM_TITLE": "Run and synchronize",
  "ARCHITECTURE$SANDBOX_TITLE": "A prepared workspace, not just a container",
  "ARCHITECTURE$SANDBOX_VARIANT_DESCRIPTION": "An explicitly requested repository variant wins. Otherwise, the App Server automatically selects a named variant only when the repositories chosen directly by the user uniquely satisfy its non-empty dependency set, then falls back to the DB-backed default. The result determines the dependency graph, typed endpoint requirements, and durable execution guidance before services start.",
  "ARCHITECTURE$SANDBOX_VARIANT_TITLE": "Resolve runtime variant",
  "ARCHITECTURE$SANDBOX_WORKSPACE_RUNTIME_DESCRIPTION": "The selected runtime variant expands repository dependencies as a DAG, and brings the graph up only when a repository declares a preview or a caller asked to browse one: it then materializes typed env/file/service inputs, runs bounded setup, starts the preview and internal services, and gates readiness through health checks and an optional TCP bridge. Each live service records a digest of its profile, endpoints, and resolved inputs; changing from default to full stack or otherwise changing that configuration replaces the existing process instead of adopting it. Resume and Agent Server reopen paths rehydrate the persisted variant graph before work continues. A repository that declares no preview needs none of that, so its conversation and its prewarm slot keep the checkout alone, and the browsing-policy prompt block is withheld from a conversation that has no preview to browse.",
  "ARCHITECTURE$SANDBOX_WORKSPACE_RUNTIME_TITLE": "Workspace and runtime graph",
  "ARCHITECTURE$SCOPED_LOOKUPS_DESCRIPTION": "Signed lookup tokens bind organization, sandbox, account, and repository scope. Resolution also requires the sandbox session capability, so a reference copied into another sandbox or repository context is rejected.",
  "ARCHITECTURE$SCOPED_LOOKUPS_TITLE": "Scoped lazy lookup",
  "ARCHITECTURE$SDK_PIN_DESCRIPTION": "config/defaults.json is the source of truth for the exact Chartmetric software-agent-sdk repository and commit. Python dependencies, uvx launch, Docker build inputs, private Agent Server image, and compatibility tests must move together.",
  "ARCHITECTURE$SDK_PIN_TITLE": "Pinned execution harness",
  "ARCHITECTURE$SECURITY_BODY": "Provider credentials and product authorization are resolved in the control plane. Short-lived GitHub installation tokens are used for clone operations without being retained in remote URLs. Sandbox session API keys authenticate control-plane, Agent Server, proxy, and webhook traffic, while confirmation policy and security analysis gate model-proposed actions.",
  "ARCHITECTURE$SECURITY_BOUNDARIES_BODY": "Lazy lookup prevents standard SaaS secret values from entering prompts or serialized agent context, but it is not a claim that every execution path is secret-free. StaticSecret exceptions place material in the sandbox, and the coding subscription OAuth file is readable by the same sandbox user as the agent. Plugin parameters are not a secret transport, and Plugin sources have source validation and trust confirmation but no enforced signature, publisher registry, malware scan, or hook/MCP policy scanner. Separately, authenticated Organization members may view configured test-account JSON in the product UI by design; only owners and admins may mutate it.",
  "ARCHITECTURE$SECURITY_RUNTIME_BODY": "Production credentials remain server-owned. Standard SaaS execution gives the agent secret names, descriptions, and scoped lookup references instead of plaintext values, then resolves a value only at the tool boundary that needs it.",
  "ARCHITECTURE$SECURITY_RUNTIME_TITLE": "10. Secret security",
  "ARCHITECTURE$SECURITY_TITLE": "Credentials and security boundaries",
  "ARCHITECTURE$SERVER_OWNED_SECRETS_DESCRIPTION": "Organization secrets, provider credentials, subscription tokens, and test-account JSON are stored in Organization-scoped backend records with encryption at rest. APIs expose connection state or bounded metadata instead of returning general-purpose credential payloads.",
  "ARCHITECTURE$SERVER_OWNED_SECRETS_TITLE": "Server-owned storage",
  "ARCHITECTURE$SKILLS_RUNTIME_BODY": "Skills are a conversation-start snapshot, not live mutable context. Pilot resolves disabled names, loads scoped sources, adds Pilot-owned built-in Agent Skills beneath customer sources, converts metadata into SDK Skill objects, and merges them by exact name before Agent Server conversation creation. Installation or deletion affects later conversations, not the context of a conversation already running.",
  "ARCHITECTURE$SKILLS_RUNTIME_TITLE": "4. Skill loading",
  "ARCHITECTURE$SKILL_ACTIVATION_DESCRIPTION": "AgentSkills-format skills expose only their name and description until the model invokes it on demand, when the SDK loads its full instructions and resources. Triggered legacy skills still use TaskTriggers or KeywordTriggers, while path rules inject deterministically when matching files are touched. The SDK records activated_skills in events.",
  "ARCHITECTURE$SKILL_ACTIVATION_TITLE": "Trigger activation",
  "ARCHITECTURE$SKILL_BOUNDARIES_BODY": "SQL-managed Organization Skills are injected into sandbox-free control turns; those turns do not receive Pilot built-ins. Pilot-owned built-in Agent Skills are merged into execution conversations beneath every customer source, so a same-name customer skill replaces the built-in and disabled names remove it. Execution-time organization discovery currently uses authenticated Git-hosted configuration repositories. Public UI catalog data comes from the build-time @openhands/extensions snapshot, while production execution asks the pinned private Agent Server to load public skills. Skill-loading failures are non-fatal and start the conversation with the remaining sources.",
  "ARCHITECTURE$SKILL_DISCOVERY_DESCRIPTION": "The App Server calls the private Agent Server /api/skills endpoint with the sandbox session key, project root, bounded organization-config candidates, and authenticated marketplace coordinates. A shared async HTTP client and bounded provider concurrency reduce startup overhead.",
  "ARCHITECTURE$SKILL_DISCOVERY_TITLE": "Authenticated discovery",
  "ARCHITECTURE$SKILL_FILTERING_DESCRIPTION": "The member's PostgreSQL-backed disabled_skills list is unioned with the active Agent Profile deny-list, deduplicated in order, and applied by exact case-sensitive name after discovery. Unknown disabled names are harmless.",
  "ARCHITECTURE$SKILL_FILTERING_TITLE": "Personal and profile filtering",
  "ARCHITECTURE$SKILL_SOURCES_DESCRIPTION": "Sources include Pilot-owned built-in Agent Skills for execution, public catalog skills, personal Agent Server filesystem skills, project .agents/.openhands directories, SQL Organization Skills for control, Git-hosted organization configuration for execution, and auto-loaded marketplace content.",
  "ARCHITECTURE$SKILL_SOURCES_TITLE": "Scoped skill sources",
  "ARCHITECTURE$SLACK_INTEGRATION_DESCRIPTION": "Slack is a first-class event, OAuth, channel-policy, conversation, link-resolution, and file-delivery subsystem. Mentioned threads can start durable Pilot conversations and receive progress, replies, and generated artifacts. Deleting the physical Slack message while its request is active suppresses queued and late replies and interrupts the control or sandbox turn; deleting a completed message does not affect a newer run. Final replies and warnings become Organization-scoped durable outbound intents; a leased provider adapter dispatches them and reconciles an interrupted send before any retry. If the provider cannot prove whether it accepted a message, the intent becomes indeterminate instead of risking a duplicate. Before title creation or conversation context persistence, Pilot removes its own invocation mention, resolves other user mentions to Slack profile names, and converts Slack mailto markup to the visible email address.",
  "ARCHITECTURE$SLACK_INTEGRATION_TITLE": "Slack subsystem",
  "ARCHITECTURE$SLACK_POLICY_DESCRIPTION": "DB-backed channel mappings gate mention-only or automatic responses. Slack's app-mention and message envelopes share one durable claim keyed by the physical message timestamp, so one mention starts one turn. Natural first-token aliases route aside, btw, goal, and new to their dedicated semantics; the model command is not exposed. Invoked threads replay unsynchronized Slack messages before the agent turn. Linked public and private channel threads resolve as untrusted turn context, read from the recent conversation messages so a referenced thread stays available on later turns; the bot joins a public channel it is not yet in, and a thread it still cannot read becomes a note in the turn instead of failing it. Direct and group messages are excluded by OAuth scope and runtime channel-type checks. Deleted message links retain a metadata-only card without preserving the deleted content. When execution serves a web app, the Organization-scoped callback reads the backend served-app inventory and adds an absolute HTTP(S) Preview button with an idle-reclaim estimate; it never relies on an agent-authored URL or drives the Pilot UI.",
  "ARCHITECTURE$SLACK_POLICY_TITLE": "Slack channel policy",
  "ARCHITECTURE$SOURCES_LABEL": "Implementation references:",
  "ARCHITECTURE$SOURCE_TRACING_FLOW_BODY": "The control agent restores durable event history before every Ask turn. Server-side tools provide indexed search, bounded exact GitHub file reads, schema discovery, bounded database access, and integrations without putting credentials in model context; they cannot publish repository changes. Exact-file investigation returns at most 20,000 content characters by default so one large source file does not expand every later model turn. Database tools remain available before code routing finds candidates. Once an unscoped search finds repository candidates, database access pauses until the agent completes a scoped search against connected repositories; a valid scoped search completes routing even when the exact identifier has no indexed match. Source-specific rules still distinguish observations, inferences, validation pending status, and unchecked sources.",
  "ARCHITECTURE$SOURCE_TRACING_FLOW_TITLE": "From a user question to authoritative evidence",
  "ARCHITECTURE$STARTUP_TIMINGS_DESCRIPTION": "Each start task persists timestamps, duration, and outcome for queue wait, sandbox allocation and readiness, repository preparation, setup, runtime services, and conversation creation. The same start-task APIs return these diagnostics for completed and failed starts. EC2 reports running only after its private Agent Server check passes, so allocation does not repeat that check through uncommitted proxy metadata. Other backends include the sandbox session key when a second health gate uses the authenticated public proxy. Long-lived response streams end each SQL read transaction before waiting so they do not reserve pooled connections.",
  "ARCHITECTURE$STARTUP_TIMINGS_TITLE": "Durable startup timings",
  "ARCHITECTURE$STATIC_SECRET_EXCEPTIONS_DESCRIPTION": "OSS/local execution and ACP currently require StaticSecrets in the sandbox request; runtime env/file inputs are materialized server-side with mode 600. Coding-role ChatGPT subscription OAuth is also written inside the sandbox for the agent process.",
  "ARCHITECTURE$STATIC_SECRET_EXCEPTIONS_TITLE": "Explicit exceptions",
  "ARCHITECTURE$TEAM_INTEGRATIONS_DESCRIPTION": "The control plane discovers organization-scoped provider capabilities and resolves encrypted credentials only while invoking a read or explicitly requested write. Credentials never enter the model context or sandbox.",
  "ARCHITECTURE$TEAM_INTEGRATIONS_TITLE": "Organization integrations",
  "ARCHITECTURE$TEST_ACCOUNTS_DESCRIPTION": "Eligible account metadata is attached as a repository-scoped LookupSecret. The encrypted JSON value is fetched only when the browser tool requests a named field through the authenticated sandbox endpoint.",
  "ARCHITECTURE$TEST_ACCOUNTS_TITLE": "Test accounts for E2E",
  "ARCHITECTURE$TITLE": "How the product turns intent into working software",
  "ARCHITECTURE$TOOL_LOOP_RUNTIME_DESCRIPTION": "The SDK projects the active event branch into model messages, validates typed tool calls, executes lifecycle and security policy, records correlated ObservationEvents, and repeats until completion, pause, interruption, or a policy limit.",
  "ARCHITECTURE$TOOL_LOOP_RUNTIME_TITLE": "Model-action-observation loop",
  "ARCHITECTURE$USAGE_ACCOUNTING_DESCRIPTION": "Organization usage reporting derives actual usage-day deltas from immutable stats-event snapshots, then aggregates them by inclusive UTC date, project attribution, and user. Every organization member can request a selected range from GET /api/v1/usage through the TanStack Query hook and typed frontend service; the server validates membership and scopes results to the active organization, while the browser does not persist or recalculate authoritative usage. Sources: openhands/app_server/usage/router.py, openhands/app_server/usage/service.py, frontend/src/hooks/query/use-usage.ts, and frontend/src/api/usage-service/usage-service.api.ts.",
  "ARCHITECTURE$USAGE_ACCOUNTING_LIMITATIONS": "Usage is historical stats-event data, not a live in-session meter, and each query is limited to 366 days. The ledger starts recording after this feature is deployed; it does not assign older cumulative conversation totals to an invented date. Project attribution is captured with each event, while display names are resolved from the current user identity. Sessions without exactly one repository are reported as No project or Multi-project.",
  "ARCHITECTURE$USAGE_ACCOUNTING_TITLE": "Usage accounting",
  "ARCHITECTURE$UTILITIES_BODY": "Skills, Plugins, and test accounts extend the agent at conversation start. Skills add bounded instructions and resources; Plugins bundle skills, command-derived skills, MCP servers, hooks, and file-based sub-agents; test accounts make eligible authenticated E2E scenarios available without copying their values into prompts.",
  "ARCHITECTURE$UTILITIES_TITLE": "8. Utilities",
  "ARCHITECTURE$UTILITY_BOUNDARIES_BODY": "Skill and Plugin context is an immutable conversation-start snapshot. Sandbox-free control turns receive SQL Organization Skills; execution loads enabled public, user, project, organization, sandbox, and marketplace sources through Agent Server. Exact-name skill merges follow source order, with later entries replacing earlier duplicates. Marketplace names compose separately: Organization entries may replace same-name instance defaults, while personal marketplaces are additive and cannot shadow inherited names. The persisted marketplace catalog uses a 15-minute freshness window, stale-while-revalidate reads, and Redis refresh locks.",
  "ARCHITECTURE$VALIDATION_FLOW_DESCRIPTION": "Sandbox-backed coding records a Stop-gate snapshot and persists FINISHED independently. The gate normally requires an open publication at the local HEAD, but an explicit push-only request may instead verify that the non-default remote branch head matches local HEAD. Whichever publication and FINISHED arrival comes second locks the conversation and idempotently creates one durable SQL task pinned to the verified publication SHA; push-only delivery preserves the commit without creating that PR-based validation task. Transactional PostgreSQL notification wakes the worker immediately, and a low-frequency reconciler repairs interrupted arrivals.",
  "ARCHITECTURE$VALIDATION_FLOW_TITLE": "Durable post-coding validation",
  "ARCHITECTURE$VALIDATION_FOLLOW_UP_DESCRIPTION": "The Control Agent can query the durable task by ID; queued, provisioning, and running remain pending. The terminal result and evidence arrive later as a deterministic event on the completed parent conversation.",
  "ARCHITECTURE$VALIDATION_FOLLOW_UP_TITLE": "Later follow-up",
  "ARCHITECTURE$VALIDATION_PUBLICATION_DESCRIPTION": "The provider API persists authoritative branch, commit, and draft PR state. Sandbox delivery normally verifies the open PR at local HEAD; when the user explicitly requests push-only delivery, it instead verifies the non-default remote branch at that SHA. Neither path writes to the default branch.",
  "ARCHITECTURE$VALIDATION_PUBLICATION_TITLE": "Verified publication",
  "ARCHITECTURE$VALIDATION_SANDBOX_DESCRIPTION": "An isolated dedicated sandbox keeps the published repository as the primary checkout, applies the detached SHA only to that target, and prepares additional repositories for its configured runtime graph. It validates without editing published code and publishes a screenshot when the target changes user-visible UI.",
  "ARCHITECTURE$VALIDATION_SANDBOX_TITLE": "Immutable validation",
  "ARCHITECTURE$VALIDATION_TASK_DESCRIPTION": "An idempotent publication-and-SHA identity stores the exact target, lease, deadline, attempts, and isolated start-task correlation. The SQL row is the durable queue; PostgreSQL NOTIFY only reduces wake-up latency, and bounded fallback polling preserves delivery after a lost notification.",
  "ARCHITECTURE$VALIDATION_TASK_TITLE": "Durable task",
  "ARCHITECTURE$VALIDATION_TRIGGER_DESCRIPTION": "Verification and FINISHED may arrive in either order. Both sandbox callback paths use the same conversation-serialized, idempotent enqueue for the immutable delivered SHA.",
  "ARCHITECTURE$VALIDATION_TRIGGER_TITLE": "Transactional trigger",
  "ARCHITECTURE$VERIFICATION_BODY": "Verification is layered because no single test can prove the complete product path. Fast static and unit gates protect local contracts; deterministic full-stack tests prove orchestration without model variance; image tests prove packaging; live tests prove the real LLM and event path; product evidence proves the changed behavior in an authenticated Pilot environment.",
  "ARCHITECTURE$VERIFICATION_CURRENT_STATE": "Current state: there is no separate post-coding validation worker. It was paused by product decision and then removed, so no validation task, validation sandbox, or isolated validation MCP surface exists; historical events written by it remain readable. Verification is what the coding run itself proves: test-account-backed E2E and final visual evidence requirements still apply to observable changes, and the publication gate still runs at coding time.",
  "ARCHITECTURE$VERIFICATION_TITLE": "3. Verification model",
  "ARCHITECTURE$VERIFY_DOCKER_DESCRIPTION": "The same Playwright specifications run against the combined Docker image rather than the npm launcher. This catches entrypoint, bundled dependency, filesystem, port, proxy, architecture, and image-pin differences hidden by a source checkout.",
  "ARCHITECTURE$VERIFY_DOCKER_TITLE": "Docker image parity",
  "ARCHITECTURE$VERIFY_LIVE_DESCRIPTION": "A same-repository PR with the live-e2e label, or a manual PR-scoped run, uses a real model and Agent Server. It verifies conversation creation, WebSocket events, one exact terminal tool call, observation rendering, and the final response while blocking analytics and protecting credentials.",
  "ARCHITECTURE$VERIFY_LIVE_TITLE": "Opt-in Live E2E",
  "ARCHITECTURE$VERIFY_MOCK_LLM_DESCRIPTION": "Playwright starts the production-style static frontend, ingress, real Agent Server and automation backend. Only the model is replaced by scripted LLM trajectories, including title generation and typed tool calls, so browser-to-tool regressions are reproducible.",
  "ARCHITECTURE$VERIFY_MOCK_LLM_TITLE": "Deterministic Mock-LLM E2E",
  "ARCHITECTURE$VERIFY_PRODUCT_EVIDENCE_DESCRIPTION": "Observable web or API changes require test-account-backed E2E in the Pilot path. User-visible UI changes additionally require publication of the final changed screenshot; video can support but cannot replace that artifact. Before its first edit an execution run declares its checks with the delivery_plan tool, each naming one observation -- a screenshot of a surface, a recorded response for a route, or a command that must exit zero. The run does not mark them done: the finish gate decides that from what the server recorded after the change, and refuses a finish that leaves a check with no matching artifact. A check the environment makes impossible is released with a reason, which is published in the pull request instead of the evidence. Control capture: original frame → persisted provenance → image verdict → artifact URL. API: publish_response_evidence → own runtime → recorded status and body. Screen fix → verified artifact linked in PR; condition change → behavioral accepted/excluded cases. Runtime launch notifications replace fixed sandbox sleeps and are not verification. Evidence publication → shared readiness → finish; unmatched checks are returned at publication. If the required evidence verifier cannot run because its provider key spending limit is exhausted, publication reports that blocker without exposing provider error details; the change remains unverified and PR publication is blocked until verification runs.",
  "ARCHITECTURE$VERIFY_PRODUCT_EVIDENCE_TITLE": "Pilot product evidence",
  "ARCHITECTURE$VERIFY_STATIC_DESCRIPTION": "Frontend lint, Vitest, app and library builds, package inspection, backend Ruff/format/mypy policy, focused pytest suites, and the exactly-one-Alembic-head check catch contract failures early.",
  "ARCHITECTURE$VERIFY_STATIC_TITLE": "Static and focused gates",
  "ARCHITECTURE$VISUAL_GATE_DESCRIPTION": "Preview activation reuses a running or pre-warmed sandbox and launches the selected multi-repository runtime services across worker ports; the frontend waits for an application response before mounting its iframe. A preview address is only as live as the sandbox serving it: a control-plane answer that offers one for an execution environment that is no longer running starts a replacement instead of leaving the address standing, and inside a live sandbox a preview that does not answer a retry and a port check is restarted before the application is called unobservable. Completed browser ObservationEvents persist the screenshot SHA-256 with their event timestamp and ID, so replayed or older events cannot regress the newest visual check. Publishing the exact screenshot bytes fulfills that recorded generation in the artifact transaction. The final Stop gate independently verifies code publication. Screenshots and WebM/MP4 recordings are stored as conversation artifacts, rendered in the chat timeline, and attached to pull requests; video remains supporting evidence and does not replace the required final screenshot. A capture taken on a response body rather than on an application surface is refused at publication and redirected to publish_response_evidence, because an API has no screen. The execution completion checklist requires API and service changes to record the exact changed route after the final edit and service restart; tests and database queries do not replace that current runtime response. Sources: openhands/app_server/app_conversation/live_status_app_conversation_service.py, openhands/app_server/event_callback/webhook_router.py, openhands/app_server/visual_validation/browser_capture_hook.py, openhands/app_server/post_coding_validation/gate.py, openhands/app_server/visual_validation/service.py, openhands/server/routes/mcp.py, src/routes/app-preview-tab.tsx, and src/components/features/chat/visual-evidence-timeline.tsx.",
  "ARCHITECTURE$VISUAL_GATE_TITLE": "Preview and visual evidence",
  "ARCHITECTURE$WEB_API_DEPLOYMENT_INTRO": "The web application and control API deploy together on one control-plane EC2 host. They share a public origin for authentication, APIs, OAuth callbacks, webhooks, and authenticated proxy access to Security Group-restricted worker ports.",
  "ARCHITECTURE$WEB_API_DEPLOYMENT_TITLE": "Web and API deployment",
  "ARCHITECTURE$WEB_API_DESCRIPTION": "The OpenHands container runs the Python FastAPI/ASGI application with Uvicorn on internal port 3000. The same process serves the compiled SPA, V1 REST routes, health endpoints, Socket.IO compatibility, and MCP endpoints. Its application lifespan also starts the conversation, lifecycle, repository-index, and webhook workers used by the control plane.",
  "ARCHITECTURE$WEB_API_TITLE": "Application and API",
  "ARCHITECTURE$WEB_DATA_DESCRIPTION": "Caddy and OpenHands run through Docker Compose on the control EC2 instance, which uses encrypted gp3 storage, an Elastic IP, IMDSv2, and SSM instead of SSH. Production and local control planes use the same externally configured PostgreSQL database and the public schema; product-owned records stay in cm_pilot_* tables. Deployment scope separates sandbox ownership and work claiming without creating a second dataset. Secrets Manager values are mounted as root-only files under /run/secrets, and the application container applies CPU, memory, PID, capability, and no-new-privileges limits.",
  "ARCHITECTURE$WEB_DATA_TITLE": "Host, data, and secrets",
  "ARCHITECTURE$WEB_EDGE_DESCRIPTION": "A Caddy container exposes ports 80 and 443 on the control host, obtains and renews ACME certificates, applies HSTS and other security headers, compresses responses with zstd or gzip, and reverse-proxies all traffic to the OpenHands service after checking its /ready endpoint.",
  "ARCHITECTURE$WEB_EDGE_TITLE": "HTTPS edge",
  "ARCHITECTURE$WEB_FRONTEND_DESCRIPTION": "The React 19 sidebar and UI use TanStack Query to call typed REST clients. An authenticated user-scoped conversation-summary stream patches that query cache for realtime list updates, but the browser is never the persistence authority and reconciliation refetches REST state. The React Router 7 and Vite application is built in SPA mode with server-side rendering disabled. Its static assets and index.html are packaged with the OpenHands application image, and unknown browser routes fall back to index.html.",
  "ARCHITECTURE$WEB_FRONTEND_TITLE": "Frontend build",
  "ARCHITECTURE$WEB_REALTIME_DESCRIPTION": "User messages and final agent replies append an audience-scoped row to cm_pilot_conversation_summary_outbox in the same database transaction as the event. The outbox and its sequence are shared across control-plane deployments; deployment scope applies only to work claiming and sandbox ownership. PostgreSQL NOTIFY only wakes the process-wide LISTEN hub; each authenticated WebSocket reads authoritative rows by sequence, user, and organization. Reconnects reconcile through REST, and local or API-key clients retain polling. Sources: openhands/app_server/app_conversation/conversation_summary_stream.py, openhands/app_server/event/sql_event_service.py, src/hooks/use-conversation-summary-stream.ts, and src/utils/conversation-summary-cache.ts.",
  "ARCHITECTURE$WEB_REALTIME_TITLE": "Realtime conversation summaries",
  "ARCHITECTURE$WORKSPACE_CLONE_DESCRIPTION": "A new warm-preferred Preview verifies the organization-scoped immutable EFS archive against its DB cache key, SHA-256, repository heads, runtime manifest, variant, agent image, and schema, then extracts it into a UUID-scoped worker-local workspace. Because every commit mints a new cache key while its exact archive is still building, a worker keeps the previous generation of each family extracted: the open reflinks that base and fetches the commits since from the organization Git mirror instead of paying the extraction again. Ordinary and existing conversations keep persistent EFS workspaces and use the authenticated Git mirror path. Any artifact miss, a delta the mirror or a changed dependency manifest refuses, or corruption falls back to that credential-free mirror clone. PostgreSQL stores artifact status and metadata, never archive bytes.",
  "ARCHITECTURE$WORKSPACE_CLONE_TITLE": "Preview artifact or clone",
  "ARCHITECTURE$WORKSPACE_CREDENTIAL_DESCRIPTION": "The control plane resolves a short-lived GitHub App installation token or encrypted organization Root Git credential server-side. No token is stored in a Git checkout: server-side commands pass one through a temporary askpass, and the checkout's credential helper resolves the current short-lived token from the sandbox-scoped secrets endpoint at each use, so nothing goes stale and nothing is written into .git/config. The optional encrypted browser session used for native attachments also remains outside the sandbox.",
  "ARCHITECTURE$WORKSPACE_CREDENTIAL_TITLE": "Resolve access",
  "ARCHITECTURE$WORKSPACE_DESCRIPTION": "A mutable source tree for editing files, running commands and tests, starting services, and creating Git changes. Its location depends on the sandbox backend, so the control plane records the resolved workspace and project directory on the conversation; the changes, diff, file, and editor views address that path instead of assuming a layout.",
  "ARCHITECTURE$WORKSPACE_LABEL": "Execution path",
  "ARCHITECTURE$WORKSPACE_SETUP_DESCRIPTION": "Setup with Agent records the connected web, API, and worker repository graph and its named runtime variants. The artifact builder installs dependencies on worker-local storage in a scrubbed environment without runtime requirements, publishes the immutable archive and metadata to EFS, and never starts preview services. A verified Preview hit skips repository and dependency setup, while runtime inputs are still materialized and services start in dependency order. Typed organization secrets come from sandbox-only mode-600 files without entering command payloads.",
  "ARCHITECTURE$WORKSPACE_SETUP_TITLE": "Repository setup",
  "ARCHITECTURE$WORKSPACE_TITLE": "Sandbox workspace",
  "ARCHITECTURE$WORKSPACE_TOOLS_DESCRIPTION": "The LLM asks tools to read files, search text, run Git or shell commands, and receives bounded observations in the next turn.",
  "ARCHITECTURE$WORKSPACE_TOOLS_TITLE": "Retrieve by using tools",
  "AUTH$BITBUCKET_SIGNUP_DISABLED": "OpenHands Cloud has temporarily disabled Bitbucket registrations and is only accepting logins from existing users at this time. We recommend registering with GitHub or GitLab instead. We are sorry for the inconvenience.",
  "AUTH$BY_SIGNING_UP_YOU_AGREE_TO_OUR": "By signing up, you agree to our",
  "AUTH$CHECK_INBOX_FOR_VERIFICATION_EMAIL": "Please check your inbox for the verification email we sent earlier.",
  "AUTH$CONNECTION_FAILED": "Connection failed",
  "AUTH$DUPLICATE_EMAIL_ERROR": "An account with that email address already exists.",
  "AUTH$EMAIL_VERIFIED_PLEASE_LOGIN": "Your email has been verified. Please login below.",
  "AUTH$GOOGLE_ERROR_DENIED": "Google sign-in was cancelled or denied.",
  "AUTH$GOOGLE_ERROR_DOMAIN_NOT_ALLOWED": "This email domain is not allowed. Sign in with your company account.",
  "AUTH$GOOGLE_ERROR_EMAIL_NOT_VERIFIED": "Your Google account email is not verified.",
  "AUTH$GOOGLE_ERROR_EXCHANGE_FAILED": "Could not verify your Google account. Please try again.",
  "AUTH$GOOGLE_ERROR_INVALID_STATE": "The sign-in attempt expired. Please try again.",
  "AUTH$GOOGLE_ERROR_LOAD_FAILED": "Google sign-in could not be loaded.",
  "AUTH$GOOGLE_ERROR_NOT_CONFIGURED": "Google sign-in is not configured on this server.",
  "AUTH$GOOGLE_ERROR_NOT_TEAM_MEMBER": "Your account is not registered as an organization member. Ask your administrator for access.",
  "AUTH$GOOGLE_SIGN_IN_BUTTON": "Sign in with Google",
  "AUTH$GOOGLE_SIGN_IN_DESCRIPTION": "Use your company Google account to continue.",
  "AUTH$GOOGLE_SIGN_IN_FAILED": "Sign-in failed. Please try again.",
  "AUTH$INVALID_KEY": "Invalid API key. Please check the key and try again.",
  "AUTH$LETS_GET_STARTED": "Let's get started",
  "AUTH$LOCAL_MODE_DESCRIPTION": "Google sign-in is not available in local mode. Open the deployed Chartmetric Pilot service to sign in.",
  "AUTH$LOGGING_BACK_IN": "Logging back into OpenHands...",
  "AUTH$LOGIN_BRAND_DESCRIPTION": "Pilot reviews pull requests, triages errors, and ships fixes while your team sleeps.",
  "AUTH$LOGIN_BRAND_HEADLINE": "Your codebase,\nalways on call.",
  "AUTH$LOGIN_SUBTITLE": "Sign in to keep your agents shipping.",
  "AUTH$LOGIN_WELCOME_BACK": "Welcome back",
  "AUTH$NO_PROVIDERS_CONFIGURED": "At least one identity provider must be configured (e.g., GitHub)",
  "AUTH$PLEASE_CHECK_EMAIL_TO_VERIFY": "Please check your email to verify your account.",
  "AUTH$RECAPTCHA_BLOCKED": "Access blocked due to suspicious activity. If you believe this is an error, please contact contact@openhands.dev for assistance.",
  "AUTH$SIGN_IN_WITH_IDENTITY_PROVIDER": "Log in to OpenHands",
  "AUTOMATIONS$ACTIONS_MENU": "Automation actions",
  "AUTOMATIONS$ACTIVE": "Active",
  "AUTOMATIONS$ADD_AUTOMATION": "Add Automation",
  "AUTOMATIONS$BACKEND_UNAVAILABLE_MESSAGE": "The automations backend is not available right now. Please try again later or check that the automation service is running.",
  "AUTOMATIONS$BACKEND_UNAVAILABLE_RETRY": "Retry",
  "AUTOMATIONS$BACKEND_UNAVAILABLE_TITLE": "Automations Unavailable",
  "AUTOMATIONS$CANCEL": "Cancel",
  "AUTOMATIONS$CREATE_AUTOMATION_BUTTON": "Create Automation",
  "AUTOMATIONS$CREATE_AUTOMATION_PROMPT": "Create an automation",
  "AUTOMATIONS$CREATE_INSTRUCTIONS_GUIDANCE": "Include what the automation should do, when it should run, and where to send the results. Be as specific as you would when giving instructions to a capable assistant—the agent handles the schedule and setup.",
  "AUTOMATIONS$CUSTOM_SCHEDULE_HINT": "This automation uses a custom schedule. Frequency editing is disabled to avoid breaking it.",
  "AUTOMATIONS$DELETE": "Delete",
  "AUTOMATIONS$DELETE_CONFIRM_MESSAGE": "Delete \"{{name}}\"? This cannot be undone.",
  "AUTOMATIONS$DELETE_CONFIRM_TITLE": "Delete automation",
  "AUTOMATIONS$DETAIL$ACTIVE": "Active",
  "AUTOMATIONS$DETAIL$ACTIVITY": "Activity",
  "AUTOMATIONS$DETAIL$ACTIVITY_LOG": "Activity Log",
  "AUTOMATIONS$DETAIL$BACK_TO_LIST": "Back to Automations",
  "AUTOMATIONS$DETAIL$CANCELLED": "Cancelled",
  "AUTOMATIONS$DETAIL$CONFIGURATION": "Configuration",
  "AUTOMATIONS$DETAIL$CREATED": "Created",
  "AUTOMATIONS$DETAIL$DEBUG_WITH_OPENHANDS": "Debug with OpenHands",
  "AUTOMATIONS$DETAIL$EVENT_FILTER": "Filter",
  "AUTOMATIONS$DETAIL$EVENT_SOURCE": "Event Source",
  "AUTOMATIONS$DETAIL$EVENT_TYPE": "Event Type",
  "AUTOMATIONS$DETAIL$FAILED": "Failed",
  "AUTOMATIONS$DETAIL$INACTIVE": "Inactive",
  "AUTOMATIONS$DETAIL$LAST_RUN": "Last run",
  "AUTOMATIONS$DETAIL$LOAD_MORE_RUNS": "Load more",
  "AUTOMATIONS$DETAIL$LOGS_CONVERSATION_MISSING": "The conversation for this run is unavailable, so its logs cannot be loaded.",
  "AUTOMATIONS$DETAIL$LOGS_EMPTY": "(no output)",
  "AUTOMATIONS$DETAIL$LOGS_ERROR": "Failed to load logs",
  "AUTOMATIONS$DETAIL$LOGS_LOADING": "Loading logs…",
  "AUTOMATIONS$DETAIL$LOGS_NO_COMMAND": "No bash command was recorded for this run.",
  "AUTOMATIONS$DETAIL$LOGS_SANDBOX_ERROR": "Sandbox is in an error state — logs cannot be retrieved.",
  "AUTOMATIONS$DETAIL$LOGS_SANDBOX_MISSING": "Sandbox has been deleted — logs are no longer available.",
  "AUTOMATIONS$DETAIL$LOGS_SANDBOX_PAUSED": "Sandbox is paused — resume the conversation to view logs.",
  "AUTOMATIONS$DETAIL$LOGS_SANDBOX_STARTING": "Sandbox is starting — try again in a moment.",
  "AUTOMATIONS$DETAIL$LOGS_SANDBOX_UNREACHABLE": "Sandbox is unreachable — it may have been stopped or scaled down.",
  "AUTOMATIONS$DETAIL$LOGS_TAB_ERROR": "Error",
  "AUTOMATIONS$DETAIL$LOGS_TAB_OUTPUT": "Output",
  "AUTOMATIONS$DETAIL$LOGS_TITLE": "Logs",
  "AUTOMATIONS$DETAIL$LOGS_VIEW": "View logs for run on {{timestamp}}",
  "AUTOMATIONS$DETAIL$LOGS_VIEW_SHORT": "View logs",
  "AUTOMATIONS$DETAIL$MODEL": "LLM profile",
  "AUTOMATIONS$DETAIL$NOTIFICATION": "Notification",
  "AUTOMATIONS$DETAIL$NOT_FOUND_MESSAGE": "The automation you're looking for doesn't exist or has been deleted.",
  "AUTOMATIONS$DETAIL$NOT_FOUND_TITLE": "Automation not found",
  "AUTOMATIONS$DETAIL$NO_CONVERSATION": "Conversation not created",
  "AUTOMATIONS$DETAIL$NO_RUNS": "No activity yet",
  "AUTOMATIONS$DETAIL$PENDING": "Pending",
  "AUTOMATIONS$DETAIL$PLUGINS": "Plugins",
  "AUTOMATIONS$DETAIL$PROMPT": "Prompt",
  "AUTOMATIONS$DETAIL$REPOSITORIES": "Repositories",
  "AUTOMATIONS$DETAIL$RUNNING": "Running",
  "AUTOMATIONS$DETAIL$SCHEDULE": "Schedule",
  "AUTOMATIONS$DETAIL$SKIPPED": "Skipped",
  "AUTOMATIONS$DETAIL$SUCCESSFUL": "Successful",
  "AUTOMATIONS$DETAIL$TIME_DAYS_AGO": "{{count}}d ago",
  "AUTOMATIONS$DETAIL$TIME_HOURS_AGO": "{{count}}h ago",
  "AUTOMATIONS$DETAIL$TIME_JUST_NOW": "Just now",
  "AUTOMATIONS$DETAIL$TIME_MINUTES_AGO": "{{count}}m ago",
  "AUTOMATIONS$DETAIL$TIME_NEVER": "Never",
  "AUTOMATIONS$DETAIL$TIME_YESTERDAY": "Yesterday",
  "AUTOMATIONS$DETAIL$TRIGGER": "Trigger",
  "AUTOMATIONS$DETAIL$TRIGGER_EVENT": "Event",
  "AUTOMATIONS$DETAIL$TRIGGER_SCHEDULE": "Schedule",
  "AUTOMATIONS$DOWNLOAD_TARBALL": "Tarball",
  "AUTOMATIONS$EDIT": "Edit",
  "AUTOMATIONS$EDIT_ERROR": "Could not update automation",
  "AUTOMATIONS$EDIT_PROMPT_HINT": "Edits apply to future runs only.",
  "AUTOMATIONS$EDIT_SUCCESS": "Automation updated",
  "AUTOMATIONS$EDIT_TITLE": "Edit automation",
  "AUTOMATIONS$EMPTY": "No automations configured",
  "AUTOMATIONS$EMPTY_DESCRIPTION": "Automations run a saved prompt on a schedule. Add one to get started.",
  "AUTOMATIONS$EMPTY_HOW_TO_CREATE_TITLE": "How to create an automation",
  "AUTOMATIONS$EMPTY_INSTALL_PLUGIN": "Install the OpenHands plugin",
  "AUTOMATIONS$EMPTY_LEARN_MORE": "Learn more in the documentation",
  "AUTOMATIONS$EMPTY_OPTION_CONVERSATION_DESC": "Start a new conversation and tell OpenHands to <example><cmd>Create an automation</cmd><punct>.</punct></example>",
  "AUTOMATIONS$EMPTY_OPTION_CONVERSATION_TITLE": "Using OpenHands Cloud",
  "AUTOMATIONS$EMPTY_OPTION_PLUGIN_DESC": "and run the command:",
  "AUTOMATIONS$EMPTY_OPTION_PLUGIN_TITLE": "Using Claude Code or Codex",
  "AUTOMATIONS$EMPTY_START_CONVERSATION": "Start a conversation",
  "AUTOMATIONS$ERROR_RETRY": "Retry",
  "AUTOMATIONS$ERROR_TIMEOUT_INVALID_NUMBER": "Timeout must be a valid number",
  "AUTOMATIONS$ERROR_TIMEOUT_MAX_EXCEEDED": "Timeout cannot exceed 1800 seconds (30 minutes)",
  "AUTOMATIONS$ERROR_TIMEOUT_POSITIVE": "Timeout must be positive",
  "AUTOMATIONS$ERROR_TITLE": "Failed to load automations",
  "AUTOMATIONS$EXPORT": "Export",
  "AUTOMATIONS$FREQUENCY": "Frequency",
  "AUTOMATIONS$FREQUENCY_CUSTOM": "Custom",
  "AUTOMATIONS$FREQUENCY_DAILY": "Daily",
  "AUTOMATIONS$FREQUENCY_WEEKDAYS": "Weekdays (Mon–Fri)",
  "AUTOMATIONS$FREQUENCY_WEEKLY": "Weekly",
  "AUTOMATIONS$IMPORT": "Import automation",
  "AUTOMATIONS$IMPORTING": "Importing...",
  "AUTOMATIONS$IMPORT_DISABLED_NOTICE": "The imported automation will be disabled until you review and enable it.",
  "AUTOMATIONS$IMPORT_INVALID_JSON": "The selected file is not valid JSON.",
  "AUTOMATIONS$IMPORT_PREVIEW_DESCRIPTION": "Review the automation details before importing.",
  "AUTOMATIONS$IMPORT_SUCCESS": "Imported \"{{name}}\" as disabled.",
  "AUTOMATIONS$IMPORT_VIEW": "View automation",
  "AUTOMATIONS$INACTIVE": "Inactive",
  "AUTOMATIONS$LOAD_MORE": "Load more",
  "AUTOMATIONS$NAME": "Name",
  "AUTOMATIONS$NAME_REQUIRED": "Name is required",
  "AUTOMATIONS$PROMPT": "Prompt",
  "AUTOMATIONS$RUN_NOW": "Run now",
  "AUTOMATIONS$RUN_NOW_ERROR": "Could not dispatch automation",
  "AUTOMATIONS$RUN_NOW_SUCCESS": "Automation dispatched",
  "AUTOMATIONS$SAVE": "Save",
  "AUTOMATIONS$SAVING": "Saving...",
  "AUTOMATIONS$SEARCH_PLACEHOLDER": "Search automations...",
  "AUTOMATIONS$STARTING": "Starting…",
  "AUTOMATIONS$SUBTITLE": "View active and inactive automations, search by metadata, and inspect read-only details.",
  "AUTOMATIONS$TIMEOUT": "Timeout (seconds)",
  "AUTOMATIONS$TIMEOUT_HINT": "Maximum time a single run may take. Leave empty for the default of 600 seconds (10 minutes); maximum 1800 seconds (30 minutes).",
  "AUTOMATIONS$TIMEZONE": "Timezone",
  "AUTOMATIONS$TIME_OF_DAY": "Time of day",
  "AUTOMATIONS$TITLE": "Automations",
  "AUTOMATIONS$TURN_OFF": "Turn off",
  "AUTOMATIONS$TURN_ON": "Turn on",
  "AUTOMATIONS$VIEW_GRID": "Grid view",
  "AUTOMATIONS$VIEW_LIST": "List view",
  "AUTOMATIONS$VIEW_MODE": "View mode",
  "AUTOMATIONS$WEEKDAY": "Day of week",
  "AUTOMATIONS$WEEKDAY_FRI": "Friday",
  "AUTOMATIONS$WEEKDAY_MON": "Monday",
  "AUTOMATIONS$WEEKDAY_SAT": "Saturday",
  "AUTOMATIONS$WEEKDAY_SUN": "Sunday",
  "AUTOMATIONS$WEEKDAY_THU": "Thursday",
  "AUTOMATIONS$WEEKDAY_TUE": "Tuesday",
  "AUTOMATIONS$WEEKDAY_WED": "Wednesday",
  "AUTO_MERGE_PRS": "Auto-merge PRs",
  "AVATAR$ALT_TEXT": "user avatar",
  "AZURE_DEVOPS$CONNECT_ACCOUNT": "Connect Azure DevOps Account",
  "BACKEND$ADD": "Add Backend",
  "BACKEND$ADD_TITLE": "Add a backend",
  "BACKEND$AGENT_SERVER_LOCATION": "Agent-server location",
  "BACKEND$AGENT_SERVER_OPTION_DESCRIPTION": "Connect to a local or remote agent-server.",
  "BACKEND$BEFORE_CONNECT_TITLE": "Before you connect",
  "BACKEND$CONNECT": "Connect",
  "BACKEND$CONNECTION_TEST_FAILED": "Could not connect to {{host}}",
  "BACKEND$EDIT_TITLE": "Edit backend",
  "BACKEND$HEALTH_FAILED_DETAIL": "Stopped retrying after {{count}} attempts. Update the host or API key to retry.",
  "BACKEND$HEALTH_FAILED_TITLE": "Connection failed",
  "BACKEND$HOST_HELPER": "URL of your agent server",
  "BACKEND$HOST_INVALID": "Enter a valid URL (e.g. http://localhost:8080)",
  "BACKEND$HOST_LABEL": "Host",
  "BACKEND$HOST_REQUIRED": "Host is required",
  "BACKEND$KEY_LABEL": "API Key",
  "BACKEND$KIND_CLOUD": "Cloud",
  "BACKEND$KIND_LABEL": "Type",
  "BACKEND$KIND_LOCAL": "Local",
  "BACKEND$KIND_REMOTE": "Remote",
  "BACKEND$LOCAL_SETUP_DESCRIPTION": "Run the backend-only instance on a different port from this frontend, then enter that host below. For example, start it with",
  "BACKEND$LOCAL_SETUP_DOCS": "Read the local backend setup guide",
  "BACKEND$LOGGED_OUT": "Logged out",
  "BACKEND$NAME_HELPER": "A friendly label for this backend",
  "BACKEND$NAME_LABEL": "Host Name",
  "BACKEND$NAME_REQUIRED": "Name is required",
  "BACKEND$NO_BACKEND_AVAILABLE": "No Backend Available",
  "BACKEND$PERSONAL_WORKSPACE": "Personal Workspace",
  "BACKEND$REMOTE_CONNECTION_DESCRIPTION": "Use http://localhost:8000 for an SSH tunnel, your ngrok domain for an ngrok setup, or your HTTPS reverse proxy URL.",
  "BACKEND$REMOTE_CONNECTION_TITLE": "Connection details",
  "BACKEND$REMOTE_SETUP_DOCS": "Read the remote backend setup guide",
  "BACKEND$REMOTE_SETUP_TITLE": "Recommended setup",
  "BACKEND$SAVE": "Save",
  "BACKEND$STATUS_CHECKING": "Checking…",
  "BACKEND$STATUS_CONNECTED": "Connected",
  "BACKEND$STATUS_DISCONNECTED": "Disconnected",
  "BACKEND$STATUS_DISCONNECTED_ADD_API_KEY": "Disconnected (add API key)",
  "BACKEND$STATUS_DISCONNECTED_CHECK_API_KEY": "Disconnected (check API key)",
  "BACKEND$STATUS_DISCONNECTED_CHECK_CLOUD_ACCESS": "Disconnected (check API key or network)",
  "BACKEND$STATUS_DISCONNECTED_CHECK_TUNNEL": "Disconnected (request timed out)",
  "BACKEND$STATUS_DISCONNECTED_CHECK_URL_OR_NETWORK": "Disconnected (check URL or network)",
  "BACKEND$SWITCHING_TO": "Switching to {{environment}}",
  "BACKEND$VERSION_LABEL": "v{{version}}",
  "BADGE$BETA": "Beta",
  "BITBUCKET$CONNECT_TO_BITBUCKET": "Log in with Bitbucket",
  "BITBUCKET$GET_TOKEN": "Get a Bitbucket token",
  "BITBUCKET$HOST_LABEL": "Bitbucket Host",
  "BITBUCKET$INSTRUCTIONS_LINK_TEXT": "click here for instructions",
  "BITBUCKET$TOKEN_HELP_TEXT": "Get your <0>Bitbucket app password</0> or <1>click here for instructions</1>. Enter it in the format 'username:app_password'.",
  "BITBUCKET$TOKEN_LABEL": "Bitbucket Token",
  "BITBUCKET$TOKEN_LINK_TEXT": "Bitbucket app password",
  "BITBUCKET_DATA_CENTER$CONNECT_TO_BITBUCKET_DATA_CENTER": "Log in with Bitbucket Data Center",
  "BITBUCKET_DATA_CENTER$HOST_LABEL": "Bitbucket Data Center Host",
  "BITBUCKET_DATA_CENTER$TOKEN_HELP_TEXT": "Create an <0>HTTP access token</0> in your Bitbucket Data Center instance with repository read/write and pull request read/write permissions. For personal access tokens, use the format 'username:token'. For project tokens, use the format 'x-token-auth:your-token'.",
  "BITBUCKET_DATA_CENTER$TOKEN_LABEL": "Bitbucket Data Center Token",
  "BOOT$STALLED_DESCRIPTION": "The server did not answer while the app was starting. It may be restarting or temporarily unavailable.",
  "BOOT$STALLED_RELOAD": "Reload",
  "BOOT$STALLED_TITLE": "Pilot is not responding",
  "BRANDING$CHARTMETRIC_PILOT": "Chartmetric Pilot",
  "BRANDING$CHARTMETRIC_PILOT_DESCRIPTION": "Chartmetric Pilot, your AI software engineering copilot.",
  "BRANDING$CHARTMETRIC_PILOT_LOGO": "Chartmetric Pilot logo",
  "BRANDING$OPENHANDS": "OpenHands",
  "BROWSER$SERVER_MESSAGE": "No web app running. Ask OpenHands to start your project's dev server (for example: npm run dev) to see your web application here.",
  "BROWSER$SERVER_MESSAGE_PREFIX": "Ask Pilot to start",
  "BROWSER$SERVER_MESSAGE_SUFFIX": "in preview sandboxes.",
  "BROWSER_SESSION_NODE$ID": "Node ID: {{id}}",
  "BROWSER_SESSION_NODE$OPEN": "Open agent browser {{id}}",
  "BROWSER_TAB$AGENT": "Agent",
  "BROWSER_TAB$PREVIEW": "Preview",
  "BROWSER_TAB$PREVIEW_NAMED": "Preview ({{name}})",
  "BTW$FAILED": "The side question could not be answered. Please try again.",
  "BTW$INCONCLUSIVE": "The side agent could not establish an answer from the available context.",
  "BTW$QUESTION_REQUIRED": "Enter a question after /btw.",
  "BUTTON$ADD": "Add",
  "BUTTON$BACK": "Back",
  "BUTTON$CANCEL": "Cancel",
  "BUTTON$CLOSE": "Close",
  "BUTTON$COLLAPSE": "Collapse",
  "BUTTON$COLLAPSE_DETAILS": "Collapse details",
  "BUTTON$CONFIRM": "Confirm",
  "BUTTON$CONTINUE": "Continue",
  "BUTTON$COPIED": "Copied to clipboard",
  "BUTTON$COPY": "Copy to clipboard",
  "BUTTON$COPY_TO_CLIPBOARD": "Copy to Clipboard",
  "BUTTON$CREATE": "Create",
  "BUTTON$DELETE": "Delete",
  "BUTTON$DELETE_CONVERSATION": "Delete Conversation",
  "BUTTON$DISCONNECT": "Disconnect",
  "BUTTON$DISPLAY_COST": "Display Cost",
  "BUTTON$DOWNLOAD_CONVERSATION_DATA": "Download conversation data",
  "BUTTON$DUPLICATE": "Duplicate",
  "BUTTON$EDIT": "Edit",
  "BUTTON$EDIT_TITLE": "Edit Title",
  "BUTTON$END_SESSION": "End Session",
  "BUTTON$EXPAND": "Expand",
  "BUTTON$EXPAND_DETAILS": "Expand details",
  "BUTTON$EXPORT_CONVERSATION": "Export Conversation",
  "BUTTON$EXPORT_TRANSCRIPT": "Export…",
  "BUTTON$HOME": "Home",
  "BUTTON$LAUNCH": "Launch",
  "BUTTON$MARK_HELPFUL": "Mark this solution as helpful",
  "BUTTON$MARK_NOT_HELPFUL": "Mark this solution as not helpful",
  "BUTTON$OPEN_IN_NEW_TAB": "Open in New Tab",
  "BUTTON$PAUSE": "Pause",
  "BUTTON$REFRESH": "Refresh",
  "BUTTON$RENAME": "Rename",
  "BUTTON$SAVE": "Save",
  "BUTTON$SEND": "Send",
  "BUTTON$SHOW_AGENT_TOOLS_AND_METADATA": "Show Agent Tools & Metadata",
  "BUTTON$STOP": "Stop",
  "CHANGE_AGENT$SWITCH_AFTER_CONVERSATION": "Agent mode can be switched after a conversation begins",
  "CHAT$ACTION_COUNT": "{{actionCount}} {{actionLabel}}",
  "CHAT$ACTION_PLURAL": "actions",
  "CHAT$ACTION_SINGULAR": "action",
  "CHAT$ACTIVITY_COUNT": "{{messageCount}} {{messageLabel}} & {{actionCount}} {{actionLabel}}",
  "CHAT$AGENT_PROFILE_PLACEHOLDER": "Agent profile",
  "CHAT$AUTOMATION_PROMPT": "Automation prompt",
  "CHAT$CODE_REVIEWING": "Code reviewing",
  "CHAT$FINISH_BLOCKED_INSTRUCTION": "Ask the agent to resolve what is listed above and deliver it.",
  "CHAT$FINISH_BLOCKED_TITLE": "The agent stopped before delivering the change",
  "CHAT$MANAGE_AGENT_PROFILES": "Manage agent profiles",
  "CHAT$MESSAGE_PLURAL": "messages",
  "CHAT$MESSAGE_SINGULAR": "message",
  "CHAT$SHOW_LESS": "Show less",
  "CHAT$START_NEW_WITH_PROFILE_HINT": "Selecting starts a new conversation",
  "CHAT$SWITCH_AGENT_PROFILE": "Switch agent profile",
  "CHAT$TOOL_BASH": "Bash",
  "CHAT$TOOL_REQUEST": "Request",
  "CHAT$TOOL_RESULT": "Result",
  "CHAT_INTERFACE$ADD_FILE": "Add file",
  "CHAT_INTERFACE$ADD_FILES_AND_IMAGES": "Add Files and Images",
  "CHAT_INTERFACE$AGENT_ACTION_USER_CONFIRMED_MESSAGE": "Agent action has been confirmed!",
  "CHAT_INTERFACE$AGENT_ACTION_USER_REJECTED_MESSAGE": "Agent action has been rejected!",
  "CHAT_INTERFACE$AGENT_AWAITING_USER_CONFIRMATION_MESSAGE": "Agent is awaiting user confirmation for the pending action.",
  "CHAT_INTERFACE$AGENT_AWAITING_USER_INPUT_MESSAGE": "Agent is awaiting user input...",
  "CHAT_INTERFACE$AGENT_ERROR_MESSAGE": "Agent error",
  "CHAT_INTERFACE$AGENT_FINISHED_MESSAGE": "Done",
  "CHAT_INTERFACE$AGENT_INIT_MESSAGE": "Agent is initialized, waiting for task...",
  "CHAT_INTERFACE$AGENT_PAUSED_MESSAGE": "Agent has paused.",
  "CHAT_INTERFACE$AGENT_RATE_LIMITED_MESSAGE": "Agent is Rate Limited. Retrying...",
  "CHAT_INTERFACE$AGENT_RATE_LIMITED_STOPPED_MESSAGE": "Agent is rate-limited. Stopped.",
  "CHAT_INTERFACE$AGENT_REJECTED_MESSAGE": "Agent has rejected the task.",
  "CHAT_INTERFACE$AGENT_RETRYING_AFTER_HICCUP": "That step didn't go through; retrying.",
  "CHAT_INTERFACE$AGENT_RUNNING_MESSAGE": "Agent is running task",
  "CHAT_INTERFACE$AGENT_STOPPED_MESSAGE": "Agent has stopped.",
  "CHAT_INTERFACE$ARCHIVED_SANDBOX_DESCRIPTION": "This conversation's sandbox has been removed. The history above is read-only.",
  "CHAT_INTERFACE$ARCHIVED_SANDBOX_TITLE": "Sandbox no longer available",
  "CHAT_INTERFACE$ASSISTANT": "Assistant",
  "CHAT_INTERFACE$AUGMENTED_PROMPT_FILES_TITLE": "NEW FILES ADDED",
  "CHAT_INTERFACE$BRANCH_FROM_HERE": "Branch from here",
  "CHAT_INTERFACE$BTW_GOT_IT": "Got it",
  "CHAT_INTERFACE$BTW_PREFIX": "BTW:",
  "CHAT_INTERFACE$BTW_WAITING_FOR_ANSWER": "Waiting for the agent's answer…",
  "CHAT_INTERFACE$CHAT_CONVERSATION": "Chat Conversation",
  "CHAT_INTERFACE$CHAT_MESSAGE_COPIED": "Message copied to clipboard",
  "CHAT_INTERFACE$CHAT_MESSAGE_COPY_FAILED": "Failed to copy message to clipboard",
  "CHAT_INTERFACE$COMMANDS": "Commands",
  "CHAT_INTERFACE$CONNECTING": "Connecting",
  "CHAT_INTERFACE$CONTEXT_WINDOW_METER_LABEL": "Context window usage",
  "CHAT_INTERFACE$DISCONNECTED": "Disconnected",
  "CHAT_INTERFACE$DO_NOT_UPLOAD_AS_FILE": "Do not upload as file",
  "CHAT_INTERFACE$ERROR_SANDBOX_DESCRIPTION": "This conversation's sandbox encountered an error. The history above is read-only.",
  "CHAT_INTERFACE$ERROR_SANDBOX_TITLE": "Sandbox error",
  "CHAT_INTERFACE$VERIFY_PREVIOUS_WORK": "Verify previous work",
  "CHAT_INTERFACE$FAILED_TO_SEND_MESSAGE": "Failed to send message",
  "CHAT_INTERFACE$FETCHING_OLDER_MESSAGES": "Fetching older messages…",
  "CHAT_INTERFACE$HIGH_RISK_WARNING": "Review carefully before proceeding.",
  "CHAT_INTERFACE$INITIALIZING_AGENT_LOADING_MESSAGE": "Initializing agent...",
  "CHAT_INTERFACE$INITIAL_MESSAGE": "Hi! I'm OpenHands, an AI Software Engineer. What would you like to build with me today?",
  "CHAT_INTERFACE$INPUT_CONTINUE_MESSAGE": "Continue",
  "CHAT_INTERFACE$INPUT_PLACEHOLDER": "Message assistant...",
  "CHAT_INTERFACE$INPUT_SEND_MESSAGE_BUTTON_CONTENT": "Send",
  "CHAT_INTERFACE$LOADING_CONVERSATION": "Loading conversation",
  "CHAT_INTERFACE$MESSAGE_ARIA_LABEL": "Message from {{sender}}",
  "CHAT_INTERFACE$MESSAGE_DISMISS": "Dismiss",
  "CHAT_INTERFACE$MESSAGE_RETRY": "Retry",
  "CHAT_INTERFACE$MESSAGE_SENDING": "Sending...",
  "CHAT_INTERFACE$MESSAGE_SEND_FAILED": "Failed to send",
  "CHAT_INTERFACE$MORE_INPUT_ACTIONS": "More input actions",
  "CHAT_INTERFACE$PILOT_ERROR_RETRY": "Pilot error — Please wait a moment and try again.",
  "CHAT_INTERFACE$PLUS_MENU": "More actions",
  "CHAT_INTERFACE$CONVERSATION_START_PROMPT": "What would you like to start?",
  "CHAT_INTERFACE$PREPARING_REQUEST": "Reading your request and preparing the agent...",
  "CHAT_INTERFACE$REQUEST_STARTED": "I've started working on your request.",
  "CHAT_INTERFACE$SHOW_CONTEXT": "Show context",
  "CHAT_INTERFACE$SLACK_ASIDE": "Aside — Pilot stayed out",
  "CHAT_INTERFACE$SLACK_CHANNEL_MESSAGE": "From the channel, not this thread",
  "CHAT_INTERFACE$SLACK_CONTEXT_MESSAGE": "Not sent to Pilot",
  "CHAT_INTERFACE$STOPPED": "Stopped",
  "CHAT_INTERFACE$TOOLTIP_COPY_MESSAGE": "Copy message",
  "CHAT_INTERFACE$TOOLTIP_SEND_MESSAGE": "Send message",
  "CHAT_INTERFACE$TOOLTIP_UPLOAD_IMAGE": "Upload image",
  "CHAT_INTERFACE$TO_BOTTOM": "To Bottom",
  "CHAT_INTERFACE$UNKNOWN_SENDER": "Unknown",
  "CHAT_INTERFACE$UPLOAD_IMAGES_AS_FILES": "Upload as file",
  "CHAT_INTERFACE$USER_ASK_CONFIRMATION": "Do you want to continue with this action?",
  "CHAT_INTERFACE$USER_CONFIRMED": "Confirm the requested action",
  "CHAT_INTERFACE$USER_REJECTED": "Reject the requested action",
  "CLEAN_DEPENDENCIES": "Clean dependencies",
  "CODE_EDITOR$EMPTY_MESSAGE": "No file selected.",
  "CODE_EDITOR$FILE_SAVED_SUCCESSFULLY": "File saved successfully",
  "CODE_EDITOR$FILE_SAVE_ERROR": "An unknown error occurred while saving the file",
  "CODE_EDITOR$OPTIONS": "Options",
  "CODE_EDITOR$SAVE_LABEL": "Save",
  "CODE_EDITOR$SAVING_LABEL": "Saving...",
  "COMMAND_MENU$AGENT_CONTEXT_KEYWORDS": "agent context persistent memory recall knowledge",
  "COMMAND_MENU$APP_SETTINGS_KEYWORDS": "app application language theme analytics preferences",
  "COMMAND_MENU$ARCHITECTURE_KEYWORDS": "architecture diagram internals system design harness sandbox",
  "COMMAND_MENU$ARIA_LABEL": "Command menu",
  "COMMAND_MENU$AUTOMATIONS_DESCRIPTION": "Review scheduled and webhook automations.",
  "COMMAND_MENU$AUTOMATIONS_KEYWORDS": "automate cron schedule webhook jobs",
  "COMMAND_MENU$AUTOMATIONS_TITLE": "Automations",
  "COMMAND_MENU$CLEAR_SEARCH_LABEL": "Clear search",
  "COMMAND_MENU$CLOSE_LABEL": "Close command menu",
  "COMMAND_MENU$CONDENSER_SETTINGS_KEYWORDS": "condenser context memory summary",
  "COMMAND_MENU$CUSTOMIZE_DESCRIPTION": "Browse skills, plugins, and integrations.",
  "COMMAND_MENU$CUSTOMIZE_KEYWORDS": "skills extensions plugins customize marketplace",
  "COMMAND_MENU$CUSTOMIZE_TITLE": "Customize",
  "COMMAND_MENU$FOOTER_HINT": "↑↓ select · Enter run · Esc close",
  "COMMAND_MENU$GROUP_ACTIONS": "Actions",
  "COMMAND_MENU$GROUP_NAVIGATION": "Navigation",
  "COMMAND_MENU$GROUP_SETTINGS": "Settings",
  "COMMAND_MENU$INTEGRATIONS_KEYWORDS": "integrations connections slack jira linear webhooks",
  "COMMAND_MENU$LLM_SETTINGS_KEYWORDS": "llm model provider api key profile inference",
  "COMMAND_MENU$MCP_KEYWORDS": "mcp tools integrations servers context protocol",
  "COMMAND_MENU$MEMBERS_KEYWORDS": "members team organization users invite roles permissions",
  "COMMAND_MENU$NEW_CHAT_DESCRIPTION": "Start a fresh OpenHands conversation.",
  "COMMAND_MENU$NEW_CHAT_KEYWORDS": "home conversation task prompt launch",
  "COMMAND_MENU$NEW_CHAT_TITLE": "New chat",
  "COMMAND_MENU$NO_RESULTS_DESCRIPTION": "Try a page, action, or setting name.",
  "COMMAND_MENU$NO_RESULTS_TITLE": "No commands found",
  "COMMAND_MENU$OPEN_LABEL": "Search commands",
  "COMMAND_MENU$PLACEHOLDER": "Search actions, pages, and settings...",
  "COMMAND_MENU$PLUGINS_KEYWORDS": "plugins marketplace catalog install extensions packages",
  "COMMAND_MENU$REPOSITORIES_KEYWORDS": "repositories repos git github gitlab bitbucket branches",
  "COMMAND_MENU$SEARCH_LABEL": "Search commands",
  "COMMAND_MENU$SECRETS_SETTINGS_KEYWORDS": "secrets environment variables credentials tokens",
  "COMMAND_MENU$SETTINGS_DESCRIPTION": "Open the settings overview.",
  "COMMAND_MENU$SETTINGS_KEYWORDS": "preferences configuration options",
  "COMMAND_MENU$SETTINGS_TITLE": "Settings",
  "COMMAND_MENU$SHORTCUT": "⌘K",
  "COMMAND_MENU$SKILLS_KEYWORDS": "skills microagents knowledge instructions repo prompts",
  "COMMAND_MENU$TEST_ACCOUNTS_KEYWORDS": "test accounts credentials fixtures sandbox logins",
  "COMMAND_MENU$TOGGLE_SIDEBAR_DESCRIPTION": "Collapse or expand the navigation rail.",
  "COMMAND_MENU$TOGGLE_SIDEBAR_KEYWORDS": "sidebar collapse expand navigation rail",
  "COMMAND_MENU$TOGGLE_SIDEBAR_TITLE": "Toggle sidebar",
  "COMMAND_MENU$USAGE_KEYWORDS": "usage billing credits cost spend tokens sessions",
  "COMMAND_MENU$VERIFICATION_SETTINGS_KEYWORDS": "verification security risk confirmation guardrails",
  "COMMON$ACTIVE_PROFILE": "Active profile",
  "COMMON$ADD_MICROAGENT": "Add Microagent",
  "COMMON$ADVANCED_SETTINGS": "advanced settings",
  "COMMON$AND": "and",
  "COMMON$APP": "User Browser",
  "COMMON$APPLICATION_SETTINGS": "Application Settings",
  "COMMON$ARCHIVED": "Archived",
  "COMMON$ASK": "Ask",
  "COMMON$BACK": "Back",
  "COMMON$BROWSER": "Browser",
  "COMMON$BUILD": "Build",
  "COMMON$CHANGES": "Changes",
  "COMMON$CLEAR_SELECTION": "Clear selection",
  "COMMON$CLICK_FOR_INSTRUCTIONS": "Click here for instructions",
  "COMMON$CLICK_HERE": "Click here",
  "COMMON$CLOSE_CONVERSATION_STOP_RUNTIME": "Stop Conversation (Runtime)",
  "COMMON$CODE": "Code",
  "COMMON$CODE_AGENT_DESCRIPTION": "Write, edit, and debug with AI assistance in real time.",
  "COMMON$COMPLETED": "Completed",
  "COMMON$COMPLETED_PARTIALLY": "Completed partially",
  "COMMON$CONFIRMATION_MODE_ENABLED": "Confirmation mode enabled",
  "COMMON$CONNECT_REPO": "Connect Repo",
  "COMMON$CONTENT": "Content",
  "COMMON$CREATED_ON": "Created on",
  "COMMON$CREATE_A_PLAN": "Create a plan",
  "COMMON$CREATE_NEW_BRANCH": "Create New Branch",
  "COMMON$CREATE_PR": "Create PR",
  "COMMON$DELETE_CONVERSATION": "Delete Conversation",
  "COMMON$DESKTOP": "Agent Browser",
  "COMMON$DISABLE": "Disable",
  "COMMON$DROP_YOUR_FILES_HERE": "Drop your files here",
  "COMMON$EDIT_IN": "Edit in",
  "COMMON$ENABLE": "Enable",
  "COMMON$ERROR": "Error",
  "COMMON$FAILED_TO_LOAD": "Failed to load",
  "COMMON$FETCH_ERROR": "Failed to fetch skills. Please try again later.",
  "COMMON$FILES": "Files",
  "COMMON$FINISHED": "Finished",
  "COMMON$FOR_EXAMPLE": "For example",
  "COMMON$GIT_PULL": "Git Pull",
  "COMMON$GIT_PUSH": "Git Push",
  "COMMON$GIT_TOOLS": "Git Tools",
  "COMMON$GIT_TOOLS_DISABLED_CONTENT": "Git tools are only available for connected repositories",
  "COMMON$HERE": "here",
  "COMMON$HIDE_PANEL": "Hide panel",
  "COMMON$HIGH_RISK": "High Risk",
  "COMMON$INCLUDE": "Include:",
  "COMMON$IN_PROGRESS": "In Progress",
  "COMMON$JUPYTER": "Jupyter",
  "COMMON$JUPYTER_EMPTY_MESSAGE": "Your Jupyter notebook is empty. No cells to display.",
  "COMMON$LANGUAGE_MODEL_LLM": "Language Model (LLM)",
  "COMMON$LEARN": "Learn",
  "COMMON$LEARN_FILE_STRUCTURE": "Learn File Structure",
  "COMMON$LEARN_SOMETHING_NEW": "Learn something new",
  "COMMON$LET_S_WORK_ON_A_PLAN": "Let’s work on a plan",
  "COMMON$LOADING": "Loading...",
  "COMMON$MACROS": "Macros",
  "COMMON$MODEL_CONTEXT_PROTOCOL_MCP": "Model Context Protocol (MCP)",
  "COMMON$MORE_OPTIONS": "More options",
  "COMMON$MOST_RECENT": "Most Recent",
  "COMMON$NEW_CONVERSATION": "New Conversation",
  "COMMON$NEXT_PAGE": "Next page",
  "COMMON$NO_BRANCH": "No Branch",
  "COMMON$NO_DATA_FOUND": "No data found",
  "COMMON$NO_REPOSITORY": "No Repository",
  "COMMON$NO_REPO_CONNECTED": "No Repo Connected",
  "COMMON$NO_RESULTS": "No results found",
  "COMMON$NO_TASKS": "No tasks yet",
  "COMMON$OPEN_REPOSITORY": "Open Repository",
  "COMMON$OPTIONAL": "Optional",
  "COMMON$PAGINATION": "Pagination",
  "COMMON$PATH": "Path:",
  "COMMON$PATTERN": "Pattern:",
  "COMMON$PAUSED": "Paused",
  "COMMON$PERSONAL": "Personal",
  "COMMON$PLAN": "Plan",
  "COMMON$PLANNER": "Planner",
  "COMMON$PLAN_AGENT_DESCRIPTION": "Outline goals, structure tasks, and map your next steps.",
  "COMMON$PLAN_MD": "Plan.md",
  "COMMON$PREVIOUS_PAGE": "Previous page",
  "COMMON$PRIVACY_POLICY": "Privacy Policy",
  "COMMON$PULL": "Pull",
  "COMMON$PULL_REQUEST": "Pull Request",
  "COMMON$PUSH": "Push",
  "COMMON$READY_FOR_REVIEW": "Ready for review",
  "COMMON$READ_MORE": "Read more",
  "COMMON$RECENT_PROJECTS": "Recent Projects",
  "COMMON$REFETCHING": "Refetching",
  "COMMON$REFRESHING": "Refreshing…",
  "COMMON$REMOVE": "Remove",
  "COMMON$REPOSITORIES": "Repositories",
  "COMMON$RESULTS": "Results ({{count}})",
  "COMMON$REVIEW_PR_IN": "Review PR in",
  "COMMON$RUN": "Run",
  "COMMON$RUNNING": "Running",
  "COMMON$RUN_APP": "Run App",
  "COMMON$RUN_TEST": "Run Test",
  "COMMON$SEARCH_REPOSITORIES": "Search repositories",
  "COMMON$SEARCH_REPOSITORIES_PLACEHOLDER": "Search repositories...",
  "COMMON$SEE": "see",
  "COMMON$SELECT_BRANCH_PLACEHOLDER": "Select branch...",
  "COMMON$SELECT_GIT_PROVIDER": "Select Git provider",
  "COMMON$SELECT_PROVIDER_PLACEHOLDER": "Select Provider",
  "COMMON$SERVER_STATUS": "Server Status",
  "COMMON$SERVER_STOPPED": "Server Stopped",
  "COMMON$SHOW_PANEL": "Show panel",
  "COMMON$STARTING": "Starting",
  "COMMON$START_CONVERSATION": "Start Conversation",
  "COMMON$START_FROM_SCRATCH": "Start from Scratch",
  "COMMON$START_SERVER": "Start Server",
  "COMMON$STATUS": "Status",
  "COMMON$STOPPED": "Stopped",
  "COMMON$STOPPING": "Stopping...",
  "COMMON$STOP_CONVERSATION": "Stop Conversation",
  "COMMON$STOP_RUNTIME": "Stop Runtime",
  "COMMON$STOP_SERVER": "Stop Server",
  "COMMON$TASKS": "Tasks",
  "COMMON$TASK_LIST": "Task List",
  "COMMON$TERMINAL": "Terminal",
  "COMMON$TERMS_OF_SERVICE": "Terms of Service",
  "COMMON$TEST_DB_MIGRATION": "Test DB Migration",
  "COMMON$TOGGLE_MENU": "Toggle menu",
  "COMMON$TRIGGERS": "Triggers",
  "COMMON$TRUNCATED": "Results truncated",
  "COMMON$TYPE_EMAIL_AND_PRESS_SPACE": "Type email and press Space",
  "COMMON$UNKNOWN": "Unknown",
  "COMMON$UP": "Up",
  "COMMON$USER_SETTINGS": "User Settings",
  "COMMON$VIEW": "View",
  "COMMON$VIEW_LESS": "View Less",
  "COMMON$VIEW_MORE": "View More",
  "COMMON$WAITING_FOR_SANDBOX": "Waiting",
  "COMMON$WORKING": "Working",
  "COMMON$WORKING_ON_IT": "Working on it",
  "COMMON$WORKSPACE_MODE_CLOUD_REPO": "Cloud Repo",
  "COMMON$WORKSPACE_MODE_LOCAL_REPO": "Local Repo",
  "COMMON$WORKSPACE_MODE_NEW_WORKTREE": "New Worktree",
  "CONFIGURATION$AGENT_LOADING": "Please wait while the agent loads. This may take a few minutes...",
  "CONFIGURATION$AGENT_RUNNING": "Please stop the agent before editing these settings.",
  "CONFIGURATION$AGENT_SELECT_LABEL": "Agent",
  "CONFIGURATION$AGENT_SELECT_PLACEHOLDER": "Select an agent",
  "CONFIGURATION$ERROR_FETCH_MODELS": "Failed to fetch models and agents",
  "CONFIGURATION$LANGUAGE_SELECT_LABEL": "Language",
  "CONFIGURATION$LANGUAGE_SELECT_PLACEHOLDER": "Select a language",
  "CONFIGURATION$MODAL_CLOSE_BUTTON_LABEL": "Close",
  "CONFIGURATION$MODAL_RESET_BUTTON_LABEL": "Reset to defaults",
  "CONFIGURATION$MODAL_SAVE_BUTTON_LABEL": "Save",
  "CONFIGURATION$MODAL_TITLE": "Configuration",
  "CONFIGURATION$MODEL_SELECT_LABEL": "Model",
  "CONFIGURATION$MODEL_SELECT_PLACEHOLDER": "Select a model",
  "CONFIGURATION$OPENHANDS_WORKSPACE_DIRECTORY_INPUT_LABEL": "OpenHands Workspace directory",
  "CONFIGURATION$OPENHANDS_WORKSPACE_DIRECTORY_INPUT_PLACEHOLDER": "Default: ./workspace",
  "CONFIGURATION$SECURITY_SELECT_LABEL": "Security analyzer",
  "CONFIGURATION$SECURITY_SELECT_PLACEHOLDER": "Select a security analyzer (optional)",
  "CONFIGURATION$SETTINGS_NEED_UPDATE_MESSAGE": "We've changed some settings in the latest update. Take a minute to review.",
  "CONFIGURATION$SETTINGS_NOT_FOUND": "Settings not found. Please check your API key",
  "CONNECT_TO_GITHUB_BY_TOKEN_MODAL$BY_CONNECTING_YOU_AGREE": "By connecting you agree to our",
  "CONNECT_TO_GITHUB_BY_TOKEN_MODAL$CONTINUE": "Continue",
  "CONNECT_TO_GITHUB_BY_TOKEN_MODAL$TERMS_OF_SERVICE": "terms of service",
  "CONNECT_TO_GITHUB_MODAL$CLOSE": "Close",
  "CONNECT_TO_GITHUB_MODAL$CONNECT": "Connect",
  "CONNECT_TO_GITHUB_MODAL$GET_YOUR_TOKEN": "Get your token",
  "CONNECT_TO_GITHUB_MODAL$HERE": "here",
  "CONVERSATION$ACP_AGENT_GENERIC": "ACP",
  "CONVERSATION$AGO": "ago",
  "CONVERSATION$ANSWERING_MODEL": "Answering model",
  "CONVERSATION$ARCHIVE": "Archive conversation",
  "CONVERSATION$ATTACH_REPOSITORY": "Attach Repository",
  "CONVERSATION$BRANCH": "Branch",
  "CONVERSATION$BUDGET": "Budget",
  "CONVERSATION$BUDGET_USAGE": "% used",
  "CONVERSATION$BUDGET_USAGE_FORMAT": "${currentCost} / ${maxBudget} ({usagePercentage}% {used})",
  "CONVERSATION$CACHE_HIT": "Cache Hit",
  "CONVERSATION$CACHE_WRITE": "Cache Write",
  "CONVERSATION$CHANGE_REPOSITORY": "Change Repository",
  "CONVERSATION$CLEARING": "Creating new conversation...",
  "CONVERSATION$CLEAR_EMPTY": "Nothing to clear. This conversation has no messages yet.",
  "CONVERSATION$CLEAR_FAILED": "Failed to start new conversation: {{error}}",
  "CONVERSATION$CLEAR_NO_ID": "No conversation ID found",
  "CONVERSATION$CLEAR_NO_NEW_ID": "Server did not return a new conversation ID",
  "CONVERSATION$CLEAR_SUCCESS": "Starting a new conversation.",
  "CONVERSATION$CLEAR_UNKNOWN_ERROR": "Unknown error",
  "CONVERSATION$CLEAR_V1_ONLY": "The /new command is only available for V1 conversations",
  "CONVERSATION$CLONE_COMMAND_FAILED_DISCONNECTED": "Repository updated but clone command could not be sent. Please reconnect and manually clone.",
  "CONVERSATION$CLOSE_CONVERSATION_WARNING": "Are you sure you want to stop this conversation?",
  "CONVERSATION$COMPACT_CONTEXT": "Compact context",
  "CONVERSATION$COMPACT_CONTEXT_COMPLETE": "Context compacted - freed {{saved}} tokens ({{before}} to {{after}})",
  "CONVERSATION$COMPACT_CONTEXT_COMPLETE_NO_CHANGE": "Context compacted",
  "CONVERSATION$COMPACT_CONTEXT_DESCRIPTION": "Summarizes older messages to free context space while keeping recent details.",
  "CONVERSATION$COMPACT_CONTEXT_FAILED": "Failed to compact context",
  "CONVERSATION$COMPACT_CONTEXT_STARTED": "Context compaction started",
  "CONVERSATION$CONFIRM_CLOSE_CONVERSATION": "Confirm Stop Conversation",
  "CONVERSATION$CONFIRM_DELETE": "Confirm Delete",
  "CONVERSATION$CONFIRM_DELETE_ALL_DESC": "Are you sure you want to delete {{count}} conversations? This action cannot be undone.",
  "CONVERSATION$CONFIRM_DELETE_ALL_TITLE": "Delete all conversations",
  "CONVERSATION$CONFIRM_DELETE_OLDER_DESC": "Are you sure you want to delete {{count}} older conversations? This action cannot be undone.",
  "CONVERSATION$CONFIRM_DELETE_OLDER_TITLE": "Delete older conversations",
  "CONVERSATION$CONFIRM_PAUSE": "Confirm Pause",
  "CONVERSATION$CONFIRM_STOP": "Confirm Stop",
  "CONVERSATION$CONTEXT_FILLING_UP": "Context is filling up - compacting frees space",
  "CONVERSATION$CONTEXT_WINDOW": "Context Window",
  "CONVERSATION$COST_BILLED": "Billed",
  "CONVERSATION$COST_BY_MODEL": "Cost by model",
  "CONVERSATION$COST_COLUMN": "Cost",
  "CONVERSATION$COST_MODEL_COLUMN": "Model",
  "CONVERSATION$COST_ROLE_ABOUTNESS_JUDGE": "Aboutness judge",
  "CONVERSATION$COST_ROLE_COLUMN": "Role",
  "CONVERSATION$COST_ROLE_CONDENSER": "Context condenser",
  "CONVERSATION$COST_ROLE_CONTROL": "Control agent",
  "CONVERSATION$COST_ROLE_DELEGATED_TASK": "Delegated task",
  "CONVERSATION$COST_ROLE_EVIDENCE_JUDGE": "Evidence judge",
  "CONVERSATION$COST_ROLE_EXECUTION": "Execution agent",
  "CONVERSATION$COST_ROLE_FRAME_JUDGE": "Frame judge",
  "CONVERSATION$COST_ROLE_IMAGE_FALLBACK": "Image description",
  "CONVERSATION$COST_ROLE_IMAGE_SEAT": "Image model",
  "CONVERSATION$COST_ROLE_PR_REVIEW_VERIFIER": "PR review verifier",
  "CONVERSATION$COST_ROLE_REPOSITORY_WIKI": "Repository wiki",
  "CONVERSATION$COST_ROLE_ROUTING": "Request routing",
  "CONVERSATION$COST_ROLE_SUBAGENT": "Delegated sub-agent",
  "CONVERSATION$COST_SUBSCRIPTION_ESTIMATE": "Covered by subscription",
  "CONVERSATION$COST_SUBSCRIPTION_ESTIMATE_HINT": "Struck through: what these calls would have cost on the same model through OpenRouter. The subscription is a flat fee, so none of it was billed.",
  "CONVERSATION$COST_TOKENS_COLUMN": "Tokens (in / cached / out)",
  "CONVERSATION$CREATED": "Created",
  "CONVERSATION$DELETE_ALL": "delete all",
  "CONVERSATION$DELETE_WARNING": "Are you sure you want to delete this conversation? This action cannot be undone.",
  "CONVERSATION$DELETE_WARNING_WITH_TITLE": "Are you sure you want to delete the \"<title>{{title}}</title>\" conversation? This action cannot be undone.",
  "CONVERSATION$DOWNLOAD_ERROR": "ConversationId unknown, cannot download trajectory",
  "CONVERSATION$ERROR_STARTING_CONVERSATION": "Error starting conversation",
  "CONVERSATION$EXIT_WARNING": "Exit Conversation",
  "CONVERSATION$FAILED_TO_COPY_LINK": "Failed to copy link",
  "CONVERSATION$FAILED_TO_FETCH_MICROAGENTS": "Failed to fetch available microagents",
  "CONVERSATION$FAILED_TO_START_FROM_TASK": "Failed to start the conversation from task.",
  "CONVERSATION$FAILED_TO_START_WITH_ERROR": "Failed to start conversation: {{error}}",
  "CONVERSATION$FAILED_TO_UPDATE_REPOSITORY": "Failed to update repository",
  "CONVERSATION$FORK_BADGE": "Fork",
  "CONVERSATION$GIT_PROVIDER": "Git Provider",
  "CONVERSATION$HIDE": "hide",
  "CONVERSATION$HOOKS_NEED_RUNTIME": "Hooks live in the workspace, so they cannot be read while this conversation has no running execution environment.",
  "CONVERSATION$HOOKS_NEED_RUNTIME_TOOLTIP": "Start the execution environment to read this project's hooks.",
  "CONVERSATION$INPUT": "Input",
  "CONVERSATION$LINK_COPIED": "Link copied to clipboard",
  "CONVERSATION$LOADING_MORE": "Loading more conversations…",
  "CONVERSATION$LOAD_MORE": "Load more",
  "CONVERSATION$METRICS_INFO": "Conversation Metrics",
  "CONVERSATION$NOT_EXIST_OR_NO_PERMISSION": "This conversation does not exist, or you do not have permission to access it. If this is your conversation, try switching to the workspace where it was created.",
  "CONVERSATION$NOT_FOUND": "Conversation not found",
  "CONVERSATION$NO_BUDGET_LIMIT": "No budget limit",
  "CONVERSATION$NO_CONVERSATIONS": "No conversations found",
  "CONVERSATION$NO_HISTORY_AVAILABLE": "No conversation history available",
  "CONVERSATION$NO_HOOKS": "No hooks configured for this conversation.",
  "CONVERSATION$NO_METRICS": "No metrics data available",
  "CONVERSATION$NO_REPO_CONNECTED": "No Repo Connected",
  "CONVERSATION$NO_SKILLS": "No available skills found for this conversation.",
  "CONVERSATION$N_OLDER_CONVERSATIONS": "older conversations",
  "CONVERSATION$OPEN_FORK_SOURCE": "Open the conversation this fork started from",
  "CONVERSATION$OPEN_REPOSITORY": "Open Repository",
  "CONVERSATION$OUTPUT": "Output",
  "CONVERSATION$PAUSE_WARNING": "Are you sure you want to pause this conversation?",
  "CONVERSATION$PIN_TAB": "Pin tab to bar",
  "CONVERSATION$READY": "Ready",
  "CONVERSATION$REPOSITORY": "Repository",
  "CONVERSATION$REPOSITORY_UPDATED": "Repository updated successfully",
  "CONVERSATION$SELECT_OR_INSERT_LINK": "Select or insert a link",
  "CONVERSATION$SHARE": "Share",
  "CONVERSATION$SHARED_CONVERSATION": "Shared Conversation",
  "CONVERSATION$SHOW_ALL": "show all",
  "CONVERSATION$SHOW_HOOKS": "Show Available Hooks",
  "CONVERSATION$SHOW_PLUGINS": "Show Plugins",
  "CONVERSATION$SHOW_SKILLS": "Show Available Skills",
  "CONVERSATION$STARTING_CONVERSATION": "Starting",
  "CONVERSATION$START_NEW": "Start new conversation",
  "CONVERSATION$STOP_WARNING": "Are you sure you want to pause this conversation?",
  "CONVERSATION$SUBSCRIPTION_COST_NOTE": "Ran on the ChatGPT subscription, which is a flat fee — those calls add nothing to this total.",
  "CONVERSATION$TITLE_UPDATED": "Conversation title updated successfully",
  "CONVERSATION$TOTAL": "Total",
  "CONVERSATION$TOTAL_COST": "Total Cost",
  "CONVERSATION$UNARCHIVE": "Unarchive conversation",
  "CONVERSATION$UNAVAILABLE_FOR_ARCHIVES": "Unavailable for Archives",
  "CONVERSATION$UNKNOWN": "unknown",
  "CONVERSATION$UNPIN_TAB": "Unpin tab from bar",
  "CONVERSATION$UNREAD": "Unread",
  "CONVERSATION$UNTITLED": "(untitled)",
  "CONVERSATION$UPDATED": ", updated",
  "CONVERSATION$USED": "used",
  "CONVERSATION$VERSION_V0_LEGACY": "Conversation API Version 0 (Legacy)",
  "CONVERSATION$VERSION_V1_NEW": "Conversation API Version 1 (New)",
  "CONVERSATION_PANEL$ADD_CONVERSATION_TO_GROUP": "Start new conversation in {{label}}",
  "CONVERSATION_PANEL$ALL_THREADS": "All threads",
  "CONVERSATION_PANEL$BY_REPOSITORY": "By repository",
  "CONVERSATION_PANEL$BY_WORKSPACE": "By workspace",
  "CONVERSATION_PANEL$CHRONOLOGICAL": "Chronological list",
  "CONVERSATION_PANEL$COLLAPSE_FOLDER": "Collapse {{label}} folder",
  "CONVERSATION_PANEL$DRAG_FOLDER": "Drag {{label}} folder to reorder",
  "CONVERSATION_PANEL$EXPAND_FOLDER": "Expand {{label}} folder",
  "CONVERSATION_PANEL$FILTER_LABEL": "Filter conversations",
  "CONVERSATION_PANEL$HOVER_METADATA": "Hover metadata",
  "CONVERSATION_PANEL$INVOLVED": "My sessions",
  "CONVERSATION_PANEL$LESS": "Less",
  "CONVERSATION_PANEL$LLM_MODEL": "Agent / model",
  "CONVERSATION_PANEL$METADATA": "Metadata",
  "CONVERSATION_PANEL$MORE": "More",
  "CONVERSATION_PANEL$MOVE_FOLDER_DOWN": "Move {{label}} folder down",
  "CONVERSATION_PANEL$MOVE_FOLDER_UP": "Move {{label}} folder up",
  "CONVERSATION_PANEL$NEW_THREAD_FOLDER_ARIA": "Create thread folder — choose workspace or repository",
  "CONVERSATION_PANEL$NO_REPOSITORY": "No repository",
  "CONVERSATION_PANEL$NO_WORKSPACE": "No workspace",
  "CONVERSATION_PANEL$OLDER_OVER_ONE_HOUR": "Over 1 hour",
  "CONVERSATION_PANEL$OLDER_SECTION": "Older conversations",
  "CONVERSATION_PANEL$ORGANIZE": "Organize",
  "CONVERSATION_PANEL$PINNED": "Pinned",
  "CONVERSATION_PANEL$PIN_CONVERSATION": "Pin conversation",
  "CONVERSATION_PANEL$PREVIEW_AUTHOR": "Author",
  "CONVERSATION_PANEL$PREVIEW_DIRECTORY": "Directory",
  "CONVERSATION_PANEL$PREVIEW_MODEL": "Model",
  "CONVERSATION_PANEL$PRODUCTION_SESSIONS": "Prod sessions",
  "CONVERSATION_PANEL$PROJECT": "Project",
  "CONVERSATION_PANEL$RELEVANT_THREADS": "Relevant (active)",
  "CONVERSATION_PANEL$REPO_BRANCH": "Repo and branch",
  "CONVERSATION_PANEL$SEARCH_SESSIONS": "Search sessions",
  "CONVERSATION_PANEL$SELECT_FOLDER": "Select {{label}} folder",
  "CONVERSATION_PANEL$SHOW": "Show",
  "CONVERSATION_PANEL$SORT_BY": "Sort by",
  "CONVERSATION_PANEL$SORT_CREATED": "Created",
  "CONVERSATION_PANEL$SORT_UPDATED": "Updated",
  "CONVERSATION_PANEL$SOURCE": "Source",
  "CONVERSATION_PANEL$SOURCE_CONSOLE": "Console",
  "CONVERSATION_PANEL$START_YOUR_FIRST_WORK": "Start your first work with Pilot",
  "CONVERSATION_PANEL$TAGS": "Tags",
  "CONVERSATION_PANEL$UNPIN_CONVERSATION": "Unpin conversation",
  "CONVERSATION$SANDBOX_RUNNING": "Sandbox running",
  "CONVERSATION$SANDBOX_STARTING": "Sandbox starting",
  "CONVERSATION_STATUS$ANSWERED": "Answered",
  "CONVERSATION_STATUS$DELIVERED": "Delivered",
  "CRITIC$INFRASTRUCTURE": "Infrastructure:",
  "CRITIC$ITERATIVE_REFINEMENT_HINT": "Want the agent to automatically fix potential issues? Enable iterative refinement in settings.",
  "CRITIC$LIKELY_FOLLOWUP": "Likely Follow-up:",
  "CRITIC$OTHER": "Other:",
  "CRITIC$POTENTIAL_ISSUES": "Potential Issues:",
  "CRITIC$SUCCESS_LIKELIHOOD_LABEL": "Critic: agent success likelihood",
  "CTA$FEATURE_COMPLIANCE": "Custom compliance requirements",
  "CTA$FEATURE_DATA_CONTROL": "Full data control",
  "CTA$FEATURE_SUPPORT": "Dedicated support options",
  "CTA$LEARN_MORE": "Learn more",
  "CUSTOM_INPUT$OPTIONAL_LABEL": "(Optional)",
  "DESKTOP$EXPAND": "Full screen",
  "DESKTOP$KEYBOARD_CAPTURE": "Keyboard input for the agent's browser",
  "DESKTOP$RETURN_CONTROL": "Return control to agent",
  "DESKTOP$TAKE_CONTROL": "Take control",
  "DESKTOP$UNAVAILABLE": "The sandbox desktop is not available for this conversation.",
  "DESKTOP$WAITING": "Starting the sandbox desktop…",
  "DEVICE$AUTHORIZATION_REQUEST": "Device Authorization Request",
  "DEVICE$AUTHORIZATION_TITLE": "Device Authorization",
  "DEVICE$AUTHORIZE": "Authorize Device",
  "DEVICE$AUTH_REQUIRED": "Authentication Required",
  "DEVICE$CANCEL": "Cancel",
  "DEVICE$CODE_INPUT_LABEL": "Device Code:",
  "DEVICE$CODE_LABEL": "DEVICE CODE",
  "DEVICE$CODE_PLACEHOLDER": "Enter your device code",
  "DEVICE$CONFIRM_PROMPT": "Do you want to authorize this device to access your OpenHands account?",
  "DEVICE$CONTINUE": "Continue",
  "DEVICE$ENTER_CODE_PROMPT": "Enter the code displayed on your device:",
  "DEVICE$ERROR_FAILED": "Failed to authorize device. Please try again.",
  "DEVICE$ERROR_OCCURRED": "An error occurred while authorizing the device. Please try again.",
  "DEVICE$ERROR_TITLE": "Error",
  "DEVICE$PROCESSING": "Processing device verification...",
  "DEVICE$SECURITY_NOTICE": "Security Notice",
  "DEVICE$SECURITY_WARNING": "Only authorize this device if you initiated this request from your CLI or application.",
  "DEVICE$SIGN_IN_PROMPT": "Please sign in to authorize your device.",
  "DEVICE$SUCCESS_MESSAGE": "Device authorized successfully! You can now return to your CLI and close this window.",
  "DEVICE$SUCCESS_TITLE": "Success!",
  "DEVICE$TRY_AGAIN": "Try Again",
  "DIFF_VIEWER$ASK_OH": "Ask OpenHands to initialize a git repo to activate this UI.",
  "DIFF_VIEWER$COMMITS": "Commits",
  "DIFF_VIEWER$COMMITS_CAP": "Showing the latest {{count}} commits",
  "DIFF_VIEWER$COMMITS_SANDBOX_STOPPED": "The sandbox has stopped, so commit contents open on the Git provider instead.",
  "DIFF_VIEWER$FILE_DELETED": "This file was deleted. Its previous contents are no longer available for preview.",
  "DIFF_VIEWER$GETTING_LATEST_CHANGES": "Getting latest changes...",
  "DIFF_VIEWER$LOADING": "Loading changes...",
  "DIFF_VIEWER$NOT_A_GIT_REPO": "Your current workspace is not a git repository.",
  "DIFF_VIEWER$NO_CHANGES": "OpenHands hasn't made any changes yet",
  "DIFF_VIEWER$NO_COMMITS": "No commits yet",
  "DIFF_VIEWER$VIEW_COMMIT_ON_PROVIDER": "View this commit on the Git provider",
  "DIFF_VIEWER$WAITING_FOR_RUNTIME": "Waiting for runtime to start...",
  "DOWNLOAD$CANCEL": "Cancel",
  "DOWNLOAD$DOWNLOADING": "Downloading Files",
  "DOWNLOAD$FILES_PROGRESS": "{{downloaded}} of {{total}} files",
  "DOWNLOAD$FOUND_FILES": "Found {{count}} files...",
  "DOWNLOAD$PREPARING": "Preparing Download...",
  "DOWNLOAD$SCANNING": "Scanning workspace...",
  "ERROR$ACP_AUTH_REQUIRED_TITLE": "Authentication required",
  "ERROR$ACP_UPDATE_CREDENTIALS": "Update credentials",
  "ERROR$BACKEND_REQUEST_TIMEOUT": "Disconnected (request timed out). Check that the backend URL is correct and reachable.",
  "ERROR$CORS_OR_NETWORK": "Disconnected (check URL or network). Check that the backend URL is correct and the backend server is reachable. If the backend is on another origin, check that it allows this frontend origin.",
  "ERROR$FAILED_TO_LOAD_PROFILE_TRY_AGAIN": "Failed to load existing profile. Please try again.",
  "ERROR$GENERIC": "An error occurred",
  "ERROR$GENERIC_OOPS": "Oops! An error occurred!",
  "ERROR$REPOSITORY_RUNTIME_UNAVAILABLE_TITLE": "Preview unavailable",
  "ERROR$REQUIRED_FIELD": "This field is required",
  "ERROR$UNKNOWN": "Uh oh, an unknown error occurred!",
  "ERROR_TOAST$CLOSE_BUTTON_LABEL": "Close",
  "EVENT$CORRECTION_REQUESTED": "Correction requested",
  "EVENT$MESSAGE": "Message",
  "EVENT$UNKNOWN_EVENT": "Unknown event",
  "EVENT_GROUP$ACTIONS_COMPLETED": "{{count}} actions completed",
  "EVENT_GROUP$ACTIONS_PROGRESS": "{{completed}}/{{total}} actions completed",
  "EVENT_GROUP$COLLAPSE": "Collapse actions",
  "EVENT_GROUP$EXPAND": "Expand actions",
  "EXIT_PROJECT$CONFIRM": "Exit Project",
  "EXIT_PROJECT$TITLE": "Are you sure you want to exit this project?",
  "EXIT_PROJECT$WARNING": "Are you sure you want to exit this project? Any unsaved changes will be lost.",
  "EXPANDABLE_MESSAGE$HIDE_DETAILS": "Hide details",
  "EXPANDABLE_MESSAGE$SHOW_DETAILS": "Show details",
  "EXPLORER$LABEL_DROP_FILES": "Drop files here",
  "EXPLORER$NO_FILES_UPLOADED_MESSAGE": "No files were uploaded",
  "EXPLORER$UPLOAD_ERROR_MESSAGE": "Error uploading file",
  "EXPLORER$UPLOAD_PARTIAL_SUCCESS_MESSAGE": "{{count}} file(s) were skipped during upload",
  "EXPLORER$UPLOAD_SUCCESS_MESSAGE": "Successfully uploaded {{count}} file(s)",
  "EXPLORER$UPLOAD_UNEXPECTED_RESPONSE_MESSAGE": "Unexpected response structure from server",
  "FEEDBACK$CANCEL_LABEL": "Cancel",
  "FEEDBACK$CONTRIBUTE_LABEL": "Contribute to public dataset",
  "FEEDBACK$COPY_LABEL": "Copy",
  "FEEDBACK$DESCRIPTION": "We value your feedback. Please share your thoughts with us.",
  "FEEDBACK$EMAIL_LABEL": "Your email",
  "FEEDBACK$EMAIL_PLACEHOLDER": "Enter your email address",
  "FEEDBACK$FAILED_TO_SHARE": "Failed to share, please contact the developers:",
  "FEEDBACK$FAILED_TO_SUBMIT": "Failed to submit feedback",
  "FEEDBACK$GO_TO_FEEDBACK": "Go to shared feedback",
  "FEEDBACK$INVALID_EMAIL_FORMAT": "Invalid email format",
  "FEEDBACK$MODAL_CONTENT": "To help us improve, we collect feedback from your interactions to improve our prompts. By submitting this form, you consent to us collecting this data.",
  "FEEDBACK$MODAL_TITLE": "Share feedback",
  "FEEDBACK$PASSWORD": "Password:",
  "FEEDBACK$PASSWORD_COPIED_MESSAGE": "Password copied to clipboard.",
  "FEEDBACK$PRIVATE_LABEL": "Private",
  "FEEDBACK$PUBLIC_LABEL": "Public",
  "FEEDBACK$RATE_AGENT_PERFORMANCE": "Rate the agent's performance:",
  "FEEDBACK$REASON_DIDNT_FINISH_JOB": "The agent didn't finish the job",
  "FEEDBACK$REASON_FORGOT_CONTEXT": "The agent forgot about the earlier context",
  "FEEDBACK$REASON_MISUNDERSTOOD_INSTRUCTION": "The agent misunderstood my instruction",
  "FEEDBACK$REASON_OTHER": "Other",
  "FEEDBACK$REASON_SHOULD_ASK_FIRST": "The agent should've asked me first before doing it!",
  "FEEDBACK$REASON_UNNECESSARY_CHANGES": "The agent made unnecessary changes",
  "FEEDBACK$SELECT_REASON": "Select a reason (optional):",
  "FEEDBACK$SELECT_REASON_COUNTDOWN": "Auto-submitting in {{countdown}} seconds...",
  "FEEDBACK$SHARE_LABEL": "Share",
  "FEEDBACK$SHARING_SETTINGS_LABEL": "Sharing settings",
  "FEEDBACK$SUBMITTING_LABEL": "Submitting...",
  "FEEDBACK$SUBMITTING_MESSAGE": "Submitting feedback, please wait...",
  "FEEDBACK$THANK_YOU_FOR_FEEDBACK": "Thank you for your feedback! This will help us improve OpenHands going forward.",
  "FEEDBACK$TITLE": "Feedback",
  "FILES$BINARY_FALLBACK": "Binary file – preview not available",
  "FILES$DIFF_VIEW": "Diff",
  "FILES$HIDE_FILE_TREE": "Hide file tree",
  "FILES$LOADING_FILES": "Loading files…",
  "FILES$LOAD_ERROR": "Could not load this file",
  "FILES$MORE_FILES": "More files",
  "FILES$NO_FILES": "No files in workspace",
  "FILES$NO_FILE_SELECTED": "Select a file to view its contents",
  "FILES$OPEN_IN_NEW_WINDOW": "Open in new window",
  "FILES$PLAIN": "Plain",
  "FILES$REFRESH": "Refresh files",
  "FILES$RICH": "Rich",
  "FILES$SANDBOX_STOPPED": "This conversation's sandbox has stopped, so its workspace files can no longer be browsed. Diff and Commits still work from the saved snapshot.",
  "FILES$SHOW_FILE_TREE": "Show file tree",
  "FILES$UNSUPPORTED_DOCUMENT": "Preview isn't available for {{type}} files.",
  "FILE_EXPLORER$UPLOAD": "Upload File",
  "FILE_SERVICE$INVALID_FILE_PATH": "Invalid file path. Please check the file name and try again.",
  "FILE_SERVICE$LIST_FILES_ERROR": "Error listing files. Please try again.",
  "FILE_SERVICE$SAVE_FILE_ERROR": "Error saving file. Please try again.",
  "FILE_SERVICE$SELECT_FILE_ERROR": "Error selecting file. Please try again.",
  "FILE_SERVICE$UPLOAD_FILES_ERROR": "Error uploading files. Please try again.",
  "FINISH$TASK_COMPLETED_PARTIALLY": "I believe that the task was **completed partially**.",
  "FINISH$TASK_COMPLETED_SUCCESSFULLY": "I believe that the task was **completed successfully**.",
  "FINISH$TASK_NOT_COMPLETED": "I believe that the task was **not completed**.",
  "FIX_README": "Fix README",
  "FORGEJO$HOST_LABEL": "Forgejo Host (domain)",
  "FORGEJO$TOKEN_LABEL": "Forgejo Personal Access Token",
  "FORM$DESCRIPTION": "Description",
  "FORM$VALUE": "Value",
  "GIT$ACTIVITY_DESCRIPTION": "Pilot PR reviews and work requested from GitHub will appear here.",
  "GIT$AZURE_DEVOPS_HOST": "Azure DevOps Organization",
  "GIT$AZURE_DEVOPS_HOST_PLACEHOLDER": "organization",
  "GIT$AZURE_DEVOPS_TOKEN": "Azure DevOps Personal Access Token",
  "GIT$AZURE_DEVOPS_TOKEN_HELP": "How to create an Azure DevOps token",
  "GIT$BITBUCKET_DC_TOKEN_HELP_LINK": "Bitbucket Data Center HTTP access token docs",
  "GIT$BITBUCKET_TOKEN_HELP_LINK": "Bitbucket token help link",
  "GIT$BITBUCKET_TOKEN_SEE_MORE_LINK": "Bitbucket token see more link",
  "GIT$GITHUB_API": "GitHub API",
  "GIT$GITHUB_TOKEN_HELP_LINK": "GitHub token help link",
  "GIT$GITHUB_TOKEN_SEE_MORE_LINK": "GitHub token see more link",
  "GIT$GITLAB_API": "GitLab API",
  "GIT$GITLAB_TOKEN_HELP_LINK": "Gitlab token help link",
  "GIT$GITLAB_TOKEN_SEE_MORE_LINK": "GitLab token see more link",
  "GIT$MERGE_REQUEST": "Merge Request",
  "GIT$PULL_REQUEST": "Pull Request",
  "GITHUB$ADD_MORE_REPOS": "Add more repositories...",
  "GITHUB$APP_CALLBACK_FAILED": "The Pilot GitHub App could not be installed. Try the second step again.",
  "GITHUB$AUTH_SCOPE": "openid email profile",
  "GITHUB$CODE_NOT_IN_GITHUB": "Code not in GitHub?",
  "GITHUB$CONFIGURE_REPOS": "Configure Github Repositories",
  "GITHUB$CONNECT": "Connect to GitHub",
  "GITHUB$CONNECTION_APP_METADATA": "Installed on @{{account}} · {{type}}",
  "GITHUB$CONNECTION_ATTACHMENT_METADATA": "Connected as @{{account}}",
  "GITHUB$CONNECTION_COMPLETED": "Completed",
  "GITHUB$CONNECTION_CURRENT": "Current",
  "GITHUB$CONNECTION_INSTALL_APP": "Install GitHub App",
  "GITHUB$CONNECTION_LOADING": "Loading GitHub connection…",
  "GITHUB$CONNECTION_LOAD_ERROR": "GitHub connection status could not be loaded.",
  "GITHUB$CONNECTION_LOCAL_HELPER_ERROR": "The attachment session could not be connected or has expired. Start a new pairing and try again.",
  "GITHUB$CONNECTION_LOCAL_HELPER_INSTRUCTIONS": "Open the downloaded Pilot GitHub Connect app. It finds an existing @{{account}} session and returns here automatically. If your system warns about the download, use Open from the file's context menu.",
  "GITHUB$CONNECTION_MODAL_DESCRIPTION": "Your progress is saved. Resume from the first incomplete step at any time.",
  "GITHUB$CONNECTION_MODAL_TITLE": "Connect GitHub",
  "GITHUB$CONNECTION_PARTIAL": "{{completed}} / 3 steps completed",
  "GITHUB$CONNECTION_PENDING": "Pending",
  "GITHUB$CONNECTION_PROGRESS": "Overall progress",
  "GITHUB$CONNECTION_RETRY": "Retry",
  "GITHUB$CONNECTION_START_LOCAL_HELPER": "Connect attachment session",
  "GITHUB$CONNECTION_STEPS_COMPLETED": "{{completed}} / {{total}} steps completed",
  "GITHUB$CONNECTION_STEP_ACCOUNT": "Connect team GitHub account",
  "GITHUB$CONNECTION_STEP_ACCOUNT_DESCRIPTION": "Authorize the GitHub account that owns or manages your team's repositories.",
  "GITHUB$CONNECTION_STEP_APP": "Install Pilot GitHub App",
  "GITHUB$CONNECTION_STEP_APP_DESCRIPTION": "Install Pilot so it can create branches and pull requests in selected repositories.",
  "GITHUB$CONNECTION_STEP_ATTACHMENT": "Optional: Enable native GitHub attachments",
  "GITHUB$CONNECTION_STEP_ATTACHMENT_DESCRIPTION": "Reuse the GitHub session already open in your browser. Without it, Pilot posts a secure evidence link instead.",
  "GITHUB$CONNECTION_TITLE": "GitHub connection",
  "GITHUB$CONNECT_PILOT_BOT": "Connect Bot",
  "GITHUB$CONNECT_TO_GITHUB": "Log in with GitHub",
  "GITHUB$GET_TOKEN": "Get your token",
  "GITHUB$HOST_LABEL": "GitHub Host (optional)",
  "GITHUB$INSTRUCTIONS_LINK_TEXT": "click here for instructions",
  "GITHUB$LOADING_REPOSITORIES": "Loading repositories...",
  "GITHUB$MASTER_ACCOUNT_CONNECT_DESCRIPTION": "Connect the GitHub account that owns or manages your repositories.",
  "GITHUB$MASTER_ACCOUNT_DESCRIPTION": "The connected master account is used to access your organization's repositories.",
  "GITHUB$MASTER_ACCOUNT_LOAD_ERROR": "The connected GitHub account could not be loaded. Reconnect it to continue.",
  "GITHUB$MASTER_ACCOUNT_NOT_CONNECTED": "No GitHub master account connected",
  "GITHUB$NO_RESULTS": "No results found.",
  "GITHUB$OAUTH_CALLBACK_FAILED": "The team GitHub account could not be connected. Try the first step again.",
  "GITHUB$PILOT_BOT": "Pilot Bot",
  "GITHUB$PILOT_BOT_DESCRIPTION": "Pilot creates branches and pull requests using this GitHub App. The connected master account is used when the bot is not installed.",
  "GITHUB$PILOT_BOT_INSTALLED_ON": "Installed on @{{account}}",
  "GITHUB$PILOT_BOT_NAME": "Pilot",
  "GITHUB$PILOT_BOT_NOT_CONNECTED": "Not installed",
  "GITHUB$PUBLIC_REPOS": "Public Repos",
  "GITHUB$RECONNECT": "Reconnect",
  "GITHUB$START_FROM_SCRATCH": "Start from scratch",
  "GITHUB$TOKEN_HELP_TEXT": "Get your <0>GitHub token</0> or <1>click here for instructions</1>",
  "GITHUB$TOKEN_INVALID": "Invalid GitHub token",
  "GITHUB$TOKEN_LABEL": "GitHub Token",
  "GITHUB$TOKEN_LINK_TEXT": "GitHub token",
  "GITHUB$TOKEN_OPTIONAL": "GitHub Token (Optional)",
  "GITHUB$YOUR_REPOS": "Your Repos",
  "GITLAB$CONNECT_TO_GITLAB": "Log in with GitLab",
  "GITLAB$GET_TOKEN": "Generate a token on",
  "GITLAB$HOST_LABEL": "GitLab Host (optional)",
  "GITLAB$INSTRUCTIONS_LINK_TEXT": "click here for instructions",
  "GITLAB$OR_SEE": "or see the",
  "GITLAB$TOKEN_HELP_TEXT": "Get your <0>GitLab token</0> or <1>click here for instructions</1>",
  "GITLAB$TOKEN_LABEL": "GitLab Token",
  "GITLAB$TOKEN_LINK_TEXT": "GitLab token",
  "GITLAB$WEBHOOK_COLUMN_ACTION": "Action",
  "GITLAB$WEBHOOK_COLUMN_RESOURCE": "Resource",
  "GITLAB$WEBHOOK_COLUMN_STATUS": "Status",
  "GITLAB$WEBHOOK_COLUMN_TYPE": "Type",
  "GITLAB$WEBHOOK_MANAGER_DESCRIPTION": "Manage webhooks for your GitLab projects and groups. Webhooks enable OpenHands to receive notifications from GitLab. Note: If a webhook is already installed, you must first delete it through the GitLab UI before reinstalling.",
  "GITLAB$WEBHOOK_MANAGER_ERROR": "Failed to load resources. Please try again.",
  "GITLAB$WEBHOOK_MANAGER_LOADING": "Loading resources...",
  "GITLAB$WEBHOOK_MANAGER_NO_RESOURCES": "No projects or groups found where you have admin access.",
  "GITLAB$WEBHOOK_MANAGER_TITLE": "Webhook Management",
  "GITLAB$WEBHOOK_REINSTALL": "Reinstall",
  "GITLAB$WEBHOOK_REINSTALLING": "Reinstalling...",
  "GITLAB$WEBHOOK_REINSTALL_FAILED": "Failed to reinstall webhook",
  "GITLAB$WEBHOOK_REINSTALL_SUCCESS": "Webhook reinstalled successfully",
  "GITLAB$WEBHOOK_STATUS_FAILED": "Failed",
  "GITLAB$WEBHOOK_STATUS_INSTALLED": "Installed",
  "GITLAB$WEBHOOK_STATUS_NOT_INSTALLED": "Not Installed",
  "GOAL$MISSING": "Missing: {{missing}}",
  "GOAL$OBJECTIVE_REQUIRED": "Please provide an objective — e.g. /goal <objective>",
  "GOAL$PREFIX": "Goal:",
  "GOAL$RESUME": "Resume",
  "GOAL$RESUME_FAILED": "Failed to resume the goal loop",
  "GOAL$ROUND": "Round {{iteration}}/{{max}}",
  "GOAL$SCORE": "score {{score}}%",
  "GOAL$START_FAILED": "Failed to start the goal loop",
  "GOAL$STATUS_CAPPED": "capped",
  "GOAL$STATUS_COMPLETE": "complete",
  "GOAL$STATUS_INTERRUPTED": "interrupted",
  "GOAL$STATUS_RUNNING": "running",
  "GOAL$STOP": "Stop",
  "GOAL$STOP_FAILED": "Failed to stop the goal loop",
  "HOME$ADD_ALL_SUBDIRECTORIES": "Add all subdirectories",
  "HOME$ADD_FILES_OR_PHOTOS": "Add files or photos",
  "HOME$ADD_GITHUB_REPOS": "+ Add GitHub Repos",
  "HOME$ADD_THIS_DIRECTORY": "Add this directory",
  "HOME$ADD_WORKSPACES": "Add Workspace",
  "HOME$ADD_WORKSPACES_TITLE": "Add workspaces",
  "HOME$AUTOMATIONS_OVERVIEW": "Automations",
  "HOME$AUTOMATIONS_VIEW_ALL": "View all",
  "HOME$AUTOMATION_CONSECUTIVE_FAILURES": "Failed {{count}} times in a row",
  "HOME$AUTOMATION_LAST_RUN_FAILED": "Last run failed",
  "HOME$AUTOMATION_LAST_RUN_SUCCEEDED": "Last run succeeded",
  "HOME$AUTOMATION_NEVER_RUN": "Not run yet",
  "HOME$AUTOMATION_RECENT_RUNS": "Recent runs",
  "HOME$AUTOMATION_RUN_IN_PROGRESS": "Running now",
  "HOME$CANCEL": "Cancel",
  "HOME$CONNECT_TO_REPOSITORY": "Connect to a Repository",
  "HOME$CONNECT_TO_REPOSITORY_TOOLTIP": "You can enter a public GitHub URL if you'd like to work from a public repo instead",
  "HOME$CREATING_CONVERSATION": "Creating conversation…",
  "HOME$DONE": "Done",
  "HOME$FAILED_TO_LOAD_BRANCHES": "Failed to load branches",
  "HOME$FAILED_TO_LOAD_REPOSITORIES": "Failed to load repositories",
  "HOME$FAVORITES": "Favorites",
  "HOME$FIX_FAILING_CHECKS": "Fix failing checks",
  "HOME$FOLDER": "Folder",
  "HOME$GUIDE_MESSAGE_TITLE": "New around here? Not sure where to start?",
  "HOME$HOST_HOME_NOT_MOUNTED_HINT": "The agent server cannot access this directory. Check that the path exists and is readable.",
  "HOME$KIND": "Kind",
  "HOME$LAUNCH": "Launch",
  "HOME$LAUNCH_FROM_SCRATCH": "Launch from Scratch",
  "HOME$LETS_START_BUILDING": "Let's Start Building!",
  "HOME$LOADING": "Loading...",
  "HOME$LOADING_BRANCHES": "Loading branches...",
  "HOME$LOADING_MORE_REPOSITORIES": "Loading more repositories...",
  "HOME$LOADING_REPOSITORIES": "Loading repositories...",
  "HOME$LOCATIONS": "Locations",
  "HOME$MANAGE_PROJECTS": "Manage projects",
  "HOME$MANAGE_WORKSPACES": "Manage Workspaces",
  "HOME$MANAGE_WORKSPACES_EMPTY": "You don't have any workspaces yet.",
  "HOME$NAME": "Name",
  "HOME$NEW_PROJECT_DESCRIPTION": "Start a new conversation that is not connected to an existing repository.",
  "HOME$NOT_SURE_HOW_TO_START": "Not sure how to start?",
  "HOME$NO_REPOSITORY_FOUND": "No repository found to launch conversation",
  "HOME$NO_WORKSPACES": "No workspaces yet",
  "HOME$NO_WORKSPACE_OPTION": "No workspace",
  "HOME$OPENHANDS_DESCRIPTION": "OpenHands makes it easy to build and maintain software using AI-driven development.",
  "HOME$OPEN_ISSUE": "Open issue",
  "HOME$OPEN_WORKSPACE": "Open Workspace",
  "HOME$PILOT_IS_READY": "Pilot is ready",
  "HOME$PILOT_READY_DESCRIPTION": "A master engineer that already knows everything inside your company.",
  "HOME$PREVIEW_REPOSITORIES": "Open a workspace",
  "HOME$PREVIEW_REPOSITORIES_HINT": "starts a sandbox on the repository, no question needed",
  "HOME$PREVIEW_REPOSITORY_OPENING": "Opening…",
  "HOME$PREVIEW_REPOSITORY_OPEN_LABEL": "Open a sandbox on {{repository}}",
  "HOME$PREVIEW_REPOSITORY_READY": "Preview ready",
  "HOME$READ_THIS": "Read this",
  "HOME$REMOVE_WORKSPACE": "Remove",
  "HOME$REMOVE_WORKSPACE_CONFIRMATION": "Remove \"{{name}}\" from your saved workspaces?",
  "HOME$REMOVE_WORKSPACE_PARENT": "Remove parent",
  "HOME$REMOVE_WORKSPACE_PARENT_CONFIRMATION": "Remove \"{{name}}\" and its {{count}} child workspaces?",
  "HOME$REPOSITORIES_TAB": "Repositories",
  "HOME$RESOLVE_MERGE_CONFLICTS": "Resolve merge conflicts",
  "HOME$RESOLVE_UNRESOLVED_COMMENTS": "Resolve unresolved comments",
  "HOME$SEARCHING_REPOSITORIES": "Searching repositories...",
  "HOME$SELECT_OR_INSERT_URL": "Select or insert a URL",
  "HOME$START_FROM_PROJECT": "Start from project?",
  "HOME$USE_THIS_FOLDER": "Use this folder",
  "HOME$WEB_SEARCH": "Web Search",
  "HOME$WHAT_DO_YOU_NEED": "What do you need?",
  "HOME$WORKSPACES_TAB": "Workspaces",
  "HOME$WORKSPACES_UNSUPPORTED_AGENT_SERVER": "Workspaces are supported only for agent-server {{requiredVersion}} or higher. This backend is running {{actualVersion}}. Please upgrade your agent-server backend to the latest version.",
  "HOME$WORKSPACES_UNSUPPORTED_PLACEHOLDER": "Upgrade agent-server to use workspaces",
  "HOME$WORKSPACE_GROUP_OTHER": "Other",
  "HOME$WORKSPACE_PARENTS": "Workspace parents",
  "HOME$WORKSPACE_PLACEHOLDER": "Select a workspace",
  "HOME$WORKSPACE_SCAN_ERROR": "Some workspace folders could not be loaded.",
  "HOOK$BLOCKED_REASON": "Blocked reason",
  "HOOK$COMMAND": "Command",
  "HOOK$CONTEXT": "Context",
  "HOOK$ERROR": "Error",
  "HOOK$EXIT_CODE": "Exit code",
  "HOOK$HOOK_LABEL": "Hook",
  "HOOK$OUTPUT": "Output",
  "HOOK$STDERR": "Stderr",
  "HOOKS_MODAL$ASYNC": "Async",
  "HOOKS_MODAL$COMMANDS": "Commands",
  "HOOKS_MODAL$EVENT_POST_TOOL_USE": "Post Tool Use",
  "HOOKS_MODAL$EVENT_PRE_TOOL_USE": "Pre Tool Use",
  "HOOKS_MODAL$EVENT_SESSION_END": "Session End",
  "HOOKS_MODAL$EVENT_SESSION_START": "Session Start",
  "HOOKS_MODAL$EVENT_STOP": "Stop",
  "HOOKS_MODAL$EVENT_USER_PROMPT_SUBMIT": "User Prompt Submit",
  "HOOKS_MODAL$HOOK_COUNT": "{{count}} hook(s)",
  "HOOKS_MODAL$HOOK_COUNT_one": "{{count}} hook",
  "HOOKS_MODAL$HOOK_COUNT_other": "{{count}} hooks",
  "HOOKS_MODAL$MATCHER": "Matcher",
  "HOOKS_MODAL$TIMEOUT": "Timeout: {{timeout}}s",
  "HOOKS_MODAL$TITLE": "Available Hooks",
  "HOOKS_MODAL$TYPE": "Type: {{type}}",
  "HOOKS_MODAL$WARNING": "Hooks are loaded from your workspace. This view refreshes on demand and may differ from the hooks that were active when the conversation started. Stop and restart the conversation to apply changes.",
  "INCREASE_TEST_COVERAGE": "Increase test coverage",
  "INVARIANT$ASK_CONFIRMATION_RISK_SEVERITY_LABEL": "Ask for user confirmation on risk severity:",
  "INVARIANT$CLICK_TO_LEARN_MORE_LABEL": "Click to learn more",
  "INVARIANT$DONT_ASK_FOR_CONFIRMATION_LABEL": "Don't ask for confirmation",
  "INVARIANT$EXPORT_TRACE_LABEL": "Export Trace",
  "INVARIANT$INVARIANT_ANALYZER_LABEL": "Invariant Analyzer",
  "INVARIANT$INVARIANT_ANALYZER_MESSAGE": "Invariant Analyzer continuously monitors your OpenHands agent for security issues.",
  "INVARIANT$LOG_LABEL": "Logs",
  "INVARIANT$POLICY_LABEL": "Policy",
  "INVARIANT$POLICY_UPDATED_MESSAGE": "Policy updated",
  "INVARIANT$SETTINGS_LABEL": "Settings",
  "INVARIANT$SETTINGS_UPDATED_MESSAGE": "Settings updated",
  "INVARIANT$TRACE_EXPORTED_MESSAGE": "Trace exported",
  "INVARIANT$UPDATE_POLICY_LABEL": "Update Policy",
  "INVARIANT$UPDATE_SETTINGS_LABEL": "Update Settings",
  "JUPYTER$OUTPUT_LABEL": "STDOUT/STDERR",
  "LANDING$ATTACH_IMAGES": "Attach images",
  "LANDING$CHANGE_PROMPT": "What would you like to change in {{repo}}?",
  "LANDING$OPEN_REPO": "Open a Repo",
  "LANDING$OR": "Or",
  "LANDING$REPLAY": "+ Replay Trajectory",
  "LANDING$SELECT_GIT_REPO": "Select a Git project",
  "LANDING$START_HELP": "Not sure how to start?",
  "LANDING$START_HELP_LINK": "Read this",
  "LANDING$SUBTITLE": "OpenHands makes it easy to build and maintain software using a simple prompt.",
  "LANDING$TITLE": "Let's start building!",
  "LANDING$UPLOAD_TRAJECTORY": "Upload a .json",
  "LANGUAGE$LABEL": "Language",
  "LAUNCH$ADDITIONAL_PLUGINS": "Additional Plugins",
  "LAUNCH$ERROR_CREATION_FAILED": "Failed to Start Conversation",
  "LAUNCH$ERROR_CREATION_UNKNOWN": "An unexpected error occurred while starting the conversation. Please try again.",
  "LAUNCH$ERROR_INVALID_FORMAT": "The plugin configuration is invalid. Please check the URL and try again.",
  "LAUNCH$ERROR_NO_PLUGINS": "No plugins were specified. Please provide at least one plugin to launch.",
  "LAUNCH$ERROR_TITLE": "Unable to Launch",
  "LAUNCH$GO_HOME": "Go Home",
  "LAUNCH$MODAL_TITLE": "Launch",
  "LAUNCH$MODAL_TITLE_GENERIC": "Launch Plugin",
  "LAUNCH$PLUGINS": "Plugins",
  "LAUNCH$PLUGIN_PATH": "path:",
  "LAUNCH$PLUGIN_REF": "ref:",
  "LAUNCH$STARTING": "Starting...",
  "LAUNCH$START_CONVERSATION": "Start Conversation",
  "LAUNCH$TRUST_SKILL_CHECKBOX": "I trust this skill from {{sources}} with the agent secrets defined in my account.",
  "LAUNCH$TRY_AGAIN": "Try Again",
  "LINK_PREVIEW$PR_DRAFT": "Draft",
  "LINK_PREVIEW$SLACK_DELETED_DESCRIPTION": "This message was deleted or is no longer available.",
  "LINK_PREVIEW$SLACK_DELETED_TITLE": "Deleted Slack message",
  "LLM$MODEL": "LLM Model",
  "LLM$PROVIDER": "LLM Provider",
  "LLM$SELECT_MODEL_PLACEHOLDER": "Select a model",
  "LLM$SELECT_PROVIDER_PLACEHOLDER": "Select a provider",
  "LOADING_PROJECT$LOADING": "Loading...",
  "LOAD_SESSION$MODAL_CONTENT": "You seem to have an ongoing session. Would you like to pick up where you left off, or start fresh?",
  "LOAD_SESSION$MODAL_TITLE": "Return to existing session?",
  "LOAD_SESSION$RESUME_SESSION_MODAL_ACTION_LABEL": "Resume Session",
  "LOAD_SESSION$START_NEW_SESSION_MODAL_ACTION_LABEL": "Start New Session",
  "MAINTENANCE$SCHEDULED_MESSAGE": "Scheduled maintenance will begin at {{time}}",
  "MCP$ADD_CUSTOM": "Add custom server",
  "MCP$ADD_CUSTOM_TITLE": "Add custom MCP server",
  "MCP$ALSO_SAVE_AS_SECRET": "Also save as secret",
  "MCP$COMMAND_LABEL": "Command",
  "MCP$CONNECTORS_TITLE": "Connectors",
  "MCP$CONNECTOR_CREDENTIAL_HELP": "Each credential points at an organization secret by name. The values themselves are stored under Settings → Secrets.",
  "MCP$DELETE_SERVER_ARIA": "Remove {{name}}",
  "MCP$EDIT_CUSTOM_TITLE": "Edit MCP server",
  "MCP$EDIT_SERVER_ARIA": "Edit {{name}}",
  "MCP$ERROR_FIELD_REQUIRED": "This field is required.",
  "MCP$HEALTH_CONNECTIVITY_ONLY_HINT": "This check only proves the server is reachable and lists its tools; it does not verify your credentials.",
  "MCP$HEALTH_REAUTHORIZE": "Re-authorize",
  "MCP$HEALTH_RETRY": "Retry",
  "MCP$HEALTH_STATUS_CHECKING": "Checking connection…",
  "MCP$HEALTH_STATUS_CONNECTIVITY_ONLY": "Reachable — credentials not verified",
  "MCP$HEALTH_STATUS_UNCHECKED": "Not checked yet",
  "MCP$HEALTH_STATUS_VERIFIED": "Connected — credentials verified ({{count}} tool(s))",
  "MCP$HEALTH_UPDATE_CREDENTIALS": "Update credentials",
  "MCP$INSTALLED_BADGE": "Installed",
  "MCP$INSTALLED_EMPTY_HINT": "Pick one from the marketplace below to get started.",
  "MCP$INSTALLED_EMPTY_TITLE": "No MCP servers installed yet.",
  "MCP$INSTALLED_TITLE": "Installed",
  "MCP$INSTALL_BUTTON": "Install",
  "MCP$INSTALL_SUCCESS": "MCP server saved.",
  "MCP$LIBRARY_TITLE": "Library",
  "MCP$MARKETPLACE_DESCRIPTION": "Well-known MCP servers, ready to install with a single click.",
  "MCP$MARKETPLACE_TITLE": "Marketplace",
  "MCP$OAUTH_CONNECT_HINT": "No API key needed. The server handles the OAuth flow automatically.",
  "MCP$OAUTH_CONNECT_INFO": "This server uses OAuth for authentication. Click Install to connect — you will be redirected to authorize access.",
  "MCP$PAGE_DESCRIPTION": "Add Model Context Protocol servers to expand what your agent can do. Click any server below to install it.",
  "MCP$REMOVE_SUCCESS": "MCP server removed.",
  "MCP$SAVE_AS_SECRET_TOOLTIP": "MCP credentials aren't shared with automations. Save as a secret to make this value available to automations.",
  "MCP$SEARCH_CLEAR": "Clear search",
  "MCP$SEARCH_EMPTY": "No matches for your search.",
  "MCP$SEARCH_INSTALLED_PLACEHOLDER": "Search installed",
  "MCP$SEARCH_PLACEHOLDER": "Search MCP servers",
  "MCP$SECRETS_SAVED": "Saved to secrets: {{keys}}",
  "MCP$SECRETS_SAVE_FAILED": "Failed to save secret: {{keys}}",
  "MCP$TEST_BUTTON": "Test connection",
  "MCP$TEST_ERROR_CONNECTION": "Could not reach the server. Check the URL and server type.",
  "MCP$TEST_ERROR_CREDENTIALS": "Credential check failed: {{-error}}",
  "MCP$TEST_ERROR_TIMEOUT": "Connection timed out. Check the URL and try again.",
  "MCP$TEST_ERROR_UNKNOWN": "Connection failed: {{-error}}",
  "MCP$TEST_SUCCESS": "Connected — {{count}} tool(s) available",
  "MCP$TOGGLE_ADD_SERVER": "Install server",
  "MCP$TOGGLE_DISABLE_SERVER": "Disable server",
  "MCP$TOGGLE_ENABLE_SERVER": "Enable server",
  "MCP$TOGGLE_REMOVE_SERVER": "Remove server",
  "MCP$TRANSPORT_BUILTIN": "Built-in",
  "MCP$VERIFYING": "Verifying…",
  "MCP$VIEW_DOCS": "View documentation →",
  "MCP_OBSERVATION$ARGUMENTS": "Arguments",
  "MCP_OBSERVATION$OUTPUT": "Output",
  "MICROAGENT$ADDING_CONTEXT": "OpenHands is adding this new context to your respository. We'll let you know when the pull request is ready.",
  "MICROAGENT$ADD_TO_MEMORY": "Add to Microagent Memory",
  "MICROAGENT$ADD_TO_MICROAGENT": "Add to Microagent",
  "MICROAGENT$ADD_TRIGGER": "Add a trigger for the microagent",
  "MICROAGENT$ADD_TRIGGERS": "Add triggers for the microagent",
  "MICROAGENT$CANCEL": "Cancel",
  "MICROAGENT$CONVERSATION_STARTING": "Starting conversation...",
  "MICROAGENT$DEFINITION": "Microagents are specialized prompts that enhance OpenHands with domain-specific knowledge. They provide expert guidance, automate common tasks, and ensure consistent practices across projects.",
  "MICROAGENT$DESCRIBE_WHAT_TO_ADD": "Describe what you want to add to the Microagent...",
  "MICROAGENT$LAUNCH": "Launch",
  "MICROAGENT$LOADING_PROMPT": "Loading prompt...",
  "MICROAGENT$NO_REPOSITORY_FOUND": "No repository found to launch microagent",
  "MICROAGENT$SELECT_FILE_OR_CUSTOM": "Select a microagent file or enter a custom value",
  "MICROAGENT$STATUS_COMPLETED": "View microagent update",
  "MICROAGENT$STATUS_CREATING": "Modifying microagent...",
  "MICROAGENT$STATUS_ERROR": "Microagent encountered an error",
  "MICROAGENT$STATUS_OPENING_PR": "Opening PR",
  "MICROAGENT$STATUS_WAITING": "Waiting for runtime to start...",
  "MICROAGENT$SUCCESS_PR_READY": "Success! Your microagent pull request is ready.",
  "MICROAGENT$TYPE_TRIGGER_SPACE": "Type a trigger and press Space to add it",
  "MICROAGENT$UNKNOWN_ERROR": "Unknown error, please try again",
  "MICROAGENT$VIEW_CONVERSATION": "View Conversation",
  "MICROAGENT$VIEW_YOUR_PR": "View your PR",
  "MICROAGENT$WAIT_FOR_RUNTIME": "Please wait for the runtime to be active.",
  "MICROAGENT$WHAT_TO_ADD": "What would you like to add to the Microagent?",
  "MICROAGENT$WHAT_TO_REMEMBER": "What would you like your microagent to remember?",
  "MICROAGENT$WHERE_TO_PUT": "Where should we put it?",
  "MICROAGENTS_MODAL$INPUTS": "Inputs",
  "MICROAGENTS_MODAL$TITLE": "Available Microagents",
  "MICROAGENTS_MODAL$TOOLS": "Tools",
  "MODAL$CLOSE_BUTTON_LABEL": "Close",
  "MODAL$CONFIRM_RESET_MESSAGE": "All information will be deleted",
  "MODAL$CONFIRM_RESET_TITLE": "Are you sure?",
  "MODAL$END_SESSION_MESSAGE": "Changing workspace settings will end the current session",
  "MODAL$END_SESSION_TITLE": "End Session",
  "MODEL$AVAILABLE_MODELS": "Available models",
  "MODEL$CUSTOM_MODEL": "Custom Model",
  "MODEL$LIST_FAILED": "Failed to list LLM profiles",
  "MODEL$OPEN_SETTINGS": "Open LLM settings",
  "MODEL$SWITCHED_TO_PROFILE": "Switched to profile <cmd>{{name}}</cmd>",
  "MODEL$SWITCH_FAILED": "Failed to switch to profile '{{name}}'",
  "MODEL_SELECTOR$OTHERS": "Other Models",
  "MODEL_SELECTOR$VERIFIED": "Verified Models",
  "NAV$COMING_SOON": "Coming Soon",
  "NAV$CUSTOMIZE": "Customize",
  "NAV$EXTENSIONS": "Extensions",
  "OBSERVATION$COMMAND_NO_OUTPUT": "[Command finished execution with no output]",
  "OBSERVATION$ERROR_PREFIX": "error:",
  "OBSERVATION$EXIT_CODE": "exit {{code}}",
  "OBSERVATION$MCP_NO_OUTPUT": "[MCP Tool finished execution with no output]",
  "OBSERVATION$TASK_TRACKING_NO_OUTPUT": "[Task tracking completed with no output]",
  "OBSERVATION_MESSAGE$BROWSE": "Browsing completed",
  "OBSERVATION_MESSAGE$CANVAS_UI": "Updated the workspace view",
  "OBSERVATION_MESSAGE$EDIT": "Edited <path>{{path}}</path>",
  "OBSERVATION_MESSAGE$GLOB": "Search files: <cmd>{{pattern}}</cmd>",
  "OBSERVATION_MESSAGE$GREP": "Search in files: <cmd>{{pattern}}</cmd>",
  "OBSERVATION_MESSAGE$INVOKE_SKILL": "Invoked skill <cmd>{{name}}</cmd>",
  "OBSERVATION_MESSAGE$MCP": "MCP Tool Result: {{mcp_tool_name}}",
  "OBSERVATION_MESSAGE$READ": "Read <path>{{path}}</path>",
  "OBSERVATION_MESSAGE$RECALL": "Microagent ready",
  "OBSERVATION_MESSAGE$RUN": "Ran <cmd>{{command}}</cmd>",
  "OBSERVATION_MESSAGE$RUN_IPYTHON": "Ran a Python command",
  "OBSERVATION_MESSAGE$SKILL_READY": "Skill Ready",
  "OBSERVATION_MESSAGE$TASK": "Ran subagent <cmd>{{name}}</cmd>",
  "OBSERVATION_MESSAGE$TASK_TRACKING_PLAN": "Agent updated the plan",
  "OBSERVATION_MESSAGE$TASK_TRACKING_VIEW": "Agent checked the current plan",
  "OBSERVATION_MESSAGE$THINK": "Thought",
  "OBSERVATION_MESSAGE$WRITE": "Wrote to <path>{{path}}</path>",
  "ORGANIZATION$ALL_MEMBERS": "All organization members",
  "ORGANIZATION$MEMBERS_DESCRIPTION": "Users are automatically added as members when they sign in with their Chartmetric account.",
  "ORGANIZATION$MEMBERS_LOAD_ERROR": "Failed to load organization members.",
  "ORGANIZATION$MEMBER_COUNT": "members",
  "ORGANIZATION$MEMBER_EMAIL": "Email",
  "ORGANIZATION$MEMBER_JOINED": "Joined",
  "ORGANIZATION$MEMBER_NAME": "Name",
  "ORGANIZATION$MEMBER_ROLE": "Role",
  "ORGANIZATION$MEMBER_SAVE_ERROR": "Failed to save the organization member.",
  "ORGANIZATION$MEMBER_SAVE_SUCCESS": "Organization member saved.",
  "ORGANIZATION$NO_MEMBERS": "This organization has no members.",
  "ORGANIZATION$NO_MEMBERS_MATCH_SEARCH": "No organization members match your search.",
  "ORGANIZATION$ROLE_ADMIN": "Admin",
  "ORGANIZATION$ROLE_DEVELOPER": "Developer",
  "ORGANIZATION$ROLE_OWNER": "Owner",
  "ORGANIZATION$ROLE_PM": "PM",
  "ORGANIZATION$SEARCH_MEMBERS": "Search organization members",
  "ORGANIZATION$SEARCH_MEMBERS_PLACEHOLDER": "Search by name or email",
  "PLANNER$EMPTY_MESSAGE": "There is currently no plan for this repo",
  "PLANNING_AGENTT$PLANNING_AGENT_FAILED": "Couldn't start the planning agent",
  "PLANNING_AGENTT$PLANNING_AGENT_INITIALIZED": "Planning agent initialized",
  "PLUGINS$PICKER_DONE": "Done",
  "PLUGINS$PICKER_EMPTY": "No plugins available.",
  "PLUGINS$PICKER_ERROR": "Couldn't load plugins.",
  "PLUGINS$PICKER_LOADING": "Loading...",
  "PLUGINS$PICKER_SEARCH_PLACEHOLDER": "Search plugins by name, description, or source",
  "PLUGINS$PICKER_SELECTED_COUNT": "{{count}} selected",
  "PLUGINS$PICKER_SUBTITLE": "Select plugins to load when this conversation starts.",
  "PLUGINS$PICKER_TITLE": "Attach plugins",
  "PLUGINS$PICKER_TRIGGER": "Plugins",
  "PLUGINS_MODAL$DESCRIPTION": "Plugins explicitly attached when this conversation started.",
  "PLUGINS_MODAL$EMPTY": "No plugins attached to this conversation.",
  "PLUGINS_MODAL$SOURCE_LOCAL": "Local",
  "PLUGINS_MODAL$TITLE": "Plugins",
  "PROJECT$NEW_PROJECT": "New Project",
  "PROJECT_MENU_CARD$OPEN": "Open project menu",
  "PROJECT_MENU_CARD_CONTEXT_MENU$CONNECT_TO_GITHUB_LABEL": "Connect to GitHub",
  "PROJECT_MENU_CARD_CONTEXT_MENU$DOWNLOAD_FILES_LABEL": "Download files",
  "PROJECT_MENU_CARD_CONTEXT_MENU$PUSH_TO_GITHUB_LABEL": "Push to GitHub",
  "PROJECT_MENU_DETAILS$AGO_LABEL": "ago",
  "PROJECT_MENU_DETAILS_PLACEHOLDER$CONNECTED": "Connected",
  "PROJECT_MENU_DETAILS_PLACEHOLDER$CONNECT_TO_GITHUB": "Connect to GitHub",
  "PROJECT_MENU_DETAILS_PLACEHOLDER$NEW_PROJECT_LABEL": "New Project",
  "RECOMMENDED_AUTOMATIONS$ADD_MCP": "Add {{name}}",
  "RECOMMENDED_AUTOMATIONS$BETA_LABEL": "Beta",
  "RECOMMENDED_AUTOMATIONS$CONNECTED": "Connected",
  "RECOMMENDED_AUTOMATIONS$LAUNCHING": "Launching…",
  "RECOMMENDED_AUTOMATIONS$LAUNCH_CONVERSATION": "Launch conversation",
  "RECOMMENDED_AUTOMATIONS$MINUTES": "{{count}} min",
  "RECOMMENDED_AUTOMATIONS$MISSING_CONNECT": "{{count}} MCPs to connect before launch",
  "RECOMMENDED_AUTOMATIONS$MODAL_AGENT_PROMPT": "Agent prompt",
  "RECOMMENDED_AUTOMATIONS$MODAL_CLOSE_ARIA": "Close recommended automation setup",
  "RECOMMENDED_AUTOMATIONS$MODAL_EXAMPLE_IMPLEMENTATION": "Example implementation sketch",
  "RECOMMENDED_AUTOMATIONS$MODAL_REQUIRED_MCPS": "Required MCPs",
  "RECOMMENDED_AUTOMATIONS$MODAL_REQUIRED_MCPS_DESCRIPTION": "Connect every MCP below, then OpenHands will launch a conversation with the prompt on the left.",
  "RECOMMENDED_AUTOMATIONS$NEEDS_SETUP": "Needs setup",
  "RECOMMENDED_AUTOMATIONS$POPULARITY_SORTED": "Popularity sorted",
  "RECOMMENDED_AUTOMATIONS$REQUIRED_REMAINING": "{{count}} required MCPs remaining.",
  "RECOMMENDED_AUTOMATIONS$SECTION_DESCRIPTION": "Each template bundles an agent prompt, an implementation sketch, and the MCPs needed to make it useful. Pick one to open a pre-filled conversation and finish the details with the agent.",
  "RECOMMENDED_AUTOMATIONS$SECTION_LABEL": "Recommended automations",
  "RECOMMENDED_AUTOMATIONS$SECTION_TITLE": "Start from a proven workflow",
  "REPOSITORIES$ACTION_REQUIRED": "Action required",
  "REPOSITORIES$ADD": "Add Repo",
  "REPOSITORIES$AST_CONTEXTS": "{{count}} AST/lexical contexts",
  "REPOSITORIES$AUTOMATIC_CONNECTED": "Automatic · Ready",
  "REPOSITORIES$AUTOMATIC_PENDING": "Automatic · Waiting",
  "REPOSITORIES$AUTOMATIC_PR_REVIEW": "Pilot Pull Request Review",
  "REPOSITORIES$AUTOMATIC_PR_REVIEW_DESCRIPTION": "Review every new non-draft pull request, including bot-authored ones, re-review each pushed head, and post one GitHub review with actionable inline comments. Runs on the control plane without opening a sandbox.",
  "REPOSITORIES$AUTO_REFRESH": "Auto-refreshing index status",
  "REPOSITORIES$AVAILABLE": "Available ({{count}})",
  "REPOSITORIES$BIND_MATCHING": "Connect {{count}} matching by name",
  "REPOSITORIES$BIND_MATCHING_FAILED": "Some values could not be connected. The ones that succeeded are saved — try the rest again.",
  "REPOSITORIES$CONFIGURED": "Configured",
  "REPOSITORIES$CONFIGURE_AGENT": "Configure with Agent",
  "REPOSITORIES$CONFIG_REQUIRED": "Configuration required: some runtime requirements are not ready.",
  "REPOSITORIES$CONNECT": "Connect",
  "REPOSITORIES$CONNECTED": "Connected ({{count}})",
  "REPOSITORIES$CONNECTED_LABEL": "Connected",
  "REPOSITORIES$CONNECT_WITH_AGENT": "Connect with Agent",
  "REPOSITORIES$CONTEXT": "Repository context",
  "REPOSITORIES$CONTEXTS": "{{count}} contexts",
  "REPOSITORIES$CREATE_SECRET": "Create secret",
  "REPOSITORIES$DEFAULT_VARIANT": "Primary",
  "REPOSITORIES$DEPENDENCY_COUNT": "{{count}} local service dependencies",
  "REPOSITORIES$DESCRIPTION": "Connected repositories become available to the Agent as soon as indexing finishes. Repositories that need runtime configuration or secrets are clearly flagged.",
  "REPOSITORIES$DETAILS_TABS": "Repository sections",
  "REPOSITORIES$DISABLED": "Disabled",
  "REPOSITORIES$DISCONNECT": "Disconnect",
  "REPOSITORIES$EDIT": "Edit",
  "REPOSITORIES$EDIT_TITLE": "Edit repository",
  "REPOSITORIES$ENABLED": "Enabled",
  "REPOSITORIES$ENV_TARGET": "Environment variable: {{target}}",
  "REPOSITORIES$FILES": "{{count}} files",
  "REPOSITORIES$FILE_TARGET": "File: {{target}}",
  "REPOSITORIES$FILTER": "Filter organization repositories",
  "REPOSITORIES$HEALTH_CHECK": "Health check",
  "REPOSITORIES$IMPROVE_PR_REVIEW": "Improve this review?",
  "REPOSITORIES$IMPROVE_PR_REVIEW_INTRO": "If automatic review feedback seems incorrect or irrelevant to this repository, teach the reviewer to do better. Guidance lives here instead of in each GitHub review body.",
  "REPOSITORIES$IMPROVE_PR_REVIEW_RESOLVE": "To drive a PR through CI, review, and QA with an agent, install the iterate skill and run /iterate until the PR is merge-ready.",
  "REPOSITORIES$IMPROVE_PR_REVIEW_STEP_1": "Add a .agents/skills/custom-codereview-guide.md file to your branch (or edit it if one already exists) with the /codereview trigger and the context the reviewer is missing (for example, \"Security concerns about X do not apply here because Y\").",
  "REPOSITORIES$IMPROVE_PR_REVIEW_STEP_2": "Re-request a review. The reviewer reads guidelines from the PR branch, so your changes take effect immediately.",
  "REPOSITORIES$IMPROVE_PR_REVIEW_STEP_3": "When your PR is merged, the guideline file goes through normal code review by repository maintainers.",
  "REPOSITORIES$INDEXING": "Indexing",
  "REPOSITORIES$INDEX_FAILED": "Index Failed",
  "REPOSITORIES$INVALID_JSON": "Enter valid JSON before saving.",
  "REPOSITORIES$JSON_PLACEHOLDER": "Enter valid JSON",
  "REPOSITORIES$LAST_INDEXED_WITH_FILES": "Last indexed {{time}} · {{count}} files",
  "REPOSITORIES$LOAD_MORE": "Load more repositories",
  "REPOSITORIES$MAKE_DEFAULT_VARIANT": "Set as Default",
  "REPOSITORIES$MANIFEST_PROBLEMS": "Problems with this preview configuration",
  "REPOSITORIES$MEMORY": "Repository memory",
  "REPOSITORIES$MEMORY_DELETE": "Delete memory",
  "REPOSITORIES$MEMORY_DELETING": "Deleting…",
  "REPOSITORIES$MEMORY_DESCRIPTION": "What earlier runs worked out about this repository. It is given to every run here before it starts.",
  "REPOSITORIES$MEMORY_EMPTY": "Nothing recorded yet. It is written after runs finish in this repository.",
  "REPOSITORIES$NAME": "Name (Repository)",
  "REPOSITORIES$NOT_CONFIGURED": "Not configured",
  "REPOSITORIES$NOT_INDEXED": "Connect this repository to index it. Runtime and wiki settings appear afterward.",
  "REPOSITORIES$NOT_SELECTED": "Not selected",
  "REPOSITORIES$NO_CONTEXT": "No matching context found.",
  "REPOSITORIES$NO_SECRET_KEYS": "No secret keys required.",
  "REPOSITORIES$OPTIONAL": "Optional",
  "REPOSITORIES$PENDING": "Pending",
  "REPOSITORIES$PORT": "Port",
  "REPOSITORIES$PREVIEW": "Preview",
  "REPOSITORIES$DEV_SERVER": "Dev server",
  "REPOSITORIES$PREVIEW_TOOLTIP": "Preview setup must be complete to debug through the cloud from the Agent screen.",
  "REPOSITORIES$PROFILE_PENDING": "Configure and validate this repository to enable its runtime.",
  "REPOSITORIES$QUICK_OPEN": "Quick open",
  "REPOSITORIES$QUICK_OPEN_DESCRIPTION": "Start conversations for this repository from a memory snapshot, so the development server is already compiled instead of starting cold. Falls back to the existing start path whenever no compatible snapshot is available.",
  "REPOSITORIES$QUICK_OPEN_ERROR": "Could not update quick open",
  "REPOSITORIES$QUICK_OPEN_NEEDS_RUNTIME": "Available after runtime setup; its snapshot is built from that setup.",
  "REPOSITORIES$QUICK_OPEN_SAVED": "Quick open updated",
  "REPOSITORIES$REQUIRED": "Required",
  "REPOSITORIES$RESERVED_SANDBOXES": "Reserved",
  "REPOSITORIES$RESERVED_SANDBOXES_CLAMPED": "Requested {{requested}}, keeping {{effective}}.",
  "REPOSITORIES$RESERVED_SANDBOXES_DESCRIPTION": "Keep this many prepared workspaces standing for this repository, so opening a conversation finds one instead of building it. Each one holds a host slot while it waits.",
  "REPOSITORIES$RESERVED_SANDBOXES_ERROR": "Could not update reserved sandboxes",
  "REPOSITORIES$RESERVED_SANDBOXES_NEEDS_RUNTIME": "Available after runtime setup; standby workspaces use that setup.",
  "REPOSITORIES$RESERVED_SANDBOXES_SAVED": "Reserved sandboxes updated",
  "REPOSITORIES$RUNTIME": "Runtime: {{runtime}}",
  "REPOSITORIES$RUNTIME_LABEL": "Runtime",
  "REPOSITORIES$RUNTIME_PROFILE": "Runtime setup",
  "REPOSITORIES$RUNTIME_VARIANTS": "Variants",
  "REPOSITORIES$SANDBOX_STARTUP": "Sandbox setup",
  "REPOSITORIES$SANDBOX_STARTUP_DESCRIPTION": "Choose one warm-start strategy. Quick open restores a memory snapshot without holding a host slot. Live standby keeps ready workspaces in host slots and turns Quick open off.",
  "REPOSITORIES$SANDBOX_STARTUP_NEEDS_RUNTIME": "Available after runtime setup.",
  "REPOSITORIES$SAVE": "Save",
  "REPOSITORIES$SEARCH_CONTEXT": "Search indexed context",
  "REPOSITORIES$SECRETS_REQUIRED": "Secrets Required",
  "REPOSITORIES$SECRET_KEYS": "Secret Keys",
  "REPOSITORIES$SECRET_NAME": "Name",
  "REPOSITORIES$SECRET_NOTICE": "Stored directly in the encrypted database. The Agent cannot read this value.",
  "REPOSITORIES$SELECT": "Select a repository to inspect its context.",
  "REPOSITORIES$SELECTED_SOURCE": "Selected source",
  "REPOSITORIES$SELECT_SECRET": "Select an existing organization secret",
  "REPOSITORIES$SELECT_VALUE": "Select a value",
  "REPOSITORIES$SERVICE_CONNECTION": "Automatically connects to {{service}} in {{repository}}.",
  "REPOSITORIES$SERVICE_FALLBACK_HELP": "When {{repository}} is not in the workspace, this points at the address below instead.",
  "REPOSITORIES$SERVICE_FALLBACK_LABEL": "Deployed address",
  "REPOSITORIES$SETUP_COMMANDS": "Setup commands",
  "REPOSITORIES$SETUP_PROGRESS": "Setup",
  "REPOSITORIES$SETUP_PROGRESS_COUNT": "{{completed}} of {{total}} steps done",
  "REPOSITORIES$SETUP_REQUIRED": "Setup Required",
  "REPOSITORIES$START_COMMAND": "Start command",
  "REPOSITORIES$STATUS_CONNECTED": "Connected",
  "REPOSITORIES$STATUS_INDEXING": "Indexing",
  "REPOSITORIES$STATUS_NOT_CONNECTED": "Not connected",
  "REPOSITORIES$STATUS_PREPARING": "Preparing",
  "REPOSITORIES$STATUS_READY": "Ready",
  "REPOSITORIES$STAY_WARM": "Connected repositories",
  "REPOSITORIES$STEP_INDEX": "Read the source",
  "REPOSITORIES$STEP_INDEX_DONE": "{{count}} files indexed",
  "REPOSITORIES$STEP_INDEX_FAILED": "Indexing failed",
  "REPOSITORIES$STEP_INDEX_RUNNING": "{{processed}} of {{total}} files",
  "REPOSITORIES$STEP_PROFILE": "Decide how it runs",
  "REPOSITORIES$STEP_PROFILE_BLOCKED": "The agent has to propose one",
  "REPOSITORIES$STEP_PROFILE_DONE": "Start command and health check set",
  "REPOSITORIES$STEP_PROFILE_WAITING": "Needs the index first",
  "REPOSITORIES$STEP_READY": "Ready to use",
  "REPOSITORIES$STEP_READY_DONE": "Sessions can start and preview it",
  "REPOSITORIES$STEP_READY_WAITING": "Finish the steps above",
  "REPOSITORIES$STEP_STATUS_ACTIVE": "In progress",
  "REPOSITORIES$STEP_STATUS_BLOCKED": "Your turn",
  "REPOSITORIES$STEP_STATUS_DONE": "Done",
  "REPOSITORIES$STEP_STATUS_FAILED": "Failed",
  "REPOSITORIES$STEP_STATUS_WAITING": "Waiting",
  "REPOSITORIES$STEP_VALUES": "Connect its values",
  "REPOSITORIES$STEP_VALUES_COUNT": "{{configured}} of {{total}} required values connected",
  "REPOSITORIES$STEP_VALUES_COUNT_IN": "{{configured}} of {{total}} required values connected for {{variant}}",
  "REPOSITORIES$STEP_VALUES_NONE": "It needs no values",
  "REPOSITORIES$STEP_VALUES_WAITING": "Known once runtime is configured",
  "REPOSITORIES$SUMMARY": "{{files}} files · {{contexts}} AST/lexical contexts",
  "REPOSITORIES$TAB_GENERAL": "General",
  "REPOSITORIES$TAB_MEMORY": "Memory",
  "REPOSITORIES$TAB_PROFILE": "Runtime",
  "REPOSITORIES$TAB_WIKI": "Wiki",
  "REPOSITORIES$TARGET": "Target",
  "REPOSITORIES$TEAM_SECRET": "Organization secret",
  "REPOSITORIES$TOAST_ACTION_REQUIRED": "{{repository}} needs your input.",
  "REPOSITORIES$TOAST_INDEXING": "Indexing {{repository}} started.",
  "REPOSITORIES$TOAST_READY": "{{repository}} is ready.",
  "REPOSITORIES$VALUE": "Value",
  "REPOSITORIES$VALUE_INHERITED": "Shared by every environment — saving here sets it for this one only",
  "REPOSITORIES$VARIANT_DESCRIPTION_EMPTY": "No description",
  "REPOSITORIES$VARIANT_DESCRIPTION_LABEL": "Purpose",
  "REPOSITORIES$VARIANT_NEEDS_CONFIG": "Needs configuration",
  "REPOSITORIES$VARIANT_PREFERS_REPOSITORIES": "Uses {{repositories}} when checked out alongside it, and the configured address otherwise.",
  "REPOSITORIES$VARIANT_REQUIRES_REPOSITORIES": "Runs with {{repositories}} checked out alongside it.",
  "REPOSITORIES$WIKI": "Repository wiki",
  "REPOSITORIES$WIKI_ALIASES": "Also called",
  "REPOSITORIES$WIKI_CANCEL_EDIT": "Cancel",
  "REPOSITORIES$WIKI_DESCRIPTION": "Defines how Pilot identifies this repository and routes related requests.",
  "REPOSITORIES$WIKI_DETAILS": "Details",
  "REPOSITORIES$WIKI_EDIT": "Edit",
  "REPOSITORIES$WIKI_EDIT_HINT": "These fields are yours. Regenerating replaces the generated content above but never touches what you write here.",
  "REPOSITORIES$WIKI_EMPTY": "No wiki yet. It is generated after the repository is indexed.",
  "REPOSITORIES$WIKI_EXTERNAL_SYSTEMS": "External systems",
  "REPOSITORIES$WIKI_FAILED": "The last wiki generation failed",
  "REPOSITORIES$WIKI_KEY_PATHS": "Key paths",
  "REPOSITORIES$WIKI_NOTES": "Notes from your team",
  "REPOSITORIES$WIKI_NO_SUMMARY": "No summary yet.",
  "REPOSITORIES$WIKI_REFRESH": "Regenerate",
  "REPOSITORIES$WIKI_REFRESHING": "Regenerating...",
  "REPOSITORIES$WIKI_SAVE": "Save",
  "REPOSITORIES$WIKI_SAVE_FAILED": "Your changes were not saved.",
  "REPOSITORIES$WIKI_SECRET_PREFIXES": "Secret prefixes",
  "REPOSITORIES$WIKI_STACK": "Stack",
  "REPOSITORIES$WIKI_SUMMARY": "Summary",
  "REPOSITORIES$WIKI_SUMMARY_TOO_LONG": "Summary is {{count}} characters; the limit is {{max}}.",
  "REPOSITORIES$WRITE_ONLY_SECRETS": "Write-only runtime secrets",
  "REPOSITORY$SELECT_BRANCH": "Select a branch",
  "REPOSITORY$SELECT_REPO": "Select a repo",
  "REPOSITORY_CREATION$APPROVE": "Approve",
  "REPOSITORY_CREATION$CONFIRM_TITLE": "Create this repository?",
  "REPOSITORY_CREATION$DECLINE": "Decline",
  "REPOSITORY_CREATION$VISIBILITY_PRIVATE": "Private repository",
  "REPOSITORY_CREATION$VISIBILITY_PUBLIC": "Public repository",
  "REPOSITORY_SCOPE$AUTO": "Auto",
  "REPOSITORY_SCOPE$LABEL": "Repository scope",
  "REPOSITORY_SCOPE$REMOVE": "Remove {{repository}}",
  "RESPONDER_DEPLOYMENT$DESCRIPTION": "Slack and GitHub responders work best when they can listen for events continuously. You can run the responder locally, or connect OpenHands Cloud so it can keep responding even when your laptop is closed.",
  "RESPONDER_DEPLOYMENT$LOCAL_ACTION": "Continue with local setup",
  "RESPONDER_DEPLOYMENT$LOCAL_DESCRIPTION": "Keeps everything on your machine, but stops polling when your laptop is off.",
  "RESPONDER_DEPLOYMENT$LOCAL_TITLE": "Poll locally on your laptop",
  "RESPONDER_DEPLOYMENT$OPENHANDS_CLOUD_ACTION": "Open OpenHands Cloud integrations",
  "RESPONDER_DEPLOYMENT$OPENHANDS_CLOUD_DESCRIPTION": "Always responds even when your laptop is closed.",
  "RESPONDER_DEPLOYMENT$OPENHANDS_CLOUD_TITLE": "Use OpenHands Cloud",
  "RESPONDER_DEPLOYMENT$TITLE": "Choose how your responder should run",
  "RESPONSE_EVIDENCE$AUTHENTICATED": "credentials sent; authentication requirement unknown",
  "RESPONSE_EVIDENCE$TITLE": "API response",
  "RESPONSE_EVIDENCE$NO_RESPONSE": "no response",
  "RESPONSE_EVIDENCE$UNAUTHENTICATED": "no credentials sent; authentication requirement unknown",
  "ROADMAP$BACKLOG_FOUNDATION": "Builds on Organization-scoped PostgreSQL persistence, the GitHub integration, the pull request publication gate, and the durable validation workflow pinned to the delivered SHA. Missing: the work-item schema, the backlog UI, and the mapping from delivery events to item state.",
  "ROADMAP$BACKLOG_ITEMS_DESCRIPTION": "Durable items with assignee, priority, repository scope, and parent/child relations, readable and writable by the agent as well as by people.",
  "ROADMAP$BACKLOG_ITEMS_TITLE": "Organization-scoped work items",
  "ROADMAP$BACKLOG_NAV": "Delivery backlog",
  "ROADMAP$BACKLOG_PULL_REQUESTS_DESCRIPTION": "Each item links the conversations and pull requests that implement it and reflects review state, validation result, and merge status from the GitHub integration.",
  "ROADMAP$BACKLOG_PULL_REQUESTS_TITLE": "Pull request tracking",
  "ROADMAP$BACKLOG_STATUS_DESCRIPTION": "Publication, validation completion, review approval, and merge advance an item on their own, so the backlog reflects the delivered commit rather than someone's memory.",
  "ROADMAP$BACKLOG_STATUS_TITLE": "Status without manual updates",
  "ROADMAP$BACKLOG_SUMMARY": "An Asana-style backlog owned by the App Server, where every item carries its repository scope, its Pilot conversations, and its pull requests. Status moves from the delivery signals Pilot already receives — publication, validation, review, merge — instead of from manual updates.",
  "ROADMAP$BACKLOG_TITLE": "One backlog for work items and the pull requests that deliver them",
  "ROADMAP$DEPLOY_FOUNDATION": "Builds on the Sandbox Orchestrator, the authenticated preview proxy, and the SHA-pinned validation workflow. Missing: the provisioning layer, a separate AWS account boundary with a least-privilege role per project, and the promotion and rollback ledger. Broad administrative permissions on the existing production account stay out of scope.",
  "ROADMAP$DEPLOY_NAV": "Build and deploy",
  "ROADMAP$DEPLOY_PROMOTION_DESCRIPTION": "Deployment targets an immutable delivered commit, records what was released, and keeps one rollback path per environment.",
  "ROADMAP$DEPLOY_PROMOTION_TITLE": "Promotion and rollback",
  "ROADMAP$DEPLOY_PROVISIONING_DESCRIPTION": "Infrastructure changes run as declarative plans that are diffed and approved before apply, inside a dedicated account boundary that holds only tagged, Pilot-owned resources.",
  "ROADMAP$DEPLOY_PROVISIONING_TITLE": "Bounded infrastructure provisioning",
  "ROADMAP$DEPLOY_SCAFFOLD_DESCRIPTION": "A new project starts from a template, runs inside its sandbox, and stays reachable through the authenticated preview proxy while it is still being built.",
  "ROADMAP$DEPLOY_SCAFFOLD_TITLE": "Scaffold and live preview",
  "ROADMAP$DEPLOY_SUMMARY": "Pilot creates a new application, provisions the infrastructure it needs, and deploys it to a shareable environment in one flow — the Replit experience on Chartmetric-owned AWS, with every privileged action bounded by an approved plan, scoped credentials, and an auditable trail.",
  "ROADMAP$DEPLOY_TITLE": "From a prompt to a deployed product on our own AWS account",
  "ROADMAP$DOCUMENT_DESCRIPTION": "Planned Chartmetric Pilot capabilities that are not implemented yet. Each initiative states the outcome, the capabilities it needs, and the subsystems it builds on. Nothing on this page is a shipped feature or a delivery date; the Technical Architecture page remains the reference for what runs today.",
  "ROADMAP$FOUNDATION_LABEL": "What this builds on",
  "ROADMAP$MONITORING_CORRELATION_DESCRIPTION": "Signals that share a root cause join one incident, so a single investigation runs instead of one per alert, with severity and repository scope resolved before any sandbox starts.",
  "ROADMAP$MONITORING_CORRELATION_TITLE": "Correlation and triage",
  "ROADMAP$MONITORING_FOUNDATION": "Builds on the Automations subsystem, the durable App Server event log, and the Ask/Execution router that already exist. Missing: one connector per provider, the incident correlation store, and the escalation policy that decides when an incident may open an execution conversation.",
  "ROADMAP$MONITORING_NAV": "Ops monitoring",
  "ROADMAP$MONITORING_REMEDIATION_DESCRIPTION": "Each incident class maps to an automation that runs the read-only investigation first and escalates to sandbox execution only when a code or configuration change is actually required.",
  "ROADMAP$MONITORING_REMEDIATION_TITLE": "Automated remediation",
  "ROADMAP$MONITORING_SIGNALS_DESCRIPTION": "Organization-scoped connectors normalize Airflow task failures, Grafana alerts, AWS service events, Sentry issues, Stripe webhook failures, and custom error payloads into one durable incident record.",
  "ROADMAP$MONITORING_SIGNALS_TITLE": "Signal ingestion",
  "ROADMAP$MONITORING_SUMMARY": "Pilot watches Airflow, Grafana, AWS, Sentry, Stripe, and custom application error sources, joins repeated signals into one incident, and opens a conversation that reproduces the failure, investigates it, and publishes a pull request with evidence. Human approval stays on the merge rather than on each investigation step.",
  "ROADMAP$MONITORING_TITLE": "Monitoring and automated remediation across the operational stack",
  "ROADMAP$NAV_LABEL": "Roadmap document sections",
  "ROADMAP$NAV_TITLE": "Product roadmap",
  "ROADMAP$PAGE_TITLE": "Product Roadmap",
  "ROADMAP$QA_AUTHORING_DESCRIPTION": "A described journey becomes a committed test file with explicit selectors and assertions, reviewed as ordinary code instead of staying hidden in an agent transcript.",
  "ROADMAP$QA_AUTHORING_TITLE": "Scenarios authored from chat",
  "ROADMAP$QA_CREDENTIALS_DESCRIPTION": "Suites run against eligible test accounts through the sandbox-scoped lookup endpoint, so credential values never enter prompts or serialized agent context.",
  "ROADMAP$QA_CREDENTIALS_TITLE": "Credentialed runs",
  "ROADMAP$QA_FOUNDATION": "Builds on sandbox execution, the test-account subsystem with lazy lookup secrets, browser validation, and the artifact publication path that already validates and stores screenshots and video. Missing: suite-level persistence, change-triggered or scheduled re-runs, and a QA results view.",
  "ROADMAP$QA_NAV": "Conversational E2E QA",
  "ROADMAP$QA_REGRESSION_DESCRIPTION": "Suites are stored per repository, re-run on later changes, and report the failing step together with its screenshot and video evidence.",
  "ROADMAP$QA_REGRESSION_TITLE": "Durable regression suites",
  "ROADMAP$QA_SUMMARY": "Describe a user journey in chat and Pilot writes the runnable end-to-end test, executes it in an isolated sandbox against a test account, and publishes the final screenshot as evidence. Generated suites become durable regression coverage instead of one-off checks.",
  "ROADMAP$QA_TITLE": "End-to-end QA suites authored in conversation",
  "ROADMAP$READINESS_EXTENDS": "Extends shipped subsystems",
  "ROADMAP$READINESS_NEW": "Needs a new subsystem",
  "ROADMAP$SLACK_EVIDENCE_DESCRIPTION": "Slack findings enter the evidence contract as cited, low-trust context that must be corroborated against code, configuration, or data before being presented as current state.",
  "ROADMAP$SLACK_EVIDENCE_TITLE": "Cross-source evidence",
  "ROADMAP$SLACK_FOUNDATION": "Builds on the existing Slack integration with its DB-backed channel mappings and user-scoped OAuth, plus the lexical Organization-scoped repository index. Missing: durable message storage with retention and deletion handling, per-user visibility enforcement at query time, and the retrieval tool that exposes it to the agent.",
  "ROADMAP$SLACK_INGESTION_DESCRIPTION": "Channel history and threads sync incrementally into durable Organization-scoped storage, including edits and deletions, rather than being replayed only when a thread mentions Pilot.",
  "ROADMAP$SLACK_INGESTION_TITLE": "Continuous history ingestion",
  "ROADMAP$SLACK_NAV": "Slack knowledge base",
  "ROADMAP$SLACK_PERMISSIONS_DESCRIPTION": "Retrieval enforces each member's Slack visibility at query time; nobody receives content from a channel they cannot read, and direct and group messages stay out of scope.",
  "ROADMAP$SLACK_PERMISSIONS_TITLE": "Permission-aware retrieval",
  "ROADMAP$SLACK_SUMMARY": "Continuous ingestion of Slack conversations into an Organization-scoped, permission-aware store the agent can search, so questions about decisions, incidents, and context are answered from what the company actually said instead of from repository code alone.",
  "ROADMAP$SLACK_TITLE": "Organization knowledge from the full Slack history",
  "SCHEMA$AGENT$DESCRIPTION": "Agent class to use.",
  "SCHEMA$AGENT$LABEL": "Agent",
  "SCHEMA$AGENT_CONTEXT$LOAD_MEMORY$DESCRIPTION": "The agent keeps notes under .openhands/memory/ and loads them at the start of each new conversation, learning your codebase and preferences over time.",
  "SCHEMA$AGENT_CONTEXT$LOAD_MEMORY$LABEL": "Enable memory",
  "SCHEMA$AGENT_CONTEXT$SECTION_LABEL": "Agent Context",
  "SCHEMA$CONDENSER$ENABLED$DESCRIPTION": "Once a conversation grows past the token limit below, older turns are replaced by a summary so the prompt stops growing. Unrelated to agent memory.",
  "SCHEMA$CONDENSER$ENABLED$LABEL": "Compact long conversations",
  "SCHEMA$CONDENSER$MAX_SIZE$DESCRIPTION": "Maximum number of events kept before the condenser runs.",
  "SCHEMA$CONDENSER$MAX_SIZE$LABEL": "Compact after this many events",
  "SCHEMA$CONDENSER$MAX_TOKENS$DESCRIPTION": "Compact when the conversation exceeds this many tokens. Values above 150,000 are capped at 150,000.",
  "SCHEMA$CONDENSER$MAX_TOKENS$LABEL": "Compact after this many tokens",
  "SCHEMA$CONDENSER$SECTION_LABEL": "Conversation history",
  "SCHEMA$CONFIRMATION_MODE$DESCRIPTION": "Require user confirmation before executing risky actions.",
  "SCHEMA$CONFIRMATION_MODE$LABEL": "Confirmation Mode",
  "SCHEMA$ENABLE_SUB_AGENTS$DESCRIPTION": "Enable sub-agent delegation via TaskToolSet.",
  "SCHEMA$ENABLE_SUB_AGENTS$LABEL": "Enable sub-agents",
  "SCHEMA$GENERAL$SECTION_LABEL": "General",
  "SCHEMA$LLM$API_KEY$DESCRIPTION": "API key for authenticating with the LLM provider.",
  "SCHEMA$LLM$API_KEY$HELP_LINK_TEXT": "Click here for instructions.",
  "SCHEMA$LLM$API_KEY$HELP_TEXT": "Don't know your API key?",
  "SCHEMA$LLM$API_KEY$LABEL": "API Key",
  "SCHEMA$LLM$API_VERSION$DESCRIPTION": "API version (e.g., Azure).",
  "SCHEMA$LLM$API_VERSION$LABEL": "API Version",
  "SCHEMA$LLM$AWS_ACCESS_KEY_ID$DESCRIPTION": "AWS access key ID for authentication.",
  "SCHEMA$LLM$AWS_ACCESS_KEY_ID$LABEL": "AWS Access Key ID",
  "SCHEMA$LLM$AWS_BEDROCK_RUNTIME_ENDPOINT$DESCRIPTION": "AWS Bedrock runtime endpoint URL.",
  "SCHEMA$LLM$AWS_BEDROCK_RUNTIME_ENDPOINT$LABEL": "AWS Bedrock Runtime Endpoint",
  "SCHEMA$LLM$AWS_PROFILE_NAME$DESCRIPTION": "AWS profile name.",
  "SCHEMA$LLM$AWS_PROFILE_NAME$LABEL": "AWS Profile Name",
  "SCHEMA$LLM$AWS_REGION_NAME$DESCRIPTION": "AWS region name.",
  "SCHEMA$LLM$AWS_REGION_NAME$LABEL": "AWS Region Name",
  "SCHEMA$LLM$AWS_ROLE_NAME$DESCRIPTION": "AWS role name for assuming roles.",
  "SCHEMA$LLM$AWS_ROLE_NAME$LABEL": "AWS Role Name",
  "SCHEMA$LLM$AWS_SECRET_ACCESS_KEY$DESCRIPTION": "AWS secret access key for authentication.",
  "SCHEMA$LLM$AWS_SECRET_ACCESS_KEY$LABEL": "AWS Secret Access Key",
  "SCHEMA$LLM$AWS_SESSION_NAME$DESCRIPTION": "AWS session name.",
  "SCHEMA$LLM$AWS_SESSION_NAME$LABEL": "AWS Session Name",
  "SCHEMA$LLM$AWS_SESSION_TOKEN$DESCRIPTION": "AWS session token for temporary credentials.",
  "SCHEMA$LLM$AWS_SESSION_TOKEN$LABEL": "AWS Session Token",
  "SCHEMA$LLM$BASE_URL$DESCRIPTION": "Custom base URL.",
  "SCHEMA$LLM$BASE_URL$LABEL": "Base URL",
  "SCHEMA$LLM$CACHING_PROMPT$DESCRIPTION": "Enable caching of prompts.",
  "SCHEMA$LLM$CACHING_PROMPT$LABEL": "Caching Prompt",
  "SCHEMA$LLM$CUSTOM_TOKENIZER$DESCRIPTION": "Custom tokenizer for token counting.",
  "SCHEMA$LLM$CUSTOM_TOKENIZER$LABEL": "Custom Tokenizer",
  "SCHEMA$LLM$DISABLE_STOP_WORD$DESCRIPTION": "Disable using stop words.",
  "SCHEMA$LLM$DISABLE_STOP_WORD$LABEL": "Disable Stop Word",
  "SCHEMA$LLM$DISABLE_VISION$DESCRIPTION": "Disable image processing for vision-capable models.",
  "SCHEMA$LLM$DISABLE_VISION$LABEL": "Disable Vision",
  "SCHEMA$LLM$DROP_PARAMS$DESCRIPTION": "Drop unsupported parameters.",
  "SCHEMA$LLM$DROP_PARAMS$LABEL": "Drop Params",
  "SCHEMA$LLM$ENABLE_ENCRYPTED_REASONING$DESCRIPTION": "Request encrypted reasoning content in Responses API.",
  "SCHEMA$LLM$ENABLE_ENCRYPTED_REASONING$LABEL": "Enable Encrypted Reasoning",
  "SCHEMA$LLM$EXTENDED_THINKING_BUDGET$DESCRIPTION": "Budget tokens for extended thinking (Anthropic models).",
  "SCHEMA$LLM$EXTENDED_THINKING_BUDGET$LABEL": "Extended Thinking Budget",
  "SCHEMA$LLM$EXTRA_HEADERS$DESCRIPTION": "Optional HTTP headers to forward to LiteLLM requests.",
  "SCHEMA$LLM$EXTRA_HEADERS$LABEL": "Extra Headers",
  "SCHEMA$LLM$FORCE_STRING_SERIALIZER$DESCRIPTION": "Force using string content serializer.",
  "SCHEMA$LLM$FORCE_STRING_SERIALIZER$LABEL": "Force String Serializer",
  "SCHEMA$LLM$INPUT_COST_PER_TOKEN$DESCRIPTION": "Cost per input token for logging purposes.",
  "SCHEMA$LLM$INPUT_COST_PER_TOKEN$LABEL": "Input Cost Per Token",
  "SCHEMA$LLM$LITELLM_EXTRA_BODY$DESCRIPTION": "Additional parameters to pass to LiteLLM requests.",
  "SCHEMA$LLM$LITELLM_EXTRA_BODY$LABEL": "LiteLLM Extra Body",
  "SCHEMA$LLM$LOG_COMPLETIONS$DESCRIPTION": "Enable logging of completions.",
  "SCHEMA$LLM$LOG_COMPLETIONS$LABEL": "Log Completions",
  "SCHEMA$LLM$LOG_COMPLETIONS_FOLDER$DESCRIPTION": "Folder to log LLM completions to.",
  "SCHEMA$LLM$LOG_COMPLETIONS_FOLDER$LABEL": "Log Completions Folder",
  "SCHEMA$LLM$MAX_INPUT_TOKENS$DESCRIPTION": "Maximum number of input tokens.",
  "SCHEMA$LLM$MAX_INPUT_TOKENS$LABEL": "Max Input Tokens",
  "SCHEMA$LLM$MAX_MESSAGE_CHARS$DESCRIPTION": "Approximate maximum characters in each event/content sent to the LLM.",
  "SCHEMA$LLM$MAX_MESSAGE_CHARS$LABEL": "Max Message Chars",
  "SCHEMA$LLM$MAX_OUTPUT_TOKENS$DESCRIPTION": "Maximum number of output tokens the model may generate.",
  "SCHEMA$LLM$MAX_OUTPUT_TOKENS$LABEL": "Max Output Tokens",
  "SCHEMA$LLM$MODEL$DESCRIPTION": "Model name.",
  "SCHEMA$LLM$MODEL$LABEL": "Model",
  "SCHEMA$LLM$MODEL_CANONICAL_NAME$DESCRIPTION": "Canonical model name for feature registry lookups.",
  "SCHEMA$LLM$MODEL_CANONICAL_NAME$LABEL": "Model Canonical Name",
  "SCHEMA$LLM$MODIFY_PARAMS$DESCRIPTION": "Allow LiteLLM to modify parameters.",
  "SCHEMA$LLM$MODIFY_PARAMS$LABEL": "Modify Params",
  "SCHEMA$LLM$NATIVE_TOOL_CALLING$DESCRIPTION": "Use native tool calling.",
  "SCHEMA$LLM$NATIVE_TOOL_CALLING$LABEL": "Native Tool Calling",
  "SCHEMA$LLM$NUM_RETRIES$DESCRIPTION": "Number of retry attempts for failed requests.",
  "SCHEMA$LLM$NUM_RETRIES$LABEL": "Number of Retries",
  "SCHEMA$LLM$OLLAMA_BASE_URL$DESCRIPTION": "Base URL for Ollama service.",
  "SCHEMA$LLM$OLLAMA_BASE_URL$LABEL": "Ollama Base URL",
  "SCHEMA$LLM$OPENROUTER_APP_NAME$DESCRIPTION": "OpenRouter application name.",
  "SCHEMA$LLM$OPENROUTER_APP_NAME$LABEL": "OpenRouter App Name",
  "SCHEMA$LLM$OPENROUTER_SITE_URL$DESCRIPTION": "OpenRouter site URL.",
  "SCHEMA$LLM$OPENROUTER_SITE_URL$LABEL": "OpenRouter Site URL",
  "SCHEMA$LLM$OUTPUT_COST_PER_TOKEN$DESCRIPTION": "Cost per output token for logging purposes.",
  "SCHEMA$LLM$OUTPUT_COST_PER_TOKEN$LABEL": "Output Cost Per Token",
  "SCHEMA$LLM$PROMPT_CACHE_RETENTION$DESCRIPTION": "Retention policy for prompt cache.",
  "SCHEMA$LLM$PROMPT_CACHE_RETENTION$LABEL": "Prompt Cache Retention",
  "SCHEMA$LLM$REASONING_EFFORT$CHOICE$HIGH": "High",
  "SCHEMA$LLM$REASONING_EFFORT$CHOICE$LOW": "Low",
  "SCHEMA$LLM$REASONING_EFFORT$CHOICE$MEDIUM": "Medium",
  "SCHEMA$LLM$REASONING_EFFORT$CHOICE$NONE": "None",
  "SCHEMA$LLM$REASONING_EFFORT$CHOICE$XHIGH": "Extra High",
  "SCHEMA$LLM$REASONING_EFFORT$DESCRIPTION": "The effort to put into reasoning (low, medium, high, xhigh, or none).",
  "SCHEMA$LLM$REASONING_EFFORT$LABEL": "Reasoning Effort",
  "SCHEMA$LLM$REASONING_SUMMARY$CHOICE$AUTO": "Auto",
  "SCHEMA$LLM$REASONING_SUMMARY$CHOICE$CONCISE": "Concise",
  "SCHEMA$LLM$REASONING_SUMMARY$CHOICE$DETAILED": "Detailed",
  "SCHEMA$LLM$REASONING_SUMMARY$DESCRIPTION": "Level of detail for reasoning summaries (auto, concise, or detailed).",
  "SCHEMA$LLM$REASONING_SUMMARY$LABEL": "Reasoning Summary",
  "SCHEMA$LLM$RETRY_MAX_WAIT$DESCRIPTION": "Maximum wait time between retries in seconds.",
  "SCHEMA$LLM$RETRY_MAX_WAIT$LABEL": "Retry Max Wait",
  "SCHEMA$LLM$RETRY_MIN_WAIT$DESCRIPTION": "Minimum wait time between retries in seconds.",
  "SCHEMA$LLM$RETRY_MIN_WAIT$LABEL": "Retry Min Wait",
  "SCHEMA$LLM$RETRY_MULTIPLIER$DESCRIPTION": "Multiplier for exponential backoff between retries.",
  "SCHEMA$LLM$RETRY_MULTIPLIER$LABEL": "Retry Multiplier",
  "SCHEMA$LLM$SAFETY_SETTINGS$DESCRIPTION": "Deprecated safety settings.",
  "SCHEMA$LLM$SAFETY_SETTINGS$LABEL": "Safety Settings",
  "SCHEMA$LLM$SECTION_LABEL": "LLM",
  "SCHEMA$LLM$SEED$DESCRIPTION": "Seed for random number generation.",
  "SCHEMA$LLM$SEED$LABEL": "Seed",
  "SCHEMA$LLM$STREAM$DESCRIPTION": "Enable streaming responses from the LLM.",
  "SCHEMA$LLM$STREAM$LABEL": "Stream",
  "SCHEMA$LLM$TEMPERATURE$DESCRIPTION": "Controls randomness in model responses. Lower values are more deterministic.",
  "SCHEMA$LLM$TEMPERATURE$LABEL": "Temperature",
  "SCHEMA$LLM$TIMEOUT$DESCRIPTION": "HTTP timeout in seconds.",
  "SCHEMA$LLM$TIMEOUT$LABEL": "Timeout",
  "SCHEMA$LLM$TOP_K$DESCRIPTION": "Limits token selection to the K most likely tokens.",
  "SCHEMA$LLM$TOP_K$LABEL": "Top K",
  "SCHEMA$LLM$TOP_P$DESCRIPTION": "Controls nucleus sampling by limiting token selection to the smallest set whose cumulative probability exceeds this value.",
  "SCHEMA$LLM$TOP_P$LABEL": "Top P",
  "SCHEMA$LLM$USAGE_ID$DESCRIPTION": "Unique usage identifier for the LLM.",
  "SCHEMA$LLM$USAGE_ID$LABEL": "Usage ID",
  "SCHEMA$MAX_ITERATIONS$DESCRIPTION": "Maximum number of iterations the conversation will run before stopping.",
  "SCHEMA$MAX_ITERATIONS$LABEL": "Max Iterations",
  "SCHEMA$MCP_CONFIG$DESCRIPTION": "MCP server configuration for the agent.",
  "SCHEMA$MCP_CONFIG$LABEL": "MCP configuration",
  "SCHEMA$SECURITY_ANALYZER$CHOICE$LLM": "LLM",
  "SCHEMA$SECURITY_ANALYZER$CHOICE$NONE": "None",
  "SCHEMA$SECURITY_ANALYZER$DESCRIPTION": "Security analyzer that evaluates actions before execution.",
  "SCHEMA$SECURITY_ANALYZER$LABEL": "Security Analyzer",
  "SCHEMA$TOOLS$DESCRIPTION": "Tools available to the agent.",
  "SCHEMA$TOOLS$LABEL": "Tools",
  "SCHEMA$VERIFICATION$CONFIRMATION_MODE$DESCRIPTION": "Require user confirmation before executing risky actions.",
  "SCHEMA$VERIFICATION$CONFIRMATION_MODE$LABEL": "Confirmation Mode",
  "SCHEMA$VERIFICATION$CRITIC_API_KEY$DESCRIPTION": "If OpenHands is selected as your active LLM provider, leave this empty; the critic reuses that provider's key. Otherwise, provide a critic API key from the link below.",
  "SCHEMA$VERIFICATION$CRITIC_API_KEY$HELP_SUFFIX": "tab of OpenHands Cloud; otherwise, enter a Critic API Key from that page.",
  "SCHEMA$VERIFICATION$CRITIC_API_KEY$HELP_TEXT": "If OpenHands is selected as your active LLM provider, leave this empty because the Critic API Key is the same as your OpenHands Provider LLM Key, which you can find in the",
  "SCHEMA$VERIFICATION$CRITIC_API_KEY$LABEL": "Critic API Key",
  "SCHEMA$VERIFICATION$CRITIC_ENABLED$DESCRIPTION": "Enable critic evaluation for the agent.",
  "SCHEMA$VERIFICATION$CRITIC_ENABLED$LABEL": "Enable Critic",
  "SCHEMA$VERIFICATION$CRITIC_MODE$CHOICE$ALL_ACTIONS": "All Actions",
  "SCHEMA$VERIFICATION$CRITIC_MODE$CHOICE$FINISH_AND_MESSAGE": "Finish and Message",
  "SCHEMA$VERIFICATION$CRITIC_MODE$DESCRIPTION": "When critic evaluation should run.",
  "SCHEMA$VERIFICATION$CRITIC_MODE$LABEL": "Critic Mode",
  "SCHEMA$VERIFICATION$CRITIC_MODEL_NAME$DESCRIPTION": "Override the critic model name.",
  "SCHEMA$VERIFICATION$CRITIC_MODEL_NAME$LABEL": "Critic Model Name",
  "SCHEMA$VERIFICATION$CRITIC_SERVER_URL$DESCRIPTION": "Override the critic service URL.",
  "SCHEMA$VERIFICATION$CRITIC_SERVER_URL$LABEL": "Critic Server URL",
  "SCHEMA$VERIFICATION$CRITIC_THRESHOLD$DESCRIPTION": "Critic success threshold used for iterative refinement.",
  "SCHEMA$VERIFICATION$CRITIC_THRESHOLD$LABEL": "Critic Threshold",
  "SCHEMA$VERIFICATION$ENABLE_ITERATIVE_REFINEMENT$DESCRIPTION": "Automatically retry tasks when critic scores fall below the threshold.",
  "SCHEMA$VERIFICATION$ENABLE_ITERATIVE_REFINEMENT$LABEL": "Enable Iterative Refinement",
  "SCHEMA$VERIFICATION$MAX_REFINEMENT_ITERATIONS$DESCRIPTION": "Maximum number of refinement attempts after critic feedback.",
  "SCHEMA$VERIFICATION$MAX_REFINEMENT_ITERATIONS$LABEL": "Max Refinement Iterations",
  "SCHEMA$VERIFICATION$SECTION_LABEL": "Verification",
  "SCHEMA$VERIFICATION$SECURITY_ANALYZER$CHOICE$LLM": "LLM",
  "SCHEMA$VERIFICATION$SECURITY_ANALYZER$CHOICE$NONE": "None",
  "SCHEMA$VERIFICATION$SECURITY_ANALYZER$DESCRIPTION": "Security analyzer that evaluates actions before execution.",
  "SCHEMA$VERIFICATION$SECURITY_ANALYZER$LABEL": "Security Analyzer",
  "SECRETS$ADD_A_SECRET": "Add a Secret",
  "SECRETS$ADD_NEW_SECRET": "Add a new secret",
  "SECRETS$ADD_SECRET": "Add secret",
  "SECRETS$API_KEY_EXAMPLE": "e.g. OpenAI_API_Key",
  "SECRETS$CONFIRM_DELETE_KEY": "Are you sure you want to delete this key?",
  "SECRETS$CONNECT_GIT_PROVIDER": "Connect a Git provider to manage secrets",
  "SECRETS$CREATED": "Secret created.",
  "SECRETS$DELETED": "Secret deleted.",
  "SECRETS$DESCRIPTION": "Description",
  "SECRETS$EDIT_A_SECRET": "Edit a Secret",
  "SECRETS$EDIT_SECRET": "Edit secret",
  "SECRETS$EDIT_SECRET_TITLE": "Edit secret key",
  "SECRETS$EDIT_VALUE_HELP": "The existing secret value is not displayed. Enter a new value only if you want to replace it.",
  "SECRETS$EMPTY": "No secrets saved yet.",
  "SECRETS$REPLACE_VALUE": "Replace value",
  "SECRETS$SECRET_ALREADY_EXISTS": "Secret already exists",
  "SECRETS$SECRET_VALUE_LEAVE_BLANK": "Secret Value (leave blank to preserve the existing value)",
  "SECRETS$SECRET_VALUE_REQUIRED": "Secret value is required",
  "SECRETS$SELECTED_SECRET_MISSING": "This secret no longer exists. Select another one or create it again.",
  "SECRETS$UPDATED": "Secret updated.",
  "SECRETS$VALUE_SECURITY_HELP": "Store database credentials, access keys, and other sensitive values. Secret values never enter agent prompts or serialized context.",
  "SECURITY$DONT_ASK_CONFIRMATION": "Don't ask for confirmation",
  "SECURITY$HIGH_RISK": "Risk: High",
  "SECURITY$LOW_RISK": "Risk: Low",
  "SECURITY$MEDIUM_RISK": "Risk: Medium",
  "SECURITY$SELECT_RISK_SEVERITY": "Select risk severity",
  "SECURITY$UNKNOWN_ANALYZER_LABEL": "Unknown security analyzer chosen",
  "SECURITY$UNKNOWN_RISK": "Risk: Unknown",
  "SECURITY_ANALYZER$HIGH_RISK": "High Risk",
  "SECURITY_ANALYZER$LOW_RISK": "Low Risk",
  "SECURITY_ANALYZER$MEDIUM_RISK": "Medium Risk",
  "SECURITY_ANALYZER$UNKNOWN_RISK": "Unknown Risk",
  "SERVED_APP$EMPTY_TITLE": "Preview your app",
  "SERVED_APP$DEV_ENVIRONMENT": "Dev environment",
  "SERVED_APP$FRAME_LOADING": "Loading the application in the preview. The first load can take a while.",
  "SERVED_APP$LOADING": "Loading the preview",
  "SERVED_APP$OPEN": "Open",
  "SERVED_APP$PICK_ELEMENT": "Point at an element",
  "SERVED_APP$PREVIEW_ENVIRONMENT": "Preview environment",
  "SERVED_APP$READY_IN": "ready in {{seconds}}s",
  "SERVED_APP$REBOOT": "Reboot",
  "SERVED_APP$SANDBOX": "Sandbox",
  "SERVED_APP$TITLE": "Served Application",
  "SERVED_APP$WAITING_FOR_APP": "Starting the application server. The preview opens automatically once it responds.",
  "SESSION$SERVER_CONNECTED_MESSAGE": "Connected to server",
  "SESSION$SESSION_CONNECTION_ERROR_MESSAGE": "Error connecting to session",
  "SESSION$SESSION_HANDLING_ERROR_MESSAGE": "Error handling message",
  "SESSION$SOCKET_NOT_INITIALIZED_ERROR_MESSAGE": "Socket not initialized",
  "SESSION$TIMEOUT_MESSAGE": "Session Timeout!",
  "SETTINGS": "Environment variables must follow KEY=value format",
  "SETTINGS$ACCOUNT_SECTION_HEADER": "Account",
  "SETTINGS$ACP_AUTH_CHECKING": "Checking for an existing {{provider}} login…",
  "SETTINGS$ACP_AUTH_DETECTED": "You're already signed in to {{provider}} — you can leave the fields below blank.",
  "SETTINGS$ACP_CREDENTIALS_DESCRIPTION": "Saved as secrets and injected into the agent at runtime. Leave a field blank to keep the existing value.",
  "SETTINGS$ACP_CREDENTIALS_TITLE": "Credentials",
  "SETTINGS$ACP_CREDENTIAL_CONFLICT_WARNING": "Setting {{conflicting}} alongside {{credential}} breaks its authentication — leave one of them blank.",
  "SETTINGS$ACP_SECRETS_ORPHANED_WARNING": "Saved, but this backend can't use these credentials yet — they'll apply once it supports ACP file credentials.",
  "SETTINGS$ACP_SECRET_ALREADY_SET": "Already saved — leave blank to keep",
  "SETTINGS$ACP_SECRET_API_KEY_HINT": "Used to authenticate the agent. Leave blank to use credentials already set on your backend.",
  "SETTINGS$ACP_SECRET_BASE_URL_HINT": "Optional. Point the agent at a custom API endpoint, such as a proxy or gateway.",
  "SETTINGS$ACP_SECRET_FILE_BLOB_HINT": "Paste the full contents of {{file}}. Run `cat {{file}}` to get it. Saved as a secret and written to disk for the agent at runtime.",
  "SETTINGS$ACP_SECRET_GCP_LOCATION_HINT": "Vertex AI region, for example us-central1.",
  "SETTINGS$ACP_SECRET_GCP_PROJECT_HINT": "Google Cloud project ID for Vertex AI (e.g. the output of `gcloud config get-value project`).",
  "SETTINGS$ACP_SECRET_OAUTH_TOKEN_HINT": "Subscription OAuth token for Claude Pro/Max. Run `claude setup-token` in your terminal to get it.",
  "SETTINGS$ACP_SECRET_VERTEXAI_FLAG_HINT": "Set to true to route Gemini through Vertex AI using the credentials above.",
  "SETTINGS$ACTIONS": "Actions",
  "SETTINGS$ADD_AGENT_PROFILE": "Add agent profile",
  "SETTINGS$ADD_LLM_PROFILE": "Add LLM Profile",
  "SETTINGS$ADVANCED": "Advanced",
  "SETTINGS$AGENT": "Agent",
  "SETTINGS$AGENT_COMMAND": "Command",
  "SETTINGS$AGENT_COMMAND_HINT": "Command line used to spawn the ACP subprocess. API keys go through the Secrets panel.",
  "SETTINGS$AGENT_CUSTOM_MODEL": "Custom model",
  "SETTINGS$AGENT_MODEL": "Model",
  "SETTINGS$AGENT_MODEL_HINT": "Choose a suggested ACP model or enter a custom model override. Built-in providers save a concrete model instead of leaving the model blank.",
  "SETTINGS$AGENT_PAGE_DESCRIPTION": "Choose between the built-in OpenHands agent and an external ACP (Agent Client Protocol) subprocess such as Claude Code, Codex, or Gemini CLI.",
  "SETTINGS$AGENT_PRESET": "Preset",
  "SETTINGS$AGENT_PRESET_CUSTOM": "Custom",
  "SETTINGS$AGENT_PROFILE_LLM_LABEL": "LLM profile",
  "SETTINGS$AGENT_PROFILE_LLM_REQUIRED": "Select an LLM profile for this agent.",
  "SETTINGS$AGENT_PROFILE_NO_LLM": "Create an LLM profile first to define an OpenHands agent.",
  "SETTINGS$AGENT_SECTION_HEADER": "Agent",
  "SETTINGS$AGENT_SELECT_ENABLED": "Enable Agent Selection - Advanced Users",
  "SETTINGS$AGENT_SERVER_API_KEY": "Session API key",
  "SETTINGS$AGENT_SERVER_API_KEY_PLACEHOLDER": "Enter the X-Session-API-Key value",
  "SETTINGS$AGENT_SERVER_BROWSER_ONLY_NOTE": "Saved only in this browser. Deployment defaults stay available until you override them here.",
  "SETTINGS$AGENT_SERVER_CONNECTION_DETAILS_DESCRIPTION": "Paste the agent server URL and optional session API key that Agent Canvas should use.",
  "SETTINGS$AGENT_SERVER_CONNECTION_DETAILS_TITLE": "Connection details",
  "SETTINGS$AGENT_SERVER_DETAILS_LABEL": "Details: {{details}}",
  "SETTINGS$AGENT_SERVER_ONBOARDING_DESCRIPTION": "Agent Canvas needs an agent server before it can load conversations, tools, and settings. Start or choose a compatible server, then connect it here.",
  "SETTINGS$AGENT_SERVER_ONBOARDING_EYEBROW": "Get started",
  "SETTINGS$AGENT_SERVER_ONBOARDING_TITLE": "Connect to your agent server",
  "SETTINGS$AGENT_SERVER_OPEN_SETTINGS_PAGE": "Open full settings page",
  "SETTINGS$AGENT_SERVER_RETRY_CONNECTION": "Retry connection",
  "SETTINGS$AGENT_SERVER_SETUP_GUIDE_HINT": "If you need help starting or upgrading the server, see the",
  "SETTINGS$AGENT_SERVER_SETUP_GUIDE_LINK": "setup instructions",
  "SETTINGS$AGENT_SERVER_UNAVAILABLE_STATUS_MESSAGE": "Check the URL, confirm the server is running, and try again. You can also point Agent Canvas at a different deployment.",
  "SETTINGS$AGENT_SERVER_UNAVAILABLE_STATUS_TITLE": "We couldn't reach the configured server",
  "SETTINGS$AGENT_SERVER_URL": "Agent server URL",
  "SETTINGS$AGENT_SERVER_URL_PLACEHOLDER": "https://agent.example.com",
  "SETTINGS$AGENT_TOOLTIP": "Select the agent to use.",
  "SETTINGS$AGENT_TYPE_ACP": "ACP (external subprocess)",
  "SETTINGS$AGENT_TYPE_OPENHANDS": "OpenHands",
  "SETTINGS$ALL": "All",
  "SETTINGS$API_KEYS": "API Keys",
  "SETTINGS$API_KEYS_DESCRIPTION": "API keys allow you to authenticate with the OpenHands API programmatically. Keep your API keys secure; anyone with your API key can access your account. For more information on how to use the API, see our <a>API documentation</a>.",
  "SETTINGS$API_KEY_COPIED": "API key copied to clipboard",
  "SETTINGS$API_KEY_CREATED": "API Key Created",
  "SETTINGS$API_KEY_DELETED": "API key deleted successfully",
  "SETTINGS$API_KEY_NAME_PLACEHOLDER": "My API Key",
  "SETTINGS$API_KEY_PLACEHOLDER": "Enter your API key.",
  "SETTINGS$API_KEY_REFRESHED": "API key refreshed successfully",
  "SETTINGS$API_KEY_WARNING": "This is the only time your API key will be displayed. Please copy it now and store it securely.",
  "SETTINGS$APPEARANCE_DESCRIPTION": "Set shared colors for both display themes. Only workspace owners and admins can make changes.",
  "SETTINGS$APPEARANCE_HEADER": "Top bar",
  "SETTINGS$APPEARANCE_PRIMARY": "Primary",
  "SETTINGS$APPEARANCE_SIDEBAR": "Sidebar",
  "SETTINGS$APPEARANCE_TITLE": "Workspace colors",
  "SETTINGS$ANSWER_STYLE": "Answer style",
  "SETTINGS$ANSWER_STYLE_BRIEF": "Brief",
  "SETTINGS$ANSWER_STYLE_DESCRIPTION": "Choose how concise or technically detailed the agent's answers should be.",
  "SETTINGS$ANSWER_STYLE_STANDARD": "Standard",
  "SETTINGS$ANSWER_STYLE_TECHNICAL": "Technical",
  "SETTINGS$AUTOMATION_AGENT_MODEL": "Automation and PR review model",
  "SETTINGS$AUTOMATION_AGENT_MODEL_DESCRIPTION": "Runs scheduled Automations and automatic GitHub pull-request reviews.",
  "SETTINGS$AVAILABLE_PROFILES": "Available Profiles",
  "SETTINGS$AZURE_DEVOPS": "Azure DevOps",
  "SETTINGS$BACK_TO_LLM_LIST": "Back to LLM profiles",
  "SETTINGS$BACK_TO_LLM_PROFILES_LIST": "Back to LLM profiles list",
  "SETTINGS$BASE_URL": "Base URL",
  "SETTINGS$BASIC": "Basic",
  "SETTINGS$CLICK_FOR_INSTRUCTIONS": "Click here for instructions",
  "SETTINGS$CLICK_HERE": "Click here",
  "SETTINGS$CODE_AGENT_MODEL": "Code reasoning model",
  "SETTINGS$CODE_AGENT_MODEL_DESCRIPTION": "Implementation, debugging, and testing against a real checkout, including turns that own an execution environment.",
  "SETTINGS$COMPUTING_ADMIN_ONLY": "Only an organization owner or admin can change this.",
  "SETTINGS$COMPUTING_CAPACITY": "Uses up to {{count}} machine.",
  "SETTINGS$COMPUTING_CURRENT_USAGE": "Current organization usage",
  "SETTINGS$COMPUTING_CURRENT_USAGE_DESCRIPTION": "{{sandboxes}} active sandboxes · {{slots}} / {{limit}} shared-pool slots",
  "SETTINGS$COMPUTING_LOAD_FAILED": "The sandbox capacity could not be read.",
  "SETTINGS$COMPUTING_ON_CAPACITY": "When every sandbox is taken",
  "SETTINGS$COMPUTING_ON_CAPACITY_CONTROL": "Answer without a sandbox",
  "SETTINGS$COMPUTING_ON_CAPACITY_HELP": "Waiting keeps everything a sandbox can do, including building, running and testing, but the user waits. Answering without one replies immediately and can still read repositories and publish changes, but it cannot build, run or test anything, and the agent says so.",
  "SETTINGS$COMPUTING_ON_CAPACITY_WAIT": "Wait for one to free up",
  "SETTINGS$COMPUTING_POOL_DESCRIPTION": "Conversations run in sandboxes. This is how many may run at once and what happens to a request that arrives when they are all taken. The change takes effect on the next reconcile rather than needing a release.",
  "SETTINGS$COMPUTING_POOL_TITLE": "Sandbox capacity",
  "SETTINGS$COMPUTING_RESTORE_DEFAULT": "Restore default",
  "SETTINGS$COMPUTING_SAVE": "Save",
  "SETTINGS$COMPUTING_SAVE_FAILED": "The change was not saved.",
  "SETTINGS$COMPUTING_SLOT_LIMIT": "Concurrent sandboxes",
  "SETTINGS$CONDENSER_MAX_SIZE": "Memory condenser max history size",
  "SETTINGS$CONDENSER_MAX_SIZE_TOOLTIP": "After this many events, the condenser will summarize history. Minimum 20.",
  "SETTINGS$CONFIRMATION_MODE": "Enable Confirmation Mode",
  "SETTINGS$CONFIRMATION_MODE_LOCK_TOOLTIP": "The agent is in confirmation mode. It will prompt the user to confirm certain actions when security analyzer policy detected a high-risk action. Click this icon to go to settings tab for more information.",
  "SETTINGS$CONFIRMATION_MODE_TOOLTIP": "Awaits for user confirmation before executing code.",
  "SETTINGS$CONNECTIONS_SECTION_HEADER": "Connections",
  "SETTINGS$CONVERSATION_AGENT_MODEL": "Exploration reasoning model",
  "SETTINGS$CONVERSATION_AGENT_MODEL_DESCRIPTION": "Investigates repositories, databases, and documents to answer in the chat, and decides when to start an execution environment. Every message waits on this model.",
  "SETTINGS$CONVERSATION_TITLES": "Conversation titles",
  "SETTINGS$CREATED_AT": "Created",
  "SETTINGS$CREATE_API_KEY": "Create API Key",
  "SETTINGS$CREATE_API_KEY_DESCRIPTION": "Give your API key a descriptive name to help you identify it later.",
  "SETTINGS$CREATE_PROFILE": "Create Profile",
  "SETTINGS$CUSTOM_MODEL": "Custom Model",
  "SETTINGS$DELETE_API_KEY": "Delete API Key",
  "SETTINGS$DELETE_API_KEY_CONFIRMATION": "Are you sure you want to delete the API key \"{{name}}\"? This action cannot be undone.",
  "SETTINGS$DESCRIPTION": "To continue, connect an OpenAI, Anthropic, or other LLM account",
  "SETTINGS$DISABLED_RUNNING": "Cannot be changed while the agent is running.",
  "SETTINGS$DONT_KNOW_API_KEY": "Don't know your API key?",
  "SETTINGS$EDIT_AGENT_PROFILE": "Edit agent profile",
  "SETTINGS$EDIT_LLM_PROFILE": "Edit LLM Profile",
  "SETTINGS$EDIT_PROFILE": "Edit Profile",
  "SETTINGS$EMAIL_SAVED_SUCCESSFULLY": "Email saved successfully",
  "SETTINGS$EMAIL_VERIFICATION_REQUIRED": "You must verify your email address before using All Hands",
  "SETTINGS$EMAIL_VERIFICATION_RESTRICTION_MESSAGE": "Your access is limited until your email is verified. You can only access this settings page.",
  "SETTINGS$EMAIL_VERIFIED_SUCCESSFULLY": "Your email has been verified successfully!",
  "SETTINGS$ENABLE_MEMORY_CONDENSATION": "Enable memory condensation",
  "SETTINGS$EVIDENCE_JUDGE_MODEL": "Evidence judge model",
  "SETTINGS$EVIDENCE_JUDGE_MODEL_DESCRIPTION": "Judges whether an answer is backed by the evidence gathered, and sends the investigation back when it is not. Unset means the answering model judges itself. It reads one capped summary per step, so a stronger model here costs far less than using it to answer.",
  "SETTINGS$FAILED_TO_RESEND_VERIFICATION": "Failed to resend verification email",
  "SETTINGS$FAILED_TO_SAVE_EMAIL": "Failed to save email",
  "SETTINGS$FETCH_ERROR": "Something went wrong while fetching settings. Please reload the page.",
  "SETTINGS$FOR_OTHER_OPTIONS": "For other options",
  "SETTINGS$GENERAL_AGENT_MODEL": "Default model",
  "SETTINGS$GENERAL_AGENT_MODEL_DESCRIPTION": "The organization's default model.",
  "SETTINGS$GET_IN_TOUCH": "get in touch for access",
  "SETTINGS$GITHUB": "GitHub",
  "SETTINGS$GITLAB": "GitLab",
  "SETTINGS$GITLAB_INSTALLING_WEBHOOK": "Installing GitLab webhook, please wait a few minutes.",
  "SETTINGS$GITLAB_NOT_CONNECTED": "Not Connected",
  "SETTINGS$GITLAB_REINSTALL_WEBHOOK": "Reinstall Webhook",
  "SETTINGS$GIT_EMAIL": "Git Email",
  "SETTINGS$GIT_EMAIL_PLACEHOLDER": "Email for git commits",
  "SETTINGS$GIT_SETTINGS": "Git Settings",
  "SETTINGS$GIT_SETTINGS_DESCRIPTION": "Configure the username and email that OpenHands uses to commit changes.",
  "SETTINGS$GIT_USERNAME": "Git Username",
  "SETTINGS$GIT_USERNAME_PLACEHOLDER": "Username for git commits",
  "SETTINGS$HIGH_RISK_REVIEW_MODEL": "High-risk review model",
  "SETTINGS$HIGH_RISK_REVIEW_MODEL_DESCRIPTION": "Reviews and verifies high-risk pull requests. Other pull requests keep using the automation model.",
  "SETTINGS$HIGH_RISK_REVIEW_MODEL_ENABLE": "Use a dedicated model for high-risk reviews",
  "SETTINGS$HIGH_RISK_REVIEW_MODEL_ENABLE_DESCRIPTION": "When enabled, a pull request whose diff touches authentication, migrations, deployment, dependencies, or agent behaviour is reviewed by a stronger model than an ordinary change.",
  "SETTINGS$IMAGE_FALLBACK_MODEL": "Image-only fallback model",
  "SETTINGS$IMAGE_FALLBACK_MODEL_DESCRIPTION": "Images normally go to the role model handling the turn. This model steps in only when that model cannot read images, describing the image in its place. It also reviews published captures.",
  "SETTINGS$INTEGRATIONS_SETTINGS_LINK": "Integrations",
  "SETTINGS$INVALID_EMAIL_FORMAT": "Please enter a valid email address",
  "SETTINGS$KEY_PREFIX": "Key Prefix",
  "SETTINGS$LANGUAGE": "Language",
  "SETTINGS$LANGUAGE_DESCRIPTION": "Select the language used across the OpenHands interface.",
  "SETTINGS$LANGUAGE_TOOLTIP": "Select the language for the UI.",
  "SETTINGS$LAST_USED": "Last Used",
  "SETTINGS$LLM_API_KEY": "OpenHands LLM Key",
  "SETTINGS$LLM_API_KEY_BUY_NOW": "Buy Now",
  "SETTINGS$LLM_API_KEY_DESCRIPTION": "You can use this API Key as the LLM API Key for OpenHands open-source and CLI. It will incur cost on your OpenHands Cloud account. Do NOT share this key elsewhere.",
  "SETTINGS$LLM_AUTH_TYPE": "Authentication",
  "SETTINGS$LLM_AUTH_TYPE_API_KEY": "API key",
  "SETTINGS$LLM_AUTH_TYPE_SUBSCRIPTION": "ChatGPT subscription",
  "SETTINGS$LLM_PROFILES": "LLM Profiles",
  "SETTINGS$LLM_SETTINGS": "LLM Settings",
  "SETTINGS$MANAGE_LLM_PROFILES": "Manage LLM profiles",
  "SETTINGS$MAXIMUM_BUDGET_USD": "Maximum budget per conversation in USD",
  "SETTINGS$MAX_BUDGET_PER_CONVERSATION": "Maximum Budget Per Conversation",
  "SETTINGS$MAX_BUDGET_PER_TASK": "Maximum Budget Per Task",
  "SETTINGS$MCP_ADD_SERVER": "Add Server",
  "SETTINGS$MCP_API_KEY": "API Key",
  "SETTINGS$MCP_API_KEY_NOT_SET": "Not set",
  "SETTINGS$MCP_API_KEY_PLACEHOLDER": "Enter API key (optional)",
  "SETTINGS$MCP_ARGS": "Args",
  "SETTINGS$MCP_AUTHENTICATION": "Authentication",
  "SETTINGS$MCP_AUTH_MODE_BEARER": "Bearer token",
  "SETTINGS$MCP_AUTH_MODE_HEADER": "Header",
  "SETTINGS$MCP_AUTH_MODE_NONE": "None",
  "SETTINGS$MCP_AUTH_MODE_OAUTH": "OAuth",
  "SETTINGS$MCP_COMMAND": "Command",
  "SETTINGS$MCP_COMMAND_ARGUMENTS": "Command Arguments",
  "SETTINGS$MCP_COMMAND_ARGUMENTS_HELP": "Enter each argument on a separate line. Arguments will be passed to the command in the order listed.",
  "SETTINGS$MCP_CONFIGURATION": "MCP Configuration",
  "SETTINGS$MCP_CONFIG_DESCRIPTION": "Edit the JSON configuration for MCP servers below. The configuration must include both sse_servers and stdio_servers arrays. For full configuration details and integration examples, see the <a>documentation</a>.",
  "SETTINGS$MCP_CONFIG_ERROR": "Error:",
  "SETTINGS$MCP_CONFIG_EXAMPLE": "Example:",
  "SETTINGS$MCP_CONFIRM_CHANGES": "Confirm Changes",
  "SETTINGS$MCP_CONFIRM_DELETE": "Are you sure you want to delete this server?",
  "SETTINGS$MCP_DEFAULT_CONFIG": "{\n  \"sse_servers\": [],\n  \"stdio_servers\": []\n}",
  "SETTINGS$MCP_DESCRIPTION": "Configure MCP servers for enhanced model capabilities",
  "SETTINGS$MCP_EDIT_CONFIGURATION": "Edit Configuration",
  "SETTINGS$MCP_ENV": "Env",
  "SETTINGS$MCP_ENVIRONMENT_VARIABLES": "Environment Variables",
  "SETTINGS$MCP_ERROR_COMMAND_NO_SPACES": "Command cannot contain spaces",
  "SETTINGS$MCP_ERROR_COMMAND_REQUIRED": "Command is required",
  "SETTINGS$MCP_ERROR_ENV_INVALID_FORMAT": "Environment variables must follow KEY=value format",
  "SETTINGS$MCP_ERROR_HEADER_REQUIRED": "Header authentication requires a header",
  "SETTINGS$MCP_ERROR_INVALID_JSON": "Invalid JSON",
  "SETTINGS$MCP_ERROR_NAME_DUPLICATE": "A STDIO server with this name already exists",
  "SETTINGS$MCP_ERROR_NAME_INVALID": "Name can only contain letters, numbers, hyphens, and underscores",
  "SETTINGS$MCP_ERROR_NAME_REQUIRED": "Name is required",
  "SETTINGS$MCP_ERROR_OAUTH_SECRET_REQUIRES_ID": "OAuth client secret requires a client ID",
  "SETTINGS$MCP_ERROR_SSE_ARRAY": "sse_servers must be an array",
  "SETTINGS$MCP_ERROR_SSE_URL": "Each SSE server must be a string URL or have a url property",
  "SETTINGS$MCP_ERROR_STDIO_ARRAY": "stdio_servers must be an array",
  "SETTINGS$MCP_ERROR_STDIO_PROPS": "Each stdio server must have name and command properties",
  "SETTINGS$MCP_ERROR_TIMEOUT_INVALID_NUMBER": "Timeout must be a valid number",
  "SETTINGS$MCP_ERROR_TIMEOUT_MAX_EXCEEDED": "Timeout cannot exceed 3600 seconds (1 hour)",
  "SETTINGS$MCP_ERROR_TIMEOUT_POSITIVE": "Timeout must be positive",
  "SETTINGS$MCP_ERROR_URL_DUPLICATE": "A server with this URL already exists for the selected type",
  "SETTINGS$MCP_ERROR_URL_INVALID": "Invalid URL format",
  "SETTINGS$MCP_ERROR_URL_INVALID_PROTOCOL": "URL must use http:// or https://",
  "SETTINGS$MCP_ERROR_URL_REQUIRED": "URL is required",
  "SETTINGS$MCP_HEADERS": "Headers",
  "SETTINGS$MCP_HEADERS_PLACEHOLDER": "X-API-Key=value\nX-Application-Key=value",
  "SETTINGS$MCP_LEARN_MORE": "Learn more",
  "SETTINGS$MCP_NAME": "Name",
  "SETTINGS$MCP_NO_SERVERS": "No servers configured",
  "SETTINGS$MCP_NO_SERVERS_CONFIGURED": "No MCP servers are currently configured. Click \"Edit Configuration\" to add servers.",
  "SETTINGS$MCP_OAUTH_CLIENT_AUTH": "OAuth client auth",
  "SETTINGS$MCP_OAUTH_CLIENT_AUTH_AUTO": "Auto",
  "SETTINGS$MCP_OAUTH_CLIENT_AUTH_NONE": "None",
  "SETTINGS$MCP_OAUTH_CLIENT_AUTH_PRIVATE_KEY_JWT": "Private key JWT",
  "SETTINGS$MCP_OAUTH_CLIENT_AUTH_SECRET_BASIC": "Client secret basic",
  "SETTINGS$MCP_OAUTH_CLIENT_AUTH_SECRET_POST": "Client secret POST",
  "SETTINGS$MCP_OAUTH_CLIENT_ID": "OAuth client ID",
  "SETTINGS$MCP_OAUTH_CLIENT_ID_PLACEHOLDER": "client-id",
  "SETTINGS$MCP_OAUTH_CLIENT_SECRET": "OAuth client secret",
  "SETTINGS$MCP_OAUTH_CLIENT_SECRET_PLACEHOLDER": "client-secret",
  "SETTINGS$MCP_OAUTH_SCOPES": "OAuth scopes",
  "SETTINGS$MCP_OAUTH_SCOPES_PLACEHOLDER": "read write",
  "SETTINGS$MCP_PREVIEW_CHANGES": "Preview Changes",
  "SETTINGS$MCP_SAVE_SERVER": "Save Server",
  "SETTINGS$MCP_SEARCH_DESCRIPTION": "Configure the Tavily key that OpenHands uses to add its default search MCP server.",
  "SETTINGS$MCP_SEARCH_TITLE": "Built-in search (Tavily)",
  "SETTINGS$MCP_SERVER_DETAILS": "Server Details",
  "SETTINGS$MCP_SERVER_NAME": "Server name",
  "SETTINGS$MCP_SERVER_TYPE": "Server Type",
  "SETTINGS$MCP_SERVER_TYPE_SHTTP": "SHTTP",
  "SETTINGS$MCP_SERVER_TYPE_SSE": "SSE",
  "SETTINGS$MCP_SERVER_TYPE_STDIO": "STDIO",
  "SETTINGS$MCP_SSE_SERVERS": "SSE Servers",
  "SETTINGS$MCP_STDIO_SERVERS": "Stdio Servers",
  "SETTINGS$MCP_TIMEOUT_LABEL": "Timeout (seconds)",
  "SETTINGS$MCP_TITLE": "MCP & Connectors",
  "SETTINGS$MCP_URL": "URL",
  "SETTINGS$MODEL_REQUIRED": "Model is required",
  "SETTINGS$MODEL_TOOLTIP": "Select the language model to use.",
  "SETTINGS$NAME": "Name",
  "SETTINGS$NAV_ADD_TEAM_MEMBERS": "Add Team Members",
  "SETTINGS$NAV_AGENT": "Agent",
  "SETTINGS$NAV_AGENTS": "Agents",
  "SETTINGS$NAV_AGENT_CONTEXT": "Agent Context",
  "SETTINGS$NAV_AGENT_PROFILES": "Agent profiles",
  "SETTINGS$NAV_API_KEYS": "API Keys",
  "SETTINGS$NAV_APPLICATION": "Application",
  "SETTINGS$NAV_COMPUTING": "Computing",
  "SETTINGS$NAV_CONDENSER": "Condenser",
  "SETTINGS$NAV_INTEGRATIONS": "Integrations",
  "SETTINGS$NAV_LLM": "Models",
  "SETTINGS$NAV_MEMBERS": "Members",
  "SETTINGS$NAV_REPOSITORIES": "Repositories",
  "SETTINGS$NAV_SECRETS": "Secrets",
  "SETTINGS$NAV_SKILLS": "Skills",
  "SETTINGS$NAV_TEST_ACCOUNTS": "Test accounts",
  "SETTINGS$NAV_USAGE": "Usage",
  "SETTINGS$NAV_USER": "User",
  "SETTINGS$NAV_VERIFICATION": "Verification",
  "SETTINGS$NEED_OPENHANDS_ACCOUNT": "Need an OpenHands Account?",
  "SETTINGS$NO_API_KEYS": "You don't have any API keys yet. Create one to get started.",
  "SETTINGS$OPENHANDS_API_KEYS": "OpenHands API Keys",
  "SETTINGS$OPENHANDS_API_KEY_HELP": "You can find your OpenHands Provider LLM Key in the <a>API Keys</a> tab of OpenHands Cloud.",
  "SETTINGS$OPENHANDS_API_KEY_HELP_SUFFIX": "tab of OpenHands Cloud.",
  "SETTINGS$OPENHANDS_API_KEY_HELP_TEXT": "You can find your OpenHands Provider LLM Key in the",
  "SETTINGS$ORGANIZATION_SECTION_HEADER": "Organization",
  "SETTINGS$PAGE_AGENT_CONTEXT_SUBLINE": "Let the agent keep notes and recall them in new conversations.",
  "SETTINGS$PAGE_AGENT_PROFILES_SUBLINE": "Create and manage reusable agent setups.",
  "SETTINGS$PAGE_AGENT_SUBLINE": "Choose between the built-in OpenHands agent and an external ACP subprocess.",
  "SETTINGS$PAGE_APPLICATION_SUBLINE": "Language, theme, answer style, and notifications.",
  "SETTINGS$PAGE_COMPUTING_SUBLINE": "How much sandbox capacity this deployment runs.",
  "SETTINGS$PAGE_CONDENSER_SUBLINE": "Summarize long chats to stay within context limits.",
  "SETTINGS$PAGE_INTEGRATIONS_SUBLINE": "Manage GitHub and Slack accounts connected to this organization.",
  "SETTINGS$PAGE_LLM_PROFILES_SUBLINE": "Create, edit, and activate saved LLM profiles for the agent.",
  "SETTINGS$PAGE_LLM_SUBLINE": "Models for general tasks, coding, vision, titles, and repository setup.",
  "SETTINGS$PAGE_MEMBERS_SUBLINE": "View organization members and manage their roles.",
  "SETTINGS$PAGE_REPOSITORIES_SUBLINE": "Connect repositories, monitor indexing, and configure preview runtimes.",
  "SETTINGS$PAGE_SECRETS_SUBLINE": "Named values the agent can use during conversations.",
  "SETTINGS$PAGE_USAGE_SUBLINE": "Review model costs and token usage for your organization.",
  "SETTINGS$PAGE_VERIFICATION_SUBLINE": "Confirmation prompts and security checks on actions.",
  "SETTINGS$PERSONAL_SETTINGS_HEADER": "PERSONAL SETTINGS",
  "SETTINGS$PLUGINS_ADD_BUTTON": "Add plugin",
  "SETTINGS$PLUGINS_ADD_MODAL_INTRO": "Install a plugin from a Git source or local path.",
  "SETTINGS$PLUGINS_ADD_MODAL_TITLE": "Add a plugin",
  "SETTINGS$PLUGINS_AUTO_LOAD": "Load into every new conversation",
  "SETTINGS$PLUGINS_AUTO_LOAD_HINT": "Its plugins are fetched when a conversation starts, which adds to start time.",
  "SETTINGS$PLUGINS_CLEAR_SELECTION": "Clear selection",
  "SETTINGS$PLUGINS_CLOUD_PAGE_DESCRIPTION": "Browse plugins from your registered Cloud marketplaces. Registering a marketplace adds its catalog; it does not install a plugin.",
  "SETTINGS$PLUGINS_DESCRIPTION": "Plugin configuration options will appear here.",
  "SETTINGS$PLUGINS_EDIT_MARKETPLACE": "Edit marketplace",
  "SETTINGS$PLUGINS_FILTER_ALL": "All",
  "SETTINGS$PLUGINS_FILTER_AVAILABLE": "Available",
  "SETTINGS$PLUGINS_FILTER_INSTALLED": "Installed",
  "SETTINGS$PLUGINS_FILTER_LOCAL": "Local",
  "SETTINGS$PLUGINS_INDEX_PENDING": "Pending",
  "SETTINGS$PLUGINS_INSTALL": "Install",
  "SETTINGS$PLUGINS_INSTALLING": "Installing…",
  "SETTINGS$PLUGINS_INSTALL_SUCCESS": "Plugin installed.",
  "SETTINGS$PLUGINS_LAUNCH_SELECTED": "Start conversation with selected",
  "SETTINGS$PLUGINS_LINK": "Link",
  "SETTINGS$PLUGINS_MARKETPLACE_SOURCE_PLACEHOLDER": "github:owner/marketplace or a credential-free Git URL",
  "SETTINGS$PLUGINS_NO_MATCH": "No plugins match your search.",
  "SETTINGS$PLUGINS_NO_PLUGINS": "No plugins found.",
  "SETTINGS$PLUGINS_PAGE_DESCRIPTION": "Browse, install, enable, and uninstall plugins. Enabled plugins load automatically into new conversations.",
  "SETTINGS$PLUGINS_PENDING_SOURCE": "Loading plugins from {{source}}…",
  "SETTINGS$PLUGINS_PREVIEW_FAILED": "Unavailable",
  "SETTINGS$PLUGINS_PREVIEW_PARTIAL_ERROR": "{{count}} registered marketplace(s) could not be previewed. Plugins from the other marketplaces are still shown.",
  "SETTINGS$PLUGINS_PREVIEW_RETRY_HINT": "Retried the next time this page loads.",
  "SETTINGS$PLUGINS_REFRESH": "Update",
  "SETTINGS$PLUGINS_REFRESH_SUCCESS": "Plugin updated.",
  "SETTINGS$PLUGINS_REF_LABEL": "Ref",
  "SETTINGS$PLUGINS_REGISTERING_MARKETPLACE": "Registering marketplace…",
  "SETTINGS$PLUGINS_REGISTER_MARKETPLACE": "Register marketplace",
  "SETTINGS$PLUGINS_REGISTER_MARKETPLACE_ERROR": "Could not register the marketplace.",
  "SETTINGS$PLUGINS_REGISTER_MARKETPLACE_INTRO": "Add a Git-hosted marketplace catalog to Cloud. This registers the marketplace and previews its plugins; it does not install one plugin.",
  "SETTINGS$PLUGINS_REGISTER_MARKETPLACE_SUCCESS": "Marketplace registered.",
  "SETTINGS$PLUGINS_REGISTER_MARKETPLACE_TITLE": "Register a plugin marketplace",
  "SETTINGS$PLUGINS_REPO_PATH_LABEL": "Path",
  "SETTINGS$PLUGINS_SEARCH_PLACEHOLDER": "Search plugins by name, description, or source",
  "SETTINGS$PLUGINS_SELECTED_COUNT": "{{count}} selected",
  "SETTINGS$PLUGINS_SELECT_ALL": "Select all plugins on this page",
  "SETTINGS$PLUGINS_SELECT_COLUMN": "Select",
  "SETTINGS$PLUGINS_SELECT_PLUGIN": "Select {{name}}",
  "SETTINGS$PLUGINS_SKILLS_IN_BUNDLE": "Skills in this plugin bundle",
  "SETTINGS$PLUGINS_SOURCE_CREDENTIALS_ERROR": "Source URLs cannot include usernames, passwords, or tokens. Connect the provider separately, then enter a credential-free URL.",
  "SETTINGS$PLUGINS_SOURCE_LABEL": "Source",
  "SETTINGS$PLUGINS_SOURCE_PLACEHOLDER": "github:owner/repo, a Git URL, or a local path",
  "SETTINGS$PLUGINS_TITLE": "Plugins",
  "SETTINGS$PLUGINS_UNINSTALL": "Uninstall",
  "SETTINGS$PLUGINS_UNINSTALL_SUCCESS": "Plugin uninstalled.",
  "SETTINGS$PLUGINS_UNREGISTER_CONFIRM": "Its plugins leave the list. Nothing installed from it is removed.",
  "SETTINGS$PLUGINS_UNREGISTER_MARKETPLACE": "Remove marketplace",
  "SETTINGS$PLUGINS_UNREGISTER_MARKETPLACE_ERROR": "Could not remove the marketplace.",
  "SETTINGS$PLUGINS_UNREGISTER_MARKETPLACE_SUCCESS": "Marketplace removed.",
  "SETTINGS$PLUGINS_UPDATE_MARKETPLACE_ERROR": "Could not update the marketplace.",
  "SETTINGS$PLUGINS_UPDATE_MARKETPLACE_SUCCESS": "Marketplace updated.",
  "SETTINGS$PROACTIVE_CONVERSATION_STARTERS": "Suggest Tasks on GitHub",
  "SETTINGS$PROFILES_EMPTY": "No profiles saved yet. Add a profile to save your LLM configurations.",
  "SETTINGS$PROFILES_LOAD_ERROR": "Failed to load profiles",
  "SETTINGS$PROFILE_ACTIVATE": "Activate",
  "SETTINGS$PROFILE_ACTIVATED": "Switched to profile \"{{name}}\"",
  "SETTINGS$PROFILE_ACTIVE": "Active",
  "SETTINGS$PROFILE_API_KEY_SET": "API Key Set",
  "SETTINGS$PROFILE_CANNOT_DELETE_ACTIVE": "Cannot delete the active profile",
  "SETTINGS$PROFILE_CREATED": "Profile \"{{name}}\" created",
  "SETTINGS$PROFILE_DEFAULT": "Default",
  "SETTINGS$PROFILE_DELETE": "Delete",
  "SETTINGS$PROFILE_DELETED": "Profile \"{{name}}\" deleted",
  "SETTINGS$PROFILE_DELETE_CONFIRMATION": "Are you sure you want to delete the profile \"{{name}}\"? This action cannot be undone.",
  "SETTINGS$PROFILE_DELETE_TITLE": "Delete Profile",
  "SETTINGS$PROFILE_DUPLICATED": "Profile duplicated as \"{{name}}\"",
  "SETTINGS$PROFILE_EDIT": "Edit",
  "SETTINGS$PROFILE_LOADED": "Editing profile \"{{name}}\" - save to apply changes",
  "SETTINGS$PROFILE_MENU": "Profile menu",
  "SETTINGS$PROFILE_NAME_AND_MODEL_REQUIRED": "Profile name and model are required",
  "SETTINGS$PROFILE_NAME_LABEL": "Profile Name",
  "SETTINGS$PROFILE_NAME_PLACEHOLDER": "Enter profile name",
  "SETTINGS$PROFILE_NAME_RULE": "Profile name must start with a letter or digit, and contain only letters, digits, dots, underscores, or hyphens (max 64 characters)",
  "SETTINGS$PROFILE_RENAME": "Rename",
  "SETTINGS$PROFILE_RENAMED": "Profile renamed to \"{{name}}\"",
  "SETTINGS$PROFILE_RENAME_TITLE": "Rename Profile",
  "SETTINGS$PROFILE_SAVED": "Profile \"{{name}}\" saved",
  "SETTINGS$PROFILE_SAVE_HINT": "Configure your LLM settings below, then click Save to create this profile.",
  "SETTINGS$PROFILE_SET_ACTIVE": "Set as active",
  "SETTINGS$PROFILE_SET_DEFAULT": "Set as default",
  "SETTINGS$PROFILE_UPDATED": "Profile \"{{name}}\" updated",
  "SETTINGS$PROVIDERS_DESCRIPTION": "Where the models below run. OpenRouter is managed for your organization; connect a ChatGPT subscription to also use OpenAI models.",
  "SETTINGS$PROVIDERS_TITLE": "Providers",
  "SETTINGS$PROVIDER_GPT_DISCONNECTED_WARNING": "This role runs on OpenAI, but no ChatGPT subscription is connected. Until you reconnect above, it runs on the same model through OpenRouter instead — and fails outright for a model OpenRouter does not carry.",
  "SETTINGS$PROVIDER_LABEL": "Provider",
  "SETTINGS$PROVIDER_USED_BY_DEFAULT": "Used by default",
  "SETTINGS$PRO_PILL": "Pro",
  "SETTINGS$REFRESH_LLM_API_KEY": "Refresh API Key",
  "SETTINGS$REPOSITORY_SETUP_MODEL": "Repository Setup Agent model",
  "SETTINGS$REPOSITORY_SETUP_MODEL_DESCRIPTION": "Analyzes repository requirements and validates setup and runtime configuration.",
  "SETTINGS$RESEND_VERIFICATION": "Resend verification",
  "SETTINGS$RESET": "Settings reset",
  "SETTINGS$RESET_CONFIRMATION": "Are you sure you want to reset all settings?",
  "SETTINGS$REVIEW_VERIFIER_ENABLE": "Verify every review before it is posted",
  "SETTINGS$REVIEW_VERIFIER_ENABLE_DESCRIPTION": "An independent pass reads the proposed review against the diff and rejects unsupported, stale, or incomplete findings. Turning this off posts reviews unchecked.",
  "SETTINGS$REVIEW_VERIFIER_MODEL": "Review verifier model",
  "SETTINGS$REVIEW_VERIFIER_MODEL_DESCRIPTION": "Choose a different model from the one that writes the review. A model that produced an unsupported finding is the worst judge of whether it is supported.",
  "SETTINGS$RUNTIME_OPTION_1X": "1x (2 core, 8G)",
  "SETTINGS$RUNTIME_OPTION_2X": "2x (4 core, 16G)",
  "SETTINGS$SAVE": "Save",
  "SETTINGS$SAVED": "Settings saved",
  "SETTINGS$SAVED_WARNING": "Settings saved. For old conversations, you will need to stop and restart the conversation to see the changes.",
  "SETTINGS$SAVE_AND_RECONNECT": "Save and reconnect",
  "SETTINGS$SAVE_CHANGES": "Save Changes",
  "SETTINGS$SAVING": "Saving...",
  "SETTINGS$SDK_SCHEMA_UNAVAILABLE": "SDK settings schema unavailable.",
  "SETTINGS$SEARCH_API_KEY": "Search API Key (Tavily)",
  "SETTINGS$SEARCH_API_KEY_INSTRUCTIONS": "Get your API key from Tavily",
  "SETTINGS$SEARCH_API_KEY_OPTIONAL": "This field is optional. We use Tavily as our default search engine provider.",
  "SETTINGS$SECRET_NAME_PATTERN_TITLE": "Must start with a letter, contain only letters/numbers/underscores, and be 1-64 characters",
  "SETTINGS$SECURITY_ANALYZER": "Enable Security Analyzer",
  "SETTINGS$SECURITY_ANALYZER_DESCRIPTION": "The security analyzer will be used in conjunction with confirmation mode. By default, it utilizes LLM-predicted action risk to determine whether to prompt the user for confirmation. If the risk is HIGH, it will prompt the user for confirmation by default.",
  "SETTINGS$SECURITY_ANALYZER_INVARIANT": "Invariant Rule-based Analyzer",
  "SETTINGS$SECURITY_ANALYZER_LLM_DEFAULT": "LLM Analyzer (Default)",
  "SETTINGS$SECURITY_ANALYZER_NONE": "None (Ask for every command)",
  "SETTINGS$SECURITY_ANALYZER_PLACEHOLDER": "Select a security analyzer…",
  "SETTINGS$SECURITY_ANALYZER_TOOLTIP": "When enabled, the agent will pause and ask for confirmation when it tries to execute high-risk actions",
  "SETTINGS$SEE_ADVANCED_SETTINGS": "see advanced settings",
  "SETTINGS$SENDING": "Sending",
  "SETTINGS$SESSION_TITLE_MODEL": "Session title model",
  "SETTINGS$SESSION_TITLE_MODEL_DESCRIPTION": "Uses a small, inexpensive model to name conversations.",
  "SETTINGS$SKILLS_ADD_BUTTON": "Add skill",
  "SETTINGS$SKILLS_ADD_FROM_GITHUB": "Add from GitHub",
  "SETTINGS$SKILLS_ADD_MODAL_CHAT_BODY": "In any chat, send the <cmd>/add-skill</cmd> command with a GitHub URL that points to the skill. OpenHands downloads the files into your workspace. New skills load when a conversation starts — Canvas will offer to start one for you.",
  "SETTINGS$SKILLS_ADD_MODAL_CHAT_TITLE": "Add from a conversation",
  "SETTINGS$SKILLS_ADD_MODAL_EXAMPLE_LABEL": "Example",
  "SETTINGS$SKILLS_ADD_MODAL_INTRO": "Extend what your agent can do by installing skills from the OpenHands registry, community repositories, or your own GitHub repos.",
  "SETTINGS$SKILLS_ADD_MODAL_PRIVATE_REPOS": "For private GitHub repositories, set <env>GITHUB_TOKEN</env> in your environment before using <cmd>/add-skill</cmd>.",
  "SETTINGS$SKILLS_ADD_MODAL_STEP_1": "Parse the URL to find the repository and skill path",
  "SETTINGS$SKILLS_ADD_MODAL_STEP_2": "Fetch the skill files from GitHub",
  "SETTINGS$SKILLS_ADD_MODAL_STEP_3": "Install the skill in the <path>.agents/skills/</path> directory of your workspace",
  "SETTINGS$SKILLS_ADD_MODAL_STEP_4": "Verify the installation",
  "SETTINGS$SKILLS_ADD_MODAL_STEP_5": "Offer to start a new conversation where the skill is active",
  "SETTINGS$SKILLS_ADD_MODAL_STORAGE_BODY": "Skills added with <cmd>/add-skill</cmd> are saved in <path>.agents/skills/</path> for the current workspace. You can also copy skill folders there manually if you prefer.",
  "SETTINGS$SKILLS_ADD_MODAL_STORAGE_TITLE": "Where skills are stored",
  "SETTINGS$SKILLS_ADD_MODAL_TITLE": "Add a skill",
  "SETTINGS$SKILLS_ADD_MODAL_URL_FORMATS": "Full GitHub tree links, repository paths, and short forms such as OpenHands/extensions/skills/codereview all work.",
  "SETTINGS$SKILLS_ADD_MODAL_URL_FORMATS_TITLE": "Supported URL formats",
  "SETTINGS$SKILLS_ADD_MODAL_VIEW_DOCS": "Read the full adding skills guide →",
  "SETTINGS$SKILLS_ALLOWED_TOOLS": "Allowed tools",
  "SETTINGS$SKILLS_COMPATIBILITY": "Compatibility",
  "SETTINGS$SKILLS_CONTENT": "Content",
  "SETTINGS$SKILLS_COPIED": "Path copied",
  "SETTINGS$SKILLS_COPY_PATH": "Copy source path",
  "SETTINGS$SKILLS_COUNT": "Showing {{shown}} of {{total}}",
  "SETTINGS$SKILLS_DESCRIPTION": "Enable or disable default skills. Disabled skills will not be loaded into agent context.",
  "SETTINGS$SKILLS_DETAILS": "Details",
  "SETTINGS$SKILLS_DISABLED": "Disabled",
  "SETTINGS$SKILLS_DISABLE_MODEL_INVOCATION": "Model invocation off",
  "SETTINGS$SKILLS_DISABLE_SKILL": "Disable skill",
  "SETTINGS$SKILLS_ENABLED": "Enabled",
  "SETTINGS$SKILLS_ENABLE_SKILL": "Enable skill",
  "SETTINGS$SKILLS_LICENSE": "License",
  "SETTINGS$SKILLS_METADATA": "Metadata",
  "SETTINGS$SKILLS_NO_DESCRIPTION": "No description provided.",
  "SETTINGS$SKILLS_NO_MATCH": "No skills match your search.",
  "SETTINGS$SKILLS_NO_SKILLS": "No skills found.",
  "SETTINGS$SKILLS_PAGE_DESCRIPTION": "Discover skills to add to your workspace. Open a card for prompts, curl, and install flows. Search from the sidebar to filter the list. Enable or disable default skills. Disabled skills will not be loaded into agent context.",
  "SETTINGS$SKILLS_PILLS_MORE": "+{{count}}",
  "SETTINGS$SKILLS_SEARCH_PLACEHOLDER": "Search skills by name, description, or trigger",
  "SETTINGS$SKILLS_SHOW_LESS": "Show less",
  "SETTINGS$SKILLS_SHOW_MORE": "Show more",
  "SETTINGS$SKILLS_SOURCE": "Source",
  "SETTINGS$SKILLS_TITLE": "Skills",
  "SETTINGS$SKILLS_TRIGGERS": "Triggers: {{triggers}}",
  "SETTINGS$SKILLS_TYPE_AGENTSKILLS": "Auto-discovery",
  "SETTINGS$SKILLS_TYPE_ALL": "All",
  "SETTINGS$SKILLS_TYPE_KNOWLEDGE": "Trigger-based",
  "SETTINGS$SKILLS_TYPE_LABEL": "Type",
  "SETTINGS$SKILLS_TYPE_REPO": "Always active",
  "SETTINGS$SKILLS_UPLOAD": "Upload a skill",
  "SETTINGS$SKILLS_USE_SKILL_BUTTON": "Use skill",
  "SETTINGS$SKILLS_VERSION": "v{{version}}",
  "SETTINGS$SKILLS_VERSION_LABEL": "Version",
  "SETTINGS$SKILLS_WRITE": "Write skill",
  "SETTINGS$SLACK": "Slack",
  "SETTINGS$SOLVABILITY_ANALYSIS": "Enable Solvability Analysis",
  "SETTINGS$SOUND_NOTIFICATIONS": "Desktop Notifications",
  "SETTINGS$SOUND_NOTIFICATIONS_DESCRIPTION": "Show OS notifications when a conversation needs your attention.",
  "SETTINGS$SUBSCRIPTION_ACCOUNT": "Account: {{account}}",
  "SETTINGS$SUBSCRIPTION_CARD_DESCRIPTION": "Use a connected ChatGPT Plus or Pro subscription to run supported Codex models without an OpenAI API key.",
  "SETTINGS$SUBSCRIPTION_CARD_TITLE": "ChatGPT subscription",
  "SETTINGS$SUBSCRIPTION_CONNECT": "Connect",
  "SETTINGS$SUBSCRIPTION_CONNECTED_TOAST": "ChatGPT subscription connected",
  "SETTINGS$SUBSCRIPTION_CONNECT_ERROR": "Unable to connect your ChatGPT subscription. Try again or check the agent-server logs.",
  "SETTINGS$SUBSCRIPTION_DEVICE_INSTRUCTIONS": "Finish signing in with OpenAI in your browser, then return here.",
  "SETTINGS$SUBSCRIPTION_DISCONNECT": "Disconnect",
  "SETTINGS$SUBSCRIPTION_DISCONNECTED_TOAST": "ChatGPT subscription disconnected",
  "SETTINGS$SUBSCRIPTION_FINISH_SIGN_IN": "I've finished signing in",
  "SETTINGS$SUBSCRIPTION_MODEL": "Subscription model",
  "SETTINGS$SUBSCRIPTION_OPEN_LOGIN": "Open sign-in page",
  "SETTINGS$SUBSCRIPTION_PENDING_TOAST": "Sign-in is not complete yet. Finish the browser flow and try again.",
  "SETTINGS$SUBSCRIPTION_STATUS_CHECKING": "Checking...",
  "SETTINGS$SUBSCRIPTION_STATUS_CONNECTED": "ChatGPT subscription connected",
  "SETTINGS$SUBSCRIPTION_STATUS_DISCONNECTED": "Not connected",
  "SETTINGS$SUBSCRIPTION_STATUS_UNAVAILABLE": "Subscription status is unavailable. Try again in a moment.",
  "SETTINGS$SUBSCRIPTION_USER_CODE": "Code: {{code}}",
  "SETTINGS$THEME": "Theme",
  "SETTINGS$THEME_DARK": "Dark",
  "SETTINGS$THEME_DESCRIPTION": "Choose the visual theme for the interface.",
  "SETTINGS$THEME_LIGHT": "Light",
  "SETTINGS$THEME_SYSTEM": "System",
  "SETTINGS$TITLE": "Settings",
  "SETTINGS$TITLE_GENERATION_AUTOMATIC": "Automatic (recommended)",
  "SETTINGS$TITLE_GENERATION_DESCRIPTION": "Choose which LLM profile creates conversation titles. Automatic uses your default LLM profile.",
  "SETTINGS$TITLE_GENERATION_MODEL": "Title generation model",
  "SETTINGS$TITLE_GENERATION_PROFILE_OPTION": "{{name}} · {{model}}",
  "SETTINGS$TOGGLE_SETTINGS_MENU": "Toggle settings menu",
  "SETTINGS$UPGRADE_BUTTON": "Upgrade",
  "SETTINGS$USER_EMAIL": "Email",
  "SETTINGS$USER_EMAIL_LOADING": "Loading...",
  "SETTINGS$USER_TITLE": "User Information",
  "SETTINGS$VERIFICATION_EMAIL_SENT": "Verification email sent",
  "SETTINGS$VIEW_MODE": "Settings view",
  "SETTINGS$WARNING": "Changing settings during an active session will end the session",
  "SETTINGS_FORM$ADVANCED_OPTIONS_LABEL": "Advanced Options",
  "SETTINGS_FORM$AGENT_LABEL": "Agent",
  "SETTINGS_FORM$ALL_INFORMATION_WILL_BE_DELETED_MESSAGE": "All saved information in your AI settings will be deleted, including any API keys.",
  "SETTINGS_FORM$API_KEY": "API Key",
  "SETTINGS_FORM$API_KEY_LABEL": "API Key",
  "SETTINGS_FORM$ARE_YOU_SURE_LABEL": "Are you sure?",
  "SETTINGS_FORM$BASE_URL": "Base URL",
  "SETTINGS_FORM$BASE_URL_LABEL": "Base URL",
  "SETTINGS_FORM$CANCEL_LABEL": "Cancel",
  "SETTINGS_FORM$CHANGING_WORKSPACE_WARNING_MESSAGE": "Changing your settings will clear your workspace and start a new session. Are you sure you want to continue?",
  "SETTINGS_FORM$CLICK_HERE_FOR_INSTRUCTIONS_LABEL": "Click here for instructions",
  "SETTINGS_FORM$CLOSE_LABEL": "Close",
  "SETTINGS_FORM$CUSTOM_MODEL_LABEL": "Custom Model",
  "SETTINGS_FORM$DONT_KNOW_API_KEY_LABEL": "Don't know your API key?",
  "SETTINGS_FORM$ENABLE_CONFIRMATION_MODE_LABEL": "Enable Confirmation Mode",
  "SETTINGS_FORM$ENABLE_DEFAULT_CONDENSER_SWITCH_LABEL": "Enable Memory Condenser",
  "SETTINGS_FORM$END_SESSION_LABEL": "End Session",
  "SETTINGS_FORM$RUNTIME_SIZE_LABEL": "Runtime Settings",
  "SETTINGS_FORM$SAVE_LABEL": "Save",
  "SETTINGS_FORM$SECURITY_ANALYZER_LABEL": "Security Analyzer (Optional)",
  "SETUP$CONFIRM": "Confirm and create",
  "SETUP$EMPTY_VALUE": "Not set",
  "SETUP$MANAGE_INTEGRATIONS": "Manage integrations",
  "SETUP$PREREQUISITES_TITLE": "Before you start",
  "SETUP$REPOSITORY_PLACEHOLDER": "owner/repo",
  "SETUP$REVIEW_TITLE": "Review",
  "SETUP$SUBMIT_FAILED": "Something went wrong. Nothing was created.",
  "SETUP$UNAVAILABLE_TITLE": "Not available",
  "SETUP$UNSUPPORTED_MESSAGE": "This deployment does not support everything this automation needs.",
  "SETUP$VALIDATION_INVALID_OPTION": "Choose one of the available options.",
  "SETUP$VALIDATION_MAX_LENGTH": "Must be at most {{length}} characters.",
  "SETUP$VALIDATION_MIN_LENGTH": "Must be at least {{length}} characters.",
  "SETUP$VALIDATION_REQUIRED": "This field is required.",
  "SETUP$VALIDATION_UNSAFE_VALUE": "Quotes and backslashes are not allowed.",
  "SIDEBAR$ALL_SESSIONS": "All sessions",
  "SIDEBAR$AUTOMATIONS": "Automate",
  "SIDEBAR$CLOSE_MENU": "Close navigation menu",
  "SIDEBAR$COLLAPSE": "Collapse sidebar",
  "SIDEBAR$CONVERSATIONS": "Conversations",
  "SIDEBAR$DOCS": "Documentation",
  "SIDEBAR$EXPAND": "Expand sidebar",
  "SIDEBAR$GIT": "Git",
  "SIDEBAR$INTEGRATIONS": "Integrations",
  "SIDEBAR$MCP_DIRECTORY": "MCP Directory",
  "SIDEBAR$MY_SESSIONS": "My Sessions",
  "SIDEBAR$NAVIGATION_LABEL": "Sidebar navigation",
  "SIDEBAR$NEW_CHAT": "New Chat",
  "SIDEBAR$NEW_CONVERSATION": "New Conversation",
  "SIDEBAR$NEW_SESSION": "New session",
  "SIDEBAR$OPEN_MENU": "Open navigation menu",
  "SIDEBAR$RESIZE": "Resize session sidebar",
  "SIDEBAR$SEARCH": "Search chats and projects",
  "SIDEBAR$SETTINGS": "Settings",
  "SIDEBAR$SKILLS": "Skills",
  "SIDEBAR$SKILLS_AND_PLUGINS_CLOUD_LINK": "Skills and Plugins",
  "SKILLS$INSTALL_BANNER_ACTION": "Start new conversation with this skill",
  "SKILLS$INSTALL_BANNER_MESSAGE": "Installed to this workspace: {{skills}}. Skills load when a conversation starts, so this conversation can't use them yet.",
  "SKILLS$INVOKED_SKILL_KNOWLEDGE": "Invoked Skill Knowledge:",
  "SKILLS$TRIGGERED_SKILL_KNOWLEDGE": "Triggered Skill Knowledge:",
  "SKILLS_MODAL$NO_CONTENT": "Skill has no content",
  "SKILLS_MODAL$SECTION_PROJECT": "Project skills",
  "SKILLS_MODAL$SECTION_PUBLIC": "Public skills",
  "SKILLS_MODAL$SECTION_USER": "User skills",
  "SKILLS_MODAL$TITLE": "Available Skills",
  "SKILLS_MODAL$WARNING": "If you update the skills, you will need to stop the conversation and then click on the refresh button to see the changes.",
  "SLACK$CONNECT": "Connect Slack",
  "SLACK$CONNECTION_CONNECTED": "Connected for channel links. Direct messages remain blocked.",
  "SLACK$CONNECTION_LOADING": "Loading Slack connection...",
  "SLACK$CONNECTION_LOAD_ERROR": "Slack connection status could not be loaded.",
  "SLACK$CONNECTION_NOT_CONNECTED": "Connect your Slack account to read public and joined private channel links.",
  "SLACK$CONNECTION_TITLE": "Slack connection",
  "SLACK$INSTALL_APP": "Install OpenHands Slack App",
  "SLACK$OPEN_THREAD": "Open Slack thread",
  "SLACK_CHANNELS$ACTION_FAILED": "Could not update the Slack channel.",
  "SLACK_CHANNELS$ADD": "Add channel",
  "SLACK_CHANNELS$ASIDE_HINT": "Start a message with \"aside\" and Pilot skips it — including a channel set to every message and thread, and including a direct mention.",
  "SLACK_CHANNELS$CHANNEL_ID": "Channel ID",
  "SLACK_CHANNELS$CHANNEL_NAME": "Channel name",
  "SLACK_CHANNELS$CONFIGURE": "Configure",
  "SLACK_CHANNELS$CREATED": "Slack channel added.",
  "SLACK_CHANNELS$CREATE_TITLE": "Add Slack channel",
  "SLACK_CHANNELS$DELETED": "Slack channel deleted.",
  "SLACK_CHANNELS$DELETE_CONFIRM": "Delete the Slack channel configuration for {{channel}}?",
  "SLACK_CHANNELS$DESCRIPTION": "Choose how Pilot responds in Slack channels for {{team}}.",
  "SLACK_CHANNELS$EDIT": "Edit",
  "SLACK_CHANNELS$EDIT_TITLE": "Edit Slack channel",
  "SLACK_CHANNELS$EMPTY_DESCRIPTION": "Add a channel to enable mention-only or automatic responses.",
  "SLACK_CHANNELS$EMPTY_TITLE": "No Slack channels configured",
  "SLACK_CHANNELS$EXECUTION_USER": "Execution account",
  "SLACK_CHANNELS$FORM_DESCRIPTION": "Map a Slack channel to this team and select the account used for automated runs.",
  "SLACK_CHANNELS$LOADING": "Loading Slack channels...",
  "SLACK_CHANNELS$LOAD_FAILED": "Could not load Slack channels.",
  "SLACK_CHANNELS$NOT_CONFIGURED": "Not configured",
  "SLACK_CHANNELS$NO_AVAILABLE_TITLE": "No Slack channels found",
  "SLACK_CHANNELS$RESPONSE_MODE": "Response mode",
  "SLACK_CHANNELS$RESPONSE_MODE_ALWAYS_RESPOND": "Every message and thread",
  "SLACK_CHANNELS$RESPONSE_MODE_MENTION_ONLY": "Only when mentioned",
  "SLACK_CHANNELS$RESPONSE_MODE_NOT_REGISTERED": "Never — not registered",
  "SLACK_CHANNELS$RETRY": "Retry",
  "SLACK_CHANNELS$SAVING": "Saving...",
  "SLACK_CHANNELS$TITLE": "Channels",
  "SLACK_CHANNELS$UPDATED": "Slack channel updated.",
  "SLACK_CHANNELS$WORKSPACE_ID": "Slack workspace ID",
  "SLASH_COMMAND$ASIDE_DESCRIPTION": "Add context without asking the agent to respond",
  "SLASH_COMMAND$BTW_DESCRIPTION": "Ask a side question without derailing the main task",
  "SLASH_COMMAND$GOAL_DESCRIPTION": "Drive the agent toward an objective until a judge marks it complete",
  "SLASH_COMMAND$NEW_DESCRIPTION": "Create a new conversation using the same runtime",
  "STATUS$BUILDING_RUNTIME": "Building Runtime...",
  "STATUS$CONNECTED": "Connected",
  "STATUS$CONNECTED_TO_SERVER": "Connected to server",
  "STATUS$CONNECTING_TO_RUNTIME": "Connecting to runtime...",
  "STATUS$CONNECTION_LOST": "Connection lost",
  "STATUS$DISCONNECTED_REFRESH_PAGE": "Disconnected. Please refresh the page",
  "STATUS$ERROR": "An error occurred. Please try again.",
  "STATUS$ERROR_LLM_AUTHENTICATION": "Error authenticating with the LLM provider. Please check your API key",
  "STATUS$ERROR_LLM_CONTENT_POLICY_VIOLATION": "Content policy violation. The output was blocked by content filtering policy.",
  "STATUS$ERROR_LLM_INTERNAL_SERVER_ERROR": "The request failed with an internal server error.",
  "STATUS$ERROR_LLM_SERVICE_UNAVAILABLE": "The LLM provider is currently unavailable. Please try again later.",
  "STATUS$ERROR_MEMORY": "Memory error occurred. Please try reducing the workload or restarting.",
  "STATUS$ERROR_RUNTIME_DISCONNECTED": "There was an error while connecting to the runtime. Please refresh the page.",
  "STATUS$GIT_PROVIDER_AUTHENTICATION_ERROR": "Error authenticating with the Git provider. Please check your credentials.",
  "STATUS$LLM_RETRY": "Retrying LLM request",
  "STATUS$SAVING": "Saving...",
  "STATUS$SETTING_UP_GIT_HOOKS": "Adding git hooks",
  "STATUS$SETTING_UP_SKILLS": "Adding skills",
  "STATUS$SETTING_UP_WORKSPACE": "Setting up workspace...",
  "STATUS$STARTING_RUNTIME": "Starting runtime... (this may take 1-2 minutes)",
  "STATUS$WEBSOCKET_CLOSED": "The WebSocket connection was closed.",
  "SUGGESTIONS$ADD_DOCKERFILE": "Add/improve a Dockerfile",
  "SUGGESTIONS$ADD_DOCS": "Add best practices docs for contributors",
  "SUGGESTIONS$AUTO_MERGE": "Auto-merge Dependabot PRs",
  "SUGGESTIONS$AUTO_MERGE_PRS": "Auto-merge Dependabot PRs",
  "SUGGESTIONS$CLEAN_DEPENDENCIES": "Clean up dependencies",
  "SUGGESTIONS$FIX_README": "Improve README",
  "SUGGESTIONS$HACKER_NEWS": "Write a bash script that shows the top story on Hacker News",
  "SUGGESTIONS$HELLO_WORLD": "Create a Hello World app",
  "SUGGESTIONS$INCREASE_TEST_COVERAGE": "Increase test coverage",
  "SUGGESTIONS$TEST_COVERAGE": "Increase my test coverage",
  "SUGGESTIONS$TODO_APP": "Build a todo list application",
  "SUGGESTIONS$WHAT_TO_BUILD": "What do you want to build?",
  "SYSTEM_MESSAGE_MODAL$AGENT_CLASS": "Agent Class:",
  "SYSTEM_MESSAGE_MODAL$NO_TOOLS": "No tools available for this agent",
  "SYSTEM_MESSAGE_MODAL$OPENHANDS_VERSION": "OpenHands Version:",
  "SYSTEM_MESSAGE_MODAL$PARAMETERS": "Parameters:",
  "SYSTEM_MESSAGE_MODAL$SYSTEM_MESSAGE_TAB": "System Message",
  "SYSTEM_MESSAGE_MODAL$TITLE": "Agent Tools & Metadata",
  "SYSTEM_MESSAGE_MODAL$TOOLS_TAB": "Available Tools",
  "TASK$ADDRESSING_TASK": "Addressing task...",
  "TASK$QUERY": "Query",
  "TASK$RESULT": "Result",
  "TASK$SUBAGENT": "Subagent:",
  "TASK$TASK_ID": "Task ID:",
  "TASKS$NO_TASKS_AVAILABLE": "No tasks available",
  "TASKS$SUGGESTED_TASKS": "Suggested Tasks",
  "TASKS$TASK_SUGGESTIONS_INFO": "Task suggestions information",
  "TASKS$TASK_SUGGESTIONS_TOOLTIP": "These are AI-curated task suggestions to help you get started with common development activities and best practices for your repository.",
  "TASK_TRACKING_OBSERVATION$OUTPUT": "Output",
  "TASK_TRACKING_OBSERVATION$RESULT": "Result",
  "TASK_TRACKING_OBSERVATION$TASK_ID": "ID",
  "TASK_TRACKING_OBSERVATION$TASK_LIST": "Task List",
  "TASK_TRACKING_OBSERVATION$TASK_NOTES": "Notes",
  "TERMINAL$CONSOLE": "Console",
  "TERMINAL$NO_OUTPUT": "No terminal output yet. Commands run by the agent will appear here.",
  "TERMINAL$WAITING_FOR_CLIENT": "Waiting for client to become ready...",
  "TEST_ACCOUNTS$ACTION_FAILED": "Test account action failed.",
  "TEST_ACCOUNTS$ADD": "Add test account",
  "TEST_ACCOUNTS$ADD_FIELD": "Add field",
  "TEST_ACCOUNTS$CREATED": "Test account created.",
  "TEST_ACCOUNTS$CREATE_TITLE": "Add test account",
  "TEST_ACCOUNTS$DELETE": "Delete",
  "TEST_ACCOUNTS$DELETED": "Test account deleted.",
  "TEST_ACCOUNTS$DELETE_CONFIRM": "Delete {{name}}?",
  "TEST_ACCOUNTS$DELETE_CONFIRM_DESCRIPTION": "Agents will lose access immediately.",
  "TEST_ACCOUNTS$DESCRIPTION": "Description",
  "TEST_ACCOUNTS$DESCRIPTION_TEXT": "Store E2E account data and choose which repositories may use it. Authorized organization members can view configured values, while agents resolve them only for eligible sandboxes.",
  "TEST_ACCOUNTS$EDIT": "Edit",
  "TEST_ACCOUNTS$EDITOR_DESCRIPTION": "Values are encrypted at rest. Authorized organization members can reveal them here, and agents can resolve them only for repositories assigned to an eligible sandbox.",
  "TEST_ACCOUNTS$EDIT_TITLE": "Edit test account",
  "TEST_ACCOUNTS$FIELD_DUPLICATE": "Field names must be unique.",
  "TEST_ACCOUNTS$FIELD_INCOMPLETE": "Enter a name and value for every changed field.",
  "TEST_ACCOUNTS$FIELD_KEY": "Field name",
  "TEST_ACCOUNTS$FIELD_VALUE": "Value",
  "TEST_ACCOUNTS$HIDE_VALUE": "Hide value",
  "TEST_ACCOUNTS$NAME": "Name",
  "TEST_ACCOUNTS$REMOVE_FIELD": "Remove field",
  "TEST_ACCOUNTS$REPOSITORIES": "Allowed repositories",
  "TEST_ACCOUNTS$REPOSITORY_REQUIRED": "Select at least one repository.",
  "TEST_ACCOUNTS$SAVE": "Save account",
  "TEST_ACCOUNTS$SHOW_VALUE": "Show value",
  "TEST_ACCOUNTS$UPDATED": "Test account updated.",
  "TEST_ACCOUNTS$VALUE": "Account fields",
  "TEST_ACCOUNTS$VALUE_EDIT_HELP": "Values are masked by default. Reveal them to review or edit them; leave every value blank to keep the stored credential.",
  "TEST_ACCOUNTS$VALUE_REQUIRED": "Add at least one account field.",
  "THINKING$COLLAPSE": "Collapse thinking",
  "THINKING$EXPAND": "Expand thinking",
  "THINKING$TITLE": "Thinking",
  "TIME$DAYS_AGO": "days ago",
  "TIME$HOURS_AGO": "hours ago",
  "TIME$MINUTES_AGO": "minutes ago",
  "TIPS$API_USAGE": "OpenHands has an API! Create OpenHands conversations with simple cURL command.",
  "TIPS$BLOG_SIGNUP": "Sign up for the OpenHands Blog to hear about new features and the latest releases.",
  "TIPS$CLI_MODE": "You can run OpenHands as a CLI, similar to Claude Code.",
  "TIPS$CUSTOMIZE_MICROAGENT": "You can customize OpenHands for your repo using an available microagent. Ask OpenHands to put a description of the repo, including how to run the code, into .openhands/microagents/repo.md.",
  "TIPS$GITHUB_HOOK": "OpenHands Cloud offers a GitHub hook, so you can say \"@openhands fix the merge conflicts\" or \"@openhands fix the feedback on this PR\" right inside the GitHub UI.",
  "TIPS$HEADLESS_MODE": "You can run OpenHands in headless mode to create automations, like responding to 500 errors by automatically creating a fix.",
  "TIPS$LEARN_MORE": "Learn more",
  "TIPS$PROTIP": "Protip",
  "TIPS$SAVE_WORK": "Be sure to regularly save your work, either by pushing to GitHub or by downloading your files via VS Code.",
  "TIPS$SETUP_SCRIPT": "You can add .openhands/setup.sh to your repository to automatically run a setup script every time you start an OpenHands conversation.",
  "TIPS$SPECIFY_FILES": "When possible, include the names of files or functions OpenHands should focus on. This can help OpenHands work faster, save money, and improve accuracy.",
  "TOAST$CONVERSATION_STOPPED": "Conversation stopped",
  "TOAST$FAILED_TO_STOP_CONVERSATION": "Failed to stop conversation",
  "TOAST$STOPPING_CONVERSATION": "Stopping conversation...",
  "TOS$ACCEPT": "I accept the",
  "TOS$ACCEPT_TERMS_DESCRIPTION": "Please review and accept our terms of service before continuing",
  "TOS$ACCEPT_TERMS_OF_SERVICE": "Accept Terms of Service",
  "TOS$CONTINUE": "Continue",
  "TOS$ERROR_ACCEPTING": "Error accepting Terms of Service",
  "TOS$TERMS": "terms of service",
  "TRANSCRIPT_EXPORT$DEFAULT_TITLE": "Conversation transcript",
  "TRANSCRIPT_EXPORT$DESCRIPTION": "Download a shareable transcript without sending conversation data anywhere.",
  "TRANSCRIPT_EXPORT$FORMAT": "Format",
  "TRANSCRIPT_EXPORT$HOOK": "Hook: {{command}}",
  "TRANSCRIPT_EXPORT$HTML": "Standalone web page (.html)",
  "TRANSCRIPT_EXPORT$INCLUDE_TIMESTAMPS": "Include timestamps",
  "TRANSCRIPT_EXPORT$INCLUDE_TOOL_DETAILS": "Include tool call details",
  "TRANSCRIPT_EXPORT$MARKDOWN": "Markdown document (.md)",
  "TRANSCRIPT_EXPORT$MODEL": "Model",
  "TRANSCRIPT_EXPORT$REASON": "Reason",
  "TRANSCRIPT_EXPORT$TITLE": "Export conversation",
  "TRANSCRIPT_EXPORT$TOOL": "Tool",
  "TRANSCRIPT_EXPORT$USER": "User",
  "USAGE$AUTOMATED_ACTOR": "Automated work",
  "USAGE$AUTOMATION_NAME_COLUMN": "Automation",
  "USAGE$BY_AUTOMATION_TITLE": "Usage by automation",
  "USAGE$BY_CATEGORY_TITLE": "Usage by category",
  "USAGE$BY_MEMBER_TITLE": "Usage by member",
  "USAGE$BY_PROVIDER_TITLE": "By provider",
  "USAGE$CATEGORY_AUTOMATION": "Automation",
  "USAGE$CATEGORY_COLUMN": "Category",
  "USAGE$CATEGORY_COST_DISTRIBUTION": "Cost distribution by category",
  "USAGE$CATEGORY_FILTER_LABEL": "Category",
  "USAGE$CATEGORY_OTHER": "Other",
  "USAGE$CHART_GROUPING_LABEL": "Group daily spend",
  "USAGE$COMPLETION_TOKENS": "Completion tokens",
  "USAGE$COST": "Cost",
  "USAGE$DAILY_BAR_LABEL": "{{date}}, {{cost}}",
  "USAGE$DAILY_COST_TITLE": "Daily spend",
  "USAGE$DATE_RANGE": "Date range",
  "USAGE$INVALID_DATE_RANGE": "Choose a range of up to 31 days with the start date on or before the end date.",
  "USAGE$LOADING": "Loading usage...",
  "USAGE$LOAD_ERROR": "Usage data could not be loaded.",
  "USAGE$MEMBER": "Member",
  "USAGE$ORGANIZATION_USAGE": "Organization usage",
  "USAGE$PROMPT_TOKENS": "Prompt tokens",
  "USAGE$PROVIDER_ALL": "All providers",
  "USAGE$PROVIDER_COLUMN": "Provider",
  "USAGE$PROVIDER_FILTER_LABEL": "Provider",
  "USAGE$PROVIDER_OPENAI": "OpenAI",
  "USAGE$PROVIDER_OPENROUTER": "OpenRouter",
  "USAGE$PROVIDER_OTHER": "Other",
  "USAGE$SESSIONS": "Sessions",
  "USAGE$SUBSCRIPTION_NOTE": "Work that ran on the organization's ChatGPT plan. The plan is a flat fee, so these tokens are already included in the organization cost above rather than added to it.",
  "USAGE$SUBSCRIPTION_TITLE": "ChatGPT subscription",
  "USAGE$TOKENS_ONLY_NOTE": "Cost is hidden here because a ChatGPT subscription is a flat fee: its calls spend tokens but add nothing to a bill. Select OpenRouter to see metered spend.",
  "USAGE$TOTAL_TOKENS": "Total tokens",
  "USAGE$UNKNOWN_AUTOMATION": "Unknown automation",
  "USAGE$YOUR_USAGE": "Your usage",
  "USER$ACCOUNT_SETTINGS": "Account settings",
  "USER$AVATAR_PLACEHOLDER": "user avatar placeholder",
  "WAITLIST$ALMOST_THERE": "Almost there!",
  "WAITLIST$IF_NOT_JOINED": "If you haven't already joined the waitlist, please do so to get access.",
  "WAITLIST$JOIN_WAITLIST": "Join Waitlist",
  "WAITLIST$PATIENCE_MESSAGE": "Thank you for your patience. We're working hard to give you access as soon as possible.",
  "WORKSPACE$CODE_EDITOR_TAB_LABEL": "Code Editor",
  "WORKSPACE$JUPYTER_TAB_LABEL": "Jupyter",
  "WORKSPACE$TERMINAL_TAB_LABEL": "Terminal",
  "WORKSPACE$TITLE": "Workspace"
}