5435 lines
214 KiB
TypeScript
5435 lines
214 KiB
TypeScript
// This file is automatically generated by i18next-cli. Do not edit manually.
|
||
export default interface Resources {
|
||
common: {
|
||
actions: {
|
||
cancel: 'Cancel';
|
||
close: 'Close';
|
||
closeDialog: 'Close dialog';
|
||
copied: 'Copied';
|
||
copyToClipboard: 'Copy to clipboard';
|
||
copyUrl: 'Copy URL';
|
||
goToDashboard: 'Go to Dashboard';
|
||
hide: 'Hide';
|
||
moreActions: 'More actions';
|
||
open: 'Open';
|
||
or: 'or';
|
||
refresh: 'Refresh';
|
||
reset: 'Reset';
|
||
resetSelection: 'Reset selection';
|
||
retry: 'Retry';
|
||
reveal: 'Reveal';
|
||
save: 'Save';
|
||
showLess: 'Show less';
|
||
showMore: 'Show more';
|
||
};
|
||
brand: {
|
||
claude: 'Claude';
|
||
};
|
||
chat: {
|
||
bottom: 'Bottom';
|
||
compact: {
|
||
compacted: 'Compacted';
|
||
contextCompacted: 'Context compacted';
|
||
conversationCompacted: 'Conversation Compacted';
|
||
freedTokens: '({{tokens}} freed)';
|
||
phase: 'Phase {{phase}}';
|
||
summary: 'Previous messages were summarized to save context. The full conversation history is preserved in the session file.';
|
||
toggle: 'Toggle compacted content';
|
||
};
|
||
context: {
|
||
count: 'Context ({{count}})';
|
||
count_few: 'Context ({{count}})';
|
||
count_many: 'Context ({{count}})';
|
||
count_one: 'Context ({{count}})';
|
||
count_other: 'Context ({{count}})';
|
||
remainingPercent: '({{percent}}% left)';
|
||
};
|
||
empty: {
|
||
description: 'This session does not contain any messages yet.';
|
||
icon: '💬';
|
||
title: 'No conversation history';
|
||
};
|
||
executionTrace: {
|
||
empty: 'No execution items';
|
||
input: 'Input';
|
||
nested: 'Nested: {{name}}';
|
||
};
|
||
items: {
|
||
empty: 'No items to display';
|
||
};
|
||
lastOutput: {
|
||
planReadyForApproval: 'Plan Ready for Approval';
|
||
requestInterrupted: 'Request interrupted by user';
|
||
};
|
||
scrollToBottom: 'Scroll to bottom';
|
||
subagent: {
|
||
fallbackName: 'Subagent';
|
||
meta: {
|
||
duration: 'Duration';
|
||
id: 'ID';
|
||
model: 'Model';
|
||
type: 'Type';
|
||
};
|
||
metrics: {
|
||
contextUsage: 'Context Usage';
|
||
contextWindow: 'Context Window';
|
||
mainContext: 'Main Context';
|
||
phase: 'Phase {{phase}}';
|
||
subagentContext: 'Subagent Context';
|
||
totalOutput: 'Total Output';
|
||
turns: '({{count}} turns)';
|
||
turns_few: '({{count}} turns)';
|
||
turns_many: '({{count}} turns)';
|
||
turns_one: '({{count}} turn)';
|
||
turns_other: '({{count}} turns)';
|
||
};
|
||
shutdownConfirmed: 'Shutdown confirmed';
|
||
summary: {
|
||
tools: '{{count}} tools';
|
||
tools_few: '{{count}} tools';
|
||
tools_many: '{{count}} tools';
|
||
tools_one: '{{count}} tool';
|
||
tools_other: '{{count}} tools';
|
||
};
|
||
trace: {
|
||
title: 'Execution Trace';
|
||
};
|
||
};
|
||
system: {
|
||
label: 'System';
|
||
};
|
||
teammateMessage: {
|
||
fallback: 'Teammate message';
|
||
message: 'Message';
|
||
resent: 'Resent';
|
||
};
|
||
tools: {
|
||
duration: 'Duration: {{duration}}';
|
||
noResultReceived: 'No result received';
|
||
result: 'Result';
|
||
shutdownRequested: 'Shutdown requested ->';
|
||
skill: {
|
||
instructions: 'Skill Instructions';
|
||
unknown: 'Unknown Skill';
|
||
};
|
||
teammateSpawned: 'Teammate spawned';
|
||
write: {
|
||
createdFile: 'Created file';
|
||
wroteToFile: 'Wrote to file';
|
||
};
|
||
};
|
||
user: {
|
||
backgroundTask: 'Background task';
|
||
exitCode: 'exit {{code}}';
|
||
imagesAttached: '{{count}} images attached';
|
||
imagesAttached_few: '{{count}} images attached';
|
||
imagesAttached_many: '{{count}} images attached';
|
||
imagesAttached_one: '{{count}} image attached';
|
||
imagesAttached_other: '{{count}} images attached';
|
||
showLess: 'Show less';
|
||
showMore: 'Show more';
|
||
you: 'You';
|
||
};
|
||
};
|
||
code: {
|
||
code: 'Code';
|
||
line: 'line {{line}}';
|
||
lines: 'lines {{from}}-{{to}}';
|
||
linesParenthesized: '(lines {{from}}-{{to}})';
|
||
markdownPreview: 'Markdown Preview';
|
||
mermaidSyntaxError: 'Mermaid syntax error';
|
||
moreLines: '({{count}} more lines...)';
|
||
moreLines_few: '({{count}} more lines...)';
|
||
moreLines_many: '({{count}} more lines...)';
|
||
moreLines_one: '({{count}} more line...)';
|
||
moreLines_other: '({{count}} more lines...)';
|
||
preview: 'Preview';
|
||
};
|
||
codexLogin: {
|
||
copyFailed: 'Copy failed';
|
||
copyLink: 'Copy link';
|
||
copyLinkAndCode: 'Copy link + code';
|
||
copyLoginLink: 'Copy ChatGPT login link';
|
||
copyLoginLinkAndCode: 'Copy ChatGPT login link and code';
|
||
enterCodeOnLoginPage: 'Enter this code on the ChatGPT login page';
|
||
};
|
||
commandPalette: {
|
||
currentProject: 'Current project';
|
||
empty: {
|
||
minChars: 'Type at least 2 characters to search';
|
||
noFastResults: 'No fast results in recent sessions for "{{query}}"';
|
||
noProjects: 'No projects found';
|
||
noProjectsForQuery: 'No projects found for "{{query}}"';
|
||
noResults: 'No results found for "{{query}}"';
|
||
};
|
||
footer: {
|
||
close: 'close';
|
||
escapeKey: 'esc';
|
||
fastPrefix: 'fast ';
|
||
global: 'global';
|
||
navigate: 'navigate';
|
||
open: 'open';
|
||
projectsCount: '{{count}} projects';
|
||
projectsCount_few: '{{count}} projects';
|
||
projectsCount_many: '{{count}} projects';
|
||
projectsCount_one: '{{count}} project';
|
||
projectsCount_other: '{{count}} projects';
|
||
results: '{{count}} {{speed}}results';
|
||
resultsAcrossProjects: '{{count}} {{speed}}results across all projects';
|
||
resultsAcrossProjects_few: '{{count}} {{speed}}results across all projects';
|
||
resultsAcrossProjects_many: '{{count}} {{speed}}results across all projects';
|
||
resultsAcrossProjects_one: '{{count}} {{speed}}result across all projects';
|
||
resultsAcrossProjects_other: '{{count}} {{speed}}results across all projects';
|
||
results_few: '{{count}} {{speed}}results';
|
||
results_many: '{{count}} {{speed}}results';
|
||
results_one: '{{count}} {{speed}}result';
|
||
results_other: '{{count}} {{speed}}results';
|
||
select: 'select';
|
||
typeToSearch: 'Type to search';
|
||
upDownKey: '↑↓';
|
||
};
|
||
global: 'Global';
|
||
mode: {
|
||
searchAcrossProjects: 'Search across all projects';
|
||
searchInProject: 'Search in project';
|
||
searchProjects: 'Search projects';
|
||
};
|
||
noRecentActivity: 'No recent activity';
|
||
placeholders: {
|
||
conversations: 'Search conversations...';
|
||
projects: 'Search projects...';
|
||
};
|
||
sessionsCount: '{{count}} sessions';
|
||
sessionsCount_few: '{{count}} sessions';
|
||
sessionsCount_many: '{{count}} sessions';
|
||
sessionsCount_one: '{{count}} session';
|
||
sessionsCount_other: '{{count}} sessions';
|
||
};
|
||
context: {
|
||
loadingWorkspace: 'Loading workspace';
|
||
local: 'Local';
|
||
switchWorkspace: 'Switch Workspace';
|
||
switchingTo: 'Switching to {{workspace}}';
|
||
};
|
||
contextBadge: {
|
||
badge: 'Context';
|
||
breakdown: {
|
||
text: 'Text';
|
||
thinking: 'Thinking';
|
||
};
|
||
detailsAria: 'Context injection details';
|
||
sectionSummary: '{{title}} ({{count}}) ~{{tokens}} tokens';
|
||
sectionSummary_few: '{{title}} ({{count}}) ~{{tokens}} tokens';
|
||
sectionSummary_many: '{{title}} ({{count}}) ~{{tokens}} tokens';
|
||
sectionSummary_one: '{{title}} ({{count}}) ~{{tokens}} tokens';
|
||
sectionSummary_other: '{{title}} ({{count}}) ~{{tokens}} tokens';
|
||
sections: {
|
||
claudeMdFiles: 'CLAUDE.md Files';
|
||
mentionedFiles: 'Mentioned Files';
|
||
taskCoordination: 'Task Coordination';
|
||
thinkingText: 'Thinking + Text';
|
||
toolOutputs: 'Tool Outputs';
|
||
userMessages: 'User Messages';
|
||
};
|
||
title: 'New Context Injected In This Turn';
|
||
tokenCount: '~{{tokens}} tokens';
|
||
totalNewTokens: 'Total new tokens';
|
||
turn: 'Turn {{turn}}';
|
||
};
|
||
diff: {
|
||
changed: 'Changed';
|
||
noChangesDetected: 'No changes detected';
|
||
};
|
||
editorFormatting: {
|
||
bold: 'Bold';
|
||
code: 'Code';
|
||
italic: 'Italic';
|
||
strike: 'Strike';
|
||
};
|
||
errorBoundary: {
|
||
componentStack: 'Component Stack';
|
||
copied: 'Copied';
|
||
copyErrorDetails: 'Copy Error Details';
|
||
description: 'An unexpected error occurred in the application. You can try reloading the page or resetting the error state.';
|
||
diagnosticsNotice: 'GitHub bug reports and copied diagnostics include the error message, stack traces, app version, active tab, selected team, task context, and environment details.';
|
||
reloadApp: 'Reload App';
|
||
reportBugOnGitHub: 'Report Bug on GitHub';
|
||
title: 'Something went wrong';
|
||
tryAgain: 'Try Again';
|
||
};
|
||
export: {
|
||
session: 'Export session';
|
||
sessionTitle: 'Export Session';
|
||
};
|
||
layout: {
|
||
closeTab: 'Close tab';
|
||
collapseSidebarShortcut: 'Collapse sidebar ({{shortcut}})';
|
||
discord: 'Discord';
|
||
expandSidebar: 'Expand sidebar';
|
||
github: 'GitHub';
|
||
jumpToSection: 'Jump to section';
|
||
loadingTab: 'Loading tab';
|
||
menu: {
|
||
analyzeSession: 'Analyze Session';
|
||
docs: 'Docs';
|
||
exportJson: 'Export as JSON';
|
||
exportMarkdown: 'Export as Markdown';
|
||
exportPlainText: 'Export as Plain Text';
|
||
extensions: 'Extensions';
|
||
schedules: 'Schedules';
|
||
search: 'Search';
|
||
settings: 'Settings';
|
||
teams: 'Teams';
|
||
};
|
||
newTab: 'New tab';
|
||
newTabDashboard: 'New tab (Dashboard)';
|
||
openedFromSearch: 'Opened from search';
|
||
pinnedSession: 'Pinned session';
|
||
refreshSession: 'Refresh session';
|
||
refreshSessionWithShortcut: 'Refresh Session ({{shortcut}})';
|
||
resizeSidebar: 'Resize sidebar';
|
||
sections: {
|
||
claudeLogs: 'Logs';
|
||
kanban: 'Kanban';
|
||
messages: 'Messages';
|
||
sessions: 'Sessions';
|
||
team: 'Team';
|
||
};
|
||
sidebarView: 'Sidebar view';
|
||
tabMenu: {
|
||
closeAllTabs: 'Close All Tabs';
|
||
closeOtherTabs: 'Close Other Tabs';
|
||
closeTab: 'Close Tab';
|
||
closeTabs: 'Close {{count}} Tabs';
|
||
closeTabs_few: 'Close {{count}} Tabs';
|
||
closeTabs_many: 'Close {{count}} Tabs';
|
||
closeTabs_one: 'Close {{count}} Tab';
|
||
closeTabs_other: 'Close {{count}} Tabs';
|
||
hideFromSidebar: 'Hide from Sidebar';
|
||
pinToSidebar: 'Pin to Sidebar';
|
||
splitLeft: 'Split Left';
|
||
splitRight: 'Split Right';
|
||
unhideFromSidebar: 'Unhide from Sidebar';
|
||
unpinFromSidebar: 'Unpin from Sidebar';
|
||
};
|
||
};
|
||
list: {
|
||
actions: {
|
||
copyTeam: 'Copy team';
|
||
createTeam: 'Create Team';
|
||
deleteForever: 'Delete forever';
|
||
deletePermanently: 'Delete permanently';
|
||
deleteTeam: 'Delete team';
|
||
launchTeam: 'Launch team';
|
||
launching: 'Launching...';
|
||
relaunchTeam: 'Relaunch team';
|
||
restore: 'Restore';
|
||
restoreTeam: 'Restore team';
|
||
retry: 'Retry';
|
||
stopTeam: 'Stop team';
|
||
stopping: 'Stopping...';
|
||
};
|
||
all: 'All';
|
||
membersCount: 'Members: {{count}}';
|
||
membersCount_few: 'Members: {{count}}';
|
||
membersCount_many: 'Members: {{count}}';
|
||
membersCount_one: 'Member: {{count}}';
|
||
membersCount_other: 'Members: {{count}}';
|
||
moreCount: '+{{count}} more';
|
||
moreCount_few: '+{{count}} more';
|
||
moreCount_many: '+{{count}} more';
|
||
moreCount_one: '+{{count}} more';
|
||
moreCount_other: '+{{count}} more';
|
||
noDescription: 'No description';
|
||
partial: {
|
||
pending: 'Last launch is still reconciling.';
|
||
skipped: 'Last launch has skipped teammates.';
|
||
skippedWithCount: 'Last launch skipped {{count}}/{{expected}} teammate.';
|
||
skippedWithCount_few: 'Last launch skipped {{count}}/{{expected}} teammates.';
|
||
skippedWithCount_many: 'Last launch skipped {{count}}/{{expected}} teammates.';
|
||
skippedWithCount_one: 'Last launch skipped {{count}}/{{expected}} teammate.';
|
||
skippedWithCount_other: 'Last launch skipped {{count}}/{{expected}} teammates.';
|
||
stopped: 'Last launch stopped before all teammates joined.';
|
||
stoppedWithCount: 'Last launch stopped before {{count}}/{{expected}} teammate joined.';
|
||
stoppedWithCount_few: 'Last launch stopped before {{count}}/{{expected}} teammates joined.';
|
||
stoppedWithCount_many: 'Last launch stopped before {{count}}/{{expected}} teammates joined.';
|
||
stoppedWithCount_one: 'Last launch stopped before {{count}}/{{expected}} teammate joined.';
|
||
stoppedWithCount_other: 'Last launch stopped before {{count}}/{{expected}} teammates joined.';
|
||
};
|
||
solo: 'Solo';
|
||
status: {
|
||
active: 'Active';
|
||
deleted: 'Deleted';
|
||
launching: 'Launching...';
|
||
offline: 'Offline';
|
||
partialFailure: 'Launch failed partway';
|
||
partialPending: 'Bootstrap pending';
|
||
partialSkipped: 'Launch skipped member';
|
||
running: 'Running';
|
||
};
|
||
};
|
||
locales: {
|
||
emptyMessage: 'No language found.';
|
||
names: {
|
||
ar: 'Arabic';
|
||
bn: 'Bengali';
|
||
de: 'German';
|
||
en: 'English';
|
||
es: 'Spanish';
|
||
fr: 'French';
|
||
hi: 'Hindi';
|
||
id: 'Indonesian';
|
||
ja: 'Japanese';
|
||
ko: 'Korean';
|
||
pt: 'Portuguese';
|
||
ru: 'Russian';
|
||
system: 'System';
|
||
ur: 'Urdu';
|
||
zh: 'Chinese';
|
||
};
|
||
searchPlaceholder: 'Search language...';
|
||
selectPlaceholder: 'Select app language...';
|
||
systemWithResolved: 'System - {{locale}}';
|
||
};
|
||
markdown: {
|
||
imageFallback: '[Image: {{label}}]';
|
||
largeContentNotice: 'Content is very large ({{count}} chars). Showing raw preview to keep the UI responsive.';
|
||
largeContentNotice_few: 'Content is very large ({{count}} chars). Showing raw preview to keep the UI responsive.';
|
||
largeContentNotice_many: 'Content is very large ({{count}} chars). Showing raw preview to keep the UI responsive.';
|
||
largeContentNotice_one: 'Content is very large ({{count}} chars). Showing raw preview to keep the UI responsive.';
|
||
largeContentNotice_other: 'Content is very large ({{count}} chars). Showing raw preview to keep the UI responsive.';
|
||
largeContentTitle: 'Large content is shown as raw to prevent UI freeze';
|
||
raw: 'Raw';
|
||
rawPreview: 'Raw preview';
|
||
renderMarkdown: 'Render markdown';
|
||
showAll: 'Show all';
|
||
showMore: 'Show more';
|
||
showRaw: 'Show raw';
|
||
showingChars: 'Showing {{shown}} / {{total}} chars';
|
||
};
|
||
members: {
|
||
emptyMessage: 'No members found.';
|
||
searchPlaceholder: 'Search members...';
|
||
teammateFallback: 'teammate';
|
||
unassigned: 'Unassigned';
|
||
};
|
||
notifications: {
|
||
actions: {
|
||
clearAll: 'Clear all';
|
||
clearAllNotifications: 'Clear all notifications';
|
||
clearFiltered: 'Clear filtered';
|
||
clearFilteredNotifications: 'Clear filtered notifications';
|
||
clickToConfirm: 'Click to confirm';
|
||
markAllAsRead: 'Mark all as read';
|
||
markAllRead: 'Mark all read';
|
||
markFilteredAsRead: 'Mark filtered as read';
|
||
markFilteredRead: 'Mark filtered read';
|
||
};
|
||
counts: {
|
||
inFilter: '{{count}} in filter';
|
||
inFilter_few: '{{count}} in filter';
|
||
inFilter_many: '{{count}} in filter';
|
||
inFilter_one: '{{count}} in filter';
|
||
inFilter_other: '{{count}} in filter';
|
||
total: '{{count}} total';
|
||
total_few: '{{count}} total';
|
||
total_many: '{{count}} total';
|
||
total_one: '{{count}} total';
|
||
total_other: '{{count}} total';
|
||
unread: '{{count}} unread';
|
||
unreadInFilter: '{{count}} unread in filter';
|
||
unreadInFilter_few: '{{count}} unread in filter';
|
||
unreadInFilter_many: '{{count}} unread in filter';
|
||
unreadInFilter_one: '{{count}} unread in filter';
|
||
unreadInFilter_other: '{{count}} unread in filter';
|
||
unread_few: '{{count}} unread';
|
||
unread_many: '{{count}} unread';
|
||
unread_one: '{{count}} unread';
|
||
unread_other: '{{count}} unread';
|
||
};
|
||
empty: {
|
||
allCaughtUp: "You're all caught up!";
|
||
noMatching: 'No matching notifications';
|
||
noNotifications: 'No notifications';
|
||
tryDifferentFilter: 'Try a different filter';
|
||
};
|
||
filters: {
|
||
other: 'Other';
|
||
};
|
||
loading: 'Loading notifications...';
|
||
row: {
|
||
delete: 'Delete';
|
||
markAsRead: 'Mark as read';
|
||
subagent: 'subagent';
|
||
team: 'team';
|
||
viewInSession: 'View in session';
|
||
};
|
||
title: 'Notifications';
|
||
};
|
||
providerModelBadges: {
|
||
checkFailed: 'Check failed';
|
||
checking: 'Checking';
|
||
free: 'Free';
|
||
freeTooltip: 'Reported by OpenCode metadata. Availability and limits may change.';
|
||
unavailable: 'Unavailable';
|
||
};
|
||
providerRuntime: {
|
||
codex: {
|
||
install: {
|
||
checking: 'Checking';
|
||
downloading: 'Downloading';
|
||
installCli: 'Install Codex CLI';
|
||
installing: 'Installing';
|
||
retryInstall: 'Retry install';
|
||
};
|
||
};
|
||
};
|
||
repositories: {
|
||
noneAvailable: 'No repositories available';
|
||
remove: 'Remove repository';
|
||
};
|
||
runtimeBackendSelector: {
|
||
audience: {
|
||
internal: 'Internal';
|
||
};
|
||
auto: 'Auto';
|
||
autoCurrently: 'Auto (currently: {{backend}})';
|
||
cannotSelectYet: 'This backend cannot be selected yet.';
|
||
current: 'Current';
|
||
label: 'Runtime backend';
|
||
recommended: 'Recommended';
|
||
resolved: 'Resolved: {{backend}}';
|
||
states: {
|
||
authRequired: 'Auth required';
|
||
degraded: 'Degraded';
|
||
disabled: 'Disabled';
|
||
locked: 'Locked';
|
||
runtimeMissing: 'Runtime missing';
|
||
unavailable: 'Unavailable';
|
||
};
|
||
unavailable: 'Unavailable';
|
||
};
|
||
runtimeProvider: {
|
||
defaults: {
|
||
allProjectsHint: 'Tests use {{project}}. Default applies unless a project has an override.';
|
||
projectHint: 'Saving overrides only {{project}}.';
|
||
projectOverrideContext: 'Project override context';
|
||
scopeDescriptionAllProjects: 'Default for every project that does not have its own OpenCode override.';
|
||
scopeDescriptionProject: 'Override only the selected project. Running teams are not changed.';
|
||
selectProjectHint: 'Select a project before testing local models or saving defaults.';
|
||
setAllProjectsDefault: 'Set all-projects default';
|
||
setProjectDefault: 'Set project default';
|
||
validationContext: 'Validation context';
|
||
};
|
||
};
|
||
schedules: {
|
||
actions: {
|
||
addSchedule: 'Add Schedule';
|
||
clearFilters: 'Clear filters';
|
||
createSchedule: 'Create Schedule';
|
||
delete: 'Delete';
|
||
edit: 'Edit';
|
||
pause: 'Pause';
|
||
resume: 'Resume';
|
||
runNow: 'Run now';
|
||
};
|
||
empty: {
|
||
description: 'Create a schedule on any team to automate Claude task execution with cron expressions. Schedules from all teams will appear here.';
|
||
noMatches: 'No schedules match the current filters';
|
||
title: 'No scheduled tasks';
|
||
};
|
||
filters: {
|
||
allTeams: 'All teams';
|
||
};
|
||
item: {
|
||
loadingRunHistory: 'Loading run history...';
|
||
nextRun: 'Next: {{value}}';
|
||
noRunsYet: 'No runs yet';
|
||
};
|
||
loading: 'Loading schedules...';
|
||
searchPlaceholder: 'Search schedules...';
|
||
status: {
|
||
active: 'Active';
|
||
all: 'All';
|
||
disabled: 'Disabled';
|
||
paused: 'Paused';
|
||
};
|
||
title: 'Schedules';
|
||
};
|
||
search: {
|
||
closeShortcut: 'Close (Esc)';
|
||
findInConversation: 'Find in conversation...';
|
||
nextResultShortcut: 'Next result (Enter)';
|
||
noMatchingSuggestions: 'No matching suggestions';
|
||
noResults: 'No results';
|
||
nothingFound: 'Nothing found';
|
||
placeholder: 'Search...';
|
||
previousResultShortcut: 'Previous result (Shift+Enter)';
|
||
resultCount: '{{current}} of {{total}}';
|
||
resultCountCapped: '{{current}} of {{total}}+';
|
||
searching: 'Searching...';
|
||
searchingFiles: 'Searching files...';
|
||
};
|
||
sessionContext: {
|
||
claudeMdFiles: 'CLAUDE.md Files';
|
||
empty: 'No context injections detected in this session';
|
||
header: {
|
||
bySize: 'By Size';
|
||
category: 'Category';
|
||
closePanel: 'Close panel';
|
||
current: 'Current';
|
||
phase: 'Phase:';
|
||
title: 'Context';
|
||
view: 'View:';
|
||
};
|
||
help: {
|
||
availability: {
|
||
description: 'If a provider runtime does not expose prompt-side usage yet, the panel shows metrics as unavailable instead of pretending they are zero.';
|
||
title: 'Availability';
|
||
};
|
||
contextUsed: {
|
||
description: "Prompt input plus output tokens currently occupying the model's context window.";
|
||
title: 'Context Used';
|
||
};
|
||
promptInput: {
|
||
description: 'Tokens sent to the model before generation. For Claude this includes `input_tokens + cache_creation_input_tokens + cache_read_input_tokens`.';
|
||
title: 'Prompt Input';
|
||
};
|
||
visibleContext: {
|
||
description: 'The inspectable subset of prompt input: files, CLAUDE.md, tool outputs, user messages, and similar injections that you can optimize directly.';
|
||
title: 'Visible Context';
|
||
};
|
||
};
|
||
items: {
|
||
itemsCount: '{{count}} items';
|
||
itemsCount_few: '{{count}} items';
|
||
itemsCount_many: '{{count}} items';
|
||
itemsCount_one: '{{count}} item';
|
||
itemsCount_other: '{{count}} items';
|
||
missing: 'missing';
|
||
text: 'Text';
|
||
thinking: 'Thinking';
|
||
tokensApprox: '~{{tokens}} tokens';
|
||
toolsCount: '{{count}} tools';
|
||
toolsCount_few: '{{count}} tools';
|
||
toolsCount_many: '{{count}} tools';
|
||
toolsCount_one: '{{count}} tool';
|
||
toolsCount_other: '{{count}} tools';
|
||
turn: '@Turn {{turn}}';
|
||
};
|
||
mentionedFiles: 'Mentioned Files';
|
||
metrics: {
|
||
codexTelemetryUnavailable: 'Codex prompt-side usage is not exposed by the current runtime telemetry yet, so Prompt Input and Context Used stay unavailable instead of showing a fake zero.';
|
||
contextUsed: 'Context Used';
|
||
details: 'details';
|
||
ofContext: 'of context';
|
||
ofPrompt: 'of prompt';
|
||
parentPlus: 'parent +';
|
||
promptInput: 'Prompt Input';
|
||
sessionCost: 'Session Cost:';
|
||
subagents: 'subagents';
|
||
unavailable: 'Unavailable';
|
||
visibleContext: 'Visible Context';
|
||
};
|
||
view: {
|
||
flat: 'Flat';
|
||
grouped: 'Grouped';
|
||
};
|
||
};
|
||
sessionFilters: {
|
||
project: {
|
||
selectProject: 'Select Project';
|
||
};
|
||
};
|
||
sessionItem: {
|
||
compactedTo: '(compacted to {{tokens}})';
|
||
context: 'Context: {{tokens}}';
|
||
phase: 'Phase {{phase}}:';
|
||
totalContext: 'Total Context: {{tokens}} tokens';
|
||
};
|
||
sessionReport: {
|
||
noSessionData: 'No session data available';
|
||
title: 'Session Report';
|
||
};
|
||
sessions: {
|
||
actions: {
|
||
hide: 'Hide';
|
||
pin: 'Pin';
|
||
unhide: 'Unhide';
|
||
};
|
||
count: '{{count}} sessions';
|
||
count_few: '{{count}} sessions';
|
||
count_many: '{{count}} sessions';
|
||
count_one: '{{count}} session';
|
||
count_other: '{{count}} sessions';
|
||
empty: {
|
||
noMatchingSessions: 'No matching sessions';
|
||
noMatchingSessionsDescription: 'This project has no matching sessions yet.';
|
||
noMatchingSessionsFiltered: 'Try another query or reset the provider filter.';
|
||
noSessions: 'No sessions found';
|
||
noSessionsDescription: 'This project has no sessions yet';
|
||
selectProject: 'Select a project to view sessions';
|
||
};
|
||
errors: {
|
||
loading: 'Error loading sessions';
|
||
};
|
||
failedToLoad: 'Failed to load session';
|
||
filter: {
|
||
title: 'Filter sessions';
|
||
};
|
||
inProgress: 'Session is in progress...';
|
||
loadedMatchingMore: '{{count}} matching sessions loaded so far - scroll down to load more.';
|
||
loadedMatchingMore_few: '{{count}} matching sessions loaded so far - scroll down to load more.';
|
||
loadedMatchingMore_many: '{{count}} matching sessions loaded so far - scroll down to load more.';
|
||
loadedMatchingMore_one: '{{count}} matching sessions loaded so far - scroll down to load more.';
|
||
loadedMatchingMore_other: '{{count}} matching sessions loaded so far - scroll down to load more.';
|
||
loading: 'Loading session...';
|
||
loadingMore: 'Loading more sessions...';
|
||
pinned: 'Pinned';
|
||
scrollToLoadMore: 'Scroll to load more';
|
||
search: {
|
||
clear: 'Clear session search';
|
||
placeholder: 'Search sessions...';
|
||
};
|
||
selection: {
|
||
cancel: 'Cancel selection';
|
||
exitMode: 'Exit selection mode';
|
||
hideSelected: 'Hide selected sessions';
|
||
pinSelected: 'Pin selected sessions';
|
||
selectSessions: 'Select sessions';
|
||
selected: '{{count}} selected';
|
||
selected_few: '{{count}} selected';
|
||
selected_many: '{{count}} selected';
|
||
selected_one: '{{count}} selected';
|
||
selected_other: '{{count}} selected';
|
||
unhideSelected: 'Unhide selected sessions';
|
||
};
|
||
sort: {
|
||
byContext: 'By Context';
|
||
byContextTooltip: 'Sort by context consumption';
|
||
byRecentTooltip: 'Sort by recent';
|
||
contextLoadedOnly: 'Context sorting only ranks loaded sessions.';
|
||
};
|
||
title: 'Sessions';
|
||
visibility: {
|
||
hideHidden: 'Hide hidden sessions';
|
||
showHidden: 'Show hidden sessions';
|
||
};
|
||
worktree: {
|
||
switch: 'Switch Worktree';
|
||
};
|
||
};
|
||
states: {
|
||
error: 'Error';
|
||
loading: 'Loading...';
|
||
offline: 'Offline';
|
||
online: 'Online';
|
||
unknown: 'Unknown';
|
||
};
|
||
taskContextMenu: {
|
||
archive: 'Archive';
|
||
deleteTask: 'Delete task';
|
||
markUnread: 'Mark as unread';
|
||
pin: 'Pin';
|
||
rename: 'Rename';
|
||
unarchive: 'Unarchive';
|
||
unpin: 'Unpin';
|
||
};
|
||
taskFilters: {
|
||
allProjects: 'All Projects';
|
||
allTeams: 'All teams';
|
||
apply: 'Apply';
|
||
clearAll: 'Clear all';
|
||
comments: 'Comments';
|
||
noProjects: 'No projects';
|
||
noTeamsFound: 'No teams found';
|
||
project: 'Project';
|
||
read: {
|
||
all: 'All';
|
||
read: 'Read';
|
||
unread: 'Unread';
|
||
};
|
||
searchProjects: 'Search projects...';
|
||
searchTeams: 'Search teams...';
|
||
selectAll: 'Select all';
|
||
status: 'Status';
|
||
statusOptions: {
|
||
approved: 'APPROVED';
|
||
done: 'DONE';
|
||
inProgress: 'IN PROGRESS';
|
||
needsFix: 'NEEDS FIXES';
|
||
review: 'REVIEW';
|
||
todo: 'TODO';
|
||
};
|
||
team: 'Team';
|
||
};
|
||
tasks: {
|
||
date: {
|
||
updatedPrefix: 'upd';
|
||
updatedYesterday: 'upd yesterday';
|
||
yesterday: 'Yesterday';
|
||
};
|
||
reviewState: {
|
||
needsFix: 'Needs Fixes';
|
||
};
|
||
unassigned: 'unassigned';
|
||
};
|
||
tasksPanel: {
|
||
deleteConfirm: {
|
||
cancelLabel: 'Cancel';
|
||
confirmLabel: 'Delete';
|
||
message: 'Move task #{{taskId}} to trash?';
|
||
title: 'Delete task';
|
||
};
|
||
deleteFailed: {
|
||
confirmLabel: 'OK';
|
||
fallbackMessage: 'An unexpected error occurred';
|
||
title: 'Failed to delete task';
|
||
};
|
||
empty: {
|
||
noMatchingTasks: 'No matching tasks';
|
||
noTasks: 'No tasks found';
|
||
};
|
||
groupByAria: 'Group by';
|
||
groupByLabel: 'Group by:';
|
||
groupModes: {
|
||
none: 'None';
|
||
project: 'Project';
|
||
time: 'Time';
|
||
};
|
||
hideArchived: 'Hide archived';
|
||
pinned: 'Pinned';
|
||
searchPlaceholder: 'Search tasks...';
|
||
showArchived: 'Show archived';
|
||
showLess: 'Show less';
|
||
showMore: 'Show more';
|
||
sort: {
|
||
byProject: 'By project';
|
||
byTeam: 'By team';
|
||
byTime: 'By time';
|
||
byUnread: 'By unread';
|
||
};
|
||
teamLabel: 'Team: {{team}}';
|
||
title: 'Tasks';
|
||
};
|
||
terminal: {
|
||
checkOutputForDetails: 'Check terminal output above for details';
|
||
closingInSeconds: 'Closing in {{count}}s...';
|
||
closingInSeconds_few: 'Closing in {{count}}s...';
|
||
closingInSeconds_many: 'Closing in {{count}}s...';
|
||
closingInSeconds_one: 'Closing in {{count}}s...';
|
||
closingInSeconds_other: 'Closing in {{count}}s...';
|
||
completedSuccessfully: 'Completed successfully';
|
||
exitCode: '(exit code {{code}})';
|
||
processFailed: 'Process failed';
|
||
title: 'Terminal';
|
||
};
|
||
tmuxInstaller: {
|
||
actions: {
|
||
cancel: 'Cancel';
|
||
hideSetupSteps: 'Hide setup steps';
|
||
manualGuide: 'Manual guide';
|
||
recheck: 'Re-check';
|
||
showSetupSteps: 'Show setup steps ({{count}})';
|
||
showSetupSteps_few: 'Show setup steps ({{count}})';
|
||
showSetupSteps_many: 'Show setup steps ({{count}})';
|
||
showSetupSteps_one: 'Show setup step ({{count}})';
|
||
showSetupSteps_other: 'Show setup steps ({{count}})';
|
||
};
|
||
details: {
|
||
hide: 'Hide details';
|
||
show: 'Show details';
|
||
};
|
||
detectedOs: 'Detected OS: {{os}}';
|
||
input: {
|
||
passwordNotice: 'Password input is sent directly to the installer terminal and is not added to the log output.';
|
||
placeholder: 'Send input to the installer';
|
||
send: 'Send input';
|
||
};
|
||
installerProgress: 'Installer progress';
|
||
phase: 'Phase: {{phase}}';
|
||
runtimePath: 'Runtime path: {{path}}';
|
||
summaryTitle: 'tmux is not installed';
|
||
};
|
||
tokens: {
|
||
accumulatedWithoutDuplication: 'Accumulated across entire session without duplication';
|
||
approxTokens: '~{{tokens}} tokens';
|
||
approxTokensParenthesized: '(~{{tokens}})';
|
||
cacheRead: 'Cache Read';
|
||
cacheWrite: 'Cache Write';
|
||
claudeMd: 'CLAUDE.md';
|
||
costUsd: 'Cost (USD)';
|
||
includesClaudeMd: 'incl. CLAUDE.md ×{{count}}';
|
||
inputTokens: 'Input Tokens';
|
||
mentionedFiles: '@files';
|
||
model: 'Model';
|
||
outputTokens: 'Output Tokens';
|
||
percentValue: '({{percent}}%)';
|
||
phase: 'Phase {{phase}}/{{total}}';
|
||
promptInputShare: '{{percent}}% of prompt input';
|
||
taskCoordination: 'Task Coordination';
|
||
thinkingText: 'Thinking + Text';
|
||
toolOutputs: 'Tool Outputs';
|
||
total: 'Total';
|
||
userMessages: 'User Messages';
|
||
visibleContext: 'Visible Context';
|
||
};
|
||
toolViewer: {
|
||
agent: {
|
||
action: 'action';
|
||
runtime: 'runtime';
|
||
startupInstructionsHidden: 'Startup instructions are hidden in the UI.';
|
||
team: 'team';
|
||
teammate: 'teammate';
|
||
type: 'type';
|
||
};
|
||
input: 'Input';
|
||
noInputRecorded: 'No input recorded for this tool call.';
|
||
replaceAll: '(replace all)';
|
||
};
|
||
updateDialog: {
|
||
closeDialog: 'Close dialog';
|
||
download: 'Download';
|
||
later: 'Later';
|
||
noReleaseNotes: 'No release notes available.';
|
||
restartNow: 'Restart now';
|
||
updateAvailable: 'Update available';
|
||
updateReady: 'Update Ready';
|
||
viewOnGitHub: 'View on GitHub';
|
||
};
|
||
updates: {
|
||
downloadedRestartTooltip: 'Update downloaded, restart to apply';
|
||
newVersionAvailable: 'New version available';
|
||
restartNow: 'Restart now';
|
||
restartToUpdate: 'Restart to update';
|
||
updateApp: 'Update app';
|
||
updateReady: 'Update ready';
|
||
updatingApp: 'Updating app';
|
||
};
|
||
window: {
|
||
maximize: 'Maximize';
|
||
minimize: 'Minimize';
|
||
restore: 'Restore';
|
||
};
|
||
};
|
||
dashboard: {
|
||
actions: {
|
||
clearSearch: 'Clear search';
|
||
or: 'or';
|
||
selectTeam: 'Select Team';
|
||
};
|
||
cliStatus: {
|
||
actions: {
|
||
alreadyLoggedIn: 'Already logged in?';
|
||
becomeSponsor: 'Become a sponsor';
|
||
cancel: 'Cancel';
|
||
checkNow: 'Check now';
|
||
checkUpdates: 'Check for Updates';
|
||
checking: 'Checking...';
|
||
connect: 'Connect';
|
||
extensions: 'Extensions';
|
||
login: 'Login';
|
||
manage: 'Manage';
|
||
manageProviders: 'Manage Providers';
|
||
plan: 'Plan';
|
||
recheck: 'Re-check';
|
||
recheckProvider: 'Re-check {{provider}}';
|
||
retry: 'Retry';
|
||
updateTo: 'Update to v{{version}}';
|
||
useCode: 'Use code';
|
||
};
|
||
atlas: {
|
||
alt: 'Atlas Cloud';
|
||
description: "Atlas Cloud is a full-modal AI inference platform that gives developers a single AI API to access video generation, image generation, and LLM APIs. Instead of managing multiple vendor integrations, you connect once and get unified access to 300+ curated models across all modalities. Check out Atlas Cloud's new coding plan promotion for more budget-friendly API access.";
|
||
openCodeProvider: 'OpenCode provider';
|
||
plan: 'Atlas Cloud coding plan';
|
||
sponsor: 'Sponsor';
|
||
};
|
||
errors: {
|
||
checkStatusFailed: 'Failed to check CLI status';
|
||
installationFailed: 'Installation failed';
|
||
refreshFailed: 'Failed to check for updates. Check your network connection and try again.';
|
||
runtimeUpdatedRefreshFailed: 'Runtime updated, but failed to refresh provider status.';
|
||
};
|
||
hints: {
|
||
backgroundStatus: '{{runtime}} status will be checked in the background.';
|
||
codexApiKeyFallback: '{{hint}} API key fallback is available if you switch auth mode.';
|
||
codexAutoApiKey: '{{hint}} Auto will keep using the API key until ChatGPT is connected.';
|
||
codexFinishLogin: 'Finish ChatGPT login in the browser. Enter the shown code if prompted.';
|
||
codexNoActiveLogin: 'Usage limits appear only after Codex CLI sees an active ChatGPT account. Right now it reports no active ChatGPT login.';
|
||
codexNoActiveManagedSession: 'Usage limits appear only after Codex CLI sees an active ChatGPT account. Local Codex account data exists, but no active managed session is selected right now.';
|
||
codexReconnectNeeded: 'Usage limits appear only after Codex refreshes the currently selected ChatGPT session. Right now the local session needs reconnect.';
|
||
firstCheckSlow: 'First check may take up to 30 seconds';
|
||
loginRequiredForTeams: 'Browsing sessions and projects works without login. Login is only needed to run agent teams.';
|
||
troubleshootTitle: "If you're sure you're logged in, try these steps:";
|
||
};
|
||
installer: {
|
||
checkingLatest: 'Checking latest version...';
|
||
downloading: 'Downloading {{runtime}}...';
|
||
installing: 'Installing {{runtime}}...';
|
||
success: 'Successfully installed {{runtime}} v{{version}}';
|
||
verifying: 'Verifying checksum...';
|
||
};
|
||
labels: {
|
||
apiKeyRequired: 'API key required';
|
||
collapseProviderDetails: 'Collapse provider details';
|
||
comingSoon: 'Coming soon';
|
||
expandProviderDetails: 'Expand provider details';
|
||
generateLink: 'Generate link';
|
||
loadingRateLimits: 'Rate limits loading';
|
||
loggedOut: 'Provider logged out';
|
||
loginAuthFailed: 'Authentication failed';
|
||
loginAuthUpdated: 'Authentication updated';
|
||
loginComplete: 'Login complete';
|
||
loginFailed: 'Login failed';
|
||
loginTitle: 'Login';
|
||
logoutFailed: 'Logout failed';
|
||
logoutTitle: 'Logout';
|
||
notLoggedIn: 'Not logged in';
|
||
openLogin: 'Open login';
|
||
providerActionRequired: 'Provider action required';
|
||
resets: 'resets {{time}}';
|
||
runtimeLoginTitle: '{{runtime}} Login';
|
||
};
|
||
loading: {
|
||
aiProviders: 'Checking AI Providers...';
|
||
claudeCli: 'Checking Claude CLI...';
|
||
};
|
||
provider: {
|
||
authenticated: 'Authenticated';
|
||
backend: 'Backend: {{backend}}';
|
||
checkingAuthentication: 'Checking authentication...';
|
||
checkingProviders: 'Checking providers...';
|
||
configuredLocalCount: '{{count}} configured local';
|
||
configuredLocalCount_few: '{{count}} configured local';
|
||
configuredLocalCount_many: '{{count}} configured local';
|
||
configuredLocalCount_one: '{{count}} configured local';
|
||
configuredLocalCount_other: '{{count}} configured local';
|
||
configuredLocalTitle: 'Local OpenCode routes imported from your OpenCode config.';
|
||
connectedCount: 'Providers: {{connected}}/{{denominator}} connected';
|
||
freeModels: 'Free models';
|
||
freeModelsTitle: 'OpenCode includes free model options such as Big Pickle when available in your setup. OpenRouter through OpenCode can also expose free models, but not every OpenCode/OpenRouter model is free. Availability and limits may change.';
|
||
loadingModels: 'Loading models...';
|
||
modelsUnavailable: 'Models unavailable for this runtime build';
|
||
runtime: 'Runtime: {{runtime}}';
|
||
verifiedCount: '{{count}} verified';
|
||
verifiedCount_few: '{{count}} verified';
|
||
verifiedCount_many: '{{count}} verified';
|
||
verifiedCount_one: '{{count}} verified';
|
||
verifiedCount_other: '{{count}} verified';
|
||
verifiedTitle: 'OpenCode routes with a successful execution proof.';
|
||
};
|
||
runtime: {
|
||
configuredHealthCheckFailed: 'The configured {{runtime}} failed its startup health check.';
|
||
configuredNotFound: 'The configured {{runtime}} was not found.';
|
||
foundButFailed: '{{runtime}} was found but failed to start';
|
||
healthCheckFailedDescription: 'The app found the configured {{runtime}}, but its startup health check failed. Repair or reinstall it, then retry.';
|
||
install: 'Install {{runtime}}';
|
||
installRequiredDescription: '{{runtime}} is required for team provisioning and session management. Install it to get started.';
|
||
isRequired: '{{runtime}} is required';
|
||
reinstall: 'Reinstall {{runtime}}';
|
||
};
|
||
runtimeInstall: {
|
||
checking: 'Checking';
|
||
codexTitle: 'Install Codex CLI into app data';
|
||
downloading: 'Downloading';
|
||
downloadingPercent: 'Downloading {{percent}}%';
|
||
install: 'Install';
|
||
installing: 'Installing';
|
||
openCodeTitle: 'Install OpenCode runtime into app data';
|
||
retryInstall: 'Retry install';
|
||
};
|
||
troubleshoot: {
|
||
again: 'again';
|
||
authStatusCommand: 'your configured CLI auth status command';
|
||
checkLoggedIn: '- check if it shows "Logged in"';
|
||
click: 'Click';
|
||
loginCommand: 'the runtime login command';
|
||
logoutCommand: 'the runtime logout command';
|
||
openTerminal: 'Open your terminal and run:';
|
||
reloginPrefix: "If it says logged in but the app doesn't see it, try:";
|
||
sameRuntime: 'Make sure the CLI in your terminal is the same runtime the app uses';
|
||
statusCacheHint: '- sometimes the status is cached for a few seconds';
|
||
then: 'then';
|
||
};
|
||
warnings: {
|
||
multipleApiKeysMissing: 'One or more providers are set to API key mode, but no API key is configured. Open Manage Providers to add keys or switch the connection mode.';
|
||
multipleApiKeysNeedAttention: 'One or more providers are set to API key mode and need attention. Open Manage Providers to review saved keys or switch the connection mode.';
|
||
notAuthenticated: '{{runtime}} is installed but you are not authenticated. Login is required for team provisioning and AI features.';
|
||
singleApiKeyMissing: '{{provider}} is set to API key mode, but no API key is configured. Open Manage Providers to add a key or switch the connection mode.';
|
||
singleApiKeyNeedsAttention: '{{provider}} is set to API key mode, but it is not connected. Open Manage Providers to review the saved key or switch the connection mode.';
|
||
};
|
||
};
|
||
recentProjects: {
|
||
card: {
|
||
deleted: 'Deleted';
|
||
projectFolderMissing: 'Project folder no longer exists';
|
||
taskCounts: {
|
||
active: '{{count}} active';
|
||
active_few: '{{count}} active';
|
||
active_many: '{{count}} active';
|
||
active_one: '{{count}} active';
|
||
active_other: '{{count}} active';
|
||
done: '{{count}} done';
|
||
done_few: '{{count}} done';
|
||
done_many: '{{count}} done';
|
||
done_one: '{{count}} done';
|
||
done_other: '{{count}} done';
|
||
pending: '{{count}} pending';
|
||
pending_few: '{{count}} pending';
|
||
pending_many: '{{count}} pending';
|
||
pending_one: '{{count}} pending';
|
||
pending_other: '{{count}} pending';
|
||
};
|
||
};
|
||
emptyDescription: 'Recent Claude and Codex activity will appear here.';
|
||
failedToLoad: 'Failed to load projects';
|
||
loadMore: 'Load more';
|
||
noMatches: 'No matches for "{{query}}"';
|
||
noProjects: 'No projects found';
|
||
noRecentProjects: 'No recent projects found';
|
||
retry: 'Retry';
|
||
searchPlaceholder: 'Search projects...';
|
||
searchResults: 'Search Results';
|
||
selectFolder: 'Select Folder';
|
||
selectFolderTitle: 'Select a project folder';
|
||
title: 'Recent Projects';
|
||
};
|
||
updateBanner: {
|
||
newVersionAvailable: 'New version available';
|
||
restartNow: 'Restart now';
|
||
viewDetails: 'View details';
|
||
};
|
||
webPreview: {
|
||
description: 'The browser version is still in development. Project actions, integrations, and live status updates may be limited here. Use the desktop app to access all features reliably.';
|
||
title: 'Open the desktop app for full functionality';
|
||
};
|
||
windowsAdmin: {
|
||
description: 'OpenCode runtime checks can time out when Agent Teams AI is not elevated. Restart the app with Run as administrator before launching OpenCode teams.';
|
||
title: 'Windows Administrator mode recommended';
|
||
};
|
||
};
|
||
errors: {
|
||
fallback: 'Something went wrong.';
|
||
};
|
||
extensions: {
|
||
apiKeys: {
|
||
actions: {
|
||
add: 'Add API Key';
|
||
addFirst: 'Add your first key';
|
||
edit: 'Edit';
|
||
};
|
||
description: 'Securely store API keys for auto-filling when installing MCP servers.';
|
||
empty: {
|
||
description: 'Add keys to auto-fill environment variables when installing MCP servers.';
|
||
title: 'No API keys saved';
|
||
};
|
||
form: {
|
||
addDescription: 'Store an API key for auto-filling in MCP server installations.';
|
||
addTitle: 'Add API Key';
|
||
boundTo: 'Bound to {{path}}';
|
||
cancel: 'Cancel';
|
||
editDescription: 'Update the key details. You must re-enter the value.';
|
||
editTitle: 'Edit API Key';
|
||
envVarPlaceholder: 'e.g. OPENAI_API_KEY';
|
||
environmentVariableName: 'Environment Variable Name';
|
||
errors: {
|
||
envVarRequired: 'Environment variable name is required';
|
||
invalidEnvVar: 'Invalid environment variable name';
|
||
invalidEnvVarFormat: 'Use letters, digits, underscores. Must start with a letter or underscore.';
|
||
nameRequired: 'Name is required';
|
||
projectScopeRequiresProject: 'Project-scoped API keys require an active project';
|
||
saveFailed: 'Failed to save';
|
||
valueRequired: 'Key value is required';
|
||
};
|
||
keychainUnavailable: 'OS keychain unavailable - keys encrypted with AES-256 locally. Install gnome-keyring for OS-level protection.';
|
||
name: 'Name';
|
||
namePlaceholder: 'e.g. OpenAI Production';
|
||
projectScopeLabel: 'Project: {{project}}';
|
||
projectUnavailable: 'Project unavailable';
|
||
reenterValue: 'Re-enter key value';
|
||
save: 'Save';
|
||
saving: 'Saving...';
|
||
scope: 'Scope';
|
||
update: 'Update';
|
||
userScopeLabel: 'User (global)';
|
||
value: 'Value';
|
||
valuePlaceholder: 'sk-...';
|
||
};
|
||
storage: {
|
||
localEncryption: 'OS keychain unavailable - keys are encrypted locally with AES-256. For stronger protection, install a keyring service (gnome-keyring, kwallet).';
|
||
osKeychain: 'Keys are encrypted via {{backend}} and stored with restricted file permissions (owner-only).';
|
||
};
|
||
};
|
||
customMcp: {
|
||
actions: {
|
||
add: 'Add';
|
||
cancel: 'Cancel';
|
||
install: 'Install';
|
||
installing: 'Installing...';
|
||
};
|
||
description: 'Add a server manually without the catalog.';
|
||
errors: {
|
||
installFailed: 'Install failed';
|
||
invalidServerName: 'Invalid server name. Use alphanumeric characters, dashes, underscores, dots.';
|
||
npmPackageRequired: 'npm package name is required';
|
||
serverNameRequired: 'Server name is required';
|
||
serverUrlRequired: 'Server URL is required';
|
||
};
|
||
fields: {
|
||
environmentVariables: 'Environment Variables';
|
||
headers: 'Headers';
|
||
npmPackage: 'npm Package';
|
||
scope: 'Scope';
|
||
serverName: 'Server Name';
|
||
serverUrl: 'Server URL';
|
||
transport: 'Transport';
|
||
transportType: 'Transport Type';
|
||
versionOptional: 'Version (optional)';
|
||
};
|
||
placeholders: {
|
||
envVarName: 'ENV_VAR_NAME';
|
||
headerName: 'Header-Name';
|
||
latest: 'latest';
|
||
serverName: 'my-server';
|
||
serverUrl: 'https://api.example.com/mcp';
|
||
value: 'value';
|
||
};
|
||
title: 'Add Custom MCP Server';
|
||
transport: {
|
||
httpSse: 'HTTP / SSE';
|
||
stdio: 'Stdio (npm)';
|
||
};
|
||
};
|
||
installButton: {
|
||
done: 'Done';
|
||
install: 'Install';
|
||
installing: 'Installing...';
|
||
removing: 'Removing...';
|
||
retry: 'Retry';
|
||
uninstall: 'Uninstall';
|
||
};
|
||
mcpCard: {
|
||
auth: 'Auth';
|
||
byAuthor: 'by {{author}}';
|
||
envCount: '{{count}} envs';
|
||
envCount_few: '{{count}} envs';
|
||
envCount_many: '{{count}} envs';
|
||
envCount_one: '{{count}} env';
|
||
envCount_other: '{{count}} envs';
|
||
hosting: {
|
||
both: 'Both';
|
||
local: 'Local';
|
||
remote: 'Remote';
|
||
};
|
||
repository: 'Repository';
|
||
toolsCount: '{{count}} tools';
|
||
toolsCount_few: '{{count}} tools';
|
||
toolsCount_many: '{{count}} tools';
|
||
toolsCount_one: '{{count}} tool';
|
||
toolsCount_other: '{{count}} tools';
|
||
website: 'Website';
|
||
};
|
||
mcpDetail: {
|
||
auth: {
|
||
remoteMayNeedHeaders: 'Remote MCP servers may still require custom headers or API keys even when the registry does not describe them. If connection fails after install, check the provider docs.';
|
||
required: 'This server requires authentication';
|
||
};
|
||
diagnostics: {
|
||
launchTarget: 'Launch Target';
|
||
};
|
||
form: {
|
||
autoFilled: 'Auto-filled';
|
||
environmentVariables: 'Environment Variables';
|
||
headers: 'Headers';
|
||
scope: 'Scope';
|
||
serverName: 'Server Name';
|
||
};
|
||
install: {
|
||
httpTransport: 'HTTP: {{transport}}';
|
||
install: 'Install Server';
|
||
manage: 'Manage Installation';
|
||
manualSetupDescription: 'This server requires manual setup. Check the repository for installation instructions.';
|
||
manualSetupRequired: 'Manual setup required';
|
||
npmPackage: 'npm: {{package}}';
|
||
};
|
||
links: {
|
||
glama: 'Glama';
|
||
repository: 'Repository';
|
||
website: 'Website';
|
||
};
|
||
metadata: {
|
||
author: 'Author';
|
||
githubStars: 'GitHub Stars';
|
||
hosting: 'Hosting';
|
||
installType: 'Install Type';
|
||
license: 'License';
|
||
published: 'Published';
|
||
source: 'Source';
|
||
updated: 'Updated';
|
||
version: 'Version';
|
||
};
|
||
placeholders: {
|
||
serverName: 'my-server';
|
||
};
|
||
scope: {
|
||
local: 'Local';
|
||
project: 'Project';
|
||
};
|
||
tools: {
|
||
title: 'Tools ({{count}})';
|
||
title_few: 'Tools ({{count}})';
|
||
title_many: 'Tools ({{count}})';
|
||
title_one: 'Tools ({{count}})';
|
||
title_other: 'Tools ({{count}})';
|
||
};
|
||
};
|
||
mcpPanel: {
|
||
diagnostics: {
|
||
disableReasons: {
|
||
checkingRuntimeAvailability: 'Checking runtime availability...';
|
||
checkingRuntimeStatus: 'Checking runtime status...';
|
||
runtimeFailedToStart: 'The configured runtime was found but failed to start. Open the Dashboard to repair or reinstall it.';
|
||
runtimeRequired: 'The configured runtime is required. Install or repair it from the Dashboard.';
|
||
};
|
||
serversCount: '{{count}} servers';
|
||
serversCount_few: '{{count}} servers';
|
||
serversCount_many: '{{count}} servers';
|
||
serversCount_one: '{{count}} server';
|
||
serversCount_other: '{{count}} servers';
|
||
title: 'Runtime MCP Diagnostics';
|
||
waiting: 'Waiting for diagnostics results...';
|
||
};
|
||
empty: {
|
||
description: 'Check back later for new servers';
|
||
searchDescription: 'Try a different search term';
|
||
searchTitle: 'No servers found';
|
||
title: 'No MCP servers available';
|
||
};
|
||
health: {
|
||
checkStatus: 'Check Status';
|
||
checking: 'Checking...';
|
||
checkingViaRuntime: 'Checking installed MCP servers via {{runtime}} ...';
|
||
description: 'Run diagnostics from this page to verify installed MCP connectivity.';
|
||
lastChecked: 'Last checked {{time}}';
|
||
title: 'MCP Health Status';
|
||
};
|
||
loadMore: 'Load more';
|
||
runtime: {
|
||
notAvailable: '{{runtime}} not available';
|
||
notInstalled: '{{runtime}} not installed';
|
||
requiredDescription: 'MCP health checks require {{runtime}}. Go to the Dashboard to install or repair it.';
|
||
};
|
||
searchPlaceholder: 'Search MCP servers...';
|
||
sort: {
|
||
nameAsc: 'Name A→Z';
|
||
nameDesc: 'Name Z→A';
|
||
toolsDesc: 'Most tools';
|
||
};
|
||
};
|
||
pluginCard: {
|
||
official: 'Official';
|
||
};
|
||
pluginDetail: {
|
||
links: {
|
||
contact: 'Contact';
|
||
homepage: 'Homepage';
|
||
};
|
||
metadata: {
|
||
author: 'Author';
|
||
capabilities: 'Capabilities';
|
||
category: 'Category';
|
||
installs: 'Installs';
|
||
source: 'Source';
|
||
version: 'Version';
|
||
};
|
||
readme: {
|
||
empty: 'No README available.';
|
||
loading: 'Loading README...';
|
||
};
|
||
scope: {
|
||
label: 'Scope:';
|
||
options: {
|
||
local: 'Local (gitignored)';
|
||
project: 'Project (shared)';
|
||
user: 'User (global)';
|
||
};
|
||
};
|
||
unknown: 'Unknown';
|
||
};
|
||
pluginsPanel: {
|
||
activeFilters: '{{count}} active';
|
||
activeFilters_few: '{{count}} active';
|
||
activeFilters_many: '{{count}} active';
|
||
activeFilters_one: '{{count}} active';
|
||
activeFilters_other: '{{count}} active';
|
||
browseByFit: 'Browse by fit';
|
||
capabilities: 'Capabilities';
|
||
categories: 'Categories';
|
||
clearAllFilters: 'Clear all filters';
|
||
clearFilters: 'Clear filters';
|
||
counts: {
|
||
capabilities: '{{count}} capabilities';
|
||
capabilities_few: '{{count}} capabilities';
|
||
capabilities_many: '{{count}} capabilities';
|
||
capabilities_one: '{{count}} capabilities';
|
||
capabilities_other: '{{count}} capabilities';
|
||
categories: '{{count}} categories';
|
||
categories_few: '{{count}} categories';
|
||
categories_many: '{{count}} categories';
|
||
categories_one: '{{count}} categories';
|
||
categories_other: '{{count}} categories';
|
||
plugins: '{{count}} plugins';
|
||
plugins_few: '{{count}} plugins';
|
||
plugins_many: '{{count}} plugins';
|
||
plugins_one: '{{count}} plugins';
|
||
plugins_other: '{{count}} plugins';
|
||
};
|
||
empty: {
|
||
description: 'Check back later for new plugins';
|
||
filteredDescription: 'Try adjusting your search or filter criteria';
|
||
filteredTitle: 'No plugins match your filters';
|
||
title: 'No plugins available';
|
||
};
|
||
filterDescription: 'Narrow the catalog by category, capability, or installed state.';
|
||
installedOnly: 'Installed only';
|
||
providerSupportNotice: "Plugin support is currently guaranteed for Anthropic (Claude) sessions only. We're working to support plugins across all agents.";
|
||
resultsUpdateInstantly: 'Results update instantly as you refine filters.';
|
||
searchPlaceholder: 'Search plugins...';
|
||
selectedCount: '{{count}} selected';
|
||
selectedCount_few: '{{count}} selected';
|
||
selectedCount_many: '{{count}} selected';
|
||
selectedCount_one: '{{count}} selected';
|
||
selectedCount_other: '{{count}} selected';
|
||
showing: 'Showing {{shown}} of {{total}} plugins';
|
||
sort: {
|
||
category: 'Category';
|
||
nameAsc: 'Name A-Z';
|
||
nameDesc: 'Name Z-A';
|
||
popular: 'Popular';
|
||
};
|
||
};
|
||
skillDetail: {
|
||
actions: {
|
||
cancel: 'Cancel';
|
||
delete: 'Delete';
|
||
deleteSkill: 'Delete Skill';
|
||
deleting: 'Deleting...';
|
||
editSkill: 'Edit Skill';
|
||
openFolder: 'Open Folder';
|
||
openSkillFile: 'Open SKILL.md';
|
||
retry: 'Retry';
|
||
};
|
||
badges: {
|
||
assets: 'Assets';
|
||
autoUse: 'Auto use';
|
||
hasScripts: 'Has scripts';
|
||
manualUse: 'Manual use';
|
||
references: 'References';
|
||
storedIn: 'Stored in {{root}}';
|
||
};
|
||
deleteDialog: {
|
||
description: 'Delete this skill and move it to Trash?';
|
||
descriptionWithName: 'Delete "{{name}}" and move it to Trash? You can restore it later from Trash if needed.';
|
||
title: 'Delete skill?';
|
||
};
|
||
descriptionFallback: 'Inspect discovered skill metadata and raw instructions.';
|
||
errors: {
|
||
deleteFailed: 'Failed to delete skill';
|
||
loadFailed: 'Unable to load this skill.';
|
||
};
|
||
files: {
|
||
advancedDetails: 'Advanced file details';
|
||
assets: 'Assets';
|
||
references: 'References';
|
||
scripts: 'Scripts';
|
||
storedAt: 'Stored at';
|
||
};
|
||
includes: {
|
||
assets: 'assets';
|
||
instructionsOnly: 'Just the skill instructions';
|
||
references: 'references';
|
||
scripts: 'scripts';
|
||
};
|
||
invocation: {
|
||
auto: 'Runs automatically when it matches the task.';
|
||
manualOnly: 'Only runs when you explicitly ask for it.';
|
||
};
|
||
issues: {
|
||
bundledScripts: 'This skill includes bundled scripts';
|
||
reviewCarefully: 'Review this skill carefully before using it';
|
||
};
|
||
loading: 'Loading skill details...';
|
||
scope: {
|
||
personal: 'Your personal skills';
|
||
projectOnly: 'This project only';
|
||
};
|
||
summary: {
|
||
howUsed: 'How it is used';
|
||
included: 'What comes with it';
|
||
whoCanUse: 'Who can use it';
|
||
};
|
||
titleFallback: 'Skill details';
|
||
};
|
||
skillEditor: {
|
||
actions: {
|
||
cancel: 'Cancel';
|
||
createSkill: 'Create Skill';
|
||
preparing: 'Preparing...';
|
||
reviewAndCreate: 'Review And Create';
|
||
reviewAndSave: 'Review And Save';
|
||
saveSkill: 'Save Skill';
|
||
};
|
||
advanced: {
|
||
customDescription: 'This skill uses a custom markdown format, so edit it directly here.';
|
||
customTitle: '2. SKILL.md editor';
|
||
description: 'Most people can skip this. Open it only if you want direct control over the raw markdown file.';
|
||
hide: 'Hide Advanced Editor';
|
||
resetFromStructuredFields: 'Reset From Structured Fields';
|
||
show: 'Show Advanced Editor';
|
||
title: '4. Advanced SKILL.md editor';
|
||
};
|
||
basics: {
|
||
description: 'Give this skill a clear name, choose who can use it, and decide where it should live.';
|
||
title: '1. Basics';
|
||
};
|
||
description: {
|
||
create: 'Describe the workflow in plain language, review the files that will be created, then save it.';
|
||
edit: 'Update this skill, review the resulting file changes, then save it.';
|
||
};
|
||
extraFiles: {
|
||
addedFiles: 'Added files:';
|
||
assets: 'Assets';
|
||
assetsDescription: 'Add screenshots or bundled media only if they help explain the workflow.';
|
||
description: 'Add supporting docs, scripts, or assets only if this skill really needs them.';
|
||
lockedForEdits: 'Root and folder are locked for edits';
|
||
optionalDescription: 'Add starter files that will be included in the review and written together with `SKILL.md`.';
|
||
optionalTitle: 'Optional files';
|
||
references: 'References';
|
||
referencesDescription: 'Add supporting docs, links, or examples the runtime can look at.';
|
||
scripts: 'Scripts';
|
||
scriptsDescription: 'Add helper commands or setup notes. Review carefully before sharing this skill.';
|
||
title: '3. Extra files';
|
||
};
|
||
fields: {
|
||
compatibility: 'Compatibility';
|
||
description: 'Description';
|
||
folderName: 'Folder name';
|
||
folderNameHint: 'We suggest this automatically from the skill name so review works right away.';
|
||
invocation: 'How it should be used';
|
||
license: 'License';
|
||
name: 'Skill name';
|
||
notes: 'Extra notes or guardrails';
|
||
root: 'Where to store it';
|
||
scope: 'Who can use it';
|
||
steps: 'Main steps to follow';
|
||
whenToUse: 'When to reach for this';
|
||
};
|
||
instructions: {
|
||
description: 'These sections generate the skill file for you, so you do not need to edit markdown unless you want to.';
|
||
locked: 'Structured fields are locked because you switched to manual `SKILL.md` editing below.';
|
||
title: '2. Instructions';
|
||
};
|
||
invocation: {
|
||
auto: 'Can be used automatically';
|
||
manualOnly: 'Only when you ask for it';
|
||
};
|
||
placeholders: {
|
||
compatibility: 'claude-code, cursor';
|
||
description: 'What this skill helps with';
|
||
license: 'MIT';
|
||
name: 'Write concise skill name';
|
||
notes: 'Example: Call out missing tests, regressions, and risky assumptions.';
|
||
steps: '1. Inspect the relevant files.\n2. Explain the main risk first.\n3. Suggest the safest fix.';
|
||
whenToUse: 'Example: Use this when the task is a code review or bug triage request.';
|
||
};
|
||
review: {
|
||
creating: 'Creating a skill';
|
||
hint: 'Review the file changes first, then confirm save in the next step.';
|
||
saving: 'Saving this skill';
|
||
};
|
||
root: {
|
||
codexOnly: ' - Codex only';
|
||
shared: ' - Shared';
|
||
};
|
||
scope: {
|
||
project: 'Project: {{project}}';
|
||
projectUnavailable: 'Project unavailable';
|
||
user: 'User';
|
||
};
|
||
title: {
|
||
create: 'Create skill';
|
||
edit: 'Edit skill';
|
||
};
|
||
};
|
||
skillImport: {
|
||
actions: {
|
||
backToImport: 'Back To Import';
|
||
browse: 'Browse';
|
||
cancel: 'Cancel';
|
||
importSkill: 'Import Skill';
|
||
preparing: 'Preparing...';
|
||
reviewAndImport: 'Review And Import';
|
||
};
|
||
description: 'Pick an existing skill folder, review what will be copied, then import it into one of your supported skill locations.';
|
||
errors: {
|
||
importFailed: 'Failed to import skill';
|
||
invalidFolderName: 'Pick a simpler destination folder name using letters, numbers, dots, dashes, or underscores.';
|
||
missingSkillFile: 'This folder does not look like a skill yet. It needs a SKILL.md, Skill.md, or skill.md file.';
|
||
mustBeDirectory: 'Choose a folder to import, not a single file.';
|
||
reviewFailed: 'Failed to review import changes';
|
||
symbolicLinks: 'This folder contains symbolic links. Import the real files instead of links.';
|
||
tooLarge: 'This skill folder is too large to import safely. Trim large assets and try again.';
|
||
tooManyFiles: 'This skill folder is too large to import at once. Remove extra files and try again.';
|
||
};
|
||
fields: {
|
||
audience: 'Who can use it';
|
||
destinationFolderName: 'Destination folder name';
|
||
sourceFolder: 'Source folder';
|
||
storage: 'Where to store it';
|
||
};
|
||
placeholders: {
|
||
defaultFolderName: 'Defaults to source folder name';
|
||
};
|
||
reviewHint: 'Review the copied files first, then confirm the import in the next step.';
|
||
reviewLabel: 'Importing this skill';
|
||
rootSuffix: {
|
||
codexOnly: ' - Codex only';
|
||
shared: ' - Shared';
|
||
};
|
||
scope: {
|
||
project: 'Project: {{project}}';
|
||
projectUnavailable: 'Project unavailable';
|
||
user: 'User';
|
||
};
|
||
steps: {
|
||
chooseFolder: {
|
||
description: 'This should be a folder that already contains a `SKILL.md`, `Skill.md`, or `skill.md` file.';
|
||
title: '1. Choose a skill folder';
|
||
};
|
||
location: {
|
||
description: 'Personal skills work everywhere. Project skills only show up for one codebase.';
|
||
title: '2. Decide where it belongs';
|
||
};
|
||
};
|
||
title: 'Import skill';
|
||
};
|
||
skillReview: {
|
||
binaryBadge: 'binary';
|
||
binaryPreviewHidden: 'Binary file preview is not shown. The file will be copied as-is.';
|
||
confirmPromptPrefix: 'Review the diff below, then use';
|
||
confirmPromptSuffix: 'to apply these changes.';
|
||
description: '{{reviewLabel}} previews the filesystem changes first. Nothing is written until you confirm below.';
|
||
noChanges: 'No file changes detected yet.';
|
||
noPreview: 'No preview available.';
|
||
summary: {
|
||
binary: '{{count}} binary';
|
||
fileChanges: '{{count}} file changes';
|
||
fileChanges_few: '{{count}} file changes';
|
||
fileChanges_many: '{{count}} file changes';
|
||
fileChanges_one: '{{count}} file change';
|
||
fileChanges_other: '{{count}} file changes';
|
||
new: '{{count}} new';
|
||
removed: '{{count}} removed';
|
||
updated: '{{count}} updated';
|
||
};
|
||
title: 'Review skill changes';
|
||
};
|
||
skillsPanel: {
|
||
actions: {
|
||
createSkill: 'Create Skill';
|
||
import: 'Import';
|
||
};
|
||
badges: {
|
||
assets: 'Assets';
|
||
hasScripts: 'Has scripts';
|
||
needsAttention: 'Needs attention';
|
||
references: 'References';
|
||
storedIn: 'Stored in {{root}}';
|
||
};
|
||
configuredRuntime: 'the configured runtime';
|
||
counts: {
|
||
codexOnly: '{{count}} Codex only';
|
||
codexOnly_few: '{{count}} Codex only';
|
||
codexOnly_many: '{{count}} Codex only';
|
||
codexOnly_one: '{{count}} Codex only';
|
||
codexOnly_other: '{{count}} Codex only';
|
||
personal: '{{count}} personal';
|
||
personal_few: '{{count}} personal';
|
||
personal_many: '{{count}} personal';
|
||
personal_one: '{{count}} personal';
|
||
personal_other: '{{count}} personal';
|
||
project: '{{count}} project';
|
||
project_few: '{{count}} project';
|
||
project_many: '{{count}} project';
|
||
project_one: '{{count}} project';
|
||
project_other: '{{count}} project';
|
||
shared: '{{count}} shared';
|
||
shared_few: '{{count}} shared';
|
||
shared_many: '{{count}} shared';
|
||
shared_one: '{{count}} shared';
|
||
shared_other: '{{count}} shared';
|
||
total: '{{count}} total';
|
||
total_few: '{{count}} total';
|
||
total_many: '{{count}} total';
|
||
total_one: '{{count}} total';
|
||
total_other: '{{count}} total';
|
||
};
|
||
empty: {
|
||
noMatches: 'No skills match your search';
|
||
noMatchesDescription: 'Try a different search term or switch filters.';
|
||
noSkills: 'No skills yet';
|
||
noSkillsDescription: 'Create your first skill to teach a repeatable workflow, or import one you already use.';
|
||
};
|
||
filters: {
|
||
all: 'All skills';
|
||
codexOnly: 'Codex only';
|
||
hasScripts: 'Has scripts';
|
||
needsAttention: 'Needs attention';
|
||
personal: 'Personal';
|
||
project: 'Project';
|
||
shared: 'Shared';
|
||
};
|
||
hero: {
|
||
codexAvailable: 'Use `.codex` when a skill should stay Codex-only.';
|
||
codexUnavailable: 'Existing `.codex` skills stay editable here, but new Codex-only skills need the Codex runtime enabled.';
|
||
description: 'Skills are reusable instructions that help the runtime handle the same kind of task more consistently.';
|
||
guidance: 'Use personal skills for habits you want everywhere. Use project skills for workflows that only make sense inside one codebase.';
|
||
personalContext: 'You are seeing only your personal skills right now.';
|
||
projectContext: 'You are seeing skills for {{project}} plus your personal skills.';
|
||
title: 'Teach repeatable work';
|
||
};
|
||
invocation: {
|
||
auto: 'Runs automatically when it fits';
|
||
manualOnly: 'Only runs when you explicitly ask for it';
|
||
};
|
||
loading: {
|
||
loading: 'Loading skills...';
|
||
refreshing: 'Refreshing skills...';
|
||
};
|
||
runtimeAudience: 'Shared skills in `.claude`, `.cursor`, and `.agents` are available to {{audience}}. Skills stored in `.codex` stay Codex-only when Codex support is available.';
|
||
scope: {
|
||
project: 'This project';
|
||
user: 'Personal';
|
||
};
|
||
searchPlaceholder: 'Search by skill name or what it helps with...';
|
||
sections: {
|
||
personal: {
|
||
description: 'Habits and instructions you want available everywhere.';
|
||
title: 'Personal skills';
|
||
};
|
||
project: {
|
||
description: 'Workflows that only make sense for this codebase.';
|
||
title: 'Project skills';
|
||
};
|
||
};
|
||
sort: {
|
||
label: 'Sort skills';
|
||
name: 'Name';
|
||
recent: 'Recent';
|
||
};
|
||
status: {
|
||
hasScripts: 'Includes scripts, so review it carefully';
|
||
needsAttention: 'Needs attention before you rely on it';
|
||
ready: 'Ready to use';
|
||
};
|
||
success: {
|
||
created: 'Skill created successfully.';
|
||
imported: 'Skill imported successfully.';
|
||
saved: 'Skill saved successfully.';
|
||
};
|
||
};
|
||
store: {
|
||
actions: {
|
||
addCustom: 'Add Custom';
|
||
openDashboard: 'Open Dashboard';
|
||
refreshCatalog: 'Refresh catalog';
|
||
};
|
||
capabilities: {
|
||
mcp: 'MCP: {{status}}';
|
||
plugins: 'Plugins: {{status}}';
|
||
skills: 'Skills: {{status}}';
|
||
};
|
||
desktopOnly: 'Available in the desktop app only.';
|
||
provider: {
|
||
checkingStatus: 'Checking provider status...';
|
||
connected: 'Connected';
|
||
loading: 'Loading...';
|
||
needsSetup: 'Needs setup';
|
||
readyToConfigure: 'Ready to configure';
|
||
unsupported: 'Unsupported';
|
||
};
|
||
runtime: {
|
||
checkingAvailabilityDescription: 'Extensions need the configured runtime to manage plugins, MCP servers, skills, and provider connections.';
|
||
checkingAvailabilityTitle: 'Checking extensions runtime availability';
|
||
failedToStartDescription: 'Extensions are disabled until the runtime passes its startup health check. Open the Dashboard to repair or reinstall it.';
|
||
failedToStartTitle: 'The configured runtime was found but failed to start';
|
||
multimodelCapabilitiesDescription: 'Provider support can differ by section. Plugins are shown only where the runtime explicitly declares support.';
|
||
multimodelCapabilitiesTitle: 'Multimodel runtime capabilities';
|
||
needsSignInDescription: '{{runtime}} was found{{version}}, but plugin installs are disabled until you sign in from the Dashboard.';
|
||
needsSignInTitle: '{{runtime}} needs sign-in';
|
||
notAvailableDescription: 'Extensions are disabled until the runtime is installed. Open the Dashboard to install it and retry.';
|
||
notAvailableTitle: 'The configured runtime is not available';
|
||
readyDescription: 'Plugins can be installed from this page{{versionSuffix}}.';
|
||
readyTitle: '{{runtime}} is ready';
|
||
requiredForMutations: 'The configured runtime is required to install or uninstall extensions. Install or repair it from the Dashboard.';
|
||
};
|
||
sessionsRestartWarning: "Running sessions won't pick up extension changes until restarted.";
|
||
tabs: {
|
||
apiKeys: {
|
||
description: 'Secret keys for online services. Add them here so plugins, servers, and integrations can connect and work.';
|
||
label: 'API Keys';
|
||
};
|
||
mcpServers: {
|
||
description: 'Connections to outside tools and apps. They let the runtime read data or do actions beyond this app.';
|
||
label: 'MCP Servers';
|
||
};
|
||
plugins: {
|
||
description: 'Small add-ons for the runtime. In multimodel mode they currently apply to Anthropic sessions when supported. Broader provider support is in development.';
|
||
label: 'Plugins';
|
||
};
|
||
skills: {
|
||
description: 'Ready-made instructions for common jobs. They help the runtime handle repeatable tasks more consistently.';
|
||
label: 'Skills';
|
||
};
|
||
};
|
||
title: 'Extensions';
|
||
};
|
||
};
|
||
report: {
|
||
cost: {
|
||
breakdownTitle: 'Cost Breakdown (per 1M tokens)';
|
||
cacheRead: 'Cache Read';
|
||
cacheWrite: 'Cache Write';
|
||
cost: 'Cost';
|
||
input: 'Input';
|
||
noCommits: 'no commits';
|
||
noLinesChanged: 'no lines changed';
|
||
output: 'Output';
|
||
parent: 'Parent: {{cost}}';
|
||
parentCost: 'Parent Cost';
|
||
perCommit: 'Per Commit';
|
||
perCommitFormula: 'total cost ÷ {{count}} commit';
|
||
perCommitFormula_few: 'total cost ÷ {{count}} commits';
|
||
perCommitFormula_many: 'total cost ÷ {{count}} commits';
|
||
perCommitFormula_one: 'total cost ÷ {{count}} commit';
|
||
perCommitFormula_other: 'total cost ÷ {{count}} commits';
|
||
perLineChanged: 'Per Line Changed';
|
||
perLineFormula: 'total cost ÷ {{count}} line';
|
||
perLineFormula_few: 'total cost ÷ {{count}} lines';
|
||
perLineFormula_many: 'total cost ÷ {{count}} lines';
|
||
perLineFormula_one: 'total cost ÷ {{count}} line';
|
||
perLineFormula_other: 'total cost ÷ {{count}} lines';
|
||
subagent: 'Subagent: {{cost}}';
|
||
subagentCost: 'Subagent Cost';
|
||
title: 'Cost Analysis';
|
||
total: 'Total';
|
||
};
|
||
errors: {
|
||
count: '{{count}} errors';
|
||
count_few: '{{count}} errors';
|
||
count_many: '{{count}} errors';
|
||
count_one: '{{count}} error';
|
||
count_other: '{{count}} errors';
|
||
error: 'Error';
|
||
input: 'Input';
|
||
messageIndex: 'msg #{{index}}';
|
||
permissionDenialCount: '{{count}} permission denials';
|
||
permissionDenialCount_few: '{{count}} permission denials';
|
||
permissionDenialCount_many: '{{count}} permission denials';
|
||
permissionDenialCount_one: '{{count}} permission denial';
|
||
permissionDenialCount_other: '{{count}} permission denials';
|
||
permissionDenied: 'Permission Denied';
|
||
title: 'Errors';
|
||
};
|
||
friction: {
|
||
corrections: 'Corrections';
|
||
correctionsCount: '{{count}} corrections';
|
||
correctionsCount_few: '{{count}} corrections';
|
||
correctionsCount_many: '{{count}} corrections';
|
||
correctionsCount_one: '{{count}} correction';
|
||
correctionsCount_other: '{{count}} corrections';
|
||
rate: 'Friction Rate: {{rate}}%';
|
||
repeatedBashCommands: 'Repeated Bash Commands';
|
||
reworkedFiles: 'Reworked Files (3+ edits)';
|
||
thrashingSignals: 'Thrashing Signals';
|
||
title: 'Friction Signals';
|
||
};
|
||
git: {
|
||
branchesCreated: 'Branches Created';
|
||
commits: 'Commits';
|
||
linesAdded: 'Lines Added';
|
||
linesRemoved: 'Lines Removed';
|
||
pushes: 'Pushes';
|
||
title: 'Git Activity';
|
||
};
|
||
insights: {
|
||
agent: 'agent';
|
||
agentTree: 'Agent Tree ({{count}} {{unit}})';
|
||
agentTree_few: 'Agent Tree ({{count}} {{unit}})';
|
||
agentTree_many: 'Agent Tree ({{count}} {{unit}})';
|
||
agentTree_one: 'Agent Tree ({{count}} {{unit}})';
|
||
agentTree_other: 'Agent Tree ({{count}} {{unit}})';
|
||
agent_few: 'agents';
|
||
agent_many: 'agents';
|
||
agent_one: 'agent';
|
||
agent_other: 'agents';
|
||
background: '(background)';
|
||
bashCommands: 'Bash Commands';
|
||
keyTakeaways: 'Key Takeaways';
|
||
outOfScopeFindings: 'Out-of-Scope Findings ({{count}})';
|
||
outOfScopeFindings_few: 'Out-of-Scope Findings ({{count}})';
|
||
outOfScopeFindings_many: 'Out-of-Scope Findings ({{count}})';
|
||
outOfScopeFindings_one: 'Out-of-Scope Findings ({{count}})';
|
||
outOfScopeFindings_other: 'Out-of-Scope Findings ({{count}})';
|
||
questionsAsked: 'Questions Asked ({{count}})';
|
||
questionsAsked_few: 'Questions Asked ({{count}})';
|
||
questionsAsked_many: 'Questions Asked ({{count}})';
|
||
questionsAsked_one: 'Questions Asked ({{count}})';
|
||
questionsAsked_other: 'Questions Asked ({{count}})';
|
||
repeated: 'Repeated';
|
||
skillsInvoked: 'Skills Invoked ({{count}})';
|
||
skillsInvoked_few: 'Skills Invoked ({{count}})';
|
||
skillsInvoked_many: 'Skills Invoked ({{count}})';
|
||
skillsInvoked_one: 'Skills Invoked ({{count}})';
|
||
skillsInvoked_other: 'Skills Invoked ({{count}})';
|
||
taskDispatches: 'Task Dispatches ({{count}})';
|
||
taskDispatches_few: 'Task Dispatches ({{count}})';
|
||
taskDispatches_many: 'Task Dispatches ({{count}})';
|
||
taskDispatches_one: 'Task Dispatches ({{count}})';
|
||
taskDispatches_other: 'Task Dispatches ({{count}})';
|
||
tasksCreated: 'Tasks Created ({{count}})';
|
||
tasksCreated_few: 'Tasks Created ({{count}})';
|
||
tasksCreated_many: 'Tasks Created ({{count}})';
|
||
tasksCreated_one: 'Tasks Created ({{count}})';
|
||
tasksCreated_other: 'Tasks Created ({{count}})';
|
||
teamMode: 'Team Mode';
|
||
teams: 'Teams: {{teams}}';
|
||
title: 'Session Insights';
|
||
total: 'Total';
|
||
unique: 'Unique';
|
||
};
|
||
overview: {
|
||
metrics: {
|
||
branch: 'Branch';
|
||
compactions: 'Compactions';
|
||
contextUsage: 'Context Usage';
|
||
duration: 'Duration';
|
||
messages: 'Messages';
|
||
project: 'Project';
|
||
sessionId: 'Session ID';
|
||
subagents: 'Subagents';
|
||
};
|
||
no: 'No';
|
||
title: 'Overview';
|
||
yes: 'Yes';
|
||
};
|
||
quality: {
|
||
chars: 'chars';
|
||
corrections: 'Corrections';
|
||
failed: 'failed';
|
||
fileReadRedundancy: 'File Read Redundancy';
|
||
firstMessage: 'First Message';
|
||
firstRun: 'First Run';
|
||
frictionRate: 'Friction Rate';
|
||
lastRun: 'Last Run';
|
||
messagesBeforeWork: 'Messages Before Work';
|
||
passed: 'passed';
|
||
percentOfTotal: '% of Total';
|
||
promptQuality: 'Prompt Quality';
|
||
readsPerUniqueFile: 'Reads/Unique File';
|
||
snapshot: 'snapshot';
|
||
snapshot_few: 'snapshots';
|
||
snapshot_many: 'snapshots';
|
||
snapshot_one: 'snapshot';
|
||
snapshot_other: 'snapshots';
|
||
startupOverhead: 'Startup Overhead';
|
||
testProgression: 'Test Progression';
|
||
title: 'Quality Signals';
|
||
tokensBeforeWork: 'Tokens Before Work';
|
||
totalReads: 'Total Reads';
|
||
uniqueFiles: 'Unique Files';
|
||
userMessages: 'User Messages';
|
||
};
|
||
subagents: {
|
||
metrics: {
|
||
count: 'Count';
|
||
totalCost: 'Total Cost';
|
||
totalDuration: 'Total Duration';
|
||
totalTokens: 'Total Tokens';
|
||
};
|
||
table: {
|
||
cost: 'Cost';
|
||
description: 'Description';
|
||
duration: 'Duration';
|
||
tokens: 'Tokens';
|
||
type: 'Type';
|
||
};
|
||
title: 'Subagents';
|
||
};
|
||
timeline: {
|
||
idleAnalysis: 'Idle Analysis';
|
||
keyEvents: 'Key Events';
|
||
messageNumber: 'msg #{{number}}';
|
||
metrics: {
|
||
activeTime: 'Active Time';
|
||
idleGaps: 'Idle Gaps';
|
||
idlePercent: 'Idle %';
|
||
totalIdle: 'Total Idle';
|
||
};
|
||
modelSwitches: 'Model Switches ({{count}})';
|
||
modelSwitches_few: 'Model Switches ({{count}})';
|
||
modelSwitches_many: 'Model Switches ({{count}})';
|
||
modelSwitches_one: 'Model Switches ({{count}})';
|
||
modelSwitches_other: 'Model Switches ({{count}})';
|
||
title: 'Timeline & Activity';
|
||
};
|
||
tokens: {
|
||
apiCalls: 'API Calls';
|
||
cacheCreate: 'Cache Create';
|
||
cacheEfficiency: 'Cache Efficiency';
|
||
cacheRead: 'Cache Read';
|
||
cacheReadPct: 'Cache Read %';
|
||
coldStart: 'Cold Start';
|
||
cost: 'Cost';
|
||
input: 'Input';
|
||
model: 'Model';
|
||
no: 'No';
|
||
output: 'Output';
|
||
readWriteRatio: 'R/W Ratio';
|
||
title: 'Token Usage';
|
||
total: 'Total';
|
||
yes: 'Yes';
|
||
};
|
||
tools: {
|
||
columns: {
|
||
calls: 'Calls';
|
||
errors: 'Errors';
|
||
health: 'Health';
|
||
successPercent: 'Success %';
|
||
tool: 'Tool';
|
||
};
|
||
summary: '{{formattedCount}} total calls across {{toolCount}} tools';
|
||
title: 'Tool Usage';
|
||
};
|
||
};
|
||
settings: {
|
||
advanced: {
|
||
about: {
|
||
appIconAlt: 'App icon';
|
||
description: 'Assemble AI agent teams that work autonomously in parallel, communicate across teams, and manage tasks on a kanban board - with built-in code review, live process monitoring, and full tool visibility.';
|
||
standalone: 'Standalone';
|
||
title: 'About';
|
||
version: 'Version {{version}}';
|
||
};
|
||
appName: 'Agent Teams AI';
|
||
configuration: {
|
||
editConfig: 'Edit Config';
|
||
exportConfig: 'Export Config';
|
||
importConfig: 'Import Config';
|
||
openInEditor: 'Open in Editor';
|
||
resetToDefaults: 'Reset to Defaults';
|
||
title: 'Configuration';
|
||
};
|
||
updates: {
|
||
available: 'v{{version}} available';
|
||
check: 'Check for Updates';
|
||
checking: 'Checking...';
|
||
ready: 'Update ready';
|
||
unknownVersion: 'unknown';
|
||
upToDate: 'Up to date';
|
||
};
|
||
};
|
||
cliRuntime: {
|
||
actions: {
|
||
checkForUpdates: 'Check for Updates';
|
||
checking: 'Checking...';
|
||
extensions: 'Extensions';
|
||
installRuntime: 'Install {{runtime}}';
|
||
manage: 'Manage';
|
||
recheck: 'Re-check';
|
||
reinstallRuntime: 'Reinstall {{runtime}}';
|
||
retry: 'Retry';
|
||
update: 'Update';
|
||
};
|
||
installer: {
|
||
checkingLatest: 'Checking latest version...';
|
||
downloading: 'Downloading...';
|
||
failed: 'Installation failed';
|
||
installed: 'Installed v{{version}}';
|
||
installing: 'Installing...';
|
||
latest: 'latest';
|
||
verifying: 'Verifying checksum...';
|
||
};
|
||
labels: {
|
||
multimodel: 'Multimodel';
|
||
};
|
||
loading: {
|
||
aiProviders: 'Checking AI Providers...';
|
||
claudeCli: 'Checking Claude CLI...';
|
||
};
|
||
provider: {
|
||
backend: 'Backend: {{backend}}';
|
||
loadingModels: 'Loading models...';
|
||
modelsUnavailable: 'Models unavailable for this runtime build';
|
||
runtime: 'Runtime: {{runtime}}';
|
||
};
|
||
providerTerminal: {
|
||
authFailed: 'Authentication failed';
|
||
authUpdated: 'Authentication updated';
|
||
loggedOut: 'Provider logged out';
|
||
login: 'Login';
|
||
logout: 'Logout';
|
||
logoutFailed: 'Logout failed';
|
||
};
|
||
status: {
|
||
configuredNotFound: 'The configured {{runtime}} was not found.';
|
||
foundButFailed: '{{runtime}} was found but failed to start';
|
||
healthCheckFailed: 'The configured {{runtime}} failed its startup health check.';
|
||
notInstalled: '{{runtime}} not installed';
|
||
};
|
||
title: 'CLI Runtime';
|
||
};
|
||
cliStatus: {
|
||
versionUpgrade: 'v{{current}} -> v{{latest}}';
|
||
};
|
||
configEditor: {
|
||
errors: {
|
||
loadFailed: 'Failed to load config';
|
||
saveFailed: 'Failed to save config';
|
||
};
|
||
footer: {
|
||
autoSave: 'Changes auto-save after editing';
|
||
escapeKey: 'Esc';
|
||
toClose: 'to close';
|
||
};
|
||
loading: 'Loading config...';
|
||
status: {
|
||
invalidJson: 'Invalid JSON';
|
||
saveFailed: 'Save failed';
|
||
saved: 'Saved';
|
||
saving: 'Saving...';
|
||
};
|
||
title: 'Edit Configuration';
|
||
};
|
||
connection: {
|
||
actions: {
|
||
connect: 'Connect';
|
||
connecting: 'Connecting...';
|
||
disconnect: 'Disconnect';
|
||
testConnection: 'Test Connection';
|
||
testing: 'Testing...';
|
||
};
|
||
currentMode: {
|
||
description: 'Data source for session files';
|
||
label: 'Current Mode';
|
||
local: 'Local ({{path}})';
|
||
};
|
||
description: 'Connect to a remote machine to view Claude Code sessions running there';
|
||
form: {
|
||
authentication: 'Authentication';
|
||
host: 'Host';
|
||
hostPlaceholder: 'hostname or SSH config alias';
|
||
password: 'Password';
|
||
port: 'Port';
|
||
privateKeyPath: 'Private Key Path';
|
||
username: 'Username';
|
||
usernamePlaceholder: 'user';
|
||
};
|
||
savedProfiles: {
|
||
title: 'Saved Profiles';
|
||
};
|
||
ssh: {
|
||
title: 'SSH Connection';
|
||
};
|
||
status: {
|
||
connectedTo: 'Connected to {{host}}';
|
||
remoteSessions: 'Viewing remote sessions via SSH';
|
||
};
|
||
test: {
|
||
failed: 'Connection failed: {{error}}';
|
||
success: 'Connection successful';
|
||
unknownError: 'Unknown error';
|
||
};
|
||
title: 'Remote Connection';
|
||
};
|
||
general: {
|
||
agentLanguage: {
|
||
description: 'Language for agent communication';
|
||
descriptionWithDetected: 'Language for agent communication (detected: {{detected}})';
|
||
emptyMessage: 'No language found.';
|
||
label: 'Language';
|
||
searchPlaceholder: 'Search language...';
|
||
selectPlaceholder: 'Select language...';
|
||
title: 'Agent Language';
|
||
};
|
||
appLanguage: {
|
||
description: 'Language for the application interface.';
|
||
label: 'Language';
|
||
title: 'App Language';
|
||
};
|
||
appearance: {
|
||
autoExpandAIGroups: {
|
||
description: 'Automatically expand each response turn when opening a transcript or receiving a new message';
|
||
label: 'Expand AI responses by default';
|
||
};
|
||
nativeTitleBar: {
|
||
description: 'Use the default system window frame instead of the custom title bar';
|
||
label: 'Use native title bar';
|
||
restartConfirm: {
|
||
confirmLabel: 'Restart';
|
||
message: 'The app needs to restart to apply the title bar change. Restart now?';
|
||
title: 'Restart required';
|
||
};
|
||
};
|
||
theme: {
|
||
description: 'Choose your preferred color theme';
|
||
label: 'Theme';
|
||
options: {
|
||
dark: 'Dark';
|
||
light: 'Light';
|
||
system: 'System';
|
||
};
|
||
};
|
||
title: 'Appearance';
|
||
};
|
||
browserAccess: {
|
||
serverMode: {
|
||
description: 'Start an HTTP server to access the UI from a browser or embed in iframes';
|
||
label: 'Enable server mode';
|
||
};
|
||
title: 'Browser Access';
|
||
};
|
||
localClaudeRoot: {
|
||
actions: {
|
||
selectFolder: 'Select Folder';
|
||
selectFolderManually: 'Select Folder Manually';
|
||
useAutoDetect: 'Use Auto-Detect';
|
||
useFolder: 'Use Folder';
|
||
usePath: 'Use Path';
|
||
useThisPath: 'Use This Path';
|
||
useWsl: 'Using Linux/WSL?';
|
||
};
|
||
confirm: {
|
||
noProjectsDir: {
|
||
message: 'This folder does not contain a "projects" directory. Continue anyway?';
|
||
title: 'No projects directory found';
|
||
};
|
||
noWslPaths: {
|
||
message: 'Could not find WSL distros with Claude data automatically. Select folder manually?';
|
||
title: 'No WSL Claude paths found';
|
||
};
|
||
notClaudeDir: {
|
||
message: 'This folder is named "{{folderName}}", not ".claude". Continue anyway?';
|
||
title: 'Selected folder is not .claude';
|
||
};
|
||
wslNoProjectsDir: {
|
||
message: '"{{path}}" does not contain a "projects" directory. Continue anyway?';
|
||
title: 'WSL path missing projects directory';
|
||
};
|
||
};
|
||
current: {
|
||
autoDetected: 'Auto-detected: {{path}}';
|
||
autoDetectedPath: 'Using auto-detected path';
|
||
customPath: 'Using custom path';
|
||
label: 'Current Local Root';
|
||
};
|
||
description: 'Choose which local folder is treated as your Claude data root';
|
||
errors: {
|
||
detectWslFailed: 'Failed to detect WSL Claude root paths';
|
||
loadFailed: 'Failed to load local Claude root settings';
|
||
updateFailed: 'Failed to update Claude root';
|
||
};
|
||
title: 'Local Claude Root';
|
||
wslModal: {
|
||
closeAriaLabel: 'Close WSL path modal';
|
||
description: 'Detected WSL distributions and Claude root candidates';
|
||
noProjectsDir: 'No projects directory detected';
|
||
title: 'Select WSL Claude Root';
|
||
};
|
||
};
|
||
privacy: {
|
||
telemetry: {
|
||
description: 'Help improve the app by sending anonymous crash and performance data';
|
||
label: 'Send crash reports';
|
||
};
|
||
title: 'Privacy';
|
||
};
|
||
server: {
|
||
runningOn: 'Running on';
|
||
standaloneModeDescription: 'Running in standalone mode. The HTTP server is always active. System notifications are not available - notification triggers are logged in-app only.';
|
||
title: 'Server';
|
||
};
|
||
startup: {
|
||
launchAtLogin: {
|
||
description: 'Automatically start the app when you log in';
|
||
label: 'Launch at login';
|
||
};
|
||
showDockIcon: {
|
||
description: 'Display the app icon in the dock (macOS)';
|
||
label: 'Show dock icon';
|
||
};
|
||
title: 'Startup';
|
||
};
|
||
};
|
||
notificationTriggers: {
|
||
add: {
|
||
cancel: 'Cancel';
|
||
submit: 'Add Trigger';
|
||
title: 'Add Custom Trigger';
|
||
};
|
||
builtin: {
|
||
description: 'Default triggers that come with the application. You can enable or disable them and customize their patterns.';
|
||
title: 'Built-in Triggers';
|
||
};
|
||
card: {
|
||
builtinBadge: 'Builtin';
|
||
collapseAriaLabel: 'Collapse';
|
||
deleteAriaLabel: 'Delete trigger';
|
||
editNameAriaLabel: 'Edit name';
|
||
expandAriaLabel: 'Expand';
|
||
};
|
||
color: {
|
||
customHexTitle: 'Custom hex color';
|
||
invalidHex: 'Invalid hex';
|
||
};
|
||
configuration: {
|
||
alertIfGreaterThan: 'Alert if >';
|
||
emptyPatternHint: 'Leave empty to match all content. Uses JavaScript regex syntax.';
|
||
errorStatusDescription: 'Triggers when a tool execution reports an error (is_error: true).';
|
||
matchPatternPlaceholder: 'e.g., error|failed|exception';
|
||
tokensUnit: 'tokens';
|
||
};
|
||
custom: {
|
||
description: 'Create your own triggers to get notified for specific patterns or tool outputs.';
|
||
empty: 'No custom triggers configured yet.';
|
||
title: 'Custom Triggers';
|
||
};
|
||
errors: {
|
||
invalidRegexPattern: 'Invalid regex pattern';
|
||
};
|
||
fields: {
|
||
contentType: 'Content Type';
|
||
matchField: 'Match Field';
|
||
matchPattern: 'Match Pattern (Regex)';
|
||
scopeToolName: 'Scope / Tool Name';
|
||
scopeToolNameOptional: 'Scope / Tool Name (optional)';
|
||
threshold: 'Threshold';
|
||
tokenType: 'Token Type';
|
||
triggerNamePlaceholder: 'e.g., Build Failure Alert';
|
||
triggerNameRequired: 'Trigger Name *';
|
||
};
|
||
ignorePatterns: {
|
||
hint: 'Press Enter to add. Notification is skipped if any pattern matches.';
|
||
placeholder: 'Add ignore regex...';
|
||
removeAriaLabel: 'Remove ignore pattern';
|
||
summary: 'Advanced: Exclusion Rules';
|
||
title: 'Ignore Patterns (skip if matches)';
|
||
};
|
||
options: {
|
||
contentTypes: {
|
||
text: 'Text Output';
|
||
thinking: 'Thinking';
|
||
tool_result: 'Tool Result';
|
||
tool_use: 'Tool Use';
|
||
};
|
||
matchFields: {
|
||
args: 'Arguments';
|
||
command: 'Command';
|
||
content: 'Content';
|
||
description: 'Description';
|
||
file_path: 'File Path';
|
||
fullInput: 'Full Input (JSON)';
|
||
glob: 'Glob Filter';
|
||
new_string: 'New String';
|
||
old_string: 'Old String';
|
||
path: 'Path';
|
||
pattern: 'Pattern';
|
||
prompt: 'Prompt';
|
||
query: 'Query';
|
||
skill: 'Skill Name';
|
||
subagent_type: 'Subagent Type';
|
||
text: 'Text Content';
|
||
thinking: 'Thinking Content';
|
||
url: 'URL';
|
||
};
|
||
modes: {
|
||
content_match: 'Content Pattern';
|
||
error_status: 'Execution Error';
|
||
token_threshold: 'High Token Usage';
|
||
};
|
||
tokenTypes: {
|
||
input: 'Input Tokens';
|
||
output: 'Output Tokens';
|
||
total: 'Total Tokens';
|
||
};
|
||
toolNames: {
|
||
anyTool: 'Any Tool';
|
||
};
|
||
};
|
||
preview: {
|
||
defaultTestTriggerName: 'Test Trigger';
|
||
detectedSuffix: 'errors would have been detected';
|
||
more: '...and {{count}} more';
|
||
more_few: '...and {{count}} more';
|
||
more_many: '...and {{count}} more';
|
||
more_one: '...and {{count}} more';
|
||
more_other: '...and {{count}} more';
|
||
testTrigger: 'Test Trigger';
|
||
testing: 'Testing...';
|
||
title: 'Preview';
|
||
truncatedWarning: 'Search stopped early (timeout or count limit). Actual matches may be higher.';
|
||
viewSession: 'View Session';
|
||
};
|
||
repositoryScope: {
|
||
empty: 'No repositories selected - trigger applies to all repositories';
|
||
hint: 'When repositories are selected, this trigger only fires for errors in those repositories.';
|
||
placeholder: 'Select repository to add...';
|
||
summary: 'Advanced: Repository Scope';
|
||
title: 'Limit to Repositories (applies only to selected repositories)';
|
||
};
|
||
sections: {
|
||
configuration: 'Configuration';
|
||
dotColor: 'Dot Color';
|
||
generalInfo: 'General Info';
|
||
triggerCondition: 'Trigger Condition';
|
||
};
|
||
};
|
||
notifications: {
|
||
dev: {
|
||
descriptionPrefix: 'Notifications may not work in development mode. macOS identifies the app as "Electron" (bundle ID';
|
||
descriptionSuffix: ') instead of the production app name. Check System Settings > Notifications > Electron to verify permissions.';
|
||
title: 'Dev Mode';
|
||
};
|
||
ignoredRepositories: {
|
||
description: 'Notifications from these repositories will be ignored';
|
||
empty: 'No repositories ignored';
|
||
selectPlaceholder: 'Select repository to ignore...';
|
||
title: 'Ignored Repositories';
|
||
};
|
||
settings: {
|
||
enabled: {
|
||
description: 'Show system notifications for errors and events';
|
||
label: 'Enable System Notifications';
|
||
};
|
||
sound: {
|
||
description: 'Play a sound when notifications appear';
|
||
label: 'Play sound';
|
||
};
|
||
subagentErrors: {
|
||
description: 'Detect and notify about errors in subagent sessions';
|
||
label: 'Include subagent errors';
|
||
};
|
||
title: 'Notification Settings';
|
||
};
|
||
snooze: {
|
||
clear: 'Clear Snooze';
|
||
description: 'Temporarily pause notifications';
|
||
descriptionWithTime: 'Snoozed until {{time}}';
|
||
label: 'Snooze notifications';
|
||
options: {
|
||
'-1': 'Until tomorrow';
|
||
'120': '2 hours';
|
||
'15': '15 minutes';
|
||
'240': '4 hours';
|
||
'30': '30 minutes';
|
||
'60': '1 hour';
|
||
};
|
||
selectDuration: 'Select duration...';
|
||
};
|
||
taskCompletion: {
|
||
description: 'Get native OS notifications when Claude finishes tasks - sounds, banners, and Dock/taskbar badges. Works on macOS, Linux, and Windows.';
|
||
installPlugin: 'Install claude-notifications-go plugin';
|
||
title: 'Task Completion Notifications';
|
||
};
|
||
team: {
|
||
allTasksCompleted: {
|
||
description: 'Notify when every task in a team reaches completed status';
|
||
label: 'All tasks completed';
|
||
};
|
||
autoResumeOnRateLimit: {
|
||
description: 'When Claude reports a reset time, schedule a follow-up nudge for the team lead after the limit resets';
|
||
label: 'Auto-resume after rate limit';
|
||
};
|
||
clarifications: {
|
||
description: 'Show native OS notifications when a task needs your input';
|
||
label: 'Task clarification notifications';
|
||
};
|
||
crossTeamMessage: {
|
||
description: 'Notify when a message arrives from another team';
|
||
label: 'Cross-team message notifications';
|
||
};
|
||
leadInbox: {
|
||
description: 'Notify when teammates send messages to the team lead';
|
||
label: 'Lead inbox notifications';
|
||
};
|
||
statusChange: {
|
||
description: "Show native OS notifications when a task's status changes";
|
||
label: 'Task status change notifications';
|
||
onlySolo: {
|
||
description: 'Notify only when the team has no teammates';
|
||
label: 'Only in Solo mode';
|
||
};
|
||
statuses: {
|
||
description: 'Which target statuses trigger a notification';
|
||
label: 'Notify on these statuses';
|
||
options: {
|
||
approved: 'Approved';
|
||
completed: 'Completed';
|
||
deleted: 'Deleted';
|
||
in_progress: 'Started';
|
||
needsFix: 'Needs Fixes';
|
||
pending: 'Pending';
|
||
review: 'Review';
|
||
};
|
||
};
|
||
};
|
||
taskComments: {
|
||
description: 'Show native OS notifications when agents comment on tasks';
|
||
label: 'Task comment notifications';
|
||
};
|
||
taskCreated: {
|
||
description: 'Show native OS notifications when a new task is created';
|
||
label: 'Task created notifications';
|
||
};
|
||
teamLaunched: {
|
||
description: 'Notify when a team finishes launching and is ready';
|
||
label: 'Team launched notifications';
|
||
};
|
||
title: 'Team Notifications';
|
||
toolApproval: {
|
||
description: 'Notify when a tool needs your approval (Allow/Deny) while the app is not focused';
|
||
label: 'Tool approval notifications';
|
||
};
|
||
userInbox: {
|
||
description: 'Notify when teammates send messages to you';
|
||
label: 'User inbox notifications';
|
||
};
|
||
};
|
||
test: {
|
||
action: 'Send Test';
|
||
description: 'Send a test notification to verify delivery';
|
||
failedToSend: 'Failed to send test notification';
|
||
label: 'Test notification';
|
||
sending: 'Sending...';
|
||
sent: 'Sent!';
|
||
unknownError: 'Unknown error';
|
||
};
|
||
};
|
||
providerRuntime: {
|
||
actions: {
|
||
cancel: 'Cancel';
|
||
cancelLogin: 'Cancel login';
|
||
connectChatGpt: 'Connect ChatGPT';
|
||
delete: 'Delete';
|
||
disable: 'Disable';
|
||
disconnectAccount: 'Disconnect account';
|
||
generateLink: 'Generate link';
|
||
openLogin: 'Open login';
|
||
reconnectAnthropic: 'Reconnect Anthropic';
|
||
refresh: 'Refresh';
|
||
replaceKey: 'Replace key';
|
||
saveEndpoint: 'Save endpoint';
|
||
saveKey: 'Save key';
|
||
saving: 'Saving...';
|
||
setApiKey: 'Set API key';
|
||
updateKey: 'Update key';
|
||
useCode: 'Use code';
|
||
};
|
||
alerts: {
|
||
anthropicApiKeyMissing: 'API key mode is selected, but no Anthropic API credential is available yet.';
|
||
anthropicStoredKeyAvailable: 'A saved API key is available, but app-launched Anthropic sessions use it only after you switch to API key mode.';
|
||
anthropicSubscriptionMissing: 'Anthropic subscription mode is selected. Sign in with Anthropic to use this provider.';
|
||
authTokenMissing: 'Auth token is not configured. Many local Anthropic-compatible endpoints require a non-empty token.';
|
||
chatgptLoginPending: 'Waiting for ChatGPT account login to finish...';
|
||
chatgptLoginStarting: 'Starting ChatGPT login...';
|
||
codexApiKeyMissing: 'API key mode is selected, but no OPENAI_API_KEY or CODEX_API_KEY credential is available yet.';
|
||
codexLocalArtifactsNoSession: 'Codex CLI currently has no active ChatGPT account. Local Codex account data exists, but no active managed session is selected.';
|
||
codexNeedsReconnect: 'Codex has a locally selected ChatGPT account, but the current session needs reconnect.';
|
||
codexNoChatgptAccount: 'Codex CLI currently has no active ChatGPT account. Connect ChatGPT to use your subscription.';
|
||
codexNoCredential: 'No ChatGPT account or API key is available yet.';
|
||
geminiApiUnavailable: 'Gemini API is currently unavailable. Configure `GEMINI_API_KEY` here or use valid Google ADC credentials.';
|
||
withApiKeyFallback: '{{message}} Switch to API key mode to use the detected API key.';
|
||
};
|
||
apiKey: {
|
||
loadingStoredCredentials: 'Loading stored credentials...';
|
||
projectScope: 'Project';
|
||
providers: {
|
||
anthropic: {
|
||
description: 'Use a direct Anthropic API key for API-billed access. Your Anthropic subscription session stays available when you switch back.';
|
||
name: 'Anthropic API Key';
|
||
placeholder: 'sk-ant-...';
|
||
title: 'API key';
|
||
};
|
||
codex: {
|
||
description: 'Use an OpenAI API key as a secondary Codex auth path. If you switch Codex to API key mode, the app will mirror OPENAI_API_KEY into CODEX_API_KEY for native launches.';
|
||
name: 'Codex API Key';
|
||
placeholder: 'sk-proj-...';
|
||
title: 'API key';
|
||
};
|
||
gemini: {
|
||
description: 'Use `GEMINI_API_KEY` for the Gemini API backend. CLI SDK and ADC do not require it.';
|
||
name: 'Gemini API Key';
|
||
placeholder: 'AIza...';
|
||
title: 'API access';
|
||
};
|
||
};
|
||
scope: 'Scope';
|
||
storedIn: 'Stored in {{backend}}';
|
||
storedInApp: 'Stored in app';
|
||
userScope: 'User';
|
||
};
|
||
authModeDescriptions: {
|
||
anthropic: {
|
||
apiKey: 'Force app-launched Anthropic sessions to use an API key credential.';
|
||
auto: 'Use the runtime default behavior. Saved API keys in this app are only used after you switch to API key mode.';
|
||
oauth: 'Force app-launched Anthropic sessions to use the local Anthropic subscription session.';
|
||
};
|
||
codex: {
|
||
apiKey: 'Force native Codex launches to use OPENAI_API_KEY / CODEX_API_KEY billing.';
|
||
auto: 'Prefer your ChatGPT account when it is available. Fall back to API key mode only when needed.';
|
||
chatgpt: 'Force native Codex launches to use your connected ChatGPT account and subscription.';
|
||
};
|
||
};
|
||
codex: {
|
||
account: {
|
||
appServer: 'App-server: {{state}}';
|
||
connected: 'Connected';
|
||
description: 'Manage the local Codex app-server account session that powers subscription-backed native launches.';
|
||
hints: {
|
||
autoUsesApiKeyUntilChatgpt: '{{message}} Auto will keep using the detected API key until ChatGPT is connected.';
|
||
detectedApiKeyNeedsApiMode: '{{message}} The detected API key is only used after you switch Codex to API key mode.';
|
||
localArtifactsNoSession: 'Codex CLI currently reports no active ChatGPT account. Local Codex account data exists, but no active managed session is selected. Usage limits appear here only after Codex CLI sees one.';
|
||
noActiveAccount: 'Codex CLI currently reports no active ChatGPT account. Usage limits appear here only after Codex CLI sees one.';
|
||
reconnectBeforeUsage: 'Codex has a locally selected ChatGPT account, but the current session needs reconnect before usage limits can load here.';
|
||
usageLimitsAfterReport: 'Usage limits appear here after Codex reports them for the connected ChatGPT account.';
|
||
};
|
||
loginInProgress: 'Login in progress';
|
||
plan: 'Plan: {{plan}}';
|
||
reconnectRequired: 'Reconnect required';
|
||
title: 'ChatGPT account';
|
||
};
|
||
install: {
|
||
checking: 'Checking';
|
||
downloading: 'Downloading';
|
||
installCli: 'Install Codex CLI';
|
||
installing: 'Installing';
|
||
retryInstall: 'Retry install';
|
||
title: 'Install Codex CLI into app data';
|
||
};
|
||
rateLimits: {
|
||
credits: 'Credits';
|
||
creditsDescription: 'Credits are shown separately from window-based subscription usage and may be unavailable for plan-backed ChatGPT sessions.';
|
||
noSecondaryWindow: 'Codex did not return a secondary window for this account snapshot.';
|
||
notReported: 'Not reported';
|
||
primaryReset: 'Primary reset';
|
||
primaryUsed: 'Primary used';
|
||
primaryWindow: 'Primary window';
|
||
remainingLeft: '{{value}} left';
|
||
remainingUnknown: 'Remaining unknown';
|
||
secondaryFallback: 'secondary';
|
||
secondaryReset: 'Secondary reset';
|
||
secondaryUsed: 'Secondary used';
|
||
secondaryWindow: 'Secondary window';
|
||
secondaryWindowNote: ' Weekly limits are shown separately in the {{window}} window.';
|
||
usageExplanationGeneric: 'Shows used quota, not remaining quota.';
|
||
usageExplanationWindowOnly: 'Shows used quota in the current {{window}} window, not remaining quota.';
|
||
usageExplanationWithRemaining: '{{used}} used - about {{remaining}} left in the current {{window}} window.';
|
||
usedQuotaNote: 'These percentages show used quota, not remaining quota.';
|
||
weeklyReset: 'Weekly reset';
|
||
weeklyUsed: 'Weekly used';
|
||
weeklyUsedOneWeek: 'Weekly used (1w)';
|
||
weeklyWindow: 'Weekly window';
|
||
};
|
||
};
|
||
compatibleEndpoint: {
|
||
authToken: 'Auth token';
|
||
authTokenMissing: 'Auth token is not configured.';
|
||
baseUrl: 'Base URL';
|
||
description: 'Use an Anthropic-compatible local runtime endpoint.';
|
||
keepSavedToken: 'Leave blank to keep saved token';
|
||
status: {
|
||
endpointDisabledTokenKept: 'Endpoint disabled. Saved token was kept.';
|
||
endpointSaved: 'Endpoint saved';
|
||
endpointSavedTokenMissing: 'Endpoint saved. Auth token is not configured.';
|
||
};
|
||
title: 'Local / compatible endpoint';
|
||
tokenStatus: 'Token {{status}}';
|
||
validation: {
|
||
baseUrlRequired: 'Base URL is required';
|
||
firstPartyAnthropic: 'Use Auto, Subscription, or API key for first-party Anthropic';
|
||
httpRequired: 'Base URL must use http:// or https://';
|
||
invalidUrl: 'Invalid URL';
|
||
noCredentials: 'Base URL must not include credentials';
|
||
};
|
||
};
|
||
connection: {
|
||
authenticationMethod: 'Authentication method';
|
||
descriptions: {
|
||
anthropic: 'Choose how app-launched Anthropic sessions authenticate.';
|
||
codex: 'Choose whether Codex should prefer your ChatGPT subscription or an API key when the native runtime launches.';
|
||
gemini: 'Configure optional API access. CLI SDK and ADC are still discovered automatically.';
|
||
opencode: 'OpenCode authentication and provider inventory are managed by the OpenCode runtime.';
|
||
};
|
||
method: 'Connection method';
|
||
mode: 'Mode: {{mode}}';
|
||
selected: 'Selected';
|
||
switching: 'Switching...';
|
||
title: 'Connection';
|
||
};
|
||
connectionCards: {
|
||
anthropic: {
|
||
apiKeyDescription: 'Use ANTHROPIC_API_KEY and Anthropic API billing.';
|
||
autoDescription: 'Use Anthropic runtime defaults and the best local credential available.';
|
||
hint: 'Auto keeps Anthropic on its default local credential resolution.';
|
||
subscriptionDescription: 'Use your local Anthropic sign-in session and subscription access.';
|
||
subscriptionTitle: 'Anthropic subscription';
|
||
};
|
||
apiKey: {
|
||
title: 'API key';
|
||
};
|
||
auto: {
|
||
title: 'Auto';
|
||
};
|
||
codex: {
|
||
apiKeyDescription: 'Use OPENAI_API_KEY and CODEX_API_KEY billing for native Codex launches.';
|
||
autoDescription: 'Prefer your ChatGPT account and subscription. Use API key mode only if needed.';
|
||
chatgptDescription: 'Use your connected ChatGPT account and Codex subscription.';
|
||
chatgptTitle: 'ChatGPT account';
|
||
hint: 'Codex always runs through the native runtime. Auto prefers your ChatGPT account before falling back to API-key credentials.';
|
||
};
|
||
};
|
||
connectionUi: {
|
||
actions: {
|
||
connect: 'Connect';
|
||
connectAnthropic: 'Connect Anthropic';
|
||
connectChatGpt: 'Connect ChatGPT';
|
||
disconnect: 'Disconnect';
|
||
openLogin: 'Open Login';
|
||
};
|
||
authMethod: {
|
||
apiKey: 'API key';
|
||
apiKeyHelper: 'API key helper';
|
||
claudeSubscription: 'Claude subscription';
|
||
geminiCli: 'Gemini CLI';
|
||
googleAccount: 'Google account';
|
||
oauth: 'OAuth';
|
||
serviceAccount: 'service account';
|
||
};
|
||
authMode: {
|
||
anthropicSubscription: 'Anthropic subscription';
|
||
apiKey: 'API key';
|
||
auto: 'Auto';
|
||
chatgpt: 'ChatGPT account';
|
||
oauth: 'Subscription / OAuth';
|
||
};
|
||
credential: {
|
||
apiKeyAlsoConfigured: 'API key also configured in Manage';
|
||
apiKeyConfigured: 'API key is configured';
|
||
apiKeyConfiguredInManage: 'API key is configured in Manage';
|
||
apiKeyFallbackInManage: 'API key also available in Manage as fallback';
|
||
autoWillUseUntilChatGpt: '{{summary}} - Auto will use this until ChatGPT is connected';
|
||
availableAsFallback: '{{summary}} - available as fallback';
|
||
availableIfSwitch: '{{summary}} - available if you switch to API key mode';
|
||
savedApiKeyAvailable: 'Saved API key available in Manage';
|
||
savedApiKeyAvailableIfSwitch: 'Saved API key available in Manage if you switch to API key mode';
|
||
};
|
||
disconnect: {
|
||
anthropic: 'This removes the local Anthropic subscription session from the Claude CLI runtime.';
|
||
anthropicTitle: 'Disconnect Anthropic subscription?';
|
||
anthropicWithApiKey: 'This removes the local Anthropic subscription session from the Claude CLI runtime. Saved API keys in Manage stay available.';
|
||
gemini: 'This clears the local Gemini CLI session metadata. External ADC credentials and saved API keys are not removed.';
|
||
geminiTitle: 'Disconnect Gemini CLI?';
|
||
};
|
||
mode: {
|
||
preferredAuth: 'Preferred auth: {{authMode}}';
|
||
selectedAuth: 'Selected auth: {{authMode}}';
|
||
};
|
||
runtime: {
|
||
codexNative: 'Codex native';
|
||
currentRuntime: 'Current runtime';
|
||
selectedRuntime: 'Selected runtime';
|
||
summary: '{{prefix}}: {{runtime}}';
|
||
};
|
||
status: {
|
||
apiKeyConfiguredNotVerified: 'API key configured, but not verified yet';
|
||
apiKeyModeMissingCredential: 'API key mode selected, but no API key is configured';
|
||
apiKeyReady: 'API key ready';
|
||
chatGptAccountReady: 'ChatGPT account ready';
|
||
chatGptVerificationDegraded: 'ChatGPT account detected - account verification is currently degraded.';
|
||
checked: 'Checked';
|
||
checking: 'Checking...';
|
||
codexLocalAccountNeedsReconnect: 'Codex has a locally selected ChatGPT account, but the current session needs reconnect.';
|
||
codexNativeReady: 'Codex native ready';
|
||
codexNativeUnavailable: 'Codex native unavailable';
|
||
codexNoActiveChatGptLogin: 'Codex CLI reports no active ChatGPT login';
|
||
codexNoActiveManagedSession: 'Codex CLI reports no active ChatGPT login. Local Codex account data exists, but no active managed session is selected.';
|
||
connectChatGptForSubscription: 'Connect a ChatGPT account to use your Codex subscription.';
|
||
connectedVia: 'Connected via {{method}}';
|
||
connectedViaApiKey: 'Connected via API key';
|
||
notConnected: 'Not connected';
|
||
providerActivity: 'Provider Activity';
|
||
startingChatGptLogin: 'Starting ChatGPT login...';
|
||
unableToVerify: 'Unable to verify';
|
||
unavailableInCurrentRuntime: 'Unavailable in current runtime';
|
||
waitingForChatGptLogin: 'Waiting for ChatGPT account login...';
|
||
};
|
||
};
|
||
description: 'Manage how each provider connects and, when supported, which backend the multimodel runtime should use.';
|
||
errors: {
|
||
apiKeyDeletedRefreshFailed: 'API key deleted, but failed to refresh provider status.';
|
||
apiKeyRequired: 'API key is required';
|
||
apiKeySavedRefreshFailed: 'API key saved, but failed to refresh provider status.';
|
||
connectionUpdatedRefreshFailed: 'Connection updated, but failed to refresh provider status.';
|
||
deleteApiKey: 'Failed to delete API key';
|
||
disableEndpoint: 'Failed to disable endpoint';
|
||
endpointDisabledRefreshFailed: 'Endpoint disabled, but failed to refresh provider status.';
|
||
endpointSavedRefreshFailed: 'Endpoint saved, but failed to refresh provider status.';
|
||
refreshCodexAccount: 'Failed to refresh Codex account';
|
||
saveApiKey: 'Failed to save API key';
|
||
saveEndpoint: 'Failed to save endpoint';
|
||
updateAnthropicFastMode: 'Failed to update Anthropic Fast mode';
|
||
updateConnection: 'Failed to update connection';
|
||
updateRuntimeBackend: 'Failed to update runtime backend';
|
||
};
|
||
fastMode: {
|
||
defaultOff: 'Default Off';
|
||
description: 'Apply Claude Code Fast mode by default for new Anthropic team launches when the resolved model and runtime allow it.';
|
||
disabledHint: 'New Anthropic launches stay on normal speed unless a team explicitly enables Fast mode.';
|
||
enabledHint: 'New Anthropic launches will request Fast mode by default when the resolved model supports it.';
|
||
notExposed: 'This Anthropic runtime does not expose Fast mode.';
|
||
preferFast: 'Prefer Fast';
|
||
title: 'Fast mode default';
|
||
unavailableForRuntime: 'Fast mode is currently unavailable for this Anthropic runtime.';
|
||
};
|
||
progress: {
|
||
applyingConnectionChanges: 'Applying connection changes...';
|
||
refreshingProviderStatus: 'Refreshing provider status...';
|
||
savingCompatibleEndpoint: 'Saving compatible endpoint...';
|
||
switchingAnthropicSubscription: 'Switching to Anthropic subscription...';
|
||
switchingApiKey: 'Switching to API key...';
|
||
switchingApiKeyMode: 'Switching to API key mode...';
|
||
switchingAuto: 'Switching to Auto...';
|
||
switchingChatgpt: 'Switching to ChatGPT account mode...';
|
||
};
|
||
provider: 'Provider';
|
||
runtime: {
|
||
descriptions: {
|
||
anthropic: 'Anthropic currently has no separate runtime backend selector.';
|
||
codex: 'Codex now runs only through the native runtime path.';
|
||
gemini: 'Choose which Gemini runtime backend multimodel should use.';
|
||
opencode: 'OpenCode uses its own managed runtime host. Desktop currently exposes status only.';
|
||
};
|
||
title: 'Runtime';
|
||
updating: 'Updating runtime...';
|
||
};
|
||
runtimeSummary: 'Runtime: {{runtime}}';
|
||
status: {
|
||
configured: 'configured';
|
||
enabled: 'Enabled';
|
||
notConfigured: 'Not configured';
|
||
notSet: 'not set';
|
||
off: 'Off';
|
||
unknown: 'Unknown';
|
||
};
|
||
title: 'Provider Settings';
|
||
usage: {
|
||
apiKey: 'Using API key';
|
||
apiKeyRequired: 'API key required';
|
||
compatibleEndpoint: 'Using compatible endpoint';
|
||
notConnected: 'Not connected';
|
||
usingMethod: 'Using {{method}}';
|
||
};
|
||
};
|
||
runtimeProvider: {
|
||
actions: {
|
||
cancel: 'Cancel';
|
||
test: 'Test';
|
||
};
|
||
badges: {
|
||
configured: 'configured';
|
||
connected: 'connected';
|
||
default: 'default';
|
||
failed: 'failed';
|
||
free: 'free';
|
||
knownRoute: 'known route';
|
||
local: 'local';
|
||
needsTest: 'needs test';
|
||
unknown: 'unknown';
|
||
usedInTeamPicker: 'Saved for team picker';
|
||
verified: 'verified';
|
||
};
|
||
compatibleEndpoint: {
|
||
baseUrlPlaceholder: 'http://localhost:1234';
|
||
};
|
||
defaults: {
|
||
allProjects: 'All projects';
|
||
allProjectsHint: 'Tests use {{project}}. Default applies unless a project has an override.';
|
||
loadingContexts: 'Loading contexts...';
|
||
projectHint: 'Saving overrides only {{project}}.';
|
||
projectOverrideContext: 'Project override context';
|
||
scopeDescriptionAllProjects: 'Default for every project that does not have its own OpenCode override.';
|
||
scopeDescriptionProject: 'Override only the selected project. Running teams are not changed.';
|
||
selectProjectContext: 'Select project context';
|
||
selectProjectHint: 'Select a project before testing local models or saving defaults.';
|
||
selectValidationContext: 'Select validation context';
|
||
setAllProjectsDefault: 'Set all-projects default';
|
||
setProjectDefault: 'Set project default';
|
||
thisProject: 'This project';
|
||
title: 'OpenCode defaults';
|
||
validationContext: 'Validation context';
|
||
};
|
||
diagnostics: {
|
||
copied: 'Diagnostics copied';
|
||
copiedShort: 'Copied';
|
||
copy: 'Copy diagnostics';
|
||
hints: 'Hints';
|
||
likelyCause: 'Likely cause:';
|
||
};
|
||
modelRoutes: {
|
||
searchPlaceholder: 'Search model routes';
|
||
};
|
||
models: {
|
||
actionsUnavailable: 'Actions are temporarily unavailable.';
|
||
alreadyDefault: 'This is already the selected OpenCode default.';
|
||
defaultSaveInProgress: 'OpenCode default is being saved.';
|
||
empty: 'No models found.';
|
||
emptyFree: 'No free models found.';
|
||
emptyRecommended: 'No recommended models found.';
|
||
emptyRecommendedFree: 'No recommended free models found.';
|
||
freeOnly: 'Free only';
|
||
launchableDescription: 'Known routes from OpenCode config, free built-in models, and the current default. Local routes need a successful test before they are ready for team launches.';
|
||
launchableTitle: 'OpenCode model routes';
|
||
loadingRoutes: 'Loading OpenCode model routes...';
|
||
noRoutesMatch: 'No OpenCode model routes match "{{query}}".';
|
||
noneReported: 'No OpenCode model routes were reported yet. Configure a local route in OpenCode or use the Providers tab to inspect catalog providers.';
|
||
recommendedOnly: 'Recommended only';
|
||
routeUnavailableAuth: 'This provider requires authentication before this model can be used.';
|
||
routeUnavailableFailed: 'This model route failed its last execution test.';
|
||
routeUnavailableGeneric: 'This model route cannot be used right now.';
|
||
routeUnavailableUnknown: 'This model is the current OpenCode default, but it is not available in the live catalog yet.';
|
||
searchPlaceholder: 'Search models';
|
||
selectProjectBeforeTesting: 'Select a project context before testing models.';
|
||
selectProjectBeforeTestingDefaults: 'Select a project context before testing or saving OpenCode defaults.';
|
||
testInProgress: 'Model test is already running.';
|
||
useInTeamPicker: 'Save for team picker';
|
||
validationContextRequired: 'Select a validation context above to enable Test and Set default. Saving for team picker only stores the route for new teams.';
|
||
};
|
||
providers: {
|
||
catalog: 'OpenCode provider catalog';
|
||
countFallback: 'OpenCode providers';
|
||
description: '{{count}}. Connected and recommended providers are shown first.';
|
||
description_few: '{{count}}. Connected and recommended providers are shown first.';
|
||
description_many: '{{count}}. Connected and recommended providers are shown first.';
|
||
description_one: '{{count}}. Connected and recommended providers are shown first.';
|
||
description_other: '{{count}}. Connected and recommended providers are shown first.';
|
||
loadMore: 'Load more providers';
|
||
loading: 'Loading OpenCode providers';
|
||
noMatches: 'No providers match that search.';
|
||
noneReported: 'No OpenCode providers reported by the managed runtime.';
|
||
recommended: 'Recommended';
|
||
refreshCatalog: 'Refresh catalog';
|
||
searchPlaceholder: 'Search providers';
|
||
};
|
||
setup: {
|
||
loading: 'Loading provider setup...';
|
||
};
|
||
summary: {
|
||
defaultModel: 'OpenCode default: {{model}}';
|
||
loading: 'Loading managed OpenCode runtime, connected providers, and model defaults...';
|
||
source: 'Source: {{source}}';
|
||
title: 'OpenCode runtime';
|
||
};
|
||
tabs: {
|
||
models: 'Models';
|
||
providers: 'Providers';
|
||
};
|
||
};
|
||
tabs: {
|
||
advanced: {
|
||
description: 'Power-user options: export/import config, reset defaults, and raw configuration editing.';
|
||
label: 'Advanced';
|
||
};
|
||
general: {
|
||
description: 'Core app preferences like theme, language, display density, and startup behavior.';
|
||
label: 'General';
|
||
};
|
||
infoAriaLabel: 'What is {{label}}?';
|
||
notifications: {
|
||
description: 'Control when and how you get notified about agent activity, task completions, and errors.';
|
||
label: 'Notifications';
|
||
};
|
||
};
|
||
view: {
|
||
description: 'Manage your app preferences';
|
||
loading: 'Loading settings...';
|
||
title: 'Settings';
|
||
};
|
||
workspaceProfiles: {
|
||
actions: {
|
||
addProfile: 'Add Profile';
|
||
cancel: 'Cancel';
|
||
deleteProfile: 'Delete profile';
|
||
editProfile: 'Edit profile';
|
||
save: 'Save';
|
||
};
|
||
authMethods: {
|
||
agent: 'SSH Agent';
|
||
auto: 'Auto (from SSH Config)';
|
||
password: 'Password';
|
||
privateKey: 'Private Key';
|
||
};
|
||
deleteConfirm: {
|
||
confirmLabel: 'Delete';
|
||
message: 'Are you sure you want to delete "{{name}}"? This cannot be undone.';
|
||
title: 'Delete Profile';
|
||
};
|
||
description: 'Save SSH connection profiles for quick reconnection';
|
||
empty: {
|
||
description: 'Add an SSH profile to connect quickly';
|
||
title: 'No saved profiles';
|
||
};
|
||
form: {
|
||
authentication: 'Authentication';
|
||
host: 'Host';
|
||
hostPlaceholder: 'hostname or IP';
|
||
name: 'Name';
|
||
namePlaceholder: 'My Server';
|
||
passwordPrompt: 'You will be prompted for the password when connecting.';
|
||
port: 'Port';
|
||
privateKeyPath: 'Private Key Path';
|
||
username: 'Username';
|
||
usernamePlaceholder: 'user';
|
||
};
|
||
loading: 'Loading profiles...';
|
||
title: 'Workspace Profiles';
|
||
};
|
||
};
|
||
team: {
|
||
activity: {
|
||
actions: {
|
||
createTaskFromMessage: 'Create task from message';
|
||
expandMessage: 'Expand message';
|
||
replyToMessage: 'Reply to message';
|
||
restartTeam: 'Restart team';
|
||
};
|
||
activeTasks: {
|
||
inProgress: 'In progress';
|
||
};
|
||
authError: {
|
||
description: 'Authentication failed. Restarting the team will refresh the session and may resolve this issue. If the problem persists, check your API credentials or try again later.';
|
||
};
|
||
automation: {
|
||
reviewPickup: 'Asked teammate to pick up review';
|
||
stallNudge: 'Asked teammate to continue stalled task';
|
||
workSyncBody: 'Asked teammate to sync current work';
|
||
};
|
||
badges: {
|
||
automation: 'automation';
|
||
bootstrap: 'bootstrap';
|
||
command: 'command';
|
||
comment: 'Comment';
|
||
live: 'live';
|
||
note: 'note';
|
||
rateLimited: 'Rate Limited';
|
||
restart: 'restart';
|
||
result: 'result';
|
||
session: 'session';
|
||
stallNudge: 'stall nudge';
|
||
start: 'start';
|
||
workSync: 'work sync';
|
||
};
|
||
bootstrap: {
|
||
acknowledged: 'Bootstrap acknowledged';
|
||
restarting: 'Restarting teammate';
|
||
starting: 'Starting teammate';
|
||
};
|
||
expandDialog: {
|
||
description: 'Expanded message view';
|
||
};
|
||
pendingReplies: {
|
||
awaitingApproval: 'awaiting approval';
|
||
awaitingReply: 'awaiting reply';
|
||
crossTeamAwaitingReply: 'Cross-team message sent, awaiting reply';
|
||
externalTeam: 'external team';
|
||
messageSentAwaitingReply: 'Message sent, awaiting reply';
|
||
openMember: 'Open member';
|
||
title: 'Awaiting replies';
|
||
user: 'user';
|
||
};
|
||
rawJson: 'Raw JSON';
|
||
reply: {
|
||
action: 'Reply';
|
||
replyingTo: 'Replying to';
|
||
};
|
||
thoughts: {
|
||
count: '{{count}} thoughts';
|
||
count_few: '{{count}} thoughts';
|
||
count_many: '{{count}} thoughts';
|
||
count_one: '{{count}} thought';
|
||
count_other: '{{count}} thoughts';
|
||
expand: 'Expand thoughts';
|
||
showLess: 'Show less';
|
||
showMore: 'Show more';
|
||
titleForMember: '{{name}} - thoughts';
|
||
toolSummary: '🔧 {{summary}}';
|
||
};
|
||
timeline: {
|
||
emptyHint: 'Send a message to a member to see activity.';
|
||
loadingMessages: 'Loading messages...';
|
||
newSession: 'New session';
|
||
noMessages: 'No messages';
|
||
olderCount: '+{{count}} older';
|
||
olderCount_few: '+{{count}} older';
|
||
olderCount_many: '+{{count}} older';
|
||
olderCount_one: '+{{count}} older';
|
||
olderCount_other: '+{{count}} older';
|
||
showAll: 'Show all';
|
||
showMore: 'Show {{count}} more';
|
||
};
|
||
unread: 'Unread';
|
||
};
|
||
advancedCli: {
|
||
commandPreview: 'Command preview';
|
||
customArguments: 'Custom arguments';
|
||
placeholders: {
|
||
worktreeName: 'worktree-name';
|
||
};
|
||
recent: 'Recent';
|
||
title: 'Advanced';
|
||
useWorktree: 'Use worktree';
|
||
validate: 'Validate';
|
||
validation: {
|
||
allFlagsValid: 'All flags valid';
|
||
failed: 'Validation failed';
|
||
protectedFlags: 'Protected: {{flags}}';
|
||
unknownFlags: 'Unknown: {{flags}}';
|
||
};
|
||
};
|
||
agentGraph: {
|
||
activityHud: {
|
||
activity: 'Activity';
|
||
more: '+{{count}} more';
|
||
more_few: '+{{count}} more';
|
||
more_many: '+{{count}} more';
|
||
more_one: '+{{count}} more';
|
||
more_other: '+{{count}} more';
|
||
noRecentActivity: 'No recent activity';
|
||
};
|
||
blockingEdge: {
|
||
blockedHiddenTasks: 'Blocked hidden tasks';
|
||
blockingHiddenTasks: 'Blocking hidden tasks';
|
||
blocks: 'blocks';
|
||
close: 'Close';
|
||
title: 'Blocking Dependency';
|
||
};
|
||
logPreview: {
|
||
loading: 'Loading logs';
|
||
logs: 'Logs';
|
||
more: '+{{count}} more';
|
||
more_few: '+{{count}} more';
|
||
more_many: '+{{count}} more';
|
||
more_one: '+{{count}} more';
|
||
more_other: '+{{count}} more';
|
||
};
|
||
popover: {
|
||
externalTeam: 'External team';
|
||
member: {
|
||
actions: {
|
||
message: 'Message';
|
||
profile: 'Profile';
|
||
task: 'Task';
|
||
};
|
||
activeTool: {
|
||
failed: 'Tool failed';
|
||
finished: 'Tool finished';
|
||
running: 'Running tool';
|
||
};
|
||
lead: 'Lead';
|
||
recentTools: 'Recent tools';
|
||
spawn: {
|
||
failed: 'failed';
|
||
starting: 'starting';
|
||
waitingToStart: 'waiting to start';
|
||
};
|
||
state: {
|
||
active: 'active';
|
||
idle: 'idle';
|
||
offline: 'offline';
|
||
runningTool: 'running tool';
|
||
};
|
||
workingOn: 'working on';
|
||
};
|
||
overflow: {
|
||
empty: 'No hidden tasks available.';
|
||
hiddenTasks: 'Hidden tasks';
|
||
};
|
||
process: {
|
||
at: 'At:';
|
||
openUrl: 'Open URL';
|
||
startedBy: 'Started by:';
|
||
};
|
||
};
|
||
provisioning: {
|
||
launchDetails: 'Launch details';
|
||
launchDetailsDescription: 'Detailed team launch progress, live output and CLI logs.';
|
||
};
|
||
};
|
||
claudeLogs: {
|
||
clearSearch: 'Clear search';
|
||
emptyRawLogs: '{{count}}; none are assistant/tool output yet.';
|
||
filter: {
|
||
actions: {
|
||
reset: 'Reset';
|
||
save: 'Save';
|
||
};
|
||
ariaLabel: 'Filter logs';
|
||
kinds: {
|
||
output: 'Output';
|
||
thinking: 'Thinking';
|
||
tool: 'Tool calls';
|
||
};
|
||
sections: {
|
||
content: 'Content';
|
||
stream: 'Stream';
|
||
};
|
||
streams: {
|
||
stderr: 'stderr';
|
||
stdout: 'stdout';
|
||
};
|
||
tooltip: 'Filter logs';
|
||
};
|
||
fullscreen: 'Fullscreen';
|
||
loading: 'Loading...';
|
||
logsTitle: 'Logs';
|
||
newCount: '+{{count}} new';
|
||
noLogsCaptured: 'No logs captured.';
|
||
noLogsYet: 'No logs yet.';
|
||
noMatchingLogs: 'No matching logs.';
|
||
openFullscreen: 'Open fullscreen logs';
|
||
rawLineCount: '{{formattedCount}} raw lines';
|
||
rawLineCount_few: '{{formattedCount}} raw lines';
|
||
rawLineCount_many: '{{formattedCount}} raw lines';
|
||
rawLineCount_one: '{{formattedCount}} raw line';
|
||
rawLineCount_other: '{{formattedCount}} raw lines';
|
||
rawLinesCaptured: '{{count}} captured';
|
||
searchPlaceholder: 'Search logs...';
|
||
showMore: 'Show more';
|
||
sourceSelect: {
|
||
ariaLabel: 'Log source';
|
||
emptyMessage: 'No log sources found.';
|
||
leadLabel: 'Lead';
|
||
placeholder: 'Select log source...';
|
||
searchPlaceholder: 'Search log sources...';
|
||
selectSourceEmpty: 'Select a log source.';
|
||
};
|
||
teamNotRunning: 'Team is not running.';
|
||
viewingFullscreen: 'Viewing in fullscreen mode';
|
||
};
|
||
codexReconnect: {
|
||
description: 'Your Codex session appears stale. Reconnect to continue.';
|
||
useCode: 'Use code';
|
||
};
|
||
contextLimit: {
|
||
always200k: '(always 200K for this model)';
|
||
limitTo200k: 'Limit context to 200K tokens';
|
||
tooltipContent: 'Keeps launches within a 200K-token context window when supported.';
|
||
tooltipTitle: 'Context limit';
|
||
};
|
||
create: {
|
||
actions: {
|
||
create: 'Create';
|
||
creating: 'Creating...';
|
||
openExisting: 'Open Existing Team';
|
||
skipPreflightAndCreate: 'Skip preflight and create';
|
||
};
|
||
conflict: {
|
||
description: 'Running two teams in the same directory is risky - they may conflict editing the same files. Consider using a different directory or a git worktree for isolation.';
|
||
title: 'Another team "{{team}}" is already running for this working directory';
|
||
workingDirectory: 'Working directory:';
|
||
};
|
||
description: {
|
||
copy: 'Create a new team based on an existing one.';
|
||
create: 'Set up your team and choose how it starts.';
|
||
};
|
||
errors: {
|
||
createConfigFailed: 'Failed to create team config';
|
||
loadProjectsFailed: 'Failed to load projects';
|
||
nameExists: 'Team name already exists';
|
||
nameLaunching: 'A team with this name is currently launching';
|
||
};
|
||
fields: {
|
||
color: 'Color (optional)';
|
||
description: 'Description (optional)';
|
||
prompt: 'Prompt for team lead (optional)';
|
||
teamName: 'Team name';
|
||
};
|
||
launchAfterCreate: {
|
||
description: 'Start the team immediately via local Claude CLI.';
|
||
label: 'Run command after create';
|
||
};
|
||
localOnly: 'Available only in local Electron mode.';
|
||
onDisk: 'On disk:';
|
||
optional: {
|
||
launchSettingsDescription: 'Prompt, safety, and CLI overrides live here when you need them.';
|
||
launchSettingsTitle: 'Optional launch settings';
|
||
teamDetailsDescription: 'Keep the default flow compact and only open this when you want extra context or a custom color.';
|
||
teamDetailsTitle: 'Optional team details';
|
||
};
|
||
placeholders: {
|
||
description: 'Brief description of the team purpose';
|
||
prompt: 'Instructions for the team lead during provisioning...';
|
||
};
|
||
prepare: {
|
||
checkingProviders: 'Checking selected providers...';
|
||
failed: 'Failed to prepare selected providers';
|
||
preparingEnvironment: 'Preparing environment...';
|
||
ready: 'All selected providers are ready.';
|
||
readyWithNotes: 'All selected providers are ready, with notes.';
|
||
selectWorkingDirectory: 'Select a working directory to validate the launch environment.';
|
||
selectedProvidersReady: 'Selected providers ready';
|
||
selectedProvidersReadyWithNotes: 'Selected providers ready (with notes)';
|
||
someProvidersNeedAttention: 'Some selected providers need attention.';
|
||
unsupportedPreload: 'Current preload version does not support team:prepareProvisioning. Restart the dev app.';
|
||
};
|
||
saved: 'Saved';
|
||
solo: {
|
||
description: 'Only the team lead (main process) will be started - no teammates will be spawned. Works like a regular agent session in your chosen runtime (Claude Code, Codex, OpenCode, Gemini) but with access to the task board for planning. Saves tokens by avoiding teammate coordination overhead. You can add members later from the team settings.';
|
||
label: 'Solo team';
|
||
};
|
||
title: {
|
||
copy: 'Copy Team';
|
||
create: 'Create Team';
|
||
};
|
||
validation: {
|
||
checkFormFields: 'Check form fields';
|
||
memberNameInvalid: 'Member name must start with alphanumeric, use only [a-zA-Z0-9._-], max 128 chars';
|
||
memberNameRequired: 'Member name cannot be empty';
|
||
memberNamesUnique: 'Member names must be unique';
|
||
nameMustContainLetterOrDigit: 'Name must contain at least one letter or digit';
|
||
nameTooLong: 'Name is too long (max 128 chars)';
|
||
openCodeLeadModelRequired: 'OpenCode lead requires a selected model.';
|
||
openCodeTeammateRequired: 'OpenCode lead requires at least one OpenCode teammate.';
|
||
selectWorkingDirectory: 'Select working directory (cwd)';
|
||
teamLaunching: 'Team is currently launching';
|
||
teamNameExists: 'Team name already exists';
|
||
};
|
||
};
|
||
detail: {
|
||
actions: {
|
||
add: 'Add';
|
||
cancel: 'Cancel';
|
||
delete: 'Delete';
|
||
editCode: 'Edit code';
|
||
launch: 'Launch';
|
||
remove: 'Remove';
|
||
stop: 'Stop';
|
||
task: 'Task';
|
||
visualize: 'Visualize';
|
||
};
|
||
context: {
|
||
title: 'Context';
|
||
};
|
||
deleteTeam: {
|
||
description: 'Delete team "{{team}}"? This action is irreversible. All team data and tasks will be deleted.';
|
||
title: 'Delete team';
|
||
};
|
||
draft: {
|
||
descriptionPrefix: 'This is a draft team -';
|
||
descriptionSuffix: "has been configured with {{count}} {{member}} but hasn't been provisioned by CLI yet. Click Launch to select a model and start the team.";
|
||
descriptionSuffix_few: "has been configured with {{count}} {{member}} but hasn't been provisioned by CLI yet. Click Launch to select a model and start the team.";
|
||
descriptionSuffix_many: "has been configured with {{count}} {{member}} but hasn't been provisioned by CLI yet. Click Launch to select a model and start the team.";
|
||
descriptionSuffix_one: "has been configured with {{count}} {{member}} but hasn't been provisioned by CLI yet. Click Launch to select a model and start the team.";
|
||
descriptionSuffix_other: "has been configured with {{count}} {{member}} but hasn't been provisioned by CLI yet. Click Launch to select a model and start the team.";
|
||
member: 'members';
|
||
member_few: 'members';
|
||
member_many: 'members';
|
||
member_one: 'member';
|
||
member_other: 'members';
|
||
title: 'Team not launched yet';
|
||
};
|
||
invalidTab: 'Invalid team tab';
|
||
kanbanSafeData: 'Failed to fully load kanban. Displaying safe data.';
|
||
loadFailed: 'Failed to load team';
|
||
loading: 'Loading team';
|
||
loadingSidebar: 'Loading team sidebar';
|
||
offline: {
|
||
offline: 'Team is offline';
|
||
partialFailed: 'Last launch failed partway';
|
||
partialMissing: 'Last launch failed partway - {{missing}}/{{expected}} teammates did not join';
|
||
reconciling: 'Last launch is still reconciling';
|
||
};
|
||
previous: 'Previous: {{paths}}';
|
||
removeMember: {
|
||
description: 'Remove "{{member}}" from the team? Tasks and messages will be preserved, but this name cannot be reused.';
|
||
title: 'Remove member';
|
||
};
|
||
sections: {
|
||
team: 'Team';
|
||
};
|
||
solo: 'Solo';
|
||
status: {
|
||
active: 'Active';
|
||
launching: 'Launching...';
|
||
running: 'Running';
|
||
};
|
||
telemetry: {
|
||
cpu: 'CPU';
|
||
memory: 'Memory';
|
||
};
|
||
tooltips: {
|
||
deleteTeam: 'Delete team';
|
||
editTeam: 'Edit team';
|
||
editUnavailableProvisioning: 'Edit team is unavailable while provisioning is still in progress';
|
||
openBuiltInEditor: 'Open project in built-in editor';
|
||
openTeamGraph: 'Open team graph';
|
||
stopTeam: 'Stop team';
|
||
};
|
||
waitingForProvisioning: 'Team data will appear once provisioning completes';
|
||
};
|
||
dialogs: {
|
||
actions: {
|
||
cancel: 'Cancel';
|
||
openDashboard: 'Open Dashboard';
|
||
openTeam: 'Open team';
|
||
};
|
||
membersJson: {
|
||
hide: 'Hide JSON';
|
||
};
|
||
optional: {
|
||
badge: 'Optional';
|
||
};
|
||
};
|
||
editTeam: {
|
||
actions: {
|
||
cancel: 'Cancel';
|
||
save: 'Save';
|
||
};
|
||
addMemberLockReason: 'Use the dedicated Add member dialog to add new teammates while the team is live.';
|
||
description: 'Change team name, description and color';
|
||
errors: {
|
||
changesSavedRefreshFailed: 'Team changes were saved, but failed to refresh the latest view: {{message}}';
|
||
liveRenameBlocked: 'Existing teammates cannot be renamed while the team is live. renamed: {{names}}';
|
||
memberNameEmpty: 'Member name cannot be empty';
|
||
memberNameInvalid: 'Member name must start with alphanumeric, use only [a-zA-Z0-9._-], max 128 chars';
|
||
memberNameNumericSuffix: 'Member name "{{name}}" is not allowed (reserved for Claude CLI auto-suffix). Use "{{base}}" instead.';
|
||
memberNameReserved: 'Member name "{{name}}" is reserved';
|
||
memberNamesUnique: 'Member names must be unique before saving';
|
||
newLiveTeammates: 'Add new teammates from the dedicated Add member dialog while the team is live. Edit Team only supports updating existing teammates.';
|
||
provisioning: 'Team settings cannot be edited while provisioning is still in progress. Wait for launch to finish, then try again.';
|
||
restartFailedMany: 'Team saved, but failed to restart these teammates: {{failures}}';
|
||
restartFailedOne: 'Team saved, but failed to restart this teammate: {{failures}}';
|
||
saveFailed: 'Failed to save';
|
||
settingsChanged: 'Team settings changed while this dialog was open. Reopen it and review the latest state before saving.';
|
||
settingsSavedMembersAndRefreshFailed: 'Team settings were saved, but member changes failed: {{message}}. Refresh also failed: {{refreshError}}';
|
||
settingsSavedMembersFailed: 'Team settings were saved, but member changes failed: {{message}}';
|
||
settingsSavedRefreshFailed: 'Team settings were saved, but failed to refresh the latest view: {{message}}';
|
||
teamNameEmpty: 'Team name cannot be empty';
|
||
unsupportedMixedPrimaryMutation: 'Live edits to primary-owned teammates in mixed OpenCode teams are not supported yet. Stop the team, edit the roster, then relaunch. Affected: {{names}}';
|
||
};
|
||
fields: {
|
||
colorOptional: 'Color (optional)';
|
||
description: 'Description';
|
||
name: 'Name';
|
||
};
|
||
memberRestartWarning: 'Saving will restart this teammate to apply role, workflow, worktree isolation, provider, model, effort, or MCP access changes.';
|
||
notices: {
|
||
liveRenameBlocked: 'Live save is blocked because existing teammates were renamed. Revert those identity changes or stop the team first.';
|
||
newLiveTeammates: 'New teammates cannot be added from Edit Team while the team is live. Use the Add member dialog instead.';
|
||
provisioning: 'Team provisioning is still in progress. Editing is temporarily locked until launch finishes.';
|
||
restartMany: 'Saving will restart or relaunch these teammates to apply role, workflow, worktree isolation, provider, model, effort, or MCP access changes: {{names}}.';
|
||
restartOne: 'Saving will restart or relaunch this teammate to apply role, workflow, worktree isolation, provider, model, effort, or MCP access changes: {{names}}.';
|
||
unsupportedMixedPrimaryMutation: 'Live edits/removals for primary-owned teammates in mixed OpenCode teams require stopping and relaunching the team: {{names}}.';
|
||
};
|
||
placeholders: {
|
||
description: 'Team description (optional)';
|
||
teamName: 'Team name';
|
||
};
|
||
teamLead: {
|
||
changeRuntime: 'Change lead runtime';
|
||
changeRuntimeDescription: 'Open Relaunch Team to change the lead provider, model, or effort.';
|
||
modelLockReason: 'Team lead runtime is managed from Relaunch Team.';
|
||
readOnlyHint: 'Team lead name and role stay read-only here. Open the runtime panel on the lead row to change provider, model, or effort.';
|
||
role: 'Team Lead';
|
||
};
|
||
title: 'Edit Team';
|
||
};
|
||
editor: {
|
||
actions: {
|
||
cancel: 'Cancel';
|
||
closeEditor: 'Close editor';
|
||
closeTab: 'Close tab';
|
||
closeTooltip: 'Close editor (Esc)';
|
||
discard: 'Discard';
|
||
discardAndClose: 'Discard & Close';
|
||
keep: 'Keep';
|
||
keepMine: 'Keep mine';
|
||
keyboardShortcuts: 'Keyboard shortcuts';
|
||
overwrite: 'Overwrite';
|
||
refreshAria: 'Refresh (F5)';
|
||
refreshTooltip: 'Refresh git status (F5)';
|
||
reload: 'Reload';
|
||
retry: 'Retry';
|
||
save: 'Save';
|
||
saveAllAndClose: 'Save All & Close';
|
||
};
|
||
ariaLabel: 'Project Editor';
|
||
binaryPlaceholder: {
|
||
file: 'Binary file ({{size}})';
|
||
};
|
||
dialogs: {
|
||
conflictDescription: 'The file has been modified externally since you opened it. Overwrite with your changes?';
|
||
conflictTitle: 'Save Conflict';
|
||
unsavedDescription: 'You have unsaved changes. What would you like to do?';
|
||
unsavedFileDescription: 'This file has unsaved changes. What would you like to do?';
|
||
unsavedTitle: 'Unsaved Changes';
|
||
};
|
||
draftRecovered: 'Recovered unsaved changes from a previous session.';
|
||
empty: {
|
||
selectFile: 'Select a file from the tree to edit';
|
||
};
|
||
errorBoundary: {
|
||
crashed: 'Editor crashed';
|
||
unknownError: 'Unknown error';
|
||
};
|
||
externalChange: {
|
||
changed: 'File changed on disk.';
|
||
deleted: 'File no longer exists on disk.';
|
||
};
|
||
fileTree: {
|
||
cancel: 'Cancel';
|
||
dropForProjectRoot: 'Drop here for project root';
|
||
empty: 'No files found';
|
||
failedToLoadFiles: 'Failed to load files: {{error}}';
|
||
loading: 'Loading files...';
|
||
moveToTrash: 'Move to Trash';
|
||
moveToTrashConfirm: 'Move "{{name}}" to Trash?';
|
||
};
|
||
goToLine: {
|
||
go: 'Go';
|
||
placeholder: 'Line number, +offset, -offset, or %';
|
||
position: '(current: {{current}}, total: {{total}})';
|
||
title: 'Go to Line';
|
||
};
|
||
imagePreview: {
|
||
loading: 'Loading preview...';
|
||
openFullSize: 'Open full-size preview';
|
||
openSystemViewer: 'Open in System Viewer';
|
||
};
|
||
newFile: {
|
||
aria: {
|
||
newFileName: 'New file name';
|
||
newFolderName: 'New folder name';
|
||
};
|
||
placeholders: {
|
||
fileName: 'File name...';
|
||
folderName: 'Folder name...';
|
||
};
|
||
validation: {
|
||
invalidCharacters: 'Name contains invalid characters';
|
||
invalidName: 'Invalid name';
|
||
nameRequired: 'Name cannot be empty';
|
||
nameTooLong: 'Name is too long';
|
||
};
|
||
};
|
||
quickOpen: {
|
||
empty: 'No files found';
|
||
loading: 'Loading files...';
|
||
searchPlaceholder: 'Search files by name...';
|
||
title: 'Quick Open';
|
||
};
|
||
saveFailed: 'Save failed: {{error}}';
|
||
search: {
|
||
placeholder: 'Search';
|
||
toggleReplace: 'Toggle Replace';
|
||
};
|
||
searchInFiles: {
|
||
closeSearch: 'Close search';
|
||
closeSearchShortcut: 'Close search (Esc)';
|
||
matchCase: 'Match Case';
|
||
matchCaseToggle: 'Aa';
|
||
noResults: 'No results found';
|
||
resultsSummary: '{{count}} matches in {{fileCount}} files';
|
||
resultsSummary_few: '{{count}} matches in {{fileCount}} files';
|
||
resultsSummary_many: '{{count}} matches in {{fileCount}} files';
|
||
resultsSummary_one: '{{count}} match in {{fileCount}} files';
|
||
resultsSummary_other: '{{count}} matches in {{fileCount}} files';
|
||
searchPlaceholder: 'Search...';
|
||
title: 'Search in Files';
|
||
truncated: '(truncated)';
|
||
};
|
||
searchPanel: {
|
||
all: 'All';
|
||
close: 'Close';
|
||
nextMatch: 'Next Match';
|
||
previousMatch: 'Previous Match';
|
||
replace: 'Replace';
|
||
replaceAll: 'Replace All';
|
||
replaceNext: 'Replace Next';
|
||
replacePlaceholder: 'Replace';
|
||
};
|
||
shortcuts: {
|
||
actions: {
|
||
closeEditor: 'Close Editor';
|
||
closeTab: 'Close Tab';
|
||
cycleTabs: 'Cycle Tabs';
|
||
findInFile: 'Find in File';
|
||
fullPreview: 'Full Preview';
|
||
goToLine: 'Go to Line';
|
||
nextTab: 'Next Tab';
|
||
previousTab: 'Previous Tab';
|
||
quickOpen: 'Quick Open';
|
||
redo: 'Redo';
|
||
save: 'Save';
|
||
saveAll: 'Save All';
|
||
searchInFiles: 'Search in Files';
|
||
selectNextMatch: 'Select Next Match';
|
||
splitPreview: 'Split Preview';
|
||
toggleComment: 'Toggle Comment';
|
||
toggleSidebar: 'Toggle Sidebar';
|
||
undo: 'Undo';
|
||
};
|
||
groups: {
|
||
editing: 'Editing';
|
||
fileOperations: 'File Operations';
|
||
general: 'General';
|
||
markdown: 'Markdown';
|
||
navigation: 'Navigation';
|
||
search: 'Search';
|
||
};
|
||
title: 'Keyboard Shortcuts';
|
||
};
|
||
sidebar: {
|
||
explorer: 'Explorer';
|
||
hide: 'Hide sidebar';
|
||
hideWithShortcut: 'Hide sidebar ({{shortcut}})';
|
||
show: 'Show sidebar';
|
||
showWithShortcut: 'Show sidebar ({{shortcut}})';
|
||
};
|
||
statusBar: {
|
||
disableExternalWatcher: 'Disable external change watcher';
|
||
disableWatcher: 'Disable file watcher';
|
||
enableWatcher: 'Enable file watcher';
|
||
encodingUtf8: 'UTF-8';
|
||
position: 'Ln {{line}}, Col {{col}}';
|
||
spaces: 'Spaces: {{count}}';
|
||
watch: 'watch';
|
||
watchExternalChanges: 'Watch for external changes';
|
||
watching: 'watching';
|
||
};
|
||
toolbar: {
|
||
closePreview: 'Close preview';
|
||
closeSplitPreview: 'Close split preview';
|
||
disableWordWrap: 'Disable word wrap';
|
||
enableWordWrap: 'Enable word wrap';
|
||
};
|
||
unsavedChanges: 'Unsaved changes';
|
||
};
|
||
effortLevel: {
|
||
label: 'Effort level (optional)';
|
||
maxDescription: 'Max gives the model the most reasoning time for difficult tasks.';
|
||
};
|
||
kanban: {
|
||
board: {
|
||
addTask: 'Add task';
|
||
columnsView: 'Columns view';
|
||
gridView: 'Grid view';
|
||
hiddenCount: '{{count}} hidden';
|
||
noTasks: 'No tasks';
|
||
showMore: 'Show {{count}} more';
|
||
trash: 'Trash';
|
||
};
|
||
columns: {
|
||
approved: 'APPROVED';
|
||
done: 'DONE';
|
||
inProgress: 'IN PROGRESS';
|
||
review: 'REVIEW';
|
||
todo: 'TODO';
|
||
};
|
||
filter: {
|
||
allSessions: 'All sessions';
|
||
clearAll: 'Clear all';
|
||
column: 'Column';
|
||
session: 'Session';
|
||
teammate: 'Teammate';
|
||
title: 'Filter tasks';
|
||
unassigned: '(unassigned)';
|
||
};
|
||
grid: {
|
||
addTask: 'Add task';
|
||
noTasks: 'No tasks';
|
||
};
|
||
search: {
|
||
clearSearch: 'Clear search';
|
||
createdAgo: 'created {{time}}';
|
||
placeholder: 'Search tasks... (#id or text)';
|
||
tasks: 'Tasks';
|
||
updatedAgo: 'updated {{time}}';
|
||
};
|
||
sort: {
|
||
options: {
|
||
createdAt: {
|
||
description: 'Newest first';
|
||
label: 'Created';
|
||
};
|
||
manual: {
|
||
description: 'Drag-and-drop order';
|
||
label: 'Manual';
|
||
};
|
||
owner: {
|
||
description: 'Alphabetically by assignee';
|
||
label: 'Owner';
|
||
};
|
||
updatedAt: {
|
||
description: 'Recently updated first';
|
||
label: 'Last updated';
|
||
};
|
||
};
|
||
reset: 'Reset';
|
||
sortBy: 'Sort by';
|
||
title: 'Sort tasks';
|
||
};
|
||
taskCard: {
|
||
approve: 'Approve';
|
||
awaitingLead: 'Awaiting lead';
|
||
awaitingUser: 'Awaiting user';
|
||
blockedBy: 'Blocked by';
|
||
blocks: 'Blocks';
|
||
cancel: 'Cancel';
|
||
cancelTask: 'Cancel task {{taskId}}';
|
||
changes: 'Changes';
|
||
changesNeedAttention: 'Changes need attention';
|
||
complete: 'Complete';
|
||
confirm: 'Confirm';
|
||
deleteTask: 'Delete task';
|
||
keep: 'Keep';
|
||
manualReview: 'Manual review';
|
||
moveBackToTodoConfirm: 'Move this task back to TODO and notify the team?';
|
||
newTaskLogsArriving: 'New task logs arriving';
|
||
requestChanges: 'Request changes';
|
||
requestReview: 'Request review';
|
||
start: 'Start';
|
||
taskLogsActive: 'Task logs active';
|
||
};
|
||
title: 'Kanban';
|
||
trash: {
|
||
close: 'Close';
|
||
deleted: 'Deleted';
|
||
empty: 'No deleted tasks';
|
||
owner: 'Owner';
|
||
restore: 'Restore';
|
||
restoreTask: 'Restore task';
|
||
subject: 'Subject';
|
||
title: 'Trash';
|
||
unassigned: 'Unassigned';
|
||
};
|
||
};
|
||
launch: {
|
||
actions: {
|
||
createSchedule: 'Create Schedule';
|
||
creating: 'Creating...';
|
||
goToDashboard: 'Go to Dashboard';
|
||
launchTeam: 'Launch team';
|
||
launching: 'Launching...';
|
||
relaunchTeam: 'Relaunch team';
|
||
relaunching: 'Relaunching...';
|
||
saveChanges: 'Save Changes';
|
||
saving: 'Saving...';
|
||
};
|
||
billing: {
|
||
prefix: 'Starting June 15, 2026, Anthropic bills';
|
||
readArticle: 'Read Anthropic article';
|
||
suffix: 'and Agent SDK usage from the monthly Agent SDK credit, separate from interactive Claude Code limits. The credit resets each billing cycle and unused credit does not roll over.';
|
||
};
|
||
conflict: {
|
||
description: 'Running two teams in the same directory is risky - they may conflict editing the same files. Consider using a different directory or a git worktree for isolation.';
|
||
title: 'Another team "{{team}}" is already running for this working directory';
|
||
workingDirectory: 'Working directory:';
|
||
};
|
||
description: {
|
||
createSchedule: 'Schedule automatic Claude task execution';
|
||
createScheduleForTeam: 'Schedule automatic runs for team "{{team}}"';
|
||
editSchedule: 'Editing schedule for team "{{team}}"';
|
||
launchPrefix: 'Start team';
|
||
launchSuffix: 'via local Claude CLI.';
|
||
relaunchPrefix: 'Stop the current run for';
|
||
relaunchSuffix: 'and start it again via local Claude CLI.';
|
||
};
|
||
errors: {
|
||
launchFailed: 'Failed to launch team';
|
||
loadProjectsFailed: 'Failed to load projects';
|
||
relaunchFailed: 'Failed to relaunch team';
|
||
saveScheduleFailed: 'Failed to save schedule';
|
||
};
|
||
optionalSettings: {
|
||
description: 'Keep the launch flow focused on the project path and only expand this when you want extra control.';
|
||
relaunchDescription: 'Review the roster and lead runtime before restarting the team.';
|
||
relaunchTitle: 'Relaunch settings';
|
||
title: 'Optional launch settings';
|
||
};
|
||
prepare: {
|
||
action: {
|
||
launch: 'launch';
|
||
relaunch: 'relaunch';
|
||
};
|
||
blocked: 'Runtime environment is not available - {{action}} is blocked';
|
||
checkingProviders: 'Checking selected providers...';
|
||
failed: 'Failed to prepare selected providers';
|
||
preflight: 'Pre-flight check to catch errors before {{action}}';
|
||
preparingEnvironment: 'Preparing environment...';
|
||
ready: 'All selected providers are ready.';
|
||
readyWithNotes: 'All selected providers are ready, with notes.';
|
||
selectWorkingDirectory: 'Select a working directory to validate the launch environment.';
|
||
someProvidersNeedAttention: 'Some selected providers need attention.';
|
||
unsupportedPreload: 'Current preload version does not support team:prepareProvisioning. Restart the dev app.';
|
||
};
|
||
prompt: {
|
||
label: 'Prompt';
|
||
oneShotPrefix: 'This prompt will be passed to';
|
||
oneShotSuffix: 'for one-shot execution';
|
||
saved: 'Saved';
|
||
schedulePlaceholder: 'Instructions for Claude to execute on schedule...';
|
||
teamLeadOptional: 'Prompt for team lead (optional)';
|
||
teamLeadPlaceholder: 'Instructions for team lead...';
|
||
};
|
||
providerChanged: 'Provider changed from {{from}} to {{to}}. The previous lead session will not be resumed, and the lead will start with fresh context so the new runtime is applied correctly.';
|
||
relaunchFreshSession: 'Team relaunch starts a fresh lead session. Durable team state, task board, and member configuration are rehydrated into the launch prompt.';
|
||
relaunchWarning: {
|
||
description: 'Saving these settings will stop the current team process, persist the updated roster, and launch the team again with the new runtime.';
|
||
title: 'Relaunch will restart the current team run';
|
||
};
|
||
schedule: {
|
||
labelOptional: 'Label (optional)';
|
||
labelPlaceholder: 'e.g., Daily code review, Nightly tests...';
|
||
maxBudgetUsd: 'Max budget (USD)';
|
||
maxTurns: 'Max turns';
|
||
noLimit: 'No limit';
|
||
noMatches: 'No teams match your search.';
|
||
noTeams: 'No teams available. Create a team first.';
|
||
searchTeams: 'Search teams...';
|
||
selectTeam: 'Select a team...';
|
||
team: 'Team';
|
||
title: 'Schedule';
|
||
};
|
||
title: {
|
||
createSchedule: 'Create Schedule';
|
||
editSchedule: 'Edit Schedule';
|
||
launch: 'Launch Team';
|
||
relaunch: 'Relaunch Team';
|
||
};
|
||
validation: {
|
||
fixMemberNames: 'Fix member names before launch';
|
||
memberNamesUnique: 'Member names must be unique before launch';
|
||
openCodeLeadModelRequired: 'OpenCode lead requires a selected model.';
|
||
openCodeTeammateRequired: 'OpenCode lead requires at least one OpenCode teammate.';
|
||
selectWorkingDirectory: 'Select working directory (cwd)';
|
||
};
|
||
};
|
||
layout: {
|
||
maxPanesReached: 'Maximum of {{count}} panes reached';
|
||
};
|
||
list: {
|
||
actions: {
|
||
copyTeam: 'Copy team';
|
||
createTeam: 'Create Team';
|
||
deleteForever: 'Delete forever';
|
||
deletePermanently: 'Delete permanently';
|
||
deleteTeam: 'Delete team';
|
||
launchTeam: 'Launch team';
|
||
launching: 'Launching...';
|
||
relaunchTeam: 'Relaunch team';
|
||
restore: 'Restore';
|
||
restoreTeam: 'Restore team';
|
||
retry: 'Retry';
|
||
stopTeam: 'Stop team';
|
||
stopping: 'Stopping...';
|
||
};
|
||
deleteDraft: {
|
||
cancelLabel: 'Cancel';
|
||
confirmLabel: 'Delete';
|
||
message: 'Delete draft team "{{teamName}}"? This cannot be undone.';
|
||
title: 'Delete draft';
|
||
};
|
||
deleteForever: {
|
||
cancelLabel: 'Cancel';
|
||
confirmLabel: 'Delete forever';
|
||
message: 'Delete team "{{teamName}}" permanently? All data will be lost.';
|
||
title: 'Delete permanently';
|
||
};
|
||
electronOnly: {
|
||
description: 'In browser mode, access to local `~/.claude/teams` directories is not available.';
|
||
title: 'Teams is only available in Electron mode';
|
||
};
|
||
empty: {
|
||
description: 'Create a team here to get started. It will show up in the list automatically.';
|
||
localOnly: 'Team creation is only available in local Electron mode.';
|
||
title: 'No teams found';
|
||
};
|
||
filter: {
|
||
clearAll: 'Clear all';
|
||
label: 'Filter teams';
|
||
projectPriority: 'Project priority';
|
||
status: 'Status';
|
||
};
|
||
loadFailed: 'Failed to load teams';
|
||
loading: 'Loading teams...';
|
||
localOnly: 'Only available in local Electron mode.';
|
||
membersCount: 'Members: {{count}}';
|
||
membersCount_few: 'Members: {{count}}';
|
||
membersCount_many: 'Members: {{count}}';
|
||
membersCount_one: 'Member: {{count}}';
|
||
membersCount_other: 'Members: {{count}}';
|
||
moveToTrash: {
|
||
cancelLabel: 'Cancel';
|
||
confirmLabel: 'Move to trash';
|
||
message: 'Move team "{{teamName}}" to trash? You can restore it later.';
|
||
title: 'Move to trash';
|
||
};
|
||
noDescription: 'No description';
|
||
noMatches: 'No teams matching current filters';
|
||
partial: {
|
||
pending: 'Last launch is still reconciling.';
|
||
skipped: 'Last launch has skipped teammates.';
|
||
skippedWithCount: 'Last launch skipped {{count}}/{{expected}} teammate.';
|
||
skippedWithCount_few: 'Last launch skipped {{count}}/{{expected}} teammates.';
|
||
skippedWithCount_many: 'Last launch skipped {{count}}/{{expected}} teammates.';
|
||
skippedWithCount_one: 'Last launch skipped {{count}}/{{expected}} teammate.';
|
||
skippedWithCount_other: 'Last launch skipped {{count}}/{{expected}} teammates.';
|
||
stopped: 'Last launch stopped before all teammates joined.';
|
||
stoppedWithCount: 'Last launch stopped before {{count}}/{{expected}} teammate joined.';
|
||
stoppedWithCount_few: 'Last launch stopped before {{count}}/{{expected}} teammates joined.';
|
||
stoppedWithCount_many: 'Last launch stopped before {{count}}/{{expected}} teammates joined.';
|
||
stoppedWithCount_one: 'Last launch stopped before {{count}}/{{expected}} teammate joined.';
|
||
stoppedWithCount_other: 'Last launch stopped before {{count}}/{{expected}} teammates joined.';
|
||
};
|
||
searchPlaceholder: 'Search teams...';
|
||
sections: {
|
||
otherTeams: 'Other teams';
|
||
projectTeams: 'Teams for {{project}}';
|
||
selectedProject: 'selected project';
|
||
};
|
||
solo: 'Solo';
|
||
status: {
|
||
active: 'Active';
|
||
deleted: 'Deleted';
|
||
launching: 'Launching...';
|
||
offline: 'Offline';
|
||
partialFailure: 'Launch failed partway';
|
||
partialPending: 'Bootstrap pending';
|
||
partialSkipped: 'Launch skipped member';
|
||
running: 'Running';
|
||
};
|
||
title: 'Select Team';
|
||
trash: 'Trash ({{count}})';
|
||
trash_few: 'Trash ({{count}})';
|
||
trash_many: 'Trash ({{count}})';
|
||
trash_one: 'Trash ({{count}})';
|
||
trash_other: 'Trash ({{count}})';
|
||
};
|
||
liveRuntimeStatus: {
|
||
description: 'Display-only heartbeat and launch state. Process controls remain below.';
|
||
diagnosticOnly: 'Diagnostic only';
|
||
lane: '{{lane}} lane';
|
||
source: 'source: {{source}}';
|
||
states: {
|
||
degraded: 'Needs attention';
|
||
running: 'Running';
|
||
starting: 'Starting';
|
||
stopped: 'Stopped';
|
||
unknown: 'Unknown';
|
||
waiting: 'Waiting';
|
||
};
|
||
title: 'Live runtime status';
|
||
updated: 'updated {{value}}';
|
||
};
|
||
memberDraft: {
|
||
actions: {
|
||
remove: 'Remove member';
|
||
removeAria: 'Remove {{name}}';
|
||
restore: 'Restore member';
|
||
restoreAria: 'Restore {{name}}';
|
||
};
|
||
addMembers: {
|
||
description: 'Add new members to {{teamName}}';
|
||
title: 'Add Members';
|
||
};
|
||
anthropicContext: {
|
||
defaultSetting: 'default context setting';
|
||
description: "Anthropic context is team-wide for this launch: {{mode}}. Use the lead runtime panel's Limit context checkbox to change it.";
|
||
limitEnabled: '200K limit enabled';
|
||
};
|
||
mcp: {
|
||
agentTeamsMcp: 'Agent Teams MCP';
|
||
buttonInherit: 'MCP inherit';
|
||
buttonScopes: 'MCP scopes';
|
||
chooseScopes: 'Choose scopes';
|
||
inheritLead: 'Inherit lead';
|
||
lockedInfo: 'Agent Teams MCP only is enabled for all teammates. This teammate will launch with only the Agent Teams server.';
|
||
mode: 'MCP mode';
|
||
scopes: {
|
||
local: 'local';
|
||
project: 'project';
|
||
user: 'user';
|
||
};
|
||
serverNames: 'Server names';
|
||
settingInfo: 'Agent Teams MCP launches this teammate with only the Agent Teams server. Scope and allowlist modes apply only to this teammate launch.';
|
||
strictAllowlist: 'Strict allowlist';
|
||
tooltip: "{{label}}: Control this member's MCP inheritance policy";
|
||
};
|
||
model: {
|
||
ariaLabel: '{{provider}} provider, {{model}}';
|
||
currentLeadRuntime: 'Current lead runtime';
|
||
default: 'Default';
|
||
inheritedTooltip: 'Provider, model, and effort are inherited from the lead while sync is enabled.';
|
||
leadSuffix: '{{label}} (lead)';
|
||
liveDisabled: 'Provider, model, and effort changes are disabled while the team is live. Reconnect the team to apply them safely.';
|
||
lockedActionFallback: 'Lead runtime changes open Relaunch Team, where provider, model, and effort can be updated.';
|
||
restartWholeTeam: 'Saving those runtime changes restarts the whole team.';
|
||
};
|
||
nameAria: 'Member {{index}} name';
|
||
nameFallback: 'member {{index}}';
|
||
noRole: 'No role';
|
||
placeholders: {
|
||
mcpServers: 'github, sentry';
|
||
name: 'member-name';
|
||
};
|
||
removed: 'Removed';
|
||
workflow: {
|
||
addTooltip: 'Add teammate workflow';
|
||
editTooltip: 'Edit teammate workflow';
|
||
label: 'Workflow (optional)';
|
||
placeholder: 'How this agent should behave, interact with others...';
|
||
saved: 'Saved';
|
||
};
|
||
worktree: {
|
||
description: 'Run this teammate in a separate git worktree. Apply/reject changes targets that worktree, not the lead workspace.';
|
||
label: 'Worktree';
|
||
};
|
||
};
|
||
memberLogStream: {
|
||
filters: {
|
||
all: 'All';
|
||
};
|
||
logs: {
|
||
emptyDescription: 'Member-scoped transcript or runtime logs will appear here when available.';
|
||
emptyTitle: 'No log stream entries were found for this member yet.';
|
||
loading: 'Loading member log stream...';
|
||
title: 'Logs';
|
||
};
|
||
tabs: {
|
||
execution: 'Execution';
|
||
process: 'Process';
|
||
};
|
||
};
|
||
memberWorkSync: {
|
||
details: {
|
||
actionableItems: 'Actionable items';
|
||
diagnostics: 'Diagnostics: {{diagnostics}}';
|
||
fingerprint: 'Fingerprint';
|
||
moreActionableItems: '{{count}} more actionable item(s)';
|
||
no: 'no';
|
||
none: 'none';
|
||
report: 'Report';
|
||
shadowWouldNudge: 'Shadow would nudge';
|
||
title: 'Member work sync';
|
||
yes: 'yes';
|
||
};
|
||
diagnosticsUnavailable: 'Member work sync diagnostics are unavailable.';
|
||
loadingDiagnostics: 'Loading member work sync diagnostics.';
|
||
title: 'Member work sync';
|
||
};
|
||
members: {
|
||
actions: {
|
||
assignTask: 'Assign task';
|
||
editRole: 'Edit role';
|
||
openProfile: 'Open profile';
|
||
sendMessage: 'Send message';
|
||
};
|
||
badges: {
|
||
worktree: 'worktree';
|
||
};
|
||
detail: {
|
||
assignTask: 'Assign Task';
|
||
copyDiagnostics: 'Copy diagnostics';
|
||
failedToRestartMember: 'Failed to restart member';
|
||
legacyLogsFallback: 'Legacy Logs Fallback';
|
||
pid: 'PID {{pid}}';
|
||
relaunchOpenCode: 'Relaunch OpenCode';
|
||
remove: 'Remove';
|
||
removedAt: 'Removed {{date}}';
|
||
restart: 'Restart';
|
||
sendMessage: 'Send Message';
|
||
};
|
||
editor: {
|
||
addMember: 'Add member';
|
||
agentTeamsMcpOnly: 'Agent Teams MCP only';
|
||
editAsJson: 'Edit as JSON';
|
||
memberNamesUnique: 'Member names must be unique';
|
||
removedCount: 'Removed ({{count}})';
|
||
removedModelLockReason: 'Removed members are kept for soft delete history. Restore them to edit settings.';
|
||
runInSeparateWorktrees: 'Run teammates in separate worktrees';
|
||
title: 'Members';
|
||
};
|
||
executionLog: {
|
||
agentInstructions: 'Agent instructions';
|
||
agentTurn: 'Agent turn';
|
||
empty: 'Nothing to display';
|
||
emptyUserMessage: '{{time}} - (empty)';
|
||
memberTurn: '{{member}} turn';
|
||
turn: 'turn';
|
||
};
|
||
leadModel: {
|
||
anthropicContextLimit: 'The 200K context limit is team-wide for Anthropic runtimes in this launch, including custom Anthropic teammates.';
|
||
anthropicTeamWide: 'Anthropic team-wide';
|
||
defaultModel: 'Default';
|
||
leadShort: 'lead';
|
||
providerModelAria: '{{provider}} provider, {{model}}';
|
||
runtimeInheritance: 'Lead runtime applies to teammates unless they set their own provider or model.';
|
||
syncWithTeammates: 'Sync model with teammates';
|
||
teamLead: 'Team Lead';
|
||
};
|
||
list: {
|
||
loading: 'Loading team members';
|
||
removedCount: 'Removed ({{count}})';
|
||
soloLeadOnly: 'Solo team - lead only';
|
||
unavailable: 'Member roster unavailable';
|
||
unavailableDescription: '{{count}} teammates are known from team metadata, but roster details are missing.';
|
||
unavailableDescription_few: '{{count}} teammates are known from team metadata, but roster details are missing.';
|
||
unavailableDescription_many: '{{count}} teammates are known from team metadata, but roster details are missing.';
|
||
unavailableDescription_one: '{{count}} teammate is known from team metadata, but roster details are missing.';
|
||
unavailableDescription_other: '{{count}} teammates are known from team metadata, but roster details are missing.';
|
||
};
|
||
logs: {
|
||
active: 'active';
|
||
empty: 'No logs found';
|
||
failedToLoadDetails: 'Failed to load details';
|
||
hideDetails: 'Hide details';
|
||
leadSessionTooltip: 'Full team lead session logs - useful for global orchestration context, not specific to this agent';
|
||
loadingDetails: 'Loading details...';
|
||
memberSessionTooltip: 'Full persistent teammate session logs - useful when work runs in a root member session instead of a subagent file';
|
||
noMemberActivity: 'This member has no recorded session activity yet';
|
||
noTaskActivity: 'No session activity for this task yet';
|
||
searching: 'Searching logs...';
|
||
showDetails: 'Show details';
|
||
startedAt: 'started {{time}}';
|
||
waitingForTaskActivity: 'Task is in progress - waiting for session activity (auto-refreshing)...';
|
||
};
|
||
messages: {
|
||
empty: {
|
||
loading: 'Loading activity...';
|
||
noActivity: 'No activity with this member';
|
||
noComments: 'No comments for this member';
|
||
noLoadedActivity: 'No loaded activity for this member yet';
|
||
noLoadedMessages: 'No loaded messages for this member yet';
|
||
noMessages: 'No messages with this member';
|
||
};
|
||
filters: {
|
||
all: 'All';
|
||
comments: 'Comments';
|
||
messages: 'Messages';
|
||
};
|
||
loadOlder: 'Load older messages';
|
||
};
|
||
recentMessages: {
|
||
collapse: 'Collapse';
|
||
expand: 'Expand';
|
||
latest: 'Latest messages';
|
||
latestForMember: 'Latest messages - {{member}}';
|
||
loadMore: 'Load more';
|
||
};
|
||
roleSelect: {
|
||
customRolePlaceholder: 'Enter custom role...';
|
||
};
|
||
runtimeLogs: {
|
||
autoRefresh: 'Auto-refresh';
|
||
empty: 'No process log file captured for this member yet.';
|
||
loadingTail: 'Loading process log tail...';
|
||
wrapLines: 'Wrap lines';
|
||
};
|
||
runtimeTelemetry: {
|
||
cpu: 'CPU';
|
||
description: 'Parent and child processes only. Remote LLM inference is not included.';
|
||
memory: 'Memory';
|
||
processTreeCapped: 'Process tree was capped for this sample.';
|
||
rssHint: 'RSS can include shared pages, so it is best read as a load signal, not exclusive memory.';
|
||
sharedHost: 'Shared OpenCode host metric. It is not exclusive to this member.';
|
||
summedRss: 'summed RSS';
|
||
title: 'Local runtime load';
|
||
};
|
||
stats: {
|
||
computing: 'Computing stats...';
|
||
empty: 'No stats available';
|
||
files: 'Files';
|
||
filesTouched: 'Files Touched ({{count}})';
|
||
footer: '{{count}} sessions · computed {{computedAgo}}';
|
||
footer_few: '{{count}} sessions · computed {{computedAgo}}';
|
||
footer_many: '{{count}} sessions · computed {{computedAgo}}';
|
||
footer_one: '{{count}} session · computed {{computedAgo}}';
|
||
footer_other: '{{count}} sessions · computed {{computedAgo}}';
|
||
lines: 'Lines';
|
||
linesInfo: 'Approximate. Accurate for Edit and Write tools. Bash file writes are estimated from command patterns (heredoc, echo, sed) and may be underreported.';
|
||
moreFiles: '+{{count}} more';
|
||
showLess: 'Show less';
|
||
tokens: 'Tokens';
|
||
toolCalls: 'Tool Calls';
|
||
toolUsage: 'Tool Usage';
|
||
viewAllChanges: 'View All Changes';
|
||
};
|
||
tasks: {
|
||
empty: 'No tasks assigned to this member';
|
||
};
|
||
};
|
||
messageComposer: {
|
||
actions: {
|
||
send: 'Send';
|
||
sendingUnavailableLaunching: 'Sending unavailable while team is launching';
|
||
voiceToText: 'Voice to text';
|
||
};
|
||
attachments: {
|
||
attachFiles: 'Attach files (paste or drag & drop)';
|
||
disabledHint: 'File attachments are supported for the online team lead and online OpenCode teammates. Remove attachments or switch recipient.';
|
||
restrictions: {
|
||
crossTeam: 'File attachments are not supported for cross-team messages';
|
||
leadOnly: 'Files can only be sent to the team lead';
|
||
maximumReached: 'Maximum attachments reached';
|
||
openCodeOffline: 'Team must be online to attach files for OpenCode teammates';
|
||
sending: 'Wait for current message to finish sending before adding files';
|
||
teamOffline: 'Team must be online to attach files';
|
||
unsupportedRecipient: 'Files can be sent to the team lead or OpenCode teammates';
|
||
};
|
||
unavailable: 'Attachments are unavailable';
|
||
};
|
||
crossTeam: {
|
||
hint: 'Tip: Cross-team messages go to the target team lead. If you want the reply to come back to your team lead instead of you, say that explicitly in the message.';
|
||
};
|
||
input: {
|
||
charsLeft: '{{count}} chars left';
|
||
charsLeft_few: '{{count}} chars left';
|
||
charsLeft_many: '{{count}} chars left';
|
||
charsLeft_one: '{{count}} char left';
|
||
charsLeft_other: '{{count}} chars left';
|
||
crossTeamPlaceholder: 'Cross-team message to {{team}}...';
|
||
placeholder: 'Write a message... (Enter to send, Shift+Enter for new line)';
|
||
slashTip: 'Tip: You can use "/" to run any Claude commands.';
|
||
teamFallback: 'team';
|
||
teamLaunchingPlaceholder: 'Team is launching... message will be queued for inbox delivery.';
|
||
};
|
||
recipient: {
|
||
noResults: 'No results';
|
||
searchPlaceholder: 'Search...';
|
||
select: 'Select...';
|
||
};
|
||
slash: {
|
||
restrictions: {
|
||
attachments: 'Slash commands require a live team lead and cannot be sent with attachments';
|
||
crossTeam: 'Slash commands can only be run on the current team lead';
|
||
leadOffline: 'Slash commands require the team lead to be online';
|
||
notLead: 'Slash commands can only be sent to the team lead';
|
||
};
|
||
};
|
||
status: {
|
||
reusedCrossTeamRequest: 'Reused recent cross-team request';
|
||
teamOffline: 'Team offline';
|
||
};
|
||
teamSelector: {
|
||
current: 'current';
|
||
offline: 'offline';
|
||
offlineTitle: 'Offline';
|
||
online: 'online';
|
||
onlineTitle: 'Online';
|
||
thisTeam: 'This team';
|
||
};
|
||
};
|
||
messages: {
|
||
actionMode: {
|
||
label: 'Action mode';
|
||
};
|
||
actions: {
|
||
bottomSheetActions: 'Message bottom sheet actions';
|
||
collapseAll: 'Collapse all messages';
|
||
collapseSheet: 'Collapse sheet';
|
||
expandAll: 'Expand all messages';
|
||
expandSheet: 'Expand sheet';
|
||
floatComposer: 'Float composer';
|
||
floatMessagesComposer: 'Float messages composer';
|
||
hideSearch: 'Hide search';
|
||
loadOlder: 'Load older messages';
|
||
markAllRead: 'Mark all as read';
|
||
messageActions: 'Message actions';
|
||
moveMessagesToBottomSheet: 'Move messages to bottom sheet';
|
||
moveMessagesToSidebar: 'Move messages to sidebar';
|
||
moveToBottomSheet: 'Move to bottom sheet';
|
||
moveToInline: 'Move to inline';
|
||
moveToSidebar: 'Move to sidebar';
|
||
panelActions: 'Message panel actions';
|
||
searchMessages: 'Search messages';
|
||
};
|
||
delivery: {
|
||
copied: 'Copied';
|
||
copyDebugDetails: 'Copy debug details';
|
||
details: 'Details';
|
||
fields: {
|
||
acceptanceUnknown: 'acceptanceUnknown';
|
||
delivered: 'delivered';
|
||
diagnostics: 'diagnostics';
|
||
ledgerStatus: 'ledgerStatus';
|
||
messageId: 'messageId';
|
||
providerId: 'providerId';
|
||
queuedBehindMessageId: 'queuedBehindMessageId';
|
||
reason: 'reason';
|
||
responsePending: 'responsePending';
|
||
responseState: 'responseState';
|
||
statusMessageId: 'statusMessageId';
|
||
userVisibleMessage: 'userVisibleMessage';
|
||
userVisibleNextReviewAt: 'userVisibleNextReviewAt';
|
||
userVisibleReasonCode: 'userVisibleReasonCode';
|
||
userVisibleState: 'userVisibleState';
|
||
visibleReplyCorrelation: 'visibleReplyCorrelation';
|
||
visibleReplyMessageId: 'visibleReplyMessageId';
|
||
};
|
||
};
|
||
filter: {
|
||
actions: {
|
||
reset: 'Reset';
|
||
save: 'Save';
|
||
};
|
||
ariaLabel: 'Filter messages';
|
||
from: 'From';
|
||
noData: 'No data';
|
||
showStatusUpdates: 'Show status updates (idle/shutdown)';
|
||
to: 'To';
|
||
tooltip: 'Filter messages';
|
||
};
|
||
panelMode: 'Message panel mode';
|
||
search: {
|
||
placeholder: 'Search...';
|
||
};
|
||
status: {
|
||
title: 'Status';
|
||
};
|
||
title: 'Messages';
|
||
unread: {
|
||
new: '{{count}} new';
|
||
new_few: '{{count}} new';
|
||
new_many: '{{count}} new';
|
||
new_one: '{{count}} new';
|
||
new_other: '{{count}} new';
|
||
unread: '{{count}} unread';
|
||
unread_few: '{{count}} unread';
|
||
unread_many: '{{count}} unread';
|
||
unread_one: '{{count}} unread';
|
||
unread_other: '{{count}} unread';
|
||
};
|
||
};
|
||
modelSelector: {
|
||
advisory: {
|
||
note: 'Note';
|
||
pingNotConfirmed: 'Ping not confirmed';
|
||
};
|
||
anthropicExtraUsage: {
|
||
pricingDocs: 'Read Anthropic pricing docs';
|
||
};
|
||
badges: {
|
||
configured: 'Configured';
|
||
connected: 'Connected';
|
||
failed: 'Failed';
|
||
free: 'Free';
|
||
issue: 'Issue';
|
||
local: 'Local';
|
||
needsTest: 'Needs test';
|
||
unavailable: 'Unavailable';
|
||
verified: 'Verified';
|
||
};
|
||
customModelId: 'Custom model id';
|
||
defaultModel: 'Default';
|
||
defaultTooltip: {
|
||
anthropic: 'Uses the Claude team default model.\nResolves to {{longContextModel}} with 1M context, or {{limitedContextModel}} with 200K context when Limit context is enabled.';
|
||
anthropicCompatible: 'Uses the Anthropic-compatible endpoint default model.';
|
||
anthropicCompatibleWithResolved: 'Uses the Anthropic-compatible endpoint default model.\nCurrently resolves to {{model}}.';
|
||
openCode: 'Uses the OpenCode runtime default model.';
|
||
openCodeWithResolved: 'Uses the OpenCode default model.\nCurrently resolves to {{model}}.';
|
||
runtime: 'Uses the runtime default for the selected provider.';
|
||
};
|
||
empty: {
|
||
freeOpenCode: 'No free OpenCode models are available in the current runtime list.';
|
||
noModels: 'No models are available in the current runtime list.';
|
||
noSearchMatches: 'No models match this search.';
|
||
recommendedFreeOpenCode: 'No recommended free OpenCode models are available in the current runtime list.';
|
||
recommendedOpenCode: 'No recommended OpenCode models are available in the current runtime list.';
|
||
};
|
||
fastMode: {
|
||
codexLabel: 'Fast mode (2x credits)';
|
||
defaultFast: 'Default (Fast)';
|
||
defaultOff: 'Default (Off)';
|
||
defaultResolvesTo: 'Default currently resolves to {{mode}}.';
|
||
fast: 'Fast';
|
||
off: 'Off';
|
||
optionalLabel: 'Fast mode (optional)';
|
||
runtimeBackedHint: 'Fast mode is runtime-backed and only unlocks when the resolved Anthropic launch model supports it.';
|
||
};
|
||
label: 'Model (optional)';
|
||
multimodelOff: 'Multimodel off';
|
||
multimodelRequired: 'Codex and Gemini require Multimodel mode.';
|
||
openCode: {
|
||
allSources: 'All OpenCode sources';
|
||
filterSource: 'Filter {{source}}';
|
||
filterSources: 'Filter OpenCode sources';
|
||
freeOnly: 'Free only';
|
||
freeTooltip: 'OpenCode marks this model as free.';
|
||
loadingModels: 'Loading OpenCode models...';
|
||
noSourcesFound: 'No sources found.';
|
||
recommendedOnly: 'Recommended only';
|
||
searchSources: 'Search sources';
|
||
sourcesCount: '{{count}} OpenCode sources';
|
||
sourcesCount_few: '{{count}} OpenCode sources';
|
||
sourcesCount_many: '{{count}} OpenCode sources';
|
||
sourcesCount_one: '{{count}} OpenCode sources';
|
||
sourcesCount_other: '{{count}} OpenCode sources';
|
||
};
|
||
openCodeStatus: {
|
||
badges: {
|
||
check: 'Check';
|
||
free: 'Free';
|
||
install: 'Install';
|
||
setup: 'Setup';
|
||
};
|
||
freeModelsAvailableTitle: 'OpenCode free models are available';
|
||
loadingRuntime: 'OpenCode runtime status is still loading.';
|
||
messages: {
|
||
checking: 'The app is still checking the OpenCode runtime. Wait for provider status to finish, then try again.';
|
||
freeAvailable: 'OpenCode is detected. You can use free OpenCode models such as Big Pickle without connecting a provider. Connect a provider only when you want provider-backed models.';
|
||
launchBlocked: 'OpenCode is installed and authenticated, but Agent Teams launch readiness is blocked.';
|
||
noFreeListed: 'OpenCode is detected, but no free OpenCode model is listed yet. Refresh provider status, or connect a provider in OpenCode for provider-backed models.';
|
||
ready: 'OpenCode is ready for team launch.';
|
||
unsupported: 'OpenCode is not installed, not found, or the detected runtime is not supported. Install or update OpenCode, then refresh provider status. You can also use the Install button on the home page.';
|
||
};
|
||
notReadyTitle: 'OpenCode is not ready for team launch';
|
||
providerNotConnectedTitle: 'OpenCode provider is not connected';
|
||
readyMessage: 'OpenCode passed provider readiness. Select it to use OpenCode models for this team.';
|
||
readyTitle: 'OpenCode is ready';
|
||
summary: {
|
||
checking: 'OpenCode status: checking runtime';
|
||
status: 'OpenCode status: {{parts}}';
|
||
};
|
||
summaryParts: {
|
||
freeWithoutAuth: 'free models available without auth';
|
||
providerConnected: 'provider connected';
|
||
providerModelsNeedSetup: 'provider-backed models need setup';
|
||
providerNotConnected: 'provider not connected';
|
||
providerOptional: 'provider connection optional';
|
||
runtimeDetected: 'runtime detected';
|
||
runtimeMissing: 'runtime missing';
|
||
teamLaunchBlocked: 'team launch blocked';
|
||
teamLaunchReady: 'team launch ready';
|
||
};
|
||
useOpenCode: 'Use OpenCode';
|
||
};
|
||
placeholders: {
|
||
customModelId: 'openai/gpt-oss-20b';
|
||
};
|
||
pricing: {
|
||
cacheReadTitle: 'Cache read: {{rate}} per 1M tokens';
|
||
cacheWriteTitle: 'Cache write: {{rate}} per 1M tokens';
|
||
free: 'Free';
|
||
inputShort: 'in {{rate}}';
|
||
inputTitle: 'Input: {{rate}} per 1M tokens';
|
||
outputShort: 'out {{rate}}';
|
||
outputTitle: 'Output: {{rate}} per 1M tokens';
|
||
perMillionSummary: '{{summary}} / 1M';
|
||
};
|
||
reason: 'Reason: {{reason}}';
|
||
routeGroups: {
|
||
builtinFree: 'Free built-in';
|
||
connectedProviders: 'Connected providers';
|
||
openCodeConfig: 'OpenCode config';
|
||
otherCatalog: 'Other OpenCode catalog';
|
||
};
|
||
runtimeModelsSyncing: 'Explicit models load from the current runtime. Default remains available while the list is syncing.';
|
||
searchModels: 'Search models';
|
||
unavailableInRuntime: 'Unavailable in current runtime';
|
||
};
|
||
openCodeContextConfigHint: {
|
||
and: 'and';
|
||
compactionConfig: 'Compaction config';
|
||
description: 'Add matching limits to the OpenCode config for the provider and model used by this teammate. This helps OpenCode compact and prune before local models overflow their context window.';
|
||
promptInstructionsSuffix: 'are weaker because the request is assembled before the model reads them.';
|
||
providerLimits: 'Provider limits';
|
||
replacePrefix: 'Replace';
|
||
replaceSuffix: 'with the provider and model IDs from your OpenCode setup. Prompt instructions like';
|
||
summary: 'OpenCode local models can use an OpenCode context budget instead of prompt-only limits.';
|
||
};
|
||
permissions: {
|
||
autoApproveAllTools: 'Auto-approve all tools';
|
||
autonomousModeDescription: 'Autonomous mode: team tools execute without confirmation. Be cautious with untrusted code.';
|
||
manualModeDescription: "Manual mode: you'll approve or deny each tool call in real time.";
|
||
};
|
||
processes: {
|
||
ago: '{{time}} ago';
|
||
kill: 'Kill';
|
||
open: 'Open';
|
||
openInBrowser: 'Open in browser';
|
||
pid: 'PID{{pid}}';
|
||
running: 'Running';
|
||
stopProcess: 'Stop process (SIGTERM)';
|
||
stopped: 'Stopped';
|
||
stoppedAgo: 'stopped {{time}} ago';
|
||
title: 'CLI Processes';
|
||
};
|
||
projectPath: {
|
||
browse: 'Browse';
|
||
createAutomatically: 'If the directory does not exist, it will be created automatically.';
|
||
customWorkingDirectory: 'Custom working directory';
|
||
deleted: {
|
||
label: 'Deleted';
|
||
title: 'Project folder no longer exists';
|
||
};
|
||
empty: 'Nothing found';
|
||
label: 'Project';
|
||
loadingProjects: 'Loading projects...';
|
||
mode: {
|
||
customPath: 'Custom path';
|
||
projectList: 'From project list';
|
||
};
|
||
noProjects: 'No projects found, switch to custom path.';
|
||
searchPlaceholder: 'Search project by name or path';
|
||
selectFromList: 'Select a project from the list';
|
||
selectProject: 'Select a project...';
|
||
source: {
|
||
claude: 'Found by Claude';
|
||
codex: 'Found by Codex';
|
||
mixed: 'Found by Claude and Codex';
|
||
};
|
||
};
|
||
provisioning: {
|
||
cancel: 'Cancel';
|
||
cliLogs: 'CLI logs';
|
||
copied: 'Copied';
|
||
copyDiagnostics: 'Copy diagnostics';
|
||
diagnostics: 'Diagnostics';
|
||
diagnosticsCopied: 'Diagnostics copied';
|
||
liveOutput: 'Live output';
|
||
moreWarningsHidden: '{{count}} more warnings hidden';
|
||
noOutput: 'No output captured yet.';
|
||
pid: 'PID {{pid}}';
|
||
presentation: {
|
||
awaitingPermission: '{{count}} teammate awaiting permission approval';
|
||
bootstrapStalled: 'Bootstrap stalled: {{names}}';
|
||
bootstrapStalledWithOpenCodeWait: '{{stalled}}; Waiting for OpenCode: {{names}}';
|
||
countPendingDiagnostic: '{{count}} {{label}}';
|
||
failed: {
|
||
memberFailedToStart: '{{name}} failed to start';
|
||
teammatesFailedRatio: '{{count}}/{{total}} teammates failed to start';
|
||
teammatesFailedToStart: '{{count}} teammates failed to start';
|
||
};
|
||
joining: {
|
||
teammatesConfirmedRatio: '{{count}}/{{total}} teammates confirmed';
|
||
teammatesStillJoining: '{{count}} teammates still joining';
|
||
teammatesStillJoining_few: '{{count}} teammates still joining';
|
||
teammatesStillJoining_many: '{{count}} teammates still joining';
|
||
teammatesStillJoining_one: '{{count}} teammate still joining';
|
||
teammatesStillJoining_other: '{{count}} teammates still joining';
|
||
};
|
||
nameListWithMore: '{{names}}, +{{count}} more';
|
||
namedPendingDiagnostic: '{{label}}: {{names}}';
|
||
panel: {
|
||
coreTeamReady: 'Core team ready';
|
||
finishingLaunch: 'Finishing launch';
|
||
launchContinuedSkipped: 'Launch continued with skipped teammates';
|
||
launchDetails: 'Launch details';
|
||
launchFailed: 'Launch failed';
|
||
launchFinishedWithErrors: 'Launch finished with errors';
|
||
launchingTeam: 'Launching team';
|
||
teamLaunched: 'Team launched';
|
||
};
|
||
pendingLabels: {
|
||
awaitingPermission: 'Awaiting permission';
|
||
awaitingPermissionLower: 'awaiting permission';
|
||
bootstrapStalled: 'Bootstrap stalled';
|
||
bootstrapUnconfirmed: 'Bootstrap unconfirmed';
|
||
bootstrapUnconfirmedLower: 'bootstrap unconfirmed';
|
||
shellOnly: 'Shell-only';
|
||
shellOnlyLower: 'shell-only';
|
||
waitingForBootstrap: 'Waiting for bootstrap';
|
||
waitingForBootstrapLower: 'waiting for bootstrap';
|
||
waitingForRuntime: 'Waiting for runtime';
|
||
waitingForRuntimeLower: 'waiting for runtime';
|
||
};
|
||
ready: {
|
||
allTeammatesJoined: 'All {{count}} teammates joined';
|
||
launchContinuedSkipped: 'Launch continued - {{count}}/{{total}} teammates skipped';
|
||
launchFinishedWithErrors: 'Launch finished with errors - {{count}}/{{total}} teammates failed to start';
|
||
leadOnline: 'Lead online';
|
||
teamLaunchedAllJoined: 'Team launched - all {{count}} teammates joined';
|
||
teamLaunchedLeadOnline: 'Team launched - lead online';
|
||
teamProvisionedAllJoined: 'Team provisioned - all {{count}} teammates joined';
|
||
teamProvisionedLeadOnline: 'Team provisioned - lead online';
|
||
teamProvisionedStillJoining: 'Team provisioned - teammates are still joining';
|
||
};
|
||
skipped: {
|
||
memberSkipped: '{{name}} skipped for this launch';
|
||
memberSkippedCompact: '{{name}} skipped';
|
||
memberSkippedWithReason: '{{name}} skipped for this launch - {{reason}}';
|
||
teammatesSkipped: '{{count}} teammates skipped';
|
||
teammatesSkippedList: 'Skipped teammates: {{list}}';
|
||
teammatesSkippedRatio: '{{count}}/{{total}} teammates skipped for this launch';
|
||
};
|
||
waitingForOpenCode: 'Waiting for OpenCode: {{names}}';
|
||
};
|
||
providerStatus: {
|
||
copied: 'Copied';
|
||
copyDiagnostics: 'Copy diagnostics';
|
||
deepVerificationPending: 'Deep verification is still running. OpenCode free models may take around 20 seconds.';
|
||
detailSummary: {
|
||
authenticationRequired: 'Authentication required';
|
||
cliBinaryCouldNotStart: 'CLI binary could not be started';
|
||
cliBinaryMissing: 'CLI binary missing';
|
||
cliPreflightFailed: 'CLI preflight failed';
|
||
cliPreflightIncomplete: 'CLI preflight did not complete';
|
||
needsAttention: 'Needs attention';
|
||
openCodeMcpUnreachable: 'OpenCode app MCP unreachable';
|
||
openCodeNoOutput: 'OpenCode runtime check returned no output';
|
||
openCodeRuntimeMissing: 'OpenCode runtime missing';
|
||
openCodeWindowsAccessBlocked: 'OpenCode Windows access blocked';
|
||
readyWithNotes: 'Ready with notes';
|
||
runtimeProviderNotConfigured: 'Runtime provider is not configured';
|
||
selectedModelAvailable: 'Selected model available';
|
||
selectedModelCheckFailed: 'Selected model check failed';
|
||
selectedModelCompatibilityPending: 'Selected model compatibility pending';
|
||
selectedModelCompatible: 'Selected model compatible';
|
||
selectedModelDeferred: 'Selected model verification deferred';
|
||
selectedModelPingNotConfirmed: 'Selected model ping not confirmed';
|
||
selectedModelTimedOut: 'Selected model verification timed out';
|
||
selectedModelUnavailable: 'Selected model unavailable';
|
||
selectedModelVerified: 'Selected model verified';
|
||
workingDirectoryMissing: 'Working directory missing';
|
||
};
|
||
failureHints: {
|
||
authenticationRequired: 'Authenticate the required provider in Claude CLI, then reopen this dialog.';
|
||
cliBinaryMissing: 'Make sure the local Claude CLI binary exists and can be started, then reopen this dialog.';
|
||
default: 'Resolve the issue above, then reopen this dialog.';
|
||
openCodeAccessDenied: 'Fix folder permissions or move the project to a user-writable folder. Running as administrator is only a temporary workaround.';
|
||
openCodeAppMcpUnreachable: 'Retry launch to refresh the OpenCode app MCP bridge. If it repeats, restart the app and OpenCode runtime.';
|
||
openCodeBridgeNoOutput: 'Restart the app and OpenCode runtime, then retry. If it repeats, copy diagnostics.';
|
||
openCodeRuntimeMissing: 'Install or retry OpenCode runtime from the provider status card, then reopen this dialog.';
|
||
runtimeProviderNotConfigured: 'Configure the selected provider runtime, then reopen this dialog.';
|
||
workingDirectoryMissing: 'Choose an existing working directory, then reopen this dialog.';
|
||
};
|
||
modelChecksSummary: 'Selected model checks - {{details}}';
|
||
modelParts: {
|
||
available: '{{count}} available';
|
||
available_few: '{{count}} available';
|
||
available_many: '{{count}} available';
|
||
available_one: '{{count}} available';
|
||
available_other: '{{count}} available';
|
||
checkFailed: '{{count}} model check failed';
|
||
checkFailed_few: '{{count}} models check failed';
|
||
checkFailed_many: '{{count}} models check failed';
|
||
checkFailed_one: '{{count}} model check failed';
|
||
checkFailed_other: '{{count}} models check failed';
|
||
checking: '{{count}} checking';
|
||
checking_few: '{{count}} checking';
|
||
checking_many: '{{count}} checking';
|
||
checking_one: '{{count}} checking';
|
||
checking_other: '{{count}} checking';
|
||
compatibilityPending: '{{count}} compatible, deep verification pending';
|
||
compatibilityPending_few: '{{count}} compatible, deep verification pending';
|
||
compatibilityPending_many: '{{count}} compatible, deep verification pending';
|
||
compatibilityPending_one: '{{count}} compatible, deep verification pending';
|
||
compatibilityPending_other: '{{count}} compatible, deep verification pending';
|
||
compatible: '{{count}} compatible';
|
||
compatible_few: '{{count}} compatible';
|
||
compatible_many: '{{count}} compatible';
|
||
compatible_one: '{{count}} compatible';
|
||
compatible_other: '{{count}} compatible';
|
||
deferred: '{{count}} verification deferred';
|
||
deferred_few: '{{count}} verification deferred';
|
||
deferred_many: '{{count}} verification deferred';
|
||
deferred_one: '{{count}} verification deferred';
|
||
deferred_other: '{{count}} verification deferred';
|
||
pingNotConfirmed: '{{count}} ping not confirmed';
|
||
pingNotConfirmed_few: '{{count}} ping not confirmed';
|
||
pingNotConfirmed_many: '{{count}} ping not confirmed';
|
||
pingNotConfirmed_one: '{{count}} ping not confirmed';
|
||
pingNotConfirmed_other: '{{count}} ping not confirmed';
|
||
timedOut: '{{count}} model timed out';
|
||
timedOut_few: '{{count}} models timed out';
|
||
timedOut_many: '{{count}} models timed out';
|
||
timedOut_one: '{{count}} model timed out';
|
||
timedOut_other: '{{count}} models timed out';
|
||
unavailable: '{{count}} model unavailable';
|
||
unavailable_few: '{{count}} models unavailable';
|
||
unavailable_many: '{{count}} models unavailable';
|
||
unavailable_one: '{{count}} model unavailable';
|
||
unavailable_other: '{{count}} models unavailable';
|
||
verified: '{{count}} verified';
|
||
verified_few: '{{count}} verified';
|
||
verified_many: '{{count}} verified';
|
||
verified_one: '{{count}} verified';
|
||
verified_other: '{{count}} verified';
|
||
};
|
||
openProviderSettings: 'Open {{provider}} settings';
|
||
progress: {
|
||
checkingProvider: 'Checking {{provider}} provider...';
|
||
checkingProviders: 'Checking {{providers}} providers...';
|
||
checkingSelectedProviders: 'Checking selected providers in parallel...';
|
||
};
|
||
status: {
|
||
checking: 'checking...';
|
||
failed: 'ERR';
|
||
notes: 'OK (notes)';
|
||
pending: 'waiting';
|
||
ready: 'OK';
|
||
};
|
||
};
|
||
steps: {
|
||
assembling: 'Members joining';
|
||
configuring: 'Team setup';
|
||
finalizing: 'Finalizing';
|
||
starting: 'Starting';
|
||
};
|
||
};
|
||
review: {
|
||
conflict: {
|
||
cancel: 'Cancel';
|
||
description: "This file has been modified since the agent's changes";
|
||
editManually: 'Edit Manually';
|
||
keepCurrent: 'Keep Current';
|
||
saveResolution: 'Save Resolution';
|
||
title: 'Conflict Detected';
|
||
useOriginal: 'Use Original';
|
||
};
|
||
continuousScroll: {
|
||
empty: 'No reviewable file changes';
|
||
};
|
||
diffControls: {
|
||
acceptChange: 'Accept change (⌘Y)';
|
||
acceptShortcut: '⌘Y';
|
||
keep: 'Keep';
|
||
nextChunk: 'Next chunk';
|
||
previousChunk: 'Previous chunk';
|
||
rejectChange: 'Reject change (⌘N)';
|
||
rejectShortcut: '⌘N';
|
||
undo: 'Undo';
|
||
};
|
||
diffError: {
|
||
actions: {
|
||
retry: 'Retry';
|
||
};
|
||
raw: {
|
||
charsTotal: '... ({{count}} chars total)';
|
||
charsTotal_few: '... ({{count}} chars total)';
|
||
charsTotal_many: '... ({{count}} chars total)';
|
||
charsTotal_one: '... ({{count}} char total)';
|
||
charsTotal_other: '... ({{count}} chars total)';
|
||
file: 'File: {{file}}';
|
||
modified: '+++ Modified';
|
||
original: '--- Original';
|
||
show: 'Show raw diff data';
|
||
};
|
||
title: 'Failed to render diff view';
|
||
unexpected: 'An unexpected error occurred while rendering the diff.';
|
||
};
|
||
empty: {
|
||
noFileChangesRecorded: 'No file changes recorded';
|
||
noFileEvents: 'The task ledger has no file events for this task.';
|
||
noFileEventsYet: 'The task ledger has no file events for this task yet.';
|
||
noSafeDiff: 'No safe diff available';
|
||
noSafeDiffDescription: 'The task ledger did not expose a safe file diff for this task.';
|
||
noSafeDiffDiagnosticsDescription: 'The task ledger did not expose a safe file diff for this task. The diagnostics below explain why.';
|
||
};
|
||
fileHeader: {
|
||
actions: {
|
||
accept: 'Accept';
|
||
discard: 'Discard';
|
||
discardTooltip: 'Discard all edits for this file';
|
||
keepMyDraft: 'Keep my draft';
|
||
reject: 'Reject';
|
||
reloadFromDisk: 'Reload from disk';
|
||
restore: 'Restore';
|
||
restoreTooltip: 'Create/restore this file on disk from the preview';
|
||
saveFile: 'Save File';
|
||
saveFileTooltip: 'Save file to disk';
|
||
};
|
||
badges: {
|
||
deleted: 'DELETED';
|
||
manualReview: 'MANUAL REVIEW';
|
||
new: 'NEW';
|
||
worktree: 'WORKTREE';
|
||
};
|
||
contentSource: {
|
||
'disk-current': 'Current Disk';
|
||
'file-history': 'File History';
|
||
'git-fallback': 'Git Fallback';
|
||
'ledger-exact': 'Task Ledger';
|
||
'ledger-snapshot': 'Ledger Snapshot';
|
||
'snippet-reconstruction': 'Reconstructed';
|
||
unavailable: 'Content unavailable';
|
||
};
|
||
contentUnavailable: {
|
||
badge: 'Content unavailable';
|
||
description: 'The ledger recorded metadata for this change, but full text content is not available. This usually means binary, large, or hash-only content.';
|
||
safety: 'Automatic accept/reject is disabled for this file to avoid unsafe disk writes.';
|
||
title: 'Text content is unavailable';
|
||
};
|
||
disabled: {
|
||
acceptRejectContentUnavailable: 'Accept/Reject is disabled because full text content is unavailable.';
|
||
acceptRejectMissingOnDisk: 'Accept/Reject is disabled while the file is missing on disk.';
|
||
rejectBaselineUnavailable: 'Reject is disabled because the original baseline is unavailable.';
|
||
rejectContentUnavailable: 'Reject is disabled because full text content is unavailable.';
|
||
rejectManualLedgerReview: 'Reject is disabled because this ledger change has binary, large, or unavailable content.';
|
||
};
|
||
externalChange: {
|
||
changedOnDisk: 'Changed on disk';
|
||
deletedOnDisk: 'Deleted on disk';
|
||
recreatedOnDisk: 'Recreated on disk';
|
||
};
|
||
missingOnDisk: {
|
||
badge: 'Missing on disk';
|
||
description: 'We can still show a preview from agent logs, but your filesystem is out of sync.';
|
||
restorePrefix: 'Use';
|
||
restoreSuffix: 'to write the preview content back to disk.';
|
||
restoreUnavailable: 'Full file content is not available to restore automatically.';
|
||
title: 'File is missing on disk';
|
||
};
|
||
pathChange: {
|
||
from: 'From {{path}}';
|
||
to: 'To {{path}}';
|
||
};
|
||
worktree: {
|
||
isolated: 'Isolated worktree';
|
||
};
|
||
};
|
||
fileMissingPrefix: 'File is missing on disk. This diff may be only a preview from agent logs. Use';
|
||
fileMissingSuffix: 'to create the file on disk.';
|
||
filePlaceholder: {
|
||
description: 'Preparing a full editor diff for this file.';
|
||
loading: 'Loading';
|
||
};
|
||
fileTree: {
|
||
badges: {
|
||
deleted: 'deleted';
|
||
new: 'new';
|
||
};
|
||
collapseFolder: 'Collapse {{name}}';
|
||
empty: {
|
||
noChangedFiles: 'No changed files';
|
||
noMatchingFiles: 'No matching files';
|
||
};
|
||
expandFolder: 'Expand {{name}}';
|
||
filters: {
|
||
clear: 'Clear';
|
||
new: 'New';
|
||
rejected: 'Rejected';
|
||
unresolved: 'Unresolved';
|
||
};
|
||
searchPlaceholder: 'Search files…';
|
||
viewed: 'Viewed';
|
||
};
|
||
fullDiffLoading: {
|
||
editorViewLoading: 'Editor view loading';
|
||
filesInProgress: '{{count}} files in progress';
|
||
filesInProgress_few: '{{count}} files in progress';
|
||
filesInProgress_many: '{{count}} files in progress';
|
||
filesInProgress_one: '{{count}} file in progress';
|
||
filesInProgress_other: '{{count}} files in progress';
|
||
filesReady: '{{ready}}/{{total}} files ready';
|
||
previewsReady: '{{count}} previews ready';
|
||
previewsReady_few: '{{count}} previews ready';
|
||
previewsReady_many: '{{count}} previews ready';
|
||
previewsReady_one: '{{count}} preview ready';
|
||
previewsReady_other: '{{count}} previews ready';
|
||
progressDescription: '{{ready}} ready, {{loading}} still loading. Preview diffs stay visible below while the remaining baselines are resolved.';
|
||
singleDescription: 'Preview diffs stay visible below while the exact baseline is resolved.';
|
||
subtitleCurrentFile: 'Finalizing the exact editor diff for the current file.';
|
||
subtitleForFile: 'Finalizing the exact editor diff for {{file}}.';
|
||
subtitleMany: 'Resolving exact before/after baselines for the files currently loading.';
|
||
titleMany: 'Preparing {{count}} Full Diffs';
|
||
titleOne: 'Preparing Full Diff';
|
||
};
|
||
loading: {
|
||
diff: 'DIFF';
|
||
ledgerObjectsProcessed: '{{count}} ledger objects processed';
|
||
ledgerObjectsProcessed_few: '{{count}} ledger objects processed';
|
||
ledgerObjectsProcessed_many: '{{count}} ledger objects processed';
|
||
ledgerObjectsProcessed_one: '{{count}} ledger object processed';
|
||
ledgerObjectsProcessed_other: '{{count}} ledger objects processed';
|
||
phases: {
|
||
checkingWorktree: 'Checking worktree context...';
|
||
preparingDiffs: 'Preparing review diffs...';
|
||
readingLedger: 'Reading task ledger...';
|
||
resolvingFiles: 'Resolving file states...';
|
||
};
|
||
};
|
||
progress: {
|
||
viewed: '{{viewed}}/{{total}} viewed';
|
||
};
|
||
restore: 'Restore';
|
||
scope: {
|
||
confidence: {
|
||
bestEffort: 'Best effort';
|
||
high: 'High confidence';
|
||
low: 'Low confidence';
|
||
medium: 'Medium confidence';
|
||
};
|
||
ledger: {
|
||
exact: {
|
||
badge: 'Ledger exact';
|
||
detail: 'The orchestrator captured these file changes while the agent was working on this task.';
|
||
title: 'Changes captured by task ledger';
|
||
};
|
||
limited: {
|
||
detail: 'The orchestrator captured these file changes for this task, but at least one change was captured from a snapshot or metadata-only source. Review exact text diffs where available; binary or unavailable content may require manual review.';
|
||
mixedBadge: 'Mixed reviewability';
|
||
needsReviewBadge: 'Needs review';
|
||
title: 'Changes captured with limited reviewability';
|
||
};
|
||
};
|
||
readMore: 'Read more';
|
||
tiers: {
|
||
allSession: {
|
||
detail: 'No task markers found in the session log. Cannot isolate this task - all file changes from the entire session are shown, including changes from other tasks. This can happen with older CLI versions or non-standard workflows.';
|
||
title: 'Showing all session changes';
|
||
};
|
||
endEstimated: {
|
||
detail: 'Only the start marker was found - the task has no completion marker yet. Changes shown from task start to end of session. If other tasks ran after this one in the same session, their changes may also be included.';
|
||
title: 'End boundary estimated';
|
||
};
|
||
exact: {
|
||
detail: 'Both start and completion markers found in the session log. The diff includes only changes made during this specific task - other tasks that modified the same files are excluded.';
|
||
title: 'Task scope determined precisely';
|
||
};
|
||
startEstimated: {
|
||
detail: 'Only the completion marker was found - the start of work was not captured. If other tasks ran before this one in the same session, their changes to the same files may also be included.';
|
||
title: 'Start boundary estimated';
|
||
};
|
||
};
|
||
workInterval: {
|
||
badge: 'Interval scoped';
|
||
detail: 'The task start marker was not available in the session log, so the diff is scoped by the task work interval stored on the board.';
|
||
title: 'Scoped by persisted work interval';
|
||
};
|
||
};
|
||
shortcuts: {
|
||
actions: {
|
||
acceptChange: 'Accept change';
|
||
closeDialog: 'Close dialog';
|
||
nextChange: 'Next change';
|
||
nextFile: 'Next file';
|
||
previousChange: 'Previous change';
|
||
previousFile: 'Previous file';
|
||
redo: 'Redo';
|
||
rejectChange: 'Reject change';
|
||
saveFile: 'Save file';
|
||
toggleShortcuts: 'Toggle shortcuts';
|
||
undo: 'Undo';
|
||
};
|
||
title: 'Keyboard Shortcuts';
|
||
};
|
||
timeline: {
|
||
empty: 'No edit events';
|
||
titleWithCount: 'Edit Timeline ({{count}})';
|
||
};
|
||
toolbar: {
|
||
actions: {
|
||
acceptAll: 'Accept All';
|
||
applyRejections: 'Apply Rejections';
|
||
applying: 'Applying...';
|
||
auto: 'Auto';
|
||
rejectAll: 'Reject All';
|
||
undo: 'Undo';
|
||
};
|
||
stats: {
|
||
accepted: '{{count}} accepted';
|
||
accepted_few: '{{count}} accepted';
|
||
accepted_many: '{{count}} accepted';
|
||
accepted_one: '{{count}} accepted';
|
||
accepted_other: '{{count}} accepted';
|
||
acrossFiles: 'across {{count}} files';
|
||
acrossFiles_few: 'across {{count}} files';
|
||
acrossFiles_many: 'across {{count}} files';
|
||
acrossFiles_one: 'across {{count}} file';
|
||
acrossFiles_other: 'across {{count}} files';
|
||
edited: '{{count}} edited';
|
||
edited_few: '{{count}} edited';
|
||
edited_many: '{{count}} edited';
|
||
edited_one: '{{count}} edited';
|
||
edited_other: '{{count}} edited';
|
||
pending: '{{count}} pending';
|
||
pending_few: '{{count}} pending';
|
||
pending_many: '{{count}} pending';
|
||
pending_one: '{{count}} pending';
|
||
pending_other: '{{count}} pending';
|
||
rejected: '{{count}} rejected';
|
||
rejected_few: '{{count}} rejected';
|
||
rejected_many: '{{count}} rejected';
|
||
rejected_one: '{{count}} rejected';
|
||
rejected_other: '{{count}} rejected';
|
||
};
|
||
tooltips: {
|
||
acceptAll: 'Accept all changes across all files';
|
||
applyRejections: 'Apply rejected hunks to disk; accepted changes are kept as-is';
|
||
autoOff: 'Auto-mark files as viewed when scrolled to end (OFF)';
|
||
autoOn: 'Auto-mark files as viewed when scrolled to end (ON)';
|
||
rejectAll: 'Reject all safely rejectable changes across all files';
|
||
rejectAllDisabled: 'No pending files have a safe original baseline to reject.';
|
||
undo: 'Undo last review operation (Ctrl+Z)';
|
||
};
|
||
};
|
||
};
|
||
reviewDialog: {
|
||
charsLeft: '{{count}} chars left';
|
||
placeholder: 'Describe what needs to change... (Enter to submit)';
|
||
saved: 'Saved';
|
||
submit: 'Submit';
|
||
title: 'Request Changes';
|
||
};
|
||
roleSelect: {
|
||
customRole: 'Custom role...';
|
||
empty: 'No roles found.';
|
||
noRole: 'No role';
|
||
reservedRole: 'This role is reserved';
|
||
searchPlaceholder: 'Search roles...';
|
||
};
|
||
runningTeams: {
|
||
title: 'Running Teams';
|
||
};
|
||
schedule: {
|
||
actions: {
|
||
addSchedule: 'Add Schedule';
|
||
delete: 'Delete';
|
||
edit: 'Edit';
|
||
pause: 'Pause';
|
||
resume: 'Resume';
|
||
runNow: 'Run now';
|
||
};
|
||
count: '{{count}} schedules';
|
||
count_few: '{{count}} schedules';
|
||
count_many: '{{count}} schedules';
|
||
count_one: '{{count}} schedule';
|
||
count_other: '{{count}} schedules';
|
||
cron: {
|
||
errors: {
|
||
enterExpression: 'Enter a cron expression';
|
||
invalidExpression: 'Invalid cron expression';
|
||
};
|
||
expression: 'Cron expression';
|
||
highFrequencyWarning: 'High frequency schedule (less than 5 min interval)';
|
||
nextRuns: 'Next runs:';
|
||
presets: {
|
||
dailyAtNine: 'Daily at 9am';
|
||
everyHour: 'Every hour';
|
||
everySixHours: 'Every 6 hours';
|
||
everyThirtyMinutes: 'Every 30 min';
|
||
mondayAtNine: 'Monday at 9am';
|
||
weekdaysAtNine: 'Weekdays at 9am';
|
||
};
|
||
selectTimezone: 'Select timezone';
|
||
timezone: 'Timezone';
|
||
warmUpDescription: 'Prepares selected providers before scheduled execution';
|
||
warmUpOptions: {
|
||
fifteenMinutes: '15 min';
|
||
fiveMinutes: '5 min';
|
||
none: 'No warm-up';
|
||
tenMinutes: '10 min';
|
||
thirtyMinutes: '30 min';
|
||
};
|
||
warmUpTime: 'Warm-up time';
|
||
};
|
||
empty: {
|
||
description: 'Create a schedule to run Claude tasks automatically on a cron schedule.';
|
||
title: 'No schedules yet';
|
||
};
|
||
nextRun: 'Next: {{next}}';
|
||
runHistory: {
|
||
empty: 'No runs yet';
|
||
loading: 'Loading run history...';
|
||
};
|
||
runLog: {
|
||
close: 'Close';
|
||
errors: 'Errors';
|
||
exitCode: 'exit {{code}}';
|
||
loadingLogs: 'Loading logs...';
|
||
retryCount: 'retry {{count}}/{{max}}';
|
||
stillRunning: 'Task is still running...';
|
||
title: 'Run Log';
|
||
};
|
||
runStatus: {
|
||
cancelled: 'Cancelled';
|
||
completed: 'Completed';
|
||
failed: 'Failed';
|
||
interrupted: 'Interrupted';
|
||
pending: 'Pending';
|
||
running: 'Running';
|
||
warm: 'Warm';
|
||
warmingUp: 'Warming up';
|
||
};
|
||
status: {
|
||
active: 'Active';
|
||
disabled: 'Disabled';
|
||
paused: 'Paused';
|
||
};
|
||
title: 'Schedules';
|
||
};
|
||
sendMessage: {
|
||
attachments: {
|
||
attachFiles: 'Attach files (paste or drag & drop)';
|
||
disabledHint: 'File attachments are supported for the online team lead and online OpenCode teammates. Remove attachments or switch recipient.';
|
||
openCodeOnlineRequired: 'Team must be online to attach files for OpenCode teammates';
|
||
recipientUnsupported: 'Files can be sent to the team lead or OpenCode teammates';
|
||
teamOnlineRequired: 'Team must be online to attach files';
|
||
unavailable: 'Attachments are unavailable';
|
||
};
|
||
charsLeft: '{{count}} chars left';
|
||
description: 'Send a direct message to a team member.';
|
||
messageLabel: 'Message';
|
||
placeholder: 'Write your message... (Enter to send)';
|
||
quote: {
|
||
remove: 'Remove quote';
|
||
replyingTo: 'Replying to';
|
||
};
|
||
recipientLabel: 'Recipient';
|
||
saved: 'Saved';
|
||
selectMemberPlaceholder: 'Select member...';
|
||
send: 'Send';
|
||
sending: 'Sending...';
|
||
title: 'Send Message';
|
||
};
|
||
sessions: {
|
||
empty: 'No sessions found';
|
||
filterBySession: 'Filter by this session';
|
||
lead: 'lead';
|
||
loading: 'Loading sessions...';
|
||
noProjectPath: 'No project path linked';
|
||
openSession: 'Open session';
|
||
projectNotFound: 'Project not found';
|
||
provisioningHint: 'Sessions will appear after team provisioning';
|
||
removeFilter: 'Remove filter';
|
||
showAllSessions: 'Show for all sessions';
|
||
title: 'Sessions';
|
||
};
|
||
taskActivity: {
|
||
contextUnavailable: 'Detailed transcript context is no longer available for this activity.';
|
||
description: 'Key explicit runtime activity linked to this task from transcript metadata.';
|
||
empty: 'No explicit task activity was found in the available transcripts yet. Older or heuristic session logs may still be available below in Execution Sessions.';
|
||
loading: 'Loading task activity...';
|
||
loadingDetails: 'Loading activity details...';
|
||
lowSignalOnly: 'No key task activity was found yet. Low-level execution details are available below in Task Log Stream.';
|
||
title: 'Task Activity';
|
||
};
|
||
taskAttachments: {
|
||
attachImage: 'Attach image';
|
||
dropFilesHere: 'Drop files here';
|
||
dropImageHere: 'Drop image here';
|
||
fromOriginalMessage: 'From original message';
|
||
loading: 'Loading attachments...';
|
||
pasteOrDragDrop: 'or paste / drag-drop';
|
||
};
|
||
taskComments: {
|
||
attachFile: 'Attach file (or paste)';
|
||
awaitingReplyFrom: 'Awaiting reply from';
|
||
cancelReply: 'Cancel reply';
|
||
charsLeft: '{{count}} chars left';
|
||
comment: 'Comment';
|
||
or: 'or';
|
||
placeholder: 'Add a comment... (Enter to send)';
|
||
replyingTo: 'Replying to';
|
||
saved: 'Saved';
|
||
voiceToText: 'Voice to text';
|
||
};
|
||
taskDetail: {
|
||
actions: {
|
||
cancel: 'Cancel';
|
||
delete: 'Delete';
|
||
markResolved: 'Mark resolved';
|
||
save: 'Save';
|
||
};
|
||
attachments: {
|
||
commentAttachment: 'Comment attachment';
|
||
fromComments: 'From comments';
|
||
preview: 'Preview {{filename}}';
|
||
};
|
||
changes: {
|
||
badges: {
|
||
attention: 'attention';
|
||
noSafeDiff: 'no safe diff';
|
||
};
|
||
empty: {
|
||
noFileChangesRecorded: 'No file changes recorded';
|
||
noFileChangesRecordedYet: 'No file changes recorded yet';
|
||
noReviewableChangesRecovered: 'No reviewable file changes recovered';
|
||
noSafeDiffAvailable: 'No safe diff available';
|
||
};
|
||
fileCount: '{{count}} files';
|
||
fileCount_few: '{{count}} files';
|
||
fileCount_many: '{{count}} files';
|
||
fileCount_one: '{{count}} files';
|
||
fileCount_other: '{{count}} files';
|
||
fileRowsHidden: '{{count}} file rows hidden';
|
||
fileRowsHidden_few: '{{count}} file rows hidden';
|
||
fileRowsHidden_many: '{{count}} file rows hidden';
|
||
fileRowsHidden_one: '{{count}} file rows hidden';
|
||
fileRowsHidden_other: '{{count}} file rows hidden';
|
||
loadFailed: 'Failed to load task changes summary';
|
||
loading: 'Loading changes...';
|
||
moreDiagnostics: '{{count}} more diagnostics';
|
||
moreDiagnostics_few: '{{count}} more diagnostics';
|
||
moreDiagnostics_many: '{{count}} more diagnostics';
|
||
moreDiagnostics_one: '{{count}} more diagnostics';
|
||
moreDiagnostics_other: '{{count}} more diagnostics';
|
||
moreFiles: '{{count}} more files';
|
||
moreFiles_few: '{{count}} more files';
|
||
moreFiles_many: '{{count}} more files';
|
||
moreFiles_one: '{{count}} more files';
|
||
moreFiles_other: '{{count}} more files';
|
||
openInEditor: 'Open in editor';
|
||
openTask: 'Open task {{subject}}';
|
||
refresh: 'Refresh changes';
|
||
refreshFailed: 'Refresh failed: {{error}}';
|
||
refreshShort: 'Refresh';
|
||
refreshTeamChanges: 'Refresh team changes';
|
||
refreshing: 'Refreshing';
|
||
refreshingChanges: 'Refreshing changes...';
|
||
reviewDiff: 'Review diff';
|
||
reviewTaskDiff: 'Review task diff';
|
||
scannedCandidateTasks: 'Scanned {{requested}} of {{eligible}} candidate tasks';
|
||
tasksDeferred: '{{count}} tasks deferred this pass';
|
||
tasksDeferred_few: '{{count}} tasks deferred this pass';
|
||
tasksDeferred_many: '{{count}} tasks deferred this pass';
|
||
tasksDeferred_one: '{{count}} tasks deferred this pass';
|
||
tasksDeferred_other: '{{count}} tasks deferred this pass';
|
||
title: 'Changes';
|
||
};
|
||
clarification: {
|
||
awaitingLead: 'Awaiting clarification from team lead';
|
||
awaitingUser: 'Awaiting clarification from you';
|
||
};
|
||
comments: {
|
||
actions: {
|
||
cancelReply: 'Cancel reply';
|
||
comment: 'Comment';
|
||
reply: 'Reply';
|
||
replyToComment: 'Reply to comment';
|
||
showMore: 'Show more comments ({{visible}}/{{total}})';
|
||
};
|
||
attachments: {
|
||
downloadFailed: 'Download failed';
|
||
previewAlt: 'Attachment preview';
|
||
};
|
||
badges: {
|
||
approved: 'Approved';
|
||
reviewRequested: 'Review requested';
|
||
};
|
||
input: {
|
||
charsLeft: '{{count}} chars left';
|
||
charsLeft_few: '{{count}} chars left';
|
||
charsLeft_many: '{{count}} chars left';
|
||
charsLeft_one: '{{count}} char left';
|
||
charsLeft_other: '{{count}} chars left';
|
||
placeholder: 'Add a comment... (Enter to send)';
|
||
};
|
||
renderLimit: 'Showing the most recent {{formattedCount}} comments to keep the UI responsive.';
|
||
replyingTo: 'Replying to';
|
||
unknownTime: 'unknown time';
|
||
};
|
||
description: {
|
||
add: 'Click to add description...';
|
||
edit: 'Edit description';
|
||
placeholder: 'Task description (supports markdown)';
|
||
};
|
||
loading: {
|
||
fetchingTeamData: 'Fetching team data';
|
||
title: 'Loading task...';
|
||
};
|
||
logs: {
|
||
newArriving: 'New task logs arriving';
|
||
};
|
||
notFound: 'Task not found';
|
||
related: {
|
||
blockedBy: 'Blocked by';
|
||
blocks: 'Blocks';
|
||
linkedFrom: 'Linked from';
|
||
links: 'Links';
|
||
title: 'Related tasks';
|
||
};
|
||
review: {
|
||
reviewer: 'Reviewer: {{reviewer}}';
|
||
};
|
||
reviewStates: {
|
||
approved: 'Approved';
|
||
inReview: 'In review';
|
||
needsFix: 'Needs fix';
|
||
};
|
||
sections: {
|
||
attachments: 'Attachments';
|
||
changes: 'Changes';
|
||
comments: 'Comments';
|
||
description: 'Description';
|
||
taskLogs: 'Task Logs';
|
||
workflowHistory: 'Workflow History';
|
||
};
|
||
unassigned: 'Unassigned';
|
||
workflow: {
|
||
implementationTimeTitle: 'Implementation time from persisted work intervals';
|
||
inProgressTime: 'In progress time {{duration}}';
|
||
};
|
||
workflowTimeline: {
|
||
approved: 'Approved';
|
||
assignedTo: 'Assigned to';
|
||
by: 'by';
|
||
changesRequested: 'Changes requested';
|
||
createdAs: 'Created as';
|
||
currentImplementationInterval: 'Current implementation interval';
|
||
empty: 'No workflow history recorded';
|
||
implementationIntervalEnded: 'Implementation interval ended at this transition';
|
||
ownerChanged: 'Owner changed';
|
||
reassigned: 'Reassigned';
|
||
reviewRequested: 'Review requested';
|
||
reviewStarted: 'Review started';
|
||
runningPrefix: 'running ';
|
||
unassignedFrom: 'Unassigned from';
|
||
unknownEvent: 'Unknown event';
|
||
};
|
||
};
|
||
taskLogs: {
|
||
exact: {
|
||
description: 'Exact transcript slices rendered with the same execution-log components used in Logs.';
|
||
emptyDescription: 'Exact transcript bundles will appear here when explicit task-linked transcript metadata is available.';
|
||
emptyTitle: 'No exact task logs yet';
|
||
loading: 'Loading exact task logs...';
|
||
summaryOnly: 'summary only';
|
||
title: 'Exact Task Logs';
|
||
};
|
||
executionSessions: {
|
||
description: 'Legacy session-centric transcript browsing and previews.';
|
||
online: 'Online';
|
||
title: 'Execution Sessions';
|
||
updating: 'Updating...';
|
||
};
|
||
stream: {
|
||
title: 'Task Log Stream';
|
||
};
|
||
};
|
||
tasks: {
|
||
createTask: {
|
||
assignee: 'Assignee';
|
||
assigneeOptional: 'Assignee (optional)';
|
||
blockedByOptional: 'Blocked by tasks (optional)';
|
||
blockedBySummary: 'Task will be blocked by: {{tasks}}';
|
||
cancel: 'Cancel';
|
||
create: 'Create';
|
||
creating: 'Creating...';
|
||
description: "The task will be created in the team's tasks/ directory and appear on the Kanban board.";
|
||
descriptionOptional: 'Description (optional)';
|
||
detailsPlaceholder: 'Task details (supports markdown)';
|
||
hideOptionalFields: 'Hide optional fields';
|
||
offlineNotice: {
|
||
after: '- launch the team to start execution.';
|
||
before: 'Team is offline. The task will be added to';
|
||
};
|
||
promptOptional: 'Prompt for assignee (optional)';
|
||
promptPlaceholder: 'Custom instructions for the team member...';
|
||
relatedOptional: 'Related tasks (optional)';
|
||
relatedSummary: 'Related: {{tasks}}';
|
||
saved: 'Saved';
|
||
searchTasks: 'Search tasks...';
|
||
selectMember: 'Select a member';
|
||
selectMemberOptional: 'Select member...';
|
||
showOptionalFields: 'Show optional fields';
|
||
startImmediately: 'Start immediately';
|
||
startOfflineHint: 'Team is offline. Launch the team first to start tasks immediately.';
|
||
subject: 'Subject';
|
||
subjectPlaceholder: 'What needs to be done?';
|
||
title: 'Create Task';
|
||
todo: 'TODO';
|
||
};
|
||
deleteConfirm: {
|
||
cancelLabel: 'Cancel';
|
||
confirmLabel: 'Delete';
|
||
message: 'Move task #{{taskId}} to trash?';
|
||
title: 'Delete task';
|
||
};
|
||
list: {
|
||
columns: {
|
||
blockedBy: 'Blocked By';
|
||
blocks: 'Blocks';
|
||
id: 'ID';
|
||
owner: 'Owner';
|
||
status: 'Status';
|
||
subject: 'Subject';
|
||
};
|
||
empty: 'No tasks in this team';
|
||
filters: {
|
||
allOwners: 'All owners';
|
||
allStatuses: 'All statuses';
|
||
ownerAria: 'Filter tasks by owner';
|
||
statusAria: 'Filter tasks by status';
|
||
};
|
||
showing: 'Showing {{shown}} of {{total}}';
|
||
};
|
||
openTask: 'Open task';
|
||
status: {
|
||
completed: 'completed';
|
||
deleted: 'deleted';
|
||
inProgress: 'in_progress';
|
||
pending: 'pending';
|
||
};
|
||
statusSummary: {
|
||
completed: '{{count}} completed';
|
||
completed_few: '{{count}} completed';
|
||
completed_many: '{{count}} completed';
|
||
completed_one: '{{count}} completed';
|
||
completed_other: '{{count}} completed';
|
||
inProgress: '{{count}} in_progress';
|
||
inProgress_few: '{{count}} in_progress';
|
||
inProgress_many: '{{count}} in_progress';
|
||
inProgress_one: '{{count}} in_progress';
|
||
inProgress_other: '{{count}} in_progress';
|
||
pending: '{{count}} pending';
|
||
pending_few: '{{count}} pending';
|
||
pending_many: '{{count}} pending';
|
||
pending_one: '{{count}} pending';
|
||
pending_other: '{{count}} pending';
|
||
progressAria: 'Tasks {{completed}}/{{total}} completed';
|
||
};
|
||
teamPrefix: 'Team:';
|
||
unassigned: 'Unassigned';
|
||
};
|
||
toolApproval: {
|
||
after: 'after';
|
||
allow: 'Allow';
|
||
allowAll: 'Allow all';
|
||
autoActionIn: 'Auto-{{action}} in {{time}}';
|
||
autoAllowAllTools: 'Auto-allow all tools';
|
||
autoAllowFileEdits: 'Auto-allow file edits (Edit, Write, NotebookEdit)';
|
||
autoAllowSafeCommands: 'Auto-allow safe commands (git, pnpm, npm, ls...)';
|
||
deny: 'Deny';
|
||
diff: {
|
||
binaryFile: 'Binary file - cannot preview';
|
||
newFile: 'New file';
|
||
previewChanges: 'Preview changes';
|
||
readingFile: 'Reading file...';
|
||
truncated: 'File truncated at 2MB - diff may be incomplete';
|
||
};
|
||
onTimeout: 'On timeout:';
|
||
pendingCount: '{{count}} pending';
|
||
secondsShort: 'sec';
|
||
settings: 'Settings';
|
||
submit: 'Submit';
|
||
timeoutActions: {
|
||
allow: 'Allow';
|
||
deny: 'Deny';
|
||
wait: 'Wait forever';
|
||
};
|
||
};
|
||
worktreeGitReadiness: {
|
||
checking: 'Checking Git repository status for teammate worktrees...';
|
||
createInitialCommit: 'Create initial commit';
|
||
initialCommitMessage: 'chore: initial commit';
|
||
initialCommitNotice: 'The initial commit action stages and commits all current files with message';
|
||
initializeRepository: 'Initialize Git repository';
|
||
needsSetup: 'Worktree isolation needs Git setup';
|
||
ready: 'Git worktrees are ready.';
|
||
readyOnBranch: 'Git worktrees are ready on branch {{branch}}.';
|
||
};
|
||
};
|
||
}
|