@kilocode/client 0.0.0-stage → 0.0.0-v2-9

package/dist/chunks/contract-1x65x4hv.js

@@ -0,0 +1,1701 @@
+import {
+  isFormNotFoundError2,
+  isFormAlreadySettledError2,
+  isPermissionNotFoundError2
+} from "./contract-c46qzyff.js";
+
+// src/solid/data.ts
+import { Worktree } from "@opencode/schema/worktree";
+import { SessionID } from "@opencode/schema/session-id";
+import { SessionMessage } from "@opencode/schema/session-message";
+import { createStore, produce, reconcile } from "solid-js/store";
+import { batch, createEffect, createMemo, createSignal, onCleanup } from "solid-js";
+var messagePageLimit = 20;
+var settleMs2 = 150;
+function locationKey2(location) {
+  return JSON.stringify([location.directory, location.workspaceID]);
+}
+function locationQuery(ref) {
+  return { directory: ref.directory };
+}
+function optimisticFiles(files) {
+  const items = files?.flatMap((file) => {
+    if (!file.uri.startsWith("data:"))
+      return [];
+    const comma = file.uri.indexOf(",");
+    if (comma < 0)
+      return [];
+    const header = file.uri.slice(5, comma);
+    const parts = header.split(";");
+    if (!parts.slice(1).some((part) => part.toLowerCase() === "base64"))
+      return [];
+    const item = {
+      data: file.uri.slice(comma + 1),
+      mime: parts[0] || "application/octet-stream",
+      source: { type: "inline" }
+    };
+    if (file.name !== undefined)
+      item.name = file.name;
+    if (file.description !== undefined)
+      item.description = file.description;
+    if (file.mention !== undefined)
+      item.mention = { ...file.mention };
+    return [item];
+  });
+  return items?.length ? items : undefined;
+}
+function formRequestOptions(sessionID, ref) {
+  if (sessionID !== "global" || !ref)
+    return;
+  return {
+    headers: {
+      "x-opencode-directory": encodeURIComponent(ref.directory)
+    }
+  };
+}
+function createSync() {
+  const state = new Map;
+  const start = (key, load, wait) => {
+    const entry = { promise: Promise.resolve(), invalidated: false, started: !wait };
+    state.set(key, entry);
+    const run = () => {
+      entry.started = true;
+      return load();
+    };
+    entry.promise = (wait ? wait.catch(() => {
+      return;
+    }).then(run) : run()).then(() => {
+      if (state.get(key) === entry && !entry.invalidated)
+        state.set(key, true);
+    }).finally(() => {
+      if (state.get(key) === entry)
+        state.delete(key);
+    });
+    return entry.promise;
+  };
+  return {
+    run(key, load) {
+      const active = state.get(key);
+      if (active === true)
+        return Promise.resolve();
+      if (!active)
+        return start(key, load);
+      if (!active.invalidated)
+        return active.promise;
+      return start(key, load, active.promise);
+    },
+    complete(key) {
+      if (state.has(key))
+        return;
+      state.set(key, true);
+    },
+    has(key) {
+      return state.has(key);
+    },
+    pending(key) {
+      const active = state.get(key);
+      return active !== undefined && active !== true;
+    },
+    invalidate(key) {
+      if (key) {
+        const active = state.get(key);
+        if (active === true)
+          state.delete(key);
+        if (active !== undefined && active !== true && active.started)
+          active.invalidated = true;
+        return;
+      }
+      state.forEach((active, current) => {
+        if (active === true)
+          state.delete(current);
+        if (active !== true && active.started)
+          active.invalidated = true;
+      });
+    }
+  };
+}
+var CHILD_PAGE = 200;
+function createData2(config) {
+  const api = config.api;
+  let disposed = false;
+  onCleanup(() => disposed = true);
+  function refresh(load) {
+    if (disposed || config.connection && config.connection.status() !== "connected")
+      return;
+    load().catch((error) => {
+      if (disposed || config.connection && config.connection.status() !== "connected")
+        return;
+      if (config.onError)
+        return config.onError(error);
+      console.error("Failed to refresh client data", error);
+    });
+  }
+  const settling = new Map;
+  onCleanup(() => settling.forEach((timer) => clearTimeout(timer)));
+  function settle(key, load) {
+    clearTimeout(settling.get(key));
+    settling.set(key, setTimeout(() => {
+      settling.delete(key);
+      refresh(load);
+    }, settleMs2));
+  }
+  const [store, setStore] = createStore({
+    session: {
+      info: {},
+      family: {},
+      active: {},
+      message: {},
+      messageCursor: {},
+      messageLoading: {},
+      pending: {},
+      permission: {},
+      form: {}
+    },
+    project: {
+      info: {},
+      permission: {}
+    },
+    location: {}
+  });
+  const [defaultLocation, setDefaultLocation] = createSignal({ directory: config.directory });
+  const sessions = createMemo(() => Object.values(store.session.info).toSorted((a, b) => b.time.updated - a.time.updated));
+  const messageIndex = new Map;
+  const sync = createSync();
+  let activeUpdates;
+  const pendingUpdates = new Map;
+  function setSessionActive(sessionID, status) {
+    activeUpdates?.set(sessionID, status);
+    setStore("session", "active", sessionID, status);
+  }
+  function removePending(sessionID, inboxID) {
+    if (!inboxID)
+      return;
+    pendingUpdates.get(sessionID)?.set(inboxID, undefined);
+    if (store.session.pending[sessionID]?.some((item) => item.id === inboxID))
+      setStore("session", "pending", sessionID, (store.session.pending[sessionID] ?? []).filter((item) => item.id !== inboxID));
+  }
+  function removePermission(sessionID, requestID) {
+    const requests = store.session.permission[sessionID];
+    if (!requests?.some((request) => request.id === requestID))
+      return;
+    setStore("session", "permission", sessionID, requests.filter((request) => request.id !== requestID));
+  }
+  function removeForm(sessionID, formID, ref) {
+    const forms = store.session.form[sessionID];
+    if (!forms)
+      return false;
+    const location = ref && locationKey2(ref);
+    const next = forms.filter((form) => {
+      if (form.id !== formID)
+        return true;
+      if (sessionID !== "global" || !location)
+        return false;
+      return !form.location || locationKey2(form.location) !== location;
+    });
+    if (next.length === forms.length)
+      return false;
+    setStore("session", "form", sessionID, next);
+    return true;
+  }
+  function settleForm(input, ref, request) {
+    return request.catch((error) => {
+      if (!isFormNotFoundError2(error) && !isFormAlreadySettledError2(error) || error.id !== input.formID)
+        throw error;
+    }).then(() => {
+      if (!removeForm(input.sessionID, input.formID, ref))
+        return;
+      result.session.form.invalidate(input.sessionID, ref);
+      result.session.form.sync(input.sessionID, ref).catch(() => {
+        return;
+      });
+    });
+  }
+  function updatePending(sessionID, inboxID, delivery) {
+    const index = store.session.pending[sessionID]?.findIndex((item) => item.id === inboxID) ?? -1;
+    const item = store.session.pending[sessionID]?.[index];
+    pendingUpdates.get(sessionID)?.set(inboxID, item ? { ...item, delivery } : delivery);
+    if (index < 0 || !item || item.delivery === delivery)
+      return;
+    setStore("session", "pending", sessionID, index, { ...item, delivery });
+  }
+  const outbox = new Set;
+  const sessionOutbox = new Set;
+  const creating = new Map;
+  const sending = new Map;
+  const messageLoads = new Map;
+  const compacting = new Map;
+  onCleanup(() => compacting.clear());
+  function track(map, key, promise) {
+    map.set(key, promise);
+    const settle = () => {
+      if (map.get(key) === promise)
+        map.delete(key);
+    };
+    promise.then(settle, settle);
+  }
+  function sendAdmission(sessionID, send, gate) {
+    const created = creating.get(sessionID);
+    const previous = sending.get(sessionID);
+    const request = Promise.resolve().then(() => Promise.all([gate, created, previous])).then(send);
+    track(sending, sessionID, request.catch(() => {
+      return;
+    }));
+    return request;
+  }
+  function admitLocal(item) {
+    batch(() => {
+      const pending = store.session.pending[item.sessionID] ?? [];
+      const at = pending.findIndex((entry) => entry.id === item.id);
+      setStore("session", "pending", item.sessionID, at < 0 ? [...pending, item] : pending.map((entry, index) => index === at ? item : entry));
+      if (item.type === "compaction")
+        return;
+      materializeInboxMessage(item);
+    });
+  }
+  function materializeInboxMessage(item) {
+    if (item.type !== "user" && item.type !== "synthetic")
+      return;
+    message.update(item.sessionID, (draft, index) => {
+      const row = item.type === "user" ? { id: item.id, type: "user", ...item.payload, time: { created: item.time.created } } : { id: item.id, type: "synthetic", ...item.payload, time: { created: item.time.created } };
+      const position = index.get(item.id);
+      if (position === undefined)
+        return message.append(draft, index, row);
+      draft[position] = row;
+    });
+  }
+  function retractLocal(sessionID, inboxID) {
+    batch(() => {
+      removePending(sessionID, inboxID);
+      if (!messageIndex.get(sessionID)?.has(inboxID))
+        return;
+      message.update(sessionID, (draft, index) => {
+        const position = index.get(inboxID);
+        if (position === undefined)
+          return;
+        draft.splice(position, 1);
+        index.delete(inboxID);
+        message.reindex(draft, index, position);
+      });
+    });
+  }
+  const message = {
+    update(sessionID, fn) {
+      setStore("session", "message", produce((draft) => {
+        fn(draft[sessionID] ??= [], index(sessionID));
+      }));
+    },
+    append(messages, index, item) {
+      if (index.has(item.id))
+        return;
+      index.set(item.id, messages.length);
+      messages.push(item);
+    },
+    insert(sessionID, item) {
+      message.update(sessionID, (draft, index) => message.append(draft, index, item));
+    },
+    editAssistant(sessionID, messageID, fn) {
+      message.update(sessionID, (draft, index) => {
+        const position = index.get(messageID);
+        const item = position === undefined ? undefined : draft[position];
+        if (item?.type === "assistant")
+          fn(item);
+      });
+    },
+    editTool(sessionID, messageID, toolID, fn) {
+      message.editAssistant(sessionID, messageID, (assistant) => {
+        const tool = assistant.content.findLast((item) => item.type === "tool" && item.id === toolID);
+        if (tool)
+          fn(tool);
+      });
+    },
+    editText(sessionID, messageID, fn) {
+      message.editAssistant(sessionID, messageID, (assistant) => {
+        const text = assistant.content.findLast((item) => item.type === "text");
+        if (text)
+          fn(text);
+      });
+    },
+    editReasoning(sessionID, messageID, fn) {
+      message.editAssistant(sessionID, messageID, (assistant) => {
+        const reasoning = assistant.content.findLast((item) => item.type === "reasoning" && !item.time?.completed);
+        if (reasoning)
+          fn(reasoning);
+      });
+    },
+    activeAssistant(messages) {
+      const item = messages.findLast((item) => item.type === "assistant" && !item.time.completed);
+      return item?.type === "assistant" ? item : undefined;
+    },
+    shell(messages, shellID) {
+      const item = messages.findLast((item) => item.type === "shell" && item.shellID === shellID);
+      return item?.type === "shell" ? item : undefined;
+    },
+    compaction(messages) {
+      const item = messages.findLast((item) => item.type === "compaction" && item.status === "running");
+      return item?.type === "compaction" ? item : undefined;
+    },
+    reindex(messages, index, start) {
+      for (let position = start;position < messages.length; position++) {
+        const item = messages[position];
+        if (item)
+          index.set(item.id, position);
+      }
+    }
+  };
+  function index(sessionID) {
+    const existing = messageIndex.get(sessionID);
+    if (existing)
+      return existing;
+    const created = new Map;
+    messageIndex.set(sessionID, created);
+    return created;
+  }
+  async function listChildren(input) {
+    const page = await api().session.list(input);
+    if (page.data.length < CHILD_PAGE || !page.cursor.next)
+      return page.data;
+    return [...page.data, ...await listChildren({ cursor: page.cursor.next, limit: CHILD_PAGE })];
+  }
+  function resolveRoot(sessionID) {
+    let current = sessionID;
+    let parentID = store.session.info[sessionID]?.parentID;
+    const seen = new Set([sessionID]);
+    while (parentID) {
+      if (seen.has(parentID))
+        break;
+      seen.add(parentID);
+      current = parentID;
+      parentID = store.session.info[parentID]?.parentID;
+    }
+    return current;
+  }
+  function registerSession(sessionID) {
+    const info = store.session.info[sessionID];
+    if (!info)
+      return;
+    const rootID = resolveRoot(sessionID);
+    setStore("session", "family", produce((draft) => {
+      if (sessionID !== rootID && draft[sessionID]) {
+        const members = draft[rootID] ??= [];
+        for (const id of draft[sessionID]) {
+          if (!members.includes(id))
+            members.push(id);
+        }
+        delete draft[sessionID];
+      }
+      const family = draft[rootID] ??= [];
+      if (!family.includes(sessionID))
+        family.push(sessionID);
+    }));
+  }
+  function evictSession(sessionID) {
+    if (sessionOutbox.has(sessionID))
+      return;
+    sync.invalidate(`session.pending:${sessionID}`);
+    sync.invalidate(`session.message:${sessionID}`);
+    messageLoads.delete(sessionID);
+    const pending = store.session.pending[sessionID]?.filter((item) => outbox.has(item.id)) ?? [];
+    const messages = store.session.message[sessionID]?.filter((item) => outbox.has(item.id)) ?? [];
+    messageIndex.delete(sessionID);
+    if (messages.length)
+      messageIndex.set(sessionID, new Map(messages.map((item, index) => [item.id, index])));
+    setStore("session", produce((draft) => {
+      delete draft.message[sessionID];
+      delete draft.messageCursor[sessionID];
+      delete draft.messageLoading[sessionID];
+      delete draft.pending[sessionID];
+      if (messages.length)
+        draft.message[sessionID] = messages;
+      if (pending.length)
+        draft.pending[sessionID] = pending;
+    }));
+  }
+  function removeSession(sessionID) {
+    activeUpdates?.set(sessionID, undefined);
+    store.session.pending[sessionID]?.forEach((item) => outbox.delete(item.id));
+    messageIndex.delete(sessionID);
+    sync.invalidate(`session:${sessionID}`);
+    sync.invalidate(`session.family:${sessionID}`);
+    sync.invalidate(`session.pending:${sessionID}`);
+    sync.invalidate(`session.message:${sessionID}`);
+    sync.invalidate(`session.permission:${sessionID}`);
+    sync.invalidate(`session.form:${sessionID}:`);
+    setStore("session", produce((draft) => {
+      delete draft.info[sessionID];
+      delete draft.active[sessionID];
+      delete draft.message[sessionID];
+      delete draft.messageCursor[sessionID];
+      delete draft.messageLoading[sessionID];
+      delete draft.pending[sessionID];
+      delete draft.permission[sessionID];
+      delete draft.form[sessionID];
+      for (const [rootID, family] of Object.entries(draft.family)) {
+        const next = family.filter((id) => id !== sessionID);
+        if (next.length === 0)
+          delete draft.family[rootID];
+        else
+          draft.family[rootID] = next;
+      }
+    }));
+  }
+  function handleEvent(event) {
+    switch (event.type) {
+      case "server.connected": {
+        const updates = new Map;
+        activeUpdates = updates;
+        refresh(() => api().session.active().then((active) => {
+          if (activeUpdates !== updates)
+            return;
+          const snapshot = new Map(Object.keys(active).map((id) => [id, "running"]));
+          updates.forEach((status, id) => {
+            if (status === undefined)
+              return snapshot.delete(id);
+            snapshot.set(id, status);
+          });
+          activeUpdates = undefined;
+          setStore("session", "active", reconcile(Object.fromEntries(snapshot)));
+        }).catch(() => {
+          if (activeUpdates === updates)
+            activeUpdates = undefined;
+        }));
+        refresh(() => api().location.get({ location: locationQuery(defaultLocation()) }).then((location) => {
+          const key = locationKey2(location);
+          setStore("location", key, { info: location });
+        }));
+        refresh(() => result.location.vcs.sync());
+        refresh(() => result.project.sync());
+        return;
+      }
+      case "project.updated":
+        setStore("project", "info", event.data.id, reconcile(event.data));
+        return;
+      case "session.created":
+        sessionOutbox.delete(event.data.sessionID);
+        result.session.invalidate(event.data.sessionID);
+        refresh(() => result.session.sync(event.data.sessionID));
+        sync.complete(`session.pending:${event.data.sessionID}`);
+        sync.complete(`session.message:${event.data.sessionID}`);
+        return;
+      case "session.deleted":
+        removeSession(event.data.sessionID);
+        return;
+      case "session.usage.updated":
+        if (store.session.info[event.data.sessionID])
+          setStore("session", "info", event.data.sessionID, {
+            cost: event.data.cost,
+            tokens: event.data.tokens
+          });
+        return;
+      case "session.agent.selected": {
+        const previous = store.session.info[event.data.sessionID]?.agent;
+        if (store.session.info[event.data.sessionID])
+          setStore("session", "info", event.data.sessionID, "agent", event.data.agent);
+        message.insert(event.data.sessionID, {
+          id: SessionMessage.ID.fromEvent(event.id),
+          type: "agent-switched",
+          agent: event.data.agent,
+          previous,
+          time: { created: event.created }
+        });
+        return;
+      }
+      case "session.model.selected": {
+        const previous = event.data.previous ?? store.session.info[event.data.sessionID]?.model;
+        if (store.session.info[event.data.sessionID])
+          setStore("session", "info", event.data.sessionID, "model", event.data.model);
+        if (!store.session.message[event.data.sessionID])
+          return;
+        message.insert(event.data.sessionID, {
+          id: SessionMessage.ID.fromEvent(event.id),
+          type: "model-switched",
+          model: event.data.model,
+          previous,
+          time: { created: event.created }
+        });
+        refresh(() => api().session.message.get({ sessionID: event.data.sessionID, messageID: SessionMessage.ID.fromEvent(event.id) }).then((item) => {
+          message.update(event.data.sessionID, (draft, index) => {
+            const position = index.get(item.id);
+            if (position === undefined)
+              return message.append(draft, index, item);
+            draft[position] = item;
+          });
+        }));
+        return;
+      }
+      case "session.renamed": {
+        refresh(() => {
+          const family = sync.pending(`session.family:${event.data.sessionID}`) ? result.session.sync(event.data.sessionID, { children: true }) : Promise.resolve();
+          return Promise.all([result.session.sync(event.data.sessionID), family]).then(() => {
+            if (store.session.info[event.data.sessionID])
+              setStore("session", "info", event.data.sessionID, "title", event.data.title);
+          });
+        });
+        return;
+      }
+      case "session.permissions":
+        if (store.session.info[event.data.sessionID])
+          setStore("session", "info", event.data.sessionID, "permissions", event.data.permissions);
+        return;
+      case "session.archived":
+        if (store.session.info[event.data.sessionID])
+          setStore("session", "info", event.data.sessionID, "time", "archived", event.created);
+        return;
+      case "session.unarchived":
+        if (store.session.info[event.data.sessionID])
+          setStore("session", "info", event.data.sessionID, "time", "archived", undefined);
+        return;
+      case "session.moved": {
+        const current = store.session.info[event.data.sessionID];
+        if (current) {
+          const previous = {
+            location: { ...current.location },
+            projectID: current.projectID,
+            subpath: current.subpath
+          };
+          setStore("session", "info", event.data.sessionID, "location", event.data.location);
+          setStore("session", "info", event.data.sessionID, "projectID", event.data.projectID);
+          setStore("session", "info", event.data.sessionID, "subpath", event.data.subpath);
+          message.insert(event.data.sessionID, {
+            id: SessionMessage.ID.fromEvent(event.id),
+            type: "location-switched",
+            location: event.data.location,
+            projectID: event.data.projectID,
+            subpath: event.data.subpath,
+            previous,
+            time: { created: event.created }
+          });
+        }
+        return;
+      }
+      case "worktree.resolved": {
+        for (const [sessionID, info] of Object.entries(store.session.info)) {
+          const explicit = event.data.adopted?.includes(info.projectID);
+          const directory = explicit ? store.project.info[info.projectID]?.canonical : info.location.directory;
+          if (!directory) {
+            result.session.invalidate(sessionID);
+            refresh(() => result.session.sync(sessionID));
+            continue;
+          }
+          const adopted = Worktree.adopt({
+            projectID: info.projectID,
+            directory
+          }, event.data);
+          if (!adopted)
+            continue;
+          setStore("session", "info", sessionID, "projectID", adopted.projectID);
+          setStore("session", "info", sessionID, "subpath", adopted.subpath);
+        }
+        return;
+      }
+      case "session.inbox.delivered": {
+        const admitted = result.session.input.has(event.data.sessionID, event.data.inboxID);
+        removePending(event.data.sessionID, event.data.inboxID);
+        message.update(event.data.sessionID, (draft, index) => {
+          const position = index.get(event.data.inboxID);
+          if (position === undefined)
+            return;
+          const existing = draft[position];
+          if (!existing || !admitted)
+            return;
+          existing.time.created = event.created;
+          draft.splice(position, 1);
+          draft.push(existing);
+          message.reindex(draft, index, position);
+        });
+        compacting.get(event.data.sessionID)?.observed.add(event.data.inboxID);
+        return;
+      }
+      case "session.inbox.delivery.changed":
+        updatePending(event.data.sessionID, event.data.inboxID, event.data.delivery);
+        return;
+      case "session.inbox.cancelled": {
+        retractLocal(event.data.sessionID, event.data.inboxID);
+        compacting.get(event.data.sessionID)?.observed.add(event.data.inboxID);
+        return;
+      }
+      case "session.inbox.enqueued": {
+        outbox.delete(event.data.inboxID);
+        const item = {
+          id: event.data.inboxID,
+          sessionID: event.data.sessionID,
+          time: { created: event.created },
+          ...event.data.item
+        };
+        pendingUpdates.get(item.sessionID)?.set(item.id, item);
+        admitLocal(item);
+        if (event.data.item.type === "compaction") {
+          const active = compacting.get(event.data.sessionID);
+          active?.observed.add(event.data.inboxID);
+          if (active && active.id !== event.data.inboxID && outbox.delete(active.id))
+            removePending(event.data.sessionID, active.id);
+        }
+        return;
+      }
+      case "session.instructions.updated":
+        const updateText = event.data.text;
+        if (updateText === undefined)
+          return;
+        message.insert(event.data.sessionID, {
+          id: SessionMessage.ID.fromEvent(event.id),
+          type: "system",
+          text: updateText,
+          description: `Instructions updated: ${Object.keys(event.data.delta).join(", ")}`,
+          metadata: event.metadata,
+          time: { created: event.created }
+        });
+        return;
+      case "session.synthetic":
+        message.insert(event.data.sessionID, {
+          id: SessionMessage.ID.fromEvent(event.id),
+          type: "synthetic",
+          text: event.data.text,
+          description: event.data.description,
+          metadata: event.data.metadata,
+          time: { created: event.created }
+        });
+        return;
+      case "session.shell.started":
+        message.insert(event.data.sessionID, {
+          id: SessionMessage.ID.fromEvent(event.id),
+          type: "shell",
+          shellID: event.data.shell.id,
+          command: event.data.shell.command,
+          status: event.data.shell.status,
+          exit: event.data.shell.exit,
+          metadata: event.data.shell.metadata.background === true ? { ...event.metadata, background: true } : event.metadata,
+          time: { created: event.created }
+        });
+        return;
+      case "session.shell.ended":
+        message.update(event.data.sessionID, (draft) => {
+          const match = message.shell(draft, event.data.shell.id);
+          if (!match)
+            return;
+          match.status = event.data.shell.status;
+          match.exit = event.data.shell.exit;
+          match.output = event.data.output;
+          match.time.completed = event.created;
+        });
+        return;
+      case "session.step.started":
+        message.update(event.data.sessionID, (draft, index) => {
+          const position = index.get(event.data.assistantMessageID);
+          const existing = position === undefined ? undefined : draft[position];
+          if (existing?.type === "assistant") {
+            existing.agent = event.data.agent;
+            existing.model = event.data.model;
+            existing.retry = undefined;
+            existing.error = undefined;
+            existing.finish = undefined;
+            existing.rawFinish = undefined;
+            existing.native = undefined;
+            existing.time.created = event.data.started;
+            existing.time.streamed = undefined;
+            existing.time.completed = undefined;
+            if (event.data.snapshot)
+              existing.snapshot = { ...existing.snapshot, start: event.data.snapshot };
+            return;
+          }
+          const currentAssistant = message.activeAssistant(draft);
+          if (currentAssistant) {
+            currentAssistant.retry = undefined;
+            currentAssistant.time.completed = event.created;
+          }
+          message.append(draft, index, {
+            id: event.data.assistantMessageID,
+            type: "assistant",
+            agent: event.data.agent,
+            model: event.data.model,
+            metadata: event.metadata,
+            content: [],
+            snapshot: event.data.snapshot ? { start: event.data.snapshot } : undefined,
+            time: { created: event.data.started }
+          });
+        });
+        return;
+      case "session.step.streamed":
+        message.editAssistant(event.data.sessionID, event.data.assistantMessageID, (assistant) => {
+          assistant.time.streamed = event.created;
+        });
+        return;
+      case "session.step.ended": {
+        message.editAssistant(event.data.sessionID, event.data.assistantMessageID, (assistant) => {
+          assistant.time.completed = event.created;
+          assistant.finish = event.data.finish;
+          assistant.rawFinish = event.data.rawFinish;
+          assistant.native = event.data.native;
+          assistant.cost = event.data.cost;
+          assistant.tokens = event.data.tokens;
+          if (event.data.snapshot)
+            assistant.snapshot = { ...assistant.snapshot, end: event.data.snapshot };
+        });
+        return;
+      }
+      case "session.step.failed":
+        message.editAssistant(event.data.sessionID, event.data.assistantMessageID, (assistant) => {
+          assistant.time.completed = event.created;
+          assistant.finish = event.data.finish ?? "error";
+          assistant.rawFinish = event.data.rawFinish;
+          assistant.native = event.data.native;
+          assistant.error = event.data.error;
+          assistant.retry = undefined;
+          if (event.data.cost !== undefined && event.data.tokens !== undefined) {
+            assistant.cost = event.data.cost;
+            assistant.tokens = event.data.tokens;
+          }
+        });
+        return;
+      case "session.text.started":
+        message.editAssistant(event.data.sessionID, event.data.assistantMessageID, (assistant) => {
+          assistant.content.push({ type: "text", text: "" });
+        });
+        return;
+      case "session.text.delta":
+        message.editText(event.data.sessionID, event.data.assistantMessageID, (text) => {
+          text.text += event.data.delta;
+        });
+        return;
+      case "session.text.ended":
+        message.editText(event.data.sessionID, event.data.assistantMessageID, (text) => {
+          text.text = event.data.text;
+        });
+        return;
+      case "session.tool.input.started":
+        message.editAssistant(event.data.sessionID, event.data.assistantMessageID, (assistant) => {
+          assistant.content.push({
+            type: "tool",
+            id: event.data.id,
+            name: event.data.name,
+            time: { created: event.created },
+            state: { status: "streaming", input: "" }
+          });
+        });
+        return;
+      case "session.tool.input.delta":
+        message.editTool(event.data.sessionID, event.data.assistantMessageID, event.data.id, (tool) => {
+          if (tool.state.status === "streaming")
+            tool.state.input += event.data.delta;
+        });
+        return;
+      case "session.tool.input.ended":
+        message.editTool(event.data.sessionID, event.data.assistantMessageID, event.data.id, (tool) => {
+          if (tool.state.status === "streaming")
+            tool.state.input = event.data.text;
+        });
+        return;
+      case "session.tool.called":
+        message.editTool(event.data.sessionID, event.data.assistantMessageID, event.data.id, (tool) => {
+          tool.time.ran = event.created;
+          tool.executed = event.data.executed;
+          tool.native = event.data.native;
+          tool.state = { status: "running", input: event.data.input, metadata: {} };
+        });
+        return;
+      case "session.tool.progress":
+        message.editTool(event.data.sessionID, event.data.assistantMessageID, event.data.id, (tool) => {
+          if (tool.state.status === "running")
+            tool.state.metadata = event.data.metadata;
+        });
+        return;
+      case "session.tool.success":
+        message.editTool(event.data.sessionID, event.data.assistantMessageID, event.data.id, (tool) => {
+          if (tool.state.status !== "running")
+            return;
+          tool.state = {
+            status: "completed",
+            input: tool.state.input,
+            metadata: event.data.metadata,
+            content: [...event.data.content]
+          };
+          tool.executed = event.data.executed || tool.executed === true;
+          if (event.data.native)
+            tool.native = { ...tool.native, ...event.data.native };
+          tool.time.completed = event.created;
+        });
+        return;
+      case "session.tool.failed":
+        message.editTool(event.data.sessionID, event.data.assistantMessageID, event.data.id, (tool) => {
+          if (tool.state.status !== "streaming" && tool.state.status !== "running")
+            return;
+          tool.state = {
+            status: "error",
+            error: event.data.error,
+            input: typeof tool.state.input === "string" ? {} : tool.state.input,
+            metadata: event.data.metadata,
+            content: event.data.content
+          };
+          tool.executed = event.data.executed || tool.executed === true;
+          if (event.data.native)
+            tool.native = { ...tool.native, ...event.data.native };
+          tool.time.completed = event.created;
+        });
+        return;
+      case "session.reasoning.started":
+        message.editAssistant(event.data.sessionID, event.data.assistantMessageID, (assistant) => {
+          assistant.content.push({
+            type: "reasoning",
+            text: "",
+            native: event.data.native,
+            time: { created: event.created }
+          });
+        });
+        return;
+      case "session.reasoning.delta":
+        message.editReasoning(event.data.sessionID, event.data.assistantMessageID, (reasoning) => {
+          reasoning.text += event.data.delta;
+        });
+        return;
+      case "session.reasoning.ended":
+        message.editReasoning(event.data.sessionID, event.data.assistantMessageID, (reasoning) => {
+          reasoning.text = event.data.text;
+          reasoning.time = { created: reasoning.time?.created ?? event.created, completed: event.created };
+          if (event.data.native !== undefined)
+            reasoning.native = event.data.native;
+        });
+        return;
+      case "session.retry.scheduled":
+        message.editAssistant(event.data.sessionID, event.data.assistantMessageID, (assistant) => {
+          assistant.retry = { attempt: event.data.attempt, at: event.data.at, error: event.data.error };
+        });
+        return;
+      case "session.execution.started":
+        setSessionActive(event.data.sessionID, "running");
+        return;
+      case "session.compaction.started":
+        if (event.data.inputID)
+          removePending(event.data.sessionID, event.data.inputID);
+        message.insert(event.data.sessionID, {
+          id: event.data.inputID ?? SessionMessage.ID.fromEvent(event.id),
+          type: "compaction",
+          status: "running",
+          reason: event.data.reason,
+          summary: "",
+          time: { created: event.created }
+        });
+        if (event.data.inputID)
+          compacting.get(event.data.sessionID)?.observed.add(event.data.inputID);
+        return;
+      case "session.execution.succeeded":
+      case "session.execution.failed":
+      case "session.execution.interrupted":
+        setSessionActive(event.data.sessionID, "idle");
+        message.update(event.data.sessionID, (draft) => {
+          const currentAssistant = message.activeAssistant(draft);
+          if (currentAssistant)
+            currentAssistant.retry = undefined;
+        });
+        if (event.type === "session.execution.interrupted" && event.data.reason === "shutdown")
+          return;
+        message.insert(event.data.sessionID, {
+          id: SessionMessage.ID.fromEvent(event.id),
+          type: "idle",
+          outcome: event.type === "session.execution.succeeded" ? "succeeded" : event.type === "session.execution.failed" ? "failed" : "interrupted",
+          ...event.type === "session.execution.failed" ? { error: event.data.error } : {},
+          time: { created: event.created }
+        });
+        if (store.session.message[event.data.sessionID]?.some((item) => item.type === "assistant" && item.content.some((part) => part.type === "tool" && (part.state.status === "streaming" || part.state.status === "running")))) {
+          sync.invalidate(`session.message:${event.data.sessionID}`);
+          refresh(() => result.session.message.sync(event.data.sessionID));
+        }
+        if (!store.session.info[event.data.sessionID] && !sync.has(`session:${event.data.sessionID}`))
+          return;
+        result.session.invalidate(event.data.sessionID);
+        refresh(() => result.session.sync(event.data.sessionID));
+        return;
+      case "session.viewed":
+        if (!store.session.info[event.data.sessionID] && !sync.has(`session:${event.data.sessionID}`))
+          return;
+        result.session.invalidate(event.data.sessionID);
+        refresh(() => result.session.sync(event.data.sessionID));
+        return;
+      case "session.revert.staged":
+        if (store.session.info[event.data.sessionID])
+          setStore("session", "info", event.data.sessionID, "revert", event.data.revert);
+        return;
+      case "session.revert.cleared":
+        if (store.session.info[event.data.sessionID])
+          setStore("session", "info", event.data.sessionID, "revert", undefined);
+        return;
+      case "session.revert.committed":
+        if (store.session.info[event.data.sessionID]) {
+          setStore("session", "info", event.data.sessionID, "revert", undefined);
+        }
+        setStore("session", "pending", event.data.sessionID, (store.session.pending[event.data.sessionID] ?? []).filter((item) => item.id < event.data.to));
+        message.update(event.data.sessionID, (draft, index) => {
+          const position = draft.findIndex((item) => item.id >= event.data.to);
+          if (position === -1)
+            return;
+          for (const item of draft.splice(position))
+            index.delete(item.id);
+        });
+        return;
+      case "session.compaction.delta":
+        message.update(event.data.sessionID, (draft) => {
+          const current = message.compaction(draft);
+          if (current?.status === "running")
+            current.summary += event.data.text;
+        });
+        return;
+      case "session.compaction.ended":
+        message.update(event.data.sessionID, (draft, index) => {
+          const position = draft.findLastIndex((item) => item.type === "compaction" && item.status === "running");
+          const current = draft[position];
+          if (current?.type === "compaction") {
+            Object.assign(current, {
+              status: "completed",
+              reason: event.data.reason,
+              model: event.data.model,
+              native: event.data.native,
+              summary: event.data.text,
+              cost: event.data.cost,
+              tokens: event.data.tokens
+            });
+            return;
+          }
+          message.append(draft, index, {
+            id: SessionMessage.ID.fromEvent(event.id),
+            type: "compaction",
+            status: "completed",
+            reason: event.data.reason,
+            model: event.data.model,
+            native: event.data.native,
+            summary: event.data.text,
+            cost: event.data.cost,
+            tokens: event.data.tokens,
+            time: { created: event.created }
+          });
+        });
+        return;
+      case "session.compaction.failed":
+        if (event.data.inputID)
+          removePending(event.data.sessionID, event.data.inputID);
+        message.update(event.data.sessionID, (draft, index) => {
+          const position = draft.findLastIndex((item) => item.type === "compaction" && item.status === "running");
+          const current = draft[position];
+          const failed = {
+            id: current?.id ?? event.data.inputID ?? SessionMessage.ID.fromEvent(event.id),
+            type: "compaction",
+            status: "failed",
+            reason: event.data.reason,
+            error: event.data.error,
+            metadata: current?.type === "compaction" ? current.metadata : event.metadata,
+            cost: event.data.cost,
+            tokens: event.data.tokens,
+            time: current?.type === "compaction" ? current.time : { created: event.created }
+          };
+          if (current?.type === "compaction") {
+            draft[position] = failed;
+            return;
+          }
+          message.append(draft, index, failed);
+        });
+        if (event.data.inputID)
+          compacting.get(event.data.sessionID)?.observed.add(event.data.inputID);
+        return;
+      case "permission.asked":
+        if (store.session.permission[event.data.sessionID]?.some((request) => request.id === event.data.id))
+          return;
+        setStore("session", "permission", event.data.sessionID, [
+          ...store.session.permission[event.data.sessionID] ?? [],
+          event.data
+        ]);
+        return;
+      case "permission.replied":
+        removePermission(event.data.sessionID, event.data.requestID);
+        return;
+      case "form.replied":
+      case "form.cancelled":
+        removeForm(event.data.sessionID, event.data.id, event.location);
+        return;
+    }
+    if (event.type === "credential.updated" || event.type === "credential.switched") {
+      Object.keys(store.location).forEach((key) => {
+        const ref = JSON.parse(key);
+        const location = { directory: ref[0], workspaceID: ref[1] ?? undefined };
+        if (event.type === "credential.updated") {
+          result.location.integration.invalidate(location);
+          refresh(() => result.location.integration.sync(location));
+          return;
+        }
+        setStore("location", key, (data) => ({
+          integration: data?.integration?.map((integration) => {
+            if (integration.id !== event.data.integrationID)
+              return integration;
+            const active = integration.connections.find((connection) => connection.type === "credential" && connection.id === event.data.credentialID);
+            if (!active)
+              return integration;
+            return {
+              ...integration,
+              connections: [active, ...integration.connections.filter((connection) => connection !== active)]
+            };
+          })
+        }));
+        result.location.model.invalidate(location);
+        result.location.provider.invalidate(location);
+        refresh(() => Promise.all([result.location.model.sync(location), result.location.provider.sync(location)]));
+      });
+      return;
+    }
+    if (!event.location)
+      return;
+    const location = event.location;
+    switch (event.type) {
+      case "provider.updated":
+        result.location.provider.invalidate(location);
+        refresh(() => result.location.provider.sync(location));
+        break;
+      case "model.updated":
+        result.location.model.invalidate(location);
+        refresh(() => result.location.model.sync(location));
+        break;
+      case "agent.updated":
+        result.location.agent.invalidate(location);
+        refresh(() => result.location.agent.sync(location));
+        break;
+      case "command.updated":
+        result.location.command.invalidate(location);
+        refresh(() => result.location.command.sync(location));
+        break;
+      case "skill.updated":
+        result.location.skill.invalidate(location);
+        refresh(() => result.location.skill.sync(location));
+        break;
+      case "vcs.branch.updated":
+        setStore("location", locationKey2(location), (data) => ({
+          vcs: {
+            branch: {
+              ...data?.vcs?.branch,
+              current: event.data.branch
+            }
+          }
+        }));
+        break;
+      case "form.created":
+        if (store.session.form[event.data.form.sessionID]?.some((form) => form.id === event.data.form.id))
+          break;
+        setStore("session", "form", event.data.form.sessionID, [
+          ...store.session.form[event.data.form.sessionID] ?? [],
+          event.data.form.sessionID === "global" ? { ...event.data.form, location } : event.data.form
+        ]);
+        break;
+      case "shell.created":
+        setStore("location", locationKey2(location), (data) => ({
+          shell: {
+            ...data?.shell,
+            [event.data.info.id]: { ...event.data.info, location }
+          }
+        }));
+        break;
+      case "shell.exited":
+      case "shell.deleted":
+        setStore("location", locationKey2(location), (data) => ({
+          shell: Object.fromEntries(Object.entries(data?.shell ?? {}).filter(([id]) => id !== event.data.id))
+        }));
+        break;
+      case "reference.updated":
+        result.location.reference.invalidate(location);
+        refresh(() => result.location.reference.sync(location));
+        break;
+      case "integration.updated":
+        result.location.integration.invalidate(location);
+        result.location.model.invalidate(location);
+        result.location.provider.invalidate(location);
+        refresh(() => Promise.all([
+          result.location.integration.sync(location),
+          result.location.model.sync(location),
+          result.location.provider.sync(location)
+        ]));
+        break;
+      case "config.updated":
+        result.location.config.invalidate(location);
+        if (result.location.config.list(location) !== undefined || sync.has(`location.config:${locationKey2(location)}`))
+          refresh(() => result.location.config.sync(location));
+        refresh(() => result.location.websearch.refresh(location));
+        break;
+      case "websearch.updated":
+        refresh(() => result.location.websearch.refresh(location));
+        break;
+      case "mcp.status.changed":
+        result.location.mcp.server.invalidate(location);
+        settle(`mcp.status:${locationKey2(location)}`, () => result.location.mcp.server.sync(location));
+        break;
+      case "mcp.resources.changed":
+        result.location.mcp.resource.invalidate(location);
+        refresh(() => result.location.mcp.resource.sync(location));
+        break;
+    }
+  }
+  function locationResource(field, load, options) {
+    const publish = (key, value) => setStore("location", key, { [field]: value });
+    return {
+      list: (ref) => store.location[locationKey2(ref ?? defaultLocation())]?.[field],
+      sync: (ref) => {
+        const location = ref ?? defaultLocation();
+        const id = locationKey2(location);
+        return sync.run(`location.${field}:${id}`, async () => {
+          const response = await load(locationQuery(location));
+          const key = locationKey2(response.location);
+          publish(key, response.data);
+          if (options?.alias && key !== id)
+            publish(id, response.data);
+        });
+      },
+      invalidate: (ref) => sync.invalidate(`location.${field}:${locationKey2(ref ?? defaultLocation())}`)
+    };
+  }
+  const vcs = locationResource("vcs", (location) => api().vcs.get({ location }));
+  const shells = locationResource("shell", async (location) => {
+    const response = await api().shell.list({ location });
+    const ref = { directory: response.location.directory };
+    return {
+      location: response.location,
+      data: Object.fromEntries(response.data.map((info) => [info.id, { ...info, location: ref }]))
+    };
+  });
+  const result = {
+    on: config.event.on,
+    listen: config.event.listen,
+    session: {
+      list() {
+        return sessions();
+      },
+      get(sessionID) {
+        return store.session.info[sessionID];
+      },
+      creating(sessionID) {
+        return creating.has(sessionID);
+      },
+      remember(info) {
+        batch(() => {
+          setStore("session", "info", info.id, reconcile(info));
+          sync.complete(`session:${info.id}`);
+          registerSession(info.id);
+        });
+      },
+      setStatus(sessionID, status) {
+        setSessionActive(sessionID, status);
+      },
+      root(sessionID) {
+        return resolveRoot(sessionID);
+      },
+      family(sessionID) {
+        return store.session.family[resolveRoot(sessionID)] ?? [];
+      },
+      evict(sessionID) {
+        const root = resolveRoot(sessionID);
+        batch(() => {
+          for (const id of new Set([root, sessionID, ...store.session.family[root] ?? []]))
+            evictSession(id);
+        });
+      },
+      cost(sessionID) {
+        const session = store.session.info[sessionID];
+        if (!session)
+          return 0;
+        if (session.parentID)
+          return session.cost;
+        return (store.session.family[sessionID] ?? [sessionID]).reduce((total, id) => total + (store.session.info[id]?.cost ?? 0), 0);
+      },
+      status(sessionID) {
+        return store.session.active[sessionID] ?? "idle";
+      },
+      active() {
+        return Object.entries(store.session.active).flatMap(([sessionID, status]) => status === "running" ? [sessionID] : []);
+      },
+      input: {
+        list(sessionID) {
+          return (store.session.pending[sessionID] ?? []).flatMap((item) => item.type === "compaction" ? [] : [item.id]);
+        },
+        has(sessionID, inboxID) {
+          return store.session.pending[sessionID]?.some((item) => item.id === inboxID && item.type !== "compaction") ?? false;
+        }
+      },
+      pending: {
+        list(sessionID) {
+          return store.session.pending[sessionID] ?? [];
+        },
+        status(sessionID, inboxID) {
+          const pending = store.session.pending[sessionID] ?? [];
+          const item = pending.find((entry) => entry.id === inboxID && entry.type === "user");
+          if (!item)
+            return;
+          if (item.delivery === "queue")
+            return "queued";
+          const messages = store.session.message[sessionID] ?? [];
+          const boundary = messages.findLastIndex((entry) => entry.type === "idle");
+          if ((store.session.active[sessionID] ?? "idle") === "idle")
+            return boundary >= 0 && item.time.created <= messages[boundary].time.created ? "stranded" : "starting";
+          return messages.slice(boundary + 1).some((entry) => entry.type === "user" && !pending.some((other) => other.id === entry.id)) ? "steering" : "starting";
+        },
+        sync(sessionID) {
+          return sync.run(`session.pending:${sessionID}`, async () => {
+            const updates = new Map;
+            pendingUpdates.set(sessionID, updates);
+            try {
+              const snapshot = await api().session.inbox.list({ sessionID });
+              const current = new Map(snapshot.map((item) => [item.id, item]));
+              updates.forEach((item, id) => {
+                if (item === undefined)
+                  current.delete(id);
+                else if (typeof item === "string") {
+                  const existing = current.get(id);
+                  if (existing)
+                    current.set(id, { ...existing, delivery: item });
+                } else
+                  current.set(id, item);
+              });
+              const pending = [...current.values()];
+              pending.forEach((item) => outbox.delete(item.id));
+              if (pending.some((item) => item.type === "compaction"))
+                store.session.pending[sessionID]?.filter((item) => item.type === "compaction").forEach((item) => outbox.delete(item.id));
+              const inflight = (store.session.pending[sessionID] ?? []).filter((item) => outbox.has(item.id));
+              const merged = inflight.length === 0 ? pending : [...pending, ...inflight];
+              batch(() => {
+                setStore("session", "pending", sessionID, reconcile(merged));
+                merged.forEach(materializeInboxMessage);
+              });
+            } finally {
+              if (pendingUpdates.get(sessionID) === updates)
+                pendingUpdates.delete(sessionID);
+            }
+          });
+        },
+        invalidate(sessionID) {
+          sync.invalidate(`session.pending:${sessionID}`);
+        }
+      },
+      create(input) {
+        const { projectID, ...payload } = input;
+        const id = payload.id ?? SessionID.create();
+        const location = payload.location ?? defaultLocation();
+        const fresh = !store.session.info[id];
+        if (fresh) {
+          const now = Date.now();
+          sessionOutbox.add(id);
+          result.session.remember({
+            id,
+            projectID: projectID ?? store.location[locationKey2(location)]?.info?.project.id ?? "",
+            agent: payload.agent,
+            model: payload.model,
+            cost: 0,
+            tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+            time: { created: now, updated: now },
+            title: payload.title,
+            location
+          });
+          sync.complete(`session.family:${id}`);
+          sync.complete(`session.pending:${id}`);
+          sync.complete(`session.message:${id}`);
+        }
+        const request = Promise.resolve().then(() => api().session.create({ ...payload, id, location })).then((info) => {
+          sessionOutbox.delete(id);
+          result.session.remember(info);
+          return info;
+        }).catch((error) => {
+          if (fresh && sessionOutbox.delete(id))
+            removeSession(id);
+          throw error;
+        });
+        if (fresh)
+          track(creating, id, request);
+        return { id, request };
+      },
+      compact(input) {
+        const active = compacting.get(input.sessionID);
+        if (active)
+          return active.request;
+        const id = SessionMessage.ID.create();
+        if (!store.session.pending[input.sessionID]?.some((item) => item.type === "compaction")) {
+          outbox.add(id);
+          admitLocal({
+            id,
+            sessionID: input.sessionID,
+            time: { created: Date.now() },
+            type: "compaction",
+            delivery: "steer",
+            payload: {}
+          });
+        }
+        const observed = new Set;
+        const request = sendAdmission(input.sessionID, async () => {
+          if (input.model)
+            await api().session.switchModel({ sessionID: input.sessionID, model: input.model });
+          return api().session.compact({ sessionID: input.sessionID, id });
+        }).then((item) => {
+          batch(() => {
+            outbox.delete(id);
+            if (item.id !== id)
+              removePending(input.sessionID, id);
+            if (!observed.has(item.id) && !messageIndex.get(input.sessionID)?.has(item.id))
+              admitLocal(item);
+          });
+          return item;
+        }).catch((error) => {
+          if (outbox.delete(id))
+            removePending(input.sessionID, id);
+          throw error;
+        }).finally(() => {
+          if (compacting.get(input.sessionID)?.request === request)
+            compacting.delete(input.sessionID);
+        });
+        compacting.set(input.sessionID, { id, observed, request });
+        return request;
+      },
+      prompt(input) {
+        const { gate, prepare, ...request } = input;
+        const id = request.id ?? SessionMessage.ID.create();
+        const fresh = !messageIndex.get(request.sessionID)?.has(id) && !store.session.pending[request.sessionID]?.some((item) => item.id === id);
+        if (fresh) {
+          const files = optimisticFiles(request.files);
+          const payload = {
+            text: request.text,
+            agents: request.agents?.map((agent) => ({ ...agent })),
+            metadata: request.metadata
+          };
+          if (files)
+            payload.files = files;
+          outbox.add(id);
+          admitLocal({
+            id,
+            sessionID: request.sessionID,
+            time: { created: Date.now() },
+            type: "user",
+            delivery: request.delivery ?? "steer",
+            payload
+          });
+        }
+        return sendAdmission(request.sessionID, async () => {
+          await prepare?.();
+          return api().session.prompt({ ...request, id });
+        }, gate).catch((error) => {
+          if (fresh && outbox.delete(id))
+            retractLocal(request.sessionID, id);
+          throw error;
+        });
+      },
+      sync(sessionID, options) {
+        return sync.run(options?.children ? `session.family:${sessionID}` : `session:${sessionID}`, async () => {
+          const [info, children] = await Promise.all([
+            api().session.get({ sessionID }),
+            options?.children ? listChildren({ parentID: sessionID, order: "desc", limit: CHILD_PAGE }) : []
+          ]);
+          const sessions = [info, ...children];
+          batch(() => {
+            setStore("session", "info", produce((draft) => {
+              for (const session of sessions)
+                draft[session.id] = session;
+            }));
+            for (const session of sessions) {
+              sync.complete(`session:${session.id}`);
+              registerSession(session.id);
+            }
+          });
+        });
+      },
+      invalidate(sessionID) {
+        sync.invalidate(`session:${sessionID}`);
+      },
+      message: {
+        list(sessionID) {
+          return store.session.message[sessionID] ?? [];
+        },
+        get(sessionID, messageID) {
+          const messages = store.session.message[sessionID];
+          const position = messageIndex.get(sessionID)?.get(messageID);
+          return position === undefined ? undefined : messages?.[position];
+        },
+        sync(sessionID) {
+          return sync.run(`session.message:${sessionID}`, async () => {
+            const response = await api().message.list({
+              sessionID,
+              limit: config.initialMessageLimit?.() ?? messagePageLimit,
+              order: "desc"
+            });
+            const fetched = response.data.toReversed();
+            const ids = new Set(fetched.map((item) => item.id));
+            const admitted = new Set((store.session.pending[sessionID] ?? []).flatMap((item) => item.type === "user" || item.type === "synthetic" ? [item.id] : []));
+            const local = (store.session.message[sessionID] ?? []).filter((item) => !ids.has(item.id) && (outbox.has(item.id) || admitted.has(item.id)));
+            const messages = local.length === 0 ? fetched : [...fetched, ...local];
+            batch(() => {
+              messageIndex.set(sessionID, new Map(messages.map((message, index) => [message.id, index])));
+              setStore("session", "message", sessionID, reconcile(messages));
+              setStore("session", "messageCursor", sessionID, response.cursor.next ?? undefined);
+            });
+          });
+        },
+        more(sessionID) {
+          return store.session.messageCursor[sessionID] !== undefined;
+        },
+        loading(sessionID) {
+          return store.session.messageLoading[sessionID] ?? false;
+        },
+        async loadMore(sessionID, options) {
+          const signal = options?.signal;
+          if (signal?.aborted)
+            return;
+          while (messageLoads.has(sessionID)) {
+            const published = await (() => {
+              const pending = messageLoads.get(sessionID);
+              if (!signal)
+                return pending;
+              const aborted = Promise.withResolvers();
+              const cancel = () => aborted.resolve();
+              signal.addEventListener("abort", cancel, { once: true });
+              return Promise.race([pending, aborted.promise]).catch((error) => {
+                if (!signal.aborted)
+                  throw error;
+              }).finally(() => signal.removeEventListener("abort", cancel));
+            })();
+            if (!options?.all && published || signal?.aborted)
+              return;
+          }
+          const cursor = store.session.messageCursor[sessionID];
+          if (!cursor || signal?.aborted)
+            return;
+          setStore("session", "messageLoading", sessionID, true);
+          const request = (async () => {
+            const fetched = [];
+            let next = cursor;
+            do {
+              const response = await api().message.list({
+                sessionID,
+                limit: options?.all ? 200 : messagePageLimit,
+                cursor: next
+              }, { signal });
+              if (signal?.aborted)
+                return;
+              fetched.push(...response.data);
+              next = response.cursor.next ?? undefined;
+              if (!options?.all)
+                break;
+            } while (next);
+            const existing = store.session.message[sessionID] ?? [];
+            const ids = new Set(existing.map((item) => item.id));
+            const messages = [...fetched.reverse().filter((item) => !ids.has(item.id)), ...existing];
+            batch(() => {
+              options?.beforePublish?.();
+              messageIndex.set(sessionID, new Map(messages.map((item, position) => [item.id, position])));
+              setStore("session", "message", sessionID, reconcile(messages));
+              setStore("session", "messageCursor", sessionID, next);
+            });
+            return true;
+          })().catch((error) => {
+            if (!signal?.aborted)
+              throw error;
+          }).finally(() => setStore("session", "messageLoading", sessionID, false));
+          track(messageLoads, sessionID, request);
+          await request;
+        },
+        invalidate(sessionID) {
+          sync.invalidate(`session.message:${sessionID}`);
+        }
+      },
+      permission: {
+        list(sessionID) {
+          return store.session.permission[sessionID];
+        },
+        sessions() {
+          return Object.entries(store.session.permission).flatMap(([sessionID, requests]) => requests.length > 0 ? [sessionID] : []);
+        },
+        sync(sessionID) {
+          return sync.run(`session.permission:${sessionID}`, async () => {
+            setStore("session", "permission", sessionID, await api().permission.list({ sessionID }));
+          });
+        },
+        invalidate(sessionID) {
+          sync.invalidate(`session.permission:${sessionID}`);
+        },
+        async reply(input) {
+          await api().permission.reply(input).catch((error) => {
+            if (!isPermissionNotFoundError2(error))
+              throw error;
+          });
+          removePermission(input.sessionID, input.requestID);
+        }
+      },
+      form: {
+        list(sessionID, ref) {
+          const forms = store.session.form[sessionID];
+          if (sessionID !== "global")
+            return forms;
+          if (!ref)
+            return;
+          const key = locationKey2(ref);
+          return forms?.filter((form) => form.location && locationKey2(form.location) === key);
+        },
+        sessions() {
+          return Object.entries(store.session.form).flatMap(([sessionID, forms]) => sessionID !== "global" && forms.length > 0 ? [sessionID] : []);
+        },
+        sync(sessionID, ref) {
+          const key = `session.form:${sessionID}:${sessionID === "global" ? locationKey2(ref ?? defaultLocation()) : ""}`;
+          return sync.run(key, async () => {
+            if (sessionID === "global") {
+              const response = await api().form.list({
+                location: locationQuery(ref ?? defaultLocation())
+              });
+              const location = {
+                directory: response.location.directory
+              };
+              const locationID = locationKey2(location);
+              setStore("session", "form", sessionID, [
+                ...(store.session.form[sessionID] ?? []).filter((form) => form.location && locationKey2(form.location) !== locationID),
+                ...response.data.filter((form) => form.sessionID === "global").map((form) => ({ ...form, location }))
+              ]);
+              return;
+            }
+            setStore("session", "form", sessionID, await api().session.form.list({ sessionID }));
+          });
+        },
+        invalidate(sessionID, ref) {
+          sync.invalidate(`session.form:${sessionID}:${sessionID === "global" ? locationKey2(ref ?? defaultLocation()) : ""}`);
+        },
+        reply(input, ref) {
+          return settleForm(input, ref, api().session.form.reply(input, formRequestOptions(input.sessionID, ref)));
+        },
+        cancel(input, ref) {
+          return settleForm(input, ref, api().session.form.cancel(input, formRequestOptions(input.sessionID, ref)));
+        }
+      }
+    },
+    project: {
+      list() {
+        return Object.values(store.project.info).filter((project) => project.time.archived === undefined).toSorted((a, b) => b.time.active - a.time.active);
+      },
+      get(projectID) {
+        return store.project.info[projectID];
+      },
+      sync() {
+        return sync.run("project", async () => {
+          const projects = await api().project.list();
+          setStore("project", "info", reconcile(Object.fromEntries(projects.map((project) => [project.id, project]))));
+        });
+      },
+      invalidate() {
+        sync.invalidate("project");
+      },
+      permission: {
+        list(projectID) {
+          return store.project.permission[projectID];
+        },
+        sync(projectID) {
+          return sync.run(`project.permission:${projectID}`, async () => {
+            setStore("project", "permission", projectID, await api().permission.saved.list({ projectID }));
+          });
+        },
+        invalidate(projectID) {
+          sync.invalidate(`project.permission:${projectID}`);
+        }
+      }
+    },
+    shell: {
+      list(location) {
+        return Object.values(shells.list(location) ?? {});
+      },
+      listBySession(sessionID) {
+        return Object.values(store.location).flatMap((data) => Object.values(data.shell ?? {})).filter((shell) => shell.metadata.sessionID === sessionID);
+      },
+      get(id) {
+        return Object.values(store.location).map((data) => data.shell?.[id]).find((shell) => shell !== undefined);
+      },
+      sync: shells.sync,
+      invalidate: shells.invalidate
+    },
+    location: {
+      info(ref) {
+        return store.location[locationKey2(ref ?? defaultLocation())]?.info;
+      },
+      default() {
+        return defaultLocation();
+      },
+      syncInfo(ref) {
+        const current = ref ?? defaultLocation();
+        return sync.run(`location:${locationKey2(current)}`, async () => {
+          const location = await api().location.get({ location: locationQuery(current) });
+          const key = locationKey2(location);
+          if (!store.location[key])
+            setStore("location", key, {});
+          setStore("location", key, "info", location);
+          if (!ref) {
+            setDefaultLocation({ directory: location.directory });
+          }
+        });
+      },
+      async sync(ref) {
+        await result.location.syncInfo(ref);
+        const location = ref ?? defaultLocation();
+        await Promise.all([
+          result.location.vcs.sync(location),
+          result.location.agent.sync(location),
+          result.location.command.sync(location),
+          result.location.integration.sync(location),
+          result.location.mcp.server.sync(location),
+          result.location.mcp.resource.sync(location),
+          result.location.model.sync(location),
+          result.location.provider.sync(location),
+          result.location.reference.sync(location),
+          result.location.skill.sync(location),
+          result.shell.sync(location),
+          result.session.form.sync("global", location)
+        ]);
+      },
+      invalidate(ref) {
+        const location = ref ?? defaultLocation();
+        sync.invalidate(`location:${locationKey2(location)}`);
+        result.location.vcs.invalidate(location);
+        result.location.agent.invalidate(location);
+        result.location.command.invalidate(location);
+        result.location.config.invalidate(location);
+        result.location.integration.invalidate(location);
+        result.location.mcp.server.invalidate(location);
+        result.location.mcp.resource.invalidate(location);
+        result.location.model.invalidate(location);
+        result.location.provider.invalidate(location);
+        result.location.reference.invalidate(location);
+        result.location.skill.invalidate(location);
+        result.shell.invalidate(location);
+        result.session.form.invalidate("global", location);
+      },
+      vcs: { info: vcs.list, sync: vcs.sync, invalidate: vcs.invalidate },
+      agent: locationResource("agent", (location) => api().agent.list({ location })),
+      command: locationResource("command", (location) => api().command.list({ location })),
+      config: locationResource("config", async (location) => ({
+        location: { directory: location.directory },
+        data: await api().config.get({ location })
+      })),
+      integration: locationResource("integration", (location) => api().integration.list({ location })),
+      mcp: {
+        server: locationResource("mcpServer", (location) => api().mcp.list({ location })),
+        resource: locationResource("mcpResource", async (location) => {
+          const response = await api().mcp.resource.catalog({ location });
+          return { location: response.location, data: response.data.resources };
+        })
+      },
+      model: locationResource("model", (location) => api().model.list({ location }), { alias: true }),
+      provider: locationResource("provider", (location) => api().provider.list({ location }), { alias: true }),
+      reference: locationResource("reference", (location) => api().reference.list({ location })),
+      websearch: {
+        list(location) {
+          return store.location[locationKey2(location ?? defaultLocation())]?.websearch;
+        },
+        async refresh(ref) {
+          const input = { location: locationQuery(ref ?? defaultLocation()) };
+          const providers = await api().websearch.providers(input);
+          const key = locationKey2(providers.location);
+          setStore("location", key, { websearch: providers.data });
+        }
+      },
+      skill: locationResource("skill", (location) => api().skill.list({ location }))
+    }
+  };
+  createEffect(() => {
+    if (config.connection?.status() === "connected")
+      return;
+    sync.invalidate();
+  });
+  onCleanup(config.event.listen(({ details }) => {
+    handleEvent(details);
+  }));
+  return result;
+}
+
+export { settleMs2, locationKey2, createData2 };