@akshar5/cohall 0.5.6 → 0.6.0

package/bin/cohall.js

@@ -16,10 +16,10 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
 // packages/protocol/src/index.ts
-import { Schema } from "effect";
-var version = "0.5.6", maxSocketPayloadBytes, bounded = (maxLength) => Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(maxLength)), optionalText = (maxLength) => Schema.String.check(Schema.isMaxLength(maxLength)), boundedArray = (schema, maxLength) => Schema.Array(schema).check(Schema.isMaxLength(maxLength)), count, uuid = (name) => Schema.String.check(Schema.isUUID(4)).pipe(Schema.brand(name)), isoTimestamp = (name) => Schema.String.check(Schema.isPattern(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?Z$/, {
+import { Effect, Schema } from "effect";
+var version = "0.6.0", maxSocketPayloadBytes, bounded = (maxLength) => Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(maxLength)), optionalText = (maxLength) => Schema.String.check(Schema.isMaxLength(maxLength)), boundedArray = (schema, maxLength) => Schema.Array(schema).check(Schema.isMaxLength(maxLength)), count, uuid = (name) => Schema.String.check(Schema.isUUID(4)).pipe(Schema.brand(name)), isoTimestamp = (name) => Schema.String.check(Schema.isPattern(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?Z$/, {
   expected: "an ISO-8601 UTC timestamp"
-})).pipe(Schema.brand(name)), DeviceId, ThreadId, MessageId, TaskId, AuthSessionId, OperationId, Timestamp, Platform, Provider, DeviceStatus, TaskStatus, OperationStatus, TaskTraceEventKind, MessageRole, ConnectionRole, AuthSession, CreatePairingInput, PairingCredential, ExchangePairingInput, SessionCredential, PairingResult, Capability, Workspace, Device, minimumDeviceOperationVersion = "0.5.0", parsedVersion = (value) => {
+})).pipe(Schema.brand(name)), BotId, Bot, DeviceId, ThreadId, MessageId, TaskId, AuthSessionId, OperationId, Timestamp, Platform, Provider, DeviceStatus, TaskStatus, OperationStatus, TaskTraceEventKind, MessageRole, ConnectionRole, AuthSession, CreatePairingInput, PairingCredential, ExchangePairingInput, SessionCredential, PairingResult, Capability, Workspace, Device, minimumDeviceOperationVersion = "0.5.0", parsedVersion = (value) => {
   const match = /^v?(\d+)\.(\d+)\.(\d+)(-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/.exec(value);
   if (match === null) {
     return;
@@ -50,10 +50,25 @@ var version = "0.5.6", maxSocketPayloadBytes, bounded = (maxLength) => Schema.St
     return;
   }
   throw new Error(`All-device upgrades require Cohall ${minimumDeviceOperationVersion} or newer on every device. Upgrade individually first: ${unsupported.map((device) => `${device.name} (${device.version})`).join(", ")}`);
-}, Thread, Message, Task, upgradeVersion, CreateUpgradeOperationsInput, DeviceOperation, TaskStatusCounts, ProviderUsage, DeviceUsage, UsageSummary, TaskTraceEvent, TaskTrace, ThreadContext, CreateTaskInput, SocketEvent, ErrorResponse, terminalTaskStatuses, isTerminalTask = (task) => terminalTaskStatuses.has(task.status), now = () => Timestamp.make(new Date().toISOString()), makeDeviceId = () => DeviceId.make(crypto.randomUUID()), makeThreadId = () => ThreadId.make(crypto.randomUUID()), makeMessageId = () => MessageId.make(crypto.randomUUID()), makeTaskId = () => TaskId.make(crypto.randomUUID()), makeAuthSessionId = () => AuthSessionId.make(crypto.randomUUID()), makeOperationId = () => OperationId.make(crypto.randomUUID()), decodeCreatePairingInput, decodeExchangePairingInput, decodeCreateTaskInput, decodeCreateUpgradeOperationsInput, decodeDevice, decodeSocketEvent;
+}, Thread, Message, validBotTarget = (input) => {
+  const provider = input.provider ?? (input.botId === undefined ? "codex" : "grok-bot");
+  if (provider === "grok-bot" && input.workspace !== undefined) {
+    return "Grok Bots use their own computer context; omit workspace";
+  }
+  return provider === "grok-bot" === (input.botId !== undefined) ? undefined : "The grok-bot provider requires botId; other providers cannot select a bot";
+}, Task, taskSlot = (task) => task.provider === "grok-bot" ? `grok-bot:${task.botId}` : "cli", upgradeVersion, CreateUpgradeOperationsInput, DeviceOperation, TaskStatusCounts, ProviderUsage, DeviceUsage, UsageSummary, TaskTraceEvent, TaskTrace, ThreadContext, CreateTaskInput, SocketEvent, ErrorResponse, terminalTaskStatuses, isTerminalTask = (task) => terminalTaskStatuses.has(task.status), now = () => Timestamp.make(new Date().toISOString()), makeDeviceId = () => DeviceId.make(crypto.randomUUID()), makeThreadId = () => ThreadId.make(crypto.randomUUID()), makeMessageId = () => MessageId.make(crypto.randomUUID()), makeTaskId = () => TaskId.make(crypto.randomUUID()), makeAuthSessionId = () => AuthSessionId.make(crypto.randomUUID()), makeOperationId = () => OperationId.make(crypto.randomUUID()), decodeCreatePairingInput, decodeExchangePairingInput, decodeCreateTaskInput = (input) => Schema.decodeUnknownEffect(CreateTaskInput)(input).pipe(Effect.map((task) => ({
+  ...task,
+  provider: task.provider ?? (task.botId === undefined ? "codex" : "grok-bot")
+}))), decodeCreateUpgradeOperationsInput, decodeDevice, decodeSocketEvent;
 var init_src = __esm(() => {
   maxSocketPayloadBytes = 1024 * 1024;
   count = Schema.Int.check(Schema.isBetween({ minimum: 0, maximum: Number.MAX_SAFE_INTEGER }));
+  BotId = bounded(256).pipe(Schema.brand("BotId"));
+  Bot = Schema.Struct({
+    id: BotId,
+    name: bounded(128),
+    description: Schema.optionalKey(optionalText(512))
+  });
   DeviceId = uuid("DeviceId");
   ThreadId = uuid("ThreadId");
   MessageId = uuid("MessageId");
@@ -62,7 +77,7 @@ var init_src = __esm(() => {
   OperationId = uuid("OperationId");
   Timestamp = isoTimestamp("Timestamp");
   Platform = Schema.Literals(["darwin", "linux", "windows", "unknown"]);
-  Provider = Schema.Literals(["codex", "claude-code", "opencode"]);
+  Provider = Schema.Literals(["codex", "claude-code", "opencode", "grok-bot"]);
   DeviceStatus = Schema.Literals(["online", "busy", "offline"]);
   TaskStatus = Schema.Literals([
     "queued",
@@ -127,7 +142,8 @@ var init_src = __esm(() => {
     platform: Platform,
     architecture: bounded(64),
     status: DeviceStatus,
-    providers: boundedArray(Provider, 3),
+    providers: boundedArray(Provider, Provider.literals.length),
+    bots: Schema.optionalKey(boundedArray(Bot, 256)),
     capabilities: boundedArray(Capability, 64),
     workspaces: boundedArray(Workspace, 64),
     version: bounded(32),
@@ -157,6 +173,7 @@ var init_src = __esm(() => {
     prompt: bounded(131072),
     context: Schema.optionalKey(optionalText(131072)),
     provider: Provider,
+    botId: Schema.optionalKey(BotId),
     status: TaskStatus,
     sourceDeviceId: Schema.optionalKey(DeviceId),
     targetDeviceId: DeviceId,
@@ -169,7 +186,7 @@ var init_src = __esm(() => {
     updatedAt: Timestamp,
     startedAt: Schema.optionalKey(Timestamp),
     completedAt: Schema.optionalKey(Timestamp)
-  });
+  }).check(Schema.makeFilter(validBotTarget));
   upgradeVersion = Schema.String.check(Schema.isPattern(/^(?:latest|v?\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?)$/, {
     expected: "latest or an exact semantic version"
   }));
@@ -208,12 +225,12 @@ var init_src = __esm(() => {
     deviceName: bounded(128),
     tasks: count,
     byStatus: TaskStatusCounts,
-    byProvider: boundedArray(ProviderUsage, 3)
+    byProvider: boundedArray(ProviderUsage, Provider.literals.length)
   });
   UsageSummary = Schema.Struct({
     retainedTasks: count,
     byStatus: TaskStatusCounts,
-    byProvider: boundedArray(ProviderUsage, 3),
+    byProvider: boundedArray(ProviderUsage, Provider.literals.length),
     devices: boundedArray(DeviceUsage, 256)
   });
   TaskTraceEvent = Schema.Struct({
@@ -226,6 +243,7 @@ var init_src = __esm(() => {
     threadId: ThreadId,
     status: TaskStatus,
     provider: Provider,
+    botId: Schema.optionalKey(BotId),
     sourceDeviceId: Schema.optionalKey(DeviceId),
     targetDevice: Device,
     parentTaskId: Schema.optionalKey(TaskId),
@@ -237,7 +255,7 @@ var init_src = __esm(() => {
     events: boundedArray(TaskTraceEvent, 100),
     truncated: Schema.Boolean,
     error: Schema.optionalKey(optionalText(16384))
-  });
+  }).check(Schema.makeFilter(validBotTarget));
   ThreadContext = Schema.Struct({
     thread: Thread,
     messages: boundedArray(Message, 20),
@@ -250,15 +268,20 @@ var init_src = __esm(() => {
     prompt: bounded(131072),
     context: Schema.optionalKey(optionalText(131072)),
     provider: Schema.optionalKey(Provider),
+    botId: Schema.optionalKey(BotId),
     targetDeviceId: Schema.optionalKey(DeviceId),
     parentTaskId: Schema.optionalKey(TaskId),
     workspace: Schema.optionalKey(bounded(4096))
-  });
+  }).check(Schema.makeFilter(validBotTarget));
   SocketEvent = Schema.TaggedUnion({
     Authenticate: { token: bounded(256) },
     Connected: { serverVersion: bounded(32), connectedAt: Timestamp },
     DeviceHello: { device: Device },
-    DeviceHeartbeat: { deviceId: DeviceId, status: DeviceStatus },
+    DeviceHeartbeat: {
+      deviceId: DeviceId,
+      status: DeviceStatus,
+      bots: Schema.optionalKey(boundedArray(Bot, 256))
+    },
     TaskAssigned: { task: Task },
     TaskAccepted: { taskId: TaskId },
     TaskFinished: {
@@ -287,25 +310,24 @@ var init_src = __esm(() => {
   ]);
   decodeCreatePairingInput = Schema.decodeUnknownEffect(CreatePairingInput);
   decodeExchangePairingInput = Schema.decodeUnknownEffect(ExchangePairingInput);
-  decodeCreateTaskInput = Schema.decodeUnknownEffect(CreateTaskInput);
   decodeCreateUpgradeOperationsInput = Schema.decodeUnknownEffect(CreateUpgradeOperationsInput);
   decodeDevice = Schema.decodeUnknownEffect(Device);
   decodeSocketEvent = Schema.decodeUnknownEffect(SocketEvent);
 });
 
 // apps/relay/src/config.ts
-import { Effect as Effect10, Schema as Schema10 } from "effect";
-import { access as access5, chmod as chmod6, mkdir as mkdir6, readFile as readFile5, writeFile as writeFile7 } from "node:fs/promises";
-import { homedir as homedir5, platform as platform4 } from "node:os";
-import { join as join7, resolve as resolve3 } from "node:path";
+import { Effect as Effect12, Schema as Schema12 } from "effect";
+import { access as access5, chmod as chmod7, mkdir as mkdir7, readFile as readFile5, writeFile as writeFile7 } from "node:fs/promises";
+import { homedir as homedir5, platform as platform5 } from "node:os";
+import { join as join8, resolve as resolve4 } from "node:path";
 var RelayConfiguration, defaultDataDirectory = () => {
-  if (platform4() === "win32") {
-    return join7(process.env.LOCALAPPDATA ?? join7(homedir5(), "AppData", "Local"), "Cohall");
+  if (platform5() === "win32") {
+    return join8(process.env.LOCALAPPDATA ?? join8(homedir5(), "AppData", "Local"), "Cohall");
   }
-  if (platform4() === "darwin") {
-    return join7(homedir5(), "Library", "Application Support", "Cohall", "relay");
+  if (platform5() === "darwin") {
+    return join8(homedir5(), "Library", "Application Support", "Cohall", "relay");
   }
-  return join7(process.env.XDG_DATA_HOME ?? join7(homedir5(), ".local", "share"), "cohall");
+  return join8(process.env.XDG_DATA_HOME ?? join8(homedir5(), ".local", "share"), "cohall");
 }, generatedToken = () => Array.from(crypto.getRandomValues(new Uint8Array(32)), (value) => value.toString(16).padStart(2, "0")).join(""), tokenFrom = async (path) => {
   if (await access5(path).then(() => true).catch(() => false)) {
     return (await readFile5(path, "utf8")).trim();
@@ -313,8 +335,8 @@ var RelayConfiguration, defaultDataDirectory = () => {
   const token = generatedToken();
   await writeFile7(path, `${token}
 `, { mode: 384 });
-  if (platform4() !== "win32") {
-    await chmod6(path, 384);
+  if (platform5() !== "win32") {
+    await chmod7(path, 384);
   }
   return token;
 }, booleanEnvironment = (name) => {
@@ -328,16 +350,16 @@ var RelayConfiguration, defaultDataDirectory = () => {
   throw new Error(`${name} must be true or false`);
 }, isLoopback2 = (host) => host === "127.0.0.1" || host === "localhost" || host === "::1", loadEnvironmentConfiguration;
 var init_config = __esm(() => {
-  RelayConfiguration = Schema10.Struct({
-    host: Schema10.NonEmptyString,
-    port: Schema10.Int.check(Schema10.isBetween({ minimum: 1, maximum: 65535 })),
-    token: Schema10.String.check(Schema10.isMinLength(32)),
-    dataDirectory: Schema10.NonEmptyString,
-    databasePath: Schema10.NonEmptyString,
-    allowRemote: Schema10.Boolean,
-    historyTaskLimit: Schema10.Int.check(Schema10.isBetween({ minimum: 100, maximum: 1e5 }))
+  RelayConfiguration = Schema12.Struct({
+    host: Schema12.NonEmptyString,
+    port: Schema12.Int.check(Schema12.isBetween({ minimum: 1, maximum: 65535 })),
+    token: Schema12.String.check(Schema12.isMinLength(32)),
+    dataDirectory: Schema12.NonEmptyString,
+    databasePath: Schema12.NonEmptyString,
+    allowRemote: Schema12.Boolean,
+    historyTaskLimit: Schema12.Int.check(Schema12.isBetween({ minimum: 100, maximum: 1e5 }))
   });
-  loadEnvironmentConfiguration = Effect10.tryPromise({
+  loadEnvironmentConfiguration = Effect12.tryPromise({
     try: async () => {
       const host = process.env.COHALL_RELAY_HOST ?? "127.0.0.1";
       const port = Number(process.env.COHALL_RELAY_PORT ?? "8787");
@@ -345,22 +367,22 @@ var init_config = __esm(() => {
       if (!isLoopback2(host) && !allowRemote) {
         throw new Error("Remote relay binding is disabled. Use a private network or TLS reverse proxy, then set COHALL_RELAY_ALLOW_REMOTE=true.");
       }
-      const dataDirectory = resolve3(process.env.COHALL_DATA_DIR ?? defaultDataDirectory());
-      await mkdir6(dataDirectory, { recursive: true, mode: 448 });
-      if (platform4() !== "win32") {
-        await chmod6(dataDirectory, 448);
+      const dataDirectory = resolve4(process.env.COHALL_DATA_DIR ?? defaultDataDirectory());
+      await mkdir7(dataDirectory, { recursive: true, mode: 448 });
+      if (platform5() !== "win32") {
+        await chmod7(dataDirectory, 448);
       }
-      const token = process.env.COHALL_TOKEN ?? await tokenFrom(join7(dataDirectory, "owner-token"));
+      const token = process.env.COHALL_TOKEN ?? await tokenFrom(join8(dataDirectory, "owner-token"));
       if (token.length < 32) {
         throw new Error("The Cohall relay owner token must be at least 32 characters");
       }
       const historyTaskLimit = Number(process.env.COHALL_HISTORY_TASK_LIMIT ?? "1000");
-      return Schema10.decodeUnknownSync(RelayConfiguration)({
+      return Schema12.decodeUnknownSync(RelayConfiguration)({
         host,
         port,
         token,
         dataDirectory,
-        databasePath: join7(dataDirectory, "cohall.db"),
+        databasePath: join8(dataDirectory, "cohall.db"),
         allowRemote,
         historyTaskLimit
       });
@@ -540,18 +562,18 @@ __export(exports_store, {
   RelayStore: () => exports_store,
   PersistenceError: () => PersistenceError
 });
-import { Context as Context2, Effect as Effect11, Layer as Layer2, Schema as Schema11 } from "effect";
+import { Context as Context2, Effect as Effect13, Layer as Layer2, Schema as Schema13 } from "effect";
 import { createHash as createHash2, randomBytes } from "node:crypto";
 var PersistenceError, Service2, operationError = (operation) => (cause) => new PersistenceError({
   operation,
   message: cause instanceof Error ? cause.message : String(cause)
-}), decode = (operation, schema, value) => Schema11.decodeUnknownEffect(schema)(value).pipe(Effect11.mapError(operationError(operation))), threadFromRow = (row) => decode("RelayStore.decodeThread", Thread, {
+}), decode2 = (operation, schema, value) => Schema13.decodeUnknownEffect(schema)(value).pipe(Effect13.mapError(operationError(operation))), threadFromRow = (row) => decode2("RelayStore.decodeThread", Thread, {
   id: row.id,
   title: row.title,
   createdAt: row.created_at,
   updatedAt: row.updated_at,
   ...row.default_device_id === null ? {} : { defaultDeviceId: row.default_device_id }
-}), messageFromRow = (row) => decode("RelayStore.decodeMessage", Message, {
+}), messageFromRow = (row) => decode2("RelayStore.decodeMessage", Message, {
   id: row.id,
   threadId: row.thread_id,
   role: row.role === "tool" ? "agent" : row.role,
@@ -560,7 +582,7 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
   createdAt: row.created_at,
   ...row.task_id === null ? {} : { taskId: row.task_id },
   ...row.device_id === null ? {} : { deviceId: row.device_id }
-}), deviceFromRow = (row) => decode("RelayStore.decodeDevice", Device, {
+}), deviceFromRow = (row) => decode2("RelayStore.decodeDevice", Device, {
   id: row.id,
   name: row.name,
   hostname: row.hostname,
@@ -568,16 +590,18 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
   architecture: row.architecture,
   status: row.status,
   providers: JSON.parse(row.providers_json),
+  ...row.bots_json === null ? {} : { bots: JSON.parse(row.bots_json) },
   capabilities: JSON.parse(row.capabilities_json),
   workspaces: JSON.parse(row.workspaces_json),
   version: row.version,
   lastSeenAt: row.last_seen_at,
   ...row.connected_at === null ? {} : { connectedAt: row.connected_at }
-}), taskFromRow = (row) => decode("RelayStore.decodeTask", Task, {
+}), taskFromRow = (row) => decode2("RelayStore.decodeTask", Task, {
   id: row.id,
   threadId: row.thread_id,
   prompt: row.prompt,
   provider: row.provider,
+  ...row.bot_id === null ? {} : { botId: row.bot_id },
   status: row.status,
   targetDeviceId: row.target_device_id,
   createdAt: row.created_at,
@@ -591,7 +615,7 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
   ...row.error === null ? {} : { error: row.error },
   ...row.started_at === null ? {} : { startedAt: row.started_at },
   ...row.completed_at === null ? {} : { completedAt: row.completed_at }
-}), operationFromRow = (row) => decode("RelayStore.decodeOperation", DeviceOperation, {
+}), operationFromRow = (row) => decode2("RelayStore.decodeOperation", DeviceOperation, {
   id: row.id,
   kind: row.kind,
   status: row.status,
@@ -611,17 +635,17 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
   completed: 0,
   failed: 0,
   cancelled: 0
-}), taskTraceEventFromRow = (row) => decode("RelayStore.decodeTaskTraceEvent", TaskTraceEvent, {
+}), taskTraceEventFromRow = (row) => decode2("RelayStore.decodeTaskTraceEvent", TaskTraceEvent, {
   kind: row.kind,
   at: row.created_at,
   ...row.detail === null ? {} : { detail: row.detail }
-}), rolesFromRow = (row) => Schema11.decodeUnknownSync(Schema11.Array(ConnectionRole))(JSON.parse(row.roles_json)), authSessionFromRow = (row) => {
+}), rolesFromRow = (row) => Schema13.decodeUnknownSync(Schema13.Array(ConnectionRole))(JSON.parse(row.roles_json)), authSessionFromRow = (row) => {
   const roles = rolesFromRow(row);
   const role = roles[0];
-  return role === undefined ? Effect11.fail(new PersistenceError({
+  return role === undefined ? Effect13.fail(new PersistenceError({
     operation: "RelayStore.decodeAuthSession",
     message: `Session ${row.id} has no role`
-  })) : decode("RelayStore.decodeAuthSession", AuthSession, {
+  })) : decode2("RelayStore.decodeAuthSession", AuthSession, {
     id: row.id,
     label: row.label,
     role,
@@ -641,6 +665,8 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
       return "Claude Code";
     case "opencode":
       return "OpenCode";
+    case "grok-bot":
+      return "Grok Bot";
   }
 }, recentWithin = (items, byteBudget) => {
   const encoder = new TextEncoder;
@@ -713,22 +739,22 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
   };
   const queryTask = (taskId) => db.query("SELECT * FROM tasks WHERE id = ?").get(taskId);
   const queryOperation = (operationId) => db.query("SELECT * FROM device_operations WHERE id = ?").get(operationId);
-  const getTask = Effect11.fn("RelayStore.getTask")(function* (taskId) {
-    const row = yield* Effect11.try({
+  const getTask = Effect13.fn("RelayStore.getTask")(function* (taskId) {
+    const row = yield* Effect13.try({
       try: () => queryTask(taskId),
       catch: operationError("RelayStore.getTask")
     });
     if (row === null) {
-      return yield* Effect11.fail(new PersistenceError({
+      return yield* Effect13.fail(new PersistenceError({
         operation: "RelayStore.getTask",
         message: `Unknown task ${taskId}`
       }));
     }
     return yield* taskFromRow(row);
   });
-  const traceTask = Effect11.fn("RelayStore.traceTask")(function* (taskId) {
+  const traceTask = Effect13.fn("RelayStore.traceTask")(function* (taskId) {
     const task = yield* getTask(taskId);
-    const [deviceRow, eventRows] = yield* Effect11.try({
+    const [deviceRow, eventRows] = yield* Effect13.try({
       try: () => [
         db.query("SELECT * FROM devices WHERE id = ?").get(task.targetDeviceId),
         db.query(`SELECT * FROM (
@@ -739,20 +765,21 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
       catch: operationError("RelayStore.traceTask")
     });
     if (deviceRow === null) {
-      return yield* Effect11.fail(new PersistenceError({
+      return yield* Effect13.fail(new PersistenceError({
         operation: "RelayStore.traceTask.device",
         message: `Unknown target device ${task.targetDeviceId}`
       }));
     }
     const targetDevice = yield* deviceFromRow(deviceRow);
     const selectedRows = eventRows.slice(-100);
-    const recordedEvents = yield* Effect11.forEach(selectedRows, taskTraceEventFromRow);
+    const recordedEvents = yield* Effect13.forEach(selectedRows, taskTraceEventFromRow);
     const events = recordedEvents.length === 0 ? derivedTraceEvents(task) : recordedEvents;
     return TaskTrace.make({
       taskId: task.id,
       threadId: task.threadId,
       status: task.status,
       provider: task.provider,
+      ...task.botId === undefined ? {} : { botId: task.botId },
       targetDevice,
       createdAt: task.createdAt,
       updatedAt: task.updatedAt,
@@ -766,15 +793,15 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
       ...task.error === undefined ? {} : { error: task.error }
     });
   });
-  const listDevices = Effect11.fn("RelayStore.listDevices")(function* () {
-    const rows = yield* Effect11.try({
+  const listDevices = Effect13.fn("RelayStore.listDevices")(function* () {
+    const rows = yield* Effect13.try({
       try: () => db.query("SELECT * FROM devices WHERE forgotten_at IS NULL ORDER BY name COLLATE NOCASE, id").all(),
       catch: operationError("RelayStore.listDevices")
     });
-    return yield* Effect11.forEach(rows, deviceFromRow);
+    return yield* Effect13.forEach(rows, deviceFromRow);
   });
-  const usage = Effect11.fn("RelayStore.usage")(function* () {
-    const rows = yield* Effect11.try({
+  const usage = Effect13.fn("RelayStore.usage")(function* () {
+    const rows = yield* Effect13.try({
       try: () => db.query(`SELECT tasks.target_device_id AS device_id, devices.name AS device_name,
                     tasks.status, tasks.provider, COUNT(*) AS tasks
              FROM tasks
@@ -788,9 +815,9 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
     const devices = new Map;
     let retainedTasks = 0;
     for (const row of rows) {
-      const status = Schema11.decodeUnknownSync(TaskStatus)(row.status);
-      const provider = Schema11.decodeUnknownSync(Provider)(row.provider);
-      const deviceId = Schema11.decodeUnknownSync(DeviceId)(row.device_id);
+      const status = Schema13.decodeUnknownSync(TaskStatus)(row.status);
+      const provider = Schema13.decodeUnknownSync(Provider)(row.provider);
+      const deviceId = Schema13.decodeUnknownSync(DeviceId)(row.device_id);
       retainedTasks += row.tasks;
       totalStatus[status] += row.tasks;
       totalProviders.set(provider, (totalProviders.get(provider) ?? 0) + row.tasks);
@@ -820,29 +847,29 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
       }))
     });
   });
-  const getOperation = Effect11.fn("RelayStore.getOperation")(function* (operationId) {
-    const row = yield* Effect11.try({
+  const getOperation = Effect13.fn("RelayStore.getOperation")(function* (operationId) {
+    const row = yield* Effect13.try({
       try: () => queryOperation(operationId),
       catch: operationError("RelayStore.getOperation")
     });
     if (row === null) {
-      return yield* Effect11.fail(new PersistenceError({
+      return yield* Effect13.fail(new PersistenceError({
         operation: "RelayStore.getOperation",
         message: `Unknown device operation ${operationId}`
       }));
     }
     return yield* operationFromRow(row);
   });
-  const listOperations = Effect11.fn("RelayStore.listOperations")(function* () {
-    const rows = yield* Effect11.try({
+  const listOperations = Effect13.fn("RelayStore.listOperations")(function* () {
+    const rows = yield* Effect13.try({
       try: () => db.query("SELECT * FROM device_operations ORDER BY created_at DESC, id DESC LIMIT 50").all(),
       catch: operationError("RelayStore.listOperations")
     });
-    return yield* Effect11.forEach(rows, operationFromRow);
+    return yield* Effect13.forEach(rows, operationFromRow);
   });
-  const createUpgradeOperations = Effect11.fn("RelayStore.createUpgradeOperations")(function* (input) {
+  const createUpgradeOperations = Effect13.fn("RelayStore.createUpgradeOperations")(function* (input) {
     const timestamp = now();
-    const operations = yield* Effect11.try({
+    const operations = yield* Effect13.try({
       try: () => db.transaction(() => {
         const devices = db.query("SELECT * FROM devices WHERE forgotten_at IS NULL ORDER BY name COLLATE NOCASE, id").all();
         if (devices.length === 0) {
@@ -882,15 +909,15 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
     });
     return operations;
   });
-  const pendingOperationsFor = Effect11.fn("RelayStore.pendingOperationsFor")(function* (deviceId) {
-    const rows = yield* Effect11.try({
+  const pendingOperationsFor = Effect13.fn("RelayStore.pendingOperationsFor")(function* (deviceId) {
+    const rows = yield* Effect13.try({
       try: () => db.query(`SELECT * FROM device_operations WHERE target_device_id = ? AND status = 'queued'
              ORDER BY created_at, id LIMIT 10`).all(deviceId),
       catch: operationError("RelayStore.pendingOperationsFor")
     });
-    return yield* Effect11.forEach(rows, operationFromRow);
+    return yield* Effect13.forEach(rows, operationFromRow);
   });
-  const transitionOperation = Effect11.fn("RelayStore.transitionOperation")(function* (operationId, expected, status, result, error) {
+  const transitionOperation = Effect13.fn("RelayStore.transitionOperation")(function* (operationId, expected, status, result, error) {
     const current = yield* getOperation(operationId);
     if (!expected.includes(current.status)) {
       return current;
@@ -898,7 +925,7 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
     const timestamp = now();
     const completed = status === "completed" || status === "failed" ? timestamp : undefined;
     const placeholders = expected.map(() => "?").join(", ");
-    yield* Effect11.try({
+    yield* Effect13.try({
       try: () => db.transaction(() => {
         const updated = db.query(`UPDATE device_operations
                SET status = ?, result = ?, error = ?, updated_at = ?, completed_at = ?
@@ -911,23 +938,23 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
     });
     return yield* getOperation(operationId);
   });
-  const requireOperationTarget = Effect11.fn("RelayStore.requireOperationTarget")(function* (operationId, deviceId) {
+  const requireOperationTarget = Effect13.fn("RelayStore.requireOperationTarget")(function* (operationId, deviceId) {
     const operation = yield* getOperation(operationId);
     if (operation.targetDeviceId !== deviceId) {
-      return yield* Effect11.fail(new PersistenceError({
+      return yield* Effect13.fail(new PersistenceError({
         operation: "RelayStore.requireOperationTarget",
         message: `Device ${deviceId} cannot update operation ${operationId}`
       }));
     }
     return operation;
   });
-  const assignOperation = Effect11.fn("RelayStore.assignOperation")(function* (operationId) {
+  const assignOperation = Effect13.fn("RelayStore.assignOperation")(function* (operationId) {
     const current = yield* getOperation(operationId);
     if (current.status !== "queued") {
       return current;
     }
     const timestamp = now();
-    yield* Effect11.try({
+    yield* Effect13.try({
       try: () => db.query(`UPDATE device_operations SET status = 'assigned', updated_at = ?
              WHERE id = ? AND status = 'queued'
                AND NOT EXISTS (
@@ -943,19 +970,19 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
     });
     return yield* getOperation(operationId);
   });
-  const acceptOperation = (operationId, deviceId) => requireOperationTarget(operationId, deviceId).pipe(Effect11.flatMap(() => transitionOperation(operationId, ["assigned"], "running")));
-  const finishOperation = (operationId, deviceId, result) => requireOperationTarget(operationId, deviceId).pipe(Effect11.flatMap(() => transitionOperation(operationId, ["queued", "assigned", "running"], "completed", result)));
-  const failOperation = (operationId, deviceId, error) => requireOperationTarget(operationId, deviceId).pipe(Effect11.flatMap(() => transitionOperation(operationId, ["queued", "assigned", "running"], "failed", undefined, error)));
+  const acceptOperation = (operationId, deviceId) => requireOperationTarget(operationId, deviceId).pipe(Effect13.flatMap(() => transitionOperation(operationId, ["assigned"], "running")));
+  const finishOperation = (operationId, deviceId, result) => requireOperationTarget(operationId, deviceId).pipe(Effect13.flatMap(() => transitionOperation(operationId, ["queued", "assigned", "running"], "completed", result)));
+  const failOperation = (operationId, deviceId, error) => requireOperationTarget(operationId, deviceId).pipe(Effect13.flatMap(() => transitionOperation(operationId, ["queued", "assigned", "running"], "failed", undefined, error)));
   const abandonOperation = (operationId) => transitionOperation(operationId, ["queued", "assigned", "running"], "failed", undefined, "Abandoned by the relay owner");
-  const requeueOperationsFor = Effect11.fn("RelayStore.requeueOperationsFor")(function* (deviceId) {
-    yield* Effect11.try({
+  const requeueOperationsFor = Effect13.fn("RelayStore.requeueOperationsFor")(function* (deviceId) {
+    yield* Effect13.try({
       try: () => db.query(`UPDATE device_operations SET status = 'queued', updated_at = ?
              WHERE target_device_id = ? AND status IN ('assigned', 'running')`).run(now(), deviceId),
       catch: operationError("RelayStore.requeueOperationsFor")
     });
   });
-  const forgetDevice = Effect11.fn("RelayStore.forgetDevice")(function* (deviceId) {
-    const row = yield* Effect11.try({
+  const forgetDevice = Effect13.fn("RelayStore.forgetDevice")(function* (deviceId) {
+    const row = yield* Effect13.try({
       try: () => db.transaction(() => {
         const device = db.query("SELECT * FROM devices WHERE id = ? AND forgotten_at IS NULL").get(deviceId);
         if (device === null) {
@@ -982,8 +1009,8 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
     });
     return yield* deviceFromRow(row);
   });
-  const recover = Effect11.fn("RelayStore.recover")(function* () {
-    yield* Effect11.try({
+  const recover = Effect13.fn("RelayStore.recover")(function* () {
+    yield* Effect13.try({
       try: () => db.transaction(() => {
         const timestamp = now();
         const interrupted = db.query("SELECT id FROM tasks WHERE status IN ('assigned', 'running')").all();
@@ -1001,52 +1028,54 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
       catch: operationError("RelayStore.recover")
     });
   });
-  const upsertDevice = Effect11.fn("RelayStore.upsertDevice")(function* (device) {
-    yield* Effect11.try({
+  const upsertDevice = Effect13.fn("RelayStore.upsertDevice")(function* (device) {
+    yield* Effect13.try({
       try: () => db.query(`INSERT INTO devices (
             id, name, hostname, platform, architecture, status, providers_json,
-            capabilities_json, workspaces_json, version, last_seen_at, connected_at
-          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            capabilities_json, workspaces_json, version, last_seen_at, connected_at, bots_json
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
           ON CONFLICT(id) DO UPDATE SET
             name = excluded.name, hostname = excluded.hostname, platform = excluded.platform,
             architecture = excluded.architecture, status = excluded.status,
-            providers_json = excluded.providers_json, capabilities_json = excluded.capabilities_json,
+            providers_json = excluded.providers_json, bots_json = excluded.bots_json,
+            capabilities_json = excluded.capabilities_json,
             workspaces_json = excluded.workspaces_json, version = excluded.version,
             last_seen_at = excluded.last_seen_at, connected_at = excluded.connected_at,
-            forgotten_at = NULL`).run(device.id, device.name, device.hostname, device.platform, device.architecture, device.status, JSON.stringify(device.providers), JSON.stringify(device.capabilities), JSON.stringify(device.workspaces), device.version, device.lastSeenAt, device.connectedAt ?? null),
+            forgotten_at = NULL`).run(device.id, device.name, device.hostname, device.platform, device.architecture, device.status, JSON.stringify(device.providers), JSON.stringify(device.capabilities), JSON.stringify(device.workspaces), device.version, device.lastSeenAt, device.connectedAt ?? null, device.bots === undefined ? null : JSON.stringify(device.bots)),
       catch: operationError("RelayStore.upsertDevice")
     });
     return device;
   });
-  const updateDeviceStatus = Effect11.fn("RelayStore.updateDeviceStatus")(function* (deviceId, status) {
+  const updateDeviceStatus = Effect13.fn("RelayStore.updateDeviceStatus")(function* (deviceId, status, bots) {
     const timestamp = now();
-    const result = yield* Effect11.try({
-      try: () => db.query("UPDATE devices SET status = ?, last_seen_at = ? WHERE id = ?").run(status, timestamp, deviceId),
+    const result = yield* Effect13.try({
+      try: () => db.query("UPDATE devices SET status = ?, last_seen_at = ?, bots_json = COALESCE(?, bots_json) WHERE id = ?").run(status, timestamp, bots === undefined ? null : JSON.stringify(bots), deviceId),
       catch: operationError("RelayStore.updateDeviceStatus")
     });
     if (result.changes !== 1) {
-      return yield* Effect11.fail(new PersistenceError({
+      return yield* Effect13.fail(new PersistenceError({
         operation: "RelayStore.updateDeviceStatus",
         message: `Unknown device ${deviceId}`
       }));
     }
     const row = db.query("SELECT * FROM devices WHERE id = ?").get(deviceId);
     if (row === null) {
-      return yield* Effect11.fail(new PersistenceError({
+      return yield* Effect13.fail(new PersistenceError({
         operation: "RelayStore.updateDeviceStatus.read",
         message: `Device ${deviceId} disappeared after update`
       }));
     }
     return yield* deviceFromRow(row);
   });
-  const createDelegation2 = Effect11.fn("RelayStore.createDelegation")(function* (input, targetDeviceId, sourceDeviceId, providerSessionId) {
+  const createDelegation2 = Effect13.fn("RelayStore.createDelegation")(function* (input, targetDeviceId, sourceDeviceId, providerSessionId) {
     const timestamp = now();
     const threadId = input.threadId ?? makeThreadId();
     const task = Task.make({
       id: makeTaskId(),
       threadId,
       prompt: input.prompt,
-      provider: input.provider ?? "codex",
+      provider: input.provider ?? (input.botId === undefined ? "codex" : "grok-bot"),
+      ...input.botId === undefined ? {} : { botId: input.botId },
       status: "queued",
       targetDeviceId,
       createdAt: timestamp,
@@ -1073,7 +1102,7 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
       taskId: task.id,
       ...sourceDeviceId === undefined ? {} : { deviceId: sourceDeviceId }
     });
-    yield* Effect11.try({
+    yield* Effect13.try({
       try: () => db.transaction(() => {
         const outstanding = db.query(`SELECT COUNT(*) AS count FROM tasks WHERE target_device_id = ?
                AND status IN ('queued', 'assigned', 'running', 'cancelling')`).get(targetDeviceId);
@@ -1087,9 +1116,9 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
         }
         db.query(`INSERT INTO tasks (
               id, thread_id, prompt, context, provider, status, source_device_id,
-              target_device_id, parent_task_id, workspace, provider_session_id,
+              target_device_id, parent_task_id, workspace, provider_session_id, bot_id,
               created_at, updated_at
-            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(task.id, task.threadId, task.prompt, task.context ?? null, task.provider, task.status, task.sourceDeviceId ?? null, task.targetDeviceId, task.parentTaskId ?? null, task.workspace ?? null, task.providerSessionId ?? null, task.createdAt, task.updatedAt);
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(task.id, task.threadId, task.prompt, task.context ?? null, task.provider, task.status, task.sourceDeviceId ?? null, task.targetDeviceId, task.parentTaskId ?? null, task.workspace ?? null, task.providerSessionId ?? null, task.botId ?? null, task.createdAt, task.updatedAt);
         recordTaskTraceEvent(task.id, "queued", "Relay accepted the task", timestamp);
         db.query(`INSERT INTO messages (
               id, thread_id, role, kind, author_id, author_name, content, created_at,
@@ -1101,18 +1130,18 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
     });
     return task;
   });
-  const threadContext2 = Effect11.fn("RelayStore.threadContext")(function* (threadId) {
-    const threadRow = yield* Effect11.try({
+  const threadContext2 = Effect13.fn("RelayStore.threadContext")(function* (threadId) {
+    const threadRow = yield* Effect13.try({
       try: () => db.query("SELECT * FROM threads WHERE id = ?").get(threadId),
       catch: operationError("RelayStore.threadContext.thread")
     });
     if (threadRow === null) {
-      return yield* Effect11.fail(new PersistenceError({
+      return yield* Effect13.fail(new PersistenceError({
         operation: "RelayStore.threadContext",
         message: `Unknown thread ${threadId}`
       }));
     }
-    const [messageRows, taskRows] = yield* Effect11.try({
+    const [messageRows, taskRows] = yield* Effect13.try({
       try: () => [
         db.query(`SELECT * FROM (
                  SELECT * FROM messages WHERE thread_id = ?
@@ -1125,10 +1154,10 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
       ],
       catch: operationError("RelayStore.threadContext.items")
     });
-    const [thread, messages, tasks] = yield* Effect11.all([
+    const [thread, messages, tasks] = yield* Effect13.all([
       threadFromRow(threadRow),
-      Effect11.forEach(messageRows.slice(-20), messageFromRow),
-      Effect11.forEach(taskRows.slice(-20), taskFromRow)
+      Effect13.forEach(messageRows.slice(-20), messageFromRow),
+      Effect13.forEach(taskRows.slice(-20), taskFromRow)
     ]);
     const recentMessages = recentWithin(messages, 256 * 1024);
     const recentTasks = recentWithin(tasks, 768 * 1024);
@@ -1139,22 +1168,22 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
       truncated: messageRows.length > 20 || taskRows.length > 20 || recentMessages.truncated || recentTasks.truncated
     });
   });
-  const pendingTasksFor = Effect11.fn("RelayStore.pendingTasksFor")(function* (deviceId) {
-    const rows = yield* Effect11.try({
+  const pendingTasksFor = Effect13.fn("RelayStore.pendingTasksFor")(function* (deviceId) {
+    const rows = yield* Effect13.try({
       try: () => db.query(`SELECT * FROM tasks WHERE target_device_id = ?
            AND status IN ('queued', 'cancelling') ORDER BY created_at, id LIMIT 100`).all(deviceId),
       catch: operationError("RelayStore.pendingTasksFor")
     });
-    return yield* Effect11.forEach(rows, taskFromRow);
+    return yield* Effect13.forEach(rows, taskFromRow);
   });
-  const transition = Effect11.fn("RelayStore.transition")(function* (taskId, expected, update, event) {
+  const transition = Effect13.fn("RelayStore.transition")(function* (taskId, expected, update, event) {
     const current = yield* getTask(taskId);
     if (!expected.includes(current.status)) {
       return current;
     }
     const placeholders = expected.map(() => "?").join(", ");
     const timestamp = now();
-    yield* Effect11.try({
+    yield* Effect13.try({
       try: () => db.transaction(() => {
         const result = db.query(`UPDATE tasks SET status = ?, provider_session_id = ?, result = ?, error = ?,
              started_at = ?, completed_at = ?, updated_at = ?
@@ -1170,24 +1199,26 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
     });
     return yield* getTask(taskId);
   });
-  const assignTask = Effect11.fn("RelayStore.assignTask")(function* (taskId) {
+  const assignTask = Effect13.fn("RelayStore.assignTask")(function* (taskId) {
     const current = yield* getTask(taskId);
     if (current.status !== "queued") {
       return current;
     }
     const timestamp = now();
-    yield* Effect11.try({
+    yield* Effect13.try({
       try: () => db.transaction(() => {
         const result = db.query(`UPDATE tasks SET status = 'assigned', updated_at = ?
                WHERE id = ? AND status = 'queued' AND NOT EXISTS (
                  SELECT 1 FROM tasks active
                  WHERE active.target_device_id = ? AND active.id <> ?
+                   AND CASE WHEN active.provider = 'grok-bot'
+                     THEN 'grok-bot:' || active.bot_id ELSE 'cli' END = ?
                    AND active.status IN ('assigned', 'running', 'cancelling')
                ) AND NOT EXISTS (
                  SELECT 1 FROM device_operations active
                  WHERE active.target_device_id = ?
                    AND active.status IN ('assigned', 'running')
-               )`).run(timestamp, taskId, current.targetDeviceId, taskId, current.targetDeviceId);
+               )`).run(timestamp, taskId, current.targetDeviceId, taskId, taskSlot(current), current.targetDeviceId);
         if (result.changes === 1) {
           recordTaskTraceEvent(taskId, "assigned", "Relay dispatched the task over the device WebSocket", timestamp);
         }
@@ -1196,32 +1227,32 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
     });
     return yield* getTask(taskId);
   });
-  const requireTarget = Effect11.fn("RelayStore.requireTarget")(function* (taskId, deviceId) {
+  const requireTarget = Effect13.fn("RelayStore.requireTarget")(function* (taskId, deviceId) {
     const task = yield* getTask(taskId);
     if (task.targetDeviceId !== deviceId) {
-      return yield* Effect11.fail(new PersistenceError({
+      return yield* Effect13.fail(new PersistenceError({
         operation: "RelayStore.requireTarget",
         message: `Task ${taskId} belongs to another device`
       }));
     }
     return task;
   });
-  const terminal = Effect11.fn("RelayStore.terminal")(function* (taskId, deviceId, status, result, error, providerSessionId) {
+  const terminal = Effect13.fn("RelayStore.terminal")(function* (taskId, deviceId, status, result, error, providerSessionId) {
     const current = yield* requireTarget(taskId, deviceId);
     if (["completed", "failed", "cancelled"].includes(current.status)) {
       return current;
     }
     const timestamp = now();
-    yield* Effect11.try({
+    yield* Effect13.try({
       try: () => db.transaction(() => {
         const updated = db.query(`UPDATE tasks SET status = ?, result = ?, error = ?, provider_session_id = ?,
              completed_at = ?, updated_at = ? WHERE id = ?
-             AND status NOT IN ('completed', 'failed', 'cancelled')`).run(status, result ?? null, error ?? null, providerSessionId ?? current.providerSessionId ?? null, timestamp, timestamp, taskId);
+             AND status NOT IN ('completed', 'failed', 'cancelled')`).run(status, result ?? null, error ?? null, current.provider === "grok-bot" ? null : providerSessionId ?? current.providerSessionId ?? null, timestamp, timestamp, taskId);
         if (updated.changes !== 1) {
           return;
         }
         recordTaskTraceEvent(taskId, status, status === "completed" ? "Target device completed the task" : status === "failed" ? "Target device reported a task failure" : "Target device acknowledged cancellation", timestamp);
-        if (providerSessionId !== undefined) {
+        if (current.provider !== "grok-bot" && providerSessionId !== undefined) {
           db.query(`INSERT INTO provider_sessions (thread_id, device_id, provider, session_id, updated_at)
                VALUES (?, ?, ?, ?, ?)
                ON CONFLICT(thread_id, device_id, provider) DO UPDATE SET
@@ -1242,11 +1273,17 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
     });
     return yield* getTask(taskId);
   });
-  const requestCancellation = Effect11.fn("RelayStore.requestCancellation")(function* (taskId) {
+  const requestCancellation = Effect13.fn("RelayStore.requestCancellation")(function* (taskId) {
     const current = yield* getTask(taskId);
     if (["completed", "failed", "cancelled"].includes(current.status)) {
       return current;
     }
+    if (current.provider === "grok-bot" && current.status !== "queued") {
+      return yield* new PersistenceError({
+        operation: "RelayStore.requestCancellation",
+        message: "Stop this bot in Grok Bot; its gateway cannot cancel an individual Cohall request"
+      });
+    }
     if (current.status === "cancelling") {
       return current;
     }
@@ -1255,9 +1292,9 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
       status: "cancelling"
     }, { kind: "cancelling", detail: "Client requested task cancellation" });
   });
-  const requeueTasksFor = Effect11.fn("RelayStore.requeueTasksFor")(function* (deviceId) {
+  const requeueTasksFor = Effect13.fn("RelayStore.requeueTasksFor")(function* (deviceId) {
     const timestamp = now();
-    yield* Effect11.try({
+    yield* Effect13.try({
       try: () => db.transaction(() => {
         const interrupted = db.query(`SELECT id FROM tasks WHERE target_device_id = ?
                AND status IN ('assigned', 'running')`).all(deviceId);
@@ -1270,42 +1307,42 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
       catch: operationError("RelayStore.requeueTasksFor")
     });
   });
-  const sessionFor = Effect11.fn("RelayStore.sessionFor")(function* (threadId, deviceId, provider) {
-    const row = yield* Effect11.try({
+  const sessionFor = Effect13.fn("RelayStore.sessionFor")(function* (threadId, deviceId, provider) {
+    const row = yield* Effect13.try({
       try: () => db.query(`SELECT session_id FROM provider_sessions
            WHERE thread_id = ? AND device_id = ? AND provider = ?`).get(threadId, deviceId, provider),
       catch: operationError("RelayStore.sessionFor")
     });
     return row?.session_id;
   });
-  const createPairing = Effect11.fn("RelayStore.createPairing")(function* (input) {
+  const createPairing = Effect13.fn("RelayStore.createPairing")(function* (input) {
     const roles = [...new Set(input.roles)];
     if (roles.length === 0) {
-      return yield* Effect11.fail(new PersistenceError({
+      return yield* Effect13.fail(new PersistenceError({
         operation: "RelayStore.createPairing",
         message: "A pairing must allow at least one role"
       }));
     }
     const token = secret("pair");
     const expiresAt = new Date(Date.now() + 10 * 60 * 1000).toISOString();
-    yield* Effect11.try({
+    yield* Effect13.try({
       try: () => db.query(`INSERT INTO auth_pairings (token_hash, label, roles_json, expires_at, created_at)
            VALUES (?, ?, ?, ?, ?)`).run(tokenHash(token), input.label, JSON.stringify(roles), expiresAt, now()),
       catch: operationError("RelayStore.createPairing")
     });
     return PairingCredential.make({ token, expiresAt: Timestamp.make(expiresAt) });
   });
-  const exchangePairing2 = Effect11.fn("RelayStore.exchangePairing")(function* (token) {
+  const exchangePairing2 = Effect13.fn("RelayStore.exchangePairing")(function* (token) {
     const timestamp = now();
     const expiresAt = new Date(Date.now() + 90 * 24 * 60 * 60 * 1000).toISOString();
-    const created = yield* Effect11.try({
+    const created = yield* Effect13.try({
       try: () => db.transaction(() => {
         const pairing = db.query(`SELECT * FROM auth_pairings
              WHERE token_hash = ? AND used_at IS NULL AND expires_at > ?`).get(tokenHash(token), timestamp);
         if (pairing === null) {
           throw new Error("Pairing credential is invalid, expired, or already used");
         }
-        const roles = Schema11.decodeUnknownSync(Schema11.Array(ConnectionRole))(JSON.parse(pairing.roles_json));
+        const roles = Schema13.decodeUnknownSync(Schema13.Array(ConnectionRole))(JSON.parse(pairing.roles_json));
         const deviceId = roles.includes("device") ? makeDeviceId() : undefined;
         const consumed = db.query("UPDATE auth_pairings SET used_at = ? WHERE token_hash = ? AND used_at IS NULL").run(timestamp, pairing.token_hash);
         if (consumed.changes !== 1) {
@@ -1333,11 +1370,11 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
       })(),
       catch: operationError("RelayStore.exchangePairing")
     });
-    const credentials = yield* Effect11.forEach(created, ({ token: sessionToken, row }) => authSessionFromRow(row).pipe(Effect11.map((session) => ({ token: sessionToken, session }))));
+    const credentials = yield* Effect13.forEach(created, ({ token: sessionToken, row }) => authSessionFromRow(row).pipe(Effect13.map((session) => ({ token: sessionToken, session }))));
     return PairingResult.make({ credentials });
   });
-  const authenticateSession = Effect11.fn("RelayStore.authenticateSession")(function* (token, role) {
-    const row = yield* Effect11.try({
+  const authenticateSession = Effect13.fn("RelayStore.authenticateSession")(function* (token, role) {
+    const row = yield* Effect13.try({
       try: () => db.query(`SELECT * FROM auth_sessions
            WHERE token_hash = ? AND revoked_at IS NULL AND expires_at > ?`).get(tokenHash(token), now()),
       catch: operationError("RelayStore.authenticateSession")
@@ -1346,35 +1383,35 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
       return;
     }
     const lastSeenAt = now();
-    yield* Effect11.try({
+    yield* Effect13.try({
       try: () => db.query("UPDATE auth_sessions SET last_seen_at = ? WHERE id = ?").run(lastSeenAt, row.id),
       catch: operationError("RelayStore.authenticateSession.touch")
     });
     const session = yield* authSessionFromRow(row);
     return AuthSession.make({ ...session, lastSeenAt });
   });
-  const listAuthSessions = Effect11.fn("RelayStore.listAuthSessions")(function* () {
-    const rows = yield* Effect11.try({
+  const listAuthSessions = Effect13.fn("RelayStore.listAuthSessions")(function* () {
+    const rows = yield* Effect13.try({
       try: () => db.query("SELECT * FROM auth_sessions ORDER BY created_at DESC, id LIMIT 1000").all(),
       catch: operationError("RelayStore.listAuthSessions")
     });
-    return yield* Effect11.forEach(rows, authSessionFromRow);
+    return yield* Effect13.forEach(rows, authSessionFromRow);
   });
-  const revokeAuthSession = Effect11.fn("RelayStore.revokeAuthSession")(function* (sessionId) {
+  const revokeAuthSession = Effect13.fn("RelayStore.revokeAuthSession")(function* (sessionId) {
     const revokedAt = now();
-    const result = yield* Effect11.try({
+    const result = yield* Effect13.try({
       try: () => db.query("UPDATE auth_sessions SET revoked_at = ? WHERE id = ? AND revoked_at IS NULL").run(revokedAt, sessionId),
       catch: operationError("RelayStore.revokeAuthSession")
     });
     if (result.changes !== 1) {
-      return yield* Effect11.fail(new PersistenceError({
+      return yield* Effect13.fail(new PersistenceError({
         operation: "RelayStore.revokeAuthSession",
         message: `Unknown or already revoked session ${sessionId}`
       }));
     }
     const row = db.query("SELECT * FROM auth_sessions WHERE id = ?").get(sessionId);
     if (row === null) {
-      return yield* Effect11.fail(new PersistenceError({
+      return yield* Effect13.fail(new PersistenceError({
         operation: "RelayStore.revokeAuthSession.read",
         message: `Session ${sessionId} disappeared after revocation`
       }));
@@ -1387,7 +1424,7 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
     usage,
     forgetDevice,
     upsertDevice,
-    heartbeat: (deviceId, status) => updateDeviceStatus(deviceId, status),
+    heartbeat: (deviceId, status, bots) => updateDeviceStatus(deviceId, status, bots),
     markDeviceOffline: (deviceId) => updateDeviceStatus(deviceId, "offline"),
     createDelegation: createDelegation2,
     getTask,
@@ -1396,7 +1433,7 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
     pendingTasksFor,
     assignTask,
     rollbackAssignment: (taskId) => transition(taskId, ["assigned"], { status: "queued" }, { kind: "requeued", detail: "Target device was unavailable during dispatch" }),
-    acceptTask: (taskId, deviceId) => requireTarget(taskId, deviceId).pipe(Effect11.flatMap(() => transition(taskId, ["assigned"], { status: "running", startedAt: now() }, { kind: "running", detail: "Target device accepted the task and started the provider" }))),
+    acceptTask: (taskId, deviceId) => requireTarget(taskId, deviceId).pipe(Effect13.flatMap(() => transition(taskId, ["assigned"], { status: "running", startedAt: now() }, { kind: "running", detail: "Target device accepted the task and started the provider" }))),
     finishTask: (taskId, deviceId, result, providerSessionId) => terminal(taskId, deviceId, "completed", result, undefined, providerSessionId),
     failTask: (taskId, deviceId, error) => terminal(taskId, deviceId, "failed", undefined, error),
     acknowledgeCancellation: (taskId, deviceId) => terminal(taskId, deviceId, "cancelled"),
@@ -1419,7 +1456,7 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
     listAuthSessions,
     revokeAuthSession
   });
-}, migrate = (db) => Effect11.try({
+}, migrate = (db) => Effect13.try({
   try: () => {
     db.exec("PRAGMA journal_mode = WAL");
     db.exec("PRAGMA foreign_keys = ON");
@@ -1428,7 +1465,7 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
         CREATE TABLE IF NOT EXISTS devices (
           id TEXT PRIMARY KEY, name TEXT NOT NULL, hostname TEXT NOT NULL,
           platform TEXT NOT NULL, architecture TEXT NOT NULL, status TEXT NOT NULL,
-          providers_json TEXT NOT NULL, capabilities_json TEXT NOT NULL,
+          providers_json TEXT NOT NULL, bots_json TEXT, capabilities_json TEXT NOT NULL,
           workspaces_json TEXT NOT NULL, version TEXT NOT NULL, last_seen_at TEXT NOT NULL,
           connected_at TEXT, forgotten_at TEXT
         );
@@ -1446,7 +1483,7 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
         CREATE INDEX IF NOT EXISTS messages_thread_created ON messages(thread_id, created_at);
         CREATE TABLE IF NOT EXISTS tasks (
           id TEXT PRIMARY KEY, thread_id TEXT NOT NULL REFERENCES threads(id) ON DELETE CASCADE,
-          prompt TEXT NOT NULL, context TEXT, provider TEXT NOT NULL, status TEXT NOT NULL,
+          prompt TEXT NOT NULL, context TEXT, provider TEXT NOT NULL, bot_id TEXT, status TEXT NOT NULL,
           source_device_id TEXT REFERENCES devices(id),
           target_device_id TEXT NOT NULL REFERENCES devices(id), parent_task_id TEXT,
           workspace TEXT, provider_session_id TEXT, result TEXT, error TEXT,
@@ -1491,17 +1528,24 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
     if (!deviceColumns.some((column) => column.name === "forgotten_at")) {
       db.exec("ALTER TABLE devices ADD COLUMN forgotten_at TEXT");
     }
+    if (!deviceColumns.some((column) => column.name === "bots_json")) {
+      db.exec("ALTER TABLE devices ADD COLUMN bots_json TEXT");
+    }
+    const taskColumns = db.query("PRAGMA table_info(tasks)").all();
+    if (!taskColumns.some((column) => column.name === "bot_id")) {
+      db.exec("ALTER TABLE tasks ADD COLUMN bot_id TEXT");
+    }
   },
   catch: operationError("RelayStore.migrate")
-}), layer2 = (path, retainedTerminalTasks = 1000) => Layer2.effect(Service2, Effect11.acquireRelease(Effect11.try({
+}), layer2 = (path, retainedTerminalTasks = 1000) => Layer2.effect(Service2, Effect13.acquireRelease(Effect13.try({
   try: () => new Database(path),
   catch: operationError("RelayStore.open")
-}).pipe(Effect11.tap(migrate)), (db) => Effect11.sync(() => db.close())).pipe(Effect11.map((db) => makeService(db, retainedTerminalTasks)))), layerFromDatabase = (db) => Layer2.effect(Service2, migrate(db).pipe(Effect11.map(() => makeService(db))));
+}).pipe(Effect13.tap(migrate)), (db) => Effect13.sync(() => db.close())).pipe(Effect13.map((db) => makeService(db, retainedTerminalTasks)))), layerFromDatabase = (db) => Layer2.effect(Service2, migrate(db).pipe(Effect13.map(() => makeService(db))));
 var init_store = __esm(() => {
   init_src();
   init_database();
   init_store();
-  PersistenceError = class PersistenceError extends Schema11.TaggedErrorClass()("RelayStore.PersistenceError", { operation: Schema11.String, message: Schema11.String }) {
+  PersistenceError = class PersistenceError extends Schema13.TaggedErrorClass()("RelayStore.PersistenceError", { operation: Schema13.String, message: Schema13.String }) {
   };
   Service2 = class Service2 extends Context2.Service()("@cohall/RelayStore") {
   };
@@ -1511,13 +1555,14 @@ var init_store = __esm(() => {
 var exports_main = {};
 __export(exports_main, {
   runRelay: () => runRelay,
-  relayListenOptions: () => relayListenOptions
+  relayListenOptions: () => relayListenOptions,
+  chooseDevice: () => chooseDevice
 });
-import { Effect as Effect12, ManagedRuntime, Schema as Schema12 } from "effect";
+import { Effect as Effect14, ManagedRuntime, Schema as Schema14 } from "effect";
 import { createHash as createHash3, timingSafeEqual } from "node:crypto";
-import { access as access6, chmod as chmod7 } from "node:fs/promises";
+import { access as access6, chmod as chmod8 } from "node:fs/promises";
 import { createServer } from "node:http";
-import { platform as platform5 } from "node:os";
+import { platform as platform6 } from "node:os";
 import { WebSocketServer } from "ws";
 var RequestError, relayListenOptions = (configuration, environment = process.env, pid = process.pid) => {
   const listenPid = Number(environment.LISTEN_PID);
@@ -1544,7 +1589,7 @@ var RequestError, relayListenOptions = (configuration, environment = process.env
   if (request.method === "GET" || request.method === "HEAD") {
     return Promise.resolve(undefined);
   }
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     const chunks = [];
     let size = 0;
     const cleanup = () => {
@@ -1563,7 +1608,7 @@ var RequestError, relayListenOptions = (configuration, environment = process.env
     };
     const onEnd = () => {
       cleanup();
-      resolve4(Buffer.concat(chunks, size));
+      resolve5(Buffer.concat(chunks, size));
     };
     const onError = (cause) => {
       cleanup();
@@ -1612,18 +1657,18 @@ Content-Length: 0\r
   if ("destroy" in socket && typeof socket.destroy === "function") {
     socket.destroy();
   }
-}, body = (request, decode2) => Effect12.tryPromise({
+}, body = (request, decode3) => Effect14.tryPromise({
   try: () => request.json(),
   catch: () => new RequestError({ status: 400, message: "Expected a JSON request body" })
-}).pipe(Effect12.flatMap(decode2), Effect12.mapError((cause) => cause instanceof RequestError ? cause : new RequestError({ status: 400, message: String(cause).slice(0, 2048) }))), pathId = (schema, value) => Schema12.decodeUnknownEffect(schema)(value).pipe(Effect12.mapError(() => new RequestError({ status: 400, message: `Invalid identifier: ${value}` }))), scoreDevice = (device, input, sourceDeviceId) => {
+}).pipe(Effect14.flatMap(decode3), Effect14.mapError((cause) => cause instanceof RequestError ? cause : new RequestError({ status: 400, message: String(cause).slice(0, 2048) }))), pathId = (schema, value) => Schema14.decodeUnknownEffect(schema)(value).pipe(Effect14.mapError(() => new RequestError({ status: 400, message: `Invalid identifier: ${value}` }))), scoreDevice = (device, input, sourceDeviceId) => {
   const prompt = `${input.prompt} ${input.context ?? ""}`.toLowerCase();
   const needsXcode = /\b(xcode|ios|macos|swiftui|app store)\b/.test(prompt);
   const needsBrowser = /\b(browser|chrome|youtube|twitter|logged[- ]?in|signed[- ]?in|x\.com)\b/.test(prompt);
   return (device.status === "offline" ? 0 : 100) + (input.workspace !== undefined && device.workspaces.some((workspace) => input.workspace === workspace.path || input.workspace?.startsWith(`${workspace.path}/`)) ? 80 : 0) + (needsXcode && device.capabilities.some((capability) => capability.id === "xcode") ? 60 : 0) + (needsBrowser && device.capabilities.some((capability) => capability.id === "browser-session") ? 40 : 0) + (sourceDeviceId === device.id ? -5 : 0);
-}, chooseDevice = (input, sourceDeviceId) => Effect12.gen(function* () {
+}, chooseDevice = (input, sourceDeviceId) => Effect14.gen(function* () {
   const store = yield* exports_store.Service;
-  const devices = yield* store.listDevices().pipe(Effect12.mapError((cause) => new RequestError({ status: 500, message: cause.message })));
-  const provider = input.provider ?? "codex";
+  const devices = yield* store.listDevices().pipe(Effect14.mapError((cause) => new RequestError({ status: 500, message: cause.message })));
+  const provider = input.provider ?? (input.botId === undefined ? "codex" : "grok-bot");
   if (input.targetDeviceId !== undefined) {
     const target = devices.find((device) => device.id === input.targetDeviceId);
     if (target === undefined) {
@@ -1638,27 +1683,40 @@ Content-Length: 0\r
         message: `${target.name} does not advertise the ${provider} provider`
       });
     }
+    if (input.botId !== undefined && !target.bots?.some((bot) => bot.id === input.botId)) {
+      return yield* new RequestError({
+        status: 404,
+        message: `${target.name} does not advertise bot ${input.botId}; refresh the bot list`
+      });
+    }
     return target.id;
   }
-  const selected = devices.filter((device) => device.providers.includes(provider)).sort((left, right) => scoreDevice(right, input, sourceDeviceId) - scoreDevice(left, input, sourceDeviceId))[0];
+  const candidates = devices.filter((device) => device.providers.includes(provider) && (input.botId === undefined || device.bots?.some((bot) => bot.id === input.botId)));
+  if (input.botId !== undefined && candidates.length > 1) {
+    return yield* new RequestError({
+      status: 409,
+      message: `Bot ${input.botId} is advertised by more than one device; select a device`
+    });
+  }
+  const selected = candidates.sort((left, right) => scoreDevice(right, input, sourceDeviceId) - scoreDevice(left, input, sourceDeviceId))[0];
   if (selected === undefined) {
     return yield* new RequestError({
       status: 409,
-      message: `No Cohall device advertises the ${provider} provider`
+      message: input.botId === undefined ? `No Cohall device advertises the ${provider} provider` : `No Cohall device advertises bot ${input.botId}; refresh the bot list`
     });
   }
   return selected.id;
 }), runRelay = async () => {
-  const configuration = await Effect12.runPromise(loadEnvironmentConfiguration);
+  const configuration = await Effect14.runPromise(loadEnvironmentConfiguration);
   process.umask(63);
   const runtime = ManagedRuntime.make(exports_store.layer(configuration.databasePath, configuration.historyTaskLimit));
   const run2 = (effect) => runtime.runPromise(effect);
-  await run2(Effect12.gen(function* () {
+  await run2(Effect14.gen(function* () {
     const store = yield* exports_store.Service;
     yield* store.recover();
   }));
-  if (platform5() !== "win32" && await access6(configuration.databasePath).then(() => true).catch(() => false)) {
-    await chmod7(configuration.databasePath, 384);
+  if (platform6() !== "win32" && await access6(configuration.databasePath).then(() => true).catch(() => false)) {
+    await chmod8(configuration.databasePath, 384);
   }
   const hub = new Hub;
   let connections = 0;
@@ -1668,7 +1726,7 @@ Content-Length: 0\r
     if (ownerToken2(token)) {
       return "owner";
     }
-    return run2(Effect12.gen(function* () {
+    return run2(Effect14.gen(function* () {
       const store = yield* exports_store.Service;
       return yield* store.authenticateSession(token, role);
     })).catch(() => {
@@ -1683,7 +1741,7 @@ Content-Length: 0\r
     return authenticate(authorization.slice("Bearer ".length), "client");
   };
   const dispatch = async (task) => {
-    const assigned = await run2(Effect12.gen(function* () {
+    const assigned = await run2(Effect14.gen(function* () {
       const store = yield* exports_store.Service;
       return yield* store.assignTask(task.id);
     }));
@@ -1693,13 +1751,13 @@ Content-Length: 0\r
     if (hub.sendToDevice(assigned.targetDeviceId, SocketEvent.make({ _tag: "TaskAssigned", task: assigned }))) {
       return assigned;
     }
-    return run2(Effect12.gen(function* () {
+    return run2(Effect14.gen(function* () {
       const store = yield* exports_store.Service;
       return yield* store.rollbackAssignment(task.id);
     }));
   };
   const dispatchOperation = async (operation) => {
-    const assigned = await run2(Effect12.gen(function* () {
+    const assigned = await run2(Effect14.gen(function* () {
       const store = yield* exports_store.Service;
       return yield* store.assignOperation(operation.id);
     }));
@@ -1709,13 +1767,22 @@ Content-Length: 0\r
     if (hub.sendToDevice(assigned.targetDeviceId, SocketEvent.make({ _tag: "OperationAssigned", operation: assigned }))) {
       return assigned;
     }
-    return run2(Effect12.gen(function* () {
+    return run2(Effect14.gen(function* () {
       const store = yield* exports_store.Service;
       return yield* store.rollbackOperation(operation.id);
     }));
   };
-  const dispatchPending = async (deviceId) => {
-    const tasks = await run2(Effect12.gen(function* () {
+  const dispatchPendingOperations = async (deviceId) => {
+    const operations = await run2(Effect14.gen(function* () {
+      const store = yield* exports_store.Service;
+      return yield* store.pendingOperationsFor(deviceId);
+    }));
+    for (const operation of operations) {
+      await dispatchOperation(operation);
+    }
+  };
+  const dispatchPendingTasks = async (deviceId) => {
+    const tasks = await run2(Effect14.gen(function* () {
       const store = yield* exports_store.Service;
       return yield* store.pendingTasksFor(deviceId);
     }));
@@ -1726,13 +1793,10 @@ Content-Length: 0\r
         await dispatch(task);
       }
     }
-    const operations = await run2(Effect12.gen(function* () {
-      const store = yield* exports_store.Service;
-      return yield* store.pendingOperationsFor(deviceId);
-    }));
-    for (const operation of operations) {
-      await dispatchOperation(operation);
-    }
+  };
+  const dispatchPending = async (deviceId) => {
+    await dispatchPendingOperations(deviceId);
+    await dispatchPendingTasks(deviceId);
   };
   const sendError = (socket, code, message) => {
     socket.send(JSON.stringify(SocketEvent.make({
@@ -1742,10 +1806,10 @@ Content-Length: 0\r
     })));
   };
   const handleSocketEvent = async (socket, input) => {
-    const event = await Effect12.runPromise(Effect12.try({
+    const event = await Effect14.runPromise(Effect14.try({
       try: () => JSON.parse(socketText(input)),
       catch: () => new RequestError({ status: 400, message: "Invalid socket JSON" })
-    }).pipe(Effect12.flatMap(decodeSocketEvent))).catch((cause) => {
+    }).pipe(Effect14.flatMap(decodeSocketEvent))).catch((cause) => {
       sendError(socket, "invalid_event", cause instanceof Error ? cause.message : String(cause));
       return;
     });
@@ -1802,11 +1866,12 @@ Content-Length: 0\r
         socket.close(4009, "Device is already connected");
         return;
       }
-      await run2(Effect12.gen(function* () {
+      await run2(Effect14.gen(function* () {
         const store = yield* exports_store.Service;
         yield* store.upsertDevice(device);
       }));
-      await dispatchPending(device.id);
+      await dispatchPendingTasks(device.id);
+      await dispatchPendingOperations(device.id);
       return;
     }
     const deviceId = hub.deviceId(socket);
@@ -1820,12 +1885,12 @@ Content-Length: 0\r
     const settleOperation = (operationId) => {
       socket.send(JSON.stringify(SocketEvent.make({ _tag: "OperationSettled", operationId })));
     };
-    const processed = await run2(Effect12.gen(function* () {
+    const processed = await run2(Effect14.gen(function* () {
       const store = yield* exports_store.Service;
       switch (event._tag) {
         case "DeviceHeartbeat":
           if (event.deviceId === deviceId) {
-            yield* store.heartbeat(deviceId, event.status === "busy" ? "busy" : "online");
+            yield* store.heartbeat(deviceId, event.status === "busy" ? "busy" : "online", event.bots);
           }
           return;
         case "TaskAccepted":
@@ -1876,7 +1941,7 @@ Content-Length: 0\r
       return json({ ok: true, version });
     }
     if (url.pathname === "/api/auth/pair" && request.method === "POST") {
-      return run2(Effect12.gen(function* () {
+      return run2(Effect14.gen(function* () {
         const store = yield* exports_store.Service;
         const input = yield* body(request, decodeExchangePairingInput);
         return yield* store.exchangePairing(input.token);
@@ -1891,7 +1956,7 @@ Content-Length: 0\r
       return json({ error: "Owner token required" }, 403);
     }
     const sourceDeviceId = principal === "owner" ? undefined : principal.deviceId;
-    const effect = Effect12.gen(function* () {
+    const effect = Effect14.gen(function* () {
       const store = yield* exports_store.Service;
       if (url.pathname === "/api/auth/pairings" && request.method === "POST") {
         const input = yield* body(request, decodeCreatePairingInput);
@@ -1919,7 +1984,7 @@ Content-Length: 0\r
       if (url.pathname === "/api/operations/upgrades" && request.method === "POST") {
         const input = yield* body(request, decodeCreateUpgradeOperationsInput);
         const operations = yield* store.createUpgradeOperations(input);
-        return json(yield* Effect12.tryPromise(() => Promise.all(operations.map(dispatchOperation))), 201);
+        return json(yield* Effect14.tryPromise(() => Promise.all(operations.map(dispatchOperation))), 201);
       }
       const abandonOperation = url.pathname.match(/^\/api\/operations\/([^/]+)\/abandon$/);
       if (request.method === "POST" && abandonOperation?.[1] !== undefined) {
@@ -1946,9 +2011,9 @@ Content-Length: 0\r
       if (url.pathname === "/api/tasks" && request.method === "POST") {
         const input = yield* body(request, decodeCreateTaskInput);
         const target = yield* chooseDevice(input, sourceDeviceId);
-        const providerSessionId = input.threadId === undefined ? undefined : yield* store.sessionFor(input.threadId, target, input.provider ?? "codex");
+        const providerSessionId = input.threadId === undefined || input.provider === "grok-bot" ? undefined : yield* store.sessionFor(input.threadId, target, input.provider ?? "codex");
         const task2 = yield* store.createDelegation(input, target, sourceDeviceId, providerSessionId);
-        return json(yield* Effect12.tryPromise(() => dispatch(task2)), 201);
+        return json(yield* Effect14.tryPromise(() => dispatch(task2)), 201);
       }
       const task = url.pathname.match(/^\/api\/tasks\/([^/]+)$/);
       if (request.method === "GET" && task?.[1] !== undefined) {
@@ -1972,8 +2037,8 @@ Content-Length: 0\r
         return json(yield* store.threadContext(yield* pathId(ThreadId, thread[1])));
       }
       return yield* new RequestError({ status: 404, message: "Route not found" });
-    }).pipe(Effect12.mapError((cause) => cause instanceof RequestError ? cause : new RequestError({
-      status: cause._tag !== "RelayStore.PersistenceError" ? 500 : cause.message.startsWith("Unknown") ? 404 : cause.message.includes("outstanding task limit") ? 429 : cause.message.includes("must be offline") || cause.message.includes("still has outstanding tasks") || cause.message.includes("upgrade operation in progress") || cause.message === "No Cohall devices are registered" || cause.message.startsWith("All-device operations support") ? 409 : 500,
+    }).pipe(Effect14.mapError((cause) => cause instanceof RequestError ? cause : new RequestError({
+      status: cause._tag !== "RelayStore.PersistenceError" ? 500 : cause.message.startsWith("Unknown") ? 404 : cause.message.includes("cannot cancel an individual Cohall request") ? 409 : cause.message.includes("outstanding task limit") ? 429 : cause.message.includes("must be offline") || cause.message.includes("still has outstanding tasks") || cause.message.includes("upgrade operation in progress") || cause.message === "No Cohall devices are registered" || cause.message.startsWith("All-device operations support") ? 409 : 500,
       message: cause.message
     })));
     return run2(effect).catch((cause) => cause instanceof RequestError ? json({ error: cause.status === 500 ? "Relay request failed" : cause.message }, cause.status) : json({ error: "Relay request failed" }, 500));
@@ -1981,7 +2046,8 @@ Content-Length: 0\r
   const websocketServer = new WebSocketServer({
     noServer: true,
     maxPayload: maxSocketPayloadBytes,
-    perMessageDeflate: false
+    perMessageDeflate: false,
+    allowSynchronousEvents: false
   });
   websocketServer.on("connection", (rawSocket) => {
     const socket = rawSocket;
@@ -2046,7 +2112,7 @@ Content-Length: 0\r
       if (deviceId === undefined) {
         return;
       }
-      run2(Effect12.gen(function* () {
+      run2(Effect14.gen(function* () {
         const store = yield* exports_store.Service;
         yield* store.requeueTasksFor(deviceId);
         yield* store.requeueOperationsFor(deviceId);
@@ -2074,11 +2140,11 @@ Content-Length: 0\r
       websocketServer.emit("connection", websocket, request);
     });
   });
-  await new Promise((resolve4, reject) => {
+  await new Promise((resolve5, reject) => {
     server.once("error", reject);
     server.listen(relayListenOptions(configuration), () => {
       server.off("error", reject);
-      resolve4();
+      resolve5();
     });
   });
   const address = server.address();
@@ -2093,7 +2159,7 @@ Content-Length: 0\r
     for (const socket of websocketServer.clients) {
       socket.close(1001, "Relay shutting down");
     }
-    await new Promise((resolve4) => server.close(() => resolve4()));
+    await new Promise((resolve5) => server.close(() => resolve5()));
     websocketServer.close();
     await runtime.dispose();
   };
@@ -2105,9 +2171,9 @@ var init_main = __esm(async () => {
   init_config();
   init_hub();
   init_store();
-  RequestError = class RequestError extends Schema12.TaggedErrorClass()("Relay.RequestError", {
-    status: Schema12.Int,
-    message: Schema12.String
+  RequestError = class RequestError extends Schema14.TaggedErrorClass()("Relay.RequestError", {
+    status: Schema14.Int,
+    message: Schema14.String
   }) {
   };
   if (false) {}
@@ -2115,7 +2181,7 @@ var init_main = __esm(async () => {
 
 // apps/device/src/main.ts
 init_src();
-import { Effect as Effect13 } from "effect";
+import { Effect as Effect15 } from "effect";
 
 // packages/client/src/index.ts
 init_src();
@@ -2129,7 +2195,7 @@ __export(exports_src, {
   RelayDecodeError: () => RelayDecodeError,
   RelayClient: () => exports_src
 });
-import { Context, Effect, Layer, Schema as Schema2 } from "effect";
+import { Context, Effect as Effect2, Layer, Schema as Schema2 } from "effect";
 
 class RelayRequestError extends Schema2.TaggedErrorClass()("RelayClient.RequestError", {
   operation: Schema2.String,
@@ -2188,8 +2254,8 @@ var responseMessage = async (response, operation) => {
 };
 var make = (options) => {
   const baseUrl = normalizeBaseUrl(options.baseUrl);
-  const request = (operation, path, schema, init) => Effect.gen(function* () {
-    const response = yield* Effect.tryPromise({
+  const request = (operation, path, schema, init) => Effect2.gen(function* () {
+    const response = yield* Effect2.tryPromise({
       try: (signal) => fetch(`${baseUrl}${path}`, {
         ...init,
         signal: AbortSignal.any([signal, AbortSignal.timeout(30000)]),
@@ -2205,17 +2271,17 @@ var make = (options) => {
       })
     });
     if (!response.ok) {
-      return yield* Effect.fail(new RelayRequestError({
+      return yield* Effect2.fail(new RelayRequestError({
         operation,
-        message: yield* Effect.promise(() => responseMessage(response, operation)),
+        message: yield* Effect2.promise(() => responseMessage(response, operation)),
         status: response.status
       }));
     }
-    const json = yield* Effect.tryPromise({
+    const json = yield* Effect2.tryPromise({
       try: () => jsonBody(response, operation),
       catch: (cause) => cause instanceof RelayDecodeError ? cause : new RelayDecodeError({ operation, message: String(cause) })
     });
-    return yield* Schema2.decodeUnknownEffect(schema)(json).pipe(Effect.mapError((cause) => new RelayDecodeError({ operation, message: String(cause) })));
+    return yield* Schema2.decodeUnknownEffect(schema)(json).pipe(Effect2.mapError((cause) => new RelayDecodeError({ operation, message: String(cause) })));
   });
   return Service.of({
     devices: () => request("RelayClient.devices", "/api/devices", Schema2.Array(Device)),
@@ -2242,9 +2308,9 @@ var make = (options) => {
     abandonOperation: (operationId) => request("RelayClient.abandonOperation", `/api/operations/${encodeURIComponent(operationId)}/abandon`, DeviceOperation, { method: "POST" })
   });
 };
-var exchangePairing = (baseUrl, input) => Effect.gen(function* () {
+var exchangePairing = (baseUrl, input) => Effect2.gen(function* () {
   const operation = "RelayClient.exchangePairing";
-  const response = yield* Effect.tryPromise({
+  const response = yield* Effect2.tryPromise({
     try: (signal) => fetch(`${normalizeBaseUrl(baseUrl)}/api/auth/pair`, {
       method: "POST",
       signal: AbortSignal.any([signal, AbortSignal.timeout(30000)]),
@@ -2257,17 +2323,17 @@ var exchangePairing = (baseUrl, input) => Effect.gen(function* () {
     })
   });
   if (!response.ok) {
-    return yield* Effect.fail(new RelayRequestError({
+    return yield* Effect2.fail(new RelayRequestError({
       operation,
-      message: yield* Effect.promise(() => responseMessage(response, operation)),
+      message: yield* Effect2.promise(() => responseMessage(response, operation)),
       status: response.status
     }));
   }
-  const json = yield* Effect.tryPromise({
+  const json = yield* Effect2.tryPromise({
     try: () => jsonBody(response, operation),
     catch: (cause) => cause instanceof RelayDecodeError ? cause : new RelayDecodeError({ operation, message: String(cause) })
   });
-  return yield* Schema2.decodeUnknownEffect(PairingResult)(json).pipe(Effect.mapError((cause) => new RelayDecodeError({ operation, message: String(cause) })));
+  return yield* Schema2.decodeUnknownEffect(PairingResult)(json).pipe(Effect2.mapError((cause) => new RelayDecodeError({ operation, message: String(cause) })));
 });
 var layer = (options) => Layer.succeed(Service, make(options));
 
@@ -2276,7 +2342,7 @@ init_src();
 
 // packages/providers/src/index.ts
 init_src();
-import { Effect as Effect2, Schema as Schema3 } from "effect";
+import { Effect as Effect3, Schema as Schema3 } from "effect";
 import { accessSync, constants } from "node:fs";
 import { chmod, mkdtemp, rm, writeFile } from "node:fs/promises";
 import { homedir, platform, tmpdir } from "node:os";
@@ -2341,8 +2407,8 @@ var findExecutable = (command) => {
   }
   return;
 };
-var available = (provider) => findExecutable(executables[provider]) !== undefined;
-var availableProviders = () => Provider.literals.filter(available);
+var available = (provider) => provider !== "grok-bot" && findExecutable(executables[provider]) !== undefined;
+var availableProviders = () => Provider.literals.filter((provider) => provider !== "grok-bot").filter(available);
 var boundedText = (stream, limit, onOverflow) => new Promise((resolve, reject) => {
   const chunks = [];
   let size = 0;
@@ -2642,7 +2708,7 @@ var terminateProcessTree = async (pid) => {
   process.kill(-pid, "SIGKILL");
   await waitForProcessGroup(pid, 1000);
 };
-var run = (options) => Effect2.tryPromise({
+var run = (options) => Effect3.tryPromise({
   try: async (signal) => {
     const executable = findExecutable(executables[options.provider]);
     if (executable === undefined) {
@@ -2660,7 +2726,8 @@ var run = (options) => Effect2.tryPromise({
         env: {
           ...providerEnvironment(),
           COHALL_PROVIDER: options.provider,
-          COHALL_THREAD_ID: options.threadId
+          COHALL_THREAD_ID: options.threadId,
+          ...options.taskId === undefined ? {} : { COHALL_TASK_ID: options.taskId }
         },
         detached: platform() !== "win32",
         stdio: ["pipe", "pipe", "pipe"]
@@ -2735,23 +2802,22 @@ var run = (options) => Effect2.tryPromise({
 });
 
 // apps/device/src/cli.ts
-import { Effect as Effect7, Schema as Schema8 } from "effect";
-import { access as access4, mkdir as mkdir5, readFile as readFile4, stat as stat3, writeFile as writeFile6 } from "node:fs/promises";
+import { Effect as Effect9, Schema as Schema10 } from "effect";
+import { access as access4, mkdir as mkdir6, readFile as readFile4, stat as stat3, writeFile as writeFile6 } from "node:fs/promises";
 import { homedir as homedir4 } from "node:os";
-import { dirname as dirname5, join as join6 } from "node:path";
+import { dirname as dirname6, join as join7, resolve as resolve3 } from "node:path";
 
 // skills/cohall/SKILL.md
 var SKILL_default = `---
 name: cohall
-description: Delegate work to an agent on another user-owned device through the Cohall CLI. Use when the user asks to run, research, or check something on another device, names a Cohall target such as @macbook or @server, or needs machine-local state or capabilities such as a signed-in browser, Xcode, Docker, deployment access, a repository checkout, or unavailable tools. Carry the relevant current-conversation context into the handoff automatically.
+description: Delegate through Cohall to another user-owned device or an existing Grok Bot. Use when the user names a Cohall target, asks to message one of their bots, or needs another machine's tools, files, or signed-in services. Carry relevant conversation context into the handoff.
 ---
 
 # Cohall
 
-Cohall sends a focused task to an agent running on another device. The target
+Cohall sends a focused task to a coding agent or an existing named Grok Bot. The target
 keeps its local files, credentials, browser state, provider login, skills, and
-permissions. The relay carries prompts, final results, and task state; it is not
-a lead agent.
+permissions. The relay carries prompts, final results, and task state.
 
 Use the installed \`cohall\` executable when it is available. Fall back to
 \`npx -y @akshar5/cohall\` only when Cohall is not installed globally.
@@ -2759,9 +2825,8 @@ Use the installed \`cohall\` executable when it is available. Fall back to
 ## Recognize cross-device requests
 
 Treat phrases such as “run this on my Mac,” “ask \`@server\`,” or “have the Linux
-machine check this” as target intent. The \`@name\` form is a Cohall device
-selector, not chat syntax supplied by the harness. Resolve it with \`cohall
-devices\`, then delegate the smallest useful outcome.
+machine check this” as target intent. Resolve computers with \`cohall devices\`
+and named bots with \`cohall bots\`, then delegate the smallest useful outcome.
 
 Good reasons to delegate include:
 
@@ -2805,8 +2870,9 @@ Do not delegate ordinary local work when the other device provides no advantage.
      --context 'Why: deployment 184 failed after 15:00 UTC. Known: local checks passed and the provider status page reported elevated errors. Need: determine whether the outage explains our failure, with primary-source links and contrary evidence.'
    \`\`\`
 
-   Providers are \`codex\`, \`claude-code\`, and \`opencode\`. Omit \`--provider\` to
-   use Codex. Omit \`--target\` only when Cohall may choose a matching device.
+   Coding providers are \`codex\`, \`claude-code\`, and \`opencode\`. Omit \`--provider\`
+   to use Codex on a computer; selecting a named bot infers \`grok-bot\`.
+   Omit \`--target\` only when Cohall may choose a matching computer.
 
 5. The command waits by default and returns JSON. Treat work as successful only
    when \`status\` is \`completed\`; use \`result\` in the current task. Report a
@@ -2822,9 +2888,43 @@ Do not delegate ordinary local work when the other device provides no advantage.
      --prompt 'Check whether yesterday’s deployment failed for the same reason.'
    \`\`\`
 
-When an agent running as a Cohall task delegates again, \`COHALL_THREAD_ID\`
-automatically carries the current thread. Pass \`--thread\` explicitly from an
-ordinary shell or a separate agent turn.
+When a coding agent running as a Cohall task delegates again, \`COHALL_THREAD_ID\`
+and \`COHALL_TASK_ID\` carry its thread and parent task. Pass \`--thread\` and
+\`--parent\` explicitly from a Grok Bot using the IDs in its handoff.
+
+## Message named bots
+
+1. Run \`cohall bots\` and choose a listed target. Use its qualified target when
+   names collide; discovery includes every available bot on configured hosts.
+2. Send the prompt and relevant context:
+
+   \`\`\`bash
+   cohall send @Research --prompt 'Find three project ideas worth exploring.'
+   cohall send '@cloud/Video ideas' --prompt 'Suggest an opening for the video.'
+   \`\`\`
+
+   Named bots use their existing Grok conversation and permissions. Omit
+   \`--workspace\`. A Cohall thread records the exchange; it does not create an
+   isolated Grok conversation.
+
+3. Reuse \`--thread <thread-id>\` for follow-ups. With an explicit thread and no
+   target, Cohall resumes its most recent root bot task. Select a computer
+   explicitly when delegating a child coding task:
+
+   \`\`\`bash
+   cohall delegate --target @cloud --provider codex \\
+     --thread <thread-id> --parent <task-id> --prompt 'Implement the selected idea.'
+   \`\`\`
+
+Different bots and the computer's coding agent can run concurrently. Each
+individual bot processes one Cohall request at a time.
+
+When receiving a Cohall request inside a Grok Bot, finish with the \`cohall reply\`
+command supplied in the handoff. Pass the final answer through \`--message-file\`
+or \`--message -\` on stdin, then reply normally in chat. Use \`--error\` if unable
+to finish. This local receipt is what returns the result to the sending device;
+a chat message alone does not complete the Cohall task. The receipt survives
+worker restarts and works while the relay is temporarily unreachable.
 
 ## Context and safety
 
@@ -2860,8 +2960,10 @@ unless cancelled:
 cohall cancel <task-id>
 \`\`\`
 
-Active cancellation is acknowledged by the target device; \`cancelling\` means
-the provider process has not confirmed termination yet.
+For coding agents, active cancellation is acknowledged by the target device;
+\`cancelling\` means the provider process has not confirmed termination yet.
+Queued bot tasks can be cancelled. Stop an active bot in Grok Bot; its gateway
+cannot safely cancel an individual Cohall request.
 
 ## Read shared context
 
@@ -2910,12 +3012,12 @@ Return the diagnostic failure to the user rather than claiming remote work ran.
 
 // apps/device/src/config.ts
 init_src();
-import { Effect as Effect3, Schema as Schema4 } from "effect";
+import { Effect as Effect4, Schema as Schema4 } from "effect";
 import { access, chmod as chmod2, mkdir, readFile, realpath, rename, writeFile as writeFile2 } from "node:fs/promises";
 import { homedir as homedir2, hostname, platform as platform2 } from "node:os";
 import { dirname, join as join2, resolve } from "node:path";
 var WorkspaceList = Schema4.Array(Schema4.NonEmptyString).check(Schema4.isMaxLength(64));
-var ProviderList = Schema4.Array(Provider).check(Schema4.isMinLength(1)).check(Schema4.isMaxLength(3));
+var ProviderList = Schema4.Array(Provider).check(Schema4.isMinLength(1)).check(Schema4.isMaxLength(Provider.literals.length));
 var Sandbox = Schema4.Literals(["read-only", "workspace-write", "danger-full-access"]);
 var StoredConfiguration = Schema4.Struct({
   version: Schema4.Literal(1),
@@ -2927,12 +3029,14 @@ var StoredConfiguration = Schema4.Struct({
   deviceToken: Schema4.optionalKey(Schema4.NonEmptyString),
   providers: Schema4.optionalKey(ProviderList),
   model: Schema4.optionalKey(Schema4.NonEmptyString),
-  sandbox: Schema4.optionalKey(Sandbox)
+  sandbox: Schema4.optionalKey(Sandbox),
+  grokGateway: Schema4.optionalKey(Schema4.NonEmptyString)
 });
 var ClientConfiguration = Schema4.Struct({
   relayUrl: Schema4.NonEmptyString,
   token: Schema4.NonEmptyString,
-  mcpThreadId: Schema4.optionalKey(Schema4.String)
+  mcpThreadId: Schema4.optionalKey(Schema4.String),
+  mcpTaskId: Schema4.optionalKey(Schema4.String)
 });
 var DeviceConfiguration = Schema4.Struct({
   relayUrl: Schema4.NonEmptyString,
@@ -2942,7 +3046,8 @@ var DeviceConfiguration = Schema4.Struct({
   workspaces: WorkspaceList,
   providers: Schema4.optionalKey(ProviderList),
   model: Schema4.optionalKey(Schema4.NonEmptyString),
-  sandbox: Schema4.optionalKey(Sandbox)
+  sandbox: Schema4.optionalKey(Sandbox),
+  grokGateway: Schema4.optionalKey(Schema4.NonEmptyString)
 });
 var defaultConfigDirectory = () => {
   if (platform2() === "win32") {
@@ -2978,7 +3083,7 @@ var normalizeRelayUrl = (input) => {
   url.pathname = "/";
   return url.toString().replace(/\/$/, "");
 };
-var parseWorkspaces = (workspaceList, workspaceJson) => Effect3.tryPromise({
+var parseWorkspaces = (workspaceList, workspaceJson) => Effect4.tryPromise({
   try: async () => {
     const values = workspaceJson === undefined ? workspaceList.split(",").map((workspace) => workspace.trim()).filter((workspace) => workspace.length > 0) : Schema4.decodeUnknownSync(WorkspaceList)(JSON.parse(workspaceJson));
     const canonical = await Promise.all(values.map((workspace) => realpath(resolve(workspace))));
@@ -3031,7 +3136,7 @@ var makeStoredConfiguration = async (input) => {
   const existing = await readStoredConfiguration();
   const relayUrl = normalizeRelayUrl(input.relayUrl);
   const retainedCredentials = credentialsForRelay(existing, relayUrl);
-  const canonicalWorkspaces = input.workspaces === undefined ? existing?.workspaces ?? [] : await Effect3.runPromise(parseWorkspaces("", JSON.stringify(input.workspaces)));
+  const canonicalWorkspaces = input.workspaces === undefined ? existing?.workspaces ?? [] : await Effect4.runPromise(parseWorkspaces("", JSON.stringify(input.workspaces)));
   const clientToken = input.clientToken ?? retainedCredentials.clientToken;
   const deviceToken = input.deviceToken ?? retainedCredentials.deviceToken;
   const providers = input.providers === "auto" ? undefined : input.providers ?? existing?.providers;
@@ -3045,7 +3150,8 @@ var makeStoredConfiguration = async (input) => {
     ...deviceToken === undefined ? {} : { deviceToken },
     ...providers === undefined ? {} : { providers },
     ...existing?.model === undefined ? {} : { model: existing.model },
-    ...existing?.sandbox === undefined ? {} : { sandbox: existing.sandbox }
+    ...existing?.sandbox === undefined ? {} : { sandbox: existing.sandbox },
+    ...existing?.grokGateway === undefined ? {} : { grokGateway: existing.grokGateway }
   });
 };
 var environmentWorkspaces = async (stored) => {
@@ -3054,7 +3160,7 @@ var environmentWorkspaces = async (stored) => {
   if (list === undefined && json === undefined) {
     return stored?.workspaces ?? [];
   }
-  return Effect3.runPromise(parseWorkspaces(list ?? "", json));
+  return Effect4.runPromise(parseWorkspaces(list ?? "", json));
 };
 var environmentProvider = () => process.env.COHALL_MODEL ?? process.env.COHALL_CODEX_MODEL;
 var environmentSandbox = () => {
@@ -3075,7 +3181,7 @@ var storedOrDefaults = async () => {
     workspaces: []
   });
 };
-var loadClientConfiguration = Effect3.tryPromise({
+var loadClientConfiguration = Effect4.tryPromise({
   try: async () => {
     const stored = await storedOrDefaults();
     const relayUrl = normalizeRelayUrl(process.env.COHALL_RELAY_URL ?? stored.relayUrl);
@@ -3086,12 +3192,13 @@ var loadClientConfiguration = Effect3.tryPromise({
     return ClientConfiguration.make({
       relayUrl,
       token,
-      ...process.env.COHALL_THREAD_ID === undefined ? {} : { mcpThreadId: process.env.COHALL_THREAD_ID }
+      ...process.env.COHALL_THREAD_ID === undefined ? {} : { mcpThreadId: process.env.COHALL_THREAD_ID },
+      ...process.env.COHALL_TASK_ID === undefined ? {} : { mcpTaskId: process.env.COHALL_TASK_ID }
     });
   },
   catch: (cause) => cause instanceof Error ? cause : new Error(String(cause))
 });
-var loadOwnerConfiguration = Effect3.tryPromise({
+var loadOwnerConfiguration = Effect4.tryPromise({
   try: async () => {
     const stored = await storedOrDefaults();
     const ownerTokenPath = join2(relayDataDirectory(), "owner-token");
@@ -3111,7 +3218,7 @@ var loadOwnerConfiguration = Effect3.tryPromise({
   },
   catch: (cause) => cause instanceof Error ? cause : new Error(String(cause))
 });
-var loadDeviceConfiguration = Effect3.tryPromise({
+var loadDeviceConfiguration = Effect4.tryPromise({
   try: async () => {
     const stored = await storedOrDefaults();
     const relayUrl = normalizeRelayUrl(process.env.COHALL_RELAY_URL ?? stored.relayUrl);
@@ -3126,6 +3233,7 @@ var loadDeviceConfiguration = Effect3.tryPromise({
     const model = environmentProvider() ?? stored.model;
     const sandbox = environmentSandbox() ?? stored.sandbox;
     const providers = environmentProviders(stored);
+    const grokGateway = process.env.COHALL_GROK_GATEWAY ?? stored.grokGateway;
     return DeviceConfiguration.make({
       relayUrl,
       token,
@@ -3134,7 +3242,8 @@ var loadDeviceConfiguration = Effect3.tryPromise({
       workspaces,
       ...providers === undefined ? {} : { providers },
       ...model === undefined ? {} : { model },
-      ...sandbox === undefined ? {} : { sandbox }
+      ...sandbox === undefined ? {} : { sandbox },
+      ...grokGateway === undefined ? {} : { grokGateway: resolve(grokGateway) }
     });
   },
   catch: (cause) => cause instanceof Error ? cause : new Error(String(cause))
@@ -3143,7 +3252,7 @@ var knownProviders = Provider.literals;
 
 // apps/device/src/delegation.ts
 init_src();
-import { Effect as Effect4, Schedule, Schema as Schema5 } from "effect";
+import { Effect as Effect5, Schedule, Schema as Schema5 } from "effect";
 
 class DeviceSelectionError extends Schema5.TaggedErrorClass()("Cohall.DeviceSelectionError", { message: Schema5.String, devices: Schema5.Array(Schema5.String) }) {
 }
@@ -3156,50 +3265,112 @@ var TaskResult = Schema5.Struct({
   status: TaskStatus,
   provider: Provider,
   target_device_id: DeviceId,
+  bot_id: Schema5.optionalKey(BotId),
   result: Schema5.optionalKey(Schema5.String),
   error: Schema5.optionalKey(Schema5.String)
 });
 var matchingDevices = (devices, target) => {
-  const normalized = target.replace(/^@/, "").toLowerCase();
-  const byId = devices.find((device) => device.id === target);
+  const value = target.replace(/^@/, "");
+  const normalized = value.toLowerCase();
+  const byId = devices.find((device) => device.id === value);
   return byId === undefined ? devices.filter((device) => device.name.toLowerCase() === normalized || device.hostname.toLowerCase() === normalized) : [byId];
 };
+var listBots = (devices) => devices.flatMap((device) => (device.bots ?? []).map((bot) => ({
+  id: bot.id,
+  name: bot.name,
+  ...bot.description === undefined ? {} : { description: bot.description },
+  device_id: device.id,
+  device_name: device.name,
+  status: device.status,
+  target: `@${device.id}/${bot.id}`
+})));
+var selectTarget = Effect5.fn("Cohall.selectTarget")(function* (devices, target) {
+  const value = target.replace(/^@/, "");
+  const separator = value.indexOf("/");
+  const qualified = separator !== -1;
+  const deviceMatches = matchingDevices(devices, qualified ? value.slice(0, separator) : value);
+  const botValue = qualified ? value.slice(separator + 1) : value;
+  const bots = listBots(qualified ? deviceMatches : devices);
+  const botsById = bots.filter((bot) => bot.id === botValue);
+  const botMatches = botsById.length > 0 ? botsById : bots.filter((bot) => bot.name.toLowerCase() === botValue.toLowerCase());
+  const exactDevice = qualified ? undefined : deviceMatches.find((device) => device.id === value);
+  if (exactDevice !== undefined)
+    return { deviceId: exactDevice.id, botId: undefined };
+  const matches = [
+    ...qualified ? [] : deviceMatches.map((device) => ({ deviceId: device.id, botId: undefined })),
+    ...botMatches.map((bot) => ({ deviceId: bot.device_id, botId: bot.id }))
+  ];
+  const selected = matches[0];
+  if (matches.length === 1 && selected !== undefined)
+    return selected;
+  return yield* new DeviceSelectionError({
+    message: matches.length === 0 ? `No Cohall device or bot matches ${target}; use cohall devices or cohall bots` : `${target} is ambiguous; use a device ID or @device-id/bot-id from cohall bots`,
+    devices: [
+      ...deviceMatches.map((device) => `${device.name} (@${device.id})`),
+      ...botMatches.map((bot) => `${bot.name} on ${bot.device_name} (${bot.target})`)
+    ]
+  });
+});
 var taskResult = (task) => TaskResult.make({
   task_id: task.id,
   thread_id: task.threadId,
   status: task.status,
   provider: task.provider,
   target_device_id: task.targetDeviceId,
+  ...task.botId === undefined ? {} : { bot_id: task.botId },
   ...task.result === undefined ? {} : { result: task.result },
   ...task.error === undefined ? {} : { error: task.error }
 });
-var createDelegation = Effect4.fn("Cohall.createDelegation")(function* (client, configuration, options) {
+var createDelegation = Effect5.fn("Cohall.createDelegation")(function* (client, configuration, options) {
   const devices = yield* client.devices();
-  const matches = options.target === undefined ? [] : matchingDevices(devices, options.target);
-  if (options.target !== undefined && matches.length !== 1) {
+  if (devices.length === 0) {
     return yield* new DeviceSelectionError({
-      message: matches.length === 0 ? `No Cohall device matches ${options.target}` : `${options.target} is ambiguous; use a device ID`,
-      devices: matches.length === 0 ? devices.map((device) => `${device.name} (${device.id})`) : matches.map((device) => `${device.name} (${device.id})`)
+      message: "No Cohall devices are registered",
+      devices: []
     });
   }
-  if (devices.length === 0) {
+  let target = options.target === undefined ? undefined : yield* selectTarget(devices, options.target);
+  if (target === undefined && options.threadId !== undefined && options.provider === undefined && options.parentTaskId === undefined && configuration.mcpTaskId === undefined) {
+    const context = yield* client.threadContext(options.threadId);
+    const previous = context.tasks.findLast((task) => task.parentTaskId === undefined);
+    if (previous === undefined && context.truncated) {
+      return yield* new DeviceSelectionError({
+        message: "Earlier thread targets are no longer in the retained context; specify --target",
+        devices: []
+      });
+    }
+    if (previous?.provider === "grok-bot" && previous.botId !== undefined) {
+      target = yield* selectTarget(devices, `@${previous.targetDeviceId}/${previous.botId}`);
+    }
+  }
+  const botId = target?.botId;
+  if (botId !== undefined && options.provider !== undefined && options.provider !== "grok-bot") {
     return yield* new DeviceSelectionError({
-      message: "No Cohall devices are registered",
+      message: `A bot target requires provider grok-bot, not ${options.provider}`,
       devices: []
     });
   }
-  const target = matches[0];
+  if (botId === undefined && options.provider === "grok-bot") {
+    return yield* new DeviceSelectionError({
+      message: "Select a bot with --target; use cohall bots to list available bots",
+      devices: []
+    });
+  }
+  const provider = botId === undefined ? options.provider : "grok-bot";
   const inheritedThread = configuration.mcpThreadId;
+  const parentTaskId = options.parentTaskId ?? (configuration.mcpTaskId === undefined ? undefined : yield* Schema5.decodeUnknownEffect(TaskId)(configuration.mcpTaskId));
   return yield* client.createTask({
     prompt: options.prompt,
-    ...target === undefined ? {} : { targetDeviceId: target.id },
+    ...target === undefined ? {} : { targetDeviceId: target.deviceId },
+    ...botId === undefined ? {} : { botId },
     ...options.threadId !== undefined ? { threadId: options.threadId } : inheritedThread === undefined ? {} : { threadId: ThreadId.make(inheritedThread) },
     ...options.context === undefined ? {} : { context: options.context },
     ...options.workspace === undefined ? {} : { workspace: options.workspace },
-    ...options.provider === undefined ? {} : { provider: options.provider }
+    ...provider === undefined ? {} : { provider },
+    ...parentTaskId === undefined ? {} : { parentTaskId }
   });
 });
-var waitForTask = Effect4.fn("Cohall.waitForTask")(function* (client, initial, timeoutSeconds) {
+var waitForTask = Effect5.fn("Cohall.waitForTask")(function* (client, initial, timeoutSeconds) {
   const deadline = Date.now() + timeoutSeconds * 1000;
   let task = initial;
   while (!isTerminalTask(task)) {
@@ -3210,28 +3381,28 @@ var waitForTask = Effect4.fn("Cohall.waitForTask")(function* (client, initial, t
         status: task.status
       });
     }
-    yield* Effect4.sleep("1 second");
+    yield* Effect5.sleep("1 second");
     task = yield* client.getTask(task.id);
   }
   return task;
 });
-var followTaskTrace = Effect4.fn("Cohall.followTaskTrace")(function* (client, taskId, onTrace) {
+var followTaskTrace = Effect5.fn("Cohall.followTaskTrace")(function* (client, taskId, onTrace) {
   let revision;
-  const poll = client.traceTask(taskId).pipe(Effect4.tap((trace) => {
+  const poll = client.traceTask(taskId).pipe(Effect5.tap((trace) => {
     const latest = trace.events.at(-1);
     const nextRevision = `${trace.status}:${latest?.kind ?? "none"}:${latest?.at ?? "none"}`;
     if (nextRevision === revision) {
-      return Effect4.succeed(undefined);
+      return Effect5.succeed(undefined);
     }
     revision = nextRevision;
-    return Effect4.sync(() => onTrace(trace));
+    return Effect5.sync(() => onTrace(trace));
   }));
-  return yield* poll.pipe(Effect4.repeat({
+  return yield* poll.pipe(Effect5.repeat({
     until: (trace) => terminalTaskStatuses.has(trace.status),
     schedule: Schedule.spaced("1 second")
   }));
 });
-var threadContext = Effect4.fn("Cohall.threadContext")(function* (client, threadId) {
+var threadContext = Effect5.fn("Cohall.threadContext")(function* (client, threadId) {
   return yield* client.threadContext(threadId);
 });
 
@@ -3280,8 +3451,448 @@ var allDeviceHealth = (devices, localVersion) => {
   };
 };
 
+// apps/device/src/grok-bot.ts
+init_src();
+import { Effect as Effect6, Schedule as Schedule2, Schema as Schema7 } from "effect";
+import { open as open2 } from "node:fs/promises";
+import { isIP } from "node:net";
+
+// apps/device/src/bot-replies.ts
+init_src();
+import { Schema as Schema6 } from "effect";
+import { randomUUID } from "node:crypto";
+import { chmod as chmod3, link, mkdir as mkdir2, open, unlink } from "node:fs/promises";
+import { dirname as dirname2, join as join3 } from "node:path";
+import { platform as platform3 } from "node:os";
+var replyLifetimeMs = 6 * 60 * 60 * 1000;
+var Pending = Schema6.Struct({
+  taskId: TaskId,
+  botId: BotId,
+  threadId: ThreadId,
+  deadline: Schema6.Int.check(Schema6.isGreaterThanOrEqualTo(0))
+});
+var Dispatch = Schema6.Struct({ taskId: TaskId });
+var Reply = Schema6.Union([
+  Schema6.Struct({
+    result: Schema6.String.check(Schema6.isMaxLength(131072)),
+    error: Schema6.optionalKey(Schema6.Never)
+  }),
+  Schema6.Struct({
+    error: Schema6.NonEmptyString.check(Schema6.isMaxLength(16384)),
+    result: Schema6.optionalKey(Schema6.Never)
+  })
+]);
+var Receipt = Schema6.Struct({
+  taskId: TaskId,
+  submittedAt: Schema6.Int.check(Schema6.isGreaterThanOrEqualTo(0)),
+  reply: Reply
+});
+var isMissing = (cause) => cause instanceof Error && ("code" in cause) && cause.code === "ENOENT";
+var alreadyExists = (cause) => cause instanceof Error && ("code" in cause) && cause.code === "EEXIST";
+var paths = (taskId) => {
+  const id = Schema6.decodeUnknownSync(TaskId)(taskId);
+  const directory = join3(dirname2(configurationPath()), "bot-replies");
+  return {
+    directory,
+    pending: join3(directory, `${id}.pending.json`),
+    receipt: join3(directory, `${id}.reply.json`),
+    dispatch: join3(directory, `${id}.dispatch.json`)
+  };
+};
+var readJson = async (path, limit) => {
+  const file = await open(path, "r").catch((cause) => {
+    if (isMissing(cause))
+      return;
+    throw cause;
+  });
+  if (file === undefined)
+    return;
+  try {
+    const buffer = Buffer.alloc(limit + 1);
+    let size = 0;
+    while (size < buffer.length) {
+      const { bytesRead } = await file.read(buffer, size, buffer.length - size, size);
+      if (bytesRead === 0)
+        break;
+      size += bytesRead;
+    }
+    if (size > limit)
+      throw new Error("Bot reply record exceeds its size limit");
+    return JSON.parse(buffer.subarray(0, size).toString("utf8"));
+  } catch {
+    throw new Error("Invalid local bot reply record");
+  } finally {
+    await file.close();
+  }
+};
+var pendingReply = async (taskId) => {
+  const value = await readJson(paths(taskId).pending, 4096);
+  if (value === undefined)
+    return;
+  const decoded = Schema6.decodeUnknownResult(Pending)(value);
+  if (decoded._tag === "Failure" || decoded.success.taskId !== taskId) {
+    throw new Error("Invalid local bot reply manifest");
+  }
+  return decoded.success;
+};
+var publish = async (path, value) => {
+  const temporary = `${path}.${randomUUID()}.tmp`;
+  const file = await open(temporary, "wx", 384);
+  try {
+    try {
+      await file.writeFile(`${JSON.stringify(value)}
+`, "utf8");
+      await file.sync();
+    } finally {
+      await file.close();
+    }
+    await link(temporary, path);
+    if (platform3() !== "win32") {
+      const directory = await open(dirname2(path), "r");
+      try {
+        await directory.sync();
+      } finally {
+        await directory.close();
+      }
+    }
+    return true;
+  } catch (cause) {
+    if (alreadyExists(cause))
+      return false;
+    throw cause;
+  } finally {
+    await unlink(temporary);
+  }
+};
+var shellQuote = (value) => `'${value.replaceAll("'", "'\\''")}'`;
+var prepareBotReply = async (task) => {
+  if (task.provider !== "grok-bot" || task.botId === undefined) {
+    throw new Error("Only a named Grok Bot task can receive a bot reply");
+  }
+  const files = paths(task.id);
+  await mkdir2(files.directory, { recursive: true, mode: 448 });
+  await chmod3(files.directory, 448);
+  const record2 = Pending.make({
+    taskId: task.id,
+    botId: task.botId,
+    threadId: task.threadId,
+    deadline: Date.now() + replyLifetimeMs
+  });
+  await publish(files.pending, record2);
+  const pending = await pendingReply(task.id);
+  if (pending === undefined || pending.botId !== task.botId || pending.threadId !== task.threadId) {
+    throw new Error("Bot reply manifest does not match this task");
+  }
+  const dispatch = await readJson(files.dispatch, 4096);
+  if (dispatch !== undefined) {
+    const decoded = Schema6.decodeUnknownResult(Dispatch)(dispatch);
+    if (decoded._tag === "Failure" || decoded.success.taskId !== task.id) {
+      throw new Error("Invalid local bot dispatch record");
+    }
+  }
+  return {
+    deadline: pending.deadline,
+    command: `COHALL_CONFIG=${shellQuote(configurationPath())} cohall`,
+    dispatched: dispatch !== undefined
+  };
+};
+var claimBotDispatch = async (taskId) => {
+  const pending = await pendingReply(taskId);
+  if (pending === undefined)
+    throw new Error("No pending bot reply for this task");
+  if (Date.now() >= pending.deadline)
+    throw new Error("Bot reply deadline has expired");
+  return publish(paths(taskId).dispatch, { taskId });
+};
+var readBotReply = async (taskId) => {
+  const pending = await pendingReply(taskId);
+  if (pending === undefined)
+    return;
+  const value = await readJson(paths(taskId).receipt, 1024 * 1024);
+  if (value === undefined)
+    return;
+  const decoded = Schema6.decodeUnknownResult(Receipt)(value);
+  if (decoded._tag === "Failure" || decoded.success.taskId !== taskId) {
+    throw new Error("Invalid local bot reply receipt");
+  }
+  if (decoded.success.submittedAt >= pending.deadline) {
+    throw new Error("Bot reply was submitted after its deadline");
+  }
+  return decoded.success.reply;
+};
+var writeBotReply = async (taskId, reply) => {
+  const decoded = Schema6.decodeUnknownResult(Reply)(reply);
+  if (decoded._tag === "Failure") {
+    throw new Error("Provide a result of at most 131072 characters or a nonempty error of at most 16384 characters");
+  }
+  const pending = await pendingReply(taskId);
+  if (pending === undefined)
+    throw new Error("No pending bot reply for this task");
+  const existing = await readBotReply(taskId);
+  if (existing !== undefined) {
+    if (JSON.stringify(existing) === JSON.stringify(decoded.success))
+      return;
+    throw new Error("A different reply has already been submitted for this task");
+  }
+  const submittedAt = Date.now();
+  if (submittedAt >= pending.deadline)
+    throw new Error("Bot reply deadline has expired");
+  if (await publish(paths(taskId).receipt, { taskId, submittedAt, reply: decoded.success }))
+    return;
+  const winner = await readBotReply(taskId);
+  if (JSON.stringify(winner) !== JSON.stringify(decoded.success)) {
+    throw new Error("A different reply has already been submitted for this task");
+  }
+};
+var cleanupBotReply = async (taskId) => {
+  const files = paths(taskId);
+  for (const path of [files.pending, files.receipt, files.dispatch]) {
+    await unlink(path).catch((cause) => {
+      if (!isMissing(cause))
+        throw cause;
+    });
+  }
+};
+
+// apps/device/src/grok-bot.ts
+var maxResponseBytes = 4 * 1024 * 1024;
+var maxDiscoveryBytes = 64 * 1024;
+var text2 = Schema7.NonEmptyString;
+var Discovery = Schema7.Struct({
+  port: Schema7.Int.check(Schema7.isBetween({ minimum: 1, maximum: 65535 })),
+  host: Schema7.optionalKey(text2),
+  scheme: Schema7.optionalKey(Schema7.Literals(["http", "https"])),
+  token: Schema7.optionalKey(Schema7.String.check(Schema7.isMaxLength(16384)))
+});
+var Agent = Schema7.Struct({
+  id: Bot.fields.id,
+  name: Bot.fields.name,
+  description: Schema7.optionalKey(Schema7.String),
+  isGroup: Schema7.optionalKey(Schema7.Boolean)
+});
+var Roster = Schema7.Array(Agent).check(Schema7.isMaxLength(1024));
+var Acceptance = Schema7.Union([
+  Schema7.Struct({ outcome: Schema7.Literals(["not-found", "unknown-durability"]) }),
+  Schema7.Struct({
+    outcome: Schema7.Literal("found"),
+    record: Schema7.Struct({
+      status: Schema7.Literals(["accepted", "pending", "rejected"])
+    })
+  })
+]);
+var SendResult = Schema7.Struct({ accepted: Schema7.Literal(true) });
+
+class GatewayError extends Error {
+}
+var decode = (schema, value, label) => {
+  const result = Schema7.decodeUnknownResult(schema)(value);
+  if (result._tag === "Failure")
+    throw new GatewayError(`Grok Bot returned an invalid ${label}`);
+  return result.success;
+};
+var readConnection = async (path) => {
+  const value = await (async () => {
+    const file = await open2(path, "r");
+    try {
+      const buffer = Buffer.alloc(maxDiscoveryBytes + 1);
+      const { bytesRead } = await file.read(buffer, 0, buffer.length, 0);
+      if (bytesRead > maxDiscoveryBytes)
+        throw new Error("Discovery file exceeds its size limit");
+      return decode(Discovery, JSON.parse(buffer.subarray(0, bytesRead).toString("utf8")), "discovery file");
+    } finally {
+      await file.close();
+    }
+  })().catch(() => {
+    throw new Error("Cannot read Grok Bot gateway discovery; check its configured file and running gateway");
+  });
+  const host = value.host ?? "127.0.0.1";
+  const normalized = host === "0.0.0.0" || host === "localhost" ? "127.0.0.1" : host === "::" || host === "::1" || host === "[::1]" ? "[::1]" : host;
+  if (!(normalized === "[::1]" || isIP(normalized) === 4 && normalized.startsWith("127."))) {
+    throw new Error("Grok Bot gateway must use a loopback address on this device");
+  }
+  return { url: `${value.scheme ?? "http"}://${normalized}:${value.port}`, token: value.token };
+};
+var rpc = async (connection, method, args, schema, signal) => {
+  const controller = new AbortController;
+  const deadline = setTimeout(() => controller.abort(), 20000);
+  const combined = signal === undefined ? controller.signal : AbortSignal.any([signal, controller.signal]);
+  try {
+    const response = await fetch(`${connection.url}/api/${method}`, {
+      method: "POST",
+      redirect: "error",
+      headers: {
+        "content-type": "application/json",
+        "x-sand-slim-avatars": "1",
+        ...connection.token === undefined || connection.token.length === 0 ? {} : { authorization: `Bearer ${connection.token}` }
+      },
+      body: JSON.stringify(args),
+      signal: combined
+    });
+    if (!response.ok) {
+      await response.body?.cancel();
+      throw new GatewayError(`Grok Bot ${method} failed (HTTP ${response.status})`);
+    }
+    if (response.body === null)
+      throw new GatewayError("Grok Bot returned an empty response");
+    const reader = response.body.getReader();
+    const chunks = [];
+    let size = 0;
+    try {
+      for (;; ) {
+        const chunk = await reader.read();
+        if (chunk.done)
+          break;
+        size += chunk.value.byteLength;
+        if (size > maxResponseBytes)
+          throw new GatewayError("Grok Bot response exceeded 4 MiB");
+        chunks.push(chunk.value);
+      }
+    } finally {
+      await reader.cancel().catch(() => {
+        return;
+      });
+      reader.releaseLock();
+    }
+    let json;
+    try {
+      json = JSON.parse(Buffer.concat(chunks, size).toString("utf8"));
+    } catch {
+      throw new GatewayError(`Grok Bot ${method} returned invalid JSON`);
+    }
+    return decode(schema, json, `${method} response`);
+  } catch (cause) {
+    if (signal?.aborted)
+      throw new Error("Stopped waiting for Grok Bot; its run may still be active");
+    if (cause instanceof GatewayError)
+      throw cause;
+    throw new Error(`Grok Bot ${method} failed; check gateway availability and compatibility`);
+  } finally {
+    clearTimeout(deadline);
+  }
+};
+var discoverGrokBots = async (path) => {
+  const connection = await readConnection(path);
+  const roster = await rpc(connection, "listAgents", {}, Roster);
+  const bots = roster.filter((agent) => agent.isGroup !== true);
+  if (bots.length > 256)
+    throw new Error("Grok Bot discovery exceeds Cohall's limit of 256 bots");
+  if (new Set(bots.map((bot) => bot.id)).size !== bots.length) {
+    throw new Error("Grok Bot returned duplicate bot identities");
+  }
+  return bots.map(({ id, name, description }) => ({
+    id,
+    name,
+    ...description === undefined ? {} : { description: description.slice(0, 512) }
+  }));
+};
+var poll = async (pass, signal) => {
+  const result = await Effect6.runPromise(Effect6.tryPromise({ try: pass, catch: (cause) => cause }).pipe(Effect6.repeat({
+    schedule: Schedule2.spaced("1 second"),
+    until: (value) => value !== undefined
+  })), { signal });
+  if (result === undefined)
+    throw new Error("Grok Bot polling ended before a result");
+  return result;
+};
+var timeoutMessage = "Timed out waiting for the bot to reply through Cohall; the bot may still be running.";
+var requireTime = (deadline) => {
+  if (Date.now() >= deadline)
+    throw new Error(timeoutMessage);
+};
+var finishReply = (reply) => {
+  if (reply.error !== undefined)
+    throw new Error(reply.error);
+  if (reply.result === undefined)
+    throw new Error("Grok Bot returned an invalid Cohall reply");
+  return { result: reply.result };
+};
+var taskPrompt = (task, command) => [
+  task.prompt,
+  task.context === undefined ? "" : `Context:
+${task.context}`,
+  `This request came through Cohall. Thread: ${task.threadId}. Task: ${task.id}.`,
+  `You may use your own tools and delegate work to another Cohall device when the request calls for it. Discover devices with: ${command} devices`,
+  `Delegation example: ${command} delegate --thread ${task.threadId} --parent ${task.id} --target @device --provider codex --prompt 'Concrete task' --context 'Relevant context'`,
+  "When finished, hand the final answer back to Cohall so it reaches the requesting device. Write it to a UTF-8 file on this computer, then run:",
+  `${command} reply ${task.id} --message-file /absolute/path/to/your-answer.txt`,
+  `Alternatively pipe your answer into: ${command} reply ${task.id} --message -`,
+  `If you cannot complete this task, report the reason with: ${command} reply ${task.id} --error 'Reason'`,
+  "The reply command must succeed. Then send the same answer in this chat. A normal chat message alone does not complete the Cohall task."
+].filter(Boolean).join(`
+
+`);
+var runGrokBot = async (path, task, signal) => {
+  const existing = await readBotReply(task.id);
+  if (existing !== undefined)
+    return finishReply(existing);
+  const { deadline, command, dispatched } = await prepareBotReply(task);
+  requireTime(deadline);
+  const waitForReply = () => poll(async () => {
+    const receipt = await readBotReply(task.id);
+    if (receipt !== undefined)
+      return finishReply(receipt);
+    requireTime(deadline);
+    return;
+  }, signal);
+  if (dispatched)
+    return waitForReply();
+  if (path === undefined)
+    throw new Error("Configure this device's Grok Bot gateway discovery file first");
+  const agentId = task.botId;
+  if (agentId === undefined)
+    throw new Error("Select a Grok Bot for this task");
+  const connection = await readConnection(path);
+  const lookup = () => rpc(connection, "promptAcceptanceStatus", { accountSlot: "host", agentId, clientNonce: task.id }, Acceptance, signal);
+  let acceptance = await lookup();
+  if (acceptance.outcome === "unknown-durability")
+    throw new Error("Grok Bot cannot confirm whether this task was accepted; check its conversation before retrying");
+  if (acceptance.outcome === "not-found") {
+    const receipt = await readBotReply(task.id);
+    if (receipt !== undefined)
+      return finishReply(receipt);
+    requireTime(deadline);
+    const roster = await rpc(connection, "listAgents", {}, Roster, signal);
+    if (!roster.some((row) => row.id === agentId && row.isGroup !== true)) {
+      throw new Error("The selected Grok Bot no longer exists on this device");
+    }
+    requireTime(deadline);
+    acceptance = await lookup();
+    if (acceptance.outcome === "not-found") {
+      requireTime(deadline);
+      if (!await claimBotDispatch(task.id)) {
+        return waitForReply();
+      }
+      try {
+        await rpc(connection, "sendPrompt", {
+          agentId,
+          prompt: taskPrompt(task, command),
+          clientNonce: task.id,
+          directAddressedAcceptance: true
+        }, SendResult, signal);
+      } catch {
+        if (signal.aborted)
+          throw new Error("Stopped waiting for Grok Bot; its run may still be active");
+        const receipt2 = await readBotReply(task.id);
+        if (receipt2 !== undefined)
+          return finishReply(receipt2);
+        const reconciled = await lookup().catch(() => {
+          return;
+        });
+        if (reconciled?.outcome === "found" && reconciled.record.status === "rejected")
+          throw new Error("Grok Bot rejected this task; check its conversation");
+        return waitForReply();
+      }
+    }
+  }
+  if (acceptance.outcome === "unknown-durability")
+    throw new Error("Grok Bot cannot confirm task acceptance; the prompt was not resent");
+  if (acceptance.outcome === "found" && acceptance.record.status === "rejected")
+    throw new Error("Grok Bot rejected this task; check its conversation");
+  return waitForReply();
+};
+
 // apps/device/src/setup.ts
-import { Effect as Effect5 } from "effect";
+import { Effect as Effect7 } from "effect";
 import { hostname as hostname2 } from "node:os";
 import { Writable } from "node:stream";
 import { createInterface } from "node:readline/promises";
@@ -3295,7 +3906,7 @@ var joinRelay = async (options) => {
   if (!options.clientOnly && draft.workspaces.length === 0) {
     throw new Error("At least one workspace is required when joining a device");
   }
-  const paired = await Effect5.runPromise(exchangePairing(draft.relayUrl, { token: options.token }));
+  const paired = await Effect7.runPromise(exchangePairing(draft.relayUrl, { token: options.token }));
   const clientToken = paired.credentials.find((credential) => credential.session.role === "client")?.token;
   const deviceCredential = paired.credentials.find((credential) => credential.session.role === "device");
   if (options.clientOnly && clientToken === undefined) {
@@ -3378,15 +3989,15 @@ var guidedSetupInput = async (options, prompter) => {
 
 // apps/device/src/relay-migration.ts
 init_src();
-import { Effect as Effect6, Schema as Schema7 } from "effect";
+import { Effect as Effect8, Schema as Schema9 } from "effect";
 import { createHash } from "node:crypto";
 import { createReadStream } from "node:fs";
 import {
   access as access3,
-  chmod as chmod5,
+  chmod as chmod6,
   copyFile,
   lstat,
-  mkdir as mkdir4,
+  mkdir as mkdir5,
   mkdtemp as mkdtemp2,
   readFile as readFile3,
   realpath as realpath4,
@@ -3395,24 +4006,24 @@ import {
   stat as stat2,
   writeFile as writeFile5
 } from "node:fs/promises";
-import { basename, dirname as dirname4, join as join5, resolve as resolve2 } from "node:path";
+import { basename, dirname as dirname5, join as join6, resolve as resolve2 } from "node:path";
 import { backup as sqliteBackup, DatabaseSync } from "node:sqlite";
 import { WebSocket } from "ws";
 
 // apps/device/src/service.ts
 import { execFile as execFile3 } from "node:child_process";
-import { chmod as chmod4, mkdir as mkdir3, realpath as realpath3, writeFile as writeFile4 } from "node:fs/promises";
+import { chmod as chmod5, mkdir as mkdir4, realpath as realpath3, writeFile as writeFile4 } from "node:fs/promises";
 import { homedir as homedir3 } from "node:os";
-import { dirname as dirname3, join as join4 } from "node:path";
+import { dirname as dirname4, join as join5 } from "node:path";
 
 // apps/device/src/upgrade.ts
-import { Schema as Schema6 } from "effect";
+import { Schema as Schema8 } from "effect";
 import { execFile as execFile2 } from "node:child_process";
 import { constants as constants2 } from "node:fs";
 import {
   access as access2,
-  chmod as chmod3,
-  mkdir as mkdir2,
+  chmod as chmod4,
+  mkdir as mkdir3,
   readFile as readFile2,
   realpath as realpath2,
   rename as rename2,
@@ -3420,18 +4031,18 @@ import {
   stat,
   writeFile as writeFile3
 } from "node:fs/promises";
-import { delimiter as delimiter2, dirname as dirname2, extname as extname2, isAbsolute as isAbsolute2, join as join3, relative } from "node:path";
+import { delimiter as delimiter2, dirname as dirname3, extname as extname2, isAbsolute as isAbsolute2, join as join4, relative } from "node:path";
 import { platform as operatingSystem } from "node:os";
 var packageName = "@akshar5/cohall";
 var semanticVersion = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
-var PackageManager = Schema6.Literals(["npm", "bun", "pnpm"]);
-var RestartReceipt = Schema6.Struct({
-  version: Schema6.String,
-  fromVersion: Schema6.String,
+var PackageManager = Schema8.Literals(["npm", "bun", "pnpm"]);
+var RestartReceipt = Schema8.Struct({
+  version: Schema8.String,
+  fromVersion: Schema8.String,
   packageManager: PackageManager,
-  pendingServices: Schema6.Array(Schema6.String),
-  restartedServices: Schema6.Array(Schema6.String),
-  restartingService: Schema6.optionalKey(Schema6.String)
+  pendingServices: Schema8.Array(Schema8.String),
+  restartedServices: Schema8.Array(Schema8.String),
+  restartingService: Schema8.optionalKey(Schema8.String)
 });
 var normalizePath = (path) => path.replaceAll("\\", "/");
 var normalizeUpgradeTarget = (target) => {
@@ -3505,13 +4116,13 @@ var linuxSystemExecutableRoots = [
 ];
 var macosHomebrewRoots = ["/opt/homebrew", "/usr/local"];
 var macosAdminGroup = 80;
-var isTrustedSystemExecutablePath = (platform3, canonical) => platform3 === "linux" && linuxSystemExecutableRoots.some((root) => containsPath(root, canonical));
+var isTrustedSystemExecutablePath = (platform4, canonical) => platform4 === "linux" && linuxSystemExecutableRoots.some((root) => containsPath(root, canonical));
 var isTrustedGroupWritablePath = (options) => {
   const writableRoot = options.writableRoot;
   return options.platform === "darwin" && writableRoot !== undefined && options.uid !== undefined && options.ownerUid === options.uid && options.ownerGid === macosAdminGroup && macosHomebrewRoots.some((root) => containsPath(root, writableRoot)) && containsPath(writableRoot, options.canonical) && containsPath(writableRoot, options.path);
 };
 var trustedExecutable = async (command, options = {}) => {
-  const candidates = isAbsolute2(command) ? [command] : (process.env.PATH ?? "").split(delimiter2).filter(Boolean).flatMap((directory) => executableNames(command).map((name) => join3(directory, name)));
+  const candidates = isAbsolute2(command) ? [command] : (process.env.PATH ?? "").split(delimiter2).filter(Boolean).flatMap((directory) => executableNames(command).map((name) => join4(directory, name)));
   let selected;
   for (const path of candidates) {
     const available2 = await access2(path, operatingSystem() === "win32" ? constants2.F_OK : constants2.X_OK).then(() => true).catch(() => false);
@@ -3530,7 +4141,7 @@ var trustedExecutable = async (command, options = {}) => {
   const uid = process.getuid?.();
   const writableRoot = options.writableRoot === undefined ? undefined : await realpath2(options.writableRoot);
   const systemExecutable = isTrustedSystemExecutablePath(operatingSystem(), canonical);
-  for (let path = canonical;; path = dirname2(path)) {
+  for (let path = canonical;; path = dirname3(path)) {
     const metadata = await stat(path);
     const trustedGroupWritablePath = isTrustedGroupWritablePath({
       platform: operatingSystem(),
@@ -3547,7 +4158,7 @@ var trustedExecutable = async (command, options = {}) => {
     if (uid !== undefined && metadata.uid !== 0 && metadata.uid !== uid && !systemExecutable) {
       throw new Error(`Refusing executable owned by another user at ${path}`);
     }
-    const parent = dirname2(path);
+    const parent = dirname3(path);
     if (parent === path) {
       break;
     }
@@ -3712,15 +4323,15 @@ ${result.stderr}`);
     throw new Error(`Active ${service.label} uses ${serviceEntrypoint}, but this Cohall CLI uses ${entrypoint}. Run the service executable's upgrade command so its installation is updated before restart.`);
   }
 };
-var readReceipt = async (path) => readFile2(path, "utf8").then((content) => Schema6.decodeUnknownOption(RestartReceipt)(JSON.parse(content))).then((decoded) => decoded._tag === "Some" ? decoded.value : undefined).catch(() => {
+var readReceipt = async (path) => readFile2(path, "utf8").then((content) => Schema8.decodeUnknownOption(RestartReceipt)(JSON.parse(content))).then((decoded) => decoded._tag === "Some" ? decoded.value : undefined).catch(() => {
   return;
 });
 var writeReceipt = async (path, value) => {
-  const directory = dirname2(path);
+  const directory = dirname3(path);
   const temporary = `${path}.${process.pid}.tmp`;
-  await mkdir2(directory, { recursive: true, mode: 448 });
+  await mkdir3(directory, { recursive: true, mode: 448 });
   if (operatingSystem() !== "win32") {
-    await chmod3(directory, 448);
+    await chmod4(directory, 448);
   }
   await writeFile3(temporary, `${JSON.stringify(value, null, 2)}
 `, { mode: 384 });
@@ -3728,13 +4339,13 @@ var writeReceipt = async (path, value) => {
 };
 var installedVersion = async (entrypoint) => {
   const canonicalEntrypoint = await realpath2(entrypoint);
-  const metadata = JSON.parse(await readFile2(join3(dirname2(dirname2(canonicalEntrypoint)), "package.json"), "utf8"));
+  const metadata = JSON.parse(await readFile2(join4(dirname3(dirname3(canonicalEntrypoint)), "package.json"), "utf8"));
   if (typeof metadata !== "object" || metadata === null || !("name" in metadata) || metadata.name !== packageName || !("version" in metadata) || typeof metadata.version !== "string") {
     throw new Error(`Could not verify the installed ${packageName} version`);
   }
   return metadata.version;
 };
-var restartReceiptPath = () => join3(dirname2(configurationPath()), "upgrade-restart.json");
+var restartReceiptPath = () => join4(dirname3(configurationPath()), "upgrade-restart.json");
 var restartServices = async (runner, services, statePath, state, preserveDeviceReceipt) => {
   let current = state;
   for (const service of services) {
@@ -3905,7 +4516,7 @@ var xml = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").repl
 var systemdArgument = (value) => `"${value.replaceAll("\\", "\\\\").replaceAll('"', "\\\"")}"`;
 var deviceServicePlan = (options) => {
   if (options.platform === "linux") {
-    const path = join4(options.home, ".config", "systemd", "user", "cohall-device.service");
+    const path = join5(options.home, ".config", "systemd", "user", "cohall-device.service");
     return {
       file: {
         path,
@@ -3938,7 +4549,7 @@ WantedBy=default.target
   }
   if (options.platform === "darwin") {
     const label = "com.cohall.device";
-    const path = join4(options.home, "Library", "LaunchAgents", `${label}.plist`);
+    const path = join5(options.home, "Library", "LaunchAgents", `${label}.plist`);
     const domain = `gui/${options.uid ?? 0}`;
     return {
       file: {
@@ -4009,10 +4620,10 @@ var checked2 = async (runner, command, arguments_, allowFailure = false) => {
 var installDeviceService = async (options = {}) => {
   const entrypoint = await realpath3(options.entrypoint ?? process.argv[1] ?? "");
   packageInstallation(entrypoint);
-  const platform3 = options.platform ?? process.platform;
+  const platform4 = options.platform ?? process.platform;
   const runner = options.runner ?? defaultRunner2;
-  if (platform3 === "win32") {
-    const script = join4(dirname3(dirname3(entrypoint)), "deploy", "windows", "install-device.ps1");
+  if (platform4 === "win32") {
+    const script = join5(dirname4(dirname4(entrypoint)), "deploy", "windows", "install-device.ps1");
     await checked2(runner, "powershell.exe", [
       "-NoProfile",
       "-ExecutionPolicy",
@@ -4024,16 +4635,16 @@ var installDeviceService = async (options = {}) => {
   }
   const uid = options.uid ?? process.getuid?.();
   const plan = deviceServicePlan({
-    platform: platform3,
+    platform: platform4,
     entrypoint,
     home: options.home ?? homedir3(),
     ...uid === undefined ? {} : { uid }
   });
-  await mkdir3(dirname3(plan.file.path), { recursive: true, mode: 448 });
+  await mkdir4(dirname4(plan.file.path), { recursive: true, mode: 448 });
   await writeFile4(plan.file.path, plan.file.content, { mode: plan.file.mode });
-  await chmod4(plan.file.path, plan.file.mode);
+  await chmod5(plan.file.path, plan.file.mode);
   for (const [index, command] of plan.commands.entries()) {
-    await checked2(runner, command.command, command.arguments, platform3 === "darwin" && index === 0);
+    await checked2(runner, command.command, command.arguments, platform4 === "darwin" && index === 0);
   }
   return {
     installed: plan.file.path,
@@ -4041,9 +4652,9 @@ var installDeviceService = async (options = {}) => {
   };
 };
 var restartDeviceService = async (options = {}) => {
-  const platform3 = options.platform ?? process.platform;
+  const platform4 = options.platform ?? process.platform;
   const runner = options.runner ?? defaultRunner2;
-  if (platform3 === "linux") {
+  if (platform4 === "linux") {
     const service = "cohall-device.service";
     const check = await runner.run("systemctl", ["--user", "is-active", "--quiet", service], 1e4);
     if (check.exitCode !== 0) {
@@ -4052,7 +4663,7 @@ var restartDeviceService = async (options = {}) => {
     await checked2(runner, "systemctl", ["--user", "restart", service]);
     return { running: true, restarted: true, service };
   }
-  if (platform3 === "darwin") {
+  if (platform4 === "darwin") {
     const service = "com.cohall.device";
     const target = `gui/${options.uid ?? process.getuid?.() ?? 0}/${service}`;
     const check = await runner.run("launchctl", ["print", target], 1e4);
@@ -4062,7 +4673,7 @@ var restartDeviceService = async (options = {}) => {
     await checked2(runner, "launchctl", ["kickstart", "-k", target]);
     return { running: true, restarted: true, service };
   }
-  if (platform3 === "win32") {
+  if (platform4 === "win32") {
     const service = "Cohall Device";
     const check = await runner.run("schtasks.exe", ["/Query", "/TN", service], 1e4);
     if (check.exitCode !== 0) {
@@ -4076,10 +4687,10 @@ var restartDeviceService = async (options = {}) => {
 };
 
 // apps/device/src/relay-migration.ts
-var sha256 = Schema7.String.check(Schema7.isPattern(/^[a-f0-9]{64}$/, { expected: "a lowercase SHA-256 digest" }));
-var RelayBackupManifest = Schema7.Struct({
-  formatVersion: Schema7.Literal(1),
-  cohallVersion: Schema7.NonEmptyString,
+var sha256 = Schema9.String.check(Schema9.isPattern(/^[a-f0-9]{64}$/, { expected: "a lowercase SHA-256 digest" }));
+var RelayBackupManifest = Schema9.Struct({
+  formatVersion: Schema9.Literal(1),
+  cohallVersion: Schema9.NonEmptyString,
   createdAt: Timestamp,
   databaseSha256: sha256,
   ownerTokenSha256: sha256
@@ -4103,27 +4714,27 @@ var verifyBackupMember = async (path, maximumBytes) => {
 };
 var readManifest = async (path) => {
   await verifyBackupMember(path, 16384);
-  return Schema7.decodeUnknownSync(RelayBackupManifest)(JSON.parse(await readFile3(path, "utf8")));
+  return Schema9.decodeUnknownSync(RelayBackupManifest)(JSON.parse(await readFile3(path, "utf8")));
 };
 var verifyBackupDestinationParent = async (path) => {
   if (process.platform === "win32") {
     return;
   }
-  for (let current = await realpath4(path);; current = dirname4(current)) {
+  for (let current = await realpath4(path);; current = dirname5(current)) {
     const metadata = await stat2(current);
     const writableByOthers = (metadata.mode & 18) !== 0;
     const sticky = (metadata.mode & 512) !== 0;
     if (writableByOthers && !sticky) {
       throw new Error(`Backup destination ancestors must not be group- or world-writable unless they use the sticky bit: ${current}`);
     }
-    const parent = dirname4(current);
+    const parent = dirname5(current);
     if (parent === current) {
       return;
     }
   }
 };
 var ownerToken = async (dataDirectory) => {
-  const path = join5(dataDirectory, "owner-token");
+  const path = join6(dataDirectory, "owner-token");
   const configured = process.env.COHALL_TOKEN;
   if (configured !== undefined) {
     return configured;
@@ -4149,7 +4760,7 @@ var verifyDatabase = (path) => {
 };
 var backupRelay = async (destinationInput) => {
   const sourceDirectory = relayDataDirectory();
-  const sourceDatabase = join5(sourceDirectory, "cohall.db");
+  const sourceDatabase = join6(sourceDirectory, "cohall.db");
   if (!await exists(sourceDatabase)) {
     throw new Error(`Relay database was not found at ${sourceDatabase}`);
   }
@@ -4157,11 +4768,11 @@ var backupRelay = async (destinationInput) => {
   if (await exists(destination)) {
     throw new Error(`Backup destination already exists: ${destination}`);
   }
-  await verifyBackupDestinationParent(dirname4(destination));
-  await mkdir4(destination, { mode: 448 });
+  await verifyBackupDestinationParent(dirname5(destination));
+  await mkdir5(destination, { mode: 448 });
   try {
-    const databasePath = join5(destination, "cohall.db");
-    const ownerTokenPath = join5(destination, "owner-token");
+    const databasePath = join6(destination, "cohall.db");
+    const ownerTokenPath = join6(destination, "owner-token");
     const database = new DatabaseSync(sourceDatabase, { readOnly: true });
     try {
       await sqliteBackup(database, databasePath);
@@ -4175,7 +4786,7 @@ var backupRelay = async (destinationInput) => {
     }
     await writeFile5(ownerTokenPath, `${token}
 `, { mode: 384 });
-    await Promise.all([chmod5(databasePath, 384), chmod5(ownerTokenPath, 384)]);
+    await Promise.all([chmod6(databasePath, 384), chmod6(ownerTokenPath, 384)]);
     const createdAt = Timestamp.make(new Date().toISOString());
     const manifest = RelayBackupManifest.make({
       formatVersion: 1,
@@ -4184,7 +4795,7 @@ var backupRelay = async (destinationInput) => {
       databaseSha256: await digest(databasePath),
       ownerTokenSha256: await digest(ownerTokenPath)
     });
-    await writeFile5(join5(destination, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
+    await writeFile5(join6(destination, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
 `, {
       mode: 384
     });
@@ -4201,9 +4812,9 @@ var backupRelay = async (destinationInput) => {
 };
 var restoreRelay = async (sourceInput) => {
   const source = resolve2(sourceInput);
-  const sourceDatabase = join5(source, "cohall.db");
-  const sourceOwnerToken = join5(source, "owner-token");
-  const sourceManifest = join5(source, "manifest.json");
+  const sourceDatabase = join6(source, "cohall.db");
+  const sourceOwnerToken = join6(source, "owner-token");
+  const sourceManifest = join6(source, "manifest.json");
   for (const path of [sourceDatabase, sourceOwnerToken, sourceManifest]) {
     if (!await exists(path)) {
       throw new Error(`Relay backup is missing ${basename(path)}`);
@@ -4218,24 +4829,24 @@ var restoreRelay = async (sourceInput) => {
   if (await exists(target)) {
     throw new Error(`Relay data directory already exists: ${target}. Restore into a new COHALL_DATA_DIR.`);
   }
-  const parent = dirname4(target);
-  await mkdir4(parent, { recursive: true, mode: 448 });
-  const staging = await mkdtemp2(join5(parent, `.${basename(target)}.restore-`));
+  const parent = dirname5(target);
+  await mkdir5(parent, { recursive: true, mode: 448 });
+  const staging = await mkdtemp2(join6(parent, `.${basename(target)}.restore-`));
   let backupVersion = "";
   try {
-    await chmod5(staging, 448);
-    const databasePath = join5(staging, "cohall.db");
-    const ownerTokenPath = join5(staging, "owner-token");
-    const manifestPath = join5(staging, "migration-manifest.json");
+    await chmod6(staging, 448);
+    const databasePath = join6(staging, "cohall.db");
+    const ownerTokenPath = join6(staging, "owner-token");
+    const manifestPath = join6(staging, "migration-manifest.json");
     await Promise.all([
       copyFile(sourceDatabase, databasePath),
       copyFile(sourceOwnerToken, ownerTokenPath),
       copyFile(sourceManifest, manifestPath)
     ]);
     await Promise.all([
-      chmod5(databasePath, 384),
-      chmod5(ownerTokenPath, 384),
-      chmod5(manifestPath, 384)
+      chmod6(databasePath, 384),
+      chmod6(ownerTokenPath, 384),
+      chmod6(manifestPath, 384)
     ]);
     const manifest = await readManifest(manifestPath);
     if (await digest(databasePath) !== manifest.databaseSha256 || await digest(ownerTokenPath) !== manifest.ownerTokenSha256) {
@@ -4267,7 +4878,7 @@ var websocketUrl = (relayUrl) => {
 };
 var isLoopback = (url) => url.hostname === "localhost" || url.hostname === "[::1]" || /^127(?:\.\d{1,3}){3}$/.test(url.hostname);
 var verifyClientCredential = async (relayUrl, token) => {
-  await Effect6.runPromise(exports_src.make({ baseUrl: relayUrl, token }).devices());
+  await Effect8.runPromise(exports_src.make({ baseUrl: relayUrl, token }).devices());
 };
 var verifyDeviceCredential = (relayUrl, token) => new Promise((resolvePromise, reject) => {
   const socket = new WebSocket(websocketUrl(relayUrl), {
@@ -4295,7 +4906,7 @@ var verifyDeviceCredential = (relayUrl, token) => new Promise((resolvePromise, r
   });
   socket.on("message", (data) => {
     try {
-      const event = Schema7.decodeUnknownSync(SocketEvent)(JSON.parse(data.toString()));
+      const event = Schema9.decodeUnknownSync(SocketEvent)(JSON.parse(data.toString()));
       if (event._tag === "Connected") {
         finish();
       } else if (event._tag === "Error") {
@@ -4364,9 +4975,14 @@ var switchRelay = async (options) => {
 var valueOptions = new Set([
   "context",
   "context-file",
+  "grok-gateway",
+  "error",
   "label",
   "model",
+  "message",
+  "message-file",
   "name",
+  "parent",
   "prompt",
   "prompt-file",
   "provider",
@@ -4404,15 +5020,19 @@ Usage:
   cohall join --relay <url> --workspace <path> [--providers list] [--token-file <path>]
   cohall configure [--relay url] [--name name] [--workspace path]
                    [--providers codex,opencode|auto] [--model id]
+                   [--grok-gateway path]
   cohall config
   cohall devices
-  cohall delegate [prompt] [--target @device] [--provider provider]
-                  [--context text] [--thread uuid] [--workspace path]
+  cohall bots
+  cohall send [@device-or-bot] [prompt] [delegate options]
+  cohall delegate [prompt] [--target @device-or-bot] [--provider provider]
+                  [--context text] [--thread uuid] [--parent task-id] [--workspace path]
                   [--timeout seconds] [--no-wait]
   cohall status <task-id>
   cohall trace <task-id> [--follow]
   cohall wait <task-id> [--timeout seconds]
   cohall cancel <task-id>
+  cohall reply <task-id> --message-file path | --message text | --message - | --error text
   cohall thread <thread-id>
   cohall pair [--label name] [--client-only]
   cohall sessions
@@ -4434,7 +5054,7 @@ Usage:
   cohall skill [install [agents|claude|opencode|all]]
   cohall integrations
 
-Providers: codex, claude-code, opencode.
+Providers: codex, claude-code, opencode, grok-bot.
 Configuration is stored per user; environment variables override it.`;
 var parseArguments = (values) => {
   const options = new Map;
@@ -4520,6 +5140,7 @@ var printLine = (value) => console.log(JSON.stringify(value));
 var readInput = async (arguments_, name) => {
   const direct = option(arguments_, name);
   const path = option(arguments_, `${name}-file`);
+  const byteLimit = name === "message" ? 4 * 131072 : 131072;
   if (direct !== undefined && path !== undefined) {
     throw new Error(`Use either --${name} or --${name}-file, not both`);
   }
@@ -4527,14 +5148,13 @@ var readInput = async (arguments_, name) => {
     if (!await access4(path).then(() => true).catch(() => false)) {
       throw new Error(`File does not exist: ${path}`);
     }
-    if ((await stat3(path)).size > 131072) {
-      throw new Error(`${name} file exceeds 128 KiB`);
+    if ((await stat3(path)).size > byteLimit) {
+      throw new Error(`${name} file exceeds ${byteLimit / 1024} KiB`);
     }
-    return readFile4(path, "utf8");
   }
-  const result = direct === "-" ? await readStdin(131072, name) : direct;
+  const result = path === undefined ? direct === "-" ? await readStdin(byteLimit, name) : direct : await readFile4(path, "utf8");
   if (result !== undefined && result.length > 131072) {
-    throw new Error(`${name} exceeds 128 KiB`);
+    throw new Error(`${name} exceeds 131072 characters`);
   }
   return result;
 };
@@ -4573,14 +5193,14 @@ var pairingToken = async (arguments_) => {
   return token;
 };
 var client = async () => {
-  const configuration = await Effect7.runPromise(loadClientConfiguration);
+  const configuration = await Effect9.runPromise(loadClientConfiguration);
   return {
     configuration,
     relay: exports_src.make({ baseUrl: configuration.relayUrl, token: configuration.token })
   };
 };
 var ownerClient = async () => {
-  const configuration = await Effect7.runPromise(loadOwnerConfiguration);
+  const configuration = await Effect9.runPromise(loadOwnerConfiguration);
   return {
     configuration,
     relay: exports_src.make({ baseUrl: configuration.relayUrl, token: configuration.token })
@@ -4588,16 +5208,16 @@ var ownerClient = async () => {
 };
 var installSkill = async (target) => {
   const roots = {
-    agents: join6(homedir4(), ".agents", "skills", "cohall", "SKILL.md"),
-    claude: join6(homedir4(), ".claude", "skills", "cohall", "SKILL.md"),
-    opencode: join6(homedir4(), ".config", "opencode", "skills", "cohall", "SKILL.md")
+    agents: join7(homedir4(), ".agents", "skills", "cohall", "SKILL.md"),
+    claude: join7(homedir4(), ".claude", "skills", "cohall", "SKILL.md"),
+    opencode: join7(homedir4(), ".config", "opencode", "skills", "cohall", "SKILL.md")
   };
   const selected = target === "all" ? Object.values(roots) : (target in roots) ? [roots[target]] : undefined;
   if (selected === undefined) {
     throw new Error("Skill target must be agents, claude, opencode, or all");
   }
   for (const path of selected) {
-    await mkdir5(dirname5(path), { recursive: true });
+    await mkdir6(dirname6(path), { recursive: true });
     await writeFile6(path, SKILL_default);
   }
   return selected;
@@ -4606,6 +5226,21 @@ var printHelp = () => console.log(help);
 var printSkill = () => console.log(SKILL_default.trimEnd());
 var runCli = async (command, raw) => {
   const arguments_ = parseArguments(raw);
+  if (command === "reply") {
+    allowOptions(arguments_, ["message", "message-file", "error"]);
+    const id = Schema10.decodeUnknownSync(TaskId)(identifier(arguments_, "task id"));
+    const error = option(arguments_, "error");
+    if (error !== undefined && (option(arguments_, "message") !== undefined || option(arguments_, "message-file") !== undefined)) {
+      throw new Error("Use either --error or --message/--message-file, not both");
+    }
+    const message = error === undefined ? await readInput(arguments_, "message") : undefined;
+    if (error === undefined && message === undefined) {
+      throw new Error("A bot reply requires --message, --message-file, or --error");
+    }
+    await writeBotReply(id, error === undefined ? { result: message ?? "" } : { error });
+    print({ submitted: true, task_id: id });
+    return;
+  }
   if (command === "init") {
     allowOptions(arguments_, [
       "client-only",
@@ -4731,7 +5366,7 @@ var runCli = async (command, raw) => {
       const { relay: relay2 } = await ownerClient();
       const restart = !arguments_.options.has("no-restart");
       if (arguments_.options.has("dry-run")) {
-        const devices = await Effect7.runPromise(relay2.devices());
+        const devices = await Effect9.runPromise(relay2.devices());
         assertDeviceOperationSupport(devices);
         print({
           dry_run: true,
@@ -4741,7 +5376,7 @@ var runCli = async (command, raw) => {
         });
         return;
       }
-      const operations = await Effect7.runPromise(relay2.createUpgradeOperations({ target: normalizedTarget, restart }));
+      const operations = await Effect9.runPromise(relay2.createUpgradeOperations({ target: normalizedTarget, restart }));
       print({
         queued: operations.length,
         requested_version: normalizedTarget,
@@ -4767,10 +5402,10 @@ var runCli = async (command, raw) => {
       if (arguments_.positionals.length !== 2 || arguments_.positionals[0] !== "abandon") {
         throw new Error("Usage: cohall upgrades [abandon <operation-id>]");
       }
-      print(await Effect7.runPromise(relay2.abandonOperation(Schema8.decodeUnknownSync(OperationId)(arguments_.positionals[1]))));
+      print(await Effect9.runPromise(relay2.abandonOperation(Schema10.decodeUnknownSync(OperationId)(arguments_.positionals[1]))));
       return;
     }
-    print(await Effect7.runPromise(relay2.operations()));
+    print(await Effect9.runPromise(relay2.operations()));
     return;
   }
   if (command === "join") {
@@ -4829,20 +5464,31 @@ var runCli = async (command, raw) => {
         device_credential: configuration2.deviceToken !== undefined,
         providers: configuration2.providers ?? "auto",
         model: configuration2.model,
-        sandbox: configuration2.sandbox
+        sandbox: configuration2.sandbox,
+        grok_gateway: configuration2.grokGateway
       }
     });
     return;
   }
   if (command === "configure") {
-    allowOptions(arguments_, ["model", "name", "providers", "relay", "sandbox", "workspace"]);
+    allowOptions(arguments_, [
+      "grok-gateway",
+      "model",
+      "name",
+      "providers",
+      "relay",
+      "sandbox",
+      "workspace"
+    ]);
     noPositionals(arguments_, command);
     const existing = await readStoredConfiguration();
     const relayUrl = normalizeRelayUrl(option(arguments_, "relay") ?? existing?.relayUrl ?? "http://127.0.0.1:8787");
     const supplied = values(arguments_, "workspace");
-    const workspaces = supplied.length === 0 ? existing?.workspaces ?? [] : await Effect7.runPromise(parseWorkspaces("", JSON.stringify(supplied)));
+    const workspaces = supplied.length === 0 ? existing?.workspaces ?? [] : await Effect9.runPromise(parseWorkspaces("", JSON.stringify(supplied)));
     const sandbox = option(arguments_, "sandbox");
     const model = option(arguments_, "model") ?? existing?.model;
+    const gatewayInput = option(arguments_, "grok-gateway") ?? existing?.grokGateway;
+    const grokGateway = gatewayInput === undefined ? undefined : resolve3(gatewayInput);
     const providerInput = option(arguments_, "providers");
     const providers = providerInput === undefined ? existing?.providers : providerInput === "auto" ? undefined : parseProviders(providerInput);
     const configuration2 = StoredConfiguration.make({
@@ -4854,8 +5500,9 @@ var runCli = async (command, raw) => {
       ...credentialsForRelay(existing, relayUrl),
       ...providers === undefined ? {} : { providers },
       ...model === undefined ? {} : { model },
+      ...grokGateway === undefined ? {} : { grokGateway },
       ...(sandbox ?? existing?.sandbox) === undefined ? {} : {
-        sandbox: Schema8.decodeUnknownSync(Schema8.Literals(["read-only", "workspace-write", "danger-full-access"]))(sandbox ?? existing?.sandbox)
+        sandbox: Schema10.decodeUnknownSync(Schema10.Literals(["read-only", "workspace-write", "danger-full-access"]))(sandbox ?? existing?.sandbox)
       }
     });
     await writeStoredConfiguration(configuration2);
@@ -4898,7 +5545,7 @@ var runCli = async (command, raw) => {
     noPositionals(arguments_, command);
     if (arguments_.options.has("all")) {
       const { relay: relay2 } = await client();
-      print(allDeviceHealth(await Effect7.runPromise(relay2.devices()), version));
+      print(allDeviceHealth(await Effect9.runPromise(relay2.devices()), version));
       return;
     }
     const configuration2 = await readStoredConfiguration();
@@ -4911,14 +5558,18 @@ var runCli = async (command, raw) => {
     });
     const providerInput = process.env.COHALL_DEVICE_PROVIDERS;
     const selectedProviders = providerInput === undefined ? configuration2?.providers : providerInput === "auto" ? undefined : parseProviders(providerInput);
-    const providerExecutables = Object.fromEntries(Provider.literals.map((provider) => [
+    const providerExecutables = Object.fromEntries(Provider.literals.filter((provider) => provider !== "grok-bot").map((provider) => [
       provider,
       findExecutable(provider === "claude-code" ? "claude" : provider) ?? "not found"
     ]));
+    const grokGateway = process.env.COHALL_GROK_GATEWAY ?? configuration2?.grokGateway;
+    const grokBots = grokGateway === undefined ? undefined : await discoverGrokBots(grokGateway).catch(() => {
+      return;
+    });
     const clientToken = process.env.COHALL_CLIENT_TOKEN ?? storedCredentials.clientToken;
     const hasDeviceCredential = process.env.COHALL_DEVICE_TOKEN !== undefined || storedCredentials.deviceToken !== undefined;
     const deviceId = process.env.COHALL_DEVICE_ID ?? configuration2?.deviceId;
-    const currentDevice = response?.ok !== true || clientToken === undefined || deviceId === undefined ? undefined : await Effect7.runPromise(exports_src.make({ baseUrl: relayUrl, token: clientToken }).devices()).then((devices) => devices.find((device) => device.id === deviceId)).catch(() => {
+    const currentDevice = response?.ok !== true || clientToken === undefined || deviceId === undefined ? undefined : await Effect9.runPromise(exports_src.make({ baseUrl: relayUrl, token: clientToken }).devices()).then((devices) => devices.find((device) => device.id === deviceId)).catch(() => {
       return;
     });
     const versionWarning = deviceVersionWarning(version, currentDevice?.version);
@@ -4928,7 +5579,9 @@ var runCli = async (command, raw) => {
       ...hasDeviceCredential && response?.ok === true && currentDevice?.status !== "online" && currentDevice?.status !== "busy" ? [
         clientToken === undefined ? "Device status cannot be checked without a client credential" : "Device daemon is not connected or is not registered with the relay"
       ] : [],
-      ...selectedProviders?.flatMap((provider) => providerExecutables[provider] === "not found" ? [`Configured provider ${provider} is not installed or not on PATH`] : []) ?? []
+      ...selectedProviders?.flatMap((provider) => provider === "grok-bot" ? grokBots === undefined ? [
+        "Configured Grok Bot gateway is unavailable; check its discovery file and host process"
+      ] : [] : providerExecutables[provider] === "not found" ? [`Configured provider ${provider} is not installed or not on PATH`] : []) ?? []
     ];
     print({
       version,
@@ -4939,6 +5592,13 @@ var runCli = async (command, raw) => {
       device_credential: hasDeviceCredential,
       workspaces: configuration2?.workspaces ?? [],
       providers: providerExecutables,
+      ...grokGateway === undefined ? {} : {
+        grok_gateway: {
+          path: grokGateway,
+          reachable: grokBots !== undefined,
+          bots: grokBots?.length ?? 0
+        }
+      },
       provider_selection: selectedProviders ?? "auto",
       provider_authentication: "checked when delegated work starts",
       device_status: hasDeviceCredential === false ? "not configured" : currentDevice?.status ?? "unknown",
@@ -4951,7 +5611,7 @@ var runCli = async (command, raw) => {
     allowOptions(arguments_, []);
     noPositionals(arguments_, command);
     const { relay: relay2 } = await client();
-    print(deviceVersions(await Effect7.runPromise(relay2.devices()), version));
+    print(deviceVersions(await Effect9.runPromise(relay2.devices()), version));
     return;
   }
   if (command === "usage") {
@@ -4959,7 +5619,7 @@ var runCli = async (command, raw) => {
     noPositionals(arguments_, command);
     const { relay: relay2 } = await client();
     print({
-      ...await Effect7.runPromise(relay2.usage()),
+      ...await Effect9.runPromise(relay2.usage()),
       scope: "Retained Cohall task activity; provider token and billing usage are not available."
     });
     return;
@@ -4970,7 +5630,7 @@ var runCli = async (command, raw) => {
       allowOptions(arguments_, ["client-only", "label"]);
       noPositionals(arguments_, command);
       const roles = arguments_.options.has("client-only") ? ["client"] : ["client", "device"];
-      const credential = await Effect7.runPromise(relay2.createPairing({ label: option(arguments_, "label") ?? "Cohall device", roles }));
+      const credential = await Effect9.runPromise(relay2.createPairing({ label: option(arguments_, "label") ?? "Cohall device", roles }));
       print({
         relay_url: configuration2.relayUrl,
         pairing_token: credential.token,
@@ -4982,30 +5642,37 @@ var runCli = async (command, raw) => {
     if (command === "sessions") {
       allowOptions(arguments_, []);
       noPositionals(arguments_, command);
-      print(await Effect7.runPromise(relay2.authSessions()));
+      print(await Effect9.runPromise(relay2.authSessions()));
       return;
     }
     if (command === "forget") {
       allowOptions(arguments_, []);
-      print(await Effect7.runPromise(relay2.forgetDevice(Schema8.decodeUnknownSync(DeviceId)(identifier(arguments_, "device id")))));
+      print(await Effect9.runPromise(relay2.forgetDevice(Schema10.decodeUnknownSync(DeviceId)(identifier(arguments_, "device id")))));
       return;
     }
     allowOptions(arguments_, []);
-    print(await Effect7.runPromise(relay2.revokeAuthSession(Schema8.decodeUnknownSync(AuthSessionId)(identifier(arguments_, "session id")))));
+    print(await Effect9.runPromise(relay2.revokeAuthSession(Schema10.decodeUnknownSync(AuthSessionId)(identifier(arguments_, "session id")))));
     return;
   }
   const { configuration, relay } = await client();
   if (command === "devices") {
     allowOptions(arguments_, []);
     noPositionals(arguments_, command);
-    print(await Effect7.runPromise(relay.devices()));
+    print(await Effect9.runPromise(relay.devices()));
     return;
   }
-  if (command === "delegate") {
+  if (command === "bots") {
+    allowOptions(arguments_, []);
+    noPositionals(arguments_, command);
+    print(listBots(await Effect9.runPromise(relay.devices())));
+    return;
+  }
+  if (command === "delegate" || command === "send") {
     allowOptions(arguments_, [
       "context",
       "context-file",
       "no-wait",
+      "parent",
       "prompt",
       "prompt-file",
       "provider",
@@ -5014,66 +5681,73 @@ var runCli = async (command, raw) => {
       "timeout",
       "workspace"
     ]);
+    const positionalTarget = command === "send" && arguments_.positionals[0]?.startsWith("@") ? arguments_.positionals[0] : undefined;
+    const positionals = positionalTarget === undefined ? arguments_.positionals : arguments_.positionals.slice(1);
+    if (positionalTarget !== undefined && option(arguments_, "target") !== undefined) {
+      throw new Error("Use either a positional target or --target, not both");
+    }
     if (option(arguments_, "prompt") === "-" && option(arguments_, "context") === "-") {
       throw new Error("Only one of --prompt and --context may read from stdin");
     }
     const suppliedPrompt = await readInput(arguments_, "prompt");
-    const prompt = suppliedPrompt ?? arguments_.positionals.join(" ");
+    const prompt = suppliedPrompt ?? positionals.join(" ");
     if (prompt.trim().length === 0) {
       throw new Error("A prompt is required");
     }
-    if (suppliedPrompt !== undefined && arguments_.positionals.length > 0) {
+    if (suppliedPrompt !== undefined && positionals.length > 0) {
       throw new Error("Use either a positional prompt or --prompt, not both");
     }
     const context = await readInput(arguments_, "context");
-    const target = option(arguments_, "target");
+    const target = positionalTarget ?? option(arguments_, "target");
     const thread = option(arguments_, "thread");
     const workspace = option(arguments_, "workspace");
     const provider = option(arguments_, "provider");
-    const task = await Effect7.runPromise(createDelegation(relay, configuration, {
+    const parent = option(arguments_, "parent");
+    const task = await Effect9.runPromise(createDelegation(relay, configuration, {
       prompt,
       ...target === undefined ? {} : { target },
       ...context === undefined ? {} : { context },
-      ...thread === undefined ? {} : { threadId: Schema8.decodeUnknownSync(ThreadId)(thread) },
+      ...thread === undefined ? {} : { threadId: Schema10.decodeUnknownSync(ThreadId)(thread) },
+      ...parent === undefined ? {} : { parentTaskId: Schema10.decodeUnknownSync(TaskId)(parent) },
       ...workspace === undefined ? {} : { workspace },
-      ...provider === undefined ? {} : { provider: Schema8.decodeUnknownSync(Provider)(provider) }
+      ...provider === undefined ? {} : { provider: Schema10.decodeUnknownSync(Provider)(provider) }
     }));
-    print(taskResult(arguments_.options.has("no-wait") ? task : await Effect7.runPromise(waitForTask(relay, task, timeout(arguments_)))));
+    print(taskResult(arguments_.options.has("no-wait") ? task : await Effect9.runPromise(waitForTask(relay, task, timeout(arguments_)))));
     return;
   }
   if (command === "status") {
     allowOptions(arguments_, []);
-    const id = Schema8.decodeUnknownSync(TaskId)(identifier(arguments_, "task id"));
-    print(taskResult(await Effect7.runPromise(relay.getTask(id))));
+    const id = Schema10.decodeUnknownSync(TaskId)(identifier(arguments_, "task id"));
+    print(taskResult(await Effect9.runPromise(relay.getTask(id))));
     return;
   }
   if (command === "trace") {
     allowOptions(arguments_, ["follow"]);
-    const id = Schema8.decodeUnknownSync(TaskId)(identifier(arguments_, "task id"));
+    const id = Schema10.decodeUnknownSync(TaskId)(identifier(arguments_, "task id"));
     if (arguments_.options.has("follow")) {
-      await Effect7.runPromise(followTaskTrace(relay, id, printLine));
+      await Effect9.runPromise(followTaskTrace(relay, id, printLine));
       return;
     }
-    print(await Effect7.runPromise(relay.traceTask(id)));
+    print(await Effect9.runPromise(relay.traceTask(id)));
     return;
   }
   if (command === "wait") {
     allowOptions(arguments_, ["timeout"]);
-    const id = Schema8.decodeUnknownSync(TaskId)(identifier(arguments_, "task id"));
-    const task = await Effect7.runPromise(relay.getTask(id));
-    print(taskResult(await Effect7.runPromise(waitForTask(relay, task, timeout(arguments_)))));
+    const id = Schema10.decodeUnknownSync(TaskId)(identifier(arguments_, "task id"));
+    const task = await Effect9.runPromise(relay.getTask(id));
+    print(taskResult(await Effect9.runPromise(waitForTask(relay, task, timeout(arguments_)))));
     return;
   }
   if (command === "cancel") {
     allowOptions(arguments_, []);
-    const id = Schema8.decodeUnknownSync(TaskId)(identifier(arguments_, "task id"));
-    print(taskResult(await Effect7.runPromise(relay.cancelTask(id))));
+    const id = Schema10.decodeUnknownSync(TaskId)(identifier(arguments_, "task id"));
+    print(taskResult(await Effect9.runPromise(relay.cancelTask(id))));
     return;
   }
   if (command === "thread") {
     allowOptions(arguments_, []);
-    const id = Schema8.decodeUnknownSync(ThreadId)(identifier(arguments_, "thread id"));
-    print(await Effect7.runPromise(threadContext(relay, id)));
+    const id = Schema10.decodeUnknownSync(ThreadId)(identifier(arguments_, "thread id"));
+    print(await Effect9.runPromise(threadContext(relay, id)));
     return;
   }
   throw new Error(`Unknown Cohall command: ${command}`);
@@ -5081,15 +5755,15 @@ var runCli = async (command, raw) => {
 
 // apps/device/src/daemon.ts
 init_src();
-import { Effect as Effect8, Schedule as Schedule2, Schema as Schema9 } from "effect";
+import { Effect as Effect10, Schedule as Schedule3, Schema as Schema11 } from "effect";
 import { constants as constants3 } from "node:fs";
-import { open, realpath as realpath5, stat as stat4 } from "node:fs/promises";
-import { arch, hostname as hostname3, platform as platform3 } from "node:os";
+import { open as open3, realpath as realpath5, stat as stat4 } from "node:fs/promises";
+import { arch, hostname as hostname3, platform as platform4 } from "node:os";
 import { basename as basename2, isAbsolute as isAbsolute3, relative as relative2 } from "node:path";
 import { WebSocket as WebSocket2 } from "ws";
 var maxQueuedRelayMessages = 8;
 
-class DeviceConnectionError extends Schema9.TaggedErrorClass()("Device.ConnectionError", { message: Schema9.String }) {
+class DeviceConnectionError extends Schema11.TaggedErrorClass()("Device.ConnectionError", { message: Schema11.String }) {
 }
 var socketUrl = (configuration) => {
   const url = new URL(configuration.relayUrl);
@@ -5105,15 +5779,17 @@ var providerLabel = (provider) => {
       return "Claude Code";
     case "opencode":
       return "OpenCode";
+    case "grok-bot":
+      return "Grok Bot";
   }
 };
 var capabilities = (providers) => {
   const values2 = providers.map((provider) => ({
     id: provider,
     label: providerLabel(provider),
-    detail: `${providerLabel(provider)} executable detected; authentication is checked when work starts`
+    detail: provider === "grok-bot" ? "Named bots through this computer's local Grok Bot gateway" : `${providerLabel(provider)} executable detected; authentication is checked when work starts`
   }));
-  if (findExecutable("google-chrome") !== undefined || findExecutable("chromium") !== undefined || platform3() === "darwin") {
+  if (findExecutable("google-chrome") !== undefined || findExecutable("chromium") !== undefined || platform4() === "darwin") {
     values2.push({ id: "browser-session", label: "Signed-in browser" });
   }
   if (findExecutable("xcodebuild") !== undefined) {
@@ -5125,10 +5801,13 @@ var capabilities = (providers) => {
   return values2;
 };
 var selectProviders = (installed, configured) => configured === undefined ? installed : configured.filter((provider) => installed.includes(provider));
-var describeDevice = (configuration, status = "online") => {
-  const operatingSystem2 = platform3();
+var describeDevice = (configuration, status = "online", bots = []) => {
+  const operatingSystem2 = platform4();
   const platformName = operatingSystem2 === "darwin" || operatingSystem2 === "linux" ? operatingSystem2 : operatingSystem2 === "win32" ? "windows" : "unknown";
-  const installed = availableProviders();
+  const installed = [
+    ...availableProviders(),
+    ...configuration.grokGateway === undefined ? [] : ["grok-bot"]
+  ];
   const providers = selectProviders(installed, configuration.providers);
   return Device.make({
     id: configuration.id,
@@ -5138,6 +5817,7 @@ var describeDevice = (configuration, status = "online") => {
     architecture: arch(),
     status,
     providers,
+    ...providers.includes("grok-bot") ? { bots } : {},
     capabilities: capabilities(providers),
     workspaces: configuration.workspaces.map((path) => ({
       path,
@@ -5164,9 +5844,9 @@ var allowedWorkspace = async (configuration, requested) => {
 };
 var openAllowedWorkspace = async (configuration, requested) => {
   const path = await allowedWorkspace(configuration, requested);
-  const operatingSystem2 = platform3();
+  const operatingSystem2 = platform4();
   const flags = constants3.O_RDONLY | (operatingSystem2 === "win32" ? 0 : constants3.O_DIRECTORY | constants3.O_NOFOLLOW);
-  const handle = await open(path, flags);
+  const handle = await open3(path, flags);
   const identity = await handle.stat();
   if (!identity.isDirectory()) {
     await handle.close();
@@ -5249,15 +5929,47 @@ var rememberOperation = (state, operationId) => {
   }
 };
 var sessionKey = (task) => `${task.threadId}:${task.provider}`;
+var drain = (configuration, state) => {
+  if (state.operation !== undefined) {
+    return;
+  }
+  if (state.tasks.size === 0) {
+    const operation = state.operationQueue.shift();
+    if (operation !== undefined) {
+      executeOperation(configuration, state, operation);
+      return;
+    }
+  }
+  const occupied = new Set([...state.tasks.values()].map(({ task }) => taskSlot(task)));
+  for (let index = 0;index < state.queue.length; ) {
+    const next = state.queue[index];
+    if (next === undefined || occupied.has(taskSlot(next))) {
+      index += 1;
+      continue;
+    }
+    state.queue.splice(index, 1);
+    occupied.add(taskSlot(next));
+    execute(configuration, state, next);
+  }
+};
 var execute = (configuration, state, task) => {
   if (state.tasks.has(task.id) || state.completed.has(task.id)) {
     return;
   }
   const controller = new AbortController;
-  state.tasks.set(task.id, controller);
+  state.tasks.set(task.id, { task, controller });
   send(state, SocketEvent.make({ _tag: "TaskAccepted", taskId: task.id }));
-  const workflow = Effect8.gen(function* () {
-    const workspace = yield* Effect8.tryPromise({
+  const workflow = Effect10.gen(function* () {
+    if (task.provider === "grok-bot") {
+      return yield* Effect10.tryPromise({
+        try: (signal) => runGrokBot(configuration.grokGateway, task, signal),
+        catch: (cause) => new ProviderRunError({
+          provider: task.provider,
+          message: cause instanceof Error ? cause.message : String(cause)
+        })
+      });
+    }
+    const workspace = yield* Effect10.tryPromise({
       try: () => openAllowedWorkspace(configuration, task.workspace),
       catch: (cause) => new ProviderRunError({
         provider: task.provider,
@@ -5268,17 +5980,18 @@ var execute = (configuration, state, task) => {
     return yield* run({
       provider: task.provider,
       threadId: task.threadId,
+      taskId: task.id,
       prompt: promptFor(task, configuration.name),
       cwd: workspace.cwd,
       beforeSpawn: workspace.validate,
       ...sessionId === undefined ? {} : { sessionId },
       ...configuration.model === undefined ? {} : { model: configuration.model },
       ...configuration.sandbox === undefined ? {} : { sandbox: configuration.sandbox }
-    }).pipe(Effect8.ensuring(Effect8.promise(() => workspace.close().catch(() => {
+    }).pipe(Effect10.ensuring(Effect10.promise(() => workspace.close().catch(() => {
       return;
     }))));
   });
-  Effect8.runPromise(workflow, { signal: controller.signal }).then((result) => {
+  Effect10.runPromise(workflow, { signal: controller.signal }).then((result) => {
     if (result.sessionId !== undefined) {
       state.sessions.set(sessionKey(task), result.sessionId);
     }
@@ -5298,15 +6011,7 @@ var execute = (configuration, state, task) => {
     }));
   }).finally(() => {
     state.tasks.delete(task.id);
-    const operation = state.operationQueue.shift();
-    if (operation !== undefined) {
-      executeOperation(configuration, state, operation);
-      return;
-    }
-    const next = state.queue.shift();
-    if (next !== undefined && state.operation === undefined) {
-      execute(configuration, state, next);
-    }
+    drain(configuration, state);
   });
 };
 var executeOperation = (configuration, state, operation) => {
@@ -5331,15 +6036,7 @@ var executeOperation = (configuration, state, operation) => {
     }));
   }).finally(() => {
     state.operation = undefined;
-    const pending = state.operationQueue.shift();
-    if (pending !== undefined) {
-      executeOperation(configuration, state, pending);
-      return;
-    }
-    const next = state.queue.shift();
-    if (next !== undefined && state.tasks.size === 0) {
-      execute(configuration, state, next);
-    }
+    drain(configuration, state);
   });
 };
 var scheduleOperation = (configuration, state, operation) => {
@@ -5370,7 +6067,7 @@ var schedule = (configuration, state, task) => {
   if (task.providerSessionId !== undefined) {
     state.sessions.set(sessionKey(task), task.providerSessionId);
   }
-  if (state.tasks.size > 0 || state.operation !== undefined) {
+  if ([...state.tasks.values()].some(({ task: active }) => taskSlot(active) === taskSlot(task)) || state.operation !== undefined) {
     if (state.queue.length >= 100) {
       state.socket?.close(4008, "Task queue limit reached");
       return;
@@ -5383,7 +6080,9 @@ var schedule = (configuration, state, task) => {
 var cancel = (state, taskId) => {
   const running = state.tasks.get(taskId);
   if (running !== undefined) {
-    running.abort();
+    if (running.task.provider !== "grok-bot") {
+      running.controller.abort();
+    }
     return;
   }
   const index = state.queue.findIndex((task) => task.id === taskId);
@@ -5393,18 +6092,39 @@ var cancel = (state, taskId) => {
   remember(state, taskId);
   sendTerminal(state, taskId, SocketEvent.make({ _tag: "TaskCancelled", taskId }));
 };
-var connect = (configuration, state) => Effect8.tryPromise({
+var connect = (configuration, state) => Effect10.tryPromise({
   try: (signal) => new Promise((complete) => {
     const socket = new WebSocket2(socketUrl(configuration), {
       maxPayload: maxSocketPayloadBytes,
-      perMessageDeflate: false
+      perMessageDeflate: false,
+      allowSynchronousEvents: false
     });
+    let bots = [];
+    let refreshing = false;
+    const refreshBots = async () => {
+      if (refreshing || configuration.grokGateway === undefined || configuration.providers !== undefined && !configuration.providers.includes("grok-bot")) {
+        return;
+      }
+      refreshing = true;
+      bots = await discoverGrokBots(configuration.grokGateway).catch(() => []);
+      refreshing = false;
+      if (!closed) {
+        send(state, SocketEvent.make({
+          _tag: "DeviceHeartbeat",
+          deviceId: configuration.id,
+          status: state.tasks.size > 0 || state.operation !== undefined ? "busy" : "online",
+          bots
+        }));
+      }
+    };
     const heartbeat = setInterval(() => {
       send(state, SocketEvent.make({
         _tag: "DeviceHeartbeat",
         deviceId: configuration.id,
-        status: state.tasks.size > 0 || state.operation !== undefined ? "busy" : "online"
+        status: state.tasks.size > 0 || state.operation !== undefined ? "busy" : "online",
+        ...configuration.grokGateway === undefined ? {} : { bots }
       }));
+      refreshBots();
     }, 15000);
     let closed = false;
     let queuedMessages = 0;
@@ -5436,16 +6156,16 @@ var connect = (configuration, state) => Effect8.tryPromise({
         if (closed) {
           return;
         }
-        const text2 = Buffer.isBuffer(message) ? message.toString("utf8") : message instanceof ArrayBuffer ? Buffer.from(message).toString("utf8") : Array.isArray(message) ? Buffer.concat(message).toString("utf8") : Buffer.from(message).toString("utf8");
-        const event = await Effect8.runPromise(Effect8.try({
-          try: () => JSON.parse(text2),
+        const text3 = Buffer.isBuffer(message) ? message.toString("utf8") : message instanceof ArrayBuffer ? Buffer.from(message).toString("utf8") : Array.isArray(message) ? Buffer.concat(message).toString("utf8") : Buffer.from(message).toString("utf8");
+        const event = await Effect10.runPromise(Effect10.try({
+          try: () => JSON.parse(text3),
           catch: () => new DeviceConnectionError({ message: "Relay sent invalid JSON" })
-        }).pipe(Effect8.flatMap(decodeSocketEvent)));
+        }).pipe(Effect10.flatMap(decodeSocketEvent)));
         if (event._tag === "Connected") {
           state.socket = socket;
           socket.send(JSON.stringify(SocketEvent.make({
             _tag: "DeviceHello",
-            device: describeDevice(configuration, state.tasks.size > 0 || state.operation !== undefined ? "busy" : "online")
+            device: describeDevice(configuration, state.tasks.size > 0 || state.operation !== undefined ? "busy" : "online", bots)
           })));
           for (const payload of state.terminal.values()) {
             socket.send(payload);
@@ -5453,6 +6173,7 @@ var connect = (configuration, state) => Effect8.tryPromise({
           for (const payload of state.operationTerminal.values()) {
             socket.send(payload);
           }
+          refreshBots();
           return;
         }
         if (event._tag === "TaskAssigned") {
@@ -5465,6 +6186,9 @@ var connect = (configuration, state) => Effect8.tryPromise({
         }
         if (event._tag === "TaskSettled") {
           state.terminal.delete(event.taskId);
+          cleanupBotReply(event.taskId).catch(() => {
+            console.error(`Could not remove local bot reply for settled task ${event.taskId}`);
+          });
           return;
         }
         if (event._tag === "OperationAssigned") {
@@ -5505,9 +6229,9 @@ var runDaemon = (configuration) => {
     operationTerminal: new Map,
     completedOperations: new Set
   };
-  return connect(configuration, state).pipe(Effect8.repeat({ schedule: Schedule2.spaced("2 seconds") }), Effect8.ensuring(Effect8.sync(() => {
+  return connect(configuration, state).pipe(Effect10.repeat({ schedule: Schedule3.spaced("2 seconds") }), Effect10.ensuring(Effect10.sync(() => {
     state.socket?.close();
-    for (const controller of state.tasks.values()) {
+    for (const { controller } of state.tasks.values()) {
       controller.abort();
     }
   })));
@@ -5517,7 +6241,7 @@ var runDaemon = (configuration) => {
 init_src();
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { Effect as Effect9 } from "effect";
+import { Effect as Effect11 } from "effect";
 import * as z from "zod/v4";
 var output = (value) => ({
   content: [{ type: "text", text: JSON.stringify(value, null, 2) }]
@@ -5532,41 +6256,58 @@ var runMcp = async (configuration) => {
     title: "List Cohall devices",
     description: "List devices, their availability, local providers, capabilities, and allowed workspaces.",
     inputSchema: {}
-  }, async () => output(await Effect9.runPromise(client2.devices())));
+  }, async () => output(await Effect11.runPromise(client2.devices())));
+  server.registerTool("list_bots", {
+    title: "List Cohall bots",
+    description: "List named Grok Bots on paired devices, their host availability, and unambiguous targets for delegate. Bot names can also be used when unique.",
+    inputSchema: {}
+  }, async () => output(listBots(await Effect11.runPromise(client2.devices()))));
   server.registerTool("delegate", {
-    title: "Delegate work to another device",
-    description: "Send focused work to another Cohall device. When the request depends on the current conversation, distill its motivation, relevant facts, prior findings, constraints, and desired decision into context; Cohall cannot read the host transcript. Never forward unrelated transcript content. Reuse thread_id for related follow-ups.",
+    title: "Send work to a device or bot",
+    description: "Send focused work to a Cohall device or named Grok Bot. When the request depends on the current conversation, distill its motivation, relevant facts, prior findings, constraints, and desired decision into context; Cohall cannot read the host transcript. Never forward unrelated transcript content. Reuse thread_id for related follow-ups. Grok Bots use their existing conversation; a Cohall thread does not isolate it.",
     inputSchema: {
       prompt: z.string().min(1).max(131072),
-      target: z.string().optional().describe("Device name, @name, hostname, or ID"),
-      provider: z.enum(["codex", "claude-code", "opencode"]).default("codex"),
+      target: z.string().optional().describe("Device name, hostname or ID; @BotName; or @device/BotName. Use list_bots targets to disambiguate."),
+      provider: z.enum(Provider.literals).optional().describe("Inferred as grok-bot for a bot target; otherwise defaults to codex."),
       context: z.string().max(131072).optional().describe("Distilled context the target needs: why the user is asking, relevant facts and prior findings, constraints, and the intended decision. The calling agent must supply this when the prompt depends on its conversation; omit it only for a self-contained task."),
       thread_id: z.string().uuid().optional(),
-      workspace: z.string().max(4096).optional(),
+      parent_task_id: z.string().uuid().optional().describe("The task delegating this work. Inherited from COHALL_TASK_ID when present."),
+      workspace: z.string().max(4096).optional().describe("Coding provider workspace. Omit for named Grok Bots."),
       wait: z.boolean().default(true),
       timeout_seconds: z.number().int().min(5).max(86400).default(900)
     }
-  }, async ({ prompt, target, provider, context, thread_id, workspace, wait, timeout_seconds }) => {
-    const task = await Effect9.runPromise(createDelegation(client2, configuration, {
+  }, async ({
+    prompt,
+    target,
+    provider,
+    context,
+    thread_id,
+    parent_task_id,
+    workspace,
+    wait,
+    timeout_seconds
+  }) => {
+    const task = await Effect11.runPromise(createDelegation(client2, configuration, {
       prompt,
-      provider,
+      ...provider === undefined ? {} : { provider },
       ...target === undefined ? {} : { target },
       ...context === undefined ? {} : { context },
       ...thread_id === undefined ? {} : { threadId: ThreadId.make(thread_id) },
+      ...parent_task_id === undefined ? {} : { parentTaskId: TaskId.make(parent_task_id) },
       ...workspace === undefined ? {} : { workspace }
     }));
-    return output(taskResult(wait ? await Effect9.runPromise(waitForTask(client2, task, timeout_seconds)) : task));
+    return output(taskResult(wait ? await Effect11.runPromise(waitForTask(client2, task, timeout_seconds)) : task));
   });
   server.registerTool("task_status", {
     title: "Get delegated task status",
     description: "Read the current state and result of a Cohall task.",
     inputSchema: { task_id: z.string().uuid() }
-  }, async ({ task_id }) => output(taskResult(await Effect9.runPromise(client2.getTask(TaskId.make(task_id))))));
+  }, async ({ task_id }) => output(taskResult(await Effect11.runPromise(client2.getTask(TaskId.make(task_id))))));
   server.registerTool("task_trace", {
     title: "Trace a delegated task",
     description: "Read the redacted relay and device lifecycle for troubleshooting a Cohall task.",
     inputSchema: { task_id: z.string().uuid() }
-  }, async ({ task_id }) => output(await Effect9.runPromise(client2.traceTask(TaskId.make(task_id)))));
+  }, async ({ task_id }) => output(await Effect11.runPromise(client2.traceTask(TaskId.make(task_id)))));
   server.registerTool("wait_task", {
     title: "Wait for delegated work",
     description: "Wait for a Cohall task to finish and return its final result.",
@@ -5575,19 +6316,19 @@ var runMcp = async (configuration) => {
       timeout_seconds: z.number().int().min(5).max(86400).default(900)
     }
   }, async ({ task_id, timeout_seconds }) => {
-    const task = await Effect9.runPromise(client2.getTask(TaskId.make(task_id)));
-    return output(taskResult(await Effect9.runPromise(waitForTask(client2, task, timeout_seconds))));
+    const task = await Effect11.runPromise(client2.getTask(TaskId.make(task_id)));
+    return output(taskResult(await Effect11.runPromise(waitForTask(client2, task, timeout_seconds))));
   });
   server.registerTool("cancel_task", {
     title: "Cancel delegated work",
-    description: "Request cancellation and return its acknowledged or pending state.",
+    description: "Request cancellation of coding work or a queued Bot task. Active Grok Bot tasks must be stopped in Grok Bot.",
     inputSchema: { task_id: z.string().uuid() }
-  }, async ({ task_id }) => output(taskResult(await Effect9.runPromise(client2.cancelTask(TaskId.make(task_id))))));
+  }, async ({ task_id }) => output(taskResult(await Effect11.runPromise(client2.cancelTask(TaskId.make(task_id))))));
   server.registerTool("thread_context", {
     title: "Read a Cohall thread",
     description: "Read shared task prompts and final results for a cross-device thread.",
     inputSchema: { thread_id: z.string().uuid() }
-  }, async ({ thread_id }) => output(await Effect9.runPromise(threadContext(client2, ThreadId.make(thread_id)))));
+  }, async ({ thread_id }) => output(await Effect11.runPromise(threadContext(client2, ThreadId.make(thread_id)))));
   await server.connect(new StdioServerTransport);
 };
 
@@ -5616,12 +6357,12 @@ var main = async () => {
     return;
   }
   if (command === "device") {
-    const configuration = await Effect13.runPromise(loadDeviceConfiguration);
-    await Effect13.runPromise(runDaemon(configuration));
+    const configuration = await Effect15.runPromise(loadDeviceConfiguration);
+    await Effect15.runPromise(runDaemon(configuration));
     return;
   }
   if (command === "mcp") {
-    const configuration = await Effect13.runPromise(loadClientConfiguration);
+    const configuration = await Effect15.runPromise(loadClientConfiguration);
     await runMcp(configuration);
     return;
   }
@@ -5632,4 +6373,4 @@ await main().catch((cause) => {
   process.exitCode = 1;
 });
 
-//# debugId=28F1D5ED59BE527664756E2164756E21
+//# debugId=F147BDC9F8E0C7EE64756E2164756E21