@talgent/workbench-ui 0.0.0 → 0.2.0

package/lib/model-vendors.ts

@@ -0,0 +1,13 @@
+import { ModelVendor } from "@talgent/workbench-contracts/agent/public/v1/model_pb";
+
+// Each Model Vendor the platform knows has a bundled mark; see product-icons/README.md.
+export const modelVendors: Record<ModelVendor, { label: string; icon?: string }> = {
+  [ModelVendor.UNSPECIFIED]: { label: "Model" },
+  [ModelVendor.ANTHROPIC]: { label: "Anthropic", icon: "anthropic" },
+  [ModelVendor.OPENAI]: { label: "OpenAI", icon: "openai" },
+  [ModelVendor.DEEPSEEK]: { label: "DeepSeek", icon: "deepseek" },
+  [ModelVendor.ZHIPU]: { label: "Zhipu", icon: "glm" },
+  [ModelVendor.KIMI]: { label: "Kimi", icon: "kimi" },
+  [ModelVendor.QWEN]: { label: "Qwen", icon: "qwen" },
+  [ModelVendor.MINIMAX]: { label: "MiniMax", icon: "minimax" },
+};

package/lib/name-taken-error.ts

@@ -0,0 +1,7 @@
+// NameTakenError is a Create refused because the name is taken; the person
+// may replace that Attachment on purpose instead.
+export class NameTakenError extends Error {
+  constructor(readonly fileName: string) {
+    super(`An attachment named ${fileName} already exists.`);
+  }
+}

package/lib/notifications.ts

@@ -0,0 +1,37 @@
+import { ToastQueue } from "@heroui/react";
+
+// One global notification entry. Non-blocking results and background
+// refresh failures are Toasts; problems handled in the current flow use a
+// regional Alert instead. A key identifies the operation, so a new notice for
+// the same operation replaces the previous one instead of stacking.
+export type NotificationKind = "default" | "success" | "warning" | "danger";
+export interface Notification {
+  title: string;
+  description?: string;
+  kind: NotificationKind;
+  action?: { label: string; onPress: () => void };
+}
+
+export const notificationQueue = new ToastQueue<Notification>({ maxVisibleToasts: 3 });
+const open = new Map<string, string>();
+
+export function notify(key: string, kind: NotificationKind, title: string, description?: string, options: { timeout?: number; action?: Notification["action"] } = {}) {
+  // Danger notices stay until dismissed; HeroUI has no in-place update, so the
+  // notice for the same operation is replaced.
+  const timeout = options.timeout ?? (kind === "danger" ? 0 : 5000);
+  const existing = open.get(key);
+  if (existing) notificationQueue.close(existing);
+  const id = notificationQueue.add({ title, description, kind, action: options.action }, {
+    timeout: timeout || undefined,
+    onClose: () => { if (open.get(key) === id) open.delete(key); },
+  });
+  open.set(key, id);
+}
+
+// Recovery clears the failure notice of the same operation.
+export function dismiss(key: string) {
+  const id = open.get(key);
+  if (!id) return;
+  notificationQueue.close(id);
+  open.delete(key);
+}

package/lib/permission-modes.ts

@@ -0,0 +1,25 @@
+import { PermissionMode } from "@talgent/workbench-contracts/agent/public/v1/harness_pb";
+
+// How much a Managed Work's Harness asks before it acts, as the person picks
+// it at start and while the Work runs. A Cloud Work has no permission mode.
+export type PermissionModeOption = { mode: PermissionMode; name: string; short: string; description: string };
+
+export const permissionModes: PermissionModeOption[] = [
+  { mode: PermissionMode.ASK, name: "Ask", short: "Ask", description: "Asks before each action its rules don’t allow" },
+  { mode: PermissionMode.ACCEPT_EDITS, name: "Accept edits", short: "Accept edits", description: "Edits files without asking" },
+  { mode: PermissionMode.PLAN, name: "Plan", short: "Plan", description: "Changes nothing until its plan is approved" },
+  { mode: PermissionMode.BYPASS_PERMISSIONS, name: "Bypass permissions", short: "Bypass", description: "Acts without asking" },
+];
+
+// Modes the Harness may report it switched to by itself; no one picks them.
+const reportedPermissionModes: PermissionModeOption[] = [
+  { mode: PermissionMode.DONT_ASK, name: "Don’t ask", short: "Don’t ask", description: "Denies what its rules don’t allow, without asking" },
+  { mode: PermissionMode.AUTO, name: "Auto", short: "Auto", description: "Decides by itself what to ask" },
+];
+
+/** A Managed start's default: the Harness acts without asking. */
+export const defaultPermissionMode = PermissionMode.BYPASS_PERMISSIONS;
+
+export function permissionModeOption(mode: PermissionMode) {
+  return permissionModes.find(option => option.mode === mode) ?? reportedPermissionModes.find(option => option.mode === mode);
+}

