@belonguniverseai/react-sdk 0.6.26 → 0.6.28

package/dist/components/embed/UsageSettings.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Settings → Usage (plan 018): the signed-in user's own consumption, in
+ * weighted tokens — month-to-date, today, and a 30-day daily strip.
+ *
+ * One unit only. The raw input / output / cache counts never reach the dock
+ * (`GET /v1/usage` does not send them). Days are UTC days, and the view says so.
+ * Quiet by design (§42): primary-coloured bars, muted text, no red. A load
+ * failure is one muted line with a retry, and a cloud that predates the route
+ * says "not available yet" instead of failing.
+ */
+export declare const UsageSettings: () => import("react").JSX.Element;

package/dist/components/embed/WorkspacePolicySetting.d.ts

@@ -0,0 +1 @@
+export declare function WorkspacePolicySetting(): import("react").JSX.Element;

package/dist/components/embed/format-compact-number.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Locale-aware compact numbers for the Usage view (plan 018): "1.3M" in
+ * English, "1,3 M" in Spanish — `formatTokens` predates the dock's locales and
+ * always writes "." and "k". One formatter per locale, built once.
+ */
+export declare const formatCompactNumber: (value: number, locale: string) => string;
+/** A full, grouped number for tooltips and screen readers: "1,250,000". */
+export declare const formatWholeNumber: (value: number, locale: string) => string;

package/dist/components/embed/use-artifact-operation-notices.d.ts

@@ -0,0 +1,20 @@
+import { ArtifactOperation } from '@belong/codec/artifact-actions';
+import { ArtifactActionApi } from '../../api/artifact-actions.ts';
+import { ArtifactOperationSighting } from '../../embed/artifact-action-bridge.ts';
+import { ArtifactOperationNotice } from '../../embed/artifact-operation-notices.ts';
+/** Re-read invocations that hold the sandbox at most this often (nothing else may be reading). */
+export declare const ARTIFACT_HOLD_REFRESH_MS = 15000;
+export declare const useArtifactOperationNotices: (input: {
+    /** Null when this preview has no actions. A new API (new artifact or workspace) starts over. */
+    readonly api: ArtifactActionApi | null;
+    /**
+     * Starts the dock's automatic Simetrik reconnect, or returns null when this view has no grant
+     * scope to reconnect.
+     */
+    readonly reconnect: (reconnectId: string) => Promise<void> | null;
+}) => {
+    readonly notice: ArtifactOperationNotice;
+    readonly onOperation: (operation: ArtifactOperation, sighting: ArtifactOperationSighting) => void;
+    readonly onReconnectRequired: (reconnectId: string) => void;
+    readonly stop: () => void;
+};

package/dist/components/embed/use-inline-preview-url.d.ts

@@ -16,5 +16,7 @@ export type InlinePreviewUrl = {
 } | {
     readonly status: "ready";
     readonly url: string;
+    readonly actionEnabled?: boolean;
+    readonly actionBridgeKey?: string;
 };
-export declare const useInlinePreviewUrl: (target: InlinePreviewTarget | null) => InlinePreviewUrl;
+export declare const useInlinePreviewUrl: (target: InlinePreviewTarget | null, remintSeq?: number) => InlinePreviewUrl;

package/dist/components/scheduled/ScheduledDetailSurface.d.ts

@@ -2,10 +2,19 @@ import { TaskScheduleDetail, TaskScheduleRun } from '../../api/task-schedules.ts
 export declare const EmailNotificationIndicator: (props: {
     readonly notification: TaskScheduleDetail["notification"];
     readonly shared?: boolean;
+    readonly sharedRecipients?: readonly string[] | undefined;
 }) => import("react").JSX.Element;
 export declare const MicrosoftTeamsDeliveryIndicator: (props: {
     readonly delivery: NonNullable<TaskScheduleDetail["microsoftTeamsDelivery"]>;
 }) => import("react").JSX.Element;
