@belonguniverseai/react-sdk 0.6.21 → 0.6.23

package/dist/api/goals.d.ts

@@ -0,0 +1,179 @@
+import { z } from 'zod';
+export declare const goalStatusSchema: 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";
+}>;
+export type GoalStatus = z.infer<typeof goalStatusSchema>;
+/**
+ * One line of the panel's History (M6). `kind` and `actor` are OPEN strings,
+ * not enums, for the same reason `statusPartSchema.retryable` is optional in
+ * the transport: a value this dock predates must never make `safeParse` drop
+ * the whole goal view — the line falls back to a neutral label instead.
+ */
+export declare const goalJournalEntrySchema: 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>;
+export type GoalJournalEntry = z.infer<typeof goalJournalEntrySchema>;
+export declare const goalViewSchema: 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>;
+export type GoalView = z.infer<typeof goalViewSchema>;
+type FetchGoalOutcome = {
+    readonly status: "goal";
+    readonly goal: GoalView;
+} | {
+    readonly status: "none" | "disabled" | "error";
+};
+export type GoalActionOutcome = {
+    readonly status: "ok";
+    readonly goalStatus: GoalStatus;
+    readonly revived?: boolean;
+} | {
+    readonly status: "conflict";
+    readonly goalStatus: GoalStatus;
+} | {
+    readonly status: "not_found" | "disabled" | "error";
+};
+/**
+ * `GET /v1/sessions/:id/goal`. 404 (`goal_not_found`) means the session has
+ * no goal at all — a normal, common state, not an error — so it collapses to
+ * `{ status: "none" }` rather than `"error"`. 503 (`goals_disabled`) is the
+ * tenant-level feature flag being off.
+ */
+export declare const fetchSessionGoal: (apiBaseUrl: string, sessionId: string) => Promise<FetchGoalOutcome>;
+export declare const pauseSessionGoal: (apiBaseUrl: string, sessionId: string) => Promise<GoalActionOutcome>;
+export declare const resumeSessionGoal: (apiBaseUrl: string, sessionId: string) => Promise<GoalActionOutcome>;
+export declare const clearSessionGoal: (apiBaseUrl: string, sessionId: string) => Promise<GoalActionOutcome>;
+/**
+ * `POST /v1/sessions/:id/goal/snooze` — the footer's Snooze ▾ menu. Same
+ * 202/404/409/503 mapping as {@link goalAction} (this reuses its 202/409 body
+ * parsing exactly — the 202 shape is the same `{ status }`), except the 409
+ * conflict here is `goal_not_snoozable` (a goal that is not currently one of
+ * the four snoozable statuses — e.g. already `deferred`), which the footer
+ * shows through the same generic `failedSnooze` line rather than a
+ * status-specific one (unlike pause/resume/clear): there is exactly one
+ * snooze failure message, so every non-`ok` outcome — conflict, not found,
+ * disabled, or a plain network/parse error — reads the same way to the user.
+ */
+export declare const snoozeSessionGoal: (apiBaseUrl: string, sessionId: string, wakeAt: Date) => Promise<GoalActionOutcome>;
+/** `POST /v1/sessions/:id/goal/edit` request body — every field optional,
+ *  but the backend rejects a body with none of them set (`goal_edit_no_change`
+ *  only fires when the values match the *current* row; an empty body fails
+ *  Zod validation on the backend before it ever reaches that check). */
+export type GoalEditInput = {
+    readonly objective?: string;
+    readonly tokenBudget?: number;
+    readonly maxTurns?: number;
+};
+/**
+ * `POST /v1/sessions/:id/goal/edit`. Unlike {@link goalAction} this rides a
+ * JSON body (§4 — Content-Type required so the backend's `zValidator("json")`
+ * actually parses it instead of silently treating a missing/wrong
+ * Content-Type as `{}`). The 202 body carries `revived` — the edit raised a
+ * cap past `turns_used`/`tokens_used` and un-stalled a `budget_limited` goal
+ * — which `runGoalCommand` (chat.tsx) uses to pick between `goal.edited` and
+ * `goal.revived`. Both 409 variants the backend can return
+ * (`goal_not_editable`: the goal's current state can never be edited;
+ * `goal_edit_conflict`: a concurrent edit raced this one) collapse to the
+ * same `"conflict"` outcome — the dock has one notice for "try again",
+ * `goal.notEditable`, regardless of which race produced it.
+ */
+export declare const editSessionGoal: (apiBaseUrl: string, sessionId: string, input: GoalEditInput) => Promise<GoalActionOutcome | {
+    readonly status: "no_change";
+}>;
+export {};

