@ateam-ai-mobile/core 0.1.6 → 0.1.8

package/dist/index.js

@@ -28,12 +28,17 @@ __export(index_exports, {
   apiFetchRaw: () => apiFetchRaw,
   blocksToText: () => blocksToText,
   borderRadius: () => borderRadius,
+  capabilityEnabled: () => capabilityEnabled,
   closeChatStream: () => closeChatStream,
   colors: () => colors,
   connectAcsWs: () => connectAcsWs,
   connectorCall: () => connectorCall,
+  createAuthSession: () => createAuthSession,
+  createPushRegistration: () => createPushRegistration,
   deleteArtifact: () => deleteArtifact,
   disconnectAcsWs: () => disconnectAcsWs,
+  exchangeHandoff: () => exchangeHandoff,
+  fetchConsumerConfig: () => fetchConsumerConfig,
   fontSize: () => fontSize,
   getConfig: () => getConfig,
   getConsumerAuthApiUrl: () => getConsumerAuthApiUrl,
@@ -47,6 +52,10 @@ __export(index_exports, {
   initAdas: () => initAdas,
   isAdasInitialized: () => isAdasInitialized,
   isDevHost: () => isDevHost,
+  joinWithApple: () => joinWithApple,
+  joinWithGoogle: () => joinWithGoogle,
+  linkChannelStart: () => linkChannelStart,
+  linkChannelVerify: () => linkChannelVerify,
   listHomeActions: () => listHomeActions,
   listMadeForYou: () => listMadeForYou,
   listMyTenants: () => listMyTenants,
@@ -54,22 +63,37 @@ __export(index_exports, {
   mcpFetch: () => mcpFetch,
   mcpToolCall: () => mcpToolCall,
   notifyAcsWsForeground: () => notifyAcsWsForeground,
+  notifyAppForeground: () => notifyAppForeground,
+  onAppForeground: () => onAppForeground,
+  openJoinWithApple: () => openJoinWithApple,
+  openJoinWithGoogle: () => openJoinWithGoogle,
+  parseDeepLinkParam: () => parseDeepLinkParam,
+  parseHandoffCode: () => parseHandoffCode,
+  parseInviteCode: () => parseInviteCode,
   patchArtifact: () => patchArtifact,
   patchHomeAction: () => patchHomeAction,
   pluginCommandEmitter: () => pluginCommandEmitter,
   postCommandResult: () => postCommandResult,
+  previewInvite: () => previewInvite,
   recordEvent: () => recordEvent,
   refreshToken: () => refreshToken,
+  resolveAdasPhase: () => resolveAdasPhase,
   setAcsCacheStorage: () => setAcsCacheStorage,
   setAcsReachabilityReporter: () => setAcsReachabilityReporter,
+  setClientDeclarationProvider: () => setClientDeclarationProvider,
   setHomeActionOrder: () => setHomeActionOrder,
   setOrder: () => setOrder,
+  signInWithApple: () => signInWithApple,
+  signInWithGoogle: () => signInWithGoogle,
   spacing: () => spacing,
   switchTenant: () => switchTenant,
   unwrapMcpResult: () => unwrapMcpResult,
+  useCapability: () => useCapability,
   useChatStore: () => useChatStore,
   useHomeActionsStore: () => useHomeActionsStore,
-  useWidgetsStore: () => useWidgetsStore
+  useWidgetsStore: () => useWidgetsStore,
+  useWorkspaceStore: () => useWorkspaceStore,
+  userFromJwt: () => userFromJwt
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -281,1480 +305,1874 @@ function getSession() {
   };
 }
 
-// src/chat/store.ts
-var import_zustand = require("zustand");
-
-// src/utils/emitter.ts
-var RECENT_TTL_MS = 1e4;
-var RECENT_MAX = 20;
-var PluginCommandEmitter = class {
-  constructor() {
-    this.listeners = /* @__PURE__ */ new Map();
-    // Ring buffer of plugin commands seen recently. Lets a plugin that mounts
-    // AFTER its first command was emitted (e.g. a surface mounted by the
-    // dispatcher in response to focus-plugin) still pick that command up via
-    // `drainPluginCommands(pluginId)`. Self-cleans on TTL + size cap.
-    this.recent = [];
-  }
-  on(event, fn) {
-    if (!this.listeners.has(event)) this.listeners.set(event, /* @__PURE__ */ new Set());
-    this.listeners.get(event).add(fn);
-    return () => this.off(event, fn);
-  }
-  off(event, fn) {
-    this.listeners.get(event)?.delete(fn);
+// src/authSession.ts
+function decodeJwtPayload(token) {
+  try {
+    const segs = token.split(".");
+    if (segs.length !== 3) return null;
+    const b64 = segs[1].replace(/-/g, "+").replace(/_/g, "/");
+    const padded = b64 + "=".repeat((4 - b64.length % 4) % 4);
+    const json = typeof atob === "function" ? atob(padded) : Buffer.from(padded, "base64").toString("utf8");
+    return JSON.parse(json);
+  } catch {
+    return null;
   }
-  emit(event, data) {
-    if (event === "plugin-command" && data && data.pluginId && data.command && data.command !== "__focus") {
-      this.recent.push({
-        pluginId: data.pluginId,
-        command: data.command,
-        args: data.args,
-        correlationId: data.correlationId,
-        _bufferedAt: Date.now()
-      });
-      if (this.recent.length > RECENT_MAX) this.recent.shift();
-    }
-    this.listeners.get(event)?.forEach((fn) => {
-      try {
-        fn(data);
-      } catch {
+}
+function userFromJwt(token) {
+  const claims = decodeJwtPayload(token);
+  if (!claims?.sub) return null;
+  return {
+    actorId: String(claims.sub),
+    email: claims.email,
+    displayName: claims.name || claims.email,
+    tenantRole: claims.tenantRole ?? null,
+    serviceRole: claims.serviceRole ?? null,
+    platformRoles: Array.isArray(claims.platformRoles) ? claims.platformRoles : [],
+    roles: Array.isArray(claims.roles) ? claims.roles : []
+  };
+}
+async function attemptRefresh(expiredToken) {
+  let res;
+  try {
+    res = await fetch(`${getCoreApiUrl()}/api/auth/refresh`, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${expiredToken}`,
+        "Content-Type": "application/json"
       }
     });
+  } catch (e) {
+    console.warn("[adas/session] refresh fetch threw (network):", e?.message || e);
+    return { ok: "transient", reason: `network: ${e?.message || "unknown"}` };
   }
-  /** Pop and return any plugin-commands targeted at `pluginId` that were
-   *  emitted within the last RECENT_TTL_MS. Used by the native bridge on
-   *  mount so the surface-dispatcher path doesn't drop the first command. */
-  drainPluginCommands(pluginId) {
-    const now = Date.now();
-    const out = [];
-    const remaining = [];
-    for (const cmd of this.recent) {
-      if (now - cmd._bufferedAt > RECENT_TTL_MS) continue;
-      if (cmd.pluginId === pluginId) out.push(cmd);
-      else remaining.push(cmd);
+  if (res.status === 401 || res.status === 403) {
+    console.warn(`[adas/session] refresh rejected with ${res.status} \u2014 auth genuinely broken`);
+    return { ok: "auth_failed", status: res.status, reason: `core ${res.status}` };
+  }
+  if (!res.ok) {
+    console.warn(`[adas/session] refresh server error ${res.status} \u2014 treating as transient`);
+    return { ok: "transient", status: res.status, reason: `core ${res.status}` };
+  }
+  const body = await res.json().catch(() => null);
+  if (typeof body?.token === "string") return { ok: "ok", token: body.token };
+  console.warn("[adas/session] refresh returned 2xx but no token \u2014 treating as auth_failed");
+  return { ok: "auth_failed", status: res.status, reason: "malformed refresh response" };
+}
+function createAuthSession(deps) {
+  let state = { token: null, user: null, status: "loading" };
+  const subs = /* @__PURE__ */ new Set();
+  const set = (patch) => {
+    state = { ...state, ...patch };
+    for (const cb of subs) cb(state);
+  };
+  async function adopt(token) {
+    await deps.persistence.saveToken(token);
+    const user = userFromJwt(token);
+    set({ token, user, status: "authenticated" });
+    await deps.onToken?.(token, user);
+  }
+  async function refresh() {
+    const current = state.token;
+    if (!current) return { ok: "auth_failed", status: 0, reason: "no token in store" };
+    const outcome = await attemptRefresh(current);
+    if (outcome.ok === "ok") {
+      await adopt(outcome.token);
+      return { ok: "ok", status: 200 };
     }
-    this.recent = remaining;
-    return out;
+    if (outcome.ok === "auth_failed") return { ok: "auth_failed", status: outcome.status, reason: outcome.reason };
+    return { ok: "transient", status: outcome.status ?? 0, reason: outcome.reason };
   }
-};
-var pluginCommandEmitter = new PluginCommandEmitter();
-
-// src/chat/store.ts
-function coreHeaders() {
-  const token = getToken();
-  const headers = {
-    "Content-Type": "application/json"
+  async function logout() {
+    await deps.onLogout?.();
+    await deps.persistence.clearToken();
+    set({ token: null, user: null, status: "signed_out" });
+  }
+  return {
+    getToken: () => state.token,
+    getUser: () => state.user,
+    getState: () => state,
+    subscribe(cb) {
+      subs.add(cb);
+      return () => {
+        subs.delete(cb);
+      };
+    },
+    async restore() {
+      const token = await deps.persistence.loadToken();
+      if (!token) {
+        set({ status: "signed_out" });
+        return;
+      }
+      const user = userFromJwt(token);
+      if (!user) {
+        await deps.persistence.clearToken();
+        set({ status: "signed_out" });
+        return;
+      }
+      const claims = decodeJwtPayload(token);
+      const exp = typeof claims?.exp === "number" ? claims.exp * 1e3 : 0;
+      if (exp && Date.now() >= exp) {
+        const outcome = await attemptRefresh(token);
+        if (outcome.ok === "ok") {
+          await adopt(outcome.token);
+          return;
+        }
+        if (outcome.ok === "auth_failed") {
+          await deps.persistence.clearToken();
+          set({ token: null, user: null, status: "signed_out" });
+          return;
+        }
+        set({ token, user, status: "authenticated" });
+        return;
+      }
+      set({ token, user, status: "authenticated" });
+    },
+    async login(token) {
+      const user = userFromJwt(token);
+      if (!user) throw new Error("Invalid JWT \u2014 could not decode subject");
+      await adopt(token);
+    },
+    logout,
+    refresh
   };
-  if (token) headers["Authorization"] = `Bearer ${token}`;
-  return headers;
-}
-function isTerminalStatus(status) {
-  const s = typeof status === "string" ? status.toLowerCase() : "";
-  return s === "done" || s === "error" || s === "failed" || s === "completed";
-}
-function normalizeJobStatus(snap) {
-  const status = typeof snap?.status === "string" ? snap.status.toLowerCase() : "";
-  if (status === "done" || status === "completed") return "done";
-  if (status === "error" || status === "failed") return "error";
-  if (status === "paused" || status === "waiting") return "paused";
-  if (status === "unknown") return "unknown";
-  return "running";
-}
-function extractPendingQuestion(snap) {
-  return snap?.pendingQuestion || snap?.state?.pendingQuestion || snap?.state?.waiting || null;
-}
-function extractActorId(snap) {
-  const actorId = snap?.actorId || snap?.actor?.actorId || snap?.actor?.id || snap?.state?.actorId || snap?.state?.actor?.actorId || snap?.state?.actor?.id;
-  return typeof actorId === "string" && actorId.length > 0 ? actorId : void 0;
 }
-function extractLiveProgress(snap) {
-  const lp = snap?.liveProgress || snap?.state?.__live_progress;
-  const latest = Array.isArray(lp) ? lp[lp.length - 1] : lp;
-  if (!latest?.message) return void 0;
+
+// src/pushRegistration.ts
+function createPushRegistration(backend) {
+  let token = null;
   return {
-    message: String(latest.message || ""),
-    ...latest.step != null ? { step: latest.step } : {},
-    ...latest.total != null ? { total: latest.total } : {}
+    getToken: () => token,
+    async setToken(next) {
+      if (!next) {
+        token = null;
+        return;
+      }
+      if (next === token) return;
+      token = next;
+      try {
+        await backend.registerDevice(next);
+      } catch (e) {
+        console.warn("[adas/push] registerDevice failed:", e?.message || e);
+      }
+    },
+    async unregister() {
+      const t = token;
+      token = null;
+      if (t) {
+        backend.unregisterDevice(t).catch(
+          (e) => console.warn("[adas/push] unregisterDevice failed:", e?.message || e)
+        );
+      }
+    }
   };
 }
-function extractCurrentTool(state) {
-  const exec = state?.steps?.__exec;
-  if (!exec || typeof exec !== "object") return void 0;
-  const latest = Object.keys(exec).map((k) => ({ k, n: parseInt(k.replace("iter_", ""), 10) })).filter(({ n }) => !isNaN(n)).sort((a, b) => b.n - a.n)[0];
-  if (!latest) return void 0;
-  const steps = exec[latest.k];
-  if (!Array.isArray(steps) || !steps.length) return void 0;
-  const last = steps[steps.length - 1];
-  return last?.tool || last?.phase;
+
+// src/acs/widgetsStore.ts
+var import_zustand = require("zustand");
+
+// src/acs/providers.ts
+var _reachability = null;
+function setAcsReachabilityReporter(r) {
+  _reachability = r;
 }
-function snapshotToProgress(snap, rootJobId) {
-  const pq = extractPendingQuestion(snap);
-  const progress = {
-    jobId: rootJobId,
-    actorId: extractActorId(snap),
-    status: pq ? "paused" : normalizeJobStatus(snap),
-    subStatus: snap?.subStatus || snap?.phase || snap?.state?.visual?.phase,
-    phase: snap?.phase || snap?.state?.visual?.phase,
-    iteration: snap?.iteration || snap?.state?.plannerIter,
-    skillSlug: snap?.skillSlug || snap?.activeSkill,
-    currentTool: snap?.currentTool || snap?.lastTool || extractCurrentTool(snap?.state)
-  };
-  const liveProgress = extractLiveProgress(snap);
-  if (liveProgress) progress.liveProgress = liveProgress;
-  if (typeof snap?.humanStatus === "string" && snap.humanStatus) progress.humanStatus = snap.humanStatus;
-  if (snap?.humanLabels && typeof snap.humanLabels === "object") progress.humanLabels = snap.humanLabels;
-  if (pq) {
-    progress.pendingQuestion = {
-      inputId: pq.correlation_id || pq.correlationId || pq.inputId || "",
-      question: pq.prompt_message || pq.question || "The assistant needs your input",
-      inputType: pq.inputType || "text",
-      options: pq.options || pq.requested_fields,
-      placeholder: pq.placeholder
-    };
+function reportAcsServerUp() {
+  try {
+    _reachability?.up();
+  } catch {
   }
-  return progress;
 }
-function isTerminalSnapshot(snap) {
-  if (extractPendingQuestion(snap)) return false;
-  return snap?.done === true || isTerminalStatus(snap?.status);
+function reportAcsServerDown() {
+  try {
+    _reachability?.down();
+  } catch {
+  }
 }
-var TABLE_BLOCK_OPEN = "\uE100";
-var TABLE_BLOCK_CLOSE = "\uE101";
-function renderTableShape(content) {
-  if (!content || typeof content !== "object") return null;
-  const cols = Array.isArray(content.columns) ? content.columns : null;
-  const rows = Array.isArray(content.rows) ? content.rows : null;
-  if (!cols || !rows) return null;
-  const payload = encodeURIComponent(JSON.stringify({ columns: cols, rows }));
-  return `${TABLE_BLOCK_OPEN}${payload}${TABLE_BLOCK_CLOSE}`;
+var _kv = null;
+function setAcsCacheStorage(kv) {
+  _kv = kv;
 }
-function blocksToText(blocks) {
-  if (!blocks || blocks.length === 0) return "";
-  const hasTextBlock = blocks.some(
-    (b) => b.kind === "text" || b.kind === "markdown" || b.kind === "description"
-  );
-  return blocks.map((b) => {
-    if ((b.kind === "json" || b.kind === "code") && hasTextBlock) return "";
-    if (b.kind === "text" || b.kind === "markdown" || b.kind === "description") {
-      return typeof b.content === "string" ? b.content : "";
-    }
-    if (b.kind === "code") {
-      const code = typeof b.content === "object" ? b.content.content : b.content;
-      return `\`\`\`
-${code}
-\`\`\``;
-    }
-    if (b.kind === "table" && b.content && typeof b.content === "object") {
-      const md = renderTableShape(b.content);
-      if (md) return md;
-    }
-    if (b.kind === "json") {
-      if (b.content && typeof b.content === "object" && "pendingQuestion" in b.content) return "";
-      const md = renderTableShape(b.content);
-      if (md) return md;
-      return "```json\n" + JSON.stringify(b.content, null, 2) + "\n```";
-    }
-    if (b.kind === "html") {
-      return typeof b.content === "string" ? b.content : "";
-    }
-    return typeof b.content === "string" ? b.content : JSON.stringify(b.content);
-  }).filter(Boolean).join("\n\n");
+function getAcsCacheStorage() {
+  return _kv;
 }
-function blocksToAttachments(blocks) {
-  if (!blocks || blocks.length === 0) return void 0;
-  const atts = [];
-  for (const b of blocks) {
-    if ((b.kind === "image" || b.kind === "file") && (b.url || b.hash)) {
-      atts.push({
-        mimeType: b.mimeType || (b.kind === "image" ? "image/jpeg" : "application/octet-stream"),
-        name: b.name || "attachment",
-        previewUri: b.url ? `${getCoreApiUrl()}${b.url}` : void 0
-      });
-    }
+
+// src/acs/api.ts
+async function authedFetch(path, init) {
+  const token = getToken();
+  try {
+    const res = await fetch(`${getCoreApiUrl()}${path}`, {
+      ...init,
+      headers: {
+        "Content-Type": "application/json",
+        ...token ? { Authorization: `Bearer ${token}` } : {},
+        ...init?.headers || {}
+      }
+    });
+    reportAcsServerUp();
+    return res;
+  } catch (e) {
+    reportAcsServerDown();
+    throw e;
   }
-  return atts.length > 0 ? atts : void 0;
 }
-var useChatStore = (0, import_zustand.create)((set, get) => ({
-  messages: [],
-  loading: false,
+async function listSurface(surface, context) {
+  try {
+    const res = await authedFetch("/api/acs/surface", {
+      method: "POST",
+      body: JSON.stringify({ surface, ...context ? { context } : {} })
+    });
+    if (!res.ok) {
+      console.warn(`[acs] /surface ${surface} returned ${res.status}`);
+      return [];
+    }
+    const data = await res.json();
+    return Array.isArray(data?.items) ? data.items : [];
+  } catch (e) {
+    console.warn("[acs] /surface failed:", e?.message || e);
+    return [];
+  }
+}
+async function listMadeForYou() {
+  try {
+    const res = await authedFetch("/api/acs/made-for-you", { method: "GET" });
+    if (!res.ok) {
+      console.warn(`[acs] /made-for-you returned ${res.status}`);
+      return [];
+    }
+    const data = await res.json();
+    return Array.isArray(data?.artifacts) ? data.artifacts : [];
+  } catch (e) {
+    console.warn("[acs] /made-for-you failed:", e?.message || e);
+    return [];
+  }
+}
+async function deleteArtifact(artifactId, reason = "user_long_press_delete") {
+  try {
+    const res = await authedFetch(
+      `/api/acs/artifacts/${encodeURIComponent(artifactId)}`,
+      { method: "DELETE", body: JSON.stringify({ reason }) }
+    );
+    const data = await res.json().catch(() => ({}));
+    if (res.ok) {
+      return { ok: true, already: !!data?.already, status: res.status };
+    }
+    if (res.status === 404) {
+      return { ok: true, notFound: true, status: 404 };
+    }
+    return { ok: false, status: res.status, error: data?.error || `HTTP ${res.status}` };
+  } catch (e) {
+    return { ok: false, status: 0, error: e?.message || "network error" };
+  }
+}
+async function patchArtifact(artifactId, body, reason) {
+  try {
+    const res = await authedFetch(
+      `/api/acs/artifacts/${encodeURIComponent(artifactId)}`,
+      { method: "PATCH", body: JSON.stringify({ ...body, reason }) }
+    );
+    const data = await res.json().catch(() => ({}));
+    if (res.ok) {
+      return {
+        ok: true,
+        already: !!data?.already,
+        artifact: data?.artifact || void 0,
+        status: res.status
+      };
+    }
+    if (res.status === 404) {
+      return { ok: true, notFound: true, status: 404 };
+    }
+    return {
+      ok: false,
+      status: res.status,
+      error: data?.error || `HTTP ${res.status}`
+    };
+  } catch (e) {
+    return { ok: false, status: 0, error: e?.message || "network error" };
+  }
+}
+async function setOrder(pinned) {
+  try {
+    const res = await authedFetch("/api/acs/order", {
+      method: "PUT",
+      body: JSON.stringify({ pinned })
+    });
+    if (res.ok) return { ok: true, status: res.status };
+    const data = await res.json().catch(() => ({}));
+    return { ok: false, status: res.status, error: data?.error || `HTTP ${res.status}` };
+  } catch (e) {
+    return { ok: false, status: 0, error: e?.message || "network error" };
+  }
+}
+async function recordEvent(artifactId, event, surface) {
+  try {
+    await authedFetch("/api/acs/event", {
+      method: "POST",
+      body: JSON.stringify({ artifactId, event, ...surface ? { surface } : {} })
+    });
+  } catch {
+  }
+}
+async function listHomeActions() {
+  try {
+    const res = await authedFetch("/api/acs/home-actions", { method: "GET" });
+    if (!res.ok) {
+      console.warn(`[acs] /home-actions returned ${res.status}`);
+      return [];
+    }
+    const data = await res.json();
+    return Array.isArray(data?.actions) ? data.actions : [];
+  } catch (e) {
+    console.warn("[acs] /home-actions failed:", e?.message || e);
+    return [];
+  }
+}
+async function patchHomeAction(actionId, body, reason) {
+  try {
+    const res = await authedFetch(
+      `/api/acs/home-actions/${encodeURIComponent(actionId)}`,
+      { method: "PATCH", body: JSON.stringify({ ...body, reason }) }
+    );
+    const data = await res.json().catch(() => ({}));
+    if (res.ok) return { ok: true, action: data?.action || void 0, status: res.status };
+    if (res.status === 404) return { ok: true, status: 404 };
+    return { ok: false, status: res.status, error: data?.error || `HTTP ${res.status}` };
+  } catch (e) {
+    return { ok: false, status: 0, error: e?.message || "network error" };
+  }
+}
+async function setHomeActionOrder(order) {
+  try {
+    const res = await authedFetch("/api/acs/home-actions/order", {
+      method: "PUT",
+      body: JSON.stringify({ order })
+    });
+    if (res.ok) return { ok: true, status: res.status };
+    const data = await res.json().catch(() => ({}));
+    return { ok: false, status: res.status, error: data?.error || `HTTP ${res.status}` };
+  } catch (e) {
+    return { ok: false, status: 0, error: e?.message || "network error" };
+  }
+}
+
+// src/acs/widgetsStore.ts
+var useWidgetsStore = (0, import_zustand.create)((set, get) => ({
+  tiles: [],
+  hydrated: false,
+  loading: false,
   error: null,
-  activeJobId: null,
-  conversationLoaded: false,
-  // -----------------------------------------------------------------------
-  // Load conversation history from Core
-  // GET /api/conversation → array of turns [{user, assistant, jobId, ...}]
-  // -----------------------------------------------------------------------
-  loadConversation: async () => {
+  hydrate: async () => {
+    if (get().hydrated || get().loading) return;
+    await get().refresh();
+  },
+  refresh: async () => {
+    if (get().loading) return;
+    set({ loading: true, error: null });
     try {
-      const attachmentCache = getConfig().attachmentCache;
-      await attachmentCache?.ready();
-      const res = await fetch(`${getCoreApiUrl()}/api/conversation?limit=20`, {
-        headers: coreHeaders()
-      });
-      if (!res.ok) {
-        console.warn("[adas-chat] Failed to load conversation:", res.status);
-        set({ conversationLoaded: true });
-        return;
-      }
-      const data = await res.json();
-      if (!data.ok || !data.items) {
-        set({ conversationLoaded: true });
-        return;
-      }
-      const items = [...data.items].reverse();
-      const persistedMessages = [];
-      const seenJobIds = /* @__PURE__ */ new Set();
-      for (const turn of items) {
-        if (turn.jobId && seenJobIds.has(turn.jobId)) continue;
-        if (turn.jobId) seenJobIds.add(turn.jobId);
-        const userText = blocksToText(turn.user?.blocks);
-        let userAtts = blocksToAttachments(turn.user?.blocks);
-        if (!userAtts && turn.jobId) {
-          userAtts = attachmentCache?.get(turn.jobId);
-        }
-        const turnChainId = typeof turn.chainId === "string" ? turn.chainId : void 0;
-        if (userText || userAtts) {
-          persistedMessages.push({
-            id: `user-${turn.jobId}`,
-            role: "user",
-            content: userText || "",
-            timestamp: new Date(turn.startedAt || Date.now()),
-            skillSlug: turn.skillSlug,
-            ...userAtts ? { attachments: userAtts } : {},
-            ...turnChainId ? { chainId: turnChainId } : {}
-          });
-        }
-        const assistantText = blocksToText(turn.assistant?.blocks);
-        const assistantAtts = blocksToAttachments(turn.assistant?.blocks);
-        const assistantActions = Array.isArray(turn.assistant?.actions) ? turn.assistant.actions : void 0;
-        const turnKind = typeof turn.kind === "string" ? turn.kind : void 0;
-        if (assistantText || assistantAtts || assistantActions?.length) {
-          persistedMessages.push({
-            id: `bot-${turn.jobId}`,
-            role: "assistant",
-            content: assistantText || "",
-            timestamp: new Date(turn.finishedAt || turn.startedAt || Date.now()),
-            skillSlug: turn.skillSlug,
-            ...assistantAtts ? { attachments: assistantAtts } : {},
-            ...assistantActions?.length ? { actions: assistantActions } : {},
-            ...turnChainId ? { chainId: turnChainId } : {},
-            ...turnKind ? { kind: turnKind } : {}
-          });
-        }
-      }
-      const current = get().messages;
-      const keptPlaceholders = [];
-      for (const m of current) {
-        if (!m.id.startsWith("job-") || !m.jobProgress || !m.chainId) continue;
-        const matchIdx = persistedMessages.findIndex(
-          (pm) => pm.role === "assistant" && pm.chainId === m.chainId
-        );
-        if (matchIdx >= 0) {
-          const st = m.jobProgress.status;
-          if (st === "running" || st === "paused") {
-            persistedMessages[matchIdx] = { ...persistedMessages[matchIdx], jobProgress: m.jobProgress };
-          }
-        } else {
-          keptPlaceholders.push(m);
-        }
-      }
-      const isLocalUserId = (id) => /^user-\d+$/.test(id);
-      const keptUserBubbles = current.filter((m) => {
-        if (m.role !== "user" || !isLocalUserId(m.id)) return false;
-        if (!m.chainId) return true;
-        return !persistedMessages.some(
-          (pm) => pm.role === "user" && pm.chainId === m.chainId
-        );
-      });
-      const finalMessages = [...persistedMessages, ...keptUserBubbles, ...keptPlaceholders];
-      finalMessages.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
-      let firstRunning = keptPlaceholders.find((m) => m.jobProgress?.status === "running");
-      try {
-        let activeChains = [];
-        const chainsRes = await fetch(`${getCoreApiUrl()}/api/chains/active`, {
-          headers: coreHeaders()
-        });
-        if (chainsRes.ok) {
-          const body = await chainsRes.json();
-          activeChains = Array.isArray(body?.chains) ? body.chains : [];
-        } else {
-          const legacy = await fetch(`${getCoreApiUrl()}/api/chain/current`, {
-            headers: coreHeaders()
-          });
-          if (legacy.ok) {
-            const lb = await legacy.json();
-            if (lb?.data?.id) activeChains = [lb.data];
-          }
-        }
-        for (const slim of activeChains) {
-          if (!slim?.id) continue;
-          const chainId = String(slim.id);
-          const alreadyTracked = finalMessages.some(
-            (m) => m.role === "assistant" && m.jobProgress?.jobId === chainId
-          );
-          if (alreadyTracked) continue;
-          const progress = snapshotToProgress(
-            { ...slim, status: slim.chainStatus || slim.status },
-            chainId
-          );
-          const chainCreatedAt = typeof slim.createdAt === "number" ? slim.createdAt : typeof slim.lastUpdate === "number" ? slim.lastUpdate : Date.now();
-          const chainLastUpdate = typeof slim.lastUpdate === "number" ? slim.lastUpdate : chainCreatedAt;
-          const jobProgress = {
-            jobId: chainId,
-            actorId: extractActorId(slim),
-            status: "running",
-            chainStartedAt: chainCreatedAt,
-            ...progress
-          };
-          const goal = typeof slim.goal === "string" ? slim.goal : "";
-          const userExists = finalMessages.some(
-            (m) => m.role === "user" && (m.chainId === chainId || goal && m.content === goal)
-          );
-          if (goal && !userExists) {
-            finalMessages.push({
-              id: `user-${chainId}`,
-              role: "user",
-              content: goal,
-              timestamp: new Date(chainCreatedAt),
-              chainId
-            });
-          }
-          let matchIdx = -1;
-          for (let i = finalMessages.length - 1; i >= 0; i--) {
-            const m = finalMessages[i];
-            if (m.role === "assistant" && m.chainId === chainId) {
-              matchIdx = i;
-              break;
-            }
-          }
-          if (matchIdx >= 0) {
-            finalMessages[matchIdx] = { ...finalMessages[matchIdx], jobProgress };
-            if (jobProgress.status === "running" && !firstRunning) firstRunning = finalMessages[matchIdx];
-          } else {
-            const reattachBubble = {
-              id: `job-${chainId}`,
-              role: "assistant",
-              content: "Working on it...",
-              timestamp: new Date(chainLastUpdate),
-              jobProgress,
-              chainId
-            };
-            finalMessages.push(reattachBubble);
-            if (jobProgress.status === "running" && !firstRunning) firstRunning = reattachBubble;
-          }
-          streamJob(chainId, getTenant(), getToken());
-        }
-        finalMessages.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
-      } catch {
-      }
-      set({
-        messages: finalMessages,
-        conversationLoaded: true,
-        error: null,
-        activeJobId: firstRunning?.jobProgress?.jobId || null,
-        loading: !!firstRunning
-      });
-    } catch (err) {
-      console.warn("[adas-chat] Error loading conversation:", err.message);
-      set({ conversationLoaded: true });
+      const tiles = await listSurface("home");
+      set({ tiles, loading: false, hydrated: true });
+    } catch (e) {
+      set({ loading: false, hydrated: true, error: e?.message || "Failed to load widgets" });
     }
   },
-  // -----------------------------------------------------------------------
-  // Send message via Core API
-  // POST /api/chat { goal } → { jobId } → stream → fetch turn result
-  // -----------------------------------------------------------------------
-  sendMessage: async (text, skillSlug, attachments) => {
-    const userMsg = {
-      id: `user-${Date.now()}`,
-      role: "user",
-      content: text,
-      timestamp: /* @__PURE__ */ new Date(),
-      ...attachments?.length ? {
-        attachments: attachments.map((a) => ({
-          mimeType: a.mimeType,
-          name: a.name,
-          previewUri: a.mimeType.startsWith("image/") ? `data:${a.mimeType};base64,${a.data}` : void 0
-        }))
-      } : {}
-    };
-    set((s) => ({ messages: [...s.messages, userMsg], loading: true, error: null }));
-    try {
-      const actor = getUser();
-      const body = {
-        goal: text,
-        // Opt in to the Chain Additions router (attach/cancel/new while a
-        // chain runs). Backend ignores it where not applicable — safe to send.
-        chainRouting: true,
-        triggerContext: {
-          channel: "mobile",
-          replyContext: { chatId: actor?.actorId || "unknown" }
-        }
-      };
-      if (skillSlug) body.skillSlug = skillSlug;
-      if (attachments?.length) body.attachments = attachments;
-      const res = await fetch(`${getCoreApiUrl()}/api/chat`, {
-        method: "POST",
-        headers: coreHeaders(),
-        body: JSON.stringify(body)
-      });
-      if (!res.ok) {
-        let errMsg = `Server error (${res.status})`;
-        try {
-          const text2 = await res.text();
-          if (text2.startsWith("<") || text2.startsWith("<!")) {
-            errMsg = res.status === 502 ? "Server is temporarily unavailable. Please try again." : `Server error (${res.status})`;
-          } else {
-            const parsed = JSON.parse(text2);
-            errMsg = parsed.error || errMsg;
-          }
-        } catch {
-        }
-        throw new Error(errMsg);
-      }
-      const data = await res.json();
-      if (!data.ok) {
-        throw new Error(data.error || "Failed to send message");
-      }
-      if (data.mode === "chain_addition" || data.mode === "chain_cancel") {
-        const ack = data.mode === "chain_addition" ? data.ack || "Got it \u2014 added to the running task." : "Stopping the task\u2026";
-        set((s) => ({
-          messages: s.messages.map((m) => m.id === userMsg.id && data.chainId ? { ...m, chainId: data.chainId } : m).concat({
-            id: `ack-${Date.now()}`,
-            role: "assistant",
-            content: ack,
-            timestamp: /* @__PURE__ */ new Date(),
-            ...data.chainId ? { chainId: data.chainId } : {}
-          })
-        }));
-        return;
-      }
-      const jobId = data.id || data.jobId;
-      if (!jobId) {
-        throw new Error("No job ID returned");
-      }
-      if (attachments?.length) {
-        await getConfig().attachmentCache?.save(jobId, attachments);
-      }
-      const progressMsg = {
-        id: `job-${jobId}`,
-        role: "assistant",
-        content: "Working on it...",
-        timestamp: /* @__PURE__ */ new Date(),
-        jobProgress: {
-          jobId,
-          actorId: actor?.actorId,
-          status: "running",
-          subStatus: "Starting...",
-          chainStartedAt: Date.now()
-        },
-        chainId: jobId
-      };
-      set((s) => ({
-        messages: s.messages.map(
-          (m) => m.id === userMsg.id ? { ...m, chainId: jobId } : m
-        ).concat(progressMsg),
-        activeJobId: jobId
-      }));
-      streamJob(jobId, getTenant(), getToken());
-    } catch (err) {
-      set((s) => ({
-        messages: [...s.messages, {
-          id: `error-${Date.now()}`,
-          role: "system",
-          content: `Error: ${err.message}`,
-          timestamp: /* @__PURE__ */ new Date()
-        }],
-        loading: false
-      }));
+  clear: () => set({ tiles: [], hydrated: false, loading: false, error: null }),
+  remove: async (artifactId, reason = "user_long_press_delete") => {
+    const before = get().tiles;
+    set({ tiles: before.filter((t) => t.id !== artifactId) });
+    const result = await deleteArtifact(artifactId, reason);
+    if (result.ok) {
+      return { ok: true };
+    }
+    set({ tiles: before });
+    return { ok: false, error: result.error || `HTTP ${result.status}` };
+  },
+  hide: async (artifactId) => {
+    const before = get().tiles;
+    set({
+      tiles: before.map(
+        (t) => t.id === artifactId ? { ...t, visibility: "hidden" } : t
+      )
+    });
+    const r = await patchArtifact(artifactId, { visibility: "hidden" }, "user_long_press_hide");
+    if (r.ok) {
+      if (r.artifact) {
+        set({
+          tiles: get().tiles.map((t) => t.id === artifactId ? { ...t, ...r.artifact } : t)
+        });
+      }
+      return { ok: true };
     }
+    set({ tiles: before });
+    return { ok: false, error: r.error || `HTTP ${r.status}` };
   },
-  // -----------------------------------------------------------------------
-  // Respond to sys.askUser paused question
-  // -----------------------------------------------------------------------
-  respondToQuestion: async (jobId, inputId, answer) => {
-    try {
-      const res = await fetch(`${getCoreApiUrl()}/api/job/${jobId}/respond`, {
-        method: "POST",
-        headers: coreHeaders(),
-        body: JSON.stringify({ inputId, answer })
-      });
-      const data = await res.json();
-      if (!data.ok) {
-        console.warn("[adas-chat] Failed to respond to question:", data.error);
+  unhide: async (artifactId) => {
+    const before = get().tiles;
+    set({
+      tiles: before.map(
+        (t) => t.id === artifactId ? { ...t, visibility: "pinned" } : t
+      )
+    });
+    const r = await patchArtifact(artifactId, { visibility: "pinned" }, "user_long_press_unhide");
+    if (r.ok) {
+      if (r.artifact) {
+        set({
+          tiles: get().tiles.map((t) => t.id === artifactId ? { ...t, ...r.artifact } : t)
+        });
       }
-    } catch (err) {
-      console.warn("[adas-chat] Error responding to question:", err.message);
+      return { ok: true };
     }
+    set({ tiles: before });
+    return { ok: false, error: r.error || `HTTP ${r.status}` };
   },
-  // -----------------------------------------------------------------------
-  // Update job progress (called by the stream handler)
-  // -----------------------------------------------------------------------
-  updateJobProgress: (jobId, progress) => {
-    set((s) => ({
-      messages: s.messages.map((m) => {
-        if (m.jobProgress?.jobId === jobId) {
-          const updated = { ...m.jobProgress, ...progress };
-          if (progress.status && progress.status !== "paused") {
-            updated.pendingQuestion = void 0;
-          }
-          const isPersisted = m.id.startsWith("bot-");
-          const content = isPersisted ? m.content : progress.resultMessage || progress.pendingQuestion?.question || m.content;
-          const actions = isPersisted ? m.actions : progress.resultActions?.length ? progress.resultActions : m.actions;
-          return {
-            ...m,
-            jobProgress: updated,
-            content,
-            ...actions ? { actions } : {}
-          };
-        }
-        return m;
-      }),
-      loading: progress.status === "done" || progress.status === "error" || progress.status === "paused" ? false : s.loading,
-      activeJobId: progress.status === "done" || progress.status === "error" || progress.status === "paused" ? null : s.activeJobId
-    }));
+  rename: async (artifactId, name) => {
+    const trimmed = name.trim();
+    if (!trimmed) return { ok: false, error: "Name cannot be empty" };
+    if (trimmed.length > 60) return { ok: false, error: "Name must be 60 characters or less" };
+    const before = get().tiles;
+    set({
+      tiles: before.map((t) => t.id === artifactId ? { ...t, name: trimmed } : t)
+    });
+    const r = await patchArtifact(artifactId, { name: trimmed }, "user_long_press_rename");
+    if (r.ok) {
+      if (r.artifact) {
+        set({
+          tiles: get().tiles.map((t) => t.id === artifactId ? { ...t, ...r.artifact } : t)
+        });
+      }
+      return { ok: true };
+    }
+    set({ tiles: before });
+    return { ok: false, error: r.error || `HTTP ${r.status}` };
   },
-  clearChat: () => {
+  reorder: async (pinnedIds) => {
+    const before = get().tiles;
+    const idToOrder = new Map(pinnedIds.map((id, i) => [id, i]));
     set({
-      messages: [],
-      loading: false,
-      error: null,
-      activeJobId: null,
-      conversationLoaded: false
+      tiles: before.map((t) => {
+        const o = idToOrder.get(t.id);
+        return o == null ? t : { ...t, pinOrder: o };
+      })
     });
+    const r = await setOrder(pinnedIds);
+    if (r.ok) return { ok: true };
+    set({ tiles: before });
+    return { ok: false, error: r.error || `HTTP ${r.status}` };
   },
-  newChat: () => {
+  applyServerUpdate: (artifact) => {
     set({
-      messages: [],
-      loading: false,
-      error: null,
-      activeJobId: null,
-      conversationLoaded: true
+      tiles: get().tiles.map((t) => t.id === artifact.id ? { ...t, ...artifact } : t)
+    });
+  },
+  applyServerRetire: (artifactId) => {
+    set({ tiles: get().tiles.filter((t) => t.id !== artifactId) });
+  },
+  applyServerOrder: (pinnedIds) => {
+    const idToOrder = new Map(pinnedIds.map((id, i) => [id, i]));
+    set({
+      tiles: get().tiles.map((t) => {
+        const o = idToOrder.get(t.id);
+        return o == null ? t : { ...t, pinOrder: o };
+      })
+    });
+  },
+  track: (artifactId, event) => {
+    recordEvent(artifactId, event, "home");
+  }
+}));
+
+// src/acs/homeActionsStore.ts
+var import_zustand2 = require("zustand");
+var CACHE_KEY = "ateam.homeActions.v1";
+function persist(actions) {
+  getAcsCacheStorage()?.setItem(CACHE_KEY, JSON.stringify(actions)).catch(() => {
+  });
+}
+function sortByPin(a, b) {
+  if (!!a.pinned !== !!b.pinned) return a.pinned ? -1 : 1;
+  const ao = typeof a.pinOrder === "number" ? a.pinOrder : Number.MAX_SAFE_INTEGER;
+  const bo = typeof b.pinOrder === "number" ? b.pinOrder : Number.MAX_SAFE_INTEGER;
+  return ao - bo;
+}
+var useHomeActionsStore = (0, import_zustand2.create)((set, get) => ({
+  actions: [],
+  hydrated: false,
+  loading: false,
+  hydrate: async () => {
+    if (get().hydrated || get().loading) return;
+    try {
+      const cached = await getAcsCacheStorage()?.getItem(CACHE_KEY);
+      if (cached) {
+        const parsed = JSON.parse(cached);
+        if (Array.isArray(parsed) && parsed.length > 0) {
+          set({ actions: parsed, hydrated: true });
+        }
+      }
+    } catch {
+    }
+    await get().refresh();
+  },
+  refresh: async () => {
+    if (get().loading) return;
+    set({ loading: true });
+    const actions = await listHomeActions();
+    if (actions.length > 0) {
+      set({ actions, loading: false, hydrated: true });
+      persist(actions);
+    } else {
+      set({ loading: false, hydrated: true });
+    }
+  },
+  // clear() wipes in-memory state on sign-out AND drops the disk cache — a
+  // different user must not see the prior user's cards.
+  clear: () => {
+    set({ actions: [], hydrated: false, loading: false });
+    getAcsCacheStorage()?.setItem(CACHE_KEY, "[]").catch(() => {
     });
+  },
+  dismiss: async (actionId) => {
+    const before = get().actions;
+    const next = before.filter((a) => a.actionId !== actionId);
+    set({ actions: next });
+    persist(next);
+    const r = await patchHomeAction(actionId, { dismissed: true }, "user_dismiss");
+    if (r.ok) return { ok: true };
+    set({ actions: before });
+    persist(before);
+    return { ok: false, error: r.error || `HTTP ${r.status}` };
+  },
+  setPinned: async (actionId, pinned) => {
+    const before = get().actions;
+    const next = before.map((a) => a.actionId === actionId ? { ...a, pinned } : a).sort(sortByPin);
+    set({ actions: next });
+    persist(next);
+    const r = await patchHomeAction(actionId, { pinned }, pinned ? "user_pin" : "user_unpin");
+    if (r.ok) {
+      if (r.action) {
+        const merged = get().actions.map((a) => a.actionId === actionId ? { ...a, ...r.action } : a).sort(sortByPin);
+        set({ actions: merged });
+        persist(merged);
+      }
+      return { ok: true };
+    }
+    set({ actions: before });
+    persist(before);
+    return { ok: false, error: r.error || `HTTP ${r.status}` };
+  },
+  reorder: async (orderedIds) => {
+    const before = get().actions;
+    const idx = new Map(orderedIds.map((id, i) => [id, i]));
+    const next = before.map((a) => {
+      const o = idx.get(a.actionId);
+      return o == null ? a : { ...a, pinOrder: o };
+    }).sort(sortByPin);
+    set({ actions: next });
+    persist(next);
+    const r = await setHomeActionOrder(orderedIds);
+    if (r.ok) return { ok: true };
+    set({ actions: before });
+    persist(before);
+    return { ok: false, error: r.error || `HTTP ${r.status}` };
+  },
+  applyServerUpsert: (action) => {
+    const rest = get().actions.filter((a) => a.actionId !== action.actionId);
+    const next = [...rest, action].sort(sortByPin);
+    set({ actions: next });
+    persist(next);
+  },
+  applyServerRemove: (actionId) => {
+    const next = get().actions.filter((a) => a.actionId !== actionId);
+    set({ actions: next });
+    persist(next);
+  },
+  applyServerOrder: (orderedIds) => {
+    const idx = new Map(orderedIds.map((id, i) => [id, i]));
+    const next = get().actions.map((a) => {
+      const o = idx.get(a.actionId);
+      return o == null ? a : { ...a, pinOrder: o };
+    }).sort(sortByPin);
+    set({ actions: next });
+    persist(next);
+  }
+}));
+
+// src/acs/ws.ts
+var _ws = null;
+var _wantOpen = false;
+var _retryAttempt = 0;
+var _retryTimer = null;
+var _token = null;
+var _tenant = null;
+var TOPIC = "acs.artifacts";
+var TOPIC_HOME = "acs.home-actions";
+var MAX_BACKOFF_MS = 3e4;
+var TERMINAL_CLOSE_CODES = /* @__PURE__ */ new Set([4003]);
+var _terminated = false;
+function backoffMs(attempt) {
+  const base = Math.min(MAX_BACKOFF_MS, 500 * Math.pow(2, attempt));
+  const jitter = Math.random() * 250;
+  return base + jitter;
+}
+function send(obj) {
+  if (_ws && _ws.readyState === 1) {
+    try {
+      _ws.send(JSON.stringify(obj));
+    } catch (e) {
+      console.warn("[acsWs] send failed", e);
+    }
   }
-}));
-var _processedPluginCmds = /* @__PURE__ */ new Set();
-function dispatchPluginCommands(cmds) {
-  for (const cmd of cmds) {
-    const corrId = cmd?.correlationId || cmd?.correlation_id;
-    if (corrId && _processedPluginCmds.has(corrId)) continue;
-    if (corrId) _processedPluginCmds.add(corrId);
-    pluginCommandEmitter.emit("plugin-command", cmd);
-    const pluginId = cmd?.pluginId || cmd?.plugin_id || cmd?.args?.plugin_id;
-    if (pluginId) {
-      const props = cmd?.props ?? cmd?.args?.props ?? void 0;
-      pluginCommandEmitter.emit("focus-plugin", { pluginId, props });
+}
+function handleEvent(msg) {
+  if (msg?.event === "subscribed") {
+    console.log("[acsWs] subscribed to", msg?.data?.topic);
+    return;
+  }
+  if (msg?.topic === TOPIC_HOME) {
+    const home = useHomeActionsStore.getState();
+    switch (msg.event) {
+      case "updated":
+        if (msg.action && typeof msg.action.actionId === "string") home.applyServerUpsert(msg.action);
+        break;
+      case "removed":
+        if (typeof msg.actionId === "string") home.applyServerRemove(msg.actionId);
+        break;
+      case "order":
+        if (Array.isArray(msg.order)) home.applyServerOrder(msg.order.filter((id) => typeof id === "string"));
+        break;
+      case "refreshed":
+        home.refresh();
+        break;
+      default:
+        break;
     }
+    return;
+  }
+  if (msg?.topic !== TOPIC) return;
+  const store = useWidgetsStore.getState();
+  switch (msg.event) {
+    case "updated":
+      if (msg.artifact && typeof msg.artifact.id === "string") {
+        store.applyServerUpdate(msg.artifact);
+      }
+      break;
+    case "retired":
+      if (typeof msg.artifactId === "string") {
+        store.applyServerRetire(msg.artifactId);
+      }
+      break;
+    case "order":
+      if (Array.isArray(msg.pinned)) {
+        store.applyServerOrder(msg.pinned.filter((id) => typeof id === "string"));
+      }
+      break;
+    case "created":
+      if (msg.artifact && typeof msg.artifact.id === "string") {
+        store.applyServerUpdate(msg.artifact);
+      }
+      break;
+    default:
+      break;
   }
 }
-var _ws = null;
-var _wsReady = false;
-var _currentJobId = null;
-function ensureWs(tenant, token) {
-  if (_ws && _wsReady) return _ws;
-  const wsUrl = `${getCoreWsUrl()}/ws?token=${encodeURIComponent(token || "")}&tenant=${encodeURIComponent(tenant)}`;
-  const ws = new WebSocket(wsUrl);
+function openSocket() {
+  if (_ws) return;
+  if (!_token || !_tenant) return;
+  const url = `${getCoreWsUrl()}/ws?token=${encodeURIComponent(_token)}&tenant=${encodeURIComponent(_tenant)}`;
+  console.log(`[acsWs] opening`);
+  const ws = new WebSocket(url);
   _ws = ws;
-  _wsReady = false;
+  const isCurrent = () => ws === _ws;
   ws.onopen = () => {
-    _wsReady = true;
-    if (_currentJobId) {
-      ws.send(JSON.stringify({ type: "subscribe", jobId: _currentJobId }));
-    }
+    if (!isCurrent()) return;
+    _retryAttempt = 0;
+    send({ type: "subscribe", topic: TOPIC });
+    send({ type: "subscribe", topic: TOPIC_HOME });
   };
-  ws.onmessage = (ev) => {
+  ws.onmessage = (e) => {
+    if (!isCurrent()) return;
     try {
-      const msg = JSON.parse(typeof ev.data === "string" ? ev.data : "");
-      const { event, data } = msg;
-      const { updateJobProgress } = useChatStore.getState();
-      const jobId = data && (data.id || data.chainId) || _currentJobId;
-      if (event === "plugin_command") {
-        dispatchPluginCommands([data]);
-        return;
-      }
-      if (event === "plugin-command-ack" || event === "pong") return;
-      if (!jobId) return;
-      switch (event) {
-        case "init":
-        case "job":
-        case "update": {
-          const snap = data;
-          const progress = snapshotToProgress(snap, jobId);
-          if (isTerminalSnapshot(snap)) {
-            if (snap.status === "done" && (snap.isHandoff || snap.state?.handoffTransfer)) {
-              updateJobProgress(jobId, { status: "running" });
-              return;
-            }
-            _currentJobId = null;
-            if (progress.status === "paused" && progress.pendingQuestion) {
-              updateJobProgress(jobId, progress);
-            } else {
-              fetchTurnResult(jobId, snap);
-            }
-            return;
-          }
-          updateJobProgress(jobId, progress);
-          break;
-        }
-        case "chain_final":
-          _currentJobId = null;
-          fetchTurnResult(jobId, data);
-          break;
-        case "final":
-          _currentJobId = null;
-          fetchTurnResult(jobId, data);
-          break;
-      }
+      const msg = JSON.parse(typeof e.data === "string" ? e.data : "");
+      handleEvent(msg);
     } catch (err) {
-      console.warn("[adas-chat] WS parse error:", err);
+      console.warn("[acsWs] parse failed", err);
     }
   };
-  ws.onerror = () => {
-    _ws = null;
-    _wsReady = false;
-    if (_currentJobId) {
-      const jid = _currentJobId;
-      _currentJobId = null;
-      pollJob(jid, token);
-    }
+  ws.onerror = (e) => {
+    if (!isCurrent()) return;
+    console.warn("[acsWs] error", e?.message || e);
   };
-  ws.onclose = () => {
+  ws.onclose = (ev) => {
+    if (!isCurrent()) return;
     _ws = null;
-    _wsReady = false;
-    if (_currentJobId) {
-      const jid = _currentJobId;
-      _currentJobId = null;
-      pollJob(jid, token);
+    if (!_wantOpen) return;
+    const code = typeof ev?.code === "number" ? ev.code : 0;
+    if (TERMINAL_CLOSE_CODES.has(code)) {
+      _terminated = true;
+      if (_retryTimer) {
+        clearTimeout(_retryTimer);
+        _retryTimer = null;
+      }
+      console.warn(`[acsWs] server refused permanently (close ${code}); stopping reconnects until re-auth/tenant change`);
+      return;
     }
+    const delay = backoffMs(_retryAttempt++);
+    console.log(`[acsWs] closed (${code}); reconnecting in ${Math.round(delay)}ms (attempt ${_retryAttempt})`);
+    if (_retryTimer) clearTimeout(_retryTimer);
+    _retryTimer = setTimeout(openSocket, delay);
   };
-  return ws;
 }
-function streamJob(jobId, tenant, token) {
-  _currentJobId = jobId;
-  const ws = ensureWs(tenant, token);
-  if (_wsReady) {
-    ws.send(JSON.stringify({ type: "subscribe", jobId }));
+function notifyAcsWsForeground() {
+  if (_terminated) return;
+  if (_wantOpen && !_ws) {
+    if (_retryTimer) {
+      clearTimeout(_retryTimer);
+      _retryTimer = null;
+    }
+    _retryAttempt = 0;
+    openSocket();
   }
 }
-function closeChatStream() {
-  _currentJobId = null;
+function connectAcsWs(token, tenant) {
+  _terminated = false;
+  if (_ws && _wantOpen && _token === token && _tenant === tenant) return;
   if (_ws) {
     try {
       _ws.close();
     } catch {
     }
+    _ws = null;
   }
-  _ws = null;
-  _wsReady = false;
-}
-async function fetchTurnResult(jobId, jobSnap) {
-  if (_processedPluginCmds.size > 200) _processedPluginCmds.clear();
-  const { updateJobProgress } = useChatStore.getState();
-  const status = normalizeJobStatus(jobSnap) === "error" ? "error" : "done";
-  if (jobSnap.isHandoff || jobSnap.state?.handoffTransfer || jobSnap.result?.contentType === "handoff") {
-    try {
-      for (let i = 0; i < 40; i++) {
-        const statusRes = await fetch(`${getCoreApiUrl()}/api/job/${jobId}/status`, {
-          headers: coreHeaders()
-        });
-        if (statusRes.ok) {
-          const statusData = await statusRes.json();
-          if (statusData.done && !statusData.isHandoff) {
-            break;
-          }
-          updateJobProgress(jobId, { status: "running" });
-        }
-        await new Promise((r) => setTimeout(r, 1500));
-      }
-    } catch {
-    }
-  }
-  for (let attempt = 0; attempt < 5; attempt++) {
-    try {
-      const res = await fetch(`${getCoreApiUrl()}/api/conversation?limit=1`, {
-        headers: coreHeaders()
-      });
-      if (res.ok) {
-        const data = await res.json();
-        const items = Array.isArray(data.items) ? data.items : [];
-        const turn = items[0];
-        if (turn?.assistant || turn?.turn?.assistant) {
-          const assistant = turn.assistant || turn.turn?.assistant;
-          const text = blocksToText(assistant.blocks);
-          const actions = Array.isArray(assistant.actions) && assistant.actions.length ? assistant.actions : void 0;
-          if (text) {
-            updateJobProgress(jobId, {
-              status,
-              resultMessage: text,
-              ...actions ? { resultActions: actions } : {}
-            });
-            return;
-          }
-        }
-      }
-    } catch {
-    }
-    await new Promise((r) => setTimeout(r, 800));
-  }
-  const fallback = jobSnap.result?.message || jobSnap.state?.finalReply || (status === "error" ? "Something went wrong. Please try again." : "Done.");
-  updateJobProgress(jobId, { status, resultMessage: fallback });
+  _token = token;
+  _tenant = tenant;
+  _wantOpen = true;
+  openSocket();
 }
-async function pollJob(jobId, token) {
-  const { updateJobProgress } = useChatStore.getState();
-  for (let i = 0; i < 120; i++) {
-    try {
-      const res = await fetch(`${getCoreApiUrl()}/api/job/${jobId}/status`, {
-        headers: {
-          ...token ? { Authorization: `Bearer ${token}` } : {}
-        }
-      });
-      if (!res.ok) {
-        if (res.status === 404) return;
-        continue;
-      }
-      const snap = await res.json();
-      const progress = snapshotToProgress(snap, jobId);
-      if (progress.status === "paused" && progress.pendingQuestion) {
-        updateJobProgress(jobId, progress);
-        return;
-      }
-      updateJobProgress(jobId, progress);
-      if (isTerminalSnapshot(snap)) {
-        fetchTurnResult(jobId, snap);
-        return;
-      }
+function disconnectAcsWs() {
+  _wantOpen = false;
+  _terminated = false;
+  _token = null;
+  _tenant = null;
+  if (_retryTimer) {
+    clearTimeout(_retryTimer);
+    _retryTimer = null;
+  }
+  if (_ws) {
+    try {
+      _ws.close();
     } catch {
     }
-    await new Promise((r) => setTimeout(r, 1500));
+    _ws = null;
   }
-  updateJobProgress(jobId, {
-    status: "error",
-    resultMessage: "Job timed out. Please try again."
-  });
 }
 
-// src/api/tenants.ts
-async function listMyTenants() {
-  const token = getToken();
-  if (!token) return [];
+// src/lifecycle.ts
+var foregroundCbs = /* @__PURE__ */ new Set();
+function onAppForeground(cb) {
+  foregroundCbs.add(cb);
+  return () => {
+    foregroundCbs.delete(cb);
+  };
+}
+function notifyAppForeground() {
   try {
-    const res = await fetch(`${getConsumerAuthApiUrl()}/platform/consumer/my-tenants`, {
-      headers: { Authorization: `Bearer ${token}` }
-    });
-    const data = await res.json().catch(() => null);
-    if (!res.ok || !data?.ok || !Array.isArray(data.tenants)) return [];
-    return data.tenants.map((t) => ({
-      id: t.id,
-      name: t.name || t.id,
-      role: t.role ?? null
-    }));
-  } catch {
-    return [];
+    notifyAcsWsForeground();
+  } catch (e) {
+    console.warn("[adas/lifecycle] acs foreground reconnect failed:", e?.message || e);
+  }
+  for (const cb of foregroundCbs) {
+    try {
+      cb();
+    } catch (e) {
+      console.warn("[adas/lifecycle] foreground callback failed:", e?.message || e);
+    }
   }
 }
-async function switchTenant(targetTenantId) {
-  const token = getToken();
-  if (!token) throw new Error("[adas] switchTenant: not signed in");
-  const res = await fetch(`${getConsumerAuthApiUrl()}/platform/consumer/switch-tenant`, {
+
+// src/gate.ts
+function resolveAdasPhase(f) {
+  if (!f.configHydrated || f.authLoading || f.capabilitiesLoading || f.onboarded === void 0) {
+    return "loading";
+  }
+  if (!f.onboarded) return "onboarding";
+  if (!f.isAuthenticated) {
+    return f.handoffPending ? "handoff" : f.invitePending ? "invite" : "login";
+  }
+  if (f.requireTenantPick && !f.tenantConfirmed) return "tenant";
+  if (!f.hasCompletedSetup) return "capabilities";
+  return "app";
+}
+
+// src/consumerAuth.ts
+function cleanErrorMessage(status, rawText, fallback) {
+  const trimmed = (rawText || "").trim();
+  if (trimmed.startsWith("<")) {
+    return `${fallback} (${status}) \u2014 backend unreachable`;
+  }
+  if (!trimmed) return `${fallback} (${status})`;
+  const short = trimmed.length > 200 ? `${trimmed.slice(0, 200)}\u2026` : trimmed;
+  return `${fallback} (${status}): ${short}`;
+}
+async function postJson(path, body, jwt) {
+  const res = await fetch(`${getConsumerAuthApiUrl()}${path}`, {
     method: "POST",
     headers: {
       "Content-Type": "application/json",
-      Authorization: `Bearer ${token}`
+      ...jwt ? { Authorization: `Bearer ${jwt}` } : {}
     },
-    body: JSON.stringify({ target_tenant: targetTenantId })
+    body: JSON.stringify(body)
   });
-  const data = await res.json().catch(() => null);
-  if (!res.ok || !data?.ok || !data.jwt) {
-    throw new Error(data?.error || `switchTenant failed (${res.status})`);
+  const text = await res.text();
+  let parsed = null;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
   }
-  const session = {
-    jwt: data.jwt,
-    tenant: data.tenant,
-    actor: data.actor
-  };
-  const onSession = getConfig().onSession;
-  if (!onSession) {
-    throw new Error("[adas] switchTenant: config.onSession is required to persist the new session");
+  if (!res.ok || parsed?.ok === false) {
+    if (parsed?.error) throw new Error(parsed.error);
+    throw new Error(cleanErrorMessage(res.status, text, `consumer-auth ${path} failed`));
   }
-  await onSession(session);
-  closeChatStream();
-  useChatStore.getState().clearChat();
-  return session;
+  return parsed;
+}
+async function fetchConsumerConfig() {
+  const url = `${getConsumerAuthApiUrl()}/platform/consumer/config?tenant=${encodeURIComponent(getTenant())}`;
+  const res = await fetch(url);
+  const text = await res.text();
+  let data = null;
+  try {
+    data = JSON.parse(text);
+  } catch {
+  }
+  if (!res.ok || !data?.ok) {
+    if (data?.error) throw new Error(data.error);
+    throw new Error(cleanErrorMessage(res.status, text, "Failed to load sign-in config"));
+  }
+  return data;
+}
+async function signInWithGoogle(idToken) {
+  return postJson("/platform/consumer/oauth/google", {
+    tenant: getTenant(),
+    id_token: idToken
+  });
+}
+async function signInWithApple(idToken) {
+  return postJson("/platform/consumer/oauth/apple", {
+    tenant: getTenant(),
+    id_token: idToken
+  });
+}
+async function exchangeHandoff(code) {
+  return postJson("/platform/consumer/handoff/exchange", { code });
+}
+async function previewInvite(code) {
+  const url = `${getConsumerAuthApiUrl()}/platform/consumer/invite/${encodeURIComponent(code)}`;
+  const res = await fetch(url);
+  const text = await res.text();
+  let data = null;
+  try {
+    data = JSON.parse(text);
+  } catch {
+  }
+  if (res.status === 404) throw new Error("This invite is invalid or has expired.");
+  if (!res.ok || !data?.ok) {
+    if (data?.error) throw new Error(data.error);
+    throw new Error(cleanErrorMessage(res.status, text, "Could not load invite"));
+  }
+  return data;
+}
+async function joinWithGoogle(invite, idToken) {
+  return postJson("/platform/consumer/oauth/google", { invite, id_token: idToken });
+}
+async function joinWithApple(invite, idToken) {
+  return postJson("/platform/consumer/oauth/apple", { invite, id_token: idToken });
+}
+async function openJoinWithGoogle(tenant, idToken) {
+  return postJson("/platform/consumer/oauth/google", { tenant, id_token: idToken });
+}
+async function openJoinWithApple(tenant, idToken) {
+  return postJson("/platform/consumer/oauth/apple", { tenant, id_token: idToken });
+}
+async function linkChannelStart(jwt, channel, handle) {
+  return postJson("/platform/consumer/link-channel/start", { channel, handle }, jwt);
+}
+async function linkChannelVerify(jwt, challengeId, code) {
+  return postJson("/platform/consumer/link-channel/verify", { challenge_id: challengeId, code }, jwt);
 }
 
-// src/theme/tokens.ts
-var colors = {
-  dark: {
-    bgPrimary: "#0a0e14",
-    bgSecondary: "#111820",
-    bgTertiary: "#1a2230",
-    bgInput: "#0d1219",
-    bgHover: "#1e2a3a",
-    border: "rgba(255, 255, 255, 0.08)",
-    borderHover: "rgba(255, 255, 255, 0.15)",
-    textPrimary: "#e8ecf1",
-    textSecondary: "#8b95a5",
-    textMuted: "#5a6577",
-    accent: "#2563eb",
-    accentHover: "#3b82f6",
-    accentSoft: "rgba(37, 99, 235, 0.15)",
-    green: "#16a34a",
-    greenSoft: "rgba(22, 163, 74, 0.15)",
-    red: "#dc2626",
-    redSoft: "rgba(220, 38, 38, 0.15)",
-    amber: "#f59e0b",
-    amberSoft: "rgba(245, 158, 11, 0.15)",
-    purple: "#8b5cf6",
-    purpleSoft: "rgba(139, 92, 246, 0.15)",
-    // Message-specific
-    userBubble: "#2563eb",
-    botBubble: "#1a2230",
-    botBubbleBorder: "rgba(255, 255, 255, 0.08)"
+// src/deepLinks.ts
+function parseDeepLinkParam(url, param) {
+  if (!url) return null;
+  const re = new RegExp(`[?&]${param}=([^&#\\s]+)`, "i");
+  const m = url.match(re);
+  if (!m) return null;
+  try {
+    const v = decodeURIComponent(m[1]);
+    return v.length > 0 ? v : null;
+  } catch {
+    return m[1].length > 0 ? m[1] : null;
+  }
+}
+function parseInviteCode(url) {
+  return parseDeepLinkParam(url, "invite");
+}
+function parseHandoffCode(url) {
+  return parseDeepLinkParam(url, "handoff");
+}
+
+// src/workspace.ts
+var import_zustand3 = require("zustand");
+function normalize(w) {
+  if (!w || typeof w !== "object") return null;
+  const state = w.state === "active" || w.state === "expired" || w.state === "suspended" ? w.state : "unknown";
+  return {
+    state,
+    reason: typeof w.reason === "string" ? w.reason : null,
+    trialEndsAt: typeof w.trialEndsAt === "string" ? w.trialEndsAt : null,
+    expiresInDays: typeof w.expiresInDays === "number" ? w.expiresInDays : null,
+    capabilities: w.capabilities && typeof w.capabilities === "object" ? w.capabilities : {},
+    message: typeof w.message === "string" && w.message.trim() ? w.message : null
+  };
+}
+var _gen = 0;
+var useWorkspaceStore = (0, import_zustand3.create)((set) => ({
+  snapshot: null,
+  loaded: false,
+  refresh: async () => {
+    const gen = _gen;
+    try {
+      const res = await apiFetch("/api/session");
+      if (gen !== _gen) return;
+      set({ snapshot: normalize(res?.workspace), loaded: true });
+    } catch {
+      if (gen !== _gen) return;
+      set({ loaded: true });
+    }
   },
-  light: {
-    bgPrimary: "#ffffff",
-    bgSecondary: "#f8f9fa",
-    bgTertiary: "#f1f3f5",
-    bgInput: "#ffffff",
-    bgHover: "#e9ecef",
-    border: "rgba(0, 0, 0, 0.08)",
-    borderHover: "rgba(0, 0, 0, 0.15)",
-    textPrimary: "#1a1a2e",
-    textSecondary: "#6b7280",
-    textMuted: "#9ca3af",
-    accent: "#2563eb",
-    accentHover: "#1d4ed8",
-    accentSoft: "rgba(37, 99, 235, 0.1)",
-    green: "#16a34a",
-    greenSoft: "rgba(22, 163, 74, 0.1)",
-    red: "#dc2626",
-    redSoft: "rgba(220, 38, 38, 0.1)",
-    amber: "#f59e0b",
-    amberSoft: "rgba(245, 158, 11, 0.1)",
-    purple: "#8b5cf6",
-    purpleSoft: "rgba(139, 92, 246, 0.1)",
-    userBubble: "#2563eb",
-    botBubble: "#f1f3f5",
-    botBubbleBorder: "rgba(0, 0, 0, 0.08)"
+  clear: () => {
+    _gen++;
+    set({ snapshot: null, loaded: false });
+  }
+}));
+function capabilityEnabled(name) {
+  const { snapshot } = useWorkspaceStore.getState();
+  if (!snapshot) return true;
+  return snapshot.capabilities?.[name] === true;
+}
+function useCapability(name) {
+  return useWorkspaceStore((s) => {
+    if (!s.snapshot) return true;
+    return s.snapshot.capabilities?.[name] === true;
+  });
+}
+
+// src/chat/store.ts
+var import_zustand4 = require("zustand");
+
+// src/utils/emitter.ts
+var RECENT_TTL_MS = 1e4;
+var RECENT_MAX = 20;
+var PluginCommandEmitter = class {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Map();
+    // Ring buffer of plugin commands seen recently. Lets a plugin that mounts
+    // AFTER its first command was emitted (e.g. a surface mounted by the
+    // dispatcher in response to focus-plugin) still pick that command up via
+    // `drainPluginCommands(pluginId)`. Self-cleans on TTL + size cap.
+    this.recent = [];
+  }
+  on(event, fn) {
+    if (!this.listeners.has(event)) this.listeners.set(event, /* @__PURE__ */ new Set());
+    this.listeners.get(event).add(fn);
+    return () => this.off(event, fn);
+  }
+  off(event, fn) {
+    this.listeners.get(event)?.delete(fn);
+  }
+  emit(event, data) {
+    if (event === "plugin-command" && data && data.pluginId && data.command && data.command !== "__focus") {
+      this.recent.push({
+        pluginId: data.pluginId,
+        command: data.command,
+        args: data.args,
+        correlationId: data.correlationId,
+        _bufferedAt: Date.now()
+      });
+      if (this.recent.length > RECENT_MAX) this.recent.shift();
+    }
+    this.listeners.get(event)?.forEach((fn) => {
+      try {
+        fn(data);
+      } catch {
+      }
+    });
+  }
+  /** Pop and return any plugin-commands targeted at `pluginId` that were
+   *  emitted within the last RECENT_TTL_MS. Used by the native bridge on
+   *  mount so the surface-dispatcher path doesn't drop the first command. */
+  drainPluginCommands(pluginId) {
+    const now = Date.now();
+    const out = [];
+    const remaining = [];
+    for (const cmd of this.recent) {
+      if (now - cmd._bufferedAt > RECENT_TTL_MS) continue;
+      if (cmd.pluginId === pluginId) out.push(cmd);
+      else remaining.push(cmd);
+    }
+    this.recent = remaining;
+    return out;
   }
 };
-var ada = {
-  paper: "#FAF6EE",
-  paperSoft: "#F2EADC",
-  paperDeep: "#EBE0CC",
-  ink: "#1a1410",
-  inkSoft: "#5a4d3f",
-  inkMuted: "#9a8870",
-  border: "rgba(26, 20, 16, 0.08)",
-  borderStrong: "rgba(26, 20, 16, 0.16)",
-  orange: "#FF7A28",
-  orangeDeep: "#B8410A",
-  orangeSoft: "rgba(255, 122, 40, 0.14)",
-  userBubble: "#1a1410",
-  userBubbleText: "#FAF6EE",
-  botBubble: "#F2EADC",
-  botBubbleBorder: "rgba(26, 20, 16, 0.06)",
-  botBubbleText: "#1a1410"
-};
-var spacing = {
-  xs: 4,
-  sm: 8,
-  md: 12,
-  lg: 16,
-  xl: 20,
-  xxl: 24,
-  xxxl: 32
-};
-var fontSize = {
-  xs: 11,
-  sm: 13,
-  md: 15,
-  lg: 17,
-  xl: 20,
-  xxl: 24,
-  title: 28
-};
-var borderRadius = {
-  sm: 8,
-  md: 12,
-  lg: 16,
-  xl: 20,
-  full: 9999
-};
+var pluginCommandEmitter = new PluginCommandEmitter();
 
-// src/acs/providers.ts
-var _reachability = null;
-function setAcsReachabilityReporter(r) {
-  _reachability = r;
-}
-function reportAcsServerUp() {
-  try {
-    _reachability?.up();
-  } catch {
-  }
-}
-function reportAcsServerDown() {
-  try {
-    _reachability?.down();
-  } catch {
-  }
+// src/chat/store.ts
+function coreHeaders() {
+  const token = getToken();
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (token) headers["Authorization"] = `Bearer ${token}`;
+  return headers;
 }
-var _kv = null;
-function setAcsCacheStorage(kv) {
-  _kv = kv;
+function isTerminalStatus(status) {
+  const s = typeof status === "string" ? status.toLowerCase() : "";
+  return s === "done" || s === "error" || s === "failed" || s === "completed";
 }
-function getAcsCacheStorage() {
-  return _kv;
+function normalizeJobStatus(snap) {
+  const status = typeof snap?.status === "string" ? snap.status.toLowerCase() : "";
+  if (status === "done" || status === "completed") return "done";
+  if (status === "error" || status === "failed") return "error";
+  if (status === "paused" || status === "waiting") return "paused";
+  if (status === "unknown") return "unknown";
+  return "running";
 }
-
-// src/acs/api.ts
-async function authedFetch(path, init) {
-  const token = getToken();
-  try {
-    const res = await fetch(`${getCoreApiUrl()}${path}`, {
-      ...init,
-      headers: {
-        "Content-Type": "application/json",
-        ...token ? { Authorization: `Bearer ${token}` } : {},
-        ...init?.headers || {}
-      }
-    });
-    reportAcsServerUp();
-    return res;
-  } catch (e) {
-    reportAcsServerDown();
-    throw e;
-  }
+function extractPendingQuestion(snap) {
+  return snap?.pendingQuestion || snap?.state?.pendingQuestion || snap?.state?.waiting || null;
 }
-async function listSurface(surface, context) {
-  try {
-    const res = await authedFetch("/api/acs/surface", {
-      method: "POST",
-      body: JSON.stringify({ surface, ...context ? { context } : {} })
-    });
-    if (!res.ok) {
-      console.warn(`[acs] /surface ${surface} returned ${res.status}`);
-      return [];
-    }
-    const data = await res.json();
-    return Array.isArray(data?.items) ? data.items : [];
-  } catch (e) {
-    console.warn("[acs] /surface failed:", e?.message || e);
-    return [];
-  }
+function extractActorId(snap) {
+  const actorId = snap?.actorId || snap?.actor?.actorId || snap?.actor?.id || snap?.state?.actorId || snap?.state?.actor?.actorId || snap?.state?.actor?.id;
+  return typeof actorId === "string" && actorId.length > 0 ? actorId : void 0;
 }
-async function listMadeForYou() {
-  try {
-    const res = await authedFetch("/api/acs/made-for-you", { method: "GET" });
-    if (!res.ok) {
-      console.warn(`[acs] /made-for-you returned ${res.status}`);
-      return [];
-    }
-    const data = await res.json();
-    return Array.isArray(data?.artifacts) ? data.artifacts : [];
-  } catch (e) {
-    console.warn("[acs] /made-for-you failed:", e?.message || e);
-    return [];
-  }
+function extractLiveProgress(snap) {
+  const lp = snap?.liveProgress || snap?.state?.__live_progress;
+  const latest = Array.isArray(lp) ? lp[lp.length - 1] : lp;
+  if (!latest?.message) return void 0;
+  return {
+    message: String(latest.message || ""),
+    ...latest.step != null ? { step: latest.step } : {},
+    ...latest.total != null ? { total: latest.total } : {}
+  };
 }
-async function deleteArtifact(artifactId, reason = "user_long_press_delete") {
-  try {
-    const res = await authedFetch(
-      `/api/acs/artifacts/${encodeURIComponent(artifactId)}`,
-      { method: "DELETE", body: JSON.stringify({ reason }) }
-    );
-    const data = await res.json().catch(() => ({}));
-    if (res.ok) {
-      return { ok: true, already: !!data?.already, status: res.status };
-    }
-    if (res.status === 404) {
-      return { ok: true, notFound: true, status: 404 };
-    }
-    return { ok: false, status: res.status, error: data?.error || `HTTP ${res.status}` };
-  } catch (e) {
-    return { ok: false, status: 0, error: e?.message || "network error" };
-  }
+function extractCurrentTool(state) {
+  const exec = state?.steps?.__exec;
+  if (!exec || typeof exec !== "object") return void 0;
+  const latest = Object.keys(exec).map((k) => ({ k, n: parseInt(k.replace("iter_", ""), 10) })).filter(({ n }) => !isNaN(n)).sort((a, b) => b.n - a.n)[0];
+  if (!latest) return void 0;
+  const steps = exec[latest.k];
+  if (!Array.isArray(steps) || !steps.length) return void 0;
+  const last = steps[steps.length - 1];
+  return last?.tool || last?.phase;
 }
-async function patchArtifact(artifactId, body, reason) {
-  try {
-    const res = await authedFetch(
-      `/api/acs/artifacts/${encodeURIComponent(artifactId)}`,
-      { method: "PATCH", body: JSON.stringify({ ...body, reason }) }
-    );
-    const data = await res.json().catch(() => ({}));
-    if (res.ok) {
-      return {
-        ok: true,
-        already: !!data?.already,
-        artifact: data?.artifact || void 0,
-        status: res.status
-      };
-    }
-    if (res.status === 404) {
-      return { ok: true, notFound: true, status: 404 };
-    }
-    return {
-      ok: false,
-      status: res.status,
-      error: data?.error || `HTTP ${res.status}`
+function snapshotToProgress(snap, rootJobId) {
+  const pq = extractPendingQuestion(snap);
+  const progress = {
+    jobId: rootJobId,
+    actorId: extractActorId(snap),
+    status: pq ? "paused" : normalizeJobStatus(snap),
+    subStatus: snap?.subStatus || snap?.phase || snap?.state?.visual?.phase,
+    phase: snap?.phase || snap?.state?.visual?.phase,
+    iteration: snap?.iteration || snap?.state?.plannerIter,
+    skillSlug: snap?.skillSlug || snap?.activeSkill,
+    currentTool: snap?.currentTool || snap?.lastTool || extractCurrentTool(snap?.state)
+  };
+  const liveProgress = extractLiveProgress(snap);
+  if (liveProgress) progress.liveProgress = liveProgress;
+  if (typeof snap?.humanStatus === "string" && snap.humanStatus) progress.humanStatus = snap.humanStatus;
+  if (snap?.humanLabels && typeof snap.humanLabels === "object") progress.humanLabels = snap.humanLabels;
+  if (pq) {
+    progress.pendingQuestion = {
+      inputId: pq.correlation_id || pq.correlationId || pq.inputId || "",
+      question: pq.prompt_message || pq.question || "The assistant needs your input",
+      inputType: pq.inputType || "text",
+      options: pq.options || pq.requested_fields,
+      placeholder: pq.placeholder
     };
-  } catch (e) {
-    return { ok: false, status: 0, error: e?.message || "network error" };
   }
+  return progress;
 }
-async function setOrder(pinned) {
-  try {
-    const res = await authedFetch("/api/acs/order", {
-      method: "PUT",
-      body: JSON.stringify({ pinned })
-    });
-    if (res.ok) return { ok: true, status: res.status };
-    const data = await res.json().catch(() => ({}));
-    return { ok: false, status: res.status, error: data?.error || `HTTP ${res.status}` };
-  } catch (e) {
-    return { ok: false, status: 0, error: e?.message || "network error" };
-  }
+function isTerminalSnapshot(snap) {
+  if (extractPendingQuestion(snap)) return false;
+  return snap?.done === true || isTerminalStatus(snap?.status);
 }
-async function recordEvent(artifactId, event, surface) {
-  try {
-    await authedFetch("/api/acs/event", {
-      method: "POST",
-      body: JSON.stringify({ artifactId, event, ...surface ? { surface } : {} })
-    });
-  } catch {
-  }
+var TABLE_BLOCK_OPEN = "\uE100";
+var TABLE_BLOCK_CLOSE = "\uE101";
+function renderTableShape(content) {
+  if (!content || typeof content !== "object") return null;
+  const cols = Array.isArray(content.columns) ? content.columns : null;
+  const rows = Array.isArray(content.rows) ? content.rows : null;
+  if (!cols || !rows) return null;
+  const payload = encodeURIComponent(JSON.stringify({ columns: cols, rows }));
+  return `${TABLE_BLOCK_OPEN}${payload}${TABLE_BLOCK_CLOSE}`;
 }
-async function listHomeActions() {
-  try {
-    const res = await authedFetch("/api/acs/home-actions", { method: "GET" });
-    if (!res.ok) {
-      console.warn(`[acs] /home-actions returned ${res.status}`);
-      return [];
+function blocksToText(blocks) {
+  if (!blocks || blocks.length === 0) return "";
+  const hasTextBlock = blocks.some(
+    (b) => b.kind === "text" || b.kind === "markdown" || b.kind === "description"
+  );
+  return blocks.map((b) => {
+    if ((b.kind === "json" || b.kind === "code") && hasTextBlock) return "";
+    if (b.kind === "text" || b.kind === "markdown" || b.kind === "description") {
+      return typeof b.content === "string" ? b.content : "";
     }
-    const data = await res.json();
-    return Array.isArray(data?.actions) ? data.actions : [];
-  } catch (e) {
-    console.warn("[acs] /home-actions failed:", e?.message || e);
-    return [];
-  }
-}
-async function patchHomeAction(actionId, body, reason) {
-  try {
-    const res = await authedFetch(
-      `/api/acs/home-actions/${encodeURIComponent(actionId)}`,
-      { method: "PATCH", body: JSON.stringify({ ...body, reason }) }
-    );
-    const data = await res.json().catch(() => ({}));
-    if (res.ok) return { ok: true, action: data?.action || void 0, status: res.status };
-    if (res.status === 404) return { ok: true, status: 404 };
-    return { ok: false, status: res.status, error: data?.error || `HTTP ${res.status}` };
-  } catch (e) {
-    return { ok: false, status: 0, error: e?.message || "network error" };
-  }
+    if (b.kind === "code") {
+      const code = typeof b.content === "object" ? b.content.content : b.content;
+      return `\`\`\`
+${code}
+\`\`\``;
+    }
+    if (b.kind === "table" && b.content && typeof b.content === "object") {
+      const md = renderTableShape(b.content);
+      if (md) return md;
+    }
+    if (b.kind === "json") {
+      if (b.content && typeof b.content === "object" && "pendingQuestion" in b.content) return "";
+      const md = renderTableShape(b.content);
+      if (md) return md;
+      return "```json\n" + JSON.stringify(b.content, null, 2) + "\n```";
+    }
+    if (b.kind === "html") {
+      return typeof b.content === "string" ? b.content : "";
+    }
+    return typeof b.content === "string" ? b.content : JSON.stringify(b.content);
+  }).filter(Boolean).join("\n\n");
 }
-async function setHomeActionOrder(order) {
-  try {
-    const res = await authedFetch("/api/acs/home-actions/order", {
-      method: "PUT",
-      body: JSON.stringify({ order })
-    });
-    if (res.ok) return { ok: true, status: res.status };
-    const data = await res.json().catch(() => ({}));
-    return { ok: false, status: res.status, error: data?.error || `HTTP ${res.status}` };
-  } catch (e) {
-    return { ok: false, status: 0, error: e?.message || "network error" };
+function blocksToAttachments(blocks) {
+  if (!blocks || blocks.length === 0) return void 0;
+  const atts = [];
+  for (const b of blocks) {
+    if ((b.kind === "image" || b.kind === "file") && (b.url || b.hash)) {
+      atts.push({
+        mimeType: b.mimeType || (b.kind === "image" ? "image/jpeg" : "application/octet-stream"),
+        name: b.name || "attachment",
+        previewUri: b.url ? `${getCoreApiUrl()}${b.url}` : void 0
+      });
+    }
   }
+  return atts.length > 0 ? atts : void 0;
 }
-
-// src/acs/widgetsStore.ts
-var import_zustand2 = require("zustand");
-var useWidgetsStore = (0, import_zustand2.create)((set, get) => ({
-  tiles: [],
-  hydrated: false,
+var useChatStore = (0, import_zustand4.create)((set, get) => ({
+  messages: [],
   loading: false,
   error: null,
-  hydrate: async () => {
-    if (get().hydrated || get().loading) return;
-    await get().refresh();
-  },
-  refresh: async () => {
-    if (get().loading) return;
-    set({ loading: true, error: null });
+  activeJobId: null,
+  conversationLoaded: false,
+  // -----------------------------------------------------------------------
+  // Load conversation history from Core
+  // GET /api/conversation → array of turns [{user, assistant, jobId, ...}]
+  // -----------------------------------------------------------------------
+  loadConversation: async () => {
     try {
-      const tiles = await listSurface("home");
-      set({ tiles, loading: false, hydrated: true });
-    } catch (e) {
-      set({ loading: false, hydrated: true, error: e?.message || "Failed to load widgets" });
-    }
-  },
-  clear: () => set({ tiles: [], hydrated: false, loading: false, error: null }),
-  remove: async (artifactId, reason = "user_long_press_delete") => {
-    const before = get().tiles;
-    set({ tiles: before.filter((t) => t.id !== artifactId) });
-    const result = await deleteArtifact(artifactId, reason);
-    if (result.ok) {
-      return { ok: true };
-    }
-    set({ tiles: before });
-    return { ok: false, error: result.error || `HTTP ${result.status}` };
-  },
-  hide: async (artifactId) => {
-    const before = get().tiles;
-    set({
-      tiles: before.map(
-        (t) => t.id === artifactId ? { ...t, visibility: "hidden" } : t
-      )
-    });
-    const r = await patchArtifact(artifactId, { visibility: "hidden" }, "user_long_press_hide");
-    if (r.ok) {
-      if (r.artifact) {
-        set({
-          tiles: get().tiles.map((t) => t.id === artifactId ? { ...t, ...r.artifact } : t)
-        });
+      const attachmentCache = getConfig().attachmentCache;
+      await attachmentCache?.ready();
+      const res = await fetch(`${getCoreApiUrl()}/api/conversation?limit=20`, {
+        headers: coreHeaders()
+      });
+      if (!res.ok) {
+        console.warn("[adas-chat] Failed to load conversation:", res.status);
+        set({ conversationLoaded: true });
+        return;
       }
-      return { ok: true };
-    }
-    set({ tiles: before });
-    return { ok: false, error: r.error || `HTTP ${r.status}` };
-  },
-  unhide: async (artifactId) => {
-    const before = get().tiles;
-    set({
-      tiles: before.map(
-        (t) => t.id === artifactId ? { ...t, visibility: "pinned" } : t
-      )
-    });
-    const r = await patchArtifact(artifactId, { visibility: "pinned" }, "user_long_press_unhide");
-    if (r.ok) {
-      if (r.artifact) {
-        set({
-          tiles: get().tiles.map((t) => t.id === artifactId ? { ...t, ...r.artifact } : t)
-        });
+      const data = await res.json();
+      if (!data.ok || !data.items) {
+        set({ conversationLoaded: true });
+        return;
       }
-      return { ok: true };
-    }
-    set({ tiles: before });
-    return { ok: false, error: r.error || `HTTP ${r.status}` };
-  },
-  rename: async (artifactId, name) => {
-    const trimmed = name.trim();
-    if (!trimmed) return { ok: false, error: "Name cannot be empty" };
-    if (trimmed.length > 60) return { ok: false, error: "Name must be 60 characters or less" };
-    const before = get().tiles;
-    set({
-      tiles: before.map((t) => t.id === artifactId ? { ...t, name: trimmed } : t)
-    });
-    const r = await patchArtifact(artifactId, { name: trimmed }, "user_long_press_rename");
-    if (r.ok) {
-      if (r.artifact) {
-        set({
-          tiles: get().tiles.map((t) => t.id === artifactId ? { ...t, ...r.artifact } : t)
+      const items = [...data.items].reverse();
+      const persistedMessages = [];
+      const seenJobIds = /* @__PURE__ */ new Set();
+      for (const turn of items) {
+        if (turn.jobId && seenJobIds.has(turn.jobId)) continue;
+        if (turn.jobId) seenJobIds.add(turn.jobId);
+        const userText = blocksToText(turn.user?.blocks);
+        let userAtts = blocksToAttachments(turn.user?.blocks);
+        if (!userAtts && turn.jobId) {
+          userAtts = attachmentCache?.get(turn.jobId);
+        }
+        const turnChainId = typeof turn.chainId === "string" ? turn.chainId : void 0;
+        if (userText || userAtts) {
+          persistedMessages.push({
+            id: `user-${turn.jobId}`,
+            role: "user",
+            content: userText || "",
+            timestamp: new Date(turn.startedAt || Date.now()),
+            skillSlug: turn.skillSlug,
+            ...userAtts ? { attachments: userAtts } : {},
+            ...turnChainId ? { chainId: turnChainId } : {}
+          });
+        }
+        const assistantText = blocksToText(turn.assistant?.blocks);
+        const assistantAtts = blocksToAttachments(turn.assistant?.blocks);
+        const assistantActions = Array.isArray(turn.assistant?.actions) ? turn.assistant.actions : void 0;
+        const turnKind = typeof turn.kind === "string" ? turn.kind : void 0;
+        if (assistantText || assistantAtts || assistantActions?.length) {
+          persistedMessages.push({
+            id: `bot-${turn.jobId}`,
+            role: "assistant",
+            content: assistantText || "",
+            timestamp: new Date(turn.finishedAt || turn.startedAt || Date.now()),
+            skillSlug: turn.skillSlug,
+            ...assistantAtts ? { attachments: assistantAtts } : {},
+            ...assistantActions?.length ? { actions: assistantActions } : {},
+            ...turnChainId ? { chainId: turnChainId } : {},
+            ...turnKind ? { kind: turnKind } : {}
+          });
+        }
+      }
+      const current = get().messages;
+      const keptPlaceholders = [];
+      for (const m of current) {
+        if (!m.id.startsWith("job-") || !m.jobProgress || !m.chainId) continue;
+        const matchIdx = persistedMessages.findIndex(
+          (pm) => pm.role === "assistant" && pm.chainId === m.chainId
+        );
+        if (matchIdx >= 0) {
+          const st = m.jobProgress.status;
+          if (st === "running" || st === "paused") {
+            persistedMessages[matchIdx] = { ...persistedMessages[matchIdx], jobProgress: m.jobProgress };
+          }
+        } else {
+          keptPlaceholders.push(m);
+        }
+      }
+      const isLocalUserId = (id) => /^user-\d+$/.test(id);
+      const keptUserBubbles = current.filter((m) => {
+        if (m.role !== "user" || !isLocalUserId(m.id)) return false;
+        if (!m.chainId) return true;
+        return !persistedMessages.some(
+          (pm) => pm.role === "user" && pm.chainId === m.chainId
+        );
+      });
+      const finalMessages = [...persistedMessages, ...keptUserBubbles, ...keptPlaceholders];
+      finalMessages.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+      let firstRunning = keptPlaceholders.find((m) => m.jobProgress?.status === "running");
+      try {
+        let activeChains = [];
+        const chainsRes = await fetch(`${getCoreApiUrl()}/api/chains/active`, {
+          headers: coreHeaders()
         });
+        if (chainsRes.ok) {
+          const body = await chainsRes.json();
+          activeChains = Array.isArray(body?.chains) ? body.chains : [];
+        } else {
+          const legacy = await fetch(`${getCoreApiUrl()}/api/chain/current`, {
+            headers: coreHeaders()
+          });
+          if (legacy.ok) {
+            const lb = await legacy.json();
+            if (lb?.data?.id) activeChains = [lb.data];
+          }
+        }
+        for (const slim of activeChains) {
+          if (!slim?.id) continue;
+          const chainId = String(slim.id);
+          const alreadyTracked = finalMessages.some(
+            (m) => m.role === "assistant" && m.jobProgress?.jobId === chainId
+          );
+          if (alreadyTracked) continue;
+          const progress = snapshotToProgress(
+            { ...slim, status: slim.chainStatus || slim.status },
+            chainId
+          );
+          const chainCreatedAt = typeof slim.createdAt === "number" ? slim.createdAt : typeof slim.lastUpdate === "number" ? slim.lastUpdate : Date.now();
+          const chainLastUpdate = typeof slim.lastUpdate === "number" ? slim.lastUpdate : chainCreatedAt;
+          const jobProgress = {
+            jobId: chainId,
+            actorId: extractActorId(slim),
+            status: "running",
+            chainStartedAt: chainCreatedAt,
+            ...progress
+          };
+          const goal = typeof slim.goal === "string" ? slim.goal : "";
+          const userExists = finalMessages.some(
+            (m) => m.role === "user" && (m.chainId === chainId || goal && m.content === goal)
+          );
+          if (goal && !userExists) {
+            finalMessages.push({
+              id: `user-${chainId}`,
+              role: "user",
+              content: goal,
+              timestamp: new Date(chainCreatedAt),
+              chainId
+            });
+          }
+          let matchIdx = -1;
+          for (let i = finalMessages.length - 1; i >= 0; i--) {
+            const m = finalMessages[i];
+            if (m.role === "assistant" && m.chainId === chainId) {
+              matchIdx = i;
+              break;
+            }
+          }
+          if (matchIdx >= 0) {
+            finalMessages[matchIdx] = { ...finalMessages[matchIdx], jobProgress };
+            if (jobProgress.status === "running" && !firstRunning) firstRunning = finalMessages[matchIdx];
+          } else {
+            const reattachBubble = {
+              id: `job-${chainId}`,
+              role: "assistant",
+              content: "Working on it...",
+              timestamp: new Date(chainLastUpdate),
+              jobProgress,
+              chainId
+            };
+            finalMessages.push(reattachBubble);
+            if (jobProgress.status === "running" && !firstRunning) firstRunning = reattachBubble;
+          }
+          streamJob(chainId, getTenant(), getToken());
+        }
+        finalMessages.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+      } catch {
       }
-      return { ok: true };
+      set({
+        messages: finalMessages,
+        conversationLoaded: true,
+        error: null,
+        activeJobId: firstRunning?.jobProgress?.jobId || null,
+        loading: !!firstRunning
+      });
+    } catch (err) {
+      console.warn("[adas-chat] Error loading conversation:", err.message);
+      set({ conversationLoaded: true });
     }
-    set({ tiles: before });
-    return { ok: false, error: r.error || `HTTP ${r.status}` };
-  },
-  reorder: async (pinnedIds) => {
-    const before = get().tiles;
-    const idToOrder = new Map(pinnedIds.map((id, i) => [id, i]));
-    set({
-      tiles: before.map((t) => {
-        const o = idToOrder.get(t.id);
-        return o == null ? t : { ...t, pinOrder: o };
-      })
-    });
-    const r = await setOrder(pinnedIds);
-    if (r.ok) return { ok: true };
-    set({ tiles: before });
-    return { ok: false, error: r.error || `HTTP ${r.status}` };
-  },
-  applyServerUpdate: (artifact) => {
-    set({
-      tiles: get().tiles.map((t) => t.id === artifact.id ? { ...t, ...artifact } : t)
-    });
-  },
-  applyServerRetire: (artifactId) => {
-    set({ tiles: get().tiles.filter((t) => t.id !== artifactId) });
-  },
-  applyServerOrder: (pinnedIds) => {
-    const idToOrder = new Map(pinnedIds.map((id, i) => [id, i]));
-    set({
-      tiles: get().tiles.map((t) => {
-        const o = idToOrder.get(t.id);
-        return o == null ? t : { ...t, pinOrder: o };
-      })
-    });
   },
-  track: (artifactId, event) => {
-    recordEvent(artifactId, event, "home");
-  }
-}));
-
-// src/acs/homeActionsStore.ts
-var import_zustand3 = require("zustand");
-var CACHE_KEY = "ateam.homeActions.v1";
-function persist(actions) {
-  getAcsCacheStorage()?.setItem(CACHE_KEY, JSON.stringify(actions)).catch(() => {
-  });
-}
-function sortByPin(a, b) {
-  if (!!a.pinned !== !!b.pinned) return a.pinned ? -1 : 1;
-  const ao = typeof a.pinOrder === "number" ? a.pinOrder : Number.MAX_SAFE_INTEGER;
-  const bo = typeof b.pinOrder === "number" ? b.pinOrder : Number.MAX_SAFE_INTEGER;
-  return ao - bo;
-}
-var useHomeActionsStore = (0, import_zustand3.create)((set, get) => ({
-  actions: [],
-  hydrated: false,
-  loading: false,
-  hydrate: async () => {
-    if (get().hydrated || get().loading) return;
+  // -----------------------------------------------------------------------
+  // Send message via Core API
+  // POST /api/chat { goal } → { jobId } → stream → fetch turn result
+  // -----------------------------------------------------------------------
+  sendMessage: async (text, skillSlug, attachments) => {
+    const userMsg = {
+      id: `user-${Date.now()}`,
+      role: "user",
+      content: text,
+      timestamp: /* @__PURE__ */ new Date(),
+      ...attachments?.length ? {
+        attachments: attachments.map((a) => ({
+          mimeType: a.mimeType,
+          name: a.name,
+          previewUri: a.mimeType.startsWith("image/") ? `data:${a.mimeType};base64,${a.data}` : void 0
+        }))
+      } : {}
+    };
+    set((s) => ({ messages: [...s.messages, userMsg], loading: true, error: null }));
     try {
-      const cached = await getAcsCacheStorage()?.getItem(CACHE_KEY);
-      if (cached) {
-        const parsed = JSON.parse(cached);
-        if (Array.isArray(parsed) && parsed.length > 0) {
-          set({ actions: parsed, hydrated: true });
+      const actor = getUser();
+      const body = {
+        goal: text,
+        // Opt in to the Chain Additions router (attach/cancel/new while a
+        // chain runs). Backend ignores it where not applicable — safe to send.
+        chainRouting: true,
+        triggerContext: {
+          channel: "mobile",
+          replyContext: { chatId: actor?.actorId || "unknown" }
+        }
+      };
+      if (skillSlug) body.skillSlug = skillSlug;
+      if (attachments?.length) body.attachments = attachments;
+      const res = await fetch(`${getCoreApiUrl()}/api/chat`, {
+        method: "POST",
+        headers: coreHeaders(),
+        body: JSON.stringify(body)
+      });
+      if (!res.ok) {
+        let errMsg = `Server error (${res.status})`;
+        try {
+          const text2 = await res.text();
+          if (text2.startsWith("<") || text2.startsWith("<!")) {
+            errMsg = res.status === 502 ? "Server is temporarily unavailable. Please try again." : `Server error (${res.status})`;
+          } else {
+            const parsed = JSON.parse(text2);
+            errMsg = parsed.error || errMsg;
+          }
+        } catch {
         }
+        throw new Error(errMsg);
       }
-    } catch {
-    }
-    await get().refresh();
-  },
-  refresh: async () => {
-    if (get().loading) return;
-    set({ loading: true });
-    const actions = await listHomeActions();
-    if (actions.length > 0) {
-      set({ actions, loading: false, hydrated: true });
-      persist(actions);
-    } else {
-      set({ loading: false, hydrated: true });
+      const data = await res.json();
+      if (!data.ok) {
+        throw new Error(data.error || "Failed to send message");
+      }
+      if (data.mode === "chain_addition" || data.mode === "chain_cancel") {
+        const ack = data.mode === "chain_addition" ? data.ack || "Got it \u2014 added to the running task." : "Stopping the task\u2026";
+        set((s) => ({
+          messages: s.messages.map((m) => m.id === userMsg.id && data.chainId ? { ...m, chainId: data.chainId } : m).concat({
+            id: `ack-${Date.now()}`,
+            role: "assistant",
+            content: ack,
+            timestamp: /* @__PURE__ */ new Date(),
+            ...data.chainId ? { chainId: data.chainId } : {}
+          })
+        }));
+        return;
+      }
+      const jobId = data.id || data.jobId;
+      if (!jobId) {
+        throw new Error("No job ID returned");
+      }
+      if (attachments?.length) {
+        await getConfig().attachmentCache?.save(jobId, attachments);
+      }
+      const progressMsg = {
+        id: `job-${jobId}`,
+        role: "assistant",
+        content: "Working on it...",
+        timestamp: /* @__PURE__ */ new Date(),
+        jobProgress: {
+          jobId,
+          actorId: actor?.actorId,
+          status: "running",
+          subStatus: "Starting...",
+          chainStartedAt: Date.now()
+        },
+        chainId: jobId
+      };
+      set((s) => ({
+        messages: s.messages.map(
+          (m) => m.id === userMsg.id ? { ...m, chainId: jobId } : m
+        ).concat(progressMsg),
+        activeJobId: jobId
+      }));
+      streamJob(jobId, getTenant(), getToken());
+    } catch (err) {
+      set((s) => ({
+        messages: [...s.messages, {
+          id: `error-${Date.now()}`,
+          role: "system",
+          content: `Error: ${err.message}`,
+          timestamp: /* @__PURE__ */ new Date()
+        }],
+        loading: false
+      }));
     }
   },
-  // clear() wipes in-memory state on sign-out AND drops the disk cache — a
-  // different user must not see the prior user's cards.
-  clear: () => {
-    set({ actions: [], hydrated: false, loading: false });
-    getAcsCacheStorage()?.setItem(CACHE_KEY, "[]").catch(() => {
-    });
-  },
-  dismiss: async (actionId) => {
-    const before = get().actions;
-    const next = before.filter((a) => a.actionId !== actionId);
-    set({ actions: next });
-    persist(next);
-    const r = await patchHomeAction(actionId, { dismissed: true }, "user_dismiss");
-    if (r.ok) return { ok: true };
-    set({ actions: before });
-    persist(before);
-    return { ok: false, error: r.error || `HTTP ${r.status}` };
-  },
-  setPinned: async (actionId, pinned) => {
-    const before = get().actions;
-    const next = before.map((a) => a.actionId === actionId ? { ...a, pinned } : a).sort(sortByPin);
-    set({ actions: next });
-    persist(next);
-    const r = await patchHomeAction(actionId, { pinned }, pinned ? "user_pin" : "user_unpin");
-    if (r.ok) {
-      if (r.action) {
-        const merged = get().actions.map((a) => a.actionId === actionId ? { ...a, ...r.action } : a).sort(sortByPin);
-        set({ actions: merged });
-        persist(merged);
+  // -----------------------------------------------------------------------
+  // Respond to sys.askUser paused question
+  // -----------------------------------------------------------------------
+  respondToQuestion: async (jobId, inputId, answer) => {
+    try {
+      const res = await fetch(`${getCoreApiUrl()}/api/job/${jobId}/respond`, {
+        method: "POST",
+        headers: coreHeaders(),
+        body: JSON.stringify({ inputId, answer })
+      });
+      const data = await res.json();
+      if (!data.ok) {
+        console.warn("[adas-chat] Failed to respond to question:", data.error);
       }
-      return { ok: true };
+    } catch (err) {
+      console.warn("[adas-chat] Error responding to question:", err.message);
     }
-    set({ actions: before });
-    persist(before);
-    return { ok: false, error: r.error || `HTTP ${r.status}` };
-  },
-  reorder: async (orderedIds) => {
-    const before = get().actions;
-    const idx = new Map(orderedIds.map((id, i) => [id, i]));
-    const next = before.map((a) => {
-      const o = idx.get(a.actionId);
-      return o == null ? a : { ...a, pinOrder: o };
-    }).sort(sortByPin);
-    set({ actions: next });
-    persist(next);
-    const r = await setHomeActionOrder(orderedIds);
-    if (r.ok) return { ok: true };
-    set({ actions: before });
-    persist(before);
-    return { ok: false, error: r.error || `HTTP ${r.status}` };
   },
-  applyServerUpsert: (action) => {
-    const rest = get().actions.filter((a) => a.actionId !== action.actionId);
-    const next = [...rest, action].sort(sortByPin);
-    set({ actions: next });
-    persist(next);
+  // -----------------------------------------------------------------------
+  // Update job progress (called by the stream handler)
+  // -----------------------------------------------------------------------
+  updateJobProgress: (jobId, progress) => {
+    set((s) => ({
+      messages: s.messages.map((m) => {
+        if (m.jobProgress?.jobId === jobId) {
+          const updated = { ...m.jobProgress, ...progress };
+          if (progress.status && progress.status !== "paused") {
+            updated.pendingQuestion = void 0;
+          }
+          const isPersisted = m.id.startsWith("bot-");
+          const content = isPersisted ? m.content : progress.resultMessage || progress.pendingQuestion?.question || m.content;
+          const actions = isPersisted ? m.actions : progress.resultActions?.length ? progress.resultActions : m.actions;
+          return {
+            ...m,
+            jobProgress: updated,
+            content,
+            ...actions ? { actions } : {}
+          };
+        }
+        return m;
+      }),
+      loading: progress.status === "done" || progress.status === "error" || progress.status === "paused" ? false : s.loading,
+      activeJobId: progress.status === "done" || progress.status === "error" || progress.status === "paused" ? null : s.activeJobId
+    }));
   },
-  applyServerRemove: (actionId) => {
-    const next = get().actions.filter((a) => a.actionId !== actionId);
-    set({ actions: next });
-    persist(next);
+  clearChat: () => {
+    set({
+      messages: [],
+      loading: false,
+      error: null,
+      activeJobId: null,
+      conversationLoaded: false
+    });
   },
-  applyServerOrder: (orderedIds) => {
-    const idx = new Map(orderedIds.map((id, i) => [id, i]));
-    const next = get().actions.map((a) => {
-      const o = idx.get(a.actionId);
-      return o == null ? a : { ...a, pinOrder: o };
-    }).sort(sortByPin);
-    set({ actions: next });
-    persist(next);
+  newChat: () => {
+    set({
+      messages: [],
+      loading: false,
+      error: null,
+      activeJobId: null,
+      conversationLoaded: true
+    });
   }
 }));
-
-// src/acs/ws.ts
-var _ws2 = null;
-var _wantOpen = false;
-var _retryAttempt = 0;
-var _retryTimer = null;
-var _token = null;
-var _tenant = null;
-var TOPIC = "acs.artifacts";
-var TOPIC_HOME = "acs.home-actions";
-var MAX_BACKOFF_MS = 3e4;
-function backoffMs(attempt) {
-  const base = Math.min(MAX_BACKOFF_MS, 500 * Math.pow(2, attempt));
-  const jitter = Math.random() * 250;
-  return base + jitter;
-}
-function send(obj) {
-  if (_ws2 && _ws2.readyState === 1) {
-    try {
-      _ws2.send(JSON.stringify(obj));
-    } catch (e) {
-      console.warn("[acsWs] send failed", e);
+var _processedPluginCmds = /* @__PURE__ */ new Set();
+function dispatchPluginCommands(cmds) {
+  for (const cmd of cmds) {
+    const corrId = cmd?.correlationId || cmd?.correlation_id;
+    if (corrId && _processedPluginCmds.has(corrId)) continue;
+    if (corrId) _processedPluginCmds.add(corrId);
+    pluginCommandEmitter.emit("plugin-command", cmd);
+    const pluginId = cmd?.pluginId || cmd?.plugin_id || cmd?.args?.plugin_id;
+    if (pluginId) {
+      const props = cmd?.props ?? cmd?.args?.props ?? void 0;
+      pluginCommandEmitter.emit("focus-plugin", { pluginId, props });
     }
   }
 }
-function handleEvent(msg) {
-  if (msg?.event === "subscribed") {
-    console.log("[acsWs] subscribed to", msg?.data?.topic);
-    return;
-  }
-  if (msg?.topic === TOPIC_HOME) {
-    const home = useHomeActionsStore.getState();
-    switch (msg.event) {
-      case "updated":
-        if (msg.action && typeof msg.action.actionId === "string") home.applyServerUpsert(msg.action);
-        break;
-      case "removed":
-        if (typeof msg.actionId === "string") home.applyServerRemove(msg.actionId);
-        break;
-      case "order":
-        if (Array.isArray(msg.order)) home.applyServerOrder(msg.order.filter((id) => typeof id === "string"));
-        break;
-      case "refreshed":
-        home.refresh();
-        break;
-      default:
-        break;
-    }
-    return;
-  }
-  if (msg?.topic !== TOPIC) return;
-  const store = useWidgetsStore.getState();
-  switch (msg.event) {
-    case "updated":
-      if (msg.artifact && typeof msg.artifact.id === "string") {
-        store.applyServerUpdate(msg.artifact);
-      }
-      break;
-    case "retired":
-      if (typeof msg.artifactId === "string") {
-        store.applyServerRetire(msg.artifactId);
-      }
-      break;
-    case "order":
-      if (Array.isArray(msg.pinned)) {
-        store.applyServerOrder(msg.pinned.filter((id) => typeof id === "string"));
-      }
-      break;
-    case "created":
-      if (msg.artifact && typeof msg.artifact.id === "string") {
-        store.applyServerUpdate(msg.artifact);
-      }
-      break;
-    default:
-      break;
-  }
+var _ws2 = null;
+var _wsReady = false;
+var _clientDeclarationProvider = null;
+function setClientDeclarationProvider(fn) {
+  _clientDeclarationProvider = fn;
 }
-function openSocket() {
-  if (_ws2) return;
-  if (!_token || !_tenant) return;
-  const url = `${getCoreWsUrl()}/ws?token=${encodeURIComponent(_token)}&tenant=${encodeURIComponent(_tenant)}`;
-  console.log(`[acsWs] opening`);
-  const ws = new WebSocket(url);
+var _currentJobId = null;
+function ensureWs(tenant, token) {
+  if (_ws2 && _wsReady) return _ws2;
+  const wsUrl = `${getCoreWsUrl()}/ws?token=${encodeURIComponent(token || "")}&tenant=${encodeURIComponent(tenant)}`;
+  const ws = new WebSocket(wsUrl);
   _ws2 = ws;
+  _wsReady = false;
   ws.onopen = () => {
-    _retryAttempt = 0;
-    send({ type: "subscribe", topic: TOPIC });
-    send({ type: "subscribe", topic: TOPIC_HOME });
+    _wsReady = true;
+    try {
+      const declared = _clientDeclarationProvider?.();
+      if (declared) ws.send(JSON.stringify({ type: "declare_client", ...declared }));
+    } catch {
+    }
+    if (_currentJobId) {
+      ws.send(JSON.stringify({ type: "subscribe", jobId: _currentJobId }));
+    }
   };
-  ws.onmessage = (e) => {
+  ws.onmessage = (ev) => {
     try {
-      const msg = JSON.parse(typeof e.data === "string" ? e.data : "");
-      handleEvent(msg);
+      const msg = JSON.parse(typeof ev.data === "string" ? ev.data : "");
+      const { event, data } = msg;
+      const { updateJobProgress } = useChatStore.getState();
+      const jobId = data && (data.id || data.chainId) || _currentJobId;
+      if (event === "plugin_command") {
+        dispatchPluginCommands([data]);
+        return;
+      }
+      if (event === "plugin-command-ack" || event === "pong") return;
+      if (!jobId) return;
+      switch (event) {
+        case "init":
+        case "job":
+        case "update": {
+          const snap = data;
+          const progress = snapshotToProgress(snap, jobId);
+          if (isTerminalSnapshot(snap)) {
+            if (snap.status === "done" && (snap.isHandoff || snap.state?.handoffTransfer)) {
+              updateJobProgress(jobId, { status: "running" });
+              return;
+            }
+            _currentJobId = null;
+            if (progress.status === "paused" && progress.pendingQuestion) {
+              updateJobProgress(jobId, progress);
+            } else {
+              fetchTurnResult(jobId, snap);
+            }
+            return;
+          }
+          updateJobProgress(jobId, progress);
+          break;
+        }
+        case "chain_final":
+          _currentJobId = null;
+          fetchTurnResult(jobId, data);
+          break;
+        case "final":
+          _currentJobId = null;
+          fetchTurnResult(jobId, data);
+          break;
+      }
     } catch (err) {
-      console.warn("[acsWs] parse failed", err);
+      console.warn("[adas-chat] WS parse error:", err);
     }
   };
-  ws.onerror = (e) => {
-    console.warn("[acsWs] error", e?.message || e);
+  ws.onerror = () => {
+    _ws2 = null;
+    _wsReady = false;
+    if (_currentJobId) {
+      const jid = _currentJobId;
+      _currentJobId = null;
+      pollJob(jid, token);
+    }
   };
   ws.onclose = () => {
     _ws2 = null;
-    if (!_wantOpen) return;
-    const delay = backoffMs(_retryAttempt++);
-    console.log(`[acsWs] closed; reconnecting in ${Math.round(delay)}ms (attempt ${_retryAttempt})`);
-    if (_retryTimer) clearTimeout(_retryTimer);
-    _retryTimer = setTimeout(openSocket, delay);
-  };
-}
-function notifyAcsWsForeground() {
-  if (_wantOpen && !_ws2) {
-    if (_retryTimer) {
-      clearTimeout(_retryTimer);
-      _retryTimer = null;
-    }
-    _retryAttempt = 0;
-    openSocket();
+    _wsReady = false;
+    if (_currentJobId) {
+      const jid = _currentJobId;
+      _currentJobId = null;
+      pollJob(jid, token);
+    }
+  };
+  return ws;
+}
+function streamJob(jobId, tenant, token) {
+  _currentJobId = jobId;
+  const ws = ensureWs(tenant, token);
+  if (_wsReady) {
+    ws.send(JSON.stringify({ type: "subscribe", jobId }));
   }
 }
-function connectAcsWs(token, tenant) {
-  if (_ws2 && _wantOpen && _token === token && _tenant === tenant) return;
+function closeChatStream() {
+  _currentJobId = null;
   if (_ws2) {
     try {
       _ws2.close();
     } catch {
     }
-    _ws2 = null;
   }
-  _token = token;
-  _tenant = tenant;
-  _wantOpen = true;
-  openSocket();
+  _ws2 = null;
+  _wsReady = false;
 }
-function disconnectAcsWs() {
-  _wantOpen = false;
-  _token = null;
-  _tenant = null;
-  if (_retryTimer) {
-    clearTimeout(_retryTimer);
-    _retryTimer = null;
+async function fetchTurnResult(jobId, jobSnap) {
+  if (_processedPluginCmds.size > 200) _processedPluginCmds.clear();
+  const { updateJobProgress } = useChatStore.getState();
+  const status = normalizeJobStatus(jobSnap) === "error" ? "error" : "done";
+  if (jobSnap.isHandoff || jobSnap.state?.handoffTransfer || jobSnap.result?.contentType === "handoff") {
+    try {
+      for (let i = 0; i < 40; i++) {
+        const statusRes = await fetch(`${getCoreApiUrl()}/api/job/${jobId}/status`, {
+          headers: coreHeaders()
+        });
+        if (statusRes.ok) {
+          const statusData = await statusRes.json();
+          if (statusData.done && !statusData.isHandoff) {
+            break;
+          }
+          updateJobProgress(jobId, { status: "running" });
+        }
+        await new Promise((r) => setTimeout(r, 1500));
+      }
+    } catch {
+    }
   }
-  if (_ws2) {
+  for (let attempt = 0; attempt < 5; attempt++) {
     try {
-      _ws2.close();
+      const res = await fetch(`${getCoreApiUrl()}/api/conversation?limit=1`, {
+        headers: coreHeaders()
+      });
+      if (res.ok) {
+        const data = await res.json();
+        const items = Array.isArray(data.items) ? data.items : [];
+        const turn = items[0];
+        if (turn?.assistant || turn?.turn?.assistant) {
+          const assistant = turn.assistant || turn.turn?.assistant;
+          const text = blocksToText(assistant.blocks);
+          const actions = Array.isArray(assistant.actions) && assistant.actions.length ? assistant.actions : void 0;
+          if (text) {
+            updateJobProgress(jobId, {
+              status,
+              resultMessage: text,
+              ...actions ? { resultActions: actions } : {}
+            });
+            return;
+          }
+        }
+      }
     } catch {
     }
-    _ws2 = null;
+    await new Promise((r) => setTimeout(r, 800));
+  }
+  const fallback = jobSnap.result?.message || jobSnap.state?.finalReply || (status === "error" ? "Something went wrong. Please try again." : "Done.");
+  updateJobProgress(jobId, { status, resultMessage: fallback });
+}
+async function pollJob(jobId, token) {
+  const { updateJobProgress } = useChatStore.getState();
+  for (let i = 0; i < 120; i++) {
+    try {
+      const res = await fetch(`${getCoreApiUrl()}/api/job/${jobId}/status`, {
+        headers: {
+          ...token ? { Authorization: `Bearer ${token}` } : {}
+        }
+      });
+      if (!res.ok) {
+        if (res.status === 404) return;
+        continue;
+      }
+      const snap = await res.json();
+      const progress = snapshotToProgress(snap, jobId);
+      if (progress.status === "paused" && progress.pendingQuestion) {
+        updateJobProgress(jobId, progress);
+        return;
+      }
+      updateJobProgress(jobId, progress);
+      if (isTerminalSnapshot(snap)) {
+        fetchTurnResult(jobId, snap);
+        return;
+      }
+    } catch {
+    }
+    await new Promise((r) => setTimeout(r, 1500));
+  }
+  updateJobProgress(jobId, {
+    status: "error",
+    resultMessage: "Job timed out. Please try again."
+  });
+}
+
+// src/api/tenants.ts
+async function listMyTenants() {
+  const token = getToken();
+  if (!token) return [];
+  try {
+    const res = await fetch(`${getConsumerAuthApiUrl()}/platform/consumer/my-tenants`, {
+      headers: { Authorization: `Bearer ${token}` }
+    });
+    const data = await res.json().catch(() => null);
+    if (!res.ok || !data?.ok || !Array.isArray(data.tenants)) return [];
+    return data.tenants.map((t) => ({
+      id: t.id,
+      // Fall back to the id rather than to an empty string: a nameless row in
+      // a team switcher is unpickable.
+      name: t.name || t.id,
+      role: t.role ?? null
+    }));
+  } catch {
+    return [];
+  }
+}
+async function switchTenant(targetTenantId) {
+  const token = getToken();
+  if (!token) throw new Error("[adas] switchTenant: not signed in");
+  const res = await fetch(`${getConsumerAuthApiUrl()}/platform/consumer/switch-tenant`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`
+    },
+    body: JSON.stringify({ target_tenant: targetTenantId })
+  });
+  const data = await res.json().catch(() => null);
+  if (!res.ok || !data?.ok || !data.jwt) {
+    throw new Error(data?.error || `switchTenant failed (${res.status})`);
+  }
+  const session = {
+    jwt: data.jwt,
+    tenant: data.tenant,
+    actor: data.actor
+  };
+  const onSession = getConfig().onSession;
+  if (!onSession) {
+    throw new Error("[adas] switchTenant: config.onSession is required to persist the new session");
   }
+  await onSession(session);
+  closeChatStream();
+  useChatStore.getState().clearChat();
+  return session;
 }
+
+// src/theme/tokens.ts
+var colors = {
+  dark: {
+    bgPrimary: "#0a0e14",
+    bgSecondary: "#111820",
+    bgTertiary: "#1a2230",
+    bgInput: "#0d1219",
+    bgHover: "#1e2a3a",
+    border: "rgba(255, 255, 255, 0.08)",
+    borderHover: "rgba(255, 255, 255, 0.15)",
+    textPrimary: "#e8ecf1",
+    textSecondary: "#8b95a5",
+    textMuted: "#5a6577",
+    accent: "#2563eb",
+    accentHover: "#3b82f6",
+    accentSoft: "rgba(37, 99, 235, 0.15)",
+    green: "#16a34a",
+    greenSoft: "rgba(22, 163, 74, 0.15)",
+    red: "#dc2626",
+    redSoft: "rgba(220, 38, 38, 0.15)",
+    amber: "#f59e0b",
+    amberSoft: "rgba(245, 158, 11, 0.15)",
+    purple: "#8b5cf6",
+    purpleSoft: "rgba(139, 92, 246, 0.15)",
+    // Message-specific
+    userBubble: "#2563eb",
+    botBubble: "#1a2230",
+    botBubbleBorder: "rgba(255, 255, 255, 0.08)"
+  },
+  light: {
+    bgPrimary: "#ffffff",
+    bgSecondary: "#f8f9fa",
+    bgTertiary: "#f1f3f5",
+    bgInput: "#ffffff",
+    bgHover: "#e9ecef",
+    border: "rgba(0, 0, 0, 0.08)",
+    borderHover: "rgba(0, 0, 0, 0.15)",
+    textPrimary: "#1a1a2e",
+    textSecondary: "#6b7280",
+    textMuted: "#9ca3af",
+    accent: "#2563eb",
+    accentHover: "#1d4ed8",
+    accentSoft: "rgba(37, 99, 235, 0.1)",
+    green: "#16a34a",
+    greenSoft: "rgba(22, 163, 74, 0.1)",
+    red: "#dc2626",
+    redSoft: "rgba(220, 38, 38, 0.1)",
+    amber: "#f59e0b",
+    amberSoft: "rgba(245, 158, 11, 0.1)",
+    purple: "#8b5cf6",
+    purpleSoft: "rgba(139, 92, 246, 0.1)",
+    userBubble: "#2563eb",
+    botBubble: "#f1f3f5",
+    botBubbleBorder: "rgba(0, 0, 0, 0.08)"
+  }
+};
+var ada = {
+  paper: "#FAF6EE",
+  paperSoft: "#F2EADC",
+  paperDeep: "#EBE0CC",
+  ink: "#1a1410",
+  inkSoft: "#5a4d3f",
+  inkMuted: "#9a8870",
+  border: "rgba(26, 20, 16, 0.08)",
+  borderStrong: "rgba(26, 20, 16, 0.16)",
+  orange: "#FF7A28",
+  orangeDeep: "#B8410A",
+  orangeSoft: "rgba(255, 122, 40, 0.14)",
+  userBubble: "#1a1410",
+  userBubbleText: "#FAF6EE",
+  botBubble: "#F2EADC",
+  botBubbleBorder: "rgba(26, 20, 16, 0.06)",
+  botBubbleText: "#1a1410"
+};
+var spacing = {
+  xs: 4,
+  sm: 8,
+  md: 12,
+  lg: 16,
+  xl: 20,
+  xxl: 24,
+  xxxl: 32
+};
+var fontSize = {
+  xs: 11,
+  sm: 13,
+  md: 15,
+  lg: 17,
+  xl: 20,
+  xxl: 24,
+  title: 28
+};
+var borderRadius = {
+  sm: 8,
+  md: 12,
+  lg: 16,
+  xl: 20,
+  full: 9999
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   PluginCommandEmitter,
@@ -1765,12 +2183,17 @@ function disconnectAcsWs() {
   apiFetchRaw,
   blocksToText,
   borderRadius,
+  capabilityEnabled,
   closeChatStream,
   colors,
   connectAcsWs,
   connectorCall,
+  createAuthSession,
+  createPushRegistration,
   deleteArtifact,
   disconnectAcsWs,
+  exchangeHandoff,
+  fetchConsumerConfig,
   fontSize,
   getConfig,
   getConsumerAuthApiUrl,
@@ -1784,6 +2207,10 @@ function disconnectAcsWs() {
   initAdas,
   isAdasInitialized,
   isDevHost,
+  joinWithApple,
+  joinWithGoogle,
+  linkChannelStart,
+  linkChannelVerify,
   listHomeActions,
   listMadeForYou,
   listMyTenants,
@@ -1791,21 +2218,36 @@ function disconnectAcsWs() {
   mcpFetch,
   mcpToolCall,
   notifyAcsWsForeground,
+  notifyAppForeground,
+  onAppForeground,
+  openJoinWithApple,
+  openJoinWithGoogle,
+  parseDeepLinkParam,
+  parseHandoffCode,
+  parseInviteCode,
   patchArtifact,
   patchHomeAction,
   pluginCommandEmitter,
   postCommandResult,
+  previewInvite,
   recordEvent,
   refreshToken,
+  resolveAdasPhase,
   setAcsCacheStorage,
   setAcsReachabilityReporter,
+  setClientDeclarationProvider,
   setHomeActionOrder,
   setOrder,
+  signInWithApple,
+  signInWithGoogle,
   spacing,
   switchTenant,
   unwrapMcpResult,
+  useCapability,
   useChatStore,
   useHomeActionsStore,
-  useWidgetsStore
+  useWidgetsStore,
+  useWorkspaceStore,
+  userFromJwt
 });
 //# sourceMappingURL=index.js.map