+/**
+ * #655: the stable SERIES id integrations use to trigger a schedule. It exists
+ * from creation, so it shows for manual and paused schedules before any
+ * occurrence or execution id does. Copying is read-only — it never runs work.
+ */
+export declare const ScheduleIdField: (props: {
+    readonly taskScheduleId: string;
+}) => import("react").JSX.Element;
 export declare const RunCard: (props: {
     readonly run: TaskScheduleRun;
     readonly scheduleTitle: string;

package/dist/embed/artifact-action-bridge.d.ts

@@ -0,0 +1,70 @@
+import { ArtifactOperation, ArtifactReview } from '@belong/codec/artifact-actions';
+import { ArtifactBridgeApi } from '../api/artifact-actions.ts';
+export type ArtifactApprovalRequest = {
+    readonly operation: ArtifactOperation;
+    readonly review: ArtifactReview;
+};
+export type ArtifactActionBridge = {
+    onLoad: () => void;
+    dispose: () => void;
+};
+/**
+ * Why a bridge asks its owner for a fresh preview mint (new token, new document key, new frame):
+ * `navigation` — a second document loaded in the frame (the report reloaded or navigated itself);
+ * `stale` — the bridge was created for a frame that already loaded, or for a key already spent.
+ */
+export type ArtifactRemintReason = "navigation" | "stale";
+/**
+ * How the parent learned a snapshot: `transition` = it just changed in front of this view (a
+ * submission, an approval decision, an observed status read); `snapshot` = a current read the
+ * report asked for (get, list, observe's first answer, cancel).
+ */
+export type ArtifactOperationSighting = "transition" | "snapshot";
+/** Report requests admitted per window, across every bridge one preview view creates. */
+export declare const ARTIFACT_REQUESTS_PER_WINDOW = 60;
+export declare const ARTIFACT_REQUEST_WINDOW_MS = 60000;
+export type ArtifactRequestWindow = {
+    readonly admit: (nowMs: number) => boolean;
+};
+/** Fixed window. Owned by the preview view, so neither a reload nor a re-mint refills it. */
+export declare const createArtifactRequestWindow: () => ArtifactRequestWindow;
+export declare const ARTIFACT_POLL_BASE_MS = 2000;
+/** Ceilings while a status stays the same. Running work changes sooner than work that waits. */
+export declare const ARTIFACT_POLL_RUNNING_MAX_MS = 15000;
+export declare const ARTIFACT_POLL_WAITING_MAX_MS = 30000;
+type PolledStatus = ArtifactOperation["status"];
+/**
+ * Delay before the next status read. A new status starts again at 2 s; the same pending status
+ * backs off by half each read (running up to 15 s, queued/approval up to 30 s); an unsettled
+ * unknown outcome or a failed read doubles up to 30 s.
+ */
+export declare const nextArtifactPollDelayMs: (previous: {
+    readonly delayMs: number;
+    readonly status: PolledStatus | null;
+}, read: PolledStatus | "read_failed") => number;
+/**
+ * One bridge per minted preview document. Opaque origins require the exact frame source, a single
+ * challenge sent on the frame's FIRST load, and the minted document key; origin "null" is never an
+ * authority. The first document is the one the parent navigated the frame to; any later load is a
+ * document the report chose (reload or navigation), so the bridge retires and asks for a re-mint
+ * rather than offering that document a channel.
+ */
+export declare const createArtifactActionBridge: (input: {
+    readonly frame: HTMLIFrameElement;
+    readonly artifactId: string;
+    readonly documentKey: string;
+    readonly api: ArtifactBridgeApi;
+    readonly currentScopeKey: () => string;
+    readonly onApproval: (request: ArtifactApprovalRequest, signal: AbortSignal) => Promise<"approved" | "rejected">;
+    readonly onRemint: (reason: ArtifactRemintReason) => void;
+    /** Every validated snapshot this bridge received, for trusted parent UI (never the report). */
+    readonly onOperation?: (operation: ArtifactOperation, sighting: ArtifactOperationSighting) => void;
+    /** An authenticated API refusal needs connection repair; never a report-requested method. */
+    readonly onReconnectRequired?: (reconnectId: string) => void;
+    /** The frame already finished a load before this bridge existed: its document is unknown. */
+    readonly frameAlreadyLoaded?: boolean;
+    readonly requestWindow?: ArtifactRequestWindow;
+    readonly eventTarget?: Window;
+    readonly nowMs?: () => number;
+}) => ArtifactActionBridge;
+export {};

package/dist/embed/artifact-operation-notices.d.ts

@@ -0,0 +1,45 @@
+import { ArtifactOperation } from '@belong/codec/artifact-actions';
+import { ArtifactOperationSighting } from './artifact-action-bridge.ts';
+export declare const CLI_RECONNECT_REQUIRED = "cli_reconnect_required";
+export type TrackedArtifactOperation = {
+    readonly operation: ArtifactOperation;
+    readonly receivedAtMs: number;
+    /** This view saw it change (a transition) or saw it unsettled: its outcome is news here. */
+    readonly seenLive: boolean;
+};
+export type TrackedArtifactOperations = ReadonlyMap<string, TrackedArtifactOperation>;
+/** Latest snapshot wins; an older read finishing late never replaces a newer one. */
+export declare const trackArtifactOperation: (tracked: TrackedArtifactOperations, operation: ArtifactOperation, sighting: ArtifactOperationSighting, nowMs: number) => TrackedArtifactOperations;
+/**
+ * Launched, no positive stop evidence, and no longer running normally (its outcome is in, or it is
+ * unknown): the user's agent work waits for it, so the parent offers to stop it.
+ */
+export declare const awaitsArtifactStop: (operation: ArtifactOperation) => boolean;
+export declare const artifactOperationsAwaitingStop: (tracked: TrackedArtifactOperations) => readonly ArtifactOperation[];
+/**
+ * The newest invocation of some action was released without proof it stopped. Older ones are
+ * history: a later run of the same action already superseded them.
+ */
+export declare const latestReleasedUnconfirmed: (tracked: TrackedArtifactOperations) => boolean;
+/** A reconnect is due for an operation this view watched fail on the Simetrik connection. */
+export declare const needsArtifactReconnect: (entry: TrackedArtifactOperation) => boolean;
+export type ArtifactStopState = "idle" | "stopping" | "unreachable";
+export type ArtifactReconnectState = "idle" | "reconnecting" | "failed";
+export type ArtifactOperationNotice = {
+    readonly kind: "none";
+} | {
+    readonly kind: "awaiting_stop";
+    readonly stop: ArtifactStopState;
+} | {
+    readonly kind: "reconnecting";
+} | {
+    readonly kind: "reconnect_failed";
+} | {
+    readonly kind: "released_unconfirmed";
+};
+/** One line at most, most actionable first. */
+export declare const artifactOperationNotice: (input: {
+    readonly tracked: TrackedArtifactOperations;
+    readonly stop: ArtifactStopState;
+    readonly reconnect: ArtifactReconnectState;
+}) => ArtifactOperationNotice;

package/dist/embed/artifact-remint-budget.d.ts

@@ -0,0 +1,19 @@
+/**
+ * How often one action-enabled preview view re-mints after its report reloads or navigates
+ * itself. Each re-mint reloads the real report with a fresh document key; a report that keeps
+ * doing it (a `location.reload()` loop, or a page that bounces the frame) must not mint forever,
+ * so after the window's allowance the view shows a static state instead.
+ */
+export declare const ARTIFACT_SELF_RELOAD_WINDOW_MS = 60000;
+/** Delay before each successive re-mint inside one window. Its length is the per-window cap. */
+export declare const ARTIFACT_REMINT_BACKOFF_MS: readonly number[];
+export type ArtifactRemintDecision = {
+    readonly kind: "remint";
+    readonly delayMs: number;
+} | {
+    readonly kind: "exhausted";
+};
+export type ArtifactRemintBudget = {
+    readonly next: (nowMs: number) => ArtifactRemintDecision;
+};
+export declare const createArtifactRemintBudget: () => ArtifactRemintBudget;

package/dist/embed/artifact-sandbox-hold.d.ts

@@ -0,0 +1,10 @@
+import { ArtifactOperation } from '@belong/codec/artifact-actions';
+/** Running work owns the sandbox; launched work without stop evidence still fences it. */
+export declare const holdsArtifactSandbox: (operation: Pick<ArtifactOperation, "status" | "stopEvidence">) => boolean;
+/** One slot per preview view; `set` replaces that view's answer, `release` withdraws it. */
+export declare const registerArtifactSandboxHoldSlot: () => {
+    readonly set: (holding: boolean) => void;
+    readonly release: () => void;
+};
+export declare const peekArtifactSandboxHeld: () => boolean;
+export declare const subscribeArtifactSandboxHold: (listener: () => void) => (() => void);

package/dist/embed/dock-state.d.ts

@@ -5,7 +5,7 @@
  * in the stream-state store; this module owns only view + size. Best-effort:
  * disabled/quota'd storage just means no cross-reload restore.
  */
-export type DockView = "chat" | "goal" | "files" | "scheduled" | "prompts" | "connectors" | "skills";
+export type DockView = "chat" | "goal" | "files" | "scheduled" | "prompts" | "connectors" | "skills" | "artifacts";
 export type DockSize = "collapsed" | "expanded" | "fullscreen";
 export type DockState = {
     readonly view: DockView;

package/dist/embed/global.d.ts

@@ -1,4 +1,6 @@
 import { BelongGlobal, BelongInitInput, RouteHandler, UiActionHandler } from '../types/public.ts';
+/** Release listeners and invalidate pending theme reads when an embed leaves. */
+export declare const stopTenantThemeRefresh: () => void;
 type AgentGrantConfig = {
     readonly provider: string;
     readonly scopeExternalId: string | null;

package/dist/embed/goal-row-model.d.ts

@@ -1,7 +1,7 @@
 import { GoalElapsed } from './goal-plain-units.ts';
 import { GoalView } from '../api/goals.ts';
 export type GoalRowTone = "live" | "calm" | "attention";
-export type GoalRowActionKind = "cancel_setup" | "pause" | "resume" | "wake_now" | "details" | "answer" | "review" | "show_me" | "tell_it" | "give_it_more" | "new_goal";
+export type GoalRowActionKind = "cancel_setup" | "pause" | "resume" | "wake_now" | "details" | "answer" | "review" | "show_me" | "tell_it" | "give_it_more" | "new_goal" | "exit_goal";
 export type GoalRowAction = {
     readonly kind: GoalRowActionKind;
     readonly labelKey: string;

package/dist/embed/presets.d.ts

@@ -6,6 +6,7 @@ export declare const PRESET_NAME_SCHEMA: z.ZodEnum<{
     custom: "custom";
     belong: "belong";
     simetrik: "simetrik";
+    tenant: "tenant";
 }>;
 export declare const BELONG_LIGHT_PALETTE: BelongThemePalette;
 export declare const BELONG_DARK_PALETTE: BelongThemePalette;

package/dist/embed/response-mode.d.ts

@@ -0,0 +1,48 @@
+/**
+ * The composer's RESPONSE MODE — Fast / Balanced / Smart on a three-stop
+ * slider (the Codex app's dial). Every mode is named for its upside: a person
+ * picks what they want more of, never "less" of anything.
+ *
+ *   fast     → quick answers for simple requests
+ *   balanced → everyday work
+ *   smart    → the most capable, for complex multi-step work (the default)
+ *
+ * The dock only ever names a MODE. Which model a mode buys is the backend's
+ * call (`response-mode-model.ts`), so no model name ever reaches a customer.
+ *
+ * "Never picked" is NOT "picked Smart". Until a person picks a mode the dial
+ * shows Smart but the dock sends no mode at all, so the deployment decides:
+ * its own model today, or the intention model switch where that is enabled. A
+ * pick — Smart included — is the person's choice, sent with every message and
+ * outranking the switch.
+ *
+ * A personal preference, not a per-conversation one: the mode a person last
+ * picked carries into new chats, the way other assistants remember your last
+ * choice. Persisted best-effort to localStorage (zod-validated at the storage
+ * perimeter); private mode, disabled storage or a junk value read as "never
+ * picked". The transport stamps the pick on every send (beside the locale),
+ * and the backend keeps it durable on the message, so a continuation after a
+ * reload still runs in the mode the person chose.
+ */
+/** Fastest first — the slider's stops, left to right. */
+export declare const RESPONSE_MODES: readonly ["fast", "balanced", "smart"];
+export type ResponseMode = (typeof RESPONSE_MODES)[number];
+/** What the dial shows before a person picks: the deployment's own model. */
+export declare const DEFAULT_RESPONSE_MODE: ResponseMode;
+/** Narrow an untrusted value (storage, a slider position's lookup) to a mode. */
+export declare const parseResponseMode: (value: unknown) => ResponseMode | null;
+/** The mode the person picked, or null when they never did — sends carry a mode only then. */
+export declare const peekResponseModePick: () => ResponseMode | null;
+/** The mode the dial shows: the person's pick, else the default. */
+export declare const peekResponseMode: () => ResponseMode;
+export declare const subscribeResponseMode: (listener: () => void) => (() => void);
+/** Pick `mode` — Smart included — and remember it for this browser. */
+export declare const writeResponseMode: (mode: ResponseMode) => void;
+/** Test-only: back to a browser that never picked a mode. */
+export declare const __resetResponseModeForTest: () => void;
+/** The current mode, re-rendering on change. */
+export declare const useResponseMode: () => ResponseMode;
+/** Ask the API once whether it offers the dial (repeat calls are no-ops). */
+export declare const askResponseModesAvailability: (apiBaseUrl: string) => void;
+/** Whether the composer should show the dial for this API (the shell asked). */
+export declare const useResponseModesAvailable: (apiBaseUrl: string) => boolean;

package/dist/embed/theme.d.ts

@@ -4,6 +4,11 @@ export declare const DEFAULT_THEME: BelongTheme;
 export declare const peekTheme: () => BelongTheme;
 export declare const subscribeTheme: (listener: () => void) => (() => void);
 export declare const setTheme: (partial: PartialBelongTheme) => void;
+/** Start a branding scope. Old global prefs cannot override a tenant's default. */
+export declare const configureTenantTheme: (scope: string, inline?: PartialBelongTheme) => void;
+/** Refresh the baseline even while a user-selected style is active. No writes
+ * to local preferences: only explicit user/host overrides are persisted. */
+export declare const setPublishedTenantTheme: (partial: PartialBelongTheme | null) => void;
 /** Switch the active theme style. Built-in presets render their pure palette;
  *  the Custom style overlays the user's accent/cssVars stash. */
 export declare const applyPreset: (name: PresetName) => void;

package/dist/embed/workspace-policy.d.ts

@@ -0,0 +1,7 @@
+export declare const peekWorkspacePolicy: () => "open" | "strict";
+/** Report storage failure so the UI never claims a preference was saved when it wasn't. */
+export declare const setWorkspacePolicy: (policy: "open" | "strict") => boolean;
+export declare const useWorkspacePolicy: () => {
+    policy: string;
+    identified: boolean;
+};

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

@@ -21,7 +21,6 @@ export declare const en: {
         readonly closeContext: "Close context";
         readonly currentPage: "Current page";
         readonly windowTooltip: "Context window: {{used}} of {{window}} tokens used ({{pct}}%)";
-        readonly inOut: "Input {{in}} · output {{out}}";
         readonly turnsThisSessionOne: "{{count}} turn this session";
         readonly turnsThisSessionOther: "{{count}} turns this session";
         readonly panel: {
@@ -35,7 +34,6 @@ export declare const en: {
             };
             readonly freeSpace: "Free space";
             readonly estimateNote: "Breakdown is estimated; the total is as reported by the model.";
-            readonly cacheLine: "Cache: {{read}} read · {{write}} written";
             readonly autoCompact: "Auto-compact: {{pct}}% of budget";
         };
         readonly compactionLabel: "Auto-compact: {{used}} of {{limit}} characters used ({{pct}}%)";
@@ -113,6 +111,35 @@ 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 toolUsageRunning: "Checking your usage";
+        readonly toolUsageDone: "Checked your usage";
+        readonly toolUsageFailed: "Couldn't check your usage";
+        readonly toolUsageDetail: "Looked up how many tokens you've used.";
+        readonly toolCheckBackgroundRunning: "Checking a background command";
+        readonly toolCheckBackgroundDone: "Checked a background command";
+        readonly toolCheckBackgroundFailed: "Couldn't check the background command";
+        readonly toolCheckBackgroundDetail: "Read what a command running in the background wrote.";
+        readonly toolWaitBackgroundRunning: "Waiting for a background command";
+        readonly toolWaitBackgroundDone: "Waited for a background command";
+        readonly toolWaitBackgroundFailed: "Couldn't wait for the background command";
+        readonly toolWaitBackgroundDetail: "Waited for a command running in the background to finish.";
+        readonly toolStopBackgroundRunning: "Stopping a background command";
+        readonly toolStopBackgroundDone: "Stopped a background command";
+        readonly toolStopBackgroundFailed: "Couldn't stop the background command";
+        readonly toolStopBackgroundDetail: "Stopped a command that was running in the background.";
+        readonly toolReadFileRunning: "Reading {{file}}";
+        readonly toolReadFileDone: "Read {{file}}";
+        readonly toolReadFileFailed: "Couldn't read {{file}}";
+        readonly toolReadFileDetail: "Read {{path}}.";
+        readonly toolWriteFileRunning: "Writing {{file}}";
+        readonly toolWriteFileDone: "Wrote {{file}}";
+        readonly toolWriteFileFailed: "Couldn't write {{file}}";
+        readonly toolWriteFileDetail: "Wrote {{path}}.";
+        readonly toolEditFileRunning: "Editing {{file}}";
+        readonly toolEditFileDone: "Edited {{file}}";
+        readonly toolEditFileFailed: "Couldn't edit {{file}}";
+        readonly toolEditFileDetail: "Edited {{path}}.";
+        readonly toolFileUnnamed: "a file";
         readonly toolSaveSkillRunning: "Saving a skill";
         readonly toolSaveSkillDone: "Saved a skill";
         readonly toolSaveSkillFailed: "Couldn't save the skill";
@@ -137,6 +164,7 @@ export declare const en: {
         readonly browserRefreshView: "Refreshed the page";
         readonly failedBadge: "failed";
         readonly actionReadFile: "Read a file";
+        readonly actionCheckedUsage: "Checked your usage";
         readonly actionWroteFile: "Updated a file";
         readonly actionPublishedArtifact: "Put a report on screen";
         readonly actionLookedUpSkill: "Looked up a skill";
@@ -214,11 +242,24 @@ export declare const en: {
         readonly reconnectRateLimited: "{{provider}} is busy — trying again automatically in {{seconds}}s.";
         readonly reconnectRateLimitedStill: "{{provider}} is still busy. We'll keep trying on our own.";
     };
+    readonly myUsage: {
+        readonly thisMonth: "This month";
+        readonly today: "Today";
+        readonly last30Days: "Last 30 days";
+        readonly unit: "tokens";
+        readonly explainer: "Tokens measure all the work the agent does for you. Days are counted in UTC.";
+        readonly dayValue: "{{date}}: {{tokens}} tokens";
+        readonly chartLabel: "Tokens per day over the last 30 days";
+        readonly empty: "No usage in the last 30 days.";
+        readonly updated: "Updated {{time}} UTC";
+        readonly loading: "Loading your usage…";
+        readonly loadError: "Couldn't load your usage.";
+        readonly retry: "Try again";
+        readonly unavailable: "Usage isn't available here yet.";
+    };
     readonly stats: {
         readonly title: "Session stats";
-        readonly input: "Input";
-        readonly output: "Output";
-        readonly total: "Total";
+        readonly tokens: "Tokens";
         readonly timeRunning: "Time running";
         readonly turns: "Turns";
         readonly toolCalls: "Tool calls";
@@ -329,6 +370,8 @@ export declare const en: {
         voiceDescription: string;
         history: string;
         historyDescription: string;
+        usage: string;
+        usageDescription: string;
         about: string;
         aboutDescription: string;
         apiKeys: string;
@@ -349,6 +392,10 @@ export declare const en: {
         apiKeysAuthError: string;
         apiKeysCreateError: string;
         apiKeysRevokeError: string;
+        workspaceScope: string;
+        workspaceScopeDescription: string;
+        workspaceScopeApplies: string;
+        workspaceScopeSaveError: string;
         profile: string;
         languageDescription: string;
         dockPosition: string;
@@ -357,6 +404,7 @@ export declare const en: {
         light: string;
         dark: string;
         presetDescription: string;
+        tenantDefault: string;
         advancedAppearance: string;
         advancedDescription: string;
         readRepliesDescription: string;
@@ -438,8 +486,8 @@ export declare const en: {
         readonly sharedFinished: "This one-time task has already passed. Ask an editor to update its timing.";
         readonly sharedLimit: "You have reached the active task limit. Pause a task before adding another.";
         readonly useInWorkspace: "Use in this workspace";
-        readonly enableHelp: "Runs here using your account and connections. Run history and email recipients belong to this workspace. Make sure the required connections are ready.";
-        readonly sharedSyncHelp: "Future edits to instructions and timing apply here automatically. You can pause or remove the task in this workspace at any time.";
+        readonly enableHelp: "Runs here using your account and connections. Run history and regular recipients belong to this workspace. Make sure the required connections are ready.";
+        readonly sharedSyncHelp: "Future edits to instructions, timing, and shared recipients apply here automatically. You can pause or remove the task in this workspace at any time.";
         readonly templateSynced: "Linked HTML template. Each run uses the latest file from the owner’s workspace.";
         readonly sharedLabel: "Shared";
         readonly sharedWorkspaceCount_one: "Shared in {{count}} workspace";
@@ -476,11 +524,16 @@ export declare const en: {
         readonly lastRun: "Last run {{time}}";
         readonly dayAtTime: "{{day}} at {{time}}";
         readonly pausedNotice: "Paused — runs won't start until you resume.";
+        readonly scheduleIdLabel: "Schedule ID";
+        readonly copyScheduleId: "Copy ID";
         readonly customEmailLabel: "Custom email enabled";
         readonly customEmailDescription: "Each run reads the latest version of this template and sends an email only when its condition matches.";
         readonly customEmailTemplate: "HTML template";
         readonly emailNotificationLabel: "Completion email enabled";
         readonly emailRecipients: "Recipients";
+        readonly sharedRecipients: "Shared recipients";
+        readonly sharedRecipientsHelp: "Sent only from the owner’s original task. Shared delivery pauses when that task is paused.";
+        readonly errorRecipientsInvalid: "Enter valid, unique email addresses.";
         readonly emailAccountRecipient: "Schedule owner's account email";
         readonly teamsDeliveryLabel: "Microsoft Teams delivery approved";
         readonly teamsStatusActive: "Active";
@@ -681,6 +734,7 @@ export declare const en: {
         readonly navPrompts: "Prompts";
         readonly navConnectors: "Connectors";
         readonly navSkills: "Skills";
+        readonly navApps: "Apps";
         readonly chatPlanRunning: "Chat — plan running, {{completed}} of {{total}} steps done";
         readonly devMode: "Dev mode";
         readonly devModeTitle: "Dev mode (belong:dev)";
@@ -795,6 +849,26 @@ export declare const en: {
         readonly thisFile: "this file";
         readonly download: "Download";
         readonly loadingPreview: "Loading preview…";
+        readonly artifactApprovalLabel: "Approve report action";
+        readonly artifactApprovalTitle: "Approve {{title}}?";
+        readonly artifactApprovalDescription: "This report action runs a registered script using your workspace access.";
+        readonly artifactApprovalSelection: "Workspace: {{workspace}}. Selected transactions: {{count}}";
+        readonly artifactApprovalOperation: "Operation: {{id}}";
+        readonly artifactApprovalVersion: "Script version: {{version}}";
+        readonly artifactApprovalReview: "Show full request and script";
+        readonly artifactApprovalProvided: "Provided by the report — check these values before approving";
+        readonly artifactApprovalTransactions: "Transaction IDs ({{count}})";
+        readonly artifactApprovalParameters: "Parameters";
+        readonly artifactApprovalNoParameters: "No parameters";
+        readonly artifactReportReloadLoop: "This report keeps reloading itself, so it was stopped. Close and reopen the preview to try again.";
+        readonly artifactApprovalReject: "Reject";
+        readonly artifactApprovalConfirm: "Approve action";
+        readonly artifactApprovalPersonal: "Personal";
+        readonly artifactHeldNotice: "An earlier report action may still be running. Belong will continue when it stops.";
+        readonly artifactHeldStop: "Stop it";
+        readonly artifactHeldStopping: "Stopping…";
+        readonly artifactHeldUnreachable: "Couldn't reach your workspace. Try again in a moment.";
+        readonly artifactReleasedUnconfirmed: "An earlier report action ended before Belong could confirm it stopped. Check its results before you run it again.";
         readonly devDefault: "default";
         readonly devModelIdPlaceholder: "model id (blank = env default)";
         readonly devModelIdTitle: "Exact model id for the selected provider — overrides the env pin";
@@ -806,6 +880,7 @@ export declare const en: {
         readonly devOverrideActive: "Dev override active — click to change";
         readonly callLightModelActive: "Calls are stepped down to the light voice model — click for the best voice";
         readonly agentWorking: "{{name}} is working…";
+        readonly waitingForReportAction: "Waiting for a report action to finish…";
     };
     readonly connectors: {
         readonly setupChooseAccount: "Several accounts are connected. Open Connectors and choose the account to manage, then continue your request.";
@@ -1040,6 +1115,74 @@ export declare const en: {
         readonly deleteConfirmBody: "The agent will lose access to its tools. This can't be undone.";
         readonly deleteConfirm: "Delete connector";
     };
+    readonly artifacts: {
+        readonly viewTitle: "Apps";
+        readonly viewDescription: "Pages the assistant keeps up to date, and that you can act on. Share one with a link that always shows the latest.";
+        readonly slotCounter: "{{used}} of {{limit}}";
+        readonly atCapHint: "You're using every slot. Delete one to make room for a new app.";
+        readonly versionLine: "v{{version}} · refreshed {{when}}";
+        readonly versionLineNeverRefreshed: "v{{version}} · not refreshed yet";
+        readonly notScheduled: "Not scheduled";
+        readonly scheduledUnnamed: "On a schedule";
+        readonly overdue: "Hasn't refreshed since {{when}}";
+        readonly shareLive: "Link works until {{when}}";
+        readonly shareExpired: "Link expired";
+        readonly shareRevoked: "Link turned off";
+        readonly shareNever: "Not shared";
+        readonly copyLink: "Copy link";
+        readonly copied: "Copied";
+        readonly share: "Share";
+        readonly shareAgain: "Share again";
+        readonly extend: "Extend the link";
+        readonly revoke: "Turn the link off";
+        readonly rebind: "Change the schedule";
+        readonly delete: "Delete";
+        readonly open: "Open";
+        readonly menuAria: "More actions for {{name}}";
+        readonly emptyTitle: "No apps yet";
+        readonly emptyHint: "Ask the assistant to keep a report up to date — it will show up here with a link you can share.";
+        readonly featureAbsent: "Apps aren't available here yet.";
+        readonly loading: "Loading your apps…";
+        readonly loadError: "Couldn't load your apps.";
+        readonly retry: "Try again";
+        readonly noticeShareFailed: "Couldn't create a link for {{name}}. Try again.";
+        readonly noticeExtendFailed: "Couldn't extend the link for {{name}}. Try again.";
+        readonly noticeRevokeFailed: "Couldn't turn off the link for {{name}}. Try again.";
+        readonly noticeDeleteFailed: "Couldn't delete {{name}}. Try again.";
+        readonly noticeRebindFailed: "Couldn't change the schedule for {{name}}. Try again.";
+        readonly noticeScheduleGone: "That schedule no longer exists.";
+        readonly noticeCopyFailed: "Couldn't copy the link. Select it and copy it by hand.";
+        readonly noticeOpenFailed: "Couldn't open that version. Try again.";
+        readonly noticeGone: "That app no longer exists.";
+        readonly noticeForbidden: "You don't have permission to change apps here.";
+        readonly noticeResharedRotated: "New link created. The link you shared before no longer works.";
+        readonly reshareTitle: "Share {{name}} again?";
+        readonly reshareDescription: "This creates a new link. The one you shared before stops working for everyone who has it.";
+        readonly reshareConfirm: "Create a new link";
+        readonly cancel: "Cancel";
+        readonly deleteTitle: "Delete this app?";
+        readonly deleteDescription: "{{name}} will be removed, and the link you shared will stop working for everyone who has it.";
+        readonly deleteConfirm: "Delete";
+        readonly deleting: "Deleting…";
+        readonly bindTitle: "Keep {{name}} up to date";
+        readonly bindDescription: "Pick the schedule that should refresh this app.";
+        readonly bindNone: "Not scheduled";
+        readonly bindEmpty: "You don't have any schedules yet.";
+        readonly bindLoading: "Loading your schedules…";
+        readonly bindSearchPlaceholder: "Search your schedules";
+        readonly bindNoResults: "No schedule matches \"{{q}}\".";
+        readonly bindLoadMore: "Show more schedules";
+        readonly bindLoadError: "Couldn't load your schedules.";
+        readonly bindLoadMoreError: "Couldn't load more schedules. Try again.";
+        readonly bindConfirm: "Save";
+        readonly detailBack: "Apps";
+        readonly detailCurrent: "Current version";
+        readonly detailHistory: "Version history";
+        readonly detailVersion: "v{{version}}";
+        readonly detailPublished: "Published {{when}}";
+        readonly detailNoSummary: "No summary for this version";
+        readonly detailNotFound: "This app no longer exists.";
+    };
     readonly app: {
         readonly uploadNoWorkspace: "Open the terminal once so your workspace exists, then upload.";
         readonly uploadTooLarge: "{{name}} is too large (max 25 MB).";
@@ -1100,6 +1243,7 @@ export declare const en: {
         readonly terminalFailed: "failed";
         readonly terminalRunning: "running…";
         readonly terminalStillRunning: "still running…";
+        readonly terminalInBackground: "running in the background";
         readonly copyCommand: "Copy command";
         readonly waitingForOutput: "waiting for output…";
         readonly previousBranch: "Previous branch";
@@ -1122,6 +1266,14 @@ export declare const en: {
         readonly modeApproveDescription: "Ask before each consequential action";
         readonly modePlanLabel: "Plan";
         readonly modePlanDescription: "Propose a plan — no actions";
+        readonly responseMode: "Response mode: {{mode}}";
+        readonly responseModeTitle: "Response mode";
+        readonly responseModeFastLabel: "Fast";
+        readonly responseModeFastDescription: "Quick answers for simple requests";
+        readonly responseModeBalancedLabel: "Balanced";
+        readonly responseModeBalancedDescription: "Great for everyday work";
+        readonly responseModeSmartLabel: "Smart";
+        readonly responseModeSmartDescription: "Most capable, for complex work";
     };
     readonly conversation: {
         readonly thinking: "Thinking…";
@@ -1292,7 +1444,7 @@ export declare const en: {
             readonly edit: "Edit…";
             readonly clear: "Clear";
             readonly clearTitle: "Clear this goal?";
-            readonly clearBody: "The conversation stays. The goal and its history go.";
+            readonly clearBody: "The conversation and its messages stay, and you can keep chatting. The goal stops here — nothing it already did is undone.";
             readonly clearConfirm: "Clear this goal";
             readonly clearKeep: "Keep it";
             readonly failedPause: "Couldn't pause the goal. Try again.";
@@ -1364,6 +1516,7 @@ export declare const en: {
                 readonly primary: "Give it more";
                 readonly newGoal: "Start a new goal";
                 readonly newGoalHint: "Say what the new goal should get done…";
+                readonly exit: "Exit goal mode";
             };
             readonly composerHint: "Tell it what to try instead…";
         };