mindwire 0.1.52 → 0.1.54

package/README.md

@@ -16,6 +16,11 @@ protocol; this package is a thin, dependency-free client over its REST + SSE sur
 
 ## Install
 
+Connect saved bots to Slack, Microsoft Teams, Discord, or Telegram through
+`mw.integrations`: chat with streamed replies, run commands, trigger tasks, or send notifications.
+Connections are shared with the app and Go SDK. See the
+[messaging integrations guide](https://mindwire.sh/docs/guides/integrations) for setup and examples.
+
 ```bash
 npm i mindwire
 # or: bun add mindwire / pnpm add mindwire
@@ -38,7 +43,7 @@ If macOS rejects the login, the CLI lets you retry the password or check Screen
 Sharing permissions. Canceling or entering a wrong password keeps the existing
 desktop setup and active connections unchanged.
 Opening a workspace or checking status does not enable screen access. See the
-[desktop contract](../../daemon/DESKTOP.md#personal-mac-desktop) for platform support,
+[desktop contract](../../packages/daemon/DESKTOP.md#personal-mac-desktop) for platform support,
 permissions and the shared input protocol. Existing installations need a release
 advertising `health().localDesktopVersion >= 1`.
 
@@ -112,7 +117,7 @@ and native transcripts. Use `deleteChat()` for an explicit transcript purge.
 
 Check `health().workspaceMetadataVersion` before enabling registry features on an
 older daemon. `workspace.import()` imports legacy IDs once; existing records and
-deletion markers win. See the [registry contract](../../daemon/WORKSPACES.md) for
+deletion markers win. See the [registry contract](../../packages/daemon/WORKSPACES.md) for
 migration and recovery. The embedded Go SDK exposes the same operations through
 `client.Workspace`, using the same SQLite implementation.
 
@@ -153,6 +158,93 @@ blocks running chats/overlapping projects and recovers removal across restarts.
 Cancellation returns 409 after the `deleting` phase; cleanup then affects only the
 owned quarantine, even if someone recreates the original directory.
 
+Create a plain harness profile with `mw.bots.create({ agentId, projectId, name, raw: true })`
+(Go: `Bot.Raw`). Requires `health().botsVersion >= 7`. It keeps a named conversation
+group and the existing harness authentication, settings and native tools, without
+Mindwire bot instructions, memory, knowledge, skills or bot MCP tools. `raw` is
+creation-only; create a separate profile to change modes without carrying an old
+persona into a resumed conversation.
+
+With `botsVersion >= 8`, bots belong to a workspace and can work in any of its
+projects. `projectId` is only their optional default working folder. Start a chat
+in another project with `mw.bots.createChat(bot.id, { projectId })` (Go:
+`Bots.CreateChat(bot.ID, chatID, title, projectID)`). The profile, memory and skills
+stay shared; each chat retains its own project, native session and permissions.
+Deleting a project clears a matching default folder while preserving the bot and
+its conversations in other projects.
+
+### Bot skills
+
+Bots keep standing identity in `instructions`, durable facts in `memory`, and
+reference material in `knowledge`. Assign reusable workflows separately with
+`skills`, an array containing complete portable `SKILL.md` documents:
+
+```ts
+import { readFile } from "node:fs/promises";
+
+await mw.bots.update(bot.id, {
+  expectedRevision: bot.revision,
+  skills: [await readFile("./skills/reports/SKILL.md", "utf8")],
+});
+```
+
+Requires `health().botsVersion >= 6`. The Go equivalent is `BotEdit.Skills`.
+Each document needs YAML `name` and `description` frontmatter and a Markdown body.
+Limits are 16 skills, 32 KiB each, 128 KiB total, with unique names. The portable
+frontmatter supports `license`, `compatibility` and string-valued `metadata`;
+native permission overrides, hooks and dynamic shell substitutions are rejected. Omit `skills` when updating
+unrelated fields; an explicit empty array removes assignments.
+
+The daemon supplies a private bundle for the current turn. Codex discovers it
+through process-scoped extra roots; Claude loads it through `--plugin-dir`.
+Other harnesses load the same content through `skills_list` / `skills_read` on
+the existing scoped tool bridge. Older Codex versions without extra-root support
+also use that fallback. Only skill metadata enters standing context; bodies are
+read on demand. Assignments retain the turn's starting revision. Skills grant no
+additional permissions and never alter global harness configuration. Product
+presets and skill content belong to the client; the Go core supplies the generic
+validation, storage, delivery and permission checks.
+
+### Applications and scheduled work
+
+`mw.apps` saves application resources on their owning host. Clients can present
+these as shortcuts, launchers or other application catalogs. Consumer bot presets
+and General-mode UI are outside the Go registry; no new AI runtime is created.
+
+```ts
+const { app } = await mw.apps.register({
+  projectId, name: "Reports", icon: "chart.bar", url: "http://127.0.0.1:3000",
+  startupCommand: "./scripts/ensure-reports.sh", healthPath: "/health",
+});
+await mw.apps.open(app.id); // bounded readiness check/startup; returns the saved URL
+await mw.apps.channels(); // labels/IDs only, no provider credentials
+await mw.apps.notifications(app.id); // protected credentialFile path on the computer
+await mw.apps.saveSchedule(app.id, {
+  name: "Morning report", localTime: "09:00", timeZone: "Europe/London",
+  weekdays: [1, 2, 3, 4, 5], command: "./scripts/build-report.sh",
+  title: "Reports", body: "Your morning report is ready.",
+});
+const schedules = await mw.apps.schedules(app.id);
+```
+
+Check `health().appsVersion >= 1`. Phone delivery must already be configured.
+Schedules persist across restarts and run while the owning computer is awake;
+notifications retry without rerunning a completed command. Backend credentials
+can only send as one app through its saved destinations. See the
+[Apps contract](../../docs/apple/Apps.md) for native tools, private forwarding,
+calendar rules, removal and recovery. The Go SDK shares `client.Apps` for saved
+records, readiness, notification delivery and schedules; backend credential files
+are provisioned through the running daemon's HTTP/native tool service.
+
+The standalone daemon explicitly owns scheduling. The embedded Go SDK does not
+run scheduled commands merely because a client is constructed; opt in with
+`mindwire.Options{RunScheduledJobs: true}` when hosting a long-lived runtime.
+Native agent tools request owner approval before enabling background commands,
+using the existing interaction stream. Direct owner API/SDK requests explicitly
+authorize their work. Pausing remains available when notifications are muted or
+unconfigured. Commands use the host OS permissions; the working directory does
+not provide a sandbox.
+
 ## Targets — where the daemon runs
 
 **One `new Mindwire` = one instance = one daemon = one environment.** Every agent that instance runs
@@ -289,3 +381,6 @@ bun test               # client + SSE parser tests (mocked fetch)
 ```
 
 License: Apache-2.0.
+
+
+Public hosting adapters can check `health().appsVersion >= 2`, then call `mw.apps.preparePublication(appId)` (Go: `client.Apps.PreparePublication(ctx, appID)`). This validates a port or static build plan without deploying it. After the adapter confirms hosting, save its HTTPS link using `apps.update(..., { expectedRevision, publicUrl })`. The original private URL stays intact. Provider credentials and billing belong in the host application, outside the generic runtime.

package/dist/apps.d.ts

@@ -0,0 +1,94 @@
+import type { Mindwire } from "./client.js";
+import type { WorkspaceSnapshot } from "./workspace.js";
+/** An application resource saved on its owning host. */
+export interface AppShortcut {
+    id: string;
+    workspaceId: string;
+    projectId: string;
+    botId?: string;
+    name: string;
+    icon?: string;
+    url: string;
+    startupCommand?: string;
+    healthPath?: string;
+    archived: boolean;
+    createdAt: string;
+    revision: number;
+    channelIds?: string[];
+    notificationsMuted: boolean;
+    automation?: boolean;
+    staticDirectory?: string;
+    publicUrl?: string;
+}
+export type AppShortcutCreate = Pick<AppShortcut, "projectId" | "name" | "url"> & Partial<Pick<AppShortcut, "id" | "botId" | "icon" | "startupCommand" | "healthPath" | "automation" | "channelIds" | "notificationsMuted" | "staticDirectory" | "publicUrl">>;
+export type AppShortcutEdit = {
+    expectedRevision: number;
+} & Partial<Pick<AppShortcut, "name" | "icon" | "url" | "startupCommand" | "healthPath" | "archived" | "channelIds" | "notificationsMuted" | "staticDirectory" | "publicUrl">>;
+export interface AppShortcutMutation {
+    app: AppShortcut;
+    snapshot: WorkspaceSnapshot;
+}
+export interface AppPublication {
+    app: AppShortcut;
+    kind: "port" | "static";
+    port?: number;
+    directory?: string;
+}
+export interface AppNotificationChannel {
+    id: string;
+    name: string;
+    type: string;
+}
+export interface AppScheduleSpec {
+    id?: string;
+    expectedRevision?: number;
+    name: string;
+    runAt?: string;
+    intervalSeconds?: number;
+    localTime?: string;
+    timeZone?: string;
+    weekdays?: number[];
+    command?: string;
+    title?: string;
+    body?: string;
+    enabled?: boolean;
+}
+export interface AppSchedule extends Omit<AppScheduleSpec, "id"> {
+    id: string;
+    appId: string;
+    revision: number;
+    active: boolean;
+    state: string;
+    nextRunAt?: string;
+    retryAt?: string;
+    lastRunAt?: string;
+    lastError?: string;
+    attempts: number;
+}
+export declare class AppsApi {
+    private readonly mw;
+    constructor(mw: Mindwire);
+    list(): Promise<AppShortcut[]>;
+    get(id: string): Promise<AppShortcut>;
+    register(input: AppShortcutCreate): Promise<AppShortcutMutation>;
+    update(id: string, input: AppShortcutEdit): Promise<AppShortcutMutation>;
+    /** Ensures readiness on the owning computer; the client opens the returned URL. */
+    open(id: string): Promise<AppShortcut>;
+    /** Validates a plan for the owner's hosting adapter; does not deploy or charge. */
+    preparePublication(id: string): Promise<AppPublication>;
+    channels(): Promise<AppNotificationChannel[]>;
+    notifications(id: string, options?: {
+        channelIds?: string[];
+        rotate?: boolean;
+    }): Promise<AppShortcutMutation & {
+        credentialFile: string;
+    }>;
+    revokeNotificationAccess(id: string): Promise<{
+        revoked: boolean;
+    }>;
+    schedules(id: string): Promise<AppSchedule[]>;
+    saveSchedule(id: string, schedule: AppScheduleSpec): Promise<AppSchedule>;
+    deleteSchedule(id: string, scheduleId: string): Promise<{
+        removed: boolean;
+    }>;
+}

package/dist/bots.d.ts

@@ -0,0 +1,168 @@
+import type { Mindwire } from "./client.js";
+import type { WorkspaceRecord, WorkspaceSnapshot, WorkspaceChat, WorkspaceAgent, WorkspaceProject } from "./workspace.js";
+import type { Run } from "./types.js";
+export interface BotKnowledge {
+    id: string;
+    title: string;
+    content: string;
+}
+export interface Bot extends WorkspaceRecord {
+    agentId: string;
+    /** Default folder for new chats. The bot belongs to workspaceId and can work in its other projects. */
+    projectId: string;
+    name: string;
+    /** Saved palette-character ID; omitted/empty keeps the automatic avatar. */
+    icon?: string;
+    purpose: string;
+    instructions: string;
+    memory: string;
+    knowledge: BotKnowledge[];
+    /** Portable SKILL.md documents, loaded on demand. Requires botsVersion >= 6. */
+    skills?: string[] | null;
+    /** Creation-only plain harness: no Mindwire bot context, tools or skills. Requires botsVersion >= 7. */
+    raw?: boolean;
+    isMaster: boolean;
+    archived: boolean;
+    /** Applies to this bot's current and future chats, independent of its base engine. */
+    notificationsMuted?: boolean;
+}
+export interface BotInput {
+    icon?: string;
+    id?: string;
+    agentId: string;
+    projectId?: string;
+    name: string;
+    purpose?: string;
+    instructions?: string;
+    memory?: string;
+    knowledge?: BotKnowledge[];
+    skills?: string[];
+    /** Keep native harness behavior. Cannot be changed after creation or combined with bot context. */
+    raw?: boolean;
+}
+export interface BotEdit {
+    /** Base agent for future chats; existing chats retain their original engine. Requires botsVersion >= 5. */
+    agentId?: string;
+    icon?: string;
+    expectedRevision: number;
+    name?: string;
+    purpose?: string;
+    instructions?: string;
+    memory?: string;
+    knowledge?: BotKnowledge[];
+    archived?: boolean;
+    /** Replaces assigned SKILL.md documents; omit to preserve existing skills. */
+    skills?: string[];
+    notificationsMuted?: boolean;
+}
+export interface BotMutation {
+    bot: Bot;
+    snapshot: WorkspaceSnapshot;
+}
+export interface BotTaskInput {
+    requestId: string;
+    message: string;
+}
+export interface BotTaskRequest extends BotTaskInput {
+    chatId?: string;
+    title?: string;
+    projectId?: string;
+}
+export interface BotTask {
+    botId: string;
+    chatId: string;
+    run: Run;
+    messages?: {
+        role: string;
+        text: string;
+        createdAt: string;
+    }[];
+    output?: string;
+    historyError?: string;
+    interactions?: {
+        id: string;
+        kind: string;
+        title?: string;
+        detail?: string;
+        needsResponse: boolean;
+    }[];
+    tools?: {
+        name: string;
+        status?: string;
+    }[];
+    cancelRequested?: boolean;
+}
+export type BotPeerRoute = {
+    kind: "ssh";
+    host: string;
+    port: number;
+} | {
+    kind: "websocket";
+    url: string;
+};
+export interface BotPeerIdentity {
+    workspaceId: string;
+    publicKey: string;
+    hostKeyFingerprint: string;
+    port?: number;
+    sshPort?: number;
+    routes?: BotPeerRoute[];
+}
+export interface BotPeerInput {
+    name: string;
+    publicKey: string;
+    hostKeyFingerprint: string;
+    routes: BotPeerRoute[];
+    enabled?: boolean;
+}
+export interface BotPeer extends BotPeerInput {
+    workspaceId: string;
+}
+export interface BotPeerCheck {
+    workspaceId: string;
+    reachable: boolean;
+    error?: string;
+    addressRecovery?: boolean;
+}
+/** Saved bot identities, native tasks, and explicitly paired bot-control peers. */
+export declare class BotsApi {
+    private readonly mw;
+    constructor(mw: Mindwire);
+    list(options?: {
+        projectId?: string;
+        archived?: boolean;
+    }): Promise<Bot[]>;
+    get(id: string): Promise<Bot>;
+    ensure(agentId: string, projectId: string): Promise<BotMutation>;
+    create(input: BotInput): Promise<BotMutation>;
+    update(id: string, edit: BotEdit): Promise<BotMutation>;
+    chats(id: string): Promise<WorkspaceChat[]>;
+    createChat(id: string, input?: {
+        chatId?: string;
+        title?: string;
+        projectId?: string;
+    }): Promise<{
+        chatId: string;
+        snapshot: WorkspaceSnapshot;
+    }>;
+    agents(): Promise<{
+        agents: WorkspaceAgent[];
+        projects: WorkspaceProject[];
+    }>;
+    tasks(id: string): Promise<BotTask[]>;
+    /** Keep requestId stable when retrying a task after a lost acknowledgement. */
+    delegate(id: string, input: BotTaskRequest): Promise<BotTask>;
+    task(id: string, runId: string): Promise<BotTask>;
+    input(id: string, runId: string, input: BotTaskInput): Promise<BotTask>;
+    cancel(id: string, runId: string): Promise<BotTask>;
+    peerIdentity(): Promise<BotPeerIdentity>;
+    startPeerListener(port?: number): Promise<BotPeerIdentity>;
+    peers(): Promise<BotPeer[]>;
+    pair(workspaceId: string, input: BotPeerInput): Promise<BotPeer>;
+    revokePeer(workspaceId: string): Promise<{
+        ok: boolean;
+    }>;
+    /** Bounded peer handshake/discovery; does not start a bot task. */
+    checkPeer(workspaceId: string): Promise<BotPeerCheck>;
+    private taskPath;
+}

package/dist/{chunk-4XL565EU.js → chunk-P3JTWITC.js}

@@ -88,7 +88,7 @@ function computerPairingURI(invitation) {
 }
 
 // src/version.ts
-var SDK_VERSION = "0.1.52" ;
+var SDK_VERSION = "0.1.54" ;
 function versionAtLeast(actual, desired) {
   if (actual === desired) return true;
   if (!actual || !/^\d+\.\d+\.\d+$/.test(actual) || !/^\d+\.\d+\.\d+$/.test(desired)) return false;
@@ -1390,6 +1390,12 @@ var WorkspaceApi = class {
   projectIcon(projectId, path5) {
     return this.mw.http.request("GET", `/workspace/projects/${encodeURIComponent(projectId)}/icon`, { query: { path: path5 } });
   }
+  /** Upload a validated image (base64 content, at most 1 MB). Requires projectIconsVersion >= 2.
+   * Stores the image inside the project; set projects.put(..., { iconPath: result.path }) to select it.
+   */
+  uploadProjectIcon(projectId, image) {
+    return this.mw.http.request("POST", `/workspace/projects/${encodeURIComponent(projectId)}/icon`, { body: image });
+  }
   /** Start an operation owned by the daemon. The same ID/payload returns the existing operation. */
   createProject(request) {
     return this.mw.http.request("POST", "/workspace/projects", { body: request });
@@ -1490,6 +1496,160 @@ var GitAccessApi = class {
   }
 };
 
+// src/bots.ts
+var BotsApi = class {
+  constructor(mw) {
+    this.mw = mw;
+  }
+  mw;
+  list(options = {}) {
+    return this.mw.http.request("GET", "/bots", { query: { projectId: options.projectId, archived: options.archived ? "true" : void 0 } });
+  }
+  get(id) {
+    return this.mw.http.request("GET", `/bots/${encodeURIComponent(id)}`);
+  }
+  ensure(agentId, projectId) {
+    return this.mw.http.request("POST", "/bots/ensure", { body: { agentId, projectId } });
+  }
+  create(input) {
+    return this.mw.http.request("POST", "/bots", { body: input });
+  }
+  update(id, edit) {
+    return this.mw.http.request("PATCH", `/bots/${encodeURIComponent(id)}`, { body: edit });
+  }
+  chats(id) {
+    return this.mw.http.request("GET", `/bots/${encodeURIComponent(id)}/chats`);
+  }
+  createChat(id, input = {}) {
+    return this.mw.http.request("POST", `/bots/${encodeURIComponent(id)}/chats`, { body: input });
+  }
+  agents() {
+    return this.mw.http.request("GET", "/bots/agents");
+  }
+  tasks(id) {
+    return this.mw.http.request("GET", `/bots/${encodeURIComponent(id)}/tasks`);
+  }
+  /** Keep requestId stable when retrying a task after a lost acknowledgement. */
+  delegate(id, input) {
+    return this.mw.http.request("POST", `/bots/${encodeURIComponent(id)}/tasks`, { body: input });
+  }
+  task(id, runId) {
+    return this.mw.http.request("GET", this.taskPath(id, runId));
+  }
+  input(id, runId, input) {
+    return this.mw.http.request("POST", `${this.taskPath(id, runId)}/input`, { body: input });
+  }
+  cancel(id, runId) {
+    return this.mw.http.request("POST", `${this.taskPath(id, runId)}/cancel`);
+  }
+  peerIdentity() {
+    return this.mw.http.request("GET", "/bots/peers/identity");
+  }
+  startPeerListener(port) {
+    return this.mw.http.request("POST", "/bots/peers/listener", { body: { port } });
+  }
+  peers() {
+    return this.mw.http.request("GET", "/bots/peers");
+  }
+  pair(workspaceId, input) {
+    return this.mw.http.request("PUT", `/bots/peers/${encodeURIComponent(workspaceId)}`, { body: input });
+  }
+  revokePeer(workspaceId) {
+    return this.mw.http.request("DELETE", `/bots/peers/${encodeURIComponent(workspaceId)}`);
+  }
+  /** Bounded peer handshake/discovery; does not start a bot task. */
+  checkPeer(workspaceId) {
+    return this.mw.http.request("POST", `/bots/peers/${encodeURIComponent(workspaceId)}/check`, { body: {} });
+  }
+  taskPath(id, runId) {
+    return `/bots/${encodeURIComponent(id)}/tasks/${encodeURIComponent(runId)}`;
+  }
+};
+
+// src/apps.ts
+var AppsApi = class {
+  constructor(mw) {
+    this.mw = mw;
+  }
+  mw;
+  list() {
+    return this.mw.http.request("GET", "/apps");
+  }
+  get(id) {
+    return this.mw.http.request("GET", `/apps/${encodeURIComponent(id)}`);
+  }
+  register(input) {
+    return this.mw.http.request("POST", "/apps", { body: input });
+  }
+  update(id, input) {
+    return this.mw.http.request("PATCH", `/apps/${encodeURIComponent(id)}`, { body: input });
+  }
+  /** Ensures readiness on the owning computer; the client opens the returned URL. */
+  open(id) {
+    return this.mw.http.request("POST", `/apps/${encodeURIComponent(id)}/open`, { body: {} });
+  }
+  /** Validates a plan for the owner's hosting adapter; does not deploy or charge. */
+  preparePublication(id) {
+    return this.mw.http.request("POST", `/apps/${encodeURIComponent(id)}/publication/prepare`, { body: {} });
+  }
+  channels() {
+    return this.mw.http.request("GET", "/apps/channels");
+  }
+  notifications(id, options = {}) {
+    return this.mw.http.request("POST", `/apps/${encodeURIComponent(id)}/notifications`, { body: options });
+  }
+  revokeNotificationAccess(id) {
+    return this.mw.http.request("DELETE", `/apps/${encodeURIComponent(id)}/notifications/token`);
+  }
+  schedules(id) {
+    return this.mw.http.request("GET", `/apps/${encodeURIComponent(id)}/schedules`);
+  }
+  saveSchedule(id, schedule) {
+    return this.mw.http.request("POST", `/apps/${encodeURIComponent(id)}/schedules`, { body: schedule });
+  }
+  deleteSchedule(id, scheduleId) {
+    return this.mw.http.request("DELETE", `/apps/${encodeURIComponent(id)}/schedules/${encodeURIComponent(scheduleId)}`);
+  }
+};
+
+// src/integrations.ts
+var IntegrationsApi = class {
+  constructor(mw) {
+    this.mw = mw;
+  }
+  mw;
+  list() {
+    return this.mw.http.request("GET", "/integrations");
+  }
+  get(id) {
+    return this.mw.http.request("GET", this.path(id));
+  }
+  create(spec) {
+    return this.mw.http.request("POST", "/integrations", { body: spec });
+  }
+  /** Complete replacement with optimistic concurrency; omit credentials to preserve them. */
+  update(id, spec) {
+    return this.mw.http.request("PUT", this.path(id), { body: spec });
+  }
+  async delete(id) {
+    await this.mw.http.request("DELETE", this.path(id));
+  }
+  /** Sends to the configured destination, also useful as a connection test. */
+  send(id, text) {
+    return this.mw.http.request("POST", `${this.path(id)}/send`, { body: { text } });
+  }
+  /** Latest 100 redacted delivery receipts. */
+  events(id) {
+    return this.mw.http.request("GET", `${this.path(id)}/events`);
+  }
+  retry(id, eventId) {
+    return this.mw.http.request("POST", `${this.path(id)}/events/${encodeURIComponent(eventId)}/retry`);
+  }
+  path(id) {
+    return `/integrations/${encodeURIComponent(id)}`;
+  }
+};
+
 // src/surfaces.ts
 function savedDesktopID(id) {
   if (!/^(console|ds_[a-f0-9]{16})$/.test(id)) throw new Error("Invalid saved desktop ID.");
@@ -1988,7 +2148,7 @@ function daemonStartError(resolved, cause) {
       "  \u2022 check GitHub Release access so the SDK can download its matching daemon binary; or",
       "  \u2022 set MINDWIRE_DAEMON to a `mindwired` binary; or",
       "  \u2022 pass { baseUrl } to connect to a daemon you run yourself.",
-      "  \u2022 Working inside the mindwire monorepo? Run `go build -o /tmp/mindwired ./daemon/cmd/daemon` and set MINDWIRE_DAEMON.",
+      "  \u2022 Working inside the mindwire monorepo? Run `go -C packages/daemon build -o /tmp/mindwired ./cmd/daemon` and set MINDWIRE_DAEMON.",
       `(underlying error: ${cause.message})`
     ].join("\n");
   }
@@ -2085,6 +2245,9 @@ var handleByTransport = /* @__PURE__ */ new WeakMap();
 var Mindwire = class _Mindwire {
   /** Workspace registry: saved agent profiles, projects and chat relationships. */
   workspace;
+  bots;
+  apps;
+  integrations;
   surfaces;
   service;
   execution;
@@ -2125,6 +2288,9 @@ var Mindwire = class _Mindwire {
     });
     this.defaultAgent = opts.agent;
     this.workspace = new WorkspaceApi(this);
+    this.bots = new BotsApi(this);
+    this.apps = new AppsApi(this);
+    this.integrations = new IntegrationsApi(this);
     this.surfaces = new SurfacesApi(this);
     this.service = new ServiceApi(this);
     this.execution = new ExecutionApi(this);
@@ -2152,6 +2318,9 @@ var Mindwire = class _Mindwire {
     clone.http = this.http;
     clone.defaultAgent = agent;
     clone.workspace = new WorkspaceApi(clone);
+    clone.bots = new BotsApi(clone);
+    clone.apps = new AppsApi(clone);
+    clone.integrations = new IntegrationsApi(clone);
     clone.surfaces = new SurfacesApi(clone);
     clone.service = new ServiceApi(clone);
     clone.execution = new ExecutionApi(clone);
@@ -2323,6 +2492,20 @@ var Mindwire = class _Mindwire {
   deleteChat(chatId) {
     return this.http.request("DELETE", `/chats/${encodeURIComponent(chatId)}`);
   }
+  /** Read-only portable handoff context; requires crossAgentHandoffVersion >= 2. */
+  previewHandoff(chatId) {
+    return this.http.request("GET", `/chats/${encodeURIComponent(chatId)}/handoff`);
+  }
+  /** Start another agent in a linked conversation in the source project.
+   * Reuse the identical payload after a lost response to recover the same run. */
+  async handoff(chatId, request) {
+    const result = await this.http.request(
+      "POST",
+      `/chats/${encodeURIComponent(chatId)}/handoff`,
+      { body: request }
+    );
+    return { ...result, run: new Run(this.http, result.run) };
+  }
   /**
    * `POST /chats/{id}/fork` — clone a chat into a new id (generated when `newChatId` is omitted).
    * Codex and Claude preserve native context. `beforeMessageId` excludes that prompt and every
@@ -2869,7 +3052,7 @@ async function ensureComputer(directory, cliPath, patch = {}, onProgress, option
       if (!compatible(controller2) || !await processStateAlive(controller2)) {
         await ensureComputer(directory, cliPath, {}, onProgress, { ...options, waitForRoutes: false });
       }
-      const { changeComputerConnection } = await import('./connection-change-6E7QLJFC.js');
+      const { changeComputerConnection } = await import('./connection-change-RVS6XWTC.js');
       await changeComputerConnection(directory, Object.fromEntries(changed.map((key) => [key, patch[key]])), { signal: options.signal, onProgress });
       return computerClient(directory);
     }
@@ -2910,7 +3093,7 @@ async function ensureComputer(directory, cliPath, patch = {}, onProgress, option
     let controller = await readJSON(path4.join(directory, "computer-controller.json"));
     if (existing && controller && !compatible(controller) && await processStateAlive(controller)) {
       onProgress?.("Refreshing the background connection service\u2026");
-      const { handoffController } = await import('./controller-handoff-KNEQ5W6J.js');
+      const { handoffController } = await import('./controller-handoff-7EOSPHSD.js');
       await handoffController(directory, controller, config, await existing.computer.info());
       controller = void 0;
     }
@@ -2944,7 +3127,7 @@ async function ensureComputer(directory, cliPath, patch = {}, onProgress, option
   }
 }
 async function superviseComputer(directory) {
-  const controller = await import('./controller-566LDBZD.js');
+  const controller = await import('./controller-2WCEJ3F2.js');
   await controller.superviseComputer(directory);
 }
 async function stopComputer(directory, force = false) {
@@ -2969,5 +3152,5 @@ async function stopComputer(directory, force = false) {
 }
 
 export { CONTROLLER_PROTOCOL, ProviderConnectionError, RelayOutput, SDK_VERSION, acquireProcessLock, adoptProcess, adoptRelay, cloudflareCommand, computerClient, computerPairingQRData, computerPairingURI, currentProcessIdentity, defaultComputerConfig, defaultStateDirectory, directRoutes, ensureComputer, ensureDaemonBinary, hasCertificateError, ownChild, processIdentity, processStateAlive, providerFailure, providerNeedsAction, readJSON, startRelay, stopComputer, superviseComputer, versionAtLeast, websocketURL, writeJSON };
-//# sourceMappingURL=chunk-4XL565EU.js.map
-//# sourceMappingURL=chunk-4XL565EU.js.map
+//# sourceMappingURL=chunk-P3JTWITC.js.map
+//# sourceMappingURL=chunk-P3JTWITC.js.map