@belonguniverseai/react-sdk 0.6.20 → 0.6.22

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

@@ -0,0 +1,226 @@
+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;
+};
+/** `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,16 @@ export type QueuedMessage = {
     readonly submittedAt: number;
     readonly state: "queued" | "failed";
 };
-export declare const ChatRoute: ({ sessionId, reconcileBackgroundRun, }?: {
+export declare const ChatRoute: ({ sessionId, reconcileBackgroundRun, onOpenGoalView, onOpenFilesView, }?: {
     readonly sessionId?: 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/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,29 +1,19 @@
-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 { MessageContinuation } from './message-continuation.ts';
+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 = {
@@ -50,7 +40,31 @@ export type PartRendererProps = {
      * 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
+     * card's 200 names it). Absent = the card resolves and follows nothing.
+     */
+    readonly onFollowContinuation?: ((continuation: MessageContinuation) => void) | undefined;
     /**
      * The part belongs to a restored-history message (`metadata.fromHistory`,
      * stamped by `loadSessionHistory`). The dispatch renderers (navigation,
@@ -58,6 +72,36 @@ 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
@@ -66,7 +110,7 @@ export type PartRendererProps = {
  * `BelongDataParts` (above) plus the SDK's built-in `text` and
  * `reasoning` parts.
  */
