@belonguniverseai/react-sdk 0.6.20 → 0.6.22

package/dist/embed/slash-commands.d.ts

@@ -43,6 +43,30 @@ export type BuiltinCommand = {
     readonly type: "unschedule";
 } | {
     readonly type: "unschedule_invalid";
+} | {
+    readonly type: "goal";
+    readonly action: "create";
+    readonly objective: string;
+} | {
+    readonly type: "goal";
+    readonly action: "open_sheet";
+} | {
+    readonly type: "goal";
+    readonly action: "status" | "pause" | "resume" | "clear";
+} | {
+    readonly type: "goal";
+    readonly action: "edit";
+    readonly objective: string;
+} | {
+    readonly type: "goal";
+    readonly action: "turns";
+    readonly maxTurns: number;
+} | {
+    readonly type: "goal";
+    readonly action: "budget";
+    readonly tokenBudget: number;
+} | {
+    readonly type: "goal_invalid";
 };
 /**
  * Recognize a submitted draft as a built-in command. `/compact` remains an

package/dist/embed/task-schedule-command.d.ts

@@ -24,6 +24,13 @@ export declare const partsInTimezone: (instant: Date, timezone: string) => WallC
  *  by the gap. Exported for the Scheduled dialog's date+time+timezone →
  *  instant conversion (the server ports the same algorithm). */
 export declare const instantInTimezone: (wall: WallClock, timezone: string) => Date;
