@akshar5/cohall 0.6.2 → 0.8.0

package/bin/cohall.js

@@ -17,7 +17,7 @@ var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
 // packages/protocol/src/index.ts
 import { Effect, Schema } from "effect";
-var version = "0.6.2", 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$/, {
+var version = "0.8.0", maxSocketPayloadBytes, maxAttachmentBytes, maxTaskAttachments = 2, 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)), 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);
@@ -50,18 +50,19 @@ var version = "0.6.2", 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, validBotTarget = (input) => {
+}, Thread, Message, AttachmentName, AttachmentDirection, TaskAttachment, InputAttachment, attachments, 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, TaskInboxItem, TaskInbox, 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;
+  maxAttachmentBytes = 256 * 1024;
   count = Schema.Int.check(Schema.isBetween({ minimum: 0, maximum: Number.MAX_SAFE_INTEGER }));
   BotId = bounded(256).pipe(Schema.brand("BotId"));
   Bot = Schema.Struct({
@@ -167,6 +168,18 @@ var init_src = __esm(() => {
     taskId: Schema.optionalKey(TaskId),
     deviceId: Schema.optionalKey(DeviceId)
   });
+  AttachmentName = Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(128), Schema.makeFilter((name) => name !== "." && name !== ".." && !/[<>:"/\\|?*]/.test(name) && !/[. ]$/.test(name) && !/^(?:CON|PRN|AUX|NUL|CONIN\$|CONOUT\$|COM[1-9¹²³]|LPT[1-9¹²³])(?:\.|$)/i.test(name) && new TextEncoder().encode(name).byteLength <= 128 && [...name].every((character) => character.charCodeAt(0) >= 32 && character.charCodeAt(0) !== 127) ? undefined : "Use a file name without path separators or control characters"));
+  AttachmentDirection = Schema.Literals(["input", "output"]);
+  TaskAttachment = Schema.Struct({
+    name: AttachmentName,
+    direction: AttachmentDirection,
+    bytes: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: maxAttachmentBytes }))
+  });
+  InputAttachment = Schema.Struct({
+    name: AttachmentName,
+    data: Schema.String.check(Schema.isMaxLength(Math.ceil(maxAttachmentBytes / 3) * 4), Schema.makeFilter((value) => value.length > 0 && value.length % 4 === 0 && value.length / 4 * 3 - (value.endsWith("==") ? 2 : value.endsWith("=") ? 1 : 0) <= maxAttachmentBytes && /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(value) ? undefined : "Expected nonempty base64 data"))
+  });
+  attachments = boundedArray(InputAttachment, maxTaskAttachments).check(Schema.makeFilter((files) => new Set(files.map((file) => file.name.normalize("NFC").toLocaleLowerCase("en-US"))).size === files.length ? undefined : "Attachment names must be unique"));
   Task = Schema.Struct({
     id: TaskId,
     threadId: ThreadId,
@@ -181,12 +194,29 @@ var init_src = __esm(() => {
     workspace: Schema.optionalKey(bounded(4096)),
     providerSessionId: Schema.optionalKey(bounded(4096)),
     result: Schema.optionalKey(optionalText(131072)),
+    inputAttachmentNames: Schema.optionalKey(boundedArray(AttachmentName, maxTaskAttachments)),
     error: Schema.optionalKey(optionalText(16384)),
     createdAt: Timestamp,
     updatedAt: Timestamp,
     startedAt: Schema.optionalKey(Timestamp),
     completedAt: Schema.optionalKey(Timestamp)
   }).check(Schema.makeFilter(validBotTarget));
+  TaskInboxItem = Schema.Struct({
+    id: TaskId,
+    threadId: ThreadId,
+    targetDeviceId: DeviceId,
+    provider: Provider,
+    botId: Schema.optionalKey(BotId),
+    status: Schema.Literals(["completed", "failed", "cancelled"]),
+    promptPreview: optionalText(320),
+    resultPreview: Schema.optionalKey(optionalText(1024)),
+    errorPreview: Schema.optionalKey(optionalText(1024)),
+    completedAt: Timestamp
+  });
+  TaskInbox = Schema.Struct({
+    items: boundedArray(TaskInboxItem, 20),
+    hasMore: Schema.Boolean
+  });
   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"
   }));