package/dist/api/issue-reports.d.ts

@@ -0,0 +1,13 @@
+import { IssueReportRequest } from '../embed/issue-report-bus.ts';
+export type SubmitIssueReportResult = {
+    readonly ok: true;
+    readonly reportId: string;
+} | {
+    readonly ok: false;
+    readonly reason: "too_large" | "unsupported_media" | "request_failed";
+};
+export declare const submitIssueReport: (apiBaseUrl: string, input: {
+    readonly request: IssueReportRequest;
+    readonly message: string;
+    readonly includeScreenshot: boolean;
+}) => Promise<SubmitIssueReportResult>;

package/dist/api/query-keys.d.ts

@@ -15,13 +15,21 @@ export declare const queryKeys: {
      * `workspaceKey` is the scoped id, or "" when unconfigured.
      */
     sessionList: (workspaceKey: string, limit: number) => readonly ["belong", "sessions", "list", string, number];
+    /** Invalidation prefix for every skills-inventory read. */
     skills: readonly ["belong", "skills"];
+    /**
+     * Workspace-scoped `/` inventory (skill-library D1): library skills differ per
+     * workspace. Keeps `skills` as its prefix so existing invalidations still hit it.
+     * `workspaceKey` is the scoped id, or "" when unscoped.
+     */
+    skillsScoped: (workspaceKey: string) => readonly ["belong", "skills", string];
     workspaceFiles: readonly ["belong", "workspace-files"];
     /** Workspace-scoped Files tab / @-mention picker cache (same "" convention). */
     workspaceFilesScoped: (workspaceKey: string) => readonly ["belong", "workspace-files", string];
     agentGrant: (provider: string, scopeExternalId: string) => readonly ["belong", "agent-grant", string, string];
     /** Invalidation prefix for every task-schedule read (list + detail + runs). */
     taskSchedules: readonly ["belong", "task-schedules"];
+    apiKeys: (ownerCacheKey: string) => readonly ["belong", "api-keys", string];
     taskScheduleList: (workspaceKey: string, filter: string, q: string) => readonly ["belong", "task-schedules", "list", string, string, string];
     taskSchedule: (workspaceKey: string, taskScheduleId: string) => readonly ["belong", "task-schedules", "detail", string, string];
     taskScheduleRuns: (workspaceKey: string, taskScheduleId: string) => readonly ["belong", "task-schedules", "detail", string, string, "runs"];
@@ -29,6 +37,17 @@ export declare const queryKeys: {
     prePrompts: readonly ["belong", "pre-prompts"];
     /** Workspace-scoped saved-prompt list (same "" unscoped convention). */
     prePromptList: (workspaceKey: string) => readonly ["belong", "pre-prompts", "list", string];
+    /** Invalidation prefix for every skill-library read (skill library spec §11.2). */
+    skillLibrary: readonly ["belong", "skill-library"];
+    /** Workspace-scoped library list ("" unscoped, "__missing__" never fetched). */
+    skillLibraryList: (workspaceKey: string) => readonly ["belong", "skill-library", "list", string];
+    /**
+     * UNSCOPED deployment probe: written by every list resolution, read by the
+     * rail. Whether the feature exists is a property of the CELL, not of a
+     * workspace — keying it per workspace would pop a dead rail entry back in on
+     * every host workspace switch (R61).
+     */
+    skillLibraryAvailability: readonly ["belong", "skill-library", "availability"];
     /**
      * Invalidation prefix for every custom-connector read. NOT workspace-scoped:
      * `/v1/connectors` keys off the CALLER, not a workspace — a user's connected

package/dist/api/report-client-error.d.ts

@@ -6,6 +6,9 @@
  * `POST /v1/telemetry/client` (telemetry.routes.ts) so they surface in
  * Loki/Tempo keyed by the SAME `session.id` the user copies from the dock.
  *
+ * Also feeds them into the local client-error buffer (client-error-log.ts) so
+ * an issue report can carry the tail of what already went wrong in this tab.
+ *
  * Best-effort and unobtrusive by construction:
  *  - never throws into the caller's failure path (the report rides ON a failure);
  *  - uses `navigator.sendBeacon` with a `text/plain` body so it survives a page

package/dist/api/retry-fetch.d.ts

@@ -26,6 +26,25 @@
  *
  * Time and randomness are injectable (CLAUDE.md §25/§26); production callers
  * use the exported `retryingFetch` singleton.
+ *
+ * A 429 and a 503 get one more distinction on top of the policy above
+ * (task-9 fix round 1, review finding 2; team review S-I4): an application
+ * refusal — a goal-cap 429 (`goal_cap_user` / `goal_cap_tenant`) or the
+ * `goals_disabled` 503 the feature flag answers with (`session.routes.ts`,
+ * `goal.routes.ts`) — is a business-rule decision, not an ingress
+ * scale-out reject. Every retry replays to the exact same answer, just ~9s
+ * slower, and the user watches the composer hang before the dock can show
+ * copy it already has. The infrastructure rejects those two statuses carry
+ * NO body at all (Cloud Run's ingress 429; a cold-start or rolling-deploy
+ * 503), so the two are distinguishable by content: a 429 or 503 whose body
+ * parses as JSON with a string `error.type` is treated as terminal and
+ * returned to the caller immediately; anything else (empty body, non-JSON,
+ * JSON that doesn't match) keeps the existing transient-retry behavior.
+ *
+ * 408/502/504 stay out of it deliberately: no route on this backend answers
+ * a typed refusal with one, so a typed body on those could only come from
+ * something between us and the app — and believing it would end a ladder
+ * that exists precisely for that layer.
  */
 export declare const TRANSIENT_STATUSES: ReadonlySet<number>;
 /** Total attempts including the first. 5 attempts ≈ 8–12s of cumulative

package/dist/api/session-end.d.ts

@@ -0,0 +1,2 @@
+import { ApiClient } from './client.ts';
+export declare const endSessionForNewChat: (api: ApiClient, sessionId: string) => Promise<void>;

package/dist/api/skill-library.d.ts

@@ -0,0 +1,100 @@
+import { QueryClient, UseQueryResult } from '@tanstack/react-query';
+import { ApiClient } from './client.ts';
+export type SkillLibraryItem = {
+    readonly userSkillId: string;
+    readonly name: string;
+    readonly description: string;
+    readonly enabled: boolean;
+    readonly revision: number;
+    readonly hasScripts: boolean;
+    readonly filesCount: number;
+    readonly archiveSizeBytes: number;
+    readonly updatedAt: string;
+};
+export type SkillLibraryListResult = {
+    readonly status: "ready";
+    readonly skills: readonly SkillLibraryItem[];
+} | {
+    readonly status: "featureAbsent";
+};
+export type SkillLibraryAvailability = "available" | "absent";
+export type SkillNameReservedBy = "company_skill" | "dock_command" | "platform_skill" | "saved_prompt";
+export type ImportSkillInput = {
+    readonly file: File;
+    /** crypto.randomUUID(), minted when the upload dialog opens and again on every accepted file pick (a retry of the same pick reuses it). */
+    readonly clientSaveId: string;
+    readonly onNameConflict: "reject" | "replace";
+};
+export type ImportSkillOutcome = {
+    readonly status: "saved";
+    readonly outcome: "created" | "replaced" | "unchanged" | "idempotent";
+    readonly userSkillId: string;
+    readonly name: string;
+    readonly revision: number;
+    readonly hasScripts: boolean;
+} | {
+    readonly status: "name_taken";
+    readonly name: string;
+    readonly userSkillId: string;
+} | {
+    readonly status: "name_reserved";
+    readonly name: string;
+    readonly reservedBy: SkillNameReservedBy;
+} | {
+    readonly status: "content_reserved";
+} | {
+    readonly status: "invalid_skill_archive";
+    readonly reason: string;
+} | {
+    readonly status: "archive_too_large";
+    readonly maxArchiveBytes: number;
+} | {
+    readonly status: "limit_reached";
+    readonly maxCount: number;
+} | {
+    readonly status: "feature_absent";
+} | {
+    readonly status: "error";
+};
+export type SetSkillEnabledOutcome = {
+    readonly status: "updated";
+    readonly userSkillId: string;
+    readonly enabled: boolean;
+} | {
+    readonly status: "not_found";
+} | {
+    readonly status: "error";
+};
+export type DeleteSkillOutcome = {
+    readonly status: "deleted";
+} | {
+    readonly status: "not_found";
+} | {
+    readonly status: "error";
+};
+export declare const listSkillLibraryRequest: (api: ApiClient, query: {
+    readonly workspaceExternalId?: string;
+}, signal?: AbortSignal) => Promise<SkillLibraryListResult>;
+export declare const useSkillLibrary: () => UseQueryResult<SkillLibraryListResult>;
+/**
+ * Does this deployment have the skill library? FALSE until some list call has
+ * RESOLVED `featureAbsent` — while loading, on an outage, or in a missing scope
+ * before any probe resolved, the rail keeps its entry (a late pop-in reads as a
+ * glitch; an outage must not look like a feature that was never there).
+ */
+export declare const useSkillLibraryFeatureAbsent: () => boolean;
+/** Invalidates BOTH the library and the skills inventory. */
+export declare const invalidateSkillCaches: (queryClient: QueryClient) => Promise<void>;
+/**
+ * Raw `fetch` + FormData, because Hono RPC has no multipart path in the SDK
+ * (the `routes/documents.tsx` precedent). Not retried transparently; the
+ * per-pick `clientSaveId` (minted on open and on every accepted file pick)
+ * makes a manual retry of the same pick idempotent.
+ */
+export declare const useImportSkill: () => import('@tanstack/react-query').UseMutationResult<ImportSkillOutcome, Error, ImportSkillInput, unknown>;
+export declare const useSetSkillEnabled: () => import('@tanstack/react-query').UseMutationResult<SetSkillEnabledOutcome, Error, {
+    readonly userSkillId: string;
+    readonly enabled: boolean;
+}, unknown>;
+export declare const useDeleteSkill: () => import('@tanstack/react-query').UseMutationResult<DeleteSkillOutcome, Error, string, unknown>;
+export declare const skillLibraryDownloadUrl: (baseUrl: string, userSkillId: string) => string;

package/dist/api/skills.d.ts

@@ -29,5 +29,7 @@ export type SlashInventory = {
     readonly skills: readonly SkillSummary[];
     readonly commands: readonly CommandSummary[];
 };
-export declare const listSkillsRequest: (api: ApiClient) => Promise<SlashInventory>;
+export declare const listSkillsRequest: (api: ApiClient, query?: {
+    readonly workspaceExternalId?: string;
+}, signal?: AbortSignal) => Promise<SlashInventory>;
 export declare const useSkills: () => import('@tanstack/react-query').UseQueryResult<NoInfer<SlashInventory>, Error>;

package/dist/api/task-schedule-sharing.d.ts

@@ -0,0 +1,166 @@
+import { z } from 'zod';
+import { UpdateTaskScheduleSeriesInput } from './task-schedules.ts';
+export declare const sharedScheduleSchema: z.ZodObject<{
+    definitionId: z.ZodUUID;
+    title: z.ZodString;
+    explicitTitle: z.ZodNullable<z.ZodString>;
+    message: z.ZodString;
+    role: z.ZodEnum<{
+        edit: "edit";
+        use: "use";
+        owner: "owner";
+    }>;
+    owner: z.ZodString;
+    ownerTenant: z.ZodString;
+    revision: z.ZodNumber;
+    timeExpression: z.ZodString;
+    timezone: z.ZodString;
+    recurrence: z.ZodPipe<z.ZodObject<{
+        kind: z.ZodEnum<{
+            none: "none";
+            manual: "manual";
+            daily: "daily";
+            weekdays: "weekdays";
+            weekly: "weekly";
+            interval: "interval";
+        }>;
+        intervalMinutes: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodTransform<{
+        readonly kind: "none";
+    } | {
+        readonly kind: "daily";
+    } | {
+        readonly kind: "weekdays";
+    } | {
+        readonly kind: "weekly";
+    } | {
+        readonly kind: "manual";
+    } | {
+        readonly kind: "interval";
+        readonly intervalMinutes: number;
+    }, {
+        kind: "none" | "manual" | "daily" | "weekdays" | "weekly" | "interval";
+        intervalMinutes?: number | undefined;
+    }>>;
+    anchorAt: z.ZodISODateTime;
+    templateName: z.ZodNullable<z.ZodString>;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strip>;
+export type SharedSchedule = z.infer<typeof sharedScheduleSchema>;
+export declare const useSharedSchedules: () => import('@tanstack/react-query').UseInfiniteQueryResult<{
+    definitionId: string;
+    title: string;
+    explicitTitle: string | null;
+    message: string;
+    role: "edit" | "use" | "owner";
+    owner: string;
+    ownerTenant: string;
+    revision: number;
+    timeExpression: string;
+    timezone: string;
+    recurrence: {
+        readonly kind: "none";
+    } | {
+        readonly kind: "daily";
+    } | {
+        readonly kind: "weekdays";
+    } | {
+        readonly kind: "weekly";
+    } | {
+        readonly kind: "manual";
+    } | {
+        readonly kind: "interval";
+        readonly intervalMinutes: number;
+    };
+    anchorAt: string;
+    templateName: string | null;
+    updatedAt: string;
+}[], Error>;
+export declare const useSharingAccount: () => import('@tanstack/react-query').UseQueryResult<NoInfer<{
+    account: string;
+    tenant: string;
+}>, Error>;
+export declare const useSharedSchedule: (definitionId: string | null) => import('@tanstack/react-query').UseQueryResult<NoInfer<{
+    definitionId: string;
+    title: string;
+    explicitTitle: string | null;
+    message: string;
+    role: "edit" | "use" | "owner";
+    owner: string;
+    ownerTenant: string;
+    revision: number;
+    timeExpression: string;
+    timezone: string;
+    recurrence: {
+        readonly kind: "none";
+    } | {
+        readonly kind: "daily";
+    } | {
+        readonly kind: "weekdays";
+    } | {
+        readonly kind: "weekly";
+    } | {
+        readonly kind: "manual";
+    } | {
+        readonly kind: "interval";
+        readonly intervalMinutes: number;
+    };
+    anchorAt: string;
+    templateName: string | null;
+    updatedAt: string;
+}>, Error>;
+export declare const useScheduleAccess: (definitionId: string | null) => import('@tanstack/react-query').UseQueryResult<NoInfer<{
+    people: {
+        tenantId: string;
+        userId: string;
+        role: "edit" | "use";
+        label: string;
+        tenant: string;
+    }[];
+    invitations: {
+        id: string;
+        role: "edit" | "use";
+        expiresAt: string;
+        token: string | null;
+    }[];
+}>, Error>;
+export declare const useShareSchedule: () => import('@tanstack/react-query').UseMutationResult<{
+    definitionId: string;
+}, Error, string, unknown>;
+export declare const useCreateScheduleInvitation: () => import('@tanstack/react-query').UseMutationResult<{
+    invitationId: string;
+    token: string;
+    expiresAt: string;
+}, Error, {
+    readonly definitionId: string;
+    readonly role: "use" | "edit";
+}, unknown>;
+export declare const useAcceptScheduleInvitation: () => import('@tanstack/react-query').UseMutationResult<{
+    definitionId: string;
+}, Error, string, unknown>;
+export declare const useEnableSharedSchedule: () => import('@tanstack/react-query').UseMutationResult<{
+    taskScheduleId: string;
+}, Error, string, unknown>;
+export declare const useUpdateSharedSchedule: () => import('@tanstack/react-query').UseMutationResult<{
+    status: "updated";
+    revision: number;
+}, Error, {
+    readonly definitionId: string;
+    readonly patch: Omit<UpdateTaskScheduleSeriesInput["patch"], "mode" | "expectedRevision"> & {
+        readonly expectedRevision: number;
+    };
+}, unknown>;
+export declare const useChangeScheduleAccess: () => import('@tanstack/react-query').UseMutationResult<{
+    status: string;
+}, Error, {
+    readonly definitionId: string;
+    readonly tenantId: string;
+    readonly userId: string;
+    readonly role: "use" | "edit" | "remove";
+}, unknown>;
+export declare const useCancelScheduleInvitation: () => import('@tanstack/react-query').UseMutationResult<{
+    status: string;
+}, Error, {
+    readonly definitionId: string;
+    readonly invitationId: string;
+}, unknown>;

package/dist/api/task-schedules.d.ts

@@ -120,6 +120,7 @@ export declare const taskScheduleSeriesStatusSchema: z.ZodEnum<{
 export type TaskScheduleSeriesStatus = z.infer<typeof taskScheduleSeriesStatusSchema>;
 export type TaskScheduleFilter = "all" | "upcoming" | "completed";
 declare const taskScheduleListItemSchema: z.ZodObject<{
+    shared: z.ZodOptional<z.ZodBoolean>;
     taskScheduleId: z.ZodUUID;
     title: z.ZodString;
     status: z.ZodEnum<{
@@ -170,6 +171,7 @@ declare const taskScheduleListItemSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type TaskScheduleListItem = z.infer<typeof taskScheduleListItemSchema>;
 export declare const taskScheduleDetailSchema: z.ZodObject<{
+    shared: z.ZodOptional<z.ZodBoolean>;
     taskScheduleId: z.ZodUUID;
     title: z.ZodString;
     status: z.ZodEnum<{
@@ -217,6 +219,17 @@ export declare const taskScheduleDetailSchema: z.ZodObject<{
     }, z.core.$strip>>;
     messagePreview: z.ZodString;
     createdAt: z.ZodISODateTime;
+    sharing: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        definitionId: z.ZodUUID;
+        role: z.ZodEnum<{
+            edit: "edit";
+            revoked: "revoked";
+            use: "use";
+            owner: "owner";
+        }>;
+        revision: z.ZodNumber;
+        workspaceCount: z.ZodNumber;
+    }, z.core.$strip>>>;
     explicitTitle: z.ZodDefault<z.ZodNullable<z.ZodString>>;
     message: z.ZodString;
     mode: z.ZodEnum<{
@@ -304,6 +317,7 @@ export declare const useTaskSchedules: (filter: TaskScheduleFilter, q: string) =
     } | null;
     messagePreview: string;
     createdAt: string;
+    shared?: boolean | undefined;
 }[], Error>;
 export declare const useTaskSchedule: (taskScheduleId: string | null) => import('@tanstack/react-query').UseQueryResult<NoInfer<{
     taskScheduleId: string;
@@ -360,6 +374,13 @@ export declare const useTaskSchedule: (taskScheduleId: string | null) => import(
         maxMessagesPerRun: number;
         expiresAt: string;
     } | null;
+    shared?: boolean | undefined;
+    sharing?: {
+        definitionId: string;
+        role: "edit" | "revoked" | "use" | "owner";
+        revision: number;
+        workspaceCount: number;
+    } | null | undefined;
 }>, Error>;
 export declare const useTaskScheduleRuns: (taskScheduleId: string | null) => import('@tanstack/react-query').UseInfiniteQueryResult<{
     taskScheduleRunId: string;
@@ -386,6 +407,7 @@ export type CreateTaskScheduleSeriesInput = {
 export type UpdateTaskScheduleSeriesInput = {
     readonly taskScheduleId: string;
     readonly patch: {
+        readonly expectedRevision?: number;
         readonly title?: string | null;
         readonly message?: string;
         readonly scheduledFor?: string;
@@ -407,7 +429,7 @@ export declare const usePauseTaskSchedule: () => import('@tanstack/react-query')
     status: "paused";
 }, Error, string, unknown>;
 export declare const useResumeTaskSchedule: () => import('@tanstack/react-query').UseMutationResult<{
-    status: "active" | "completed";
+    status: "active" | "completed" | "needs_attention";
     nextRunAt: string | null;
 }, Error, string, unknown>;
 export declare const useRunNowTaskSchedule: () => import('@tanstack/react-query').UseMutationResult<{

package/dist/app/BelongDock.d.ts

@@ -1,29 +1 @@
-/**
- * BelongDock — right-edge (or left-edge) docked assistant shell.
- *
- * Layout:
- *   - A 52px rail (EmbedRail) is always visible on the chosen edge: user
- *     avatar (account + theme controls), Chat / Terminal / Files nav, and a
- *     collapse/expand toggle.
- *   - When not collapsed, a panel sits beside the rail: EmbedHeader (mark,
- *     title, Chats menu, TTS speaker, fullscreen toggle) over the active view's
- *     body (chat / files via the router <Outlet/>).
- *   - Three width states (collapsed / expanded / fullscreen) come from
- *     embed/dock-layout.ts; the host <body> margin reserves the same width so
- *     the dock never overlaps host content.
- *
- * Theme:
- *   - `peekTheme()` / `subscribeTheme()` are the live store; the host (Anna)
- *     pushes updates via `window.belong.setTheme(...)`. Belong/Ocean is the
- *     default palette but a host brand push still re-themes everything.
- *   - The dock applies the active palette as inline CSS variables on its root
- *     so values cascade to every descendant. Dark mode + side toggles live in
- *     the rail-top avatar menu (toggleThemeMode / toggleThemeSide).
- *
- * Auth gate:
- *   - With no auth source (`hasBelongAuthSource()` false) the panel shows
- *     EmbedLogin; once the host provides one — a static token, a sync provider,
- *     or the component embed's async `getToken` — the gate flips and chat
- *     renders. It's not a reactive store, so we poll it into local state.
- */
 export declare const BelongDock: () => import("react").JSX.Element | null;

package/dist/app/dock-demo-features.d.ts

@@ -0,0 +1,13 @@
+export type DemoBrand = "belong" | "simetrik";
+export declare const createDemoFeatureRoutes: (brand: DemoBrand, sessions: {
+    readonly main: string;
+    readonly second: string;
+}, enabled: boolean) => {
+    skills: () => {
+        name: string;
+        description: string;
+        group: string;
+        source: string;
+    }[];
+    fetch: (request: Request, path: string) => Promise<Response | null>;
+};