package/lib/personal-usage-service.ts

@@ -0,0 +1,19 @@
+import { timestampFromDate } from "@bufbuild/protobuf/wkt";
+import { useCurrentUser } from "./account-service";
+import { traceClient } from "./client";
+import type { DashboardReportPeriod } from "./dashboard-report";
+import type { DashboardWindow } from "./dashboard";
+import { useTokenAnalytics } from "./token-analytics";
+import { traceMetricKinds } from "./trace-view-model";
+
+/** The person's usage across all their Works, with or without a Project, as
+ * Spend shows a Project's. */
+export function usePersonalTokenAnalytics(window: DashboardWindow, period: DashboardReportPeriod) {
+  const userId = useCurrentUser().data?.user?.id ?? "";
+  return useTokenAnalytics(["personal-token", userId], bounds => traceClient.getPersonalTraceMetrics({
+    startTime: timestampFromDate(bounds.start),
+    endTime: timestampFromDate(bounds.end),
+    stepSeconds: bounds.stepSeconds,
+    metricKinds: [...traceMetricKinds],
+  }), window, period, Boolean(userId));
+}

package/lib/personal-work-service.ts

@@ -0,0 +1,159 @@
+import { timestampDate, timestampFromDate } from "@bufbuild/protobuf/wkt";
+import { useRef } from "react";
+import { keepPreviousData, useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import type { DirectoryUser, LibraryFile, LibraryWork, PersonalWorkSummary } from "@talgent/workbench-contracts/agent/public/v1/personal_work_pb";
+import { useCurrentUser } from "./account-service";
+import { agentWorkQueryKey } from "./agent-work-service";
+import { agentWorkClient, personalWorkClient } from "./client";
+import { workStartFields, type WorkStartInput } from "./start-work-request";
+import type { WorkStartSource } from "./work-start-source";
+
+// A person's own use of their Agent (Agent's PersonalWorkService): the
+// Personal Works they start for themselves, sharing them, and their Library.
+
+/** stateReason: why it stopped; disconnectedSince: when it was disconnected,
+ * null while observed. */
+export type PersonalWork = { id: string; title: string; state: string; stateReason: string; waiting: boolean; updatedAt: Date | null; disconnectedSince: Date | null };
+
+function personalWork(work: PersonalWorkSummary): PersonalWork {
+  return { id: work.workId, title: work.title.trim() || "Untitled work", state: work.state, stateReason: work.stateReason, waiting: work.waiting, updatedAt: work.updatedAt ? timestampDate(work.updatedAt) : null, disconnectedSince: work.disconnectedSince ? timestampDate(work.disconnectedSince) : null };
+}
+
+/** Every person's Personal Works lists, the prefix of personalWorksQueryKey. */
+export const personalWorksKey = ["personal-works"] as const;
+
+export function personalWorksQueryKey(userId: string | undefined) {
+  return [...personalWorksKey, userId ?? ""] as const;
+}
+
+/** How a Work is named among a person's own Works when the Workbench holds no
+ * title for it, such as a Work another product started. */
+export const untitledWorkLabel = "Work";
+
+/** The person's Personal Works, closed ones included, most recently updated first. */
+export function usePersonalWorks() {
+  const userId = useCurrentUser().data?.user?.id;
+  return useQuery({
+    queryKey: personalWorksQueryKey(userId),
+    queryFn: async ({ signal }) => (await personalWorkClient.listPersonalWorks({ limit: 100 }, { signal })).works.map(personalWork),
+    enabled: Boolean(userId),
+    retry: false,
+    refetchInterval: 10000,
+    refetchOnWindowFocus: false,
+  });
+}
+
+export function useChangePersonalWorkTitle(workId: string) {
+  const client = useQueryClient();
+  return useMutation({
+    mutationFn: async (title: string) => (await personalWorkClient.changePersonalWorkTitle({ workId, title })).title,
+    onSuccess: () => { void client.invalidateQueries({ queryKey: personalWorksKey }); },
+  });
+}
+
+/** People in the User Directory whose username matches the query. */
+export function useShareCandidates(query: string) {
+  const text = query.trim();
+  return useQuery({
+    queryKey: ["share-candidates", text],
+    queryFn: async ({ signal }) => (await personalWorkClient.searchShareReaders({ query: text, limit: 10 }, { signal })).users,
+    enabled: text.length > 0,
+    retry: false,
+    placeholderData: keepPreviousData,
+    staleTime: 30_000,
+  });
+}
+
+/** The people behind the given identities, by identity; an unknown one is absent. */
+export function useDirectoryUsers(userIds: string[]) {
+  const ids = [...new Set(userIds.filter(Boolean))].sort();
+  return useQuery({
+    queryKey: ["directory-users", ids],
+    queryFn: async ({ signal }) => new Map((await personalWorkClient.getShareReaders({ userIds: ids }, { signal })).users.map(user => [user.userId, user] as const)),
+    enabled: ids.length > 0,
+    retry: false,
+    staleTime: 60_000,
+  });
+}
+
+export function useGrantPersonalWorkShare(workId: string) {
+  const client = useQueryClient();
+  return useMutation({
+    mutationFn: (reader: DirectoryUser) => personalWorkClient.grantPersonalWorkShare({ workId, readerUserId: reader.userId }),
+    onSuccess: () => { void client.invalidateQueries({ queryKey: agentWorkQueryKey(workId) }); },
+  });
+}
+
+export function useRevokeWorkShare(workId: string) {
+  const client = useQueryClient();
+  return useMutation({
+    mutationFn: (readerUserId: string) => agentWorkClient.revokeWorkShare({ workId, readerUserId }),
+    onSuccess: () => { void client.invalidateQueries({ queryKey: agentWorkQueryKey(workId) }); },
+  });
+}
+
+export type LibraryFilter = { name: string; workId: string; addedWithinDays: number | null };
+
+export type Library = { files: LibraryFile[]; works: LibraryWork[] };
+
+/** The person's Personal Library, narrowed as asked, most recently added first. */
+export function useLibrary(filter: LibraryFilter) {
+  const userId = useCurrentUser().data?.user?.id;
+  return useQuery({
+    queryKey: ["personal-library", userId ?? "", filter.name.trim(), filter.workId, filter.addedWithinDays],
+    queryFn: async ({ signal }): Promise<Library> => {
+      const after = filter.addedWithinDays === null ? undefined : timestampFromDate(new Date(Date.now() - filter.addedWithinDays * 86_400_000));
+      const response = await personalWorkClient.listLibraryFiles({ nameQuery: filter.name.trim(), workId: filter.workId, addedAfter: after }, { signal });
+      return { files: response.files, works: response.works };
+    },
+    enabled: Boolean(userId),
+    retry: false,
+    placeholderData: keepPreviousData,
+    refetchOnWindowFocus: false,
+  });
+}
+
+/** What a new Personal Work may start with, under the person's own Agent. */
+export const personalWorkStartSource: Omit<WorkStartSource, "draft"> = {
+  key: ["personal"],
+  loadOptions: async signal => {
+    const options = (await personalWorkClient.getPersonalWorkStartOptions({}, { signal })).options;
+    return { models: options?.models ?? [], plugins: options?.plugins ?? [], connectors: options?.connectors ?? [] };
+  },
+  loadRepositories: async signal => {
+    const found = (await personalWorkClient.listPersonalWorkStartRepositories({}, { signal })).repositories;
+    return { repositories: found?.repositories ?? [], recentRepositoryIds: found?.recentRepositoryIds ?? [], repositoriesUnavailable: found?.repositoriesUnavailable ?? false };
+  },
+  chooseComputer: true,
+};
+
+/** Starts a Personal Work. One attempt keeps its request identity until it
+ * succeeds, so a retried start returns the Work it already started. */
+export function useStartPersonalWork() {
+  const client = useQueryClient();
+  const userId = useCurrentUser().data?.user?.id;
+  const attempt = useRef<string | null>(null);
+  return useMutation({
+    mutationFn: async (input: WorkStartInput) => {
+      attempt.current ??= crypto.randomUUID();
+      const workId = (await personalWorkClient.startPersonalWork({ requestId: attempt.current, ...workStartFields(input) })).workId;
+      if (!workId) throw new Error("Work was not created.");
+      attempt.current = null;
+      return workId;
+    },
+    onSuccess: () => { void client.invalidateQueries({ queryKey: personalWorksQueryKey(userId) }); },
+  });
+}
+
+/** A Work the person reads in their Library: their own Personal Work or one
+ * shared with them; undefined until known or when the Library has none. */
+export function useLibraryWork(workId: string | undefined, enabled = true) {
+  return useQuery({
+    queryKey: ["library-work", workId],
+    queryFn: async ({ signal }) => (await personalWorkClient.listLibraryFiles({ workId }, { signal })).works.find(work => work.workId === workId) ?? null,
+    enabled: Boolean(workId) && enabled,
+    retry: false,
+    refetchOnWindowFocus: false,
+    staleTime: 60_000,
+  });
+}

package/lib/plugin-parameters.ts

@@ -0,0 +1,64 @@
+import type { JsonObject, JsonValue } from "@bufbuild/protobuf";
+import type { InstalledPlugin, ParameterDeclaration } from "@talgent/workbench-contracts/marketplace/public/v1/marketplace_pb";
+
+// Form values are text as typed; they become typed manual values only after
+// validation against the release's declarations. Blank means "not set here",
+// so a declared default or a saved value continues to apply.
+export type ParameterDrafts = Record<string, string>;
+export type ParameterErrors = Record<string, string>;
+
+export const hasDefault = (declaration: ParameterDeclaration) => declaration.hasDefault || declaration.default !== undefined;
+export const parameterLabel = (name: string, declaration: ParameterDeclaration) => declaration.title || name;
+
+// A value that must be supplied: required, no declared default and nothing saved.
+export function missingRequired(declarations: Record<string, ParameterDeclaration>, saved: { configuration?: JsonObject; redacted?: string[] }, drafts: ParameterDrafts = {}) {
+  return Object.entries(declarations).filter(([name, declaration]) => declaration.required && !hasDefault(declaration)
+    && !drafts[name]?.trim() && saved.configuration?.[name] === undefined && !saved.redacted?.includes(name)).map(([name]) => name);
+}
+
+// Missing required settings on an existing installation, such as after a new
+// release declares another required parameter.
+export function installationNeedsSetup(declarations: Record<string, ParameterDeclaration>, installed: InstalledPlugin) {
+  return missingRequired(declarations, { configuration: installed.configuration, redacted: installed.redactedParameters }).length > 0;
+}
+
+export function parseParameters(declarations: Record<string, ParameterDeclaration>, drafts: ParameterDrafts, saved: { configuration?: JsonObject; redacted?: string[] } = {}): { values: JsonObject; errors: ParameterErrors } {
+  const values: JsonObject = {};
+  const errors: ParameterErrors = {};
+  for (const name of missingRequired(declarations, saved, drafts)) errors[name] = `Enter ${parameterLabel(name, declarations[name]).toLowerCase()}.`;
+  for (const [name, declaration] of Object.entries(declarations)) {
+    const raw = drafts[name];
+    if (raw === undefined || !raw.trim() || errors[name]) continue;
+    const parsed = parseValue(declaration, raw);
+    if ("error" in parsed) errors[name] = parsed.error;
+    else values[name] = parsed.value;
+  }
+  return { values, errors };
+}
+
+function parseValue(declaration: ParameterDeclaration, raw: string): { value: JsonValue } | { error: string } {
+  if (declaration.multiple) {
+    const items = raw.split("\n").map(item => item.trim()).filter(Boolean);
+    return items.length ? { value: items } : { error: "Enter at least one value." };
+  }
+  if (declaration.type === "number") {
+    const number = Number(raw);
+    if (!Number.isFinite(number)) return { error: "Enter a number." };
+    if (declaration.min !== undefined && number < declaration.min) return { error: `Enter ${declaration.min} or more.` };
+    if (declaration.max !== undefined && number > declaration.max) return { error: `Enter ${declaration.max} or less.` };
+    return { value: number };
+  }
+  if (declaration.type === "boolean") return { value: raw === "true" };
+  if (declaration.options.length && !declaration.options.includes(raw)) return { error: "Choose one of the options." };
+  return { value: raw };
+}
+
+// Saved values shown back in a form. Sensitive values are never returned by
+// ordinary queries, so they stay blank with a "saved" placeholder.
+export function draftsFrom(configuration: JsonObject | undefined): ParameterDrafts {
+  const drafts: ParameterDrafts = {};
+  for (const [name, value] of Object.entries(configuration ?? {})) {
+    drafts[name] = Array.isArray(value) ? value.join("\n") : String(value);
+  }
+  return drafts;
+}

package/lib/preview-verdict.ts

@@ -0,0 +1,26 @@
+import { WorkFilePreviewDisplay as Display, WorkFilePreviewMode as Mode, WorkFilePreviewRefusal as Refusal } from "@talgent/workbench-contracts/agent/public/v1/work_file_pb";
+import type { PreviewVerdict } from "../components/preview/preview-verdict";
+
+// Storage's file preview as a context relays it. Agent's preview contract
+// numbers its values as Storage does, and a context relaying it keeps that
+// numbering, so one reading of Agent's enums serves every relay.
+type RelayedPreview = { mode: number; display: number; refusal: number; limitBytes: bigint; accessUrl: string; rendering: boolean };
+
+const previewModes: Partial<Record<number, PreviewVerdict["mode"]>> = {
+  [Mode.REFUSED]: "refused", [Mode.PREVIEW_COPY]: "preview_copy", [Mode.RENDER]: "render", [Mode.DIRECT]: "direct", [Mode.TRUNCATED]: "truncated",
+};
+const previewDisplays: Partial<Record<number, PreviewVerdict["display"]>> = { [Display.TEXT]: "text", [Display.PDF]: "pdf", [Display.IMAGE]: "image" };
+const previewRefusals: Partial<Record<number, NonNullable<PreviewVerdict["refusal"]>>> = {
+  [Refusal.UNSUPPORTED]: "unsupported", [Refusal.STRUCTURE_MISMATCH]: "structure_mismatch", [Refusal.ENCRYPTED]: "encrypted", [Refusal.TOO_LARGE]: "too_large",
+  [Refusal.CORRUPT]: "corrupt", [Refusal.CONVERTER_REFUSED]: "converter_refused", [Refusal.RENDERING_TOO_LARGE]: "rendering_too_large",
+};
+
+// An unknown mode from a newer server reads as unsupported: nothing unknown is shown.
+export function previewVerdict(preview: RelayedPreview | undefined): PreviewVerdict {
+  const mode = preview && previewModes[preview.mode];
+  if (!preview || !mode) return { mode: "refused", display: "none", refusal: "unsupported", limitBytes: 0, rendering: false };
+  return {
+    mode, display: previewDisplays[preview.display] ?? "none", refusal: previewRefusals[preview.refusal],
+    limitBytes: Number(preview.limitBytes), url: preview.accessUrl || undefined, rendering: preview.rendering,
+  };
+}

package/lib/relative-time.ts

@@ -0,0 +1,11 @@
+/** How long ago a moment was, in the workspace's compact form ("5m ago"). */
+export function timeAgo(date: Date | null | undefined, now = Date.now()): string {
+  if (!date) return "just now";
+  const diffSeconds = Math.max(0, Math.floor((now - date.getTime()) / 1000));
+  if (diffSeconds < 60) return "just now";
+  const minutes = Math.floor(diffSeconds / 60);
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h ago`;
+  return `${Math.floor(hours / 24)}d ago`;
+}

package/lib/session.ts

@@ -0,0 +1,108 @@
+// The browser side of Account's Login Session. The SPA never sees a token:
+// Account sets HttpOnly cookies, and these calls only ask it to refresh or end
+// the session of this device.
+
+const jsonPost: RequestInit = {
+  method: "POST",
+  credentials: "same-origin",
+  headers: { "Content-Type": "application/json" },
+  body: "{}",
+};
+
+const maxNextLength = 2048;
+
+/**
+ * An internal Portal path, or "/" for anything that could leave the site or
+ * loop back into sign-in. Mirrors internalPath in Account's /auth handler,
+ * which re-checks it; this copy keeps the browser from building such links.
+ */
+export function safeInternalPath(value: string | null | undefined): string {
+  const path = value?.trim() ?? "";
+  if (!path.startsWith("/") || path.startsWith("//") || path.length > maxNextLength || /[\\\r\n\t]/.test(path)) return "/";
+  const pathname = path.split(/[?#]/, 1)[0];
+  if (pathname === "/login" || pathname === "/auth" || pathname.startsWith("/auth/")) return "/";
+  return path;
+}
+
+/** Where the "Continue with GitHub" action starts a sign-in. GitHub returns
+ * every sign-in to one entry's host, so the sign-in names this entry's origin
+ * to come back to; Account returns only to the entries it trusts. */
+export function signInHref(next: string): string {
+  return `/auth/github/login?next=${encodeURIComponent(`${window.location.origin}${safeInternalPath(next)}`)}`;
+}
+
+/** The Portal sign-in page, returning to next afterwards. home is where the
+ * entry lands after sign-in anyway, so naming it adds nothing. */
+export function signInPagePath(next: string, home = "/"): string {
+  const target = safeInternalPath(next);
+  return target === "/" || target === home ? "/login" : `/login?next=${encodeURIComponent(target)}`;
+}
+
+/** refreshed: a new token is set. rejected: sign in again. unavailable: try later. */
+export type RefreshOutcome = "refreshed" | "rejected" | "unavailable";
+
+let inFlight: Promise<RefreshOutcome> | undefined;
+
+// Once Account rejects a refresh, this device's Login Session is over: Account
+// has cleared its cookies, and only signing in again, which reloads the page,
+// starts another. Pages learn it at once instead of at their next session
+// check, and no call asks Account again meanwhile.
+let ended = false;
+const endListeners = new Set<() => void>();
+
+export function sessionEnded(): boolean {
+  return ended;
+}
+
+export function subscribeSessionEnd(listener: () => void): () => void {
+  endListeners.add(listener);
+  return () => endListeners.delete(listener);
+}
+
+function endSession() {
+  if (ended) return;
+  ended = true;
+  for (const listener of endListeners) listener();
+}
+
+async function requestRefresh(): Promise<RefreshOutcome> {
+  if (ended) return "rejected";
+  let response: Response;
+  try {
+    response = await fetch("/auth/refresh", jsonPost);
+  } catch {
+    return "unavailable";
+  }
+  if (response.ok) return "refreshed";
+  if (response.status !== 401) return "unavailable";
+  endSession();
+  return "rejected";
+}
+
+// Tabs share one refresh cookie. Account revokes a session when a replaced
+// secret comes back, so two tabs must never present the same secret: the
+// lock serializes them, and the second tab then sends the cookie the first
+// one received.
+async function refreshAcrossTabs(): Promise<RefreshOutcome> {
+  const locks = typeof navigator !== "undefined" ? navigator.locks : undefined;
+  if (!locks) return requestRefresh();
+  return locks.request("talgent-session-refresh", requestRefresh);
+}
+
+/** Refreshes this device's session once, however many callers ask at once. */
+export function refreshSession(): Promise<RefreshOutcome> {
+  if (ended) return Promise.resolve("rejected");
+  inFlight ??= refreshAcrossTabs().finally(() => {
+    inFlight = undefined;
+  });
+  return inFlight;
+}
+
+/**
+ * Ends this device's Login Session; other devices stay signed in. Fails when
+ * Account could not revoke it, and the device then stays signed in.
+ */
+export async function signOut(): Promise<void> {
+  const response = await fetch("/auth/logout", jsonPost);
+  if (!response.ok) throw new Error(`sign-out failed with ${response.status}`);
+}

package/lib/share-link.ts

@@ -0,0 +1,4 @@
+// shareLinkAddress is the absolute address a Share Link is opened at.
+export function shareLinkAddress(url: string) {
+  return new URL(url, window.location.origin).toString();
+}

package/lib/stale-build-reload.ts

@@ -0,0 +1,41 @@
+// Each image serves only its own content-hashed assets, so after a release a
+// page still running the previous build asks for chunks that no longer exist
+// (the relation graph, Mermaid, a code language). Vite reports that failure as
+// `vite:preloadError`; reloading picks up the current build. A failure right
+// after such a reload is a real outage, not a stale page, so it is left to
+// surface instead of reloading in a loop.
+const storageKey = "talgent:stale-build-reload";
+const retryAfterMs = 10_000;
+
+type ReloadTarget = Pick<Window, "addEventListener" | "removeEventListener" | "sessionStorage"> & { location: Pick<Location, "reload"> };
+
+export function installStaleBuildReload(target: ReloadTarget = window, now: () => number = Date.now) {
+  const onPreloadError = (event: Event) => {
+    const last = readLast(target);
+    if (last !== null && now() - last < retryAfterMs) return;
+    // Without storage a reload could not be told from the next one, so it could loop.
+    if (!writeLast(target, now())) return;
+    event.preventDefault();
+    target.location.reload();
+  };
+  target.addEventListener("vite:preloadError", onPreloadError);
+  return () => target.removeEventListener("vite:preloadError", onPreloadError);
+}
+
+function readLast(target: ReloadTarget): number | null {
+  try {
+    const value = Number(target.sessionStorage.getItem(storageKey));
+    return Number.isFinite(value) && value > 0 ? value : null;
+  } catch {
+    return null;
+  }
+}
+
+function writeLast(target: ReloadTarget, at: number) {
+  try {
+    target.sessionStorage.setItem(storageKey, String(at));
+    return true;
+  } catch {
+    return false;
+  }
+}

package/lib/start-work-request.ts

@@ -0,0 +1,34 @@
+import type { JsonObject } from "@bufbuild/protobuf";
+import type { PermissionMode } from "@talgent/workbench-contracts/agent/public/v1/harness_pb";
+
+/** What the person chose for a new Work, whatever the Work is for. */
+export interface WorkStartInput {
+  initialMessage: string;
+  /** The selected Model Configuration, or the Managed Computer's own Claude
+   * login; absence leaves it to the platform's default. */
+  model?: { configurationId?: string; machineLogin?: boolean };
+  thinkingLevel?: string;
+  creationCapabilities?: {
+    plugins: Array<{ name: string; include: boolean; configuration: JsonObject }>;
+    connectors: Array<{ name: string; include: boolean }>;
+    startupAgent?: string;
+  };
+  repositorySelections?: Array<{ repositoryId: string; baseBranch: string }>;
+  /** The Computer the Work runs on for its life; absence leaves it to the platform's default Computer. */
+  computerId?: string;
+  /** How the Harness runs on a Managed Computer; absent for a Cloud. */
+  harness?: { permissionMode: PermissionMode; sandbox: boolean };
+}
+
+/** The start request's fields for the choices, leaving unchosen ones unset. */
+export function workStartFields(input: WorkStartInput) {
+  return {
+    initialMessage: input.initialMessage,
+    repositorySelections: input.repositorySelections ?? [],
+    ...(input.model && { model: input.model }),
+    ...(input.thinkingLevel !== undefined && { thinkingLevel: input.thinkingLevel }),
+    ...(input.creationCapabilities && { creationCapabilities: input.creationCapabilities }),
+    ...(input.computerId && { computerId: input.computerId }),
+    ...(input.harness && { harness: input.harness }),
+  };
+}

package/lib/startup-progress.ts

@@ -0,0 +1,9 @@
+import type { StartupProgress } from "@talgent/workbench-contracts/agent/public/v1/startup_pb";
+
+// Revisions order committed Work projections, including completed progress.
+// They do not establish native feedback ownership or ordering across processes.
+export function newestStartupProgress(current: StartupProgress | undefined, incoming: StartupProgress | undefined) {
+  if (!incoming) return current;
+  if (!current || incoming.revision > current.revision) return incoming;
+  return current;
+}

package/lib/subagents.ts

@@ -0,0 +1,12 @@
+import type { SubAgent as ProtoSubAgent } from "@talgent/workbench-contracts/agent/public/v1/subagents_pb";
+
+// The SubAgents the main Agent of the Work's current Harness process delegated
+// to, as the Work reports them; the page never derives a state itself.
+export type SubAgentStatus = "running" | "completed" | "failed" | "stopped";
+export interface SubAgent { id: string; type: string; task: string; status: SubAgentStatus }
+
+const statuses: ReadonlySet<string> = new Set<SubAgentStatus>(["running", "completed", "failed", "stopped"]);
+
+export function adaptSubAgents(items: ReadonlyArray<Pick<ProtoSubAgent, "id" | "type" | "task" | "status">> | undefined): SubAgent[] {
+  return (items ?? []).flatMap(item => item.id && statuses.has(item.status) ? [{ id: item.id, type: item.type, task: item.task, status: item.status as SubAgentStatus }] : []);
+}

package/lib/thinking-levels.ts

@@ -0,0 +1,2 @@
+/** A thinking level as the composer names it; an empty level is the model's default. */
+export const thinkingLevelName = (level: string) => level ? level[0].toUpperCase() + level.slice(1) : "Default";