@@ -271,11 +301,16 @@ var init_src = __esm(() => {
     botId: Schema.optionalKey(BotId),
     targetDeviceId: Schema.optionalKey(DeviceId),
     parentTaskId: Schema.optionalKey(TaskId),
-    workspace: Schema.optionalKey(bounded(4096))
+    workspace: Schema.optionalKey(bounded(4096)),
+    attachments: Schema.optionalKey(attachments)
   }).check(Schema.makeFilter(validBotTarget));
   SocketEvent = Schema.TaggedUnion({
     Authenticate: { token: bounded(256) },
-    Connected: { serverVersion: bounded(32), connectedAt: Timestamp },
+    Connected: {
+      serverVersion: bounded(32),
+      connectedAt: Timestamp,
+      taskAttachments: Schema.optionalKey(Schema.Boolean)
+    },
     DeviceHello: { device: Device },
     DeviceHeartbeat: {
       deviceId: DeviceId,
@@ -287,6 +322,7 @@ var init_src = __esm(() => {
     TaskFinished: {
       taskId: TaskId,
       result: optionalText(131072),
+      attachments: Schema.optionalKey(attachments),
       providerSessionId: Schema.optionalKey(bounded(4096))
     },
     TaskFailed: { taskId: TaskId, error: bounded(16384) },
@@ -316,24 +352,24 @@ var init_src = __esm(() => {
 });
 
 // apps/relay/src/config.ts
-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 { Effect as Effect13, Schema as Schema14 } from "effect";
+import { access as access5, chmod as chmod7, mkdir as mkdir8, readFile as readFile5, writeFile as writeFile9 } from "node:fs/promises";
 import { homedir as homedir5, platform as platform5 } from "node:os";
-import { join as join8, resolve as resolve4 } from "node:path";
+import { join as join9, resolve as resolve4 } from "node:path";
 var RelayConfiguration, defaultDataDirectory = () => {
   if (platform5() === "win32") {
-    return join8(process.env.LOCALAPPDATA ?? join8(homedir5(), "AppData", "Local"), "Cohall");
+    return join9(process.env.LOCALAPPDATA ?? join9(homedir5(), "AppData", "Local"), "Cohall");
   }
   if (platform5() === "darwin") {
-    return join8(homedir5(), "Library", "Application Support", "Cohall", "relay");
+    return join9(homedir5(), "Library", "Application Support", "Cohall", "relay");
   }
-  return join8(process.env.XDG_DATA_HOME ?? join8(homedir5(), ".local", "share"), "cohall");
+  return join9(process.env.XDG_DATA_HOME ?? join9(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();
   }
   const token = generatedToken();
-  await writeFile7(path, `${token}
+  await writeFile9(path, `${token}
 `, { mode: 384 });
   if (platform5() !== "win32") {
     await chmod7(path, 384);
@@ -350,16 +386,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 = 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 }))
+  RelayConfiguration = Schema14.Struct({
+    host: Schema14.NonEmptyString,
+    port: Schema14.Int.check(Schema14.isBetween({ minimum: 1, maximum: 65535 })),
+    token: Schema14.String.check(Schema14.isMinLength(32)),
+    dataDirectory: Schema14.NonEmptyString,
+    databasePath: Schema14.NonEmptyString,
+    allowRemote: Schema14.Boolean,
+    historyTaskLimit: Schema14.Int.check(Schema14.isBetween({ minimum: 100, maximum: 1e5 }))
   });
-  loadEnvironmentConfiguration = Effect12.tryPromise({
+  loadEnvironmentConfiguration = Effect13.tryPromise({
     try: async () => {
       const host = process.env.COHALL_RELAY_HOST ?? "127.0.0.1";
       const port = Number(process.env.COHALL_RELAY_PORT ?? "8787");
@@ -368,21 +404,21 @@ var init_config = __esm(() => {
         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 = resolve4(process.env.COHALL_DATA_DIR ?? defaultDataDirectory());
-      await mkdir7(dataDirectory, { recursive: true, mode: 448 });
+      await mkdir8(dataDirectory, { recursive: true, mode: 448 });
       if (platform5() !== "win32") {
         await chmod7(dataDirectory, 448);
       }
-      const token = process.env.COHALL_TOKEN ?? await tokenFrom(join8(dataDirectory, "owner-token"));
+      const token = process.env.COHALL_TOKEN ?? await tokenFrom(join9(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 Schema12.decodeUnknownSync(RelayConfiguration)({
+      return Schema14.decodeUnknownSync(RelayConfiguration)({
         host,
         port,
         token,
         dataDirectory,
-        databasePath: join8(dataDirectory, "cohall.db"),
+        databasePath: join9(dataDirectory, "cohall.db"),
         allowRemote,
         historyTaskLimit
       });
@@ -564,12 +600,12 @@ __export(exports_store, {
   RelayStore: () => exports_store,
   PersistenceError: () => PersistenceError
 });
-import { Context as Context2, Effect as Effect13, Layer as Layer2, Schema as Schema13 } from "effect";
+import { Context as Context2, Effect as Effect14, Layer as Layer2, Schema as Schema15 } 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)
-}), decode2 = (operation, schema, value) => Schema13.decodeUnknownEffect(schema)(value).pipe(Effect13.mapError(operationError(operation))), threadFromRow = (row) => decode2("RelayStore.decodeThread", Thread, {
+}), decode2 = (operation, schema, value) => Schema15.decodeUnknownEffect(schema)(value).pipe(Effect14.mapError(operationError(operation))), threadFromRow = (row) => decode2("RelayStore.decodeThread", Thread, {
   id: row.id,
   title: row.title,
   createdAt: row.created_at,
@@ -598,7 +634,10 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
   version: row.version,
   lastSeenAt: row.last_seen_at,
   ...row.connected_at === null ? {} : { connectedAt: row.connected_at }
-}), taskFromRow = (row) => decode2("RelayStore.decodeTask", Task, {
+}), taskFromRow = (db, row) => Effect14.try({
+  try: () => db.query("SELECT name FROM task_attachments WHERE task_id = ? AND direction = 'input' ORDER BY name").all(row.id),
+  catch: operationError("RelayStore.taskAttachments")
+}).pipe(Effect14.flatMap((attachments2) => decode2("RelayStore.decodeTask", Task, {
   id: row.id,
   threadId: row.thread_id,
   prompt: row.prompt,
@@ -614,9 +653,21 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
   ...row.workspace === null ? {} : { workspace: row.workspace },
   ...row.provider_session_id === null ? {} : { providerSessionId: row.provider_session_id },
   ...row.result === null ? {} : { result: row.result },
+  ...attachments2.length === 0 ? {} : { inputAttachmentNames: attachments2.map((item) => item.name) },
   ...row.error === null ? {} : { error: row.error },
   ...row.started_at === null ? {} : { startedAt: row.started_at },
   ...row.completed_at === null ? {} : { completedAt: row.completed_at }
+}))), inboxItemFromRow = (row) => decode2("RelayStore.decodeInboxItem", TaskInboxItem, {
+  id: row.id,
+  threadId: row.thread_id,
+  targetDeviceId: row.target_device_id,
+  provider: row.provider,
+  ...row.bot_id === null ? {} : { botId: row.bot_id },
+  status: row.status,
+  promptPreview: row.prompt_preview,
+  completedAt: row.completed_at,
+  ...row.result_preview === null ? {} : { resultPreview: row.result_preview },
+  ...row.error_preview === null ? {} : { errorPreview: row.error_preview }
 }), operationFromRow = (row) => decode2("RelayStore.decodeOperation", DeviceOperation, {
   id: row.id,
   kind: row.kind,
@@ -641,10 +692,10 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
   kind: row.kind,
   at: row.created_at,
   ...row.detail === null ? {} : { detail: row.detail }
-}), rolesFromRow = (row) => Schema13.decodeUnknownSync(Schema13.Array(ConnectionRole))(JSON.parse(row.roles_json)), authSessionFromRow = (row) => {
+}), rolesFromRow = (row) => Schema15.decodeUnknownSync(Schema15.Array(ConnectionRole))(JSON.parse(row.roles_json)), authSessionFromRow = (row) => {
   const roles = rolesFromRow(row);
   const role = roles[0];
-  return role === undefined ? Effect13.fail(new PersistenceError({
+  return role === undefined ? Effect14.fail(new PersistenceError({
     operation: "RelayStore.decodeAuthSession",
     message: `Session ${row.id} has no role`
   })) : decode2("RelayStore.decodeAuthSession", AuthSession, {
@@ -740,23 +791,82 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
        )`).run(...parameters);
   };
   const queryTask = (taskId) => db.query("SELECT * FROM tasks WHERE id = ?").get(taskId);
+  const inboxColumns = `id, thread_id, target_device_id, provider, bot_id, status,
+    substr(prompt, 1, 160) AS prompt_preview,
+    substr(result, 1, 512) AS result_preview,
+    substr(error, 1, 512) AS error_preview,
+    COALESCE(completed_at, updated_at) AS completed_at`;
   const queryOperation = (operationId) => db.query("SELECT * FROM device_operations WHERE id = ?").get(operationId);
-  const getTask = Effect13.fn("RelayStore.getTask")(function* (taskId) {
-    const row = yield* Effect13.try({
+  const getTask = Effect14.fn("RelayStore.getTask")(function* (taskId) {
+    const row = yield* Effect14.try({
       try: () => queryTask(taskId),
       catch: operationError("RelayStore.getTask")
     });
     if (row === null) {
-      return yield* Effect13.fail(new PersistenceError({
+      return yield* Effect14.fail(new PersistenceError({
         operation: "RelayStore.getTask",
         message: `Unknown task ${taskId}`
       }));
     }
-    return yield* taskFromRow(row);
+    return yield* taskFromRow(db, row);
   });
-  const traceTask = Effect13.fn("RelayStore.traceTask")(function* (taskId) {
+  const listAttachments = Effect14.fn("RelayStore.listAttachments")(function* (taskId) {
+    yield* getTask(taskId);
+    const rows = yield* Effect14.try({
+      try: () => db.query("SELECT name, direction, length(data) AS bytes FROM task_attachments WHERE task_id = ? ORDER BY direction, name").all(taskId),
+      catch: operationError("RelayStore.listAttachments")
+    });
+    return yield* Effect14.forEach(rows, (row) => decode2("RelayStore.decodeAttachment", TaskAttachment, row));
+  });
+  const readAttachment = Effect14.fn("RelayStore.readAttachment")(function* (taskId, name, direction) {
+    yield* getTask(taskId);
+    const row = yield* Effect14.try({
+      try: () => direction === undefined ? db.query("SELECT data FROM task_attachments WHERE task_id = ? AND name = ? ORDER BY direction DESC LIMIT 1").get(taskId, name) : db.query("SELECT data FROM task_attachments WHERE task_id = ? AND name = ? AND direction = ?").get(taskId, name, direction),
+      catch: operationError("RelayStore.readAttachment")
+    });
+    if (row === null) {
+      return yield* new PersistenceError({
+        operation: "RelayStore.readAttachment",
+        message: `Unknown attachment ${name}`
+      });
+    }
+    return row.data;
+  });
+  const inboxFor = Effect14.fn("RelayStore.inboxFor")(function* (principal) {
+    const requesterId = principal === "owner" ? "owner" : principal.id;
+    const rows = yield* Effect14.try({
+      try: () => db.query(`SELECT ${inboxColumns} FROM tasks WHERE requester_id = ? AND completion_seen_at IS NULL
+             AND status IN ('completed', 'failed', 'cancelled')
+             ORDER BY completed_at ASC, id ASC LIMIT 21`).all(requesterId),
+      catch: operationError("RelayStore.inboxFor")
+    });
+    return TaskInbox.make({
+      items: yield* Effect14.forEach(rows.slice(0, 20), inboxItemFromRow),
+      hasMore: rows.length > 20
+    });
+  });
+  const acknowledgeCompletion = Effect14.fn("RelayStore.acknowledgeCompletion")(function* (taskId, principal) {
+    const requesterId = principal === "owner" ? "owner" : principal.id;
+    const row = yield* Effect14.try({
+      try: () => db.query(`SELECT ${inboxColumns} FROM tasks WHERE id = ? AND requester_id = ?
+             AND status IN ('completed', 'failed', 'cancelled')`).get(taskId, requesterId),
+      catch: operationError("RelayStore.acknowledgeCompletion.read")
+    });
+    if (row === null) {
+      return yield* new PersistenceError({
+        operation: "RelayStore.acknowledgeCompletion",
+        message: `Unknown inbox task ${taskId}`
+      });
+    }
+    yield* Effect14.try({
+      try: () => db.query("UPDATE tasks SET completion_seen_at = COALESCE(completion_seen_at, ?) WHERE id = ?").run(now(), taskId),
+      catch: operationError("RelayStore.acknowledgeCompletion.write")
+    });
+    return yield* inboxItemFromRow(row);
+  });
+  const traceTask = Effect14.fn("RelayStore.traceTask")(function* (taskId) {
     const task = yield* getTask(taskId);
-    const [deviceRow, eventRows] = yield* Effect13.try({
+    const [deviceRow, eventRows] = yield* Effect14.try({
       try: () => [
         db.query("SELECT * FROM devices WHERE id = ?").get(task.targetDeviceId),
         db.query(`SELECT * FROM (
@@ -767,14 +877,14 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
       catch: operationError("RelayStore.traceTask")
     });
     if (deviceRow === null) {
-      return yield* Effect13.fail(new PersistenceError({
+      return yield* Effect14.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* Effect13.forEach(selectedRows, taskTraceEventFromRow);
+    const recordedEvents = yield* Effect14.forEach(selectedRows, taskTraceEventFromRow);
     const events = recordedEvents.length === 0 ? derivedTraceEvents(task) : recordedEvents;
     return TaskTrace.make({
       taskId: task.id,
@@ -795,15 +905,15 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
       ...task.error === undefined ? {} : { error: task.error }
     });
   });
-  const listDevices = Effect13.fn("RelayStore.listDevices")(function* () {
-    const rows = yield* Effect13.try({
+  const listDevices = Effect14.fn("RelayStore.listDevices")(function* () {
+    const rows = yield* Effect14.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* Effect13.forEach(rows, deviceFromRow);
+    return yield* Effect14.forEach(rows, deviceFromRow);
   });
-  const usage = Effect13.fn("RelayStore.usage")(function* () {
-    const rows = yield* Effect13.try({
+  const usage = Effect14.fn("RelayStore.usage")(function* () {
+    const rows = yield* Effect14.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
@@ -817,9 +927,9 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
     const devices = new Map;
     let retainedTasks = 0;
     for (const row of rows) {
-      const status = Schema13.decodeUnknownSync(TaskStatus)(row.status);
-      const provider = Schema13.decodeUnknownSync(Provider)(row.provider);
-      const deviceId = Schema13.decodeUnknownSync(DeviceId)(row.device_id);
+      const status = Schema15.decodeUnknownSync(TaskStatus)(row.status);
+      const provider = Schema15.decodeUnknownSync(Provider)(row.provider);
+      const deviceId = Schema15.decodeUnknownSync(DeviceId)(row.device_id);
       retainedTasks += row.tasks;
       totalStatus[status] += row.tasks;
       totalProviders.set(provider, (totalProviders.get(provider) ?? 0) + row.tasks);
@@ -849,29 +959,29 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
       }))
     });
   });
-  const getOperation = Effect13.fn("RelayStore.getOperation")(function* (operationId) {
-    const row = yield* Effect13.try({
+  const getOperation = Effect14.fn("RelayStore.getOperation")(function* (operationId) {
+    const row = yield* Effect14.try({
       try: () => queryOperation(operationId),
       catch: operationError("RelayStore.getOperation")
     });
     if (row === null) {
-      return yield* Effect13.fail(new PersistenceError({
+      return yield* Effect14.fail(new PersistenceError({
         operation: "RelayStore.getOperation",
         message: `Unknown device operation ${operationId}`
       }));
     }
     return yield* operationFromRow(row);
   });
-  const listOperations = Effect13.fn("RelayStore.listOperations")(function* () {
-    const rows = yield* Effect13.try({
+  const listOperations = Effect14.fn("RelayStore.listOperations")(function* () {
+    const rows = yield* Effect14.try({
       try: () => db.query("SELECT * FROM device_operations ORDER BY created_at DESC, id DESC LIMIT 50").all(),
       catch: operationError("RelayStore.listOperations")
     });
-    return yield* Effect13.forEach(rows, operationFromRow);
+    return yield* Effect14.forEach(rows, operationFromRow);
   });
-  const createUpgradeOperations = Effect13.fn("RelayStore.createUpgradeOperations")(function* (input) {
+  const createUpgradeOperations = Effect14.fn("RelayStore.createUpgradeOperations")(function* (input) {
     const timestamp = now();
-    const operations = yield* Effect13.try({
+    const operations = yield* Effect14.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) {
@@ -911,15 +1021,15 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
     });
     return operations;
   });
-  const pendingOperationsFor = Effect13.fn("RelayStore.pendingOperationsFor")(function* (deviceId) {
-    const rows = yield* Effect13.try({
+  const pendingOperationsFor = Effect14.fn("RelayStore.pendingOperationsFor")(function* (deviceId) {
+    const rows = yield* Effect14.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* Effect13.forEach(rows, operationFromRow);
+    return yield* Effect14.forEach(rows, operationFromRow);
   });
-  const transitionOperation = Effect13.fn("RelayStore.transitionOperation")(function* (operationId, expected, status, result, error) {
+  const transitionOperation = Effect14.fn("RelayStore.transitionOperation")(function* (operationId, expected, status, result, error) {
     const current = yield* getOperation(operationId);
     if (!expected.includes(current.status)) {
       return current;
@@ -927,7 +1037,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* Effect13.try({
+    yield* Effect14.try({
       try: () => db.transaction(() => {
         const updated = db.query(`UPDATE device_operations
                SET status = ?, result = ?, error = ?, updated_at = ?, completed_at = ?
@@ -940,23 +1050,23 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
     });
     return yield* getOperation(operationId);
   });
-  const requireOperationTarget = Effect13.fn("RelayStore.requireOperationTarget")(function* (operationId, deviceId) {
+  const requireOperationTarget = Effect14.fn("RelayStore.requireOperationTarget")(function* (operationId, deviceId) {
     const operation = yield* getOperation(operationId);
     if (operation.targetDeviceId !== deviceId) {
-      return yield* Effect13.fail(new PersistenceError({
+      return yield* Effect14.fail(new PersistenceError({
         operation: "RelayStore.requireOperationTarget",
         message: `Device ${deviceId} cannot update operation ${operationId}`
       }));
     }
     return operation;
   });
-  const assignOperation = Effect13.fn("RelayStore.assignOperation")(function* (operationId) {
+  const assignOperation = Effect14.fn("RelayStore.assignOperation")(function* (operationId) {
     const current = yield* getOperation(operationId);
     if (current.status !== "queued") {
       return current;
     }
     const timestamp = now();
-    yield* Effect13.try({
+    yield* Effect14.try({
       try: () => db.query(`UPDATE device_operations SET status = 'assigned', updated_at = ?
              WHERE id = ? AND status = 'queued'
                AND NOT EXISTS (
@@ -972,19 +1082,19 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
     });
     return yield* getOperation(operationId);
   });
-  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 acceptOperation = (operationId, deviceId) => requireOperationTarget(operationId, deviceId).pipe(Effect14.flatMap(() => transitionOperation(operationId, ["assigned"], "running")));
+  const finishOperation = (operationId, deviceId, result) => requireOperationTarget(operationId, deviceId).pipe(Effect14.flatMap(() => transitionOperation(operationId, ["queued", "assigned", "running"], "completed", result)));
+  const failOperation = (operationId, deviceId, error) => requireOperationTarget(operationId, deviceId).pipe(Effect14.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 = Effect13.fn("RelayStore.requeueOperationsFor")(function* (deviceId) {
-    yield* Effect13.try({
+  const requeueOperationsFor = Effect14.fn("RelayStore.requeueOperationsFor")(function* (deviceId) {
+    yield* Effect14.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 = Effect13.fn("RelayStore.forgetDevice")(function* (deviceId) {
-    const row = yield* Effect13.try({
+  const forgetDevice = Effect14.fn("RelayStore.forgetDevice")(function* (deviceId) {
+    const row = yield* Effect14.try({
       try: () => db.transaction(() => {
         const device = db.query("SELECT * FROM devices WHERE id = ? AND forgotten_at IS NULL").get(deviceId);
         if (device === null) {
@@ -1011,8 +1121,8 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
     });
     return yield* deviceFromRow(row);
   });
-  const recover = Effect13.fn("RelayStore.recover")(function* () {
-    yield* Effect13.try({
+  const recover = Effect14.fn("RelayStore.recover")(function* () {
+    yield* Effect14.try({
       try: () => db.transaction(() => {
         const timestamp = now();
         const interrupted = db.query("SELECT id FROM tasks WHERE status IN ('assigned', 'running')").all();
@@ -1030,8 +1140,8 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
       catch: operationError("RelayStore.recover")
     });
   });
-  const upsertDevice = Effect13.fn("RelayStore.upsertDevice")(function* (device) {
-    yield* Effect13.try({
+  const upsertDevice = Effect14.fn("RelayStore.upsertDevice")(function* (device) {
+    yield* Effect14.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, bots_json
@@ -1048,29 +1158,31 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
     });
     return device;
   });
-  const updateDeviceStatus = Effect13.fn("RelayStore.updateDeviceStatus")(function* (deviceId, status, bots) {
+  const updateDeviceStatus = Effect14.fn("RelayStore.updateDeviceStatus")(function* (deviceId, status, bots) {
     const timestamp = now();
-    const result = yield* Effect13.try({
+    const result = yield* Effect14.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* Effect13.fail(new PersistenceError({
+      return yield* Effect14.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* Effect13.fail(new PersistenceError({
+      return yield* Effect14.fail(new PersistenceError({
         operation: "RelayStore.updateDeviceStatus.read",
         message: `Device ${deviceId} disappeared after update`
       }));
     }
     return yield* deviceFromRow(row);
   });
-  const createDelegation2 = Effect13.fn("RelayStore.createDelegation")(function* (input, targetDeviceId, boundDeviceId, providerSessionId) {
-    const sourceDeviceId = yield* Effect13.try({
+  const createDelegation2 = Effect14.fn("RelayStore.createDelegation")(function* (input, targetDeviceId, principal, providerSessionId) {
+    const requesterId = principal === "owner" ? "owner" : principal.id;
+    const boundDeviceId = principal === "owner" ? undefined : principal.deviceId;
+    const sourceDeviceId = yield* Effect14.try({
       try: () => boundDeviceId === undefined || db.query("SELECT id FROM devices WHERE id = ? AND forgotten_at IS NULL").get(boundDeviceId) === null ? undefined : boundDeviceId,
       catch: operationError("RelayStore.createDelegation.source")
     });
@@ -1090,6 +1202,7 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
       ...sourceDeviceId === undefined ? {} : { sourceDeviceId },
       ...input.parentTaskId === undefined ? {} : { parentTaskId: input.parentTaskId },
       ...input.workspace === undefined ? {} : { workspace: input.workspace },
+      ...input.attachments === undefined || input.attachments.length === 0 ? {} : { inputAttachmentNames: input.attachments.map((attachment) => attachment.name) },
       ...providerSessionId === undefined ? {} : { providerSessionId }
     });
     const thread = input.threadId === undefined ? Thread.make({
@@ -1108,7 +1221,7 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
       taskId: task.id,
       ...sourceDeviceId === undefined ? {} : { deviceId: sourceDeviceId }
     });
-    yield* Effect13.try({
+    yield* Effect14.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);
@@ -1122,9 +1235,16 @@ 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, 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.botId ?? null, task.createdAt, task.updatedAt);
+              requester_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, requesterId, task.targetDeviceId, task.parentTaskId ?? null, task.workspace ?? null, task.providerSessionId ?? null, task.botId ?? null, task.createdAt, task.updatedAt);
+        for (const attachment of input.attachments ?? []) {
+          const data = Buffer.from(attachment.data, "base64");
+          if (data.length < 1 || data.length > maxAttachmentBytes) {
+            throw new Error(`Attachment ${attachment.name} must be 1 to ${maxAttachmentBytes} bytes`);
+          }
+          db.query("INSERT INTO task_attachments (task_id, name, direction, data) VALUES (?, ?, 'input', ?)").run(task.id, attachment.name, data);
+        }
         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,
@@ -1136,18 +1256,18 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
     });
     return task;
   });
-  const threadContext2 = Effect13.fn("RelayStore.threadContext")(function* (threadId) {
-    const threadRow = yield* Effect13.try({
+  const threadContext2 = Effect14.fn("RelayStore.threadContext")(function* (threadId) {
+    const threadRow = yield* Effect14.try({
       try: () => db.query("SELECT * FROM threads WHERE id = ?").get(threadId),
       catch: operationError("RelayStore.threadContext.thread")
     });
     if (threadRow === null) {
-      return yield* Effect13.fail(new PersistenceError({
+      return yield* Effect14.fail(new PersistenceError({
         operation: "RelayStore.threadContext",
         message: `Unknown thread ${threadId}`
       }));
     }
-    const [messageRows, taskRows] = yield* Effect13.try({
+    const [messageRows, taskRows] = yield* Effect14.try({
       try: () => [
         db.query(`SELECT * FROM (
                  SELECT * FROM messages WHERE thread_id = ?
@@ -1160,10 +1280,10 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
       ],
       catch: operationError("RelayStore.threadContext.items")
     });
-    const [thread, messages, tasks] = yield* Effect13.all([
+    const [thread, messages, tasks] = yield* Effect14.all([
       threadFromRow(threadRow),
-      Effect13.forEach(messageRows.slice(-20), messageFromRow),
-      Effect13.forEach(taskRows.slice(-20), taskFromRow)
+      Effect14.forEach(messageRows.slice(-20), messageFromRow),
+      Effect14.forEach(taskRows.slice(-20), (row) => taskFromRow(db, row))
     ]);
     const recentMessages = recentWithin(messages, 256 * 1024);
     const recentTasks = recentWithin(tasks, 768 * 1024);
@@ -1174,22 +1294,22 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
       truncated: messageRows.length > 20 || taskRows.length > 20 || recentMessages.truncated || recentTasks.truncated
     });
   });
-  const pendingTasksFor = Effect13.fn("RelayStore.pendingTasksFor")(function* (deviceId) {
-    const rows = yield* Effect13.try({
+  const pendingTasksFor = Effect14.fn("RelayStore.pendingTasksFor")(function* (deviceId) {
+    const rows = yield* Effect14.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* Effect13.forEach(rows, taskFromRow);
+    return yield* Effect14.forEach(rows, (row) => taskFromRow(db, row));
   });
-  const transition = Effect13.fn("RelayStore.transition")(function* (taskId, expected, update, event) {
+  const transition = Effect14.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* Effect13.try({
+    yield* Effect14.try({
       try: () => db.transaction(() => {
         const result = db.query(`UPDATE tasks SET status = ?, provider_session_id = ?, result = ?, error = ?,
              started_at = ?, completed_at = ?, updated_at = ?
@@ -1205,13 +1325,13 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
     });
     return yield* getTask(taskId);
   });
-  const assignTask = Effect13.fn("RelayStore.assignTask")(function* (taskId) {
+  const assignTask = Effect14.fn("RelayStore.assignTask")(function* (taskId) {
     const current = yield* getTask(taskId);
     if (current.status !== "queued") {
       return current;
     }
     const timestamp = now();
-    yield* Effect13.try({
+    yield* Effect14.try({
       try: () => db.transaction(() => {
         const result = db.query(`UPDATE tasks SET status = 'assigned', updated_at = ?,
                  provider_session_id = CASE
@@ -1241,23 +1361,23 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
     });
     return yield* getTask(taskId);
   });
-  const requireTarget = Effect13.fn("RelayStore.requireTarget")(function* (taskId, deviceId) {
+  const requireTarget = Effect14.fn("RelayStore.requireTarget")(function* (taskId, deviceId) {
     const task = yield* getTask(taskId);
     if (task.targetDeviceId !== deviceId) {
-      return yield* Effect13.fail(new PersistenceError({
+      return yield* Effect14.fail(new PersistenceError({
         operation: "RelayStore.requireTarget",
         message: `Task ${taskId} belongs to another device`
       }));
     }
     return task;
   });
-  const terminal = Effect13.fn("RelayStore.terminal")(function* (taskId, deviceId, status, result, error, providerSessionId) {
+  const terminal = Effect14.fn("RelayStore.terminal")(function* (taskId, deviceId, status, result, error, providerSessionId, attachments2) {
     const current = yield* requireTarget(taskId, deviceId);
     if (["completed", "failed", "cancelled"].includes(current.status)) {
       return current;
     }
     const timestamp = now();
-    yield* Effect13.try({
+    yield* Effect14.try({
       try: () => db.transaction(() => {
         const updated = db.query(`UPDATE tasks SET status = ?, result = ?, error = ?, provider_session_id = ?,
              completed_at = ?, updated_at = ? WHERE id = ?
@@ -1265,6 +1385,19 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
         if (updated.changes !== 1) {
           return;
         }
+        db.query("DELETE FROM task_attachments WHERE task_id = ? AND direction = 'output'").run(taskId);
+        if (status === "completed") {
+          if ((attachments2?.length ?? 0) > maxTaskAttachments) {
+            throw new Error(`A task supports at most ${maxTaskAttachments} output files`);
+          }
+          for (const attachment of attachments2 ?? []) {
+            const data = Buffer.from(attachment.data, "base64");
+            if (data.length < 1 || data.length > maxAttachmentBytes) {
+              throw new Error(`Attachment ${attachment.name} must be 1 to ${maxAttachmentBytes} bytes`);
+            }
+            db.query("INSERT INTO task_attachments (task_id, name, direction, data) VALUES (?, ?, 'output', ?)").run(taskId, attachment.name, data);
+          }
+        }
         recordTaskTraceEvent(taskId, status, status === "completed" ? "Target device completed the task" : status === "failed" ? "Target device reported a task failure" : "Target device acknowledged cancellation", timestamp);
         if (current.provider !== "grok-bot" && providerSessionId !== undefined) {
           db.query(`INSERT INTO provider_sessions (thread_id, device_id, provider, session_id, updated_at)
@@ -1287,12 +1420,12 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
     });
     return yield* getTask(taskId);
   });
-  const requestCancellation = Effect13.fn("RelayStore.requestCancellation")(function* (taskId) {
+  const requestCancellation = Effect14.fn("RelayStore.requestCancellation")(function* (taskId) {
     const current = yield* getTask(taskId);
     if (["completed", "failed", "cancelled"].includes(current.status)) {
       return current;
     }
-    const dispatched = current.provider === "grok-bot" && (yield* Effect13.try({
+    const dispatched = current.provider === "grok-bot" && (yield* Effect14.try({
       try: () => db.query("SELECT 1 FROM tasks WHERE id = ? AND dispatched_at IS NOT NULL").get(taskId) !== null,
       catch: operationError("RelayStore.requestCancellation")
     }));
@@ -1310,9 +1443,9 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
       status: "cancelling"
     }, { kind: "cancelling", detail: "Client requested task cancellation" });
   });
-  const requeueTasksFor = Effect13.fn("RelayStore.requeueTasksFor")(function* (deviceId) {
+  const requeueTasksFor = Effect14.fn("RelayStore.requeueTasksFor")(function* (deviceId) {
     const timestamp = now();
-    yield* Effect13.try({
+    yield* Effect14.try({
       try: () => db.transaction(() => {
         const interrupted = db.query(`SELECT id FROM tasks WHERE target_device_id = ?
                AND status IN ('assigned', 'running')`).all(deviceId);
@@ -1325,42 +1458,42 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
       catch: operationError("RelayStore.requeueTasksFor")
     });
   });
-  const sessionFor = Effect13.fn("RelayStore.sessionFor")(function* (threadId, deviceId, provider) {
-    const row = yield* Effect13.try({
+  const sessionFor = Effect14.fn("RelayStore.sessionFor")(function* (threadId, deviceId, provider) {
+    const row = yield* Effect14.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 = Effect13.fn("RelayStore.createPairing")(function* (input) {
+  const createPairing = Effect14.fn("RelayStore.createPairing")(function* (input) {
     const roles = [...new Set(input.roles)];
     if (roles.length === 0) {
-      return yield* Effect13.fail(new PersistenceError({
+      return yield* Effect14.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* Effect13.try({
+    yield* Effect14.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 = Effect13.fn("RelayStore.exchangePairing")(function* (token) {
+  const exchangePairing2 = Effect14.fn("RelayStore.exchangePairing")(function* (token) {
     const timestamp = now();
     const expiresAt = new Date(Date.now() + 90 * 24 * 60 * 60 * 1000).toISOString();
-    const created = yield* Effect13.try({
+    const created = yield* Effect14.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 = Schema13.decodeUnknownSync(Schema13.Array(ConnectionRole))(JSON.parse(pairing.roles_json));
+        const roles = Schema15.decodeUnknownSync(Schema15.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) {
@@ -1388,11 +1521,11 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
       })(),
       catch: operationError("RelayStore.exchangePairing")
     });
-    const credentials = yield* Effect13.forEach(created, ({ token: sessionToken, row }) => authSessionFromRow(row).pipe(Effect13.map((session) => ({ token: sessionToken, session }))));
+    const credentials = yield* Effect14.forEach(created, ({ token: sessionToken, row }) => authSessionFromRow(row).pipe(Effect14.map((session) => ({ token: sessionToken, session }))));
     return PairingResult.make({ credentials });
   });
-  const authenticateSession = Effect13.fn("RelayStore.authenticateSession")(function* (token, role) {
-    const row = yield* Effect13.try({
+  const authenticateSession = Effect14.fn("RelayStore.authenticateSession")(function* (token, role) {
+    const row = yield* Effect14.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")
@@ -1401,35 +1534,35 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
       return;
     }
     const lastSeenAt = now();
-    yield* Effect13.try({
+    yield* Effect14.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 = Effect13.fn("RelayStore.listAuthSessions")(function* () {
-    const rows = yield* Effect13.try({
+  const listAuthSessions = Effect14.fn("RelayStore.listAuthSessions")(function* () {
+    const rows = yield* Effect14.try({
       try: () => db.query("SELECT * FROM auth_sessions ORDER BY created_at DESC, id LIMIT 1000").all(),
       catch: operationError("RelayStore.listAuthSessions")
     });
-    return yield* Effect13.forEach(rows, authSessionFromRow);
+    return yield* Effect14.forEach(rows, authSessionFromRow);
   });
-  const revokeAuthSession = Effect13.fn("RelayStore.revokeAuthSession")(function* (sessionId) {
+  const revokeAuthSession = Effect14.fn("RelayStore.revokeAuthSession")(function* (sessionId) {
     const revokedAt = now();
-    const result = yield* Effect13.try({
+    const result = yield* Effect14.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* Effect13.fail(new PersistenceError({
+      return yield* Effect14.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* Effect13.fail(new PersistenceError({
+      return yield* Effect14.fail(new PersistenceError({
         operation: "RelayStore.revokeAuthSession.read",
         message: `Session ${sessionId} disappeared after revocation`
       }));
@@ -1446,19 +1579,23 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
     markDeviceOffline: (deviceId) => updateDeviceStatus(deviceId, "offline"),
     createDelegation: createDelegation2,
     getTask,
+    listAttachments,
+    readAttachment,
+    inboxFor,
+    acknowledgeCompletion,
     traceTask,
     threadContext: threadContext2,
     pendingTasksFor,
     assignTask,
-    markTaskDispatched: (taskId) => Effect13.try({
+    markTaskDispatched: (taskId) => Effect14.try({
       try: () => {
         db.query("UPDATE tasks SET dispatched_at = COALESCE(dispatched_at, ?) WHERE id = ? AND status = 'assigned'").run(now(), taskId);
       },
       catch: operationError("RelayStore.markTaskDispatched")
     }),
     rollbackAssignment: (taskId) => transition(taskId, ["assigned"], { status: "queued" }, { kind: "requeued", detail: "Target device was unavailable during dispatch" }),
-    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),
+    acceptTask: (taskId, deviceId) => requireTarget(taskId, deviceId).pipe(Effect14.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, attachments2) => terminal(taskId, deviceId, "completed", result, undefined, providerSessionId, attachments2),
     failTask: (taskId, deviceId, error) => terminal(taskId, deviceId, "failed", undefined, error),
     acknowledgeCancellation: (taskId, deviceId) => terminal(taskId, deviceId, "cancelled"),
     requestCancellation,
@@ -1480,7 +1617,7 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
     listAuthSessions,
     revokeAuthSession
   });
-}, migrate = (db) => Effect13.try({
+}, migrate = (db) => Effect14.try({
   try: () => {
     db.exec("PRAGMA journal_mode = WAL");
     db.exec("PRAGMA foreign_keys = ON");
@@ -1509,6 +1646,7 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
           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, bot_id TEXT, status TEXT NOT NULL,
           source_device_id TEXT REFERENCES devices(id),
+          requester_id TEXT, completion_seen_at TEXT,
           target_device_id TEXT NOT NULL REFERENCES devices(id), parent_task_id TEXT,
           workspace TEXT, provider_session_id TEXT, result TEXT, error TEXT,
           created_at TEXT NOT NULL, updated_at TEXT NOT NULL, started_at TEXT, completed_at TEXT,
@@ -1516,6 +1654,12 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
         );
         CREATE INDEX IF NOT EXISTS tasks_thread_created ON tasks(thread_id, created_at);
         CREATE INDEX IF NOT EXISTS tasks_target_status ON tasks(target_device_id, status);
+        CREATE TABLE IF NOT EXISTS task_attachments (
+          task_id TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+          name TEXT NOT NULL, direction TEXT NOT NULL CHECK(direction IN ('input', 'output')),
+          data BLOB NOT NULL CHECK(length(data) BETWEEN 1 AND ${maxAttachmentBytes}),
+          PRIMARY KEY(task_id, direction, name)
+        );
         CREATE TABLE IF NOT EXISTS task_trace_events (
           id INTEGER PRIMARY KEY AUTOINCREMENT,
           task_id TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
@@ -1560,6 +1704,14 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
     if (!taskColumns.some((column) => column.name === "bot_id")) {
       db.exec("ALTER TABLE tasks ADD COLUMN bot_id TEXT");
     }
+    if (!taskColumns.some((column) => column.name === "requester_id")) {
+      db.exec("ALTER TABLE tasks ADD COLUMN requester_id TEXT");
+    }
+    if (!taskColumns.some((column) => column.name === "completion_seen_at")) {
+      db.exec("ALTER TABLE tasks ADD COLUMN completion_seen_at TEXT");
+    }
+    db.exec(`CREATE INDEX IF NOT EXISTS tasks_inbox
+        ON tasks(requester_id, completion_seen_at, completed_at)`);
     if (!taskColumns.some((column) => column.name === "dispatched_at")) {
       db.transaction(() => {
         db.exec("ALTER TABLE tasks ADD COLUMN dispatched_at TEXT");
@@ -1569,15 +1721,15 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
     }
   },
   catch: operationError("RelayStore.migrate")
-}), layer2 = (path, retainedTerminalTasks = 1000) => Layer2.effect(Service2, Effect13.acquireRelease(Effect13.try({
+}), layer2 = (path, retainedTerminalTasks = 1000) => Layer2.effect(Service2, Effect14.acquireRelease(Effect14.try({
   try: () => new Database(path),
   catch: operationError("RelayStore.open")
-}).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))));
+}).pipe(Effect14.tap(migrate)), (db) => Effect14.sync(() => db.close())).pipe(Effect14.map((db) => makeService(db, retainedTerminalTasks)))), layerFromDatabase = (db) => Layer2.effect(Service2, migrate(db).pipe(Effect14.map(() => makeService(db))));
 var init_store = __esm(() => {
   init_src();
   init_database();
   init_store();
-  PersistenceError = class PersistenceError extends Schema13.TaggedErrorClass()("RelayStore.PersistenceError", { operation: Schema13.String, message: Schema13.String }) {
+  PersistenceError = class PersistenceError extends Schema15.TaggedErrorClass()("RelayStore.PersistenceError", { operation: Schema15.String, message: Schema15.String }) {
   };
   Service2 = class Service2 extends Context2.Service()("@cohall/RelayStore") {
   };
@@ -1588,9 +1740,12 @@ var exports_main = {};
 __export(exports_main, {
   runRelay: () => runRelay,
   resolveDelegation: () => resolveDelegation,
-  relayListenOptions: () => relayListenOptions
+  relayListenOptions: () => relayListenOptions,
+  maxTaskRequestBodyBytes: () => maxTaskRequestBodyBytes,
+  canReadTaskAttachments: () => canReadTaskAttachments,
+  canDispatchTaskToDevice: () => canDispatchTaskToDevice
 });
-import { Effect as Effect14, ManagedRuntime, Schema as Schema14 } from "effect";
+import { Effect as Effect15, ManagedRuntime, Schema as Schema16 } from "effect";
 import { createHash as createHash3, timingSafeEqual } from "node:crypto";
 import { access as access6, chmod as chmod8 } from "node:fs/promises";
 import { createServer } from "node:http";
@@ -1636,7 +1791,7 @@ var RequestError, relayListenOptions = (configuration, environment = process.env
         return;
       }
       cleanup();
-      reject(new Error("Request body exceeded 256 KiB"));
+      reject(new Error(`Request body exceeded ${Math.floor(limit / 1024)} KiB`));
     };
     const onEnd = () => {
       cleanup();
@@ -1650,7 +1805,7 @@ var RequestError, relayListenOptions = (configuration, environment = process.env
     request.once("end", onEnd);
     request.once("error", onError);
   });
-}, webRequest = async (request) => {
+}, maxTaskRequestBodyBytes, webRequest = async (request) => {
   const headers = new Headers;
   for (let index = 0;index < request.rawHeaders.length; index += 2) {
     const name = request.rawHeaders[index];
@@ -1659,7 +1814,8 @@ var RequestError, relayListenOptions = (configuration, environment = process.env
       headers.append(name, value);
     }
   }
-  const payload = await requestBody(request, 256 * 1024);
+  const pathname = new URL(request.url ?? "/", "http://cohall.local").pathname;
+  const payload = await requestBody(request, pathname === "/api/tasks" ? maxTaskRequestBodyBytes : maxAttachmentBytes);
   return new Request(new URL(request.url ?? "/", "http://cohall.local"), {
     method: request.method ?? "GET",
     headers,
@@ -1689,15 +1845,15 @@ Content-Length: 0\r
   if ("destroy" in socket && typeof socket.destroy === "function") {
     socket.destroy();
   }
-}, body = (request, decode3) => Effect14.tryPromise({
+}, body = (request, decode3) => Effect15.tryPromise({
   try: () => request.json(),
   catch: () => new RequestError({ status: 400, message: "Expected a JSON request body" })
-}).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) => {
+}).pipe(Effect15.flatMap(decode3), Effect15.mapError((cause) => cause instanceof RequestError ? cause : new RequestError({ status: 400, message: String(cause).slice(0, 2048) }))), pathId = (schema, value) => Schema16.decodeUnknownEffect(schema)(value).pipe(Effect15.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);
-}, resolveDelegation = (input, sourceDeviceId) => Effect14.gen(function* () {
+}, resolveDelegation = (input, sourceDeviceId) => Effect15.gen(function* () {
   const store = yield* exports_store.Service;
   const ancestors = [];
   const seen = new Set;
@@ -1705,11 +1861,11 @@ Content-Length: 0\r
   while (nextParentId !== undefined && !seen.has(nextParentId)) {
     const parentId = nextParentId;
     seen.add(parentId);
-    const parent2 = yield* store.getTask(parentId).pipe(Effect14.catch((cause) => {
+    const parent2 = yield* store.getTask(parentId).pipe(Effect15.catch((cause) => {
       const missing = cause.message === `Unknown task ${parentId}`;
       if (missing && ancestors.length > 0)
-        return Effect14.succeed(undefined);
-      return Effect14.fail(new RequestError({ status: missing ? 404 : 500, message: cause.message }));
+        return Effect15.succeed(undefined);
+      return Effect15.fail(new RequestError({ status: missing ? 404 : 500, message: cause.message }));
     }));
     if (parent2 === undefined)
       break;
@@ -1724,8 +1880,15 @@ Content-Length: 0\r
     });
   }
   const resolvedInput = parent === undefined ? input : { ...input, threadId: parent.threadId };
-  const devices = yield* store.listDevices().pipe(Effect14.mapError((cause) => new RequestError({ status: 500, message: cause.message })));
+  const devices = yield* store.listDevices().pipe(Effect15.mapError((cause) => new RequestError({ status: 500, message: cause.message })));
   const provider = input.provider ?? (input.botId === undefined ? "codex" : "grok-bot");
+  const hasAttachments = (input.attachments?.length ?? 0) > 0;
+  if (hasAttachments && provider === "grok-bot") {
+    return yield* new RequestError({
+      status: 400,
+      message: "File attachments require a coding provider"
+    });
+  }
   const slot = taskSlot({
     provider,
     ...input.botId === undefined ? {} : { botId: input.botId }
@@ -1745,6 +1908,12 @@ Content-Length: 0\r
         message: `${target.name} does not advertise the ${provider} provider`
       });
     }
+    if (hasAttachments && !target.capabilities.some((capability) => capability.id === "task-attachments")) {
+      return yield* new RequestError({
+        status: 409,
+        message: `${target.name} does not support file attachments; upgrade its Cohall worker`
+      });
+    }
     if (input.botId !== undefined && !target.bots?.some((bot) => bot.id === input.botId)) {
       return yield* new RequestError({
         status: 404,
@@ -1759,7 +1928,8 @@ Content-Length: 0\r
     }
     return { input: resolvedInput, targetDeviceId: target.id };
   }
-  const candidates = devices.filter((device) => device.providers.includes(provider) && (input.botId === undefined || device.bots?.some((bot) => bot.id === input.botId)));
+  const providerDevices = devices.filter((device) => device.providers.includes(provider) && (input.botId === undefined || device.bots?.some((bot) => bot.id === input.botId)));
+  const candidates = hasAttachments ? providerDevices.filter((device) => device.capabilities.some((capability) => capability.id === "task-attachments")) : providerDevices;
   if (input.botId !== undefined && candidates.length > 1) {
     return yield* new RequestError({
       status: 409,
@@ -1770,16 +1940,16 @@ Content-Length: 0\r
   if (selected === undefined) {
     return yield* new RequestError({
       status: 409,
-      message: candidates.length > 0 ? "No available delegation target avoids an unfinished parent's worker slot; select another device or bot" : input.botId === undefined ? `No Cohall device advertises the ${provider} provider` : `No Cohall device advertises bot ${input.botId}; refresh the bot list`
+      message: candidates.length > 0 ? "No available delegation target avoids an unfinished parent's worker slot; select another device or bot" : hasAttachments && providerDevices.length > 0 ? `No Cohall device advertising the ${provider} provider supports file attachments; upgrade a Cohall worker` : input.botId === undefined ? `No Cohall device advertises the ${provider} provider` : `No Cohall device advertises bot ${input.botId}; refresh the bot list`
     });
   }
   return { input: resolvedInput, targetDeviceId: selected.id };
-}), runRelay = async () => {
-  const configuration = await Effect14.runPromise(loadEnvironmentConfiguration);
+}), canReadTaskAttachments = (principal, task) => principal === "owner" || principal.role === "client" || principal.deviceId === task.targetDeviceId, canDispatchTaskToDevice = (task, device) => (task.inputAttachmentNames?.length ?? 0) === 0 || device?.capabilities.some((capability) => capability.id === "task-attachments") === true, runRelay = async () => {
+  const configuration = await Effect15.runPromise(loadEnvironmentConfiguration);
   process.umask(63);
   const runtime = ManagedRuntime.make(exports_store.layer(configuration.databasePath, configuration.historyTaskLimit));
   const run2 = (effect) => runtime.runPromise(effect);
-  await run2(Effect14.gen(function* () {
+  await run2(Effect15.gen(function* () {
     const store = yield* exports_store.Service;
     yield* store.recover();
   }));
@@ -1794,33 +1964,41 @@ Content-Length: 0\r
     if (ownerToken2(token)) {
       return "owner";
     }
-    return run2(Effect14.gen(function* () {
+    return run2(Effect15.gen(function* () {
       const store = yield* exports_store.Service;
       return yield* store.authenticateSession(token, role);
     })).catch(() => {
       return;
     });
   };
-  const principalFor = async (request) => {
+  const principalFor = async (request, allowDevice = false) => {
     const authorization = request.headers.get("authorization");
     if (authorization?.startsWith("Bearer ") !== true) {
       return;
     }
-    return authenticate(authorization.slice("Bearer ".length), "client");
+    const token = authorization.slice("Bearer ".length);
+    return await authenticate(token, "client") ?? (allowDevice ? authenticate(token, "device") : undefined);
   };
   const dispatch = async (task) => {
     const store = await run2(exports_store.Service);
-    const assigned = await Effect14.runPromise(store.assignTask(task.id));
+    if ((task.inputAttachmentNames?.length ?? 0) > 0) {
+      const devices = await Effect15.runPromise(store.listDevices());
+      const target = devices.find((device) => device.id === task.targetDeviceId);
+      if (!canDispatchTaskToDevice(task, target)) {
+        return Effect15.runPromise(store.failTask(task.id, task.targetDeviceId, "Target worker no longer supports task file attachments. Upgrade the worker and retry."));
+      }
+    }
+    const assigned = await Effect15.runPromise(store.assignTask(task.id));
     if (assigned.status !== "assigned") {
       return assigned;
     }
-    if (hub.sendToDevice(assigned.targetDeviceId, SocketEvent.make({ _tag: "TaskAssigned", task: assigned }), assigned.provider === "grok-bot" ? () => Effect14.runSync(store.markTaskDispatched(assigned.id)) : undefined)) {
+    if (hub.sendToDevice(assigned.targetDeviceId, SocketEvent.make({ _tag: "TaskAssigned", task: assigned }), assigned.provider === "grok-bot" ? () => Effect15.runSync(store.markTaskDispatched(assigned.id)) : undefined)) {
       return assigned;
     }
-    return Effect14.runPromise(store.rollbackAssignment(task.id));
+    return Effect15.runPromise(store.rollbackAssignment(task.id));
   };
   const dispatchOperation = async (operation) => {
-    const assigned = await run2(Effect14.gen(function* () {
+    const assigned = await run2(Effect15.gen(function* () {
       const store = yield* exports_store.Service;
       return yield* store.assignOperation(operation.id);
     }));
@@ -1830,13 +2008,13 @@ Content-Length: 0\r
     if (hub.sendToDevice(assigned.targetDeviceId, SocketEvent.make({ _tag: "OperationAssigned", operation: assigned }))) {
       return assigned;
     }
-    return run2(Effect14.gen(function* () {
+    return run2(Effect15.gen(function* () {
       const store = yield* exports_store.Service;
       return yield* store.rollbackOperation(operation.id);
     }));
   };
   const dispatchPendingOperations = async (deviceId) => {
-    const operations = await run2(Effect14.gen(function* () {
+    const operations = await run2(Effect15.gen(function* () {
       const store = yield* exports_store.Service;
       return yield* store.pendingOperationsFor(deviceId);
     }));
@@ -1845,7 +2023,7 @@ Content-Length: 0\r
     }
   };
   const dispatchPendingTasks = async (deviceId) => {
-    const tasks = await run2(Effect14.gen(function* () {
+    const tasks = await run2(Effect15.gen(function* () {
       const store = yield* exports_store.Service;
       return yield* store.pendingTasksFor(deviceId);
     }));
@@ -1869,10 +2047,10 @@ Content-Length: 0\r
     })));
   };
   const handleSocketEvent = async (socket, input) => {
-    const event = await Effect14.runPromise(Effect14.try({
+    const event = await Effect15.runPromise(Effect15.try({
       try: () => JSON.parse(socketText(input)),
       catch: () => new RequestError({ status: 400, message: "Invalid socket JSON" })
-    }).pipe(Effect14.flatMap(decodeSocketEvent))).catch((cause) => {
+    }).pipe(Effect15.flatMap(decodeSocketEvent))).catch((cause) => {
       sendError(socket, "invalid_event", cause instanceof Error ? cause.message : String(cause));
       return;
     });
@@ -1907,7 +2085,12 @@ Content-Length: 0\r
           socket.close(4003, "Device registration timeout");
         }
       }, 5000);
-      socket.send(JSON.stringify(SocketEvent.make({ _tag: "Connected", serverVersion: version, connectedAt: now() })));
+      socket.send(JSON.stringify(SocketEvent.make({
+        _tag: "Connected",
+        serverVersion: version,
+        connectedAt: now(),
+        taskAttachments: true
+      })));
       return;
     }
     if (event._tag === "Authenticate") {
@@ -1929,7 +2112,7 @@ Content-Length: 0\r
         socket.close(4009, "Device is already connected");
         return;
       }
-      await run2(Effect14.gen(function* () {
+      await run2(Effect15.gen(function* () {
         const store = yield* exports_store.Service;
         yield* store.upsertDevice(device);
       }));
@@ -1948,7 +2131,7 @@ Content-Length: 0\r
     const settleOperation = (operationId) => {
       socket.send(JSON.stringify(SocketEvent.make({ _tag: "OperationSettled", operationId })));
     };
-    const processed = await run2(Effect14.gen(function* () {
+    const processed = await run2(Effect15.gen(function* () {
       const store = yield* exports_store.Service;
       switch (event._tag) {
         case "DeviceHeartbeat":
@@ -1960,7 +2143,7 @@ Content-Length: 0\r
           yield* store.acceptTask(event.taskId, deviceId);
           return;
         case "TaskFinished":
-          yield* store.finishTask(event.taskId, deviceId, event.result, event.providerSessionId);
+          yield* store.finishTask(event.taskId, deviceId, event.result, event.providerSessionId, event.attachments);
           return;
         case "TaskFailed":
           yield* store.failTask(event.taskId, deviceId, event.error);
@@ -2001,16 +2184,17 @@ Content-Length: 0\r
   };
   const api = async (request, url) => {
     if (url.pathname === "/api/health" && request.method === "GET") {
-      return json({ ok: true, version });
+      return json({ ok: true, version, taskAttachments: true });
     }
     if (url.pathname === "/api/auth/pair" && request.method === "POST") {
-      return run2(Effect14.gen(function* () {
+      return run2(Effect15.gen(function* () {
         const store = yield* exports_store.Service;
         const input = yield* body(request, decodeExchangePairingInput);
         return yield* store.exchangePairing(input.token);
       })).then((value) => json(value, 201)).catch(() => json({ error: "Pairing credential is invalid, expired, or already used" }, 401));
     }
-    const principal = await principalFor(request);
+    const attachmentRoute = request.method === "GET" && /^\/api\/tasks\/[^/]+\/attachments(?:\/[^/]+)?$/.test(url.pathname);
+    const principal = await principalFor(request, attachmentRoute);
     if (principal === undefined) {
       return json({ error: "Unauthorized" }, 401);
     }
@@ -2019,7 +2203,7 @@ Content-Length: 0\r
       return json({ error: "Owner token required" }, 403);
     }
     const sourceDeviceId = principal === "owner" ? undefined : principal.deviceId;
-    const effect = Effect14.gen(function* () {
+    const effect = Effect15.gen(function* () {
       const store = yield* exports_store.Service;
       if (url.pathname === "/api/auth/pairings" && request.method === "POST") {
         const input = yield* body(request, decodeCreatePairingInput);
@@ -2047,7 +2231,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* Effect14.tryPromise(() => Promise.all(operations.map(dispatchOperation))), 201);
+        return json(yield* Effect15.tryPromise(() => Promise.all(operations.map(dispatchOperation))), 201);
       }
       const abandonOperation = url.pathname.match(/^\/api\/operations\/([^/]+)\/abandon$/);
       if (request.method === "POST" && abandonOperation?.[1] !== undefined) {
@@ -2074,8 +2258,52 @@ Content-Length: 0\r
       if (url.pathname === "/api/tasks" && request.method === "POST") {
         const { input, targetDeviceId: target } = yield* resolveDelegation(yield* body(request, decodeCreateTaskInput), sourceDeviceId);
         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* Effect14.tryPromise(() => dispatch(task2)), 201);
+        const task2 = yield* store.createDelegation(input, target, principal, providerSessionId);
+        return json(yield* Effect15.tryPromise(() => dispatch(task2)), 201);
+      }
+      if (url.pathname === "/api/inbox" && request.method === "GET") {
+        return json(yield* store.inboxFor(principal));
+      }
+      const acknowledge = url.pathname.match(/^\/api\/inbox\/([^/]+)\/ack$/);
+      if (request.method === "POST" && acknowledge?.[1] !== undefined) {
+        return json(yield* store.acknowledgeCompletion(yield* pathId(TaskId, acknowledge[1]), principal));
+      }
+      const attachments2 = url.pathname.match(/^\/api\/tasks\/([^/]+)\/attachments$/);
+      if (request.method === "GET" && attachments2?.[1] !== undefined) {
+        const id = yield* pathId(TaskId, attachments2[1]);
+        const task2 = yield* store.getTask(id);
+        if (!canReadTaskAttachments(principal, task2)) {
+          return yield* new RequestError({
+            status: 403,
+            message: "Device cannot read this task's attachments"
+          });
+        }
+        return json(yield* store.listAttachments(id));
+      }
+      const attachment = url.pathname.match(/^\/api\/tasks\/([^/]+)\/attachments\/([^/]+)$/);
+      if (attachment?.[1] !== undefined && attachment[2] !== undefined && request.method === "GET") {
+        const id = yield* pathId(TaskId, attachment[1]);
+        const name = yield* Effect15.try({
+          try: () => decodeURIComponent(attachment[2]),
+          catch: () => new RequestError({ status: 400, message: "Invalid attachment name" })
+        }).pipe(Effect15.flatMap((value) => pathId(AttachmentName, value)));
+        const task2 = yield* store.getTask(id);
+        if (!canReadTaskAttachments(principal, task2)) {
+          return yield* new RequestError({
+            status: 403,
+            message: "Device cannot read this task's attachments"
+          });
+        }
+        const directionInput = url.searchParams.get("direction");
+        const direction = directionInput === null ? undefined : yield* pathId(AttachmentDirection, directionInput);
+        const data = yield* store.readAttachment(id, name, direction);
+        return new Response(new Uint8Array(data), {
+          headers: {
+            "content-type": "application/octet-stream",
+            "cache-control": "no-store",
+            "x-content-type-options": "nosniff"
+          }
+        });
       }
       const task = url.pathname.match(/^\/api\/tasks\/([^/]+)$/);
       if (request.method === "GET" && task?.[1] !== undefined) {
@@ -2099,7 +2327,7 @@ 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(Effect14.mapError((cause) => cause instanceof RequestError ? cause : new RequestError({
+    }).pipe(Effect15.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
     })));
@@ -2175,7 +2403,7 @@ Content-Length: 0\r
       if (deviceId === undefined) {
         return;
       }
-      run2(Effect14.gen(function* () {
+      run2(Effect15.gen(function* () {
         const store = yield* exports_store.Service;
         yield* store.requeueTasksFor(deviceId);
         yield* store.requeueOperationsFor(deviceId);
@@ -2187,7 +2415,7 @@ Content-Length: 0\r
     webRequest(incoming).then((request) => {
       const url = new URL(request.url);
       return url.pathname.startsWith("/api/") ? api(request, url) : json({ name: "Cohall relay", version, status: "running" });
-    }).then((response) => sendResponse(outgoing, response)).catch((cause) => sendResponse(outgoing, json({ error: cause instanceof Error ? cause.message : "Invalid request" }, cause instanceof Error && cause.message.includes("256 KiB") ? 413 : 400)));
+    }).then((response) => sendResponse(outgoing, response)).catch((cause) => sendResponse(outgoing, json({ error: cause instanceof Error ? cause.message : "Invalid request" }, cause instanceof Error && cause.message.includes("Request body exceeded") ? 413 : 400)));
   });
   server.on("upgrade", (request, socket, head) => {
     const url = URL.parse(request.url ?? "/", "http://cohall.local");
@@ -2238,17 +2466,18 @@ var init_main = __esm(async () => {
   init_config();
   init_hub();
   init_store();
-  RequestError = class RequestError extends Schema14.TaggedErrorClass()("Relay.RequestError", {
-    status: Schema14.Int,
-    message: Schema14.String
+  RequestError = class RequestError extends Schema16.TaggedErrorClass()("Relay.RequestError", {
+    status: Schema16.Int,
+    message: Schema16.String
   }) {
   };
+  maxTaskRequestBodyBytes = 3 * 1024 * 1024;
   if (false) {}
 });
 
 // apps/device/src/main.ts
 init_src();
-import { Effect as Effect15 } from "effect";
+import { Effect as Effect16 } from "effect";
 
 // packages/client/src/index.ts
 init_src();
@@ -2353,11 +2582,72 @@ var make = (options) => {
   return Service.of({
     devices: () => request("RelayClient.devices", "/api/devices", Schema2.Array(Device)),
     forgetDevice: (deviceId) => request("RelayClient.forgetDevice", `/api/devices/${encodeURIComponent(deviceId)}/forget`, Device, { method: "POST" }),
-    createTask: (input) => request("RelayClient.createTask", "/api/tasks", Task, {
-      method: "POST",
-      body: JSON.stringify(input)
+    createTask: (input) => Effect2.gen(function* () {
+      if ((input.attachments?.length ?? 0) > 0) {
+        const health = yield* request("RelayClient.attachmentSupport", "/api/health", Schema2.Struct({ taskAttachments: Schema2.optionalKey(Schema2.Boolean) }));
+        if (health.taskAttachments !== true) {
+          return yield* new RelayRequestError({
+            operation: "RelayClient.createTask",
+            message: "Upgrade the Cohall relay before sending file attachments"
+          });
+        }
+      }
+      return yield* request("RelayClient.createTask", "/api/tasks", Task, {
+        method: "POST",
+        body: JSON.stringify(input)
+      });
     }),
     getTask: (taskId) => request("RelayClient.getTask", `/api/tasks/${encodeURIComponent(taskId)}`, Task),
+    listAttachments: (taskId) => request("RelayClient.listAttachments", `/api/tasks/${encodeURIComponent(taskId)}/attachments`, Schema2.Array(TaskAttachment)),
+    readAttachment: (taskId, name, direction) => Effect2.tryPromise({
+      try: async (signal) => {
+        const operation = "RelayClient.readAttachment";
+        const response = await fetch(`${baseUrl}/api/tasks/${encodeURIComponent(taskId)}/attachments/${encodeURIComponent(name)}${direction === undefined ? "" : `?direction=${direction}`}`, {
+          headers: { authorization: `Bearer ${options.token}` },
+          signal: AbortSignal.any([signal, AbortSignal.timeout(30000)])
+        });
+        if (!response.ok) {
+          throw new RelayRequestError({
+            operation,
+            message: await responseMessage(response, operation),
+            status: response.status
+          });
+        }
+        if (response.body === null) {
+          throw new RelayDecodeError({
+            operation,
+            message: "Relay returned an empty attachment response"
+          });
+        }
+        const reader = response.body.getReader();
+        const chunks = [];
+        let size = 0;
+        while (true) {
+          const chunk = await reader.read();
+          if (chunk.done)
+            break;
+          size += chunk.value.byteLength;
+          if (size > maxAttachmentBytes) {
+            await reader.cancel();
+            throw new RelayDecodeError({ operation, message: "Attachment exceeded 256 KiB" });
+          }
+          chunks.push(chunk.value);
+        }
+        const bytes = new Uint8Array(size);
+        let offset = 0;
+        for (const chunk of chunks) {
+          bytes.set(chunk, offset);
+          offset += chunk.byteLength;
+        }
+        return bytes;
+      },
+      catch: (cause) => cause instanceof RelayRequestError || cause instanceof RelayDecodeError ? cause : new RelayRequestError({
+        operation: "RelayClient.readAttachment",
+        message: cause instanceof Error ? cause.message : String(cause)
+      })
+    }),
+    inbox: () => request("RelayClient.inbox", "/api/inbox", TaskInbox),
+    acknowledgeCompletion: (taskId) => request("RelayClient.acknowledgeCompletion", `/api/inbox/${encodeURIComponent(taskId)}/ack`, TaskInboxItem, { method: "POST" }),
     traceTask: (taskId) => request("RelayClient.traceTask", `/api/tasks/${encodeURIComponent(taskId)}/trace`, TaskTrace),
     cancelTask: (taskId) => request("RelayClient.cancelTask", `/api/tasks/${encodeURIComponent(taskId)}/cancel`, Task, {
       method: "POST"
@@ -2888,10 +3178,10 @@ var run = (options) => Effect3.callback((resume, signal) => {
 });
 
 // apps/device/src/cli.ts
-import { Effect as Effect9, Schema as Schema10 } from "effect";
-import { access as access4, mkdir as mkdir6, readFile as readFile4, stat as stat4, writeFile as writeFile6 } from "node:fs/promises";
+import { Effect as Effect10, Schema as Schema11 } from "effect";
+import { access as access4, mkdir as mkdir7, readFile as readFile4, stat as stat4, writeFile as writeFile7 } from "node:fs/promises";
 import { homedir as homedir4 } from "node:os";
-import { dirname as dirname6, join as join7, resolve as resolve3 } from "node:path";
+import { dirname as dirname6, join as join8, resolve as resolve3 } from "node:path";
 
 // skills/cohall/SKILL.md
 var SKILL_default = `---
@@ -2903,7 +3193,7 @@ description: Delegate through Cohall to another user-owned device or an existing
 
 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.
+permissions. The relay carries prompts, final results, task state, and explicitly attached files.
 
 Use the installed \`cohall\` executable when it is available. Fall back to
 \`npx -y @akshar5/cohall\` only when Cohall is not installed globally.
@@ -2964,6 +3254,16 @@ Do not delegate ordinary local work when the other device provides no advantage.
    when \`status\` is \`completed\`; use \`result\` in the current task. Report a
    \`failed\`, \`cancelled\`, or \`cancelling\` state accurately.
 
+   Pass an explicit local file with \`--attach path\` when the coding task needs
+   it. The MCP \`delegate\` tool takes \`attachment_paths\`. A task accepts up to
+   two files of 256 KiB each. The target can return files through the output
+   directory named in its task prompt. After completion, use
+   \`cohall attachments <task-id>\` and
+   \`cohall download <task-id> <name> --output <new-path>\` (or the corresponding
+   MCP tools). List results include input and output files. A shared name
+   downloads the output by default; use \`--direction input\` or the MCP
+   \`direction\` argument for the input. Named bots do not accept files.
+
 6. Reuse \`thread_id\` for related follow-ups so the target provider can resume
    its local session:
 
@@ -2978,6 +3278,11 @@ 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.
 
+For work sent with \`--no-wait\`, check \`cohall inbox\` when returning to the task.
+Read the full result with \`cohall status <task-id>\`, use it in the current work,
+then run \`cohall inbox ack <task-id>\`. Results that arrive after a wait times
+out appear in the same inbox.
+
 ## Message named bots
 
 1. Run \`cohall bots\` and choose a listed target. Use its qualified target when
@@ -3359,7 +3664,8 @@ var TaskResult = Schema5.Struct({
   target_device_id: DeviceId,
   bot_id: Schema5.optionalKey(BotId),
   result: Schema5.optionalKey(Schema5.String),
-  error: Schema5.optionalKey(Schema5.String)
+  error: Schema5.optionalKey(Schema5.String),
+  inbox_warning: Schema5.optionalKey(Schema5.String)
 });
 var matchingDevices = (devices, target) => {
   const value = target.replace(/^@/, "");
@@ -3413,6 +3719,20 @@ var taskResult = (task) => TaskResult.make({
   ...task.result === undefined ? {} : { result: task.result },
   ...task.error === undefined ? {} : { error: task.error }
 });
+var acknowledgedTaskResult = async (client, task) => {
+  const result = taskResult(task);
+  const acknowledgementError = await Effect5.runPromise(client.acknowledgeCompletion(task.id)).then(() => {
+    return;
+  }).catch((cause) => {
+    if (cause instanceof RelayRequestError && cause.status === 404)
+      return;
+    return cause instanceof Error ? cause.message : String(cause);
+  });
+  return acknowledgementError === undefined ? result : TaskResult.make({
+    ...result,
+    inbox_warning: `Result received, but the inbox could not be cleared: ${acknowledgementError}`
+  });
+};
 var createDelegation = Effect5.fn("Cohall.createDelegation")(function* (client, configuration, options) {
   const devices = yield* client.devices();
   if (devices.length === 0) {
@@ -3459,7 +3779,8 @@ var createDelegation = Effect5.fn("Cohall.createDelegation")(function* (client,
     ...options.context === undefined ? {} : { context: options.context },
     ...options.workspace === undefined ? {} : { workspace: options.workspace },
     ...provider === undefined ? {} : { provider },
-    ...parentTaskId === undefined ? {} : { parentTaskId }
+    ...parentTaskId === undefined ? {} : { parentTaskId },
+    ...options.attachments === undefined ? {} : { attachments: options.attachments }
   });
 });
 var waitForTask = Effect5.fn("Cohall.waitForTask")(function* (client, initial, timeoutSeconds) {
@@ -5111,10 +5432,143 @@ var switchRelay = async (options) => {
   };
 };
 
+// apps/device/src/task-attachments.ts
+init_src();
+import { Effect as Effect9, Schema as Schema10 } from "effect";
+import { constants as constants3 } from "node:fs";
+import { lstat as lstat2, mkdtemp as mkdtemp3, mkdir as mkdir6, open as open3, readdir, rm as rm4, writeFile as writeFile6 } from "node:fs/promises";
+import { tmpdir as tmpdir2 } from "node:os";
+import { basename as basename2, join as join7 } from "node:path";
+var readInputAttachments = async (paths2) => {
+  if (paths2.length > maxTaskAttachments) {
+    throw new Error(`A task supports at most ${maxTaskAttachments} input files`);
+  }
+  const names = new Set;
+  return Promise.all(paths2.map(async (path) => {
+    const name = Schema10.decodeUnknownSync(AttachmentName)(basename2(path));
+    const key = name.normalize("NFC").toLocaleLowerCase("en-US");
+    if (names.has(key)) {
+      throw new Error(`Attachment name ${name} is repeated`);
+    }
+    names.add(key);
+    const source = await lstat2(path);
+    if (!source.isFile()) {
+      throw new Error(`Attachment ${name} must be a regular file`);
+    }
+    const handle = await open3(path, constants3.O_RDONLY | (process.platform === "win32" ? 0 : constants3.O_NOFOLLOW));
+    try {
+      const metadata = await handle.stat();
+      if (!metadata.isFile() || metadata.dev !== source.dev || metadata.ino !== source.ino || metadata.size < 1 || metadata.size > maxAttachmentBytes) {
+        throw new Error(`Attachment ${name} must be a regular file of 1 to ${maxAttachmentBytes} bytes`);
+      }
+      const data = await handle.readFile();
+      if (data.length < 1 || data.length > maxAttachmentBytes) {
+        throw new Error(`Attachment ${name} changed size while reading`);
+      }
+      return { name, data: data.toString("base64") };
+    } finally {
+      await handle.close();
+    }
+  }));
+};
+var prepareTaskFiles = async (configuration, taskId, inputNames, signal) => {
+  const client = exports_src.make({ baseUrl: configuration.relayUrl, token: configuration.token });
+  const root = await mkdtemp3(join7(tmpdir2(), "cohall-task-"));
+  const input = join7(root, "input");
+  const output = join7(root, "output");
+  try {
+    await Promise.all([mkdir6(input), mkdir6(output)]);
+    for (const name of inputNames) {
+      const data = await Effect9.runPromise(client.readAttachment(taskId, name), { signal });
+      await writeFile6(join7(input, name), data, { flag: "wx", mode: 384 });
+    }
+    return {
+      input,
+      output,
+      inputNames,
+      collectOutputs: () => collectOutputs(output),
+      cleanup: () => rm4(root, { recursive: true, force: true })
+    };
+  } catch (cause) {
+    await rm4(root, { recursive: true, force: true });
+    throw cause;
+  }
+};
+var collectOutputs = async (directory) => {
+  const entries = await readdir(directory, { withFileTypes: true });
+  if (entries.length > maxTaskAttachments) {
+    throw new Error(`A task can return at most ${maxTaskAttachments} files`);
+  }
+  const files = [];
+  const names = new Set;
+  for (const entry of entries) {
+    const name = Schema10.decodeUnknownSync(AttachmentName)(entry.name);
+    if (!entry.isFile()) {
+      throw new Error(`Output ${name} must be a regular file`);
+    }
+    const key = name.normalize("NFC").toLocaleLowerCase("en-US");
+    if (names.has(key)) {
+      throw new Error(`Output ${name} repeats another file name`);
+    }
+    names.add(key);
+    const handle = await open3(join7(directory, name), constants3.O_RDONLY | (process.platform === "win32" ? 0 : constants3.O_NOFOLLOW));
+    try {
+      const metadata = await handle.stat();
+      const pathMetadata = await lstat2(join7(directory, name));
+      if (!metadata.isFile() || !pathMetadata.isFile() || metadata.dev !== pathMetadata.dev || metadata.ino !== pathMetadata.ino || metadata.size < 1 || metadata.size > maxAttachmentBytes) {
+        throw new Error(`Output ${name} must be a regular file of 1 to ${maxAttachmentBytes} bytes`);
+      }
+      const data = await handle.readFile();
+      if (data.length < 1 || data.length > maxAttachmentBytes) {
+        throw new Error(`Output ${name} changed size while reading`);
+      }
+      files.push({ name, data: data.toString("base64") });
+    } finally {
+      await handle.close();
+    }
+  }
+  return files;
+};
+
+// apps/device/src/mcp-diagnostics.ts
+init_src();
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import {
+  getDefaultEnvironment,
+  StdioClientTransport
+} from "@modelcontextprotocol/sdk/client/stdio.js";
+var checkMcp = async (entrypoint, relayUrl, token) => {
+  const client = new Client({ name: "cohall-doctor", version });
+  const transport = new StdioClientTransport({
+    command: process.execPath,
+    args: [entrypoint, "mcp"],
+    env: {
+      ...getDefaultEnvironment(),
+      COHALL_CONFIG: configurationPath(),
+      COHALL_RELAY_URL: relayUrl,
+      COHALL_CLIENT_TOKEN: token
+    },
+    stderr: "pipe"
+  });
+  try {
+    await client.connect(transport, { timeout: 5000 });
+    const { tools } = await client.listTools(undefined, { timeout: 5000 });
+    if (tools.length === 0)
+      return { status: "error", error: "MCP server exposed no tools" };
+    return { status: "ok", tool_count: tools.length };
+  } catch (cause) {
+    return { status: "error", error: cause instanceof Error ? cause.message : String(cause) };
+  } finally {
+    await client.close();
+  }
+};
+
 // apps/device/src/cli.ts
 var valueOptions = new Set([
+  "attach",
   "context",
   "context-file",
+  "direction",
   "grok-gateway",
   "error",
   "label",
@@ -5122,6 +5576,7 @@ var valueOptions = new Set([
   "message",
   "message-file",
   "name",
+  "output",
   "parent",
   "prompt",
   "prompt-file",
@@ -5167,10 +5622,13 @@ Usage:
   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]
+                  [--attach path] [--timeout seconds] [--no-wait]
   cohall status <task-id>
+  cohall inbox [ack <task-id>]
   cohall trace <task-id> [--follow]
   cohall wait <task-id> [--timeout seconds]
+  cohall attachments <task-id>
+  cohall download <task-id> <name> --output path [--direction input|output]
   cohall cancel <task-id>
   cohall reply <task-id> --message-file path | --message text | --message - | --error text
   cohall thread <thread-id>
@@ -5333,14 +5791,14 @@ var pairingToken = async (arguments_) => {
   return token;
 };
 var client = async () => {
-  const configuration = await Effect9.runPromise(loadClientConfiguration);
+  const configuration = await Effect10.runPromise(loadClientConfiguration);
   return {
     configuration,
     relay: exports_src.make({ baseUrl: configuration.relayUrl, token: configuration.token })
   };
 };
 var ownerClient = async () => {
-  const configuration = await Effect9.runPromise(loadOwnerConfiguration);
+  const configuration = await Effect10.runPromise(loadOwnerConfiguration);
   return {
     configuration,
     relay: exports_src.make({ baseUrl: configuration.relayUrl, token: configuration.token })
@@ -5348,17 +5806,17 @@ var ownerClient = async () => {
 };
 var installSkill = async (target) => {
   const roots = {
-    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")
+    agents: join8(homedir4(), ".agents", "skills", "cohall", "SKILL.md"),
+    claude: join8(homedir4(), ".claude", "skills", "cohall", "SKILL.md"),
+    opencode: join8(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 mkdir6(dirname6(path), { recursive: true });
-    await writeFile6(path, SKILL_default);
+    await mkdir7(dirname6(path), { recursive: true });
+    await writeFile7(path, SKILL_default);
   }
   return selected;
 };
@@ -5368,7 +5826,7 @@ 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 id = Schema11.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");
@@ -5506,7 +5964,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 Effect9.runPromise(relay2.devices());
+        const devices = await Effect10.runPromise(relay2.devices());
         assertDeviceOperationSupport(devices);
         print({
           dry_run: true,
@@ -5516,7 +5974,7 @@ var runCli = async (command, raw) => {
         });
         return;
       }
-      const operations = await Effect9.runPromise(relay2.createUpgradeOperations({ target: normalizedTarget, restart }));
+      const operations = await Effect10.runPromise(relay2.createUpgradeOperations({ target: normalizedTarget, restart }));
       print({
         queued: operations.length,
         requested_version: normalizedTarget,
@@ -5542,10 +6000,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 Effect9.runPromise(relay2.abandonOperation(Schema10.decodeUnknownSync(OperationId)(arguments_.positionals[1]))));
+      print(await Effect10.runPromise(relay2.abandonOperation(Schema11.decodeUnknownSync(OperationId)(arguments_.positionals[1]))));
       return;
     }
-    print(await Effect9.runPromise(relay2.operations()));
+    print(await Effect10.runPromise(relay2.operations()));
     return;
   }
   if (command === "join") {
@@ -5624,7 +6082,7 @@ var runCli = async (command, raw) => {
     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 Effect9.runPromise(parseWorkspaces("", JSON.stringify(supplied)));
+    const workspaces = supplied.length === 0 ? existing?.workspaces ?? [] : await Effect10.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;
@@ -5642,7 +6100,7 @@ var runCli = async (command, raw) => {
       ...model === undefined ? {} : { model },
       ...grokGateway === undefined ? {} : { grokGateway },
       ...(sandbox ?? existing?.sandbox) === undefined ? {} : {
-        sandbox: Schema10.decodeUnknownSync(Schema10.Literals(["read-only", "workspace-write", "danger-full-access"]))(sandbox ?? existing?.sandbox)
+        sandbox: Schema11.decodeUnknownSync(Schema11.Literals(["read-only", "workspace-write", "danger-full-access"]))(sandbox ?? existing?.sandbox)
       }
     });
     await writeStoredConfiguration(configuration2);
@@ -5685,7 +6143,7 @@ var runCli = async (command, raw) => {
     noPositionals(arguments_, command);
     if (arguments_.options.has("all")) {
       const { relay: relay2 } = await client();
-      print(allDeviceHealth(await Effect9.runPromise(relay2.devices()), version));
+      print(allDeviceHealth(await Effect10.runPromise(relay2.devices()), version));
       return;
     }
     const configuration2 = await readStoredConfiguration();
@@ -5707,15 +6165,17 @@ var runCli = async (command, raw) => {
       return;
     });
     const clientToken = process.env.COHALL_CLIENT_TOKEN ?? storedCredentials.clientToken;
+    const mcp = clientToken === undefined ? { status: "not configured" } : await checkMcp(process.argv[1] ?? "", relayUrl, 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 Effect9.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 Effect10.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);
     const warnings = [
       ...response?.ok === true ? [] : ["Relay is unreachable"],
       ...versionWarning === undefined ? [] : [versionWarning],
+      ...mcp.status === "error" ? [`MCP check failed: ${mcp.error}`] : [],
       ...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"
       ] : [],
@@ -5729,6 +6189,7 @@ var runCli = async (command, raw) => {
       relay_url: relayUrl,
       config_path: configurationPath(),
       client_credential: process.env.COHALL_CLIENT_TOKEN !== undefined || storedCredentials.clientToken !== undefined,
+      mcp,
       device_credential: hasDeviceCredential,
       workspaces: configuration2?.workspaces ?? [],
       providers: providerExecutables,
@@ -5751,7 +6212,7 @@ var runCli = async (command, raw) => {
     allowOptions(arguments_, []);
     noPositionals(arguments_, command);
     const { relay: relay2 } = await client();
-    print(deviceVersions(await Effect9.runPromise(relay2.devices()), version));
+    print(deviceVersions(await Effect10.runPromise(relay2.devices()), version));
     return;
   }
   if (command === "usage") {
@@ -5759,7 +6220,7 @@ var runCli = async (command, raw) => {
     noPositionals(arguments_, command);
     const { relay: relay2 } = await client();
     print({
-      ...await Effect9.runPromise(relay2.usage()),
+      ...await Effect10.runPromise(relay2.usage()),
       scope: "Retained Cohall task activity; provider token and billing usage are not available."
     });
     return;
@@ -5770,7 +6231,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 Effect9.runPromise(relay2.createPairing({ label: option(arguments_, "label") ?? "Cohall device", roles }));
+      const credential = await Effect10.runPromise(relay2.createPairing({ label: option(arguments_, "label") ?? "Cohall device", roles }));
       print({
         relay_url: configuration2.relayUrl,
         pairing_token: credential.token,
@@ -5782,35 +6243,36 @@ var runCli = async (command, raw) => {
     if (command === "sessions") {
       allowOptions(arguments_, []);
       noPositionals(arguments_, command);
-      print(await Effect9.runPromise(relay2.authSessions()));
+      print(await Effect10.runPromise(relay2.authSessions()));
       return;
     }
     if (command === "forget") {
       allowOptions(arguments_, []);
-      print(await Effect9.runPromise(relay2.forgetDevice(Schema10.decodeUnknownSync(DeviceId)(identifier(arguments_, "device id")))));
+      print(await Effect10.runPromise(relay2.forgetDevice(Schema11.decodeUnknownSync(DeviceId)(identifier(arguments_, "device id")))));
       return;
     }
     allowOptions(arguments_, []);
-    print(await Effect9.runPromise(relay2.revokeAuthSession(Schema10.decodeUnknownSync(AuthSessionId)(identifier(arguments_, "session id")))));
+    print(await Effect10.runPromise(relay2.revokeAuthSession(Schema11.decodeUnknownSync(AuthSessionId)(identifier(arguments_, "session id")))));
     return;
   }
   const { configuration, relay } = await client();
   if (command === "devices") {
     allowOptions(arguments_, []);
     noPositionals(arguments_, command);
-    print(await Effect9.runPromise(relay.devices()));
+    print(await Effect10.runPromise(relay.devices()));
     return;
   }
   if (command === "bots") {
     allowOptions(arguments_, []);
     noPositionals(arguments_, command);
-    print(listBots(await Effect9.runPromise(relay.devices())));
+    print(listBots(await Effect10.runPromise(relay.devices())));
     return;
   }
   if (command === "delegate" || command === "send") {
     allowOptions(arguments_, [
       "context",
       "context-file",
+      "attach",
       "no-wait",
       "parent",
       "prompt",
@@ -5839,56 +6301,96 @@ var runCli = async (command, raw) => {
       throw new Error("Use either a positional prompt or --prompt, not both");
     }
     const context = await readInput(arguments_, "context");
+    const attachments2 = await readInputAttachments(values(arguments_, "attach"));
     const target = positionalTarget ?? option(arguments_, "target");
     const thread = option(arguments_, "thread");
     const workspace = option(arguments_, "workspace");
     const provider = option(arguments_, "provider");
     const parent = option(arguments_, "parent");
-    const task = await Effect9.runPromise(createDelegation(relay, configuration, {
+    const task = await Effect10.runPromise(createDelegation(relay, configuration, {
       prompt,
       ...target === undefined ? {} : { target },
       ...context === undefined ? {} : { context },
-      ...thread === undefined ? {} : { threadId: Schema10.decodeUnknownSync(ThreadId)(thread) },
-      ...parent === undefined ? {} : { parentTaskId: Schema10.decodeUnknownSync(TaskId)(parent) },
+      ...thread === undefined ? {} : { threadId: Schema11.decodeUnknownSync(ThreadId)(thread) },
+      ...parent === undefined ? {} : { parentTaskId: Schema11.decodeUnknownSync(TaskId)(parent) },
       ...workspace === undefined ? {} : { workspace },
-      ...provider === undefined ? {} : { provider: Schema10.decodeUnknownSync(Provider)(provider) }
+      ...provider === undefined ? {} : { provider: Schema11.decodeUnknownSync(Provider)(provider) },
+      ...attachments2.length === 0 ? {} : { attachments: attachments2 }
     }));
-    print(taskResult(arguments_.options.has("no-wait") ? task : await Effect9.runPromise(waitForTask(relay, task, waitSeconds))));
+    const completed = arguments_.options.has("no-wait") ? task : await Effect10.runPromise(waitForTask(relay, task, waitSeconds));
+    print(arguments_.options.has("no-wait") ? taskResult(completed) : await acknowledgedTaskResult(relay, completed));
+    return;
+  }
+  if (command === "inbox") {
+    allowOptions(arguments_, []);
+    if (arguments_.positionals[0] === "ack") {
+      if (arguments_.positionals.length !== 2)
+        throw new Error("Usage: cohall inbox ack <task-id>");
+      const id = Schema11.decodeUnknownSync(TaskId)(arguments_.positionals[1]);
+      print(await Effect10.runPromise(relay.acknowledgeCompletion(id)));
+      return;
+    }
+    noPositionals(arguments_, command);
+    print(await Effect10.runPromise(relay.inbox()));
     return;
   }
   if (command === "status") {
     allowOptions(arguments_, []);
-    const id = Schema10.decodeUnknownSync(TaskId)(identifier(arguments_, "task id"));
-    print(taskResult(await Effect9.runPromise(relay.getTask(id))));
+    const id = Schema11.decodeUnknownSync(TaskId)(identifier(arguments_, "task id"));
+    print(taskResult(await Effect10.runPromise(relay.getTask(id))));
+    return;
+  }
+  if (command === "attachments") {
+    allowOptions(arguments_, []);
+    const id = Schema11.decodeUnknownSync(TaskId)(identifier(arguments_, "task id"));
+    print(await Effect10.runPromise(relay.listAttachments(id)));
+    return;
+  }
+  if (command === "download") {
+    allowOptions(arguments_, ["output", "direction"]);
+    if (arguments_.positionals.length !== 2) {
+      throw new Error("Usage: cohall download <task-id> <name> --output path [--direction input|output]");
+    }
+    const destination = option(arguments_, "output");
+    if (destination === undefined) {
+      throw new Error("--output is required");
+    }
+    const id = Schema11.decodeUnknownSync(TaskId)(arguments_.positionals[0]);
+    const name = Schema11.decodeUnknownSync(AttachmentName)(arguments_.positionals[1]);
+    const directionInput = option(arguments_, "direction");
+    const direction = directionInput === undefined ? undefined : Schema11.decodeUnknownSync(AttachmentDirection)(directionInput);
+    const data = await Effect10.runPromise(relay.readAttachment(id, name, direction));
+    await writeFile7(destination, data, { flag: "wx", mode: 384 });
+    print({ task_id: id, name, path: resolve3(destination), bytes: data.length });
     return;
   }
   if (command === "trace") {
     allowOptions(arguments_, ["follow"]);
-    const id = Schema10.decodeUnknownSync(TaskId)(identifier(arguments_, "task id"));
+    const id = Schema11.decodeUnknownSync(TaskId)(identifier(arguments_, "task id"));
     if (arguments_.options.has("follow")) {
-      await Effect9.runPromise(followTaskTrace(relay, id, printLine));
+      await Effect10.runPromise(followTaskTrace(relay, id, printLine));
       return;
     }
-    print(await Effect9.runPromise(relay.traceTask(id)));
+    print(await Effect10.runPromise(relay.traceTask(id)));
     return;
   }
   if (command === "wait") {
     allowOptions(arguments_, ["timeout"]);
-    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_)))));
+    const id = Schema11.decodeUnknownSync(TaskId)(identifier(arguments_, "task id"));
+    const task = await Effect10.runPromise(relay.getTask(id));
+    print(taskResult(await Effect10.runPromise(waitForTask(relay, task, timeout(arguments_)))));
     return;
   }
   if (command === "cancel") {
     allowOptions(arguments_, []);
-    const id = Schema10.decodeUnknownSync(TaskId)(identifier(arguments_, "task id"));
-    print(taskResult(await Effect9.runPromise(relay.cancelTask(id))));
+    const id = Schema11.decodeUnknownSync(TaskId)(identifier(arguments_, "task id"));
+    print(taskResult(await Effect10.runPromise(relay.cancelTask(id))));
     return;
   }
   if (command === "thread") {
     allowOptions(arguments_, []);
-    const id = Schema10.decodeUnknownSync(ThreadId)(identifier(arguments_, "thread id"));
-    print(await Effect9.runPromise(threadContext(relay, id)));
+    const id = Schema11.decodeUnknownSync(ThreadId)(identifier(arguments_, "thread id"));
+    print(await Effect10.runPromise(threadContext(relay, id)));
     return;
   }
   throw new Error(`Unknown Cohall command: ${command}`);
@@ -5896,15 +6398,15 @@ var runCli = async (command, raw) => {
 
 // apps/device/src/daemon.ts
 init_src();
-import { Effect as Effect10, Schedule as Schedule3, Schema as Schema11 } from "effect";
-import { constants as constants3 } from "node:fs";
-import { open as open3, realpath as realpath5, stat as stat5 } from "node:fs/promises";
+import { Effect as Effect11, Schedule as Schedule3, Schema as Schema12 } from "effect";
+import { constants as constants4 } from "node:fs";
+import { open as open4, realpath as realpath5, stat as stat5 } 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 { basename as basename3, isAbsolute as isAbsolute3, relative as relative2 } from "node:path";
 import { WebSocket as WebSocket2 } from "ws";
 var maxQueuedRelayMessages = 8;
 
-class DeviceConnectionError extends Schema11.TaggedErrorClass()("Device.ConnectionError", { message: Schema11.String }) {
+class DeviceConnectionError extends Schema12.TaggedErrorClass()("Device.ConnectionError", { message: Schema12.String }) {
 }
 var socketUrl = (configuration) => {
   const url = new URL(configuration.relayUrl);
@@ -5930,6 +6432,9 @@ var capabilities = (providers) => {
     label: providerLabel(provider),
     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 (providers.some((provider) => provider !== "grok-bot")) {
+    values2.push({ id: "task-attachments", label: "Task file attachments" });
+  }
   if (findExecutable("google-chrome") !== undefined || findExecutable("chromium") !== undefined || platform4() === "darwin") {
     values2.push({ id: "browser-session", label: "Signed-in browser" });
   }
@@ -5962,7 +6467,7 @@ var describeDevice = (configuration, status = "online", bots = []) => {
     capabilities: capabilities(providers),
     workspaces: configuration.workspaces.map((path) => ({
       path,
-      label: basename2(path) || path
+      label: basename3(path) || path
     })),
     version,
     lastSeenAt: now()
@@ -5986,8 +6491,8 @@ var allowedWorkspace = async (configuration, requested) => {
 var openAllowedWorkspace = async (configuration, requested) => {
   const path = await allowedWorkspace(configuration, requested);
   const operatingSystem2 = platform4();
-  const flags = constants3.O_RDONLY | (operatingSystem2 === "win32" ? 0 : constants3.O_DIRECTORY | constants3.O_NOFOLLOW);
-  const handle = await open3(path, flags);
+  const flags = constants4.O_RDONLY | (operatingSystem2 === "win32" ? 0 : constants4.O_DIRECTORY | constants4.O_NOFOLLOW);
+  const handle = await open4(path, flags);
   const identity = await handle.stat();
   if (!identity.isDirectory()) {
     await handle.close();
@@ -6012,7 +6517,7 @@ var openAllowedWorkspace = async (configuration, requested) => {
     close: () => handle.close()
   };
 };
-var promptFor = (task, deviceName) => {
+var promptFor = (task, deviceName, files) => {
   const context = task.context === undefined ? "" : `
 
 Relevant context supplied by the sending agent:
@@ -6022,6 +6527,14 @@ ${task.context}`;
     "Complete the delegated task using this device's local workspace, tools, credentials, and signed-in services.",
     "Never read, reveal, copy, or use Cohall configuration files or Cohall authentication tokens.",
     "Return a concise, complete result with the evidence the sending agent needs.",
+    ...files === undefined ? [] : [
+      ...files.inputNames.length === 0 ? [] : [
+        `Input directory: ${files.input}`,
+        `Input file names: ${files.inputNames.join(", ")}`
+      ],
+      `Output directory: ${files.output}`,
+      "To return files, write at most 2 regular files of up to 256 KiB each in the output directory and mention them in your result."
+    ],
     `
 Task:
 ${task.prompt}${context}`
@@ -6033,11 +6546,25 @@ var send = (state, event) => {
     state.socket.send(JSON.stringify(event));
   }
 };
+var omitOutputFiles = (event, note) => {
+  if (event._tag !== "TaskFinished" || (event.attachments?.length ?? 0) === 0) {
+    return event;
+  }
+  const message = `
+
+[Output files omitted: ${note}]`;
+  return SocketEvent.make({
+    _tag: "TaskFinished",
+    taskId: event.taskId,
+    result: `${event.result.slice(0, 131072 - message.length)}${message}`,
+    ...event.providerSessionId === undefined ? {} : { providerSessionId: event.providerSessionId }
+  });
+};
 var sendTerminal = (state, taskId, event) => {
-  const payload = JSON.stringify(event);
-  state.terminal.set(taskId, payload);
+  const safeEvent = state.supportsAttachments ? event : omitOutputFiles(event, "the relay does not support attachments. Upgrade the relay and retry.");
+  state.terminal.set(taskId, safeEvent);
   if (state.socket?.readyState === WebSocket2.OPEN) {
-    state.socket.send(payload);
+    state.socket.send(JSON.stringify(safeEvent));
   }
 };
 var sendOperationTerminal = (state, operationId, event) => {
@@ -6100,9 +6627,9 @@ var execute = (configuration, state, task) => {
   const controller = new AbortController;
   state.tasks.set(task.id, { task, controller });
   send(state, SocketEvent.make({ _tag: "TaskAccepted", taskId: task.id }));
-  const workflow = Effect10.gen(function* () {
+  const workflow = Effect11.gen(function* () {
     if (task.provider === "grok-bot") {
-      return yield* Effect10.tryPromise({
+      return yield* Effect11.tryPromise({
         try: (signal) => runGrokBot(configuration.grokGateway, task, signal),
         catch: (cause) => new ProviderRunError({
           provider: task.provider,
@@ -6110,39 +6637,64 @@ var execute = (configuration, state, task) => {
         })
       });
     }
-    const workspace = yield* Effect10.tryPromise({
+    const provider = task.provider;
+    if (!state.supportsAttachments && (task.inputAttachmentNames?.length ?? 0) > 0) {
+      return yield* new ProviderRunError({
+        provider,
+        message: "The relay does not support task file attachments"
+      });
+    }
+    const workspace = yield* Effect11.tryPromise({
       try: () => openAllowedWorkspace(configuration, task.workspace),
       catch: (cause) => new ProviderRunError({
-        provider: task.provider,
+        provider,
         message: cause instanceof Error ? cause.message : String(cause)
       })
     });
-    const sessionId = task.providerSessionId ?? state.sessions.get(sessionKey(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(Effect10.ensuring(Effect10.promise(() => workspace.close().catch(() => {
+    return yield* Effect11.gen(function* () {
+      const files = state.supportsAttachments ? yield* Effect11.tryPromise({
+        try: (signal) => prepareTaskFiles(configuration, task.id, task.inputAttachmentNames ?? [], signal),
+        catch: (cause) => new ProviderRunError({
+          provider,
+          message: cause instanceof Error ? cause.message : String(cause)
+        })
+      }) : undefined;
+      const sessionId = task.providerSessionId ?? state.sessions.get(sessionKey(task));
+      return yield* run({
+        provider,
+        threadId: task.threadId,
+        taskId: task.id,
+        prompt: promptFor(task, configuration.name, files),
+        cwd: workspace.cwd,
+        beforeSpawn: workspace.validate,
+        ...sessionId === undefined ? {} : { sessionId },
+        ...configuration.model === undefined ? {} : { model: configuration.model },
+        ...configuration.sandbox === undefined ? {} : { sandbox: configuration.sandbox }
+      }).pipe(Effect11.flatMap((result) => files === undefined ? Effect11.succeed(result) : Effect11.tryPromise({
+        try: async () => ({ ...result, attachments: await files.collectOutputs() }),
+        catch: (cause) => new ProviderRunError({
+          provider,
+          message: cause instanceof Error ? cause.message : String(cause)
+        })
+      })), Effect11.ensuring(files === undefined ? Effect11.void : Effect11.promise(() => files.cleanup())));
+    }).pipe(Effect11.ensuring(Effect11.promise(() => workspace.close().catch(() => {
       return;
     }))));
   });
-  Effect10.runPromise(workflow, { signal: controller.signal }).then((result) => {
+  Effect11.runPromise(workflow, { signal: controller.signal }).then((result) => {
+    const finished = SocketEvent.make({
+      _tag: "TaskFinished",
+      taskId: task.id,
+      result: result.result,
+      ...result.sessionId === undefined ? {} : { providerSessionId: result.sessionId },
+      ...result.attachments === undefined || result.attachments.length === 0 ? {} : { attachments: result.attachments }
+    });
+    const bounded2 = Buffer.byteLength(JSON.stringify(finished)) > maxSocketPayloadBytes ? omitOutputFiles(finished, "the combined result exceeded the 1 MiB transfer limit. Shorten the result or files and retry.") : finished;
     if (result.sessionId !== undefined) {
       state.sessions.set(sessionKey(task), result.sessionId);
     }
     remember(state, task.id);
-    sendTerminal(state, task.id, SocketEvent.make({
-      _tag: "TaskFinished",
-      taskId: task.id,
-      result: result.result,
-      ...result.sessionId === undefined ? {} : { providerSessionId: result.sessionId }
-    }));
+    sendTerminal(state, task.id, bounded2);
   }).catch((cause) => {
     remember(state, task.id);
     sendTerminal(state, task.id, controller.signal.aborted ? SocketEvent.make({ _tag: "TaskCancelled", taskId: task.id }) : SocketEvent.make({
@@ -6233,7 +6785,7 @@ var cancel = (state, taskId) => {
   remember(state, taskId);
   sendTerminal(state, taskId, SocketEvent.make({ _tag: "TaskCancelled", taskId }));
 };
-var connect = (configuration, state) => Effect10.tryPromise({
+var connect = (configuration, state) => Effect11.tryPromise({
   try: (signal) => new Promise((complete) => {
     const socket = new WebSocket2(socketUrl(configuration), {
       maxPayload: maxSocketPayloadBytes,
@@ -6298,18 +6850,21 @@ var connect = (configuration, state) => Effect10.tryPromise({
           return;
         }
         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({
+        const event = await Effect11.runPromise(Effect11.try({
           try: () => JSON.parse(text3),
           catch: () => new DeviceConnectionError({ message: "Relay sent invalid JSON" })
-        }).pipe(Effect10.flatMap(decodeSocketEvent)));
+        }).pipe(Effect11.flatMap(decodeSocketEvent)));
         if (event._tag === "Connected") {
+          state.supportsAttachments = event.taskAttachments === true;
           state.socket = socket;
           socket.send(JSON.stringify(SocketEvent.make({
             _tag: "DeviceHello",
             device: describeDevice(configuration, state.tasks.size > 0 || state.operation !== undefined ? "busy" : "online", bots)
           })));
-          for (const payload of state.terminal.values()) {
-            socket.send(payload);
+          for (const [taskId, pending] of state.terminal) {
+            const safeEvent = state.supportsAttachments ? pending : omitOutputFiles(pending, "the relay does not support attachments. Upgrade the relay and retry.");
+            state.terminal.set(taskId, safeEvent);
+            socket.send(JSON.stringify(safeEvent));
           }
           for (const payload of state.operationTerminal.values()) {
             socket.send(payload);
@@ -6359,6 +6914,7 @@ var connect = (configuration, state) => Effect10.tryPromise({
 var runDaemon = (configuration) => {
   const state = {
     socket: undefined,
+    supportsAttachments: false,
     processing: Promise.resolve(),
     terminal: new Map,
     queue: [],
@@ -6370,7 +6926,7 @@ var runDaemon = (configuration) => {
     operationTerminal: new Map,
     completedOperations: new Set
   };
-  return connect(configuration, state).pipe(Effect10.repeat({ schedule: Schedule3.spaced("2 seconds") }), Effect10.ensuring(Effect10.sync(() => {
+  return connect(configuration, state).pipe(Effect11.repeat({ schedule: Schedule3.spaced("2 seconds") }), Effect11.ensuring(Effect11.sync(() => {
     state.socket?.close();
     for (const { controller } of state.tasks.values()) {
       controller.abort();
@@ -6382,8 +6938,9 @@ var runDaemon = (configuration) => {
 init_src();
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { Effect as Effect11 } from "effect";
+import { Effect as Effect12, Schema as Schema13 } from "effect";
 import * as z from "zod/v4";
+import { writeFile as writeFile8 } from "node:fs/promises";
 var output = (value) => ({
   content: [{ type: "text", text: JSON.stringify(value, null, 2) }]
 });
@@ -6397,12 +6954,12 @@ var runMcp = async (configuration) => {
     title: "List Cohall devices",
     description: "List devices, their availability, local providers, capabilities, and allowed workspaces.",
     inputSchema: {}
-  }, async () => output(await Effect11.runPromise(client2.devices())));
+  }, async () => output(await Effect12.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()))));
+  }, async () => output(listBots(await Effect12.runPromise(client2.devices()))));
   server.registerTool("delegate", {
     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.",
@@ -6414,6 +6971,7 @@ var runMcp = async (configuration) => {
       thread_id: z.string().uuid().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."),
+      attachment_paths: z.array(z.string()).max(2).optional().describe("Local files to send with the task, up to 2 files of 256 KiB each. Coding providers only."),
       wait: z.boolean().default(true),
       timeout_seconds: z.number().int().min(5).max(86400).default(900)
     }
@@ -6425,30 +6983,65 @@ var runMcp = async (configuration) => {
     thread_id,
     parent_task_id,
     workspace,
+    attachment_paths,
     wait,
     timeout_seconds
   }) => {
-    const task = await Effect11.runPromise(createDelegation(client2, configuration, {
+    const attachments2 = await readInputAttachments(attachment_paths ?? []);
+    const task = await Effect12.runPromise(createDelegation(client2, configuration, {
       prompt,
       ...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 }
+      ...workspace === undefined ? {} : { workspace },
+      ...attachments2.length === 0 ? {} : { attachments: attachments2 }
     }));
-    return output(taskResult(wait ? await Effect11.runPromise(waitForTask(client2, task, timeout_seconds)) : task));
+    const completed = wait ? await Effect12.runPromise(waitForTask(client2, task, timeout_seconds)) : task;
+    return output(wait ? await acknowledgedTaskResult(client2, completed) : taskResult(completed));
   });
+  server.registerTool("completion_inbox", {
+    title: "List completed work",
+    description: "List up to 20 unacknowledged completed tasks sent by this client. hasMore signals additional entries. Use task_status for a full result, then acknowledge the task after handling it.",
+    inputSchema: {}
+  }, async () => output(await Effect12.runPromise(client2.inbox())));
+  server.registerTool("acknowledge_completion", {
+    title: "Acknowledge completed work",
+    description: "Remove a handled task from this client's completion inbox.",
+    inputSchema: { task_id: z.string().uuid() }
+  }, async ({ task_id }) => output(await Effect12.runPromise(client2.acknowledgeCompletion(TaskId.make(task_id)))));
   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 Effect11.runPromise(client2.getTask(TaskId.make(task_id))))));
+  }, async ({ task_id }) => output(taskResult(await Effect12.runPromise(client2.getTask(TaskId.make(task_id))))));
+  server.registerTool("list_task_attachments", {
+    title: "List task files",
+    description: "List input and output files retained with a delegated task.",
+    inputSchema: { task_id: z.string().uuid() }
+  }, async ({ task_id }) => output(await Effect12.runPromise(client2.listAttachments(TaskId.make(task_id)))));
+  server.registerTool("download_task_attachment", {
+    title: "Download a task file",
+    description: "Save one task file to a new local path. Existing files are never overwritten.",
+    inputSchema: {
+      task_id: z.string().uuid(),
+      name: z.string(),
+      output_path: z.string(),
+      direction: z.enum(["input", "output"]).optional()
+    }
+  }, async ({ task_id, name, output_path, direction }) => {
+    const safeName = Schema13.decodeUnknownSync(AttachmentName)(name);
+    const safeDirection = direction === undefined ? undefined : Schema13.decodeUnknownSync(AttachmentDirection)(direction);
+    const data = await Effect12.runPromise(client2.readAttachment(TaskId.make(task_id), safeName, safeDirection));
+    await writeFile8(output_path, data, { flag: "wx", mode: 384 });
+    return output({ task_id, name: safeName, output_path, bytes: data.length });
+  });
   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 Effect11.runPromise(client2.traceTask(TaskId.make(task_id)))));
+  }, async ({ task_id }) => output(await Effect12.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.",
@@ -6457,19 +7050,19 @@ var runMcp = async (configuration) => {
       timeout_seconds: z.number().int().min(5).max(86400).default(900)
     }
   }, async ({ task_id, timeout_seconds }) => {
-    const task = await Effect11.runPromise(client2.getTask(TaskId.make(task_id)));
-    return output(taskResult(await Effect11.runPromise(waitForTask(client2, task, timeout_seconds))));
+    const task = await Effect12.runPromise(client2.getTask(TaskId.make(task_id)));
+    return output(taskResult(await Effect12.runPromise(waitForTask(client2, task, timeout_seconds))));
   });
   server.registerTool("cancel_task", {
     title: "Cancel delegated work",
     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 Effect11.runPromise(client2.cancelTask(TaskId.make(task_id))))));
+  }, async ({ task_id }) => output(taskResult(await Effect12.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 Effect11.runPromise(threadContext(client2, ThreadId.make(thread_id)))));
+  }, async ({ thread_id }) => output(await Effect12.runPromise(threadContext(client2, ThreadId.make(thread_id)))));
   await server.connect(new StdioServerTransport);
 };
 
@@ -6498,12 +7091,12 @@ var main = async () => {
     return;
   }
   if (command === "device") {
-    const configuration = await Effect15.runPromise(loadDeviceConfiguration);
-    await Effect15.runPromise(runDaemon(configuration));
+    const configuration = await Effect16.runPromise(loadDeviceConfiguration);
+    await Effect16.runPromise(runDaemon(configuration));
     return;
   }
   if (command === "mcp") {
-    const configuration = await Effect15.runPromise(loadClientConfiguration);
+    const configuration = await Effect16.runPromise(loadClientConfiguration);
     await runMcp(configuration);
     return;
   }
@@ -6514,4 +7107,4 @@ await main().catch((cause) => {
   process.exitCode = 1;
 });
 
-//# debugId=B9C02E5590F539C264756E2164756E21
+//# debugId=9F11AB66C376A14E64756E2164756E21