+/** The Scheduled dialog's "next run" reading, localized to the VIEWER's
+ *  locale but the SCHEDULE's own timezone (chat.tsx decomposition campaign —
+ *  extracted out of `ChatRoute` as a pure helper, no behavior change). */
+export declare const scheduleLocalTime: (locale: Locale, schedule: {
+    readonly scheduledFor: string;
+    readonly timezone: string;
+}) => string;
 export declare const parseTaskScheduleCommand: (input: {
     readonly argumentsText: string;
     readonly locale: Locale;

package/dist/embed/voice/line-run-reader.d.ts

@@ -1,4 +1,11 @@
 import { RunStatusKind } from '../../stream/belong-data-parts.ts';
+/** A terminal pause is neither a completed answer nor a transport failure. */
+export type IncompleteLineRun = {
+    readonly status: "failed";
+    readonly outcome: "incomplete";
+    readonly terminationReason?: string;
+    readonly message?: string;
+};
 export type WatchLineRunInput = {
     readonly runId: string;
     readonly onPhase: (toolName: string) => void;
@@ -15,6 +22,7 @@ export type WatchLineRunInput = {
         mimeType: string;
     }) => void;
     readonly onFinish: (finalText: string) => void;
+    readonly onIncomplete: (result: IncompleteLineRun) => void;
     /**
      * The run did not finish cleanly. `cause` is a discriminated shape rather
      * than a bare `"terminal" | "transport"` string because the two carry

package/dist/embed/voice-call.d.ts

@@ -177,6 +177,7 @@ declare let lineDispatcher: ((req: {
 export declare const registerCallLineDispatcher: (dispatcher: NonNullable<typeof lineDispatcher>) => (() => void);
 export declare const registerCallLineViewSwitcher: (switcher: (sessionId: string) => void) => (() => void);
 export declare const registerCallClearNotifier: (notifier: (sessionId: string) => void) => (() => void);
+export declare const registerCallDiscoveryCancelNotifier: (notifier: (sessionId: string) => void) => (() => void);
 /**
  * ChatRoute calls this when a tool-approval card appears while a call is
  * live: the ask lands on the timeline and the voice model asks the user to
@@ -277,6 +278,9 @@ export declare const deliverAgentFailure: (message: string) => void;
 /** A background line finished: converge its chip. Nothing is spoken — see
  * this section's header. */
 export declare const deliverLineReply: (line: number) => void;
+/** An unfinished background run is available to continue, without announcing
+ * success/failure or presenting its partial output as a new finished result. */
+export declare const deliverLineIncomplete: (line: number) => void;
 /**
  * A background line published an artifact: OPEN it on screen via `showTarget`
  * (agent-auto), mirroring chat.tsx's foreground auto-open effect exactly —

package/dist/i18n/messages/en.d.ts

@@ -6,6 +6,11 @@ export declare const en: {
         readonly shownByBelong: "Shown by Belong";
         readonly openedByYou: "You opened this";
         readonly planTitle: "Plan";
+        readonly subagentsFilterAll: "All {{count}}";
+        readonly subagentsFilterRunning: "Running {{count}}";
+        readonly subagentsFilterAttention: "Needs a look {{count}}";
+        readonly subagentsFilterDone: "Done {{count}}";
+        readonly subagentsOpen: "Open";
     };
     readonly usage: {
         readonly tooltip: "Auto-compacts at {{chars}} chars; {{tokens}} tokens used this session";
@@ -38,19 +43,26 @@ export declare const en: {
         readonly skillChip: "Skill: {{name}}";
         readonly failedSuffix: " — failed";
         readonly approvalRequired: "Approval required";
+        readonly approvalRequest: "Approval request";
+        readonly alwaysAllowCommands: "Always allow running commands";
+        readonly alwaysAllowNavigation: "Always allow opening pages";
         readonly approve: "Approve";
         readonly requestChanges: "Request changes";
         readonly reject: "Reject";
         readonly approving: "Approving…";
         readonly rejecting: "Rejecting…";
         readonly sending: "Sending…";
-        readonly decisionApproved: "approved";
-        readonly decisionRejected: "rejected";
-        readonly decisionAmendRequested: "amend requested";
-        readonly expired: "expired";
-        readonly alreadyResolved: "already resolved";
+        readonly decisionApproved: "Approved";
+        readonly decisionRejected: "Rejected";
+        readonly decisionAmendRequested: "Changes requested";
+        readonly expired: "Expired";
+        readonly alreadyResolved: "Already resolved";
         readonly alwaysAllowTool: "Always allow {{toolName}}";
         readonly alwaysAllowAction: "Always allow this action";
+        readonly approvalOpenPage: "Open this page";
+        readonly approvalRunCommand: "Run this command";
+        readonly expiredHint: "The wait timed out, so nothing ran";
+        readonly alreadyResolvedHint: "Answered somewhere else";
         readonly submitError: "That didn't go through — {{message}}. Try again.";
         readonly errorServerAnswered: "the server answered {{status}}";
         readonly errorRequestUnreachable: "the request didn't reach the server";
@@ -94,6 +106,18 @@ export declare const en: {
         readonly toolForgetDone: "Forgot a note";
         readonly toolForgetFailed: "Couldn't forget the note";
         readonly toolForgetDetail: "Deleted a saved note about you.";
+        readonly toolSaveSkillRunning: "Saving a skill";
+        readonly toolSaveSkillDone: "Saved a skill";
+        readonly toolSaveSkillFailed: "Couldn't save the skill";
+        readonly toolSaveSkillDetail: "Saved a skill to your Skills.";
+        readonly toolSetSkillEnabledRunning: "Updating a skill";
+        readonly toolSetSkillEnabledDone: "Updated a skill";
+        readonly toolSetSkillEnabledFailed: "Couldn't update the skill";
+        readonly toolSetSkillEnabledDetail: "Turned a skill on or off in your Skills.";
+        readonly toolListSkillLibraryRunning: "Checking your skills";
+        readonly toolListSkillLibraryDone: "Checked your skills";
+        readonly toolListSkillLibraryFailed: "Couldn't check your skills";
+        readonly toolListSkillLibraryDetail: "Looked through the skills in your Skills.";
         readonly browserSnapshot: "Took a snapshot";
         readonly browserRead: "Read the page";
         readonly browserClick: "Clicked an element";
@@ -109,6 +133,8 @@ export declare const en: {
         readonly actionWroteFile: "Updated a file";
         readonly actionPublishedArtifact: "Put a report on screen";
         readonly actionLookedUpSkill: "Looked up a skill";
+        readonly actionSavedSkill: "Saved a skill";
+        readonly actionUpdatedSkill: "Updated a skill";
         readonly actionSubTask: "Worked through a sub-task";
         readonly actionMadePlan: "Put a plan together";
         readonly actionCheckedRules: "Checked the rules";
@@ -118,13 +144,30 @@ export declare const en: {
         readonly executingTasks: "Working on it…";
         readonly workedSteps_one: "Worked · {{count}} step";
         readonly workedSteps_other: "Worked · {{count}} steps";
-        readonly subagentRunning: "Subagent · {{description}}…";
-        readonly subagentDone: "Subagent · {{description}}";
-        readonly subagentDoneSteps_one: "Subagent · {{description}} · {{count}} step";
-        readonly subagentDoneSteps_other: "Subagent · {{description}} · {{count}} steps";
-        readonly subagentFailed: "Subagent · {{description}} · didn't finish";
-        readonly subagentTimedOut: "Subagent · {{description}} · ran out of time";
-        readonly subagentVia: "via {{name}}";
+        readonly subagentWorkingCount_one: "Working on it… · {{done}} of {{count}} done";
+        readonly subagentWorkingCount_other: "Working on it… · {{done}} of {{count}} done";
+        readonly subagentWaveFallback_one: "{{count}} running";
+        readonly subagentWaveFallback_other: "{{count}} running";
+        readonly subagentWaveFallbackDone_one: "{{done}} of {{count}} done";
+        readonly subagentWaveFallbackDone_other: "{{done}} of {{count}} done";
+        readonly subagentWaveDone: "{{count}} done";
+        readonly subagentWaveRunning: "{{count}} running";
+        readonly subagentWaveQueued: "{{count}} waiting";
+        readonly subagentWaveNeedsLook: "{{count}} need a look";
+        readonly subagentWaveStopped: "{{count}} stopped";
+        readonly subagentOutcomeQueued: "Waiting to start";
+        readonly subagentOutcomeStopped: "Stopped by you";
+        readonly subagentOutcomeStalled: "Went quiet — Belong moved on";
+        readonly subagentOutcomeTimeout: "Took too long — Belong moved on";
+        readonly subagentOutcomeError: "Couldn't finish";
+        readonly subagentOutcomeInterrupted: "Picked up again";
+        readonly subagentOutcomeWaiting: "Waiting for you";
+        readonly subagentApprovalFor: "{{description}} needs your approval";
+        readonly subagentReport: "Report";
+        readonly subagentHideReport: "Hide report";
+        readonly subagentShowAll: "Show all {{count}}";
+        readonly subagentStopAll: "Stop all";
+        readonly subagentStopAllConfirm: "Stop {{count}}?";
         readonly cliAuthStop: {
             readonly noGrant: "Connect to Simetrik to continue";
             readonly reconnectFailed: "Couldn't connect to Simetrik";
@@ -132,6 +175,7 @@ export declare const en: {
             readonly reconnecting: "Reconnecting to Simetrik…";
         };
         readonly reconnectingBadge: "reconnecting";
+        readonly incompleteTask: "Paused — unfinished";
         readonly resumingAfterPause: "Taking longer than expected — picking it back up…";
         readonly open: "Open";
         readonly reconnectRateLimited: "{{provider}} is busy — trying again automatically in {{seconds}}s.";
@@ -153,6 +197,54 @@ export declare const en: {
         readonly exportThis: "Export this session (CSV)";
         readonly exportAll: "Export all sessions (CSV)";
     };
+    readonly skills: {
+        readonly viewTitle: "Skills";
+        readonly viewDescription: "Teach the assistant how you work. Turn a skill off to keep it without using it.";
+        readonly upload: "Upload";
+        readonly toggleAria: "Use {{name}}";
+        readonly menuAria: "More actions for {{name}}";
+        readonly hasScripts: "Has scripts";
+        readonly off: "Off";
+        readonly download: "Download";
+        readonly delete: "Delete";
+        readonly emptyTitle: "No skills yet";
+        readonly emptyHint: "Upload a skill someone shared with you, or ask the assistant to turn something you do often into a skill.";
+        readonly featureAbsent: "Skills aren't available here yet.";
+        readonly scopeMissing: "Open a workspace to see its skills.";
+        readonly loading: "Loading your skills…";
+        readonly loadError: "Couldn't load your skills.";
+        readonly retry: "Try again";
+        readonly noticeToggleFailed: "Couldn't update {{name}}. Try again.";
+        readonly noticeDeleteFailed: "Couldn't delete {{name}}. Try again.";
+        readonly noticeDownloadFailed: "Couldn't download {{name}}. Try again.";
+        readonly noticeGone: "That skill no longer exists.";
+        readonly uploadTitle: "Upload a skill";
+        readonly dropzone: "Drop a .zip or .skill file here";
+        readonly chooseFile: "or choose a file";
+        readonly trustLine: "Only upload skills from people you trust — some skills include scripts the assistant can run.";
+        readonly uploading: "Uploading…";
+        readonly cancel: "Cancel";
+        readonly submit: "Upload";
+        readonly replaceTitle: "You already have a skill named {{name}}. Replace it?";
+        readonly replaceConfirm: "Replace";
+        readonly successTitle: "Added {{name}}.";
+        readonly successOn: "It's on.";
+        readonly done: "Done";
+        readonly errorWrongType: "Choose a .zip or .skill file.";
+        readonly errorTooLarge: "This skill is too large (max {{maxMb}} MB).";
+        readonly errorCompanySkill: "{{name}} is already one of your company's skills.";
+        readonly errorBuiltIn: "{{name}} is a built-in name.";
+        readonly errorSavedPrompt: "{{name}} is the name of one of your saved prompts.";
+        readonly errorContentReserved: "This is one of your company's skills and can't be added to your Skills.";
+        readonly errorNameRule: "A skill's name can only use lowercase letters, numbers and hyphens.";
+        readonly errorNotSkill: "This file isn't a skill.";
+        readonly errorLimit: "You've reached the limit of {{max}} skills in this workspace.";
+        readonly errorFailed: "Couldn't upload this skill. Try again.";
+        readonly deleteTitle: "Delete this skill?";
+        readonly deleteDescription: "{{name}} will be removed, and the assistant will stop using it in this workspace.";
+        readonly deleteConfirm: "Delete";
+        readonly deleting: "Deleting…";
+    };
     readonly sessions: {
         readonly chats: "Chats";
         readonly newChat: "New chat";
@@ -345,10 +437,14 @@ export declare const en: {
     readonly header: {
         readonly byBelong: "by Belong";
         readonly navChat: "Chat";
+        readonly navGoal: "Goal";
+        readonly navGoalNeedsYou: "Goal — it needs you";
+        readonly navChatGoalNeedsYou: "Chat — the goal needs you";
         readonly navFiles: "Files";
         readonly navScheduled: "Scheduled";
         readonly navPrompts: "Prompts";
         readonly navConnectors: "Connectors";
+        readonly navSkills: "Skills";
         readonly chatPlanRunning: "Chat — plan running, {{completed}} of {{total}} steps done";
         readonly devMode: "Dev mode";
         readonly devModeTitle: "Dev mode (belong:dev)";
@@ -409,6 +505,27 @@ export declare const en: {
         readonly reasonPlaceholder: "What was off? (optional)";
         readonly skip: "Skip";
         readonly send: "Send";
+        readonly issueReport: {
+            readonly open: "Send feedback";
+            readonly title: "Send feedback";
+            readonly placeholder: "Describe the issue";
+            readonly includesWithShot: "This report includes a screenshot of the current screen and technical details of your session.";
+            readonly includesNoShot: "This report includes technical details of your session.";
+            readonly whatsIncluded: "What's included";
+            readonly includedIds: "Session and workspace ids";
+            readonly includedBuild: "Dock build, browser and window size";
+            readonly includedErrors: "The exact text of recent errors in this tab";
+            readonly includedUrl: "The page URL";
+            readonly removeScreenshot: "Remove screenshot";
+            readonly screenshotUnavailable: "Screenshot unavailable";
+            readonly screenshotRemoved: "You removed the screenshot — the report will send without it.";
+            readonly cancel: "Cancel";
+            readonly send: "Send";
+            readonly sending: "Sending…";
+            readonly failed: "Couldn't send the report. Try again.";
+            readonly failedScreenshot: "Couldn't send the report — the screenshot didn't go through. Try again without it.";
+            readonly reportThis: "Report this with a screenshot";
+        };
     };
     readonly embed: {
         readonly yourSkills: "Your skills";
@@ -803,6 +920,261 @@ export declare const en: {
         readonly alreadyStarted: "That schedule has already started and can no longer be cancelled.";
         readonly cancelError: "Couldn't cancel the schedule — try again.";
     };
+    readonly goal: {
+        readonly setGoalMenuItem: "Set a goal…";
+        readonly setGoalMenuDescription: "Keeps working on its own, turn after turn, until it is done.";
+        readonly usage: "Use /goal <objective> to start a goal, or /goal pause, /goal resume, /goal clear, /goal edit, /goal turns or /goal budget.";
+        readonly none: "There is no goal in this conversation. Start one with /goal <objective>.";
+        readonly paused: "Goal paused. Resume with /goal resume.";
+        readonly resumed: "Goal resumed — the assistant will pick it up now.";
+        readonly cleared: "Goal cleared.";
+        readonly notPausable: "The goal is not running right now.";
+        readonly notResumable: "The goal cannot be resumed from its current state.";
+        readonly notClearable: "The goal could not be cleared from its current state.";
+        readonly disabled: "Goals are not enabled for this workspace.";
+        readonly error: "Something went wrong with the goal. Try again.";
+        readonly refusal: {
+            readonly existsTitle: "This chat already has a goal.";
+            readonly existsBody: "One goal at a time — this one is still running.";
+            readonly existsOpen: "Open it";
+            readonly existsReplace: "Clear it and set this one";
+            readonly disabledTitle: "Goals aren't turned on here yet.";
+            readonly disabledBody: "Ask whoever set up Simetrik for your team.";
+            readonly capUserTitle: "You have {{limit}} goals running — that's the most at once.";
+            readonly capUserBody: "Finish or clear one, then set this one.";
+            readonly capTenantTitle: "Your workspace is running as many goals as it can right now.";
+            readonly capTenantBody: "Try again once one finishes.";
+            readonly keepText: "Keep the text";
+            readonly planTitle: "Plan mode only proposes.";
+            readonly planRunAuto: "Run on Auto";
+            readonly notSent: "Not sent.";
+            readonly tryAgain: "Try again";
+            readonly dismiss: "Got it";
+        };
+        readonly edited: "Goal updated.";
+        readonly revived: "Goal updated and resumed — the assistant will pick it up now.";
+        readonly notEditable: "The goal can no longer be edited.";
+        readonly editUsage: "Use /goal edit <objective>, /goal turns <number> or /goal budget <tokens>.";
+        readonly status: "Goal · {{status}} · turn {{turnsUsed}} of {{maxTurns}} — {{objective}}";
+        readonly statusLabel: {
+            readonly clarifying: "setting up";
+            readonly active: "working";
+            readonly completionClaimed: "checking";
+            readonly paused: "paused";
+            readonly deferred: "waiting for a time";
+            readonly waitingForUser: "needs you";
+            readonly waitingForApproval: "needs you";
+            readonly waitingForUiAction: "needs you";
+            readonly blocked: "stopped";
+            readonly budgetLimited: "reached its limit";
+            readonly complete: "done";
+            readonly cleared: "cleared";
+        };
+        readonly badge: {
+            readonly pill: "Goal · {{label}}";
+            readonly pillResumes: "Goal · resumes {{time}}";
+            readonly pillLabel: "Goal, {{status}}, {{objective}} — open details";
+            readonly met: "met";
+            readonly open: "open";
+            readonly journalKind: {
+                readonly created: "Goal started";
+                readonly clarified: "Goal written down";
+                readonly progress: "Progress";
+                readonly verdict: "Reviewed";
+                readonly edited: "Edited";
+                readonly deferred: "Went to sleep";
+                readonly turn: "Turn";
+                readonly transition: "Updated";
+                readonly notified: "Emailed";
+                readonly noProgress: "No progress";
+                readonly verifiedWait: "Waiting on something outside the agent";
+                readonly other: "Updated";
+            };
+        };
+        readonly units: {
+            readonly justStarted: "just started";
+            readonly minutes: "{{minutes}}m";
+            readonly hoursMinutes: "{{hours}}h {{minutes}}m";
+            readonly day: "{{days}} day";
+            readonly days: "{{days}} days";
+            readonly turnsOf: "turn {{used}} of {{max}}";
+            readonly turnsLeft: "{{left}} turns left";
+        };
+        readonly progress: {
+            readonly line: "About {{percent}}% of its budget · {{used}} of {{max}} turns · running {{running}} min";
+            readonly barely: "Barely started · {{used}} of {{max}} turns";
+            readonly almostOut: "Almost out of room · {{used}} of {{max}} turns";
+            readonly showExact: "Show exact figures";
+            readonly hideExact: "Hide exact figures";
+            readonly exact: "{{tokensUsed}} of {{tokenBudget}} tokens · {{activeMinutes}} of {{maxMinutes}} min";
+        };
+        readonly view: {
+            readonly title: "Goal · {{status}}";
+            readonly objective: "Objective";
+            readonly progress: "Progress";
+            readonly criteria: "Success criteria";
+            readonly criteriaCount: "{{met}} of {{total}} met";
+            readonly lastStep: "Last step";
+            readonly history: "History";
+            readonly today: "Today";
+            readonly yesterday: "Yesterday";
+            readonly more: "more";
+            readonly historyFooter: "Showing the last 10 updates.";
+            readonly reviewer: "Reviewer feedback";
+            readonly empty: "No goal in this conversation.";
+            readonly editObjective: "Change what it should get done";
+            readonly save: "Save";
+            readonly cancel: "Cancel";
+            readonly lockedWhileChecking: "Locked while it checks the work";
+            readonly finished: "Finished in {{elapsed}} · {{met}} of {{total}} criteria met";
+            readonly lastStepElapsed: {
+                readonly justStarted: "just now";
+                readonly minutes: "{{minutes}} min ago";
+                readonly hoursMinutes: "{{hours}}h {{minutes}}m ago";
+                readonly days: "{{days}}d ago";
+            };
+        };
+        readonly proposal: {
+            readonly heading: "Suggested goal";
+            readonly confirm: "Start this goal";
+            readonly dismiss: "Not now";
+            readonly edit: "Edit first";
+            readonly runway: "{{preset}} runway · {{detail}} each time";
+            readonly dismissed: "Suggested goal — not now";
+            readonly started: "Started this goal";
+            readonly startedOpen: "Open it";
+        };
+        readonly sentAsGoal: "Sent as goal";
+        readonly actions: {
+            readonly pause: "Pause";
+            readonly resume: "Resume";
+            readonly wakeNow: "Wake now";
+            readonly edit: "Edit…";
+            readonly clear: "Clear";
+            readonly clearTitle: "Clear this goal?";
+            readonly clearBody: "The conversation stays. The goal and its history go.";
+            readonly clearConfirm: "Clear this goal";
+            readonly clearKeep: "Keep it";
+            readonly failedPause: "Couldn't pause the goal. Try again.";
+            readonly failedResume: "Couldn't pick the goal back up. Try again.";
+            readonly failedClear: "Couldn't clear the goal. Try again.";
+            readonly snooze: "Snooze";
+            readonly snooze30m: "30 minutes";
+            readonly snooze2h: "2 hours";
+            readonly snoozeTomorrow: "Tomorrow 9:00";
+            readonly failedSnooze: "Couldn't snooze the goal. Try again.";
+        };
+        readonly row: {
+            readonly headline: {
+                readonly clarifying: "Setting up the goal";
+                readonly active: "Working on your goal";
+                readonly checking: "Checking the work";
+                readonly paused: "Paused";
+                readonly stopped: "Stopped — it needs a nudge";
+            };
+            readonly detail: {
+                readonly clarifying: "Question {{index}} of {{total}}";
+                readonly live: "{{elapsed}} · turn {{used}} of {{max}}";
+                readonly liveTight: "{{elapsed}} · turn {{used}} of {{max}} · {{left}} turns left";
+                readonly paused: "{{used}} of {{max}} turns used";
+                readonly pausedElapsed: "{{used}} of {{max}} turns used · {{elapsed}} so far";
+            };
+            readonly action: {
+                readonly details: "Details";
+                readonly cancelSetup: "Cancel setup";
+            };
+            readonly srStatus: "Goal: {{headline}}. {{detail}}.";
+            readonly srStatusBrief: "Goal: {{headline}}.";
+        };
+        readonly needs: {
+            readonly question: {
+                readonly headline: "Waiting for your answer";
+                readonly detail: "Paused here until you reply";
+                readonly primary: "Answer";
+            };
+            readonly approval: {
+                readonly headline: "Waiting for your approval";
+                readonly detail: "Nothing runs until you decide";
+                readonly primary: "Review the step";
+            };
+            readonly page: {
+                readonly headline: "Waiting for something on the page";
+                readonly detail: "Finish it on the page, or tell it another way forward";
+                readonly primary: "Show me what's needed";
+            };
+            readonly sleeping: {
+                readonly headline: "Sleeping until {{time}}";
+                readonly detail: "It picks itself back up on its own";
+            };
+            readonly blocked: {
+                readonly noProgress: "Several turns with no new progress";
+                readonly errors: "Its last few attempts didn't work";
+                readonly permission: "It can't reach Simetrik right now. It reconnects on its own — this is only if it can't.";
+                readonly review: "The completion check keeps coming back with something missing";
+                readonly generic: "It stopped and needs a new direction";
+                readonly primary: "Tell it what to try";
+            };
+            readonly limit: {
+                readonly turnsHeadline: "Out of turns";
+                readonly turnsDetail: "Used all {{max}} turns";
+                readonly roomHeadline: "Out of room";
+                readonly roomDetail: "Used all the room you gave it";
+                readonly timeHeadline: "Out of time";
+                readonly timeDetail: "Ran for as long as it was allowed";
+                readonly primary: "Give it more";
+                readonly newGoal: "Start a new goal";
+                readonly newGoalHint: "Say what the new goal should get done…";
+            };
+            readonly composerHint: "Tell it what to try instead…";
+        };
+        readonly setup: {
+            readonly chip: "Setting up · question {{index}} of {{total}}";
+        };
+        readonly setCard: {
+            readonly heading: "Goal set";
+            readonly doneWhen: "I'll call it done when";
+            readonly runway: "{{preset}} runway · {{detail}}";
+            readonly runwayPlain: "About {{steps}} steps, up to {{days}} days";
+            readonly runwayPlainOneDay: "About {{steps}} steps, up to {{days}} day";
+        };
+        readonly compose: {
+            readonly title: "Set a goal";
+            readonly objectiveLabel: "What should it get done?";
+            readonly objectivePlaceholder: "e.g. Each month, reconcile the TSYS settlement file against our ledger and send me the differences.";
+            readonly criteriaLabel: "Done when…";
+            readonly criteriaOptional: "optional";
+            readonly criteriaAdd: "Add another";
+            readonly criteriaHint: "Leave this empty and it will ask you a few questions first.";
+            readonly criterionLabel: "Done when, criterion {{index}}";
+            readonly runwayLabel: "How much runway";
+            readonly runwayQuick: "Quick";
+            readonly runwayNormal: "Normal";
+            readonly runwayLong: "Long";
+            readonly runwayQuickDetail: "about 25 steps, up to a day";
+            readonly runwayNormalDetail: "about 60 steps, up to 3 days";
+            readonly runwayLongDetail: "about 200 steps, up to a week";
+            readonly modeLabel: "How it should work";
+            readonly planModeNotice: "Plan mode only proposes. This goal will run on Auto.";
+            readonly cancel: "Cancel";
+            readonly submit: "Set goal";
+            readonly submitEdit: "Save changes";
+            readonly editTitle: "Change this goal";
+        };
+        readonly ending: {
+            readonly heading: "Goal achieved";
+            readonly finished: "Finished in {{elapsed}} · {{steps}} steps";
+            readonly finishedOneStep: "Finished in {{elapsed}} · 1 step";
+            readonly finishedFast: "Finished in under a minute · {{steps}} steps";
+            readonly finishedFastOneStep: "Finished in under a minute · 1 step";
+            readonly schedule: "Run this again on a schedule";
+            readonly scheduleDaily: "Run this again every day";
+            readonly scheduleWeekly: "Run this again every week";
+            readonly scheduleMonthly: "Run this again every month";
+            readonly getFiles: "Get the files";
+            readonly another: "Set another goal";
+            readonly cleared: "Goal cleared · {{time}}";
+        };
+    };
     readonly voiceOverlay: {
         readonly startingMic: "Starting mic…";
         readonly listening: "Listening…";
@@ -886,7 +1258,7 @@ export declare const en: {
         readonly notDelivered: "Not delivered — please resend";
         readonly runFailed: "Run failed";
         readonly uploadFailed: "Attachment upload failed — remove it or try again.";
-        readonly uploadRejectedType: "“{{filename}}” isn’t a file type the assistant can read — remove it. Text, data, config, code, document and image files work; archives and compiled binaries don’t.";
+        readonly uploadRejectedType: "“{{filename}}” isn’t a file type that can be attached — remove it. Text, data, config, code, document and image files work.";
         readonly uploadRejectedSecret: "“{{filename}}” looks like an environment/secrets file — it can’t be attached. Remove it and paste only the values you need.";
         readonly authExpired: "Your session expired — please sign in to {{name}} again, then retry.";
         readonly backendUnavailable: "Can't reach the assistant service — check your connection.";

package/dist/i18n/messages/it.d.ts

@@ -0,0 +1,3 @@
+import { EnMessages } from './en.ts';
+import { LocaleMessages } from './types.ts';
+export declare const it: LocaleMessages<EnMessages>;

package/dist/i18n/messages/surfaces/aiElements.d.ts

@@ -155,3 +155,55 @@ export declare const aiElementsPt: {
         branchPage: string;
     };
 };
+export declare const aiElementsIt: {
+    aiElements: {
+        statusAwaitingApproval: string;
+        statusResponded: string;
+        statusRunning: string;
+        statusPending: string;
+        statusCompleted: string;
+        statusDenied: string;
+        statusError: string;
+        toolParameters: string;
+        toolError: string;
+        toolResult: string;
+        thinking: string;
+        thoughtForAFewSeconds: string;
+        thoughtForSeconds: string;
+        addPhotosOrFiles: string;
+        takeScreenshot: string;
+        errorNoFilesMatch: string;
+        errorFilesExceedSize: string;
+        errorTooManyFiles: string;
+        textareaPlaceholder: string;
+        uploadFiles: string;
+        stop: string;
+        submit: string;
+        attachmentSource: string;
+        attachmentImage: string;
+        attachmentFallback: string;
+        remove: string;
+        noAttachments: string;
+        noMessagesYet: string;
+        startConversation: string;
+        copy: string;
+        copied: string;
+        openExternalLink: string;
+        openInAppLink: string;
+        openLinkDescriptionPrefix: string;
+        openLinkDescriptionSuffix: string;
+        cancel: string;
+        openLink: string;
+        terminalDone: string;
+        terminalExitOk: string;
+        terminalExitCode: string;
+        terminalFailed: string;
+        terminalRunning: string;
+        terminalStillRunning: string;
+        copyCommand: string;
+        waitingForOutput: string;
+        previousBranch: string;
+        nextBranch: string;
+        branchPage: string;
+    };
+};

package/dist/i18n/messages/surfaces/app.d.ts

@@ -53,3 +53,21 @@ export declare const appPt: {
         navCall: string;
     };
 };
+export declare const appIt: {
+    app: {
+        uploadNoWorkspace: string;
+        uploadTooLarge: string;
+        uploadFailed: string;
+        sentFilesOne: string;
+        sentFilesOther: string;
+        uploadAriaLabel: string;
+        uploading: string;
+        dropFiles: string;
+        supportsFormats: string;
+        viewTitleFiles: string;
+        resizeChat: string;
+        openAssistant: string;
+        closeAssistant: string;
+        navCall: string;
+    };
+};