@belonguniverseai/react-sdk 0.6.21 → 0.6.23

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

@@ -1,6 +1,20 @@
 /** Usage meter + context-window panel dock strings. */
 export declare const usageEn: {
     readonly usage: {
+        readonly expandComposer: "Expand message input";
+        readonly collapseComposer: "Compact message input";
+        readonly filesShort_one: "{{count}} file";
+        readonly filesShort_other: "{{count}} files";
+        readonly contextTitle: "Context for this message";
+        readonly filesToSend: "Files to send";
+        readonly attachedFiles_one: "{{count}} file attached";
+        readonly attachedFiles_other: "{{count}} files attached";
+        readonly filesNote: "These files will be sent with your next message.";
+        readonly emptyFiles: "Attach files to include them in your next message.";
+        readonly pageNote: "Page label only; this control does not attach page contents.";
+        readonly removeFile: "Remove {{name}}";
+        readonly closeContext: "Close context";
+        readonly currentPage: "Current page";
         readonly tooltip: "Auto-compacts at {{chars}} chars; {{tokens}} tokens used this session";
         readonly windowTooltip: "Context window: {{used}} of {{window}} tokens used ({{pct}}%)";
         readonly context: "Context {{pct}}%";
@@ -27,6 +41,20 @@ export declare const usageEn: {
 };
 export declare const usageEs: {
     usage: {
+        expandComposer: string;
+        collapseComposer: string;
+        filesShort_one: string;
+        filesShort_other: string;
+        contextTitle: string;
+        filesToSend: string;
+        attachedFiles_one: string;
+        attachedFiles_other: string;
+        filesNote: string;
+        emptyFiles: string;
+        pageNote: string;
+        removeFile: string;
+        closeContext: string;
+        currentPage: string;
         tooltip: string;
         windowTooltip: string;
         context: string;
@@ -53,6 +81,20 @@ export declare const usageEs: {
 };
 export declare const usagePt: {
     usage: {
+        expandComposer: string;
+        collapseComposer: string;
+        filesShort_one: string;
+        filesShort_other: string;
+        contextTitle: string;
+        filesToSend: string;
+        attachedFiles_one: string;
+        attachedFiles_other: string;
+        filesNote: string;
+        emptyFiles: string;
+        pageNote: string;
+        removeFile: string;
+        closeContext: string;
+        currentPage: string;
         tooltip: string;
         windowTooltip: string;
         context: string;
@@ -79,6 +121,20 @@ export declare const usagePt: {
 };
 export declare const usageIt: {
     usage: {
+        expandComposer: string;
+        collapseComposer: string;
+        filesShort_one: string;
+        filesShort_other: string;
+        contextTitle: string;
+        filesToSend: string;
+        attachedFiles_one: string;
+        attachedFiles_other: string;
+        filesNote: string;
+        emptyFiles: string;
+        pageNote: string;
+        removeFile: string;
+        closeContext: string;
+        currentPage: string;
         tooltip: string;
         windowTooltip: string;
         context: string;

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

@@ -8,6 +8,11 @@ export declare const workspaceEn: {
         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";
     };
 };
 export declare const workspaceEs: {
@@ -18,6 +23,11 @@ export declare const workspaceEs: {
         shownByBelong: string;
         openedByYou: string;
         planTitle: string;
+        subagentsFilterAll: string;
+        subagentsFilterRunning: string;
+        subagentsFilterAttention: string;
+        subagentsFilterDone: string;
+        subagentsOpen: string;
     };
 };
 export declare const workspacePt: {
@@ -28,6 +38,11 @@ export declare const workspacePt: {
         shownByBelong: string;
         openedByYou: string;
         planTitle: string;
+        subagentsFilterAll: string;
+        subagentsFilterRunning: string;
+        subagentsFilterAttention: string;
+        subagentsFilterDone: string;
+        subagentsOpen: string;
     };
 };
 export declare const workspaceIt: {
@@ -38,5 +53,10 @@ export declare const workspaceIt: {
         shownByBelong: string;
         openedByYou: string;
         planTitle: string;
+        subagentsFilterAll: string;
+        subagentsFilterRunning: string;
+        subagentsFilterAttention: string;
+        subagentsFilterDone: string;
+        subagentsOpen: string;
     };
 };

package/dist/public-api.d.ts

@@ -1,3 +1,3 @@
-export type { BelongGlobal, BelongInitInput, BelongTheme, BelongThemeBrand, BelongThemeDensity, BelongThemeMode, BelongThemePalette, BelongThemeSide, PartialBelongTheme, RouteHandler, RouteHandlerResult, UiActionHandler, UiActionResult, } from './types/public.ts';
+export type { BelongBrowserControlConfig, BelongBrowserOpName, BelongGlobal, BelongHostMcpConfig, BelongInitInput, BelongOpenOptions, BelongTheme, BelongThemeBrand, BelongThemeDensity, BelongThemeMode, BelongThemePalette, BelongThemeSide, PartialBelongTheme, RouteHandler, RouteHandlerResult, UiActionHandler, UiActionResult, } from './types/public.ts';
 export { SdkProviders } from './app/providers.tsx';
 export { createApiClient, setBelongToken } from './api/client.ts';

package/dist/routes/chat/part-renderer-extra-props.d.ts

@@ -0,0 +1,43 @@
+import { SessionGoalApi } from './use-session-goal.ts';
+import { GoalProposalData } from '../../stream/belong-data-parts.ts';
+export type PartRendererExtraProps = {
+    readonly onContinueConnector?: ((connectorId: string, name: string) => Promise<void>) | undefined;
+    readonly onExecutePlan?: (() => void) | undefined;
+    readonly onConfirmGoal?: ((proposal: GoalProposalData) => Promise<void>) | undefined;
+    readonly renderGoalSetCard?: true | undefined;
+    readonly goalFileCount: number;
+    readonly onGoalSchedule: (command: string) => void;
+    readonly onGoalGetFiles?: (() => void) | undefined;
+    readonly onGoalStartAnother: () => void;
+    /** Task 17 — the proposal card's "Edit first", hidden under the same rule
+     *  as `onConfirmGoal` (streaming / already resolved). */
+    readonly onEditGoalProposal?: ((proposal: GoalProposalData) => void) | undefined;
+    readonly onOpenGoalProposal?: (() => void) | undefined;
+    /** Fix round 1 (Low 4) — a FUNCTION, not a bare boolean: only the dispatch
+     *  site (`ai-sdk-part-renderers.tsx`) knows which offer's objective to ask
+     *  about, since `partRendererExtraProps` is called once per message before
+     *  the specific part type is known. */
+    readonly isGoalProposalStarted: (objective: string) => boolean;
+    readonly goalProposalSessionId: string | null;
+};
+export type PartRendererExtraPropsInput = {
+    readonly isStreaming: boolean;
+    /** This message's index in the transcript. */
+    readonly messageIndex: number;
+    readonly lastUserMessageIndex: number;
+    readonly messageId: string;
+    readonly continueConnectorFor: (messageId: string) => (connectorId: string, name: string) => Promise<void>;
+    readonly onExecutePlan: () => void;
+    readonly hasLiveGoal: boolean;
+    readonly isGoalSetPart: boolean;
+    readonly goalFileCount: number;
+    readonly onGoalSchedule: (command: string) => void;
+    readonly onGoalGetFiles?: (() => void) | undefined;
+    readonly onGoalStartAnother: () => void;
+    /** Task 17 — read straight off the door instead of threading `confirmGoal`
+     *  as its own field: `goalDoor` already carries everything the proposal
+     *  card needs. */
+    readonly goalDoor: SessionGoalApi["goalDoor"];
+    readonly onOpenGoalView: (() => void) | undefined;
+};
+export declare const partRendererExtraProps: (input: PartRendererExtraPropsInput) => PartRendererExtraProps;

package/dist/routes/chat/use-goal-receipt.d.ts

@@ -0,0 +1,37 @@
+import { BelongUIMessage } from '../../stream/belong-data-parts.ts';
+import { GoalView } from '../../api/goals.ts';
+export type GoalReceiptState = {
+    readonly goalSetPartIds: ReadonlySet<string>;
+    readonly setupProgress: {
+        readonly index: number;
+        readonly total: number;
+    } | undefined;
+    /** The completion card's "Run this again on a schedule" — drops the
+     *  already-built `/schedule …` line into the draft and focuses it. The
+     *  user still presses Enter; this never sends on their behalf. */
+    readonly onGoalScheduleFollowUp: (command: string) => void;
+    /** The completion card's "Set another goal" — opens Task 16's compose
+     *  sheet directly (spec §5: "new chat + compose sheet"). Final review
+     *  (Medium 6): this used to pre-type `/goal ` into the draft, which cost
+     *  the user an extra Enter — and the bare-`/goal` slash menu ate that
+     *  Enter, so it was two. */
+    readonly onGoalAnotherFollowUp: () => void;
+};
+export declare const useGoalReceipt: (messages: readonly BelongUIMessage[], goal: GoalView | null, setDraft: (value: string) => void, 
+/** `goalDoor.onSetGoal` — the compose-sheet opener, or `undefined` once a
+ *  `goals_disabled` 503 has been seen this mount. The draft prefill is the
+ *  fallback for that one case: a completion card CAN outlive the door (the
+ *  card renders from a stored part), and a dead button is worse than a
+ *  pre-typed command. */
+openGoalComposeSheet: (() => void) | undefined) => GoalReceiptState;
+/**
+ * True when this part is the ONE `data-goal` part, for its goal, that
+ * should render the "Goal set" receipt. Typed structurally (not against
+ * `BelongMessagePart`) so this module stays decoupled from the renderer
+ * module — every message part shape chat.tsx passes in already has `type`
+ * and an optional wire `id`.
+ */
+export declare const isGoalSetPart: (messageId: string, part: {
+    readonly type: string;
+    readonly id?: string;
+}, goalSetPartIds: ReadonlySet<string>) => boolean;

package/dist/routes/chat/use-host-draft-request.d.ts

@@ -0,0 +1,2 @@
+import { Dispatch, SetStateAction } from 'react';
+export declare const useHostDraftRequest: (setDraft: Dispatch<SetStateAction<string>>) => void;

package/dist/routes/chat/use-session-goal.d.ts

@@ -0,0 +1,227 @@
+import { UseChatHelpers } from '@ai-sdk/react';
+import { fetchSessionGoal, GoalView } from '../../api/goals.ts';
+import { GoalRefusal } from '../../embed/goal-cap-notice.ts';
+import { ChatMode } from '../../embed/chat-mode.ts';
+import { GoalRunwayPreset } from '../../embed/goal-runway.ts';
+import { BuiltinCommand } from '../../embed/slash-commands.ts';
+import { GoalComposeValue } from '../../components/embed/GoalComposeSheet.tsx';
+import { BelongUIMessage, GoalProposalData } from '../../stream/belong-data-parts.ts';
+/**
+ * The card a waiting goal is waiting ON, named by the row action that offers
+ * it. Client-only (appendix A §4): the wait ends when the user acts on the
+ * CARD, never when a button on the row is pressed, so this scrolls and
+ * focuses and does nothing else.
+ */
+export type PendingCardKind = "answer" | "review" | "show_me";
+/**
+ * `startGoal`'s input (Task 16) — the ONE creation path's full shape, shared
+ * by every door: the compose sheet's submit, `/goal <objective>` (via the
+ * sheet), the proposal card's future Confirm, and the row's `new_goal`
+ * hand-off (Task 8, which only ever fills in `objective`). `criteria` and
+ * `runway` ride straight onto the message body (Task 15's `goal: { objective,
+ * criteria?, runway? }`); `mode`, when given, is the door's OWN resolved
+ * choice and is sent as-is — see the fallback below for the one caller that
+ * still doesn't resolve it itself.
+ */
+export type StartGoalInput = {
+    readonly objective: string;
+    readonly criteria?: readonly string[];
+    readonly runway?: GoalRunwayPreset;
+    readonly mode?: ChatMode;
+};
+/**
+ * Fix wave (Task 8 review, finding 1): the KIND decides the selector — a goal
+ * waiting for an approval must not land on a question card just because a
+ * question card appears first in the transcript. And within one kind, the card
+ * the goal is waiting on is the NEWEST: a transcript keeps every card the
+ * conversation ever showed, so `querySelector`'s first match is the OLDEST,
+ * which is normally one the user already settled. Prefer an explicitly pending
+ * card; otherwise take the last.
+ */
+export declare const scrollAndFocusPendingCard: (kind: PendingCardKind) => void;
+/** Every prop `<GoalComposeSheet>` takes — named once so `composeSheet` and
+ *  `goalDoor.composeSheet` below don't have to repeat the shape. */
+type GoalComposeSheetProps = {
+    readonly open: boolean;
+    readonly initial: GoalComposeValue;
+    readonly planModeResolved: boolean;
+    readonly onCancel: () => void;
+    readonly onSubmit: (value: GoalComposeValue) => void;
+    readonly onReturnFocus: () => void;
+};
+/** `openGoalComposeSheet`'s optional prefill — every field optional so a
+ *  bare `/goal` (no prefill at all) and "Edit first" (all three) share one
+ *  door. */
+export type GoalComposeSheetPrefill = {
+    readonly objective?: string;
+    readonly criteria?: readonly string[];
+    readonly runway?: GoalRunwayPreset;
+};
+export type SessionGoalApi = {
+    /** The ON-SCREEN session's goal, or null. */
+    readonly goal: GoalView | null;
+    readonly hasLiveGoal: boolean;
+    readonly startGoal: (input: StartGoalInput) => Promise<void>;
+    /** The proposal card's Confirm (`ai-sdk-part-renderers.tsx`'s `onConfirmGoal`)
+     *  hands over the WHOLE offer — this adapts it onto `startGoal` so `chat.tsx`
+     *  doesn't need its own wrapper (the line-count ratchet). Fix round 1
+     *  (Medium 1) — widened from a bare objective so Start actually creates
+     *  what the card promised (criteria + runway included). */
+    readonly confirmGoal: (proposal: GoalProposalData) => Promise<void>;
+    readonly runGoalCommand: (command: Extract<BuiltinCommand, {
+        type: "goal";
+    }>) => Promise<void>;
+    /** Opens the compose sheet — `chat.tsx`'s mode-menu "Set a goal…" entry —
+     *  or `undefined` once a `goals_disabled` 503 has been seen this mount (the
+     *  initial fetch, or a refused creation): a deployment without goals never
+     *  shows a door the backend will only refuse. */
+    readonly onSetGoal: (() => void) | undefined;
+    /** The compose sheet's open/closed state and what it starts from — the ONE
+     *  door onto `startGoal`, reached from the mode menu, a bare `/goal` (or
+     *  `/goal <objective>`, prefilled), and — Task 17 — the proposal card's
+     *  "Edit first". Flat fields for tests that drive one at a time; `composeSheet`
+     *  below bundles them exactly as `<GoalComposeSheet>` takes them, so
+     *  `chat.tsx` can spread the whole thing in one line. */
+    readonly sheetOpen: boolean;
+    readonly sheetInitial: GoalComposeValue;
+    /** True when the composer was in plan mode at the moment this sheet
+     *  opened — the sheet says so and resolves the send to Auto itself. */
+    readonly sheetPlanModeResolved: boolean;
+    /** Task 17 widens this from a bare objective to the sheet's whole prefill
+     *  — "Edit first" needs criteria and a runway too, not just the text. */
+    readonly openGoalComposeSheet: (prefill?: GoalComposeSheetPrefill) => void;
+    readonly closeGoalComposeSheet: () => void;
+    readonly submitGoalComposeSheet: (value: GoalComposeValue) => void;
+    /** `<GoalComposeSheet {...composeSheet} />` — every prop that component
+     *  takes, bundled once so the ratchet on `chat.tsx` (CLAUDE.md) never has
+     *  to grow for this door. */
+    readonly composeSheet: GoalComposeSheetProps;
+    /**
+     * Task 17 — the proposal card's "Started" state (spec §7), given the
+     * offer's own objective text: derived from `GoalView` + the loaded
+     * message list (never local state — §12/§41), true only when the
+     * session's goal origin message is BOTH a goal-origin message (Task 9's
+     * `isGoalOriginMessage`) AND carries this exact objective — so a goal
+     * started via `/goal` or the compose sheet with different words leaves an
+     * unanswered proposal card as-is (fix round 1, Low 4). Takes the
+     * objective rather than being a bare boolean because only the dispatch
+     * site (`ai-sdk-part-renderers.tsx`) knows which offer's card is asking.
+     */
+    readonly isGoalProposalStarted: (objective: string) => boolean;
+    /** Opens the compose sheet prefilled from a proposal's own fields — the
+     *  proposal card's "Edit first" (Task 17). */
+    readonly onEditGoalProposal: (proposal: GoalProposalData) => void;
+    /**
+     * The ON-SCREEN session id, for the proposal card's per-device dismissal
+     * key (ruling 5) — `null` for the rare frame before any session is known.
+     * Fix round 1 (Low 5) — was `?? ""`, which would have made every such
+     * render share ONE dismissal key (`belong:goal-proposal-dismissed:`);
+     * `null` instead tells the card to render without "Not now" until a real
+     * session id exists, per `GoalProposalCard`'s own `sessionId` prop.
+     */
+    readonly goalProposalSessionId: string | null;
+    /** `onSetGoal`, `confirmGoal` and `composeSheet` again, bundled into ONE
+     *  destructured field so `chat.tsx` (CLAUDE.md's line-count ratchet) needs
+     *  exactly one line to receive the whole door. */
+    readonly goalDoor: {
+        readonly onSetGoal: (() => void) | undefined;
+        readonly confirmGoal: (proposal: GoalProposalData) => Promise<void>;
+        readonly composeSheet: GoalComposeSheetProps;
+        readonly isGoalProposalStarted: (objective: string) => boolean;
+        readonly onEditGoalProposal: (proposal: GoalProposalData) => void;
+        readonly goalProposalSessionId: string | null;
+    };
+    /** Hand the mount `GET /goal` its answer. Publishes the view AND the settled
+     *  signal, so both halves of "what does this session's goal look like" are
+     *  decided in one place. */
+    readonly seedGoalFromServer: (sessionId: string, outcome: Awaited<ReturnType<typeof fetchSessionGoal>>) => void;
+    /** The next user message resumes the goal (the row's `Tell it what to try`). */
+    readonly armResumeOnNextSend: () => void;
+    /** The client message ids `startGoal` has sent with a `goal` body, this
+     *  mount. Task 9's `SentAsGoalTag` reconciliation: the optimistic source of
+     *  truth for the render frame(s) before `GoalView.originatingClientMessageId`
+     *  exists (§41 — a reload takes over from there). See `isGoalOriginMessage`. */
+    readonly goalOriginIds: ReadonlySet<string>;
+    /** Fix round 1 (Task 9 review, finding 2) — `handleCreateSendError` calls
+     *  this once it has confirmed the failed send WAS a goal-creation send. A
+     *  refused creation must not leave its message id tagged forever: this
+     *  drops it from `goalOriginIds` if it was already captured, and disarms
+     *  the one-shot arm if the message never arrived (e.g. the transport
+     *  rejected before `messages` ever grew). Exposed mainly for the test
+     *  suite, which drives it directly to simulate that call. */
+    readonly dropGoalOriginOnRefusal: () => void;
+    /** Task 14 — the refused `/goal`'s ANSWER, a card under the user's own
+     *  bubble instead of a chat notice telling them to type another command.
+     *  `null` when there is nothing to answer. Client-only state (never
+     *  reconciled from the server), so it never survives a reload. */
+    readonly refusal: GoalRefusal | null;
+    /** The id of the user message this refusal is answering, so `chat.tsx` can
+     *  render the card under that exact bubble. `null` for a refusal that
+     *  never got as far as sending anything (the client's own "you already
+     *  have one" pre-check) — `chat.tsx` renders the card in the transcript
+     *  flow instead, where the old notice used to sit. */
+    readonly refusalMessageId: string | null;
+    /** Fix round 1 — Replace/Retry's async chain is in flight; the card
+     *  disables its buttons on this so a fast double click can't fire two. */
+    readonly refusalBusy: boolean;
+    /** Answers the card's dismiss — clears the refusal and nothing else. */
+    readonly dismissRefusal: () => void;
+    /** `useChat`'s `onError` (final review, finding 1) — the send-error path
+     *  for a goal-creation send. `wasGoalCreateSend` is read internally
+     *  (`isGoalCreateSendPending`'s old job): every OTHER failure of the chat
+     *  is left entirely to its own error surface. A refusal `goalRefusalFromError`
+     *  recognises is HELD as `refusal` (never a `notice(...)` string) and the
+     *  chat's own error state is cleared so the generic bubble never doubles
+     *  up on the same refusal. */
+    readonly handleCreateSendError: (error: unknown, clearChatError: () => void) => void;
+    /** "Clear it and set this one" — clears the existing goal, then starts this
+     *  one with the objective the refused send carried. */
+    readonly onRefusalReplace: () => void;
+    /** "Keep the text" — puts the refused objective back in the composer. */
+    readonly onRefusalKeepText: () => void;
+    /** `not_sent` → "Try again"; `plan_mode` → "Run on Auto". Both just
+     *  re-send the same objective (`startGoal` resolves plan mode itself). */
+    readonly onRefusalRetry: () => void;
+};
+/**
+ * True when THIS message is the one that started the goal. Reconciled from
+ * `GoalView.originatingClientMessageId` (Task 6) so the tag survives a
+ * reload; the optimistic local flag only covers the first frame — matching on
+ * the client message id (never the objective text) is what makes the two
+ * agree without ever tagging the wrong bubble when the user sends the same
+ * sentence twice.
+ *
+ * Fix round 1 (Task 9 review, finding 2) — once the SERVER has answered
+ * (`goal.originatingClientMessageId` is set), that answer is authoritative
+ * and wins outright (§12: check the fact directly, don't lean on a flag that
+ * might be stale). Before this, a stale id still sitting in `optimisticIds`
+ * (one the refusal cleanup below didn't reach, or a future multi-attempt
+ * race) could keep tagging a bubble the server never named as the origin.
+ * The optimistic set is consulted ONLY for the frame(s) before the server has
+ * said anything about this session's goal.
+ */
+export declare const isGoalOriginMessage: (input: {
+    readonly goal: Pick<GoalView, "originatingClientMessageId"> | null;
+    readonly clientMessageId: string | null | undefined;
+    readonly optimisticIds: ReadonlySet<string>;
+}) => boolean;
+export type SessionGoalInput = {
+    readonly apiBaseUrl: string;
+    readonly sessionId: string | null;
+    readonly transportSessionId: string | null;
+    readonly messages: readonly BelongUIMessage[];
+    readonly mode: ChatMode;
+    readonly sendMessage: UseChatHelpers<BelongUIMessage>["sendMessage"];
+    readonly onModeChange: (mode: ChatMode) => void;
+    readonly notice: (text: string) => void;
+    /** Runs inside the click gesture, immediately before a creation send —
+     *  ChatRoute's TTS unlock + voice-turn reset, which stay its business. */
+    readonly beforeSend: () => void;
+    readonly devOverrides: Readonly<Record<string, unknown>>;
+    /** Task 14 — "Keep the text" (a refused goal's cap card) hands the refused
+     *  objective back to the composer through the SAME door
+     *  `useGoalReceipt`'s follow-ups already use. */
+    readonly setDraft: (value: string) => void;
+};
+export declare const useSessionGoal: (input: SessionGoalInput) => SessionGoalApi;
+export {};

package/dist/routes/chat.d.ts

@@ -25,7 +25,17 @@ export type QueuedMessage = {
     readonly submittedAt: number;
     readonly state: "queued" | "failed";
 };
-export declare const ChatRoute: ({ sessionId, reconcileBackgroundRun, }?: {
+export declare const ChatRoute: ({ sessionId, draftId, reconcileBackgroundRun, onOpenGoalView, onOpenFilesView, }?: {
     readonly sessionId?: string;
+    readonly draftId?: string;
     readonly reconcileBackgroundRun?: boolean;
+    /** Put the Goal view on screen (the dock owns navigation — same path the
+     *  header pill takes). Omitted in tests and stories, where the row's
+     *  Details simply does nothing. */
+    readonly onOpenGoalView?: (() => void) | undefined;
+    /** Put the Files view on screen — same navigation door as the rail's Files
+     *  item (Task 13's completion card "Get the files"). Omitted in tests and
+     *  stories, where the button simply doesn't render (`GoalCompletionCard`
+     *  hides it on `undefined`). */
+    readonly onOpenFilesView?: (() => void) | undefined;
 }) => import("react").JSX.Element;

package/dist/routes/goal.d.ts

@@ -0,0 +1 @@
+export declare const GoalRoute: () => import("react").JSX.Element;

package/dist/routes/library.d.ts

@@ -0,0 +1,4 @@
+/** Both old deep links and the new Library URLs share one selection surface. */
+export declare function LibraryRoute({ view }: {
+    readonly view: "skills" | "prompts";
+}): import("react").JSX.Element;

package/dist/routes/skills.d.ts

@@ -0,0 +1,2 @@
+/** /skills — the user's skill library (rail tab). */
+export declare const SkillsRoute: () => import("react").JSX.Element;

package/dist/stream/activity-items.d.ts

@@ -0,0 +1,25 @@
+import { SandboxCommandData, SubagentData, ToolCallData } from './belong-data-parts.ts';
+/** One tool call in an activity run, paired (for shell) with its same-id output. */
+export type ToolActivityItem = {
+    readonly tool: ToolCallData;
+    readonly output: SandboxCommandData | null;
+};
+/**
+ * BEL-199 — a delegated subagent in an activity run. It sits INSIDE the one
+ * collapsed line beside the tool items, never beside the group.
+ */
+export type SubagentActivityItem = {
+    readonly kind: "subagent";
+    readonly subagentId: string;
+    readonly data: SubagentData;
+};
+/**
+ * Deliberate shape note: the TOOL variant carries no `kind` discriminant. It is
+ * the shape every existing fixture and story already builds, and a subagent item
+ * is distinguishable without one (`"kind" in item`) — so this stays a sound
+ * union while a required discriminant would have churned ~25 unrelated call
+ * sites across four story files for no safety the guard below doesn't give.
+ */
+export type ActivityItem = ToolActivityItem | SubagentActivityItem;
+export declare const isSubagentItem: (item: ActivityItem) => item is SubagentActivityItem;
+export declare const isToolItem: (item: ActivityItem) => item is ToolActivityItem;

package/dist/stream/ai-sdk-part-renderers.d.ts

@@ -1,30 +1,19 @@
 import { MessageContinuation } from './message-continuation.ts';
-import { BelongDataParts, BelongUIMessage, SandboxCommandData, SubagentData, ToolCallData } from './belong-data-parts.ts';
-/** One tool call in an activity run, paired (for shell) with its same-id output. */
-export type ToolActivityItem = {
-    readonly tool: ToolCallData;
-    readonly output: SandboxCommandData | null;
-};
-/**
- * BEL-199 — a delegated subagent in an activity run. It sits INSIDE the one
- * collapsed line beside the tool items, never beside the group.
- */
-export type SubagentActivityItem = {
-    readonly kind: "subagent";
-    readonly subagentId: string;
-    readonly data: SubagentData;
-};
-/**
- * Deliberate shape note: the TOOL variant carries no `kind` discriminant. It is
- * the shape every existing fixture and story already builds, and a subagent item
- * is distinguishable without one (`"kind" in item`) — so this stays a sound
- * union while a required discriminant would have churned ~25 unrelated call
- * sites across four story files for no safety the guard below doesn't give.
- */
-export type ActivityItem = ToolActivityItem | SubagentActivityItem;
-export declare const ActivityGroup: ({ items, live, }: {
+import { BelongDataParts, BelongUIMessage, GoalProposalData } from './belong-data-parts.ts';
+import { ActivityItem } from './activity-items.ts';
+import { SubagentLanesContext, SubagentMessageIndex } from './subagent-lanes-model.ts';
+export declare const ActivityGroup: ({ items, live, subagents, }: {
     readonly items: readonly ActivityItem[];
+    /** The collapsed line's shimmer: true only for the LAST group of the streaming message. */
     readonly live?: boolean | undefined;
+    /**
+     * Spec 2026-09-16 §4a — the message this group belongs to. The lanes nest
+     * their calls (and a wave its lanes) from every group of it, and tick and
+     * offer Stop while IT streams: an approval or question card after them makes
+     * this group non-last while the subagents still run. Absent (a story, a unit
+     * test), the group is its own message and the lanes follow `live`.
+     */
+    readonly subagents?: SubagentLanesContext | undefined;
 }) => import("react").JSX.Element;
 /** A segment of a message's text: prose to render as markdown, or a `@`-mention. */
 type TextSegment = {
@@ -45,12 +34,34 @@ type TextSegment = {
 export declare const splitMentionSegments: (text: string) => readonly TextSegment[];
 export type BelongMessagePart = BelongUIMessage["parts"][number];
 export type PartRendererProps = {
+    /** Only the current part of the active runtime turn is live. A stopped
+     * stream may retain a native `streaming` state in the message snapshot. */
+    readonly live?: boolean;
     readonly part: BelongMessagePart;
     /**
      * Renders the plan card's "Run this plan" CTA when provided (chat.tsx
      * omits it while a run streams so the CTA can't double-submit).
      */
     readonly onExecutePlan?: (() => void) | undefined;
+    /**
+     * Renders the goal-proposal card's Confirm when provided (chat.tsx omits
+     * it while a run streams, so the CTA can't double-submit — same rule as
+     * `onExecutePlan`).
+     */
+    readonly onConfirmGoal?: ((proposal: GoalProposalData) => Promise<void>) | undefined;
+    /** Task 17 — the proposal card's "Edit first", gated the same as
+     *  `onConfirmGoal` (streaming, or already resolved). */
+    readonly onEditGoalProposal?: ((proposal: GoalProposalData) => void) | undefined;
+    /** Task 17 — the proposal card's collapsed "Started" line's "Open it". */
+    readonly onOpenGoalProposal?: (() => void) | undefined;
+    /** Task 17 — derived from `GoalView`, never local state (§12/§41). Fix
+     *  round 1 (Low 4) — a function of the SPECIFIC offer's objective, called
+     *  at the `data-goal-proposal` dispatch arm below where that text is
+     *  known, so an unrelated goal elsewhere in the transcript can't flip
+     *  this offer's card to "Started". */
+    readonly isGoalProposalStarted?: ((objective: string) => boolean) | undefined;
+    /** Task 17 — ruling 5's per-device dismissal key is per session. */
+    readonly goalProposalSessionId?: string | null | undefined;
     readonly onContinueConnector?: ((connectorId: string, name: string) => Promise<void>) | undefined;
     /**
      * Follows the turn an approval card's decision started (an agent-raised plan
@@ -64,15 +75,38 @@ export type PartRendererProps = {
      * side effects. Absent/false = live part, dispatch as usual.
      */
     readonly historical?: boolean | undefined;
+    /**
+     * Task 12 — true when THIS `data-goal` part is the ONE part designated,
+     * FOR ITS GOAL, to render the "Goal set" receipt (fix round 1: one per
+     * `goalId`, not one globally). `chat.tsx` computes the designated ids once
+     * per render (`useGoalReceipt` / `selectGoalSetPartIds`,
+     * `routes/chat/use-goal-receipt.ts`) and gates this prop per-part via
+     * `isGoalSetPart`, the same way it gates `onExecutePlan`/`onConfirmGoal` on
+     * `isStreaming`/`hasLiveGoal`. Every other `data-goal` part — including
+     * every earlier/later status update of the SAME goal, and every part of a
+     * DIFFERENT goal that already claimed its own receipt — renders nothing
+     * (see the dispatch below).
+     */
+    readonly renderGoalSetCard?: boolean | undefined;
+    /**
+     * Task 13 — the ending's inputs (spec §5). `goalFileCount` is the whole
+     * session's `file`/`data-artifact` part count (`countSessionFiles`),
+     * threaded through unconditionally — unlike the CTAs above, the completion
+     * card is not a mid-run double-submit risk, so it needs no `isStreaming`
+     * gate. `onGoalGetFiles` stays optional at THIS layer too: undefined hides
+     * the button exactly as `GoalCompletionCard` documents.
+     */
+    readonly goalFileCount?: number | undefined;
+    readonly onGoalSchedule?: ((command: string) => void) | undefined;
+    readonly onGoalGetFiles?: (() => void) | undefined;
+    readonly onGoalStartAnother?: (() => void) | undefined;
+    /**
+     * Spec 2026-09-16 §4a — the subagents of this part's message, so an approval
+     * card a subagent raised can name it. Absent = no attribution.
+     */
+    readonly subagents?: SubagentMessageIndex | undefined;
 };
-/**
- * The AI SDK's `UIMessagePart` union is open at the patch-version
- * boundary, so we cannot use `.exhaustive()` here — `.otherwise(() =>
- * null)` keeps unknown variants quiet. The supported types come from
- * `BelongDataParts` (above) plus the SDK's built-in `text` and
- * `reasoning` parts.
- */
-export declare const PartRenderer: ({ part, onExecutePlan, historical, onContinueConnector, onFollowContinuation, }: PartRendererProps) => import("react").JSX.Element | null;
+export declare const PartRenderer: ({ part, onExecutePlan, onConfirmGoal, onEditGoalProposal, onOpenGoalProposal, isGoalProposalStarted, goalProposalSessionId, historical, live, onContinueConnector, renderGoalSetCard, goalFileCount, onGoalSchedule, onGoalGetFiles, onGoalStartAnother, onFollowContinuation, subagents, }: PartRendererProps) => import("react").JSX.Element | null;
 export type RenderGroup = {
     readonly kind: "part";
     readonly part: BelongMessagePart;
@@ -84,3 +118,4 @@ export type RenderGroup = {
 };
 export declare const groupMessageParts: (parts: readonly BelongMessagePart[]) => readonly RenderGroup[];
 export type { BelongDataParts };
+export type { ActivityItem, ToolActivityItem } from './activity-items.ts';