-export declare const PartRenderer: ({ part, onExecutePlan, historical, onContinueConnector, }: PartRendererProps) => import("react").JSX.Element | null;
+export declare const PartRenderer: ({ part, onExecutePlan, onConfirmGoal, onEditGoalProposal, onOpenGoalProposal, isGoalProposalStarted, goalProposalSessionId, historical, onContinueConnector, renderGoalSetCard, goalFileCount, onGoalSchedule, onGoalGetFiles, onGoalStartAnother, onFollowContinuation, subagents, }: PartRendererProps) => import("react").JSX.Element | null;
 export type RenderGroup = {
     readonly kind: "part";
     readonly part: BelongMessagePart;
@@ -78,3 +122,4 @@ export type RenderGroup = {
 };
 export declare const groupMessageParts: (parts: readonly BelongMessagePart[]) => readonly RenderGroup[];
 export type { BelongDataParts };
+export type { ActivityItem, ToolActivityItem } from './activity-items.ts';

package/dist/stream/belong-chat-transport.d.ts

@@ -22,9 +22,9 @@ export declare const choiceAnswerSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
 export declare const choiceStateSchema: z.ZodEnum<{
     detached: "detached";
     pending: "pending";
+    cancelled: "cancelled";
     dismissed: "dismissed";
     answered: "answered";
-    cancelled: "cancelled";
 }>;
 /**
  * The wire/stored part union. Exported so the history loader (chat.tsx) can
@@ -129,6 +129,22 @@ export declare const wireStreamPartSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
         stepsUsed: z.ZodOptional<z.ZodNumber>;
         summary: z.ZodOptional<z.ZodString>;
         timedOut: z.ZodOptional<z.ZodBoolean>;
+        outcome: z.ZodCatch<z.ZodOptional<z.ZodEnum<{
+            error: "error";
+            ok: "ok";
+            timeout: "timeout";
+            stopped: "stopped";
+            stalled: "stalled";
+            interrupted: "interrupted";
+        }>>>;
+        queued: z.ZodOptional<z.ZodBoolean>;
+        startedAt: z.ZodOptional<z.ZodString>;
+        durationMs: z.ZodOptional<z.ZodNumber>;
+        tokensCount: z.ZodOptional<z.ZodNumber>;
+        waveId: z.ZodOptional<z.ZodString>;
+        groupLabel: z.ZodOptional<z.ZodString>;
+        planStepId: z.ZodOptional<z.ZodString>;
+        stoppable: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>;
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"data-sandbox-command">;
@@ -195,6 +211,8 @@ export declare const wireStreamPartSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
             throttled: "throttled";
         }>;
         message: z.ZodOptional<z.ZodString>;
+        outcome: z.ZodOptional<z.ZodString>;
+        terminationReason: z.ZodOptional<z.ZodString>;
         retryable: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>;
 }, z.core.$strip>, z.ZodObject<{
@@ -226,9 +244,9 @@ export declare const wireStreamPartSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
         state: z.ZodEnum<{
             detached: "detached";
             pending: "pending";
+            cancelled: "cancelled";
             dismissed: "dismissed";
             answered: "answered";
-            cancelled: "cancelled";
         }>;
         questions: z.ZodArray<z.ZodObject<{
             id: z.ZodString;
@@ -253,6 +271,92 @@ export declare const wireStreamPartSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
         }, z.core.$strip>], "kind">>>;
         reply: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"data-goal">;
+    id: z.ZodString;
+    data: z.ZodObject<{
+        goalId: z.ZodString;
+        status: z.ZodEnum<{
+            active: "active";
+            paused: "paused";
+            clarifying: "clarifying";
+            completion_claimed: "completion_claimed";
+            deferred: "deferred";
+            waiting_for_user: "waiting_for_user";
+            waiting_for_approval: "waiting_for_approval";
+            waiting_for_ui_action: "waiting_for_ui_action";
+            blocked: "blocked";
+            budget_limited: "budget_limited";
+            complete: "complete";
+            cleared: "cleared";
+        }>;
+        statusReason: z.ZodNullable<z.ZodString>;
+        objective: z.ZodString;
+        successCriteria: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            text: z.ZodString;
+            status: z.ZodEnum<{
+                open: "open";
+                met: "met";
+            }>;
+            evidence: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>;
+        constraints: z.ZodArray<z.ZodString>;
+        tokensUsed: z.ZodNumber;
+        tokenBudget: z.ZodNumber;
+        turnsUsed: z.ZodNumber;
+        maxTurns: z.ZodNumber;
+        activeSeconds: z.ZodNumber;
+        maxActiveSeconds: z.ZodNumber;
+        lastProgressNote: z.ZodNullable<z.ZodString>;
+        updatedAt: z.ZodString;
+        startedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        originatingClientMessageId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        clarifyMaxQuestions: z.ZodOptional<z.ZodNumber>;
+        judgeFeedback: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        judgeRejections: z.ZodOptional<z.ZodNumber>;
+        clarifyingTurns: z.ZodOptional<z.ZodNumber>;
+        resumeAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        journal: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            seq: z.ZodNumber;
+            kind: z.ZodString;
+            actor: z.ZodString;
+            toStatus: z.ZodNullable<z.ZodEnum<{
+                active: "active";
+                paused: "paused";
+                clarifying: "clarifying";
+                completion_claimed: "completion_claimed";
+                deferred: "deferred";
+                waiting_for_user: "waiting_for_user";
+                waiting_for_approval: "waiting_for_approval";
+                waiting_for_ui_action: "waiting_for_ui_action";
+                blocked: "blocked";
+                budget_limited: "budget_limited";
+                complete: "complete";
+                cleared: "cleared";
+            }>>;
+            note: z.ZodNullable<z.ZodString>;
+            at: z.ZodString;
+        }, z.core.$strip>>>;
+        runway: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            quick: "quick";
+            normal: "normal";
+            long: "long";
+        }>>>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"data-goal-proposal">;
+    id: z.ZodString;
+    data: z.ZodObject<{
+        objective: z.ZodString;
+        why: z.ZodString;
+        criteria: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        runway: z.ZodOptional<z.ZodEnum<{
+            quick: "quick";
+            normal: "normal";
+            long: "long";
+        }>>;
+    }, z.core.$strip>;
 }, z.core.$strip>], "type">;
 /** A request was 401'd twice (once with a freshly re-read token): the host
  * session is expired — the dock must surface re-auth, not retry forever. */
@@ -260,6 +364,22 @@ export declare const AUTH_EXPIRED_ERROR_PREFIX = "auth_expired:";
 /** The SSE reconnect loop exhausted its attempt budget without the backend
  * delivering a single event — the service is unreachable. */
 export declare const BACKEND_UNAVAILABLE_ERROR_PREFIX = "backend_unavailable:";
+/**
+ * `POST /v1/sessions/:id/messages` refused the send. Carries the raw status
+ * + body — the same shape as `AttachmentUploadError`'s precedent
+ * (`chat-upload.ts`) — so a caller can recognize a SPECIFIC refusal (e.g. the
+ * goal-cap 429s, `goal_cap_user` / `goal_cap_tenant`) instead of pattern-
+ * matching the thrown `Error`'s message string. Deviation 11: this is the
+ * minimum honest channel — the send path had no error surface at all before
+ * this, so `goal_exists` and the new caps were previously invisible in the
+ * dock. The message text is unchanged from the plain `Error` this replaces,
+ * so every existing `.rejects.toThrow(...)` assertion still passes.
+ */
+export declare class PostMessageError extends Error {
+    readonly status: number;
+    readonly body: string;
+    constructor(status: number, body: string);
+}
 /** First reconnect delay — identical to the historic fixed delay, so the
  * BEL-48 mid-run clean-EOF reconnect regains the stream just as fast. */
 export declare const RECONNECT_BASE_DELAY_MS = 1000;
@@ -372,6 +492,9 @@ export declare class BelongChatTransport implements ChatTransport<BelongUIMessag
     get sessionId(): string | null;
     /** The construction-captured workspace (see #workspaceExternalId). */
     get workspaceExternalId(): string | null;
+    /** Includes an outstanding SSE handshake and the transport's retry loop,
+     * which can own the Session before useChat reports `streaming`. */
+    get hasLiveStream(): boolean;
     /** Drop the cached session so the next `sendMessages` creates a new one. */
     reset(): void;
     /**
@@ -386,6 +509,28 @@ export declare class BelongChatTransport implements ChatTransport<BelongUIMessag
      * best-effort.
      */
     cancelRun: (runId: string) => Promise<readonly RecalledQueuedMessage[]>;
+    /**
+     * Spec 2026-09-16 §1.4/§3.5 — ask belong-cloud to stop ONE subagent of a
+     * live run (`POST /v1/runs/:runId/subagents/:subagentId/stop`, 202
+     * `{ status: "stop_requested" }`). Modelled on `cancelRun`: same auth
+     * headers, same transient retries (the route is idempotent, §18). It changes
+     * nothing locally — the lane flips only when the `subagent_finished` part
+     * arrives — and the stop is best-effort BY DESIGN (spec §5: the backend
+     * swallows delivery failures too), so the dock promises nothing here.
+     *
+     * The two failure families are deliberately NOT collapsed into one. A 404
+     * (`subagent_not_found`, or an API that has not deployed the route yet) and a
+     * 409 (`subagent_not_running` — it finished while the user was clicking) are
+     * ordinary things that happen to a working product: the lane simply never
+     * flips and nothing is said. A 401 is something else entirely — the host
+     * session going stale mid-click — so it takes the same §C3 treatment every
+     * other authed call in this transport gets: one FORCED token rotation and one
+     * retry, which makes a merely stale token still stop the subagent. Only a
+     * SECOND 401 is a genuinely expired session, and that is reported as
+     * `auth_expired` (the evidence behind the dock's re-auth surface), never as an
+     * unaccepted stop.
+     */
+    stopSubagent: (runId: string, subagentId: string) => Promise<void>;
     sendMessages: ChatTransport<BelongUIMessage>["sendMessages"];
     reconnectToStream: ChatTransport<BelongUIMessage>["reconnectToStream"];
 }