@akshar5/cohall 0.7.0 → 0.9.0

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## [0.9.0](https://github.com/AksharP5/cohall/compare/v0.8.0...v0.9.0) (2026-09-30)
+
+
+### Features
+
+* **devices:** show queue depth and oldest wait ([#95](https://github.com/AksharP5/cohall/issues/95)) ([f9a6f94](https://github.com/AksharP5/cohall/commit/f9a6f943b61a22840ce4be73f79a965fb5a193c3))
+* **tasks:** report bounded worker progress ([#97](https://github.com/AksharP5/cohall/issues/97)) ([ced7062](https://github.com/AksharP5/cohall/commit/ced706251800fb4daa47f5ef9fe8e2672c9d445a))
+
+
+### Bug Fixes
+
+* **doctor:** report rejected client credentials ([#92](https://github.com/AksharP5/cohall/issues/92)) ([8744622](https://github.com/AksharP5/cohall/commit/87446220f84753d18b29d670dc5636c3036ac502))
+* **mcp:** warn when upgrades need a connection restart ([#99](https://github.com/AksharP5/cohall/issues/99)) ([106e4a6](https://github.com/AksharP5/cohall/commit/106e4a645d0cf0814195ca8387cc45b2cb630c86))
+
+## [0.8.0](https://github.com/AksharP5/cohall/compare/v0.7.0...v0.8.0) (2026-09-27)
+
+
+### Features
+
+* **doctor:** verify MCP server exposes tools ([#89](https://github.com/AksharP5/cohall/issues/89)) ([bee2abc](https://github.com/AksharP5/cohall/commit/bee2abcf64bd5715a88c560d07b8515455cd90d1))
+
 ## [0.7.0](https://github.com/AksharP5/cohall/compare/v0.6.2...v0.7.0) (2026-09-26)
 
 

package/README.md

@@ -8,6 +8,18 @@ One npm package provides a durable self-hosted relay, outbound-only device
 workers, a CLI, an installable agent skill, an optional MCP server, and local
 Codex, Claude Code, and OpenCode adapters, plus an experimental Grok Bot adapter.
 
+https://github.com/user-attachments/assets/7db8ebb2-da77-484f-bba9-703a44f95f4a
+
+<details>
+<summary>Video music credits</summary>
+
+Music: ["Hang Low" by Rewob (feat. DustyZonda)](https://ccmixter.org/files/rewob/69753),
+including ["Hang Low a capella - Ashes and Dreams - main vox" by DustyZonda (feat. Liv Mircea)](https://ccmixter.org/files/DustyZonda/60053).
+Both licensed under [CC BY 3.0](https://creativecommons.org/licenses/by/3.0/).
+Trimmed and mixed for this video.
+
+</details>
+
 ## How it works
 
 ```text
@@ -197,6 +209,10 @@ npx -y @akshar5/cohall wait <task-id> --timeout 1800
 npx -y @akshar5/cohall trace <task-id> --follow
 ```
 
+Task status and traces include the worker's latest progress note when it reports
+one. Workers can publish a brief milestone with `cohall progress --message
+"Running tests"`; the task ID is inherited during delegated work.
+
 Completed tasks also appear in the sending client's inbox. This covers queued
 work and tasks that finish after a wait times out:
 
@@ -351,6 +367,9 @@ cohall usage
 ```
 
 `doctor --all` reports connectivity, providers, workspaces, and version drift.
+It and `cohall devices` include each device's current queue count and the
+creation time of its oldest queued task. Assigned, running, cancelling, and
+terminal tasks do not count as queued. Queue fields are absent with older relays.
 `usage` reports retained Cohall task activity by device, status, and provider;
 provider token counts and billing are not available to the relay.
 

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.7.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$/, {
+var version = "0.9.0", maxSocketPayloadBytes, maxAttachmentBytes, maxTaskAttachments = 2, maxProgressNoteBytes = 1024, 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);
@@ -56,7 +56,7 @@ var version = "0.7.0", maxSocketPayloadBytes, maxAttachmentBytes, maxTaskAttachm
     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, 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) => ({
+}, TaskProgressInput, TaskProgress, 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, decodeTaskProgressInput, decodeExchangePairingInput, decodeCreateTaskInput = (input) => Schema.decodeUnknownEffect(CreateTaskInput)(input).pipe(Effect.map((task) => ({
   ...task,
   provider: task.provider ?? (task.botId === undefined ? "codex" : "grok-bot")
 }))), decodeCreateUpgradeOperationsInput, decodeDevice, decodeSocketEvent;
@@ -149,7 +149,11 @@ var init_src = __esm(() => {
     workspaces: boundedArray(Workspace, 64),
     version: bounded(32),
     lastSeenAt: Timestamp,
-    connectedAt: Schema.optionalKey(Timestamp)
+    connectedAt: Schema.optionalKey(Timestamp),
+    queue: Schema.optionalKey(Schema.Struct({
+      queued: count,
+      oldestQueuedAt: Schema.optionalKey(Timestamp)
+    }))
   });
   Thread = Schema.Struct({
     id: ThreadId,
@@ -180,6 +184,10 @@ var init_src = __esm(() => {
     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"));
+  TaskProgressInput = Schema.Struct({
+    note: bounded(maxProgressNoteBytes).check(Schema.makeFilter((value) => value.trim().length > 0 && new TextEncoder().encode(value).byteLength <= maxProgressNoteBytes ? undefined : `Expected a nonblank progress note of at most ${maxProgressNoteBytes} UTF-8 bytes`)).pipe(Schema.brand("TaskProgressNote"))
+  });
+  TaskProgress = Schema.Struct({ ...TaskProgressInput.fields, at: Timestamp });
   Task = Schema.Struct({
     id: TaskId,
     threadId: ThreadId,
@@ -196,6 +204,7 @@ var init_src = __esm(() => {
     result: Schema.optionalKey(optionalText(131072)),
     inputAttachmentNames: Schema.optionalKey(boundedArray(AttachmentName, maxTaskAttachments)),
     error: Schema.optionalKey(optionalText(16384)),
+    progress: Schema.optionalKey(TaskProgress),
     createdAt: Timestamp,
     updatedAt: Timestamp,
     startedAt: Schema.optionalKey(Timestamp),
@@ -284,7 +293,8 @@ var init_src = __esm(() => {
     completedAt: Schema.optionalKey(Timestamp),
     events: boundedArray(TaskTraceEvent, 100),
     truncated: Schema.Boolean,
-    error: Schema.optionalKey(optionalText(16384))
+    error: Schema.optionalKey(optionalText(16384)),
+    progress: Schema.optionalKey(TaskProgress)
   }).check(Schema.makeFilter(validBotTarget));
   ThreadContext = Schema.Struct({
     thread: Thread,
@@ -345,6 +355,7 @@ var init_src = __esm(() => {
     "cancelled"
   ]);
   decodeCreatePairingInput = Schema.decodeUnknownEffect(CreatePairingInput);
+  decodeTaskProgressInput = Schema.decodeUnknownEffect(TaskProgressInput);
   decodeExchangePairingInput = Schema.decodeUnknownEffect(ExchangePairingInput);
   decodeCreateUpgradeOperationsInput = Schema.decodeUnknownEffect(CreateUpgradeOperationsInput);
   decodeDevice = Schema.decodeUnknownEffect(Device);
@@ -596,13 +607,14 @@ var exports_store = {};
 __export(exports_store, {
   layerFromDatabase: () => layerFromDatabase,
   layer: () => layer2,
+  TaskProgressError: () => TaskProgressError,
   Service: () => Service2,
   RelayStore: () => exports_store,
   PersistenceError: () => PersistenceError
 });
 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({
+var PersistenceError, TaskProgressError, Service2, operationError = (operation) => (cause) => new PersistenceError({
   operation,
   message: cause instanceof Error ? cause.message : String(cause)
 }), decode2 = (operation, schema, value) => Schema15.decodeUnknownEffect(schema)(value).pipe(Effect14.mapError(operationError(operation))), threadFromRow = (row) => decode2("RelayStore.decodeThread", Thread, {
@@ -633,7 +645,13 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
   workspaces: JSON.parse(row.workspaces_json),
   version: row.version,
   lastSeenAt: row.last_seen_at,
-  ...row.connected_at === null ? {} : { connectedAt: row.connected_at }
+  ...row.connected_at === null ? {} : { connectedAt: row.connected_at },
+  ...row.queued_tasks === undefined ? {} : {
+    queue: {
+      queued: row.queued_tasks,
+      ...row.oldest_queued_at === undefined || row.oldest_queued_at === null ? {} : { oldestQueuedAt: row.oldest_queued_at }
+    }
+  }
 }), 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")
@@ -655,6 +673,7 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
   ...row.result === null ? {} : { result: row.result },
   ...attachments2.length === 0 ? {} : { inputAttachmentNames: attachments2.map((item) => item.name) },
   ...row.error === null ? {} : { error: row.error },
+  ...row.progress_note === null ? {} : { progress: { note: row.progress_note, at: row.progress_at } },
   ...row.started_at === null ? {} : { startedAt: row.started_at },
   ...row.completed_at === null ? {} : { completedAt: row.completed_at }
 }))), inboxItemFromRow = (row) => decode2("RelayStore.decodeInboxItem", TaskInboxItem, {
@@ -902,12 +921,18 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
       ...task.workspace === undefined ? {} : { workspace: task.workspace },
       ...task.startedAt === undefined ? {} : { startedAt: task.startedAt },
       ...task.completedAt === undefined ? {} : { completedAt: task.completedAt },
-      ...task.error === undefined ? {} : { error: task.error }
+      ...task.error === undefined ? {} : { error: task.error },
+      ...task.progress === undefined ? {} : { progress: task.progress }
     });
   });
   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(),
+      try: () => db.query(`SELECT devices.*, COUNT(tasks.id) AS queued_tasks,
+                    MIN(tasks.created_at) AS oldest_queued_at
+             FROM devices LEFT JOIN tasks
+               ON tasks.target_device_id = devices.id AND tasks.status = 'queued'
+             WHERE devices.forgotten_at IS NULL
+             GROUP BY devices.id ORDER BY devices.name COLLATE NOCASE, devices.id`).all(),
       catch: operationError("RelayStore.listDevices")
     });
     return yield* Effect14.forEach(rows, deviceFromRow);
@@ -1127,7 +1152,8 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
         const timestamp = now();
         const interrupted = db.query("SELECT id FROM tasks WHERE status IN ('assigned', 'running')").all();
         db.query("UPDATE devices SET status = 'offline'").run();
-        db.query("UPDATE tasks SET status = 'queued', updated_at = ? WHERE status IN ('assigned', 'running')").run(timestamp);
+        db.query(`UPDATE tasks SET status = 'queued', updated_at = ?, progress_note = NULL, progress_at = NULL
+             WHERE status IN ('assigned', 'running')`).run(timestamp);
         db.query("UPDATE device_operations SET status = 'queued', updated_at = ? WHERE status IN ('assigned', 'running')").run(timestamp);
         for (const task of interrupted) {
           recordTaskTraceEvent(TaskId.make(task.id), "requeued", "Relay restarted before the task completed", timestamp);
@@ -1371,6 +1397,28 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
     }
     return task;
   });
+  const reportTaskProgress = Effect14.fn("RelayStore.reportTaskProgress")(function* (taskId, deviceId, note) {
+    const task = yield* getTask(taskId);
+    if (task.targetDeviceId !== deviceId) {
+      return yield* new TaskProgressError({
+        status: 403,
+        message: "Only the target device can report progress"
+      });
+    }
+    const progress = TaskProgress.make({ note, at: now() });
+    const changed = yield* Effect14.try({
+      try: () => db.query(`UPDATE tasks SET progress_note = ?, progress_at = ?, updated_at = ?
+         WHERE id = ? AND target_device_id = ? AND status = 'running'`).run(note, progress.at, progress.at, taskId, deviceId).changes,
+      catch: operationError("RelayStore.reportTaskProgress")
+    });
+    if (changed !== 1) {
+      return yield* new TaskProgressError({
+        status: 409,
+        message: "Task must be running to report progress"
+      });
+    }
+    return progress;
+  });
   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)) {
@@ -1380,7 +1428,7 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
     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 = ?
+             completed_at = ?, updated_at = ?, progress_note = NULL, progress_at = NULL WHERE id = ?
              AND status NOT IN ('completed', 'failed', 'cancelled')`).run(status, result ?? null, error ?? null, current.provider === "grok-bot" ? null : providerSessionId ?? current.providerSessionId ?? null, timestamp, timestamp, taskId);
         if (updated.changes !== 1) {
           return;
@@ -1449,7 +1497,7 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
       try: () => db.transaction(() => {
         const interrupted = db.query(`SELECT id FROM tasks WHERE target_device_id = ?
                AND status IN ('assigned', 'running')`).all(deviceId);
-        db.query(`UPDATE tasks SET status = 'queued', updated_at = ?
+        db.query(`UPDATE tasks SET status = 'queued', updated_at = ?, progress_note = NULL, progress_at = NULL
              WHERE target_device_id = ? AND status IN ('assigned', 'running')`).run(timestamp, deviceId);
         for (const task of interrupted) {
           recordTaskTraceEvent(TaskId.make(task.id), "requeued", "Target device disconnected before task completion", timestamp);
@@ -1579,6 +1627,7 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
     markDeviceOffline: (deviceId) => updateDeviceStatus(deviceId, "offline"),
     createDelegation: createDelegation2,
     getTask,
+    reportTaskProgress,
     listAttachments,
     readAttachment,
     inboxFor,
@@ -1650,7 +1699,7 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
           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,
-          dispatched_at TEXT
+          dispatched_at TEXT, progress_note TEXT, progress_at TEXT
         );
         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);
@@ -1701,6 +1750,12 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
       db.exec("ALTER TABLE devices ADD COLUMN bots_json TEXT");
     }
     const taskColumns = db.query("PRAGMA table_info(tasks)").all();
+    if (!taskColumns.some((column) => column.name === "progress_note")) {
+      db.exec("ALTER TABLE tasks ADD COLUMN progress_note TEXT");
+    }
+    if (!taskColumns.some((column) => column.name === "progress_at")) {
+      db.exec("ALTER TABLE tasks ADD COLUMN progress_at TEXT");
+    }
     if (!taskColumns.some((column) => column.name === "bot_id")) {
       db.exec("ALTER TABLE tasks ADD COLUMN bot_id TEXT");
     }
@@ -1731,6 +1786,8 @@ var init_store = __esm(() => {
   init_store();
   PersistenceError = class PersistenceError extends Schema15.TaggedErrorClass()("RelayStore.PersistenceError", { operation: Schema15.String, message: Schema15.String }) {
   };
+  TaskProgressError = class TaskProgressError extends Schema15.TaggedErrorClass()("RelayStore.TaskProgressError", { status: Schema15.Literals([403, 409]), message: Schema15.String }) {
+  };
   Service2 = class Service2 extends Context2.Service()("@cohall/RelayStore") {
   };
 });
@@ -2184,7 +2241,7 @@ Content-Length: 0\r
   };
   const api = async (request, url) => {
     if (url.pathname === "/api/health" && request.method === "GET") {
-      return json({ ok: true, version, taskAttachments: true });
+      return json({ ok: true, version, taskAttachments: true, taskProgress: true });
     }
     if (url.pathname === "/api/auth/pair" && request.method === "POST") {
       return run2(Effect15.gen(function* () {
@@ -2194,7 +2251,8 @@ Content-Length: 0\r
       })).then((value) => json(value, 201)).catch(() => json({ error: "Pairing credential is invalid, expired, or already used" }, 401));
     }
     const attachmentRoute = request.method === "GET" && /^\/api\/tasks\/[^/]+\/attachments(?:\/[^/]+)?$/.test(url.pathname);
-    const principal = await principalFor(request, attachmentRoute);
+    const progressRoute = request.method === "POST" && /^\/api\/tasks\/[^/]+\/progress$/.test(url.pathname);
+    const principal = await principalFor(request, attachmentRoute || progressRoute);
     if (principal === undefined) {
       return json({ error: "Unauthorized" }, 401);
     }
@@ -2313,6 +2371,20 @@ Content-Length: 0\r
       if (request.method === "GET" && trace?.[1] !== undefined) {
         return json(yield* store.traceTask(yield* pathId(TaskId, trace[1])));
       }
+      const progress = url.pathname.match(/^\/api\/tasks\/([^/]+)\/progress$/);
+      if (request.method === "POST" && progress?.[1] !== undefined) {
+        const id = yield* pathId(TaskId, progress[1]);
+        const input = yield* body(request, decodeTaskProgressInput);
+        const task2 = yield* store.getTask(id);
+        const deviceId = principal === "owner" ? task2.targetDeviceId : principal.deviceId;
+        if (deviceId === undefined) {
+          return yield* new RequestError({
+            status: 403,
+            message: "Only the target device can report progress"
+          });
+        }
+        return json(yield* store.reportTaskProgress(id, deviceId, input.note));
+      }
       const cancel2 = url.pathname.match(/^\/api\/tasks\/([^/]+)\/cancel$/);
       if (request.method === "POST" && cancel2?.[1] !== undefined) {
         const id = yield* pathId(TaskId, cancel2[1]);
@@ -2327,7 +2399,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(Effect15.mapError((cause) => cause instanceof RequestError ? cause : new RequestError({
+    }).pipe(Effect15.mapError((cause) => cause instanceof RequestError ? cause : cause._tag === "RelayStore.TaskProgressError" ? new RequestError({ status: cause.status, message: cause.message }) : 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
     })));
@@ -2598,6 +2670,16 @@ var make = (options) => {
       });
     }),
     getTask: (taskId) => request("RelayClient.getTask", `/api/tasks/${encodeURIComponent(taskId)}`, Task),
+    reportTaskProgress: (taskId, input) => Effect2.gen(function* () {
+      const health = yield* request("RelayClient.progressSupport", "/api/health", Schema2.Struct({ taskProgress: Schema2.optionalKey(Schema2.Boolean) }));
+      if (health.taskProgress !== true) {
+        return yield* new RelayRequestError({
+          operation: "RelayClient.reportTaskProgress",
+          message: "Upgrade the Cohall relay before reporting task progress"
+        });
+      }
+      return yield* request("RelayClient.reportTaskProgress", `/api/tasks/${encodeURIComponent(taskId)}/progress`, TaskProgress, { method: "POST", body: JSON.stringify(input) });
+    }),
     listAttachments: (taskId) => request("RelayClient.listAttachments", `/api/tasks/${encodeURIComponent(taskId)}/attachments`, Schema2.Array(TaskAttachment)),
     readAttachment: (taskId, name, direction) => Effect2.tryPromise({
       try: async (signal) => {
@@ -3665,7 +3747,8 @@ var TaskResult = Schema5.Struct({
   bot_id: Schema5.optionalKey(BotId),
   result: Schema5.optionalKey(Schema5.String),
   error: Schema5.optionalKey(Schema5.String),
-  inbox_warning: Schema5.optionalKey(Schema5.String)
+  inbox_warning: Schema5.optionalKey(Schema5.String),
+  progress: Schema5.optionalKey(TaskProgress)
 });
 var matchingDevices = (devices, target) => {
   const value = target.replace(/^@/, "");
@@ -3717,7 +3800,8 @@ var taskResult = (task) => TaskResult.make({
   target_device_id: task.targetDeviceId,
   ...task.botId === undefined ? {} : { bot_id: task.botId },
   ...task.result === undefined ? {} : { result: task.result },
-  ...task.error === undefined ? {} : { error: task.error }
+  ...task.error === undefined ? {} : { error: task.error },
+  ...task.progress === undefined ? {} : { progress: task.progress }
 });
 var acknowledgedTaskResult = async (client, task) => {
   const result = taskResult(task);
@@ -3803,7 +3887,7 @@ var followTaskTrace = Effect5.fn("Cohall.followTaskTrace")(function* (client, ta
   let revision;
   const poll = client.traceTask(taskId).pipe(Effect5.tap((trace) => {
     const latest = trace.events.at(-1);
-    const nextRevision = `${trace.status}:${latest?.kind ?? "none"}:${latest?.at ?? "none"}`;
+    const nextRevision = `${trace.status}:${latest?.kind ?? "none"}:${latest?.at ?? "none"}:${trace.progress?.at ?? ""}:${trace.progress?.note ?? ""}`;
     if (nextRevision === revision) {
       return Effect5.succeed(undefined);
     }
@@ -3850,6 +3934,7 @@ var allDeviceHealth = (devices, localVersion) => {
       providers: device.providers,
       workspaces: device.workspaces.map((workspace) => workspace.path),
       last_seen_at: device.lastSeenAt,
+      ...device.queue === undefined ? {} : { queue: device.queue },
       warnings
     };
   });
@@ -5530,6 +5615,39 @@ var collectOutputs = async (directory) => {
   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",
@@ -5585,6 +5703,7 @@ Usage:
                    [--grok-gateway path]
   cohall config
   cohall devices
+  cohall progress [task-id] --message <note>
   cohall bots
   cohall send [@device-or-bot] [prompt] [delegate options]
   cohall delegate [prompt] [--target @device-or-bot] [--provider provider]
@@ -6132,16 +6251,29 @@ 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 Effect10.runPromise(exports_src.make({ baseUrl: relayUrl, token: clientToken }).devices()).then((devices) => devices.find((device) => device.id === deviceId)).catch(() => {
-      return;
-    });
+    const clientAuthentication = clientToken === undefined ? { status: "not configured" } : response?.ok !== true ? { status: "not checked" } : await Effect10.runPromise(exports_src.make({ baseUrl: relayUrl, token: clientToken }).devices().pipe(Effect10.match({
+      onSuccess: (devices) => ({ status: "ok", devices }),
+      onFailure: (error) => {
+        const httpStatus = error instanceof RelayRequestError ? error.status : undefined;
+        const reason = httpStatus === 401 || httpStatus === 403 ? "Client credential was rejected by the relay" : "Client relay check failed";
+        return {
+          status: "error",
+          ...httpStatus === undefined ? {} : { http_status: httpStatus },
+          error: `${reason}: ${error.message}`
+        };
+      }
+    })));
+    const currentDevice = clientAuthentication.status === "ok" ? clientAuthentication.devices.find((device) => device.id === deviceId) : undefined;
     const versionWarning = deviceVersionWarning(version, currentDevice?.version);
     const warnings = [
       ...response?.ok === true ? [] : ["Relay is unreachable"],
       ...versionWarning === undefined ? [] : [versionWarning],
-      ...hasDeviceCredential && response?.ok === true && currentDevice?.status !== "online" && currentDevice?.status !== "busy" ? [
+      ...mcp.status === "error" ? [`MCP check failed: ${mcp.error}`] : [],
+      ...clientAuthentication.status === "error" ? [clientAuthentication.error] : [],
+      ...hasDeviceCredential && response?.ok === true && clientAuthentication.status !== "error" && currentDevice?.status !== "online" && currentDevice?.status !== "busy" ? [
         clientToken === undefined ? "Device status cannot be checked without a client credential" : "Device daemon is not connected or is not registered with the relay"
       ] : [],
       ...selectedProviders?.flatMap((provider) => provider === "grok-bot" ? grokBots === undefined ? [
@@ -6154,6 +6286,8 @@ var runCli = async (command, raw) => {
       relay_url: relayUrl,
       config_path: configurationPath(),
       client_credential: process.env.COHALL_CLIENT_TOKEN !== undefined || storedCredentials.clientToken !== undefined,
+      client_authentication: clientAuthentication.status === "ok" ? { status: "ok" } : clientAuthentication,
+      mcp,
       device_credential: hasDeviceCredential,
       workspaces: configuration2?.workspaces ?? [],
       providers: providerExecutables,
@@ -6220,6 +6354,18 @@ var runCli = async (command, raw) => {
     return;
   }
   const { configuration, relay } = await client();
+  if (command === "progress") {
+    allowOptions(arguments_, ["message"]);
+    const rawId = arguments_.positionals.length === 0 ? configuration.mcpTaskId : identifier(arguments_, "task id");
+    if (rawId === undefined)
+      throw new Error("Task id is required outside delegated work");
+    const note = option(arguments_, "message");
+    if (note === undefined)
+      throw new Error("--message is required");
+    const input = Schema11.decodeUnknownSync(TaskProgressInput)({ note });
+    print(await Effect10.runPromise(relay.reportTaskProgress(Schema11.decodeUnknownSync(TaskId)(rawId), input)));
+    return;
+  }
   if (command === "devices") {
     allowOptions(arguments_, []);
     noPositionals(arguments_, command);
@@ -6491,6 +6637,7 @@ ${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.",
+    "For long tasks, optionally report a brief milestone with `cohall progress --message 'Running tests'`. Do not include logs or secrets in progress notes.",
     ...files === undefined ? [] : [
       ...files.inputNames.length === 0 ? [] : [
         `Input directory: ${files.input}`,
@@ -6905,15 +7052,81 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 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) }]
+
+// apps/device/src/mcp-build-notice.ts
+import { execFile as execFile3 } from "node:child_process";
+import { stat as stat6 } from "node:fs/promises";
+import { promisify } from "node:util";
+var execute2 = promisify(execFile3);
+var fingerprint = async (entrypoint) => stat6(entrypoint, { bigint: true }).then((file) => `${file.dev}:${file.ino}:${file.size}:${file.mtimeNs}:${file.ctimeNs}`).catch(() => {
+  return;
 });
+var createMcpBuildNotice = async (entrypoint, runningVersion, {
+  checkIntervalMs = 60000,
+  probeTimeoutMs = 2000,
+  now: now2 = Date.now
+} = {}) => {
+  let previous = entrypoint === undefined ? undefined : await fingerprint(entrypoint);
+  let nextCheckAt = 0;
+  const reported = new Set;
+  return async (result) => {
+    if (entrypoint === undefined || now2() < nextCheckAt)
+      return result;
+    nextCheckAt = now2() + checkIntervalMs;
+    const current = await fingerprint(entrypoint);
+    if (current === undefined || current === previous)
+      return result;
+    const installedVersion2 = await execute2(process.execPath, [entrypoint, "--version"], {
+      timeout: probeTimeoutMs,
+      killSignal: "SIGKILL",
+      maxBuffer: 4096,
+      windowsHide: true
+    }).then(({ stdout }) => stdout.trim()).catch(() => {
+      return;
+    });
+    if (installedVersion2 === undefined || !/^\d+\.\d+\.\d+(?:-[\da-zA-Z.-]+)?(?:\+[\da-zA-Z.-]+)?$/.test(installedVersion2)) {
+      return result;
+    }
+    previous = current;
+    if (installedVersion2 === runningVersion || reported.has(installedVersion2))
+      return result;
+    reported.add(installedVersion2);
+    return {
+      ...result,
+      content: [
+        ...result.content,
+        {
+          type: "text",
+          text: `Cohall MCP is still running ${runningVersion}; its executable is now ${installedVersion2}. Restart the Cohall MCP connection in your agent host to load it.`
+        }
+      ]
+    };
+  };
+};
+
+// apps/device/src/mcp.ts
 var runMcp = async (configuration) => {
+  const buildNotice = await createMcpBuildNotice(process.argv[1], version);
+  const output = (value) => buildNotice({ content: [{ type: "text", text: JSON.stringify(value, null, 2) }] });
   const client2 = exports_src.make({
     baseUrl: configuration.relayUrl,
     token: configuration.token
   });
   const server = new McpServer({ name: "cohall", version });
+  server.registerTool("task_progress", {
+    title: "Report task progress",
+    description: `Replace the latest progress note for a running task on this device. Use brief milestones, up to ${maxProgressNoteBytes} UTF-8 bytes. Inherits the delegated task ID when omitted.`,
+    inputSchema: {
+      task_id: z.string().uuid().optional(),
+      note: z.string().min(1).max(maxProgressNoteBytes)
+    }
+  }, async ({ task_id, note }) => {
+    const id = task_id ?? configuration.mcpTaskId;
+    if (id === undefined)
+      throw new Error("Task id is required outside delegated work");
+    const input = Schema13.decodeUnknownSync(TaskProgressInput)({ note });
+    return output(await Effect12.runPromise(client2.reportTaskProgress(Schema13.decodeUnknownSync(TaskId)(id), input)));
+  });
   server.registerTool("list_devices", {
     title: "List Cohall devices",
     description: "List devices, their availability, local providers, capabilities, and allowed workspaces.",
@@ -7003,7 +7216,7 @@ var runMcp = async (configuration) => {
   });
   server.registerTool("task_trace", {
     title: "Trace a delegated task",
-    description: "Read the redacted relay and device lifecycle for troubleshooting a Cohall task.",
+    description: "Read the relay and device lifecycle and latest worker progress note for troubleshooting a Cohall task.",
     inputSchema: { task_id: z.string().uuid() }
   }, async ({ task_id }) => output(await Effect12.runPromise(client2.traceTask(TaskId.make(task_id)))));
   server.registerTool("wait_task", {
@@ -7071,4 +7284,4 @@ await main().catch((cause) => {
   process.exitCode = 1;
 });
 
-//# debugId=C3F729038365DD7F64756E2164756E21
+//# debugId=48BD90839B9C2B1564756E